Namespaces
	ARIA_F

	ASN1

	Camellia_F

	Cert_Extension

	Charset

	CryptoBox

	CT

	FPE

	HTTP

	KeyPair

	OCSP

	OIDS

	OS

	PEM_Code

	PK_Ops

	PKCS11

	PKCS8

	PKIX

	Roughtime

	SHA1_F

	SHA1_SSE2_F

	Sodium

	stlCompatibilityDetails

	TLS

	X509

Classes
class	Adler32

class	AEAD_Mode

class	AES_128

class	AES_192

class	AES_256

class	Algorithm_Not_Found

class	AlgorithmIdentifier

class	Allocator_Initializer

class	AlternativeName

class	ANSI_X919_MAC

class	ANSI_X923_Padding

class	Argon2

class	Argon2_Family

class	ARIA_128

class	ARIA_192

class	ARIA_256

class	ASN1_Formatter

class	ASN1_Object

class	ASN1_Pretty_Printer

class	ASN1_String

class	ASN1_Time

class	Atomic

class	Attribute

class	AutoSeeded_RNG

class	Barrier

class	Base64_Decoder

class	Base64_Encoder

class	Bcrypt_PBKDF

class	Bcrypt_PBKDF_Family

class	BER_Bad_Tag

class	BER_Decoder

class	BER_Decoding_Error

class	BER_Object

class	BigInt

class	BitBucket

class	BLAKE2b

class	Blinded_Point_Multiply

class	Blinder

class	Block_Cipher_Fixed_Params

class	BlockCipher

class	BlockCipherModePaddingMethod

class	Blowfish

struct	BotanErrorCategory
	An error category for errors from Botan (other than TLS alerts) More...

class	Buffered_Computation

class	Buffered_Filter

class	Bzip2_Compression

class	Bzip2_Decompression

class	calendar_point

class	Camellia_128

class	Camellia_192

class	Camellia_256

class	Cascade_Cipher

class	CAST_128

class	CAST_256

class	CBC_Decryption

class	CBC_Encryption

class	CBC_MAC

class	CBC_Mode

class	CCM_Decryption

class	CCM_Encryption

class	CCM_Mode

class	CECPQ1_key

class	Certificate_Extension

class	Certificate_Store

class	Certificate_Store_In_Memory

class	Certificate_Store_In_SQL

class	Certificate_Store_In_SQLite

class	Certificate_Store_MacOS

class	Certificate_Store_Windows

class	CFB_Decryption

class	CFB_Encryption

class	CFB_Mode

class	ChaCha

class	ChaCha20Poly1305_Decryption

class	ChaCha20Poly1305_Encryption

class	ChaCha20Poly1305_Mode

class	ChaCha_RNG

class	Chain

class	Cipher_Mode

class	Cipher_Mode_Filter

class	CMAC

class	Comb4P

class	CommonCrypto_Error

struct	CommonCryptor_Opts

class	Compression_Algorithm

class	Compression_Alloc_Info

class	Compression_Error

class	Compression_Stream

class	CPUID

class	CRC24

class	CRC32

class	Credentials_Manager

class	CRL_Entry

class	CTR_BE

class	CTS_Decryption

class	CTS_Encryption

class	Curve25519_PrivateKey

class	Curve25519_PublicKey

class	CurveGFp

class	CurveGFp_Repr

class	Data_Store

class	DataSink

class	DataSink_Stream

class	DataSource

class	DataSource_Memory

class	DataSource_Stream

class	Decoding_Error

class	Decompression_Algorithm

class	Deflate_Compression

class	Deflate_Decompression

class	DER_Encoder

class	DES

class	DESX

class	Device_EntropySource

class	DH_PrivateKey

class	DH_PublicKey

class	DL_Group

class	DL_Scheme_PrivateKey

class	DL_Scheme_PublicKey

class	DLIES_Decryptor

class	DLIES_Encryptor

class	donna128

class	DSA_PrivateKey

class	DSA_PublicKey

class	Dynamically_Loaded_Library

class	EAX_Decryption

class	EAX_Encryption

class	EAX_Mode

class	EC_Group

class	EC_PrivateKey

class	EC_PublicKey

class	ECDH_PrivateKey

class	ECDH_PublicKey

class	ECDSA_PrivateKey

class	ECDSA_PublicKey

class	ECGDSA_PrivateKey

class	ECGDSA_PublicKey

class	ECIES_Decryptor

class	ECIES_Encryptor

class	ECIES_KA_Operation

class	ECIES_KA_Params

class	ECIES_System_Params

class	ECKCDSA_PrivateKey

class	ECKCDSA_PublicKey

class	Ed25519_PrivateKey

class	Ed25519_PublicKey

class	ElGamal_PrivateKey

class	ElGamal_PublicKey

class	EME

class	EME_PKCS1v15

class	EME_Raw

class	EMSA

class	EMSA1

class	EMSA_PKCS1v15

class	EMSA_PKCS1v15_Raw

class	EMSA_Raw

class	EMSA_X931

class	Encoding_Error

class	Encrypted_PSK_Database

class	Encrypted_PSK_Database_SQL

class	Entropy_Source

class	Entropy_Sources

class	ESP_Padding

class	Exception

class	Extensions

class	Fanout_Filter

class	FE_25519

class	File_Descriptor_Source

class	Filter

class	Fixed_Base_Power_Mod

class	Fixed_Exponent_Power_Mod

class	Flatfile_Certificate_Store

class	Fork

class	FPE_FE1

class	GCM_Decryption

class	GCM_Encryption

class	GCM_Mode

struct	ge_p3

class	GeneralName
	X.509 GeneralName Type. More...

class	GeneralSubtree
	A single Name Constraint. More...

class	Getentropy

class	GF2m_Field

class	GHASH

class	GMAC

class	GOST_28147_89

class	GOST_28147_89_Params

class	GOST_3410_PrivateKey

class	GOST_3410_PublicKey

class	GOST_34_11

class	Gzip_Compression

class	Gzip_Decompression

class	Hardware_RNG

class	HashFunction

class	Hex_Decoder

class	Hex_Encoder

class	HKDF

class	HKDF_Expand

class	HKDF_Extract

class	HMAC

class	HMAC_DRBG

class	HOTP

class	IDEA

class	Illegal_Point

class	Illegal_Transformation

class	Integer_Overflow_Detected

class	Intel_Rdseed

class	Internal_Error

class	Invalid_Algorithm_Name

class	Invalid_Argument

class	Invalid_Authentication_Tag

class	Invalid_IV_Length

class	Invalid_Key_Length

class	Invalid_OID

class	Invalid_State

class	ISO_9796_DS2

class	ISO_9796_DS3

class	KASUMI

class	KDF

class	KDF1

class	KDF1_18033

class	KDF2

class	Keccak_1600

class	Key_Length_Specification

class	Key_Not_Set

class	Keyed_Filter

class	LibraryInitializer

class	Lion

class	lock_guard

class	Lookup_Error

class	LZMA_Compression

class	LZMA_Decompression

class	McEliece_PrivateKey

class	McEliece_PublicKey

class	MD4

class	MD5

class	MDx_HashFunction

class	Memory_Pool

class	MessageAuthenticationCode

class	MISTY1

class	mlock_allocator

class	Modular_Reducer

class	Montgomery_Int

class	Montgomery_Params

class	NameConstraints
	Name Constraints. More...

class	newhope_poly

class	No_Filesystem_Access

class	No_Provider_Found

class	Noekeon

class	noop_mutex

class	Not_Implemented

class	Null_Padding

class	Null_RNG

class	OAEP

class	OCB_Decryption

class	OCB_Encryption

class	OCB_Mode

class	OctetString

class	OFB

class	OID

class	OneAndZeros_Padding

class	OpenPGP_S2K

class	OpenSSL_Error

class	Output_Buffers

class	Parallel

class	PasswordHash

class	PasswordHashFamily

class	Path_Validation_Restrictions

class	Path_Validation_Result

class	PBKDF

class	PBKDF2

class	PBKDF2_Family

class	Pipe

class	PK_Decryptor

class	PK_Decryptor_EME

class	PK_Encryptor

class	PK_Encryptor_EME

class	PK_KEM_Decryptor

class	PK_KEM_Encryptor

class	PK_Key_Agreement

class	PK_Key_Agreement_Key

class	PK_Signer

class	PK_Verifier

class	PKCS10_Request

class	PKCS5_PBKDF1

class	PKCS5_PBKDF2

class	PKCS7_Padding

class	PKCS8_Exception

class	PointGFp

class	PointGFp_Base_Point_Precompute

class	PointGFp_Multi_Point_Precompute

class	PointGFp_Var_Point_Precompute

class	Policy_Violation

class	Poly1305

class	polyn_gf2m

class	Power_Mod

class	Private_Key

class	PRNG_Unseeded

class	Processor_RNG

class	ProcWalking_EntropySource

class	Provider_Not_Found

class	PSK_Database

class	PSSR

class	PSSR_Raw

class	Public_Key

class	RandomNumberGenerator

class	RC4

class	RDRAND_RNG

class	RFC4880_S2K

class	RFC4880_S2K_Family

class	RFC6979_Nonce_Generator

class	RIPEMD_160

class	RSA_PrivateKey

class	RSA_PublicKey

class	RTSS_Share

class	RWLock

class	Salsa20

class	SCAN_Name

class	Scrypt

class	Scrypt_Family

class	secure_allocator

class	SecureQueue

class	SEED

class	Self_Test_Failure

class	Semaphore

class	Serpent

class	SHA_160

class	SHA_224

class	SHA_256

class	SHA_3

class	SHA_384

class	SHA_3_224

class	SHA_3_256

class	SHA_3_384

class	SHA_3_512

class	SHA_512

class	SHA_512_256

class	SHACAL2

class	SHAKE_128

class	SHAKE_128_Cipher

class	SHAKE_256

class	SIMD_4x32

class	SIMD_8x32

class	SipHash

class	SIV_Decryption

class	SIV_Encryption

class	SIV_Mode

class	Skein_512

class	SM2_PrivateKey

class	SM2_PublicKey

class	SM3

class	SM4

class	SP800_108_Counter

class	SP800_108_Feedback

class	SP800_108_Pipeline

class	SP800_56A_Hash

class	SP800_56A_HMAC

class	SP800_56C

class	SQL_Database

class	Sqlite3_Database

class	SRP6_Server_Session

class	Stateful_RNG

class	Stream_Compression

class	Stream_Decompression

class	Stream_IO_Error

class	StreamCipher

class	Streebog

class	Streebog_256

class	Streebog_512

class	SymmetricAlgorithm

class	System_Certificate_Store

class	System_Error

class	System_RNG

class	Thread_Pool

class	Threefish_512

class	Tiger

class	Timer

class	TLS_12_PRF

class	TLS_PRF

class	TOTP

class	TPM_Context

class	TPM_Error

class	TPM_PrivateKey

class	TPM_RNG

class	TripleDES

class	Tweakable_Block_Cipher

class	Twofish

class	Unsupported_Argument

struct	URI

class	UUID

class	Whirlpool

class	Win32_EntropySource

class	X509_CA

class	X509_Cert_Options

class	X509_Certificate

class	X509_CRL

class	X509_DN

class	X509_Object

class	X942_PRF

class	XMSS_Address

class	XMSS_Common_Ops

class	XMSS_Hash

class	XMSS_Index_Registry

class	XMSS_Key_Pair

class	XMSS_Parameters

class	XMSS_PrivateKey

class	XMSS_PublicKey

class	XMSS_Signature

class	XMSS_Signature_Operation

class	XMSS_Tools

class	XMSS_Verification_Operation

class	XMSS_WOTS_Addressed_PrivateKey

class	XMSS_WOTS_Addressed_PublicKey

class	XMSS_WOTS_Parameters

class	XMSS_WOTS_PrivateKey

class	XMSS_WOTS_PublicKey

class	XTEA

class	XTS_Decryption

class	XTS_Encryption

class	XTS_Mode

class	Zlib_Compression

class	Zlib_Decompression

class	Zlib_Style_Stream

Typedefs
typedef __vector unsigned int	Altivec32x4

typedef __vector unsigned long long	Altivec64x2

typedef __vector unsigned char	Altivec8x16

typedef BLAKE2b	Blake2b

using	byte = std::uint8_t

typedef std::vector< std::set< Certificate_Status_Code > >	CertificatePathStatusCodes

typedef EC_Group	EC_Domain_Params

typedef FE_25519	fe

typedef uint16_t	gf2m

using	InitializationVector = OctetString

typedef Invalid_Authentication_Tag	Integrity_Failure

template<typename T >
using	lock_guard_type = lock_guard< T >

typedef MessageAuthenticationCode	MAC

typedef noop_mutex	mutex_type

typedef PK_Key_Agreement_Key	PK_KA_Key

typedef Private_Key	PKCS8_PrivateKey

typedef newhope_poly	poly

typedef noop_mutex	recursive_mutex_type

typedef RandomNumberGenerator	RNG

typedef PBKDF	S2K

using	s32bit = std::int32_t

template<typename T >
using	secure_deque = std::deque< T, secure_allocator< T > >

template<typename T >
using	secure_vector = std::vector< T, secure_allocator< T > >

template<typename T >
using	SecureVector = secure_vector< T >

typedef SHA_160	SHA_1

typedef SM2_PrivateKey	SM2_Encryption_PrivateKey

typedef SM2_PublicKey	SM2_Encryption_PublicKey

typedef SM2_PrivateKey	SM2_Signature_PrivateKey

typedef SM2_PublicKey	SM2_Signature_PublicKey

using	SymmetricKey = OctetString

typedef Cipher_Mode_Filter	Transform_Filter

typedef Transform_Filter	Transformation_Filter

using	u16bit = std::uint16_t

using	u32bit = std::uint32_t

using	u64bit = std::uint64_t

typedef std::vector< secure_vector< uint8_t > >	wots_keysig_t

typedef Curve25519_PrivateKey	X25519_PrivateKey

typedef Curve25519_PublicKey	X25519_PublicKey

typedef Public_Key	X509_PublicKey

typedef ASN1_Time	X509_Time

Enumerations
enum	{ SM3_BLOCK_BYTES = 64, SM3_DIGEST_BYTES = 32 }

enum	ASN1_Tag : uint32_t { UNIVERSAL = 0x00, APPLICATION = 0x40, CONTEXT_SPECIFIC = 0x80, CONSTRUCTED = 0x20, PRIVATE = CONSTRUCTED \| CONTEXT_SPECIFIC, EOC = 0x00, BOOLEAN = 0x01, INTEGER = 0x02, BIT_STRING = 0x03, OCTET_STRING = 0x04, NULL_TAG = 0x05, OBJECT_ID = 0x06, ENUMERATED = 0x0A, SEQUENCE = 0x10, SET = 0x11, UTF8_STRING = 0x0C, NUMERIC_STRING = 0x12, PRINTABLE_STRING = 0x13, T61_STRING = 0x14, IA5_STRING = 0x16, VISIBLE_STRING = 0x1A, UNIVERSAL_STRING = 0x1C, BMP_STRING = 0x1E, UTC_TIME = 0x17, GENERALIZED_TIME = 0x18, UTC_OR_GENERALIZED_TIME = 0x19, NO_OBJECT = 0xFF00, DIRECTORY_STRING = 0xFF01 }

enum	Certificate_Status_Code { Certificate_Status_Code::OK = 0, Certificate_Status_Code::VERIFIED = 0, Certificate_Status_Code::OCSP_RESPONSE_GOOD = 1, Certificate_Status_Code::OCSP_SIGNATURE_OK = 2, Certificate_Status_Code::VALID_CRL_CHECKED = 3, Certificate_Status_Code::OCSP_NO_HTTP = 4, Certificate_Status_Code::FIRST_WARNING_STATUS = 500, Certificate_Status_Code::CERT_SERIAL_NEGATIVE = 500, Certificate_Status_Code::DN_TOO_LONG = 501, Certificate_Status_Code::OCSP_NO_REVOCATION_URL = 502, Certificate_Status_Code::OCSP_SERVER_NOT_AVAILABLE = 503, Certificate_Status_Code::OSCP_NO_REVOCATION_URL = 502, Certificate_Status_Code::OSCP_SERVER_NOT_AVAILABLE = 503, Certificate_Status_Code::FIRST_ERROR_STATUS = 1000, Certificate_Status_Code::SIGNATURE_METHOD_TOO_WEAK = 1000, Certificate_Status_Code::UNTRUSTED_HASH = 1001, Certificate_Status_Code::NO_REVOCATION_DATA = 1002, Certificate_Status_Code::NO_MATCHING_CRLDP = 1003, Certificate_Status_Code::CERT_NOT_YET_VALID = 2000, Certificate_Status_Code::CERT_HAS_EXPIRED = 2001, Certificate_Status_Code::OCSP_NOT_YET_VALID = 2002, Certificate_Status_Code::OCSP_HAS_EXPIRED = 2003, Certificate_Status_Code::CRL_NOT_YET_VALID = 2004, Certificate_Status_Code::CRL_HAS_EXPIRED = 2005, Certificate_Status_Code::OCSP_IS_TOO_OLD = 2006, Certificate_Status_Code::CERT_ISSUER_NOT_FOUND = 3000, Certificate_Status_Code::CANNOT_ESTABLISH_TRUST = 3001, Certificate_Status_Code::CERT_CHAIN_LOOP = 3002, Certificate_Status_Code::CHAIN_LACKS_TRUST_ROOT = 3003, Certificate_Status_Code::CHAIN_NAME_MISMATCH = 3004, Certificate_Status_Code::POLICY_ERROR = 4000, Certificate_Status_Code::INVALID_USAGE = 4001, Certificate_Status_Code::CERT_CHAIN_TOO_LONG = 4002, Certificate_Status_Code::CA_CERT_NOT_FOR_CERT_ISSUER = 4003, Certificate_Status_Code::NAME_CONSTRAINT_ERROR = 4004, Certificate_Status_Code::CA_CERT_NOT_FOR_CRL_ISSUER = 4005, Certificate_Status_Code::OCSP_CERT_NOT_LISTED = 4006, Certificate_Status_Code::OCSP_BAD_STATUS = 4007, Certificate_Status_Code::CERT_NAME_NOMATCH = 4008, Certificate_Status_Code::UNKNOWN_CRITICAL_EXTENSION = 4009, Certificate_Status_Code::DUPLICATE_CERT_EXTENSION = 4010, Certificate_Status_Code::OCSP_SIGNATURE_ERROR = 4501, Certificate_Status_Code::OCSP_ISSUER_NOT_FOUND = 4502, Certificate_Status_Code::OCSP_RESPONSE_MISSING_KEYUSAGE = 4503, Certificate_Status_Code::OCSP_RESPONSE_INVALID = 4504, Certificate_Status_Code::EXT_IN_V1_V2_CERT = 4505, Certificate_Status_Code::DUPLICATE_CERT_POLICY = 4506, Certificate_Status_Code::V2_IDENTIFIERS_IN_V1_CERT = 4507, Certificate_Status_Code::CERT_IS_REVOKED = 5000, Certificate_Status_Code::CRL_BAD_SIGNATURE = 5001, Certificate_Status_Code::SIGNATURE_ERROR = 5002, Certificate_Status_Code::CERT_PUBKEY_INVALID = 5003, Certificate_Status_Code::SIGNATURE_ALGO_UNKNOWN = 5004, Certificate_Status_Code::SIGNATURE_ALGO_BAD_PARAMS = 5005 }

enum	Character_Set { LOCAL_CHARSET, UCS2_CHARSET, UTF8_CHARSET, LATIN1_CHARSET }

enum	Cipher_Dir : int { ENCRYPTION, DECRYPTION }

enum	CRL_Code : uint32_t { UNSPECIFIED = 0, KEY_COMPROMISE = 1, CA_COMPROMISE = 2, AFFILIATION_CHANGED = 3, SUPERSEDED = 4, CESSATION_OF_OPERATION = 5, CERTIFICATE_HOLD = 6, REMOVE_FROM_CRL = 8, PRIVLEDGE_WITHDRAWN = 9, PRIVILEGE_WITHDRAWN = 9, AA_COMPROMISE = 10, DELETE_CRL_ENTRY = 0xFF00, OCSP_GOOD = 0xFF01, OCSP_UNKNOWN = 0xFF02 }

enum	Decoder_Checking { NONE, IGNORE_WS, FULL_CHECK }

enum	DL_Group_Source { DL_Group_Source::Builtin, DL_Group_Source::RandomlyGenerated, DL_Group_Source::ExternalSource }

enum	EC_Group_Encoding { EC_DOMPAR_ENC_EXPLICIT = 0, EC_DOMPAR_ENC_IMPLICITCA = 1, EC_DOMPAR_ENC_OID = 2 }

enum	EC_Group_Source { EC_Group_Source::Builtin, EC_Group_Source::ExternalSource }

enum	ECIES_Flags : uint32_t { ECIES_Flags::NONE = 0, ECIES_Flags::SINGLE_HASH_MODE = 1, ECIES_Flags::COFACTOR_MODE = 2, ECIES_Flags::OLD_COFACTOR_MODE = 4, ECIES_Flags::CHECK_MODE = 8 }

enum	ErrorType { ErrorType::Unknown = 1, ErrorType::SystemError, ErrorType::NotImplemented, ErrorType::OutOfMemory, ErrorType::InternalError, ErrorType::IoError, ErrorType::InvalidObjectState = 100, ErrorType::KeyNotSet, ErrorType::InvalidArgument, ErrorType::InvalidKeyLength, ErrorType::InvalidNonceLength, ErrorType::LookupError, ErrorType::EncodingFailure, ErrorType::DecodingFailure, ErrorType::TLSError, ErrorType::HttpError, ErrorType::InvalidTag, ErrorType::RoughtimeError, ErrorType::OpenSSLError = 200, ErrorType::CommonCryptoError, ErrorType::Pkcs11Error, ErrorType::TPMError, ErrorType::DatabaseError, ErrorType::ZlibError = 300, ErrorType::Bzip2Error, ErrorType::LzmaError }

enum	Key_Constraints { NO_CONSTRAINTS = 0, DIGITAL_SIGNATURE = 1 << 15, NON_REPUDIATION = 1 << 14, KEY_ENCIPHERMENT = 1 << 13, DATA_ENCIPHERMENT = 1 << 12, KEY_AGREEMENT = 1 << 11, KEY_CERT_SIGN = 1 << 10, CRL_SIGN = 1 << 9, ENCIPHER_ONLY = 1 << 8, DECIPHER_ONLY = 1 << 7 }

enum	Newhope_Mode { Newhope_Mode::SHA3, Newhope_Mode::BoringSSL }

enum	Newhope_Params { NEWHOPE_SENDABYTES = 1824, NEWHOPE_SENDBBYTES = 2048, NEWHOPE_OFFER_BYTES = 1824, NEWHOPE_ACCEPT_BYTES = 2048, NEWHOPE_SHARED_KEY_BYTES = 32, NEWHOPE_SEED_BYTES = 32, NEWHOPE_POLY_BYTES = 1792, CECPQ1_OFFER_BYTES = NEWHOPE_OFFER_BYTES + 32, CECPQ1_ACCEPT_BYTES = NEWHOPE_ACCEPT_BYTES + 32, CECPQ1_SHARED_KEY_BYTES = NEWHOPE_SHARED_KEY_BYTES + 32 }

enum	Signature_Format { IEEE_1363, DER_SEQUENCE }

enum	TPM_Storage_Type { TPM_Storage_Type::User, TPM_Storage_Type::System }

enum	Usage_Type { Usage_Type::UNSPECIFIED, Usage_Type::TLS_SERVER_AUTH, Usage_Type::TLS_CLIENT_AUTH, Usage_Type::CERTIFICATE_AUTHORITY, Usage_Type::OCSP_RESPONDER, Usage_Type::ENCRYPTION }

enum	X509_Encoding { RAW_BER, PEM }

Functions
BigInt	abs (const BigInt &n)

BOTAN_MALLOC_FN void *	allocate_memory (size_t elems, size_t elem_size)

size_t	almost_montgomery_inverse (BigInt &result, const BigInt &a, const BigInt &p)

void	aont_package (RandomNumberGenerator &rng, BlockCipher *cipher, const uint8_t input[], size_t input_len, uint8_t output[])

void	aont_unpackage (BlockCipher *cipher, const uint8_t input[], size_t input_len, uint8_t output[])

void	argon2 (uint8_t output[], size_t output_len, const char *password, size_t password_len, const uint8_t salt[], size_t salt_len, const uint8_t key[], size_t key_len, const uint8_t ad[], size_t ad_len, uint8_t mode, size_t threads, size_t M, size_t t)

bool	argon2_check_pwhash (const char *password, size_t password_len, const std::string &hash)

std::string	argon2_generate_pwhash (const char *password, size_t password_len, RandomNumberGenerator &rng, size_t p, size_t M, size_t t, uint8_t y=2, size_t salt_len=16, size_t output_len=32)

std::string	asn1_class_to_string (ASN1_Tag type)

std::string	asn1_tag_to_string (ASN1_Tag type)

void	assertion_failure (const char expr_str, const char assertion_made, const char func, const char file, int line)

size_t	base32_decode (uint8_t out[], const char in[], size_t input_length, size_t &input_consumed, bool final_inputs, bool ignore_ws)

size_t	base32_decode (uint8_t output[], const char input[], size_t input_length, bool ignore_ws)

size_t	base32_decode (uint8_t output[], const std::string &input, bool ignore_ws)

secure_vector< uint8_t >	base32_decode (const char input[], size_t input_length, bool ignore_ws)

secure_vector< uint8_t >	base32_decode (const std::string &input, bool ignore_ws)

template<typename Alloc >
std::string	base32_encode (const std::vector< uint8_t, Alloc > &input)

size_t	base32_encode (char out[], const uint8_t in[], size_t input_length, size_t &input_consumed, bool final_inputs)

std::string	base32_encode (const uint8_t input[], size_t input_length)

std::vector< uint8_t >	base58_check_decode (const std::string &s)

std::vector< uint8_t >	base58_check_decode (const char input[], size_t input_length)

template<typename Alloc >
std::string	base58_check_encode (const std::vector< uint8_t, Alloc > &vec)

std::string	base58_check_encode (const uint8_t input[], size_t input_length)

std::vector< uint8_t >	base58_decode (const std::string &s)

std::vector< uint8_t >	base58_decode (const char input[], size_t input_length)

template<typename Alloc >
std::string	base58_encode (const std::vector< uint8_t, Alloc > &vec)

std::string	base58_encode (const uint8_t input[], size_t input_length)

size_t	base64_decode (uint8_t out[], const char in[], size_t input_length, size_t &input_consumed, bool final_inputs, bool ignore_ws)

size_t	base64_decode (uint8_t output[], const char input[], size_t input_length, bool ignore_ws)

size_t	base64_decode (uint8_t output[], const std::string &input, bool ignore_ws)

secure_vector< uint8_t >	base64_decode (const char input[], size_t input_length, bool ignore_ws)

secure_vector< uint8_t >	base64_decode (const std::string &input, bool ignore_ws)

size_t	base64_decode_max_output (size_t input_length)

template<typename Alloc >
std::string	base64_encode (const std::vector< uint8_t, Alloc > &input)

size_t	base64_encode (char out[], const uint8_t in[], size_t input_length, size_t &input_consumed, bool final_inputs)

std::string	base64_encode (const uint8_t input[], size_t input_length)

size_t	base64_encode_max_output (size_t input_length)

template<typename Base >
size_t	base_decode (Base &&base, uint8_t output[], const char input[], size_t input_length, size_t &input_consumed, bool final_inputs, bool ignore_ws=true)

template<typename Base >
size_t	base_decode_full (Base &&base, uint8_t output[], const char input[], size_t input_length, bool ignore_ws)

template<typename Vector , typename Base >
Vector	base_decode_to_vec (Base &&base, const char input[], size_t input_length, bool ignore_ws)

template<class Base >
size_t	base_encode (Base &&base, char output[], const uint8_t input[], size_t input_length, size_t &input_consumed, bool final_inputs)

template<typename Base >
std::string	base_encode_to_string (Base &&base, const uint8_t input[], size_t input_length)

void	bcrypt_pbkdf (uint8_t output[], size_t output_len, const char *pass, size_t pass_len, const uint8_t salt[], size_t salt_len, size_t rounds)

void	bigint_add2 (word x[], size_t x_size, const word y[], size_t y_size)

word	bigint_add2_nc (word x[], size_t x_size, const word y[], size_t y_size)

void	bigint_add3 (word z[], const word x[], size_t x_size, const word y[], size_t y_size)

word	bigint_add3_nc (word z[], const word x[], size_t x_size, const word y[], size_t y_size)

int32_t	bigint_cmp (const word x[], size_t x_size, const word y[], size_t y_size)

void	bigint_cnd_abs (word cnd, word x[], size_t size)

word	bigint_cnd_add (word cnd, word x[], word x_size, const word y[], size_t y_size)

word	bigint_cnd_add (word cnd, word x[], const word y[], size_t size)

void	bigint_cnd_add_or_sub (CT::Mask< word > mask, word x[], const word y[], size_t size)

word	bigint_cnd_addsub (CT::Mask< word > mask, word x[], const word y[], const word z[], size_t size)

word	bigint_cnd_sub (word cnd, word x[], size_t x_size, const word y[], size_t y_size)

word	bigint_cnd_sub (word cnd, word x[], const word y[], size_t size)

void	bigint_cnd_swap (word cnd, word x[], word y[], size_t size)

void	bigint_comba_mul16 (word z[32], const word x[16], const word y[16])

void	bigint_comba_mul24 (word z[48], const word x[24], const word y[24])

void	bigint_comba_mul4 (word z[8], const word x[4], const word y[4])

void	bigint_comba_mul6 (word z[12], const word x[6], const word y[6])

void	bigint_comba_mul8 (word z[16], const word x[8], const word y[8])

void	bigint_comba_mul9 (word z[18], const word x[9], const word y[9])

void	bigint_comba_sqr16 (word z[32], const word x[16])

void	bigint_comba_sqr24 (word z[48], const word x[24])

void	bigint_comba_sqr4 (word z[8], const word x[4])

void	bigint_comba_sqr6 (word z[12], const word x[6])

void	bigint_comba_sqr8 (word z[16], const word x[8])

void	bigint_comba_sqr9 (word z[18], const word x[9])

CT::Mask< word >	bigint_ct_is_eq (const word x[], size_t x_size, const word y[], size_t y_size)

CT::Mask< word >	bigint_ct_is_lt (const word x[], size_t x_size, const word y[], size_t y_size, bool lt_or_equal=false)

word	bigint_divop (word n1, word n0, word d)

word BOTAN_WARN_UNUSED_RESULT	bigint_linmul2 (word x[], size_t x_size, word y)

void	bigint_linmul3 (word z[], const word x[], size_t x_size, word y)

void	bigint_mod_sub (word t[], const word s[], const word mod[], size_t mod_sw, word ws[])

template<size_t N>
void	bigint_mod_sub_n (word t[], const word s[], const word mod[], word ws[])

word	bigint_modop (word n1, word n0, word d)

void	bigint_monty_redc (word z[], const word p[], size_t p_size, word p_dash, word workspace[], size_t ws_size)

void	bigint_monty_redc_16 (word z[], const word p[], word p_dash, word ws[])

void	bigint_monty_redc_16 (word z[], const word p[16], word p_dash, word ws[])

void	bigint_monty_redc_24 (word z[], const word p[], word p_dash, word ws[])

void	bigint_monty_redc_24 (word z[], const word p[24], word p_dash, word ws[])

void	bigint_monty_redc_32 (word z[], const word p[], word p_dash, word ws[])

void	bigint_monty_redc_32 (word z[], const word p[32], word p_dash, word ws[])

void	bigint_monty_redc_4 (word z[], const word p[4], word p_dash, word ws[])

void	bigint_monty_redc_4 (word z[], const word p[], word p_dash, word ws[])

void	bigint_monty_redc_6 (word z[], const word p[], word p_dash, word ws[])

void	bigint_monty_redc_6 (word z[], const word p[6], word p_dash, word ws[])

void	bigint_monty_redc_8 (word z[], const word p[], word p_dash, word ws[])

void	bigint_monty_redc_8 (word z[], const word p[8], word p_dash, word ws[])

void	bigint_mul (word z[], size_t z_size, const word x[], size_t x_size, size_t x_sw, const word y[], size_t y_size, size_t y_sw, word workspace[], size_t ws_size)

void	bigint_shl1 (word x[], size_t x_size, size_t x_words, size_t word_shift, size_t bit_shift)

void	bigint_shl2 (word y[], const word x[], size_t x_size, size_t word_shift, size_t bit_shift)

void	bigint_shr1 (word x[], size_t x_size, size_t word_shift, size_t bit_shift)

void	bigint_shr2 (word y[], const word x[], size_t x_size, size_t word_shift, size_t bit_shift)

void	bigint_sqr (word z[], size_t z_size, const word x[], size_t x_size, size_t x_sw, word workspace[], size_t ws_size)

word	bigint_sub2 (word x[], size_t x_size, const word y[], size_t y_size)

void	bigint_sub2_rev (word x[], const word y[], size_t y_size)

word	bigint_sub3 (word z[], const word x[], size_t x_size, const word y[], size_t y_size)

CT::Mask< word >	bigint_sub_abs (word z[], const word x[], const word y[], size_t N, word ws[])

int32_t	bigint_sub_abs (word z[], const word x[], size_t x_size, const word y[], size_t y_size)

template<typename T >
T	bit_permute_step (T x, T mask, size_t shift)

size_t	bit_size_to_32bit_size (size_t bit_size)

size_t	bit_size_to_byte_size (size_t bit_size)

const BotanErrorCategory &	botan_category () noexcept

template<typename T >
void	bswap_4 (T x[4])

template<typename T , typename Alloc >
size_t	buffer_insert (std::vector< T, Alloc > &buf, size_t buf_offset, const T input[], size_t input_length)

template<typename T , typename Alloc , typename Alloc2 >
size_t	buffer_insert (std::vector< T, Alloc > &buf, size_t buf_offset, const std::vector< T, Alloc2 > &input)

calendar_point	calendar_value (const std::chrono::system_clock::time_point &time_point)

template<size_t S, int64_t MUL = 1>
void	carry (int64_t &h0, int64_t &h1)

template<size_t S>
void	carry0 (int64_t &h0, int64_t &h1)

template<size_t S>
void	carry0 (int32_t &h0, int32_t &h1)

uint64_t	carry_shift (const donna128 &a, size_t shift)

const uint8_t *	cast_char_ptr_to_uint8 (const char *s)

uint8_t *	cast_char_ptr_to_uint8 (char *s)

const char *	cast_uint8_ptr_to_char (const uint8_t *b)

char *	cast_uint8_ptr_to_char (uint8_t *b)

void	CECPQ1_accept (uint8_t shared_key[CECPQ1_SHARED_KEY_BYTES], uint8_t send[CECPQ1_ACCEPT_BYTES], const uint8_t received[CECPQ1_OFFER_BYTES], RandomNumberGenerator &rng)

void	CECPQ1_accept (uint8_t shared_key, uint8_t accept_message, const uint8_t *offer_message, RandomNumberGenerator &rng)

void	CECPQ1_finish (uint8_t shared_key, const CECPQ1_key &offer_key, const uint8_t accept_message)

void	CECPQ1_finish (uint8_t shared_key[CECPQ1_SHARED_KEY_BYTES], const CECPQ1_key &offer_key, const uint8_t received[CECPQ1_ACCEPT_BYTES])

void	CECPQ1_offer (uint8_t send[CECPQ1_OFFER_BYTES], CECPQ1_key *offer_key_output, RandomNumberGenerator &rng)

void	CECPQ1_offer (uint8_t offer_message, CECPQ1_key offer_key_output, RandomNumberGenerator &rng)

template<typename T >
uint8_t	ceil_log2 (T x)

bool	check_bcrypt (const std::string &pass, const std::string &hash)

bool	check_passhash9 (const std::string &pass, const std::string &hash)

bool	check_prime (const BigInt &n, RandomNumberGenerator &rng)

size_t	checked_add (size_t x, size_t y, const char *file, int line)

PK_Signer *	choose_sig_format (const Private_Key &key, RandomNumberGenerator &rng, const std::string &hash_fn, AlgorithmIdentifier &sig_algo)

PK_Signer *	choose_sig_format (const Private_Key &key, const std::map< std::string, std::string > &opts, RandomNumberGenerator &rng, const std::string &hash_fn, AlgorithmIdentifier &sig_algo)

size_t	clamp (size_t n, size_t lower_bound, size_t upper_bound)

std::string	clean_ws (const std::string &s)

void	clear_bytes (void *ptr, size_t bytes)

template<typename T >
void	clear_mem (T *ptr, size_t n)

uint64_t	combine_lower (const donna128 &a, size_t s1, const donna128 &b, size_t s2)

void	commoncrypto_adjust_key_size (const uint8_t key[], size_t length, const CommonCryptor_Opts &opts, secure_vector< uint8_t > &full_key)

CommonCryptor_Opts	commoncrypto_opts_from_algo (const std::string &algo)

CommonCryptor_Opts	commoncrypto_opts_from_algo_name (const std::string &algo_name)

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

template<typename T >
void	copy_mem (T out, const T in, size_t n)

template<typename T >
void	copy_out_be (uint8_t out[], size_t out_bytes, const T in[])

template<typename T >
void	copy_out_le (uint8_t out[], size_t out_bytes, const T in[])

template<typename T , typename Alloc >
void	copy_out_vec_be (uint8_t out[], size_t out_bytes, const std::vector< T, Alloc > &in)

template<typename T , typename Alloc >
void	copy_out_vec_le (uint8_t out[], size_t out_bytes, const std::vector< T, Alloc > &in)

AlternativeName	create_alt_name (const Data_Store &info)

X509_DN	create_dn (const Data_Store &info)

std::string	create_hex_fingerprint (const uint8_t bits[], size_t bits_len, const std::string &hash_name)

template<typename Alloc >
std::string	create_hex_fingerprint (const std::vector< uint8_t, Alloc > &vec, const std::string &hash_name)

std::unique_ptr< Private_Key >	create_private_key (const std::string &alg_name, RandomNumberGenerator &rng, const std::string &params, const std::string &provider)

uint8_t	ct_compare_u8 (const uint8_t x[], const uint8_t y[], size_t len)

void	ct_divide (const BigInt &x, const BigInt &y, BigInt &q_out, BigInt &r_out)

BigInt	ct_divide (const BigInt &x, const BigInt &y)

void	ct_divide_u8 (const BigInt &x, uint8_t y, BigInt &q_out, uint8_t &r_out)

BigInt	ct_inverse_mod_odd_modulus (const BigInt &n, const BigInt &mod)

template<typename T >
T	ct_is_zero (T x)

BigInt	ct_modulo (const BigInt &x, const BigInt &y)

template<typename T >
size_t	ctz (T n)

void	curve25519_basepoint (uint8_t mypublic[32], const uint8_t secret[32])

void	curve25519_donna (uint8_t mypublic[32], const uint8_t secret[32], const uint8_t basepoint[32])

void	deallocate_memory (void *p, size_t elems, size_t elem_size)

gf2m	decode_gf2m (const uint8_t *mem)

void	divide (const BigInt &x, const BigInt &y, BigInt &q, BigInt &r)

size_t	dl_exponent_size (size_t bits)

size_t	dl_work_factor (size_t bits)

template<typename E , typename... Args>
void	do_throw_error (const char file, int line, const char func, Args... args)

secure_vector< uint8_t >	EC2OSP (const PointGFp &point, uint8_t format)

size_t	ecp_work_factor (size_t bits)

void	ed25519_gen_keypair (uint8_t pk, uint8_t sk, const uint8_t seed[32])

void	ed25519_gen_keypair (uint8_t pk[32], uint8_t sk[64], const uint8_t seed[32])

void	ed25519_sign (uint8_t sig[64], const uint8_t m[], size_t mlen, const uint8_t sk[64], const uint8_t domain_sep[], size_t domain_sep_len)

bool	ed25519_verify (const uint8_t m, size_t mlen, const uint8_t sig[64], const uint8_t pk, const uint8_t domain_sep[], size_t domain_sep_len)

bool	ed25519_verify (const uint8_t msg[], size_t msg_len, const uint8_t sig[64], const uint8_t pk[32], const uint8_t domain_sep[], size_t domain_sep_len)

uint32_t	encode_gf2m (gf2m to_enc, uint8_t *mem)

std::string	erase_chars (const std::string &str, const std::set< char > &chars)

template<typename T >
uint16_t	expand_mask_16bit (T tst)

template<typename T >
T	expand_top_bit (T a)

void	fe_0 (fe &x)

void	fe_1 (fe &x)

void	fe_add (fe &x, const fe &a, const fe &b)

void	fe_copy (fe &a, const fe &b)

void	fe_frombytes (fe &x, const uint8_t *b)

void	fe_invert (fe &x, const fe &z)

int	fe_isnegative (const fe &x)

int	fe_isnonzero (const fe &x)

void	fe_mul (fe &x, const fe &a, const fe &b)

void	fe_neg (fe &x, const fe &z)

void	fe_pow22523 (fe &x, const fe &y)

void	fe_sq (fe &x, const fe &z)

void	fe_sq2 (fe &x, const fe &z)

void	fe_sq_iter (fe &x, const fe &z, size_t iter)

void	fe_sub (fe &x, const fe &a, const fe &b)

void	fe_tobytes (uint8_t *b, const fe &x)

secure_vector< gf2m >	find_roots_gf2m_decomp (const polyn_gf2m &polyn, size_t code_length)

BigInt	gcd (const BigInt &a, const BigInt &b)

void	ge_double_scalarmult_vartime (uint8_t out[32], const uint8_t a[], const ge_p3 *A, const uint8_t b[])

void	ge_double_scalarmult_vartime (uint8_t out[32], const uint8_t a, const ge_p3 A, const uint8_t *b)

int	ge_frombytes_negate_vartime (ge_p3 , const uint8_t )

void	ge_scalarmult_base (uint8_t out[32], const uint8_t in[32])

std::string	generate_bcrypt (const std::string &pass, RandomNumberGenerator &rng, uint16_t work_factor, char version)

bool	generate_dsa_primes (RandomNumberGenerator &rng, BigInt &p, BigInt &q, size_t pbits, size_t qbits, const std::vector< uint8_t > &seed_c, size_t offset)

std::vector< uint8_t >	generate_dsa_primes (RandomNumberGenerator &rng, BigInt &p, BigInt &q, size_t pbits, size_t qbits)

McEliece_PrivateKey	generate_mceliece_key (RandomNumberGenerator &rng, size_t ext_deg, size_t code_length, size_t t)

std::string	generate_passhash9 (const std::string &pass, RandomNumberGenerator &rng, uint16_t work_factor, uint8_t alg_id)

BigInt	generate_rfc6979_nonce (const BigInt &x, const BigInt &q, const BigInt &h, const std::string &hash)

BigInt	generate_rsa_prime (RandomNumberGenerator &keygen_rng, RandomNumberGenerator &prime_test_rng, size_t bits, const BigInt &coprime, size_t prob)

BigInt	generate_srp6_verifier (const std::string &identifier, const std::string &password, const std::vector< uint8_t > &salt, const std::string &group_id, const std::string &hash_id)

BigInt	generate_srp6_verifier (const std::string &identifier, const std::string &password, const std::vector< uint8_t > &salt, const DL_Group &group, const std::string &hash_id)

AEAD_Mode *	get_aead (const std::string &name, Cipher_Dir direction)

BlockCipherModePaddingMethod *	get_bc_pad (const std::string &algo_spec)

template<typename T >
constexpr uint8_t	get_byte (size_t byte_num, T input)

Keyed_Filter *	get_cipher (const std::string &algo_spec, Cipher_Dir direction)

Keyed_Filter *	get_cipher (const std::string &algo_spec, const SymmetricKey &key, Cipher_Dir direction)

Keyed_Filter *	get_cipher (const std::string &algo_spec, const SymmetricKey &key, const InitializationVector &iv, Cipher_Dir direction)

Cipher_Mode *	get_cipher_mode (const std::string &algo_spec, Cipher_Dir direction, const std::string &provider="")

EME *	get_eme (const std::string &algo_spec)

EMSA *	get_emsa (const std::string &algo_spec)

std::vector< std::string >	get_files_recursive (const std::string &dir)

KDF *	get_kdf (const std::string &algo_spec)

PBKDF *	get_pbkdf (const std::string &algo_spec, const std::string &provider="")

PBKDF *	get_s2k (const std::string &algo_spec)

const std::vector< std::string >	get_sig_paddings (const std::string algo)

gf2m	gray_to_lex (gf2m gray)

bool	has_filesystem_impl ()

std::string	hash_for_emsa (const std::string &algo_spec)

size_t	hex_decode (uint8_t output[], const char input[], size_t input_length, size_t &input_consumed, bool ignore_ws)

size_t	hex_decode (uint8_t output[], const char input[], size_t input_length, bool ignore_ws)

size_t	hex_decode (uint8_t output[], const std::string &input, bool ignore_ws)

std::vector< uint8_t >	hex_decode (const char input[], size_t input_length, bool ignore_ws)

std::vector< uint8_t >	hex_decode (const std::string &input, bool ignore_ws)

secure_vector< uint8_t >	hex_decode_locked (const char input[], size_t input_length, bool ignore_ws)

secure_vector< uint8_t >	hex_decode_locked (const std::string &input, bool ignore_ws)

void	hex_encode (char output[], const uint8_t input[], size_t input_length, bool uppercase)

std::string	hex_encode (const uint8_t input[], size_t input_length, bool uppercase)

template<typename Alloc >
std::string	hex_encode (const std::vector< uint8_t, Alloc > &input, bool uppercase=true)

template<typename T >
size_t	high_bit (T n)

secure_vector< uint8_t >	hkdf_expand_label (const std::string &hash_fn, const uint8_t secret[], size_t secret_len, const std::string &label, const uint8_t hash_val[], size_t hash_val_len, size_t length)

bool	host_wildcard_match (const std::string &issued_, const std::string &host_)

uint8_t	ieee1363_hash_id (const std::string &name)

size_t	if_work_factor (size_t bits)

void	initialize_allocator ()

BigInt	inverse_euclid (const BigInt &x, const BigInt &modulus)

BigInt	inverse_mod (const BigInt &n, const BigInt &mod)

std::string	ipv4_to_string (uint32_t ip)

bool	is_bailie_psw_probable_prime (const BigInt &n, const Modular_Reducer &mod_n)

bool	is_bailie_psw_probable_prime (const BigInt &n)

bool	is_lucas_probable_prime (const BigInt &C, const Modular_Reducer &mod_C)

bool	is_miller_rabin_probable_prime (const BigInt &n, const Modular_Reducer &mod_n, RandomNumberGenerator &rng, size_t test_iterations)

bool	is_passhash9_alg_supported (uint8_t alg_id)

BigInt	is_perfect_square (const BigInt &C)

template<typename T >
constexpr bool	is_power_of_2 (T arg)

bool	is_prime (const BigInt &n, RandomNumberGenerator &rng, size_t prob, bool is_random)

int32_t	jacobi (const BigInt &a, const BigInt &n)

std::string	key_constraints_to_string (Key_Constraints constraints)

BigInt	lcm (const BigInt &a, const BigInt &b)

gf2m	lex_to_gray (gf2m lex)

uint64_t	load_3 (const uint8_t in[3])

uint64_t	load_4 (const uint8_t *in)

template<typename T >
T	load_be (const uint8_t in[], size_t off)

template<typename T >
void	load_be (const uint8_t in[], T &x0, T &x1)

template<typename T >
void	load_be (const uint8_t in[], T &x0, T &x1, T &x2, T &x3)

template<typename T >
void	load_be (const uint8_t in[], T &x0, T &x1, T &x2, T &x3, T &x4, T &x5, T &x6, T &x7)

template<typename T >
void	load_be (T out[], const uint8_t in[], size_t count)

template<>
uint16_t	load_be< uint16_t > (const uint8_t in[], size_t off)

template<>
uint32_t	load_be< uint32_t > (const uint8_t in[], size_t off)

template<>
uint64_t	load_be< uint64_t > (const uint8_t in[], size_t off)

template<typename T >
T	load_le (const uint8_t in[], size_t off)

template<typename T >
void	load_le (const uint8_t in[], T &x0, T &x1)

template<typename T >
void	load_le (const uint8_t in[], T &x0, T &x1, T &x2, T &x3)

template<typename T >
void	load_le (const uint8_t in[], T &x0, T &x1, T &x2, T &x3, T &x4, T &x5, T &x6, T &x7)

template<typename T >
void	load_le (T out[], const uint8_t in[], size_t count)

template<>
uint16_t	load_le< uint16_t > (const uint8_t in[], size_t off)

template<>
uint32_t	load_le< uint32_t > (const uint8_t in[], size_t off)

template<>
uint64_t	load_le< uint64_t > (const uint8_t in[], size_t off)

std::unique_ptr< Private_Key >	load_private_key (const AlgorithmIdentifier &alg_id, const secure_vector< uint8_t > &key_bits)

std::unique_ptr< Public_Key >	load_public_key (const AlgorithmIdentifier &alg_id, const std::vector< uint8_t > &key_bits)

size_t	low_zero_bits (const BigInt &n)

std::unique_ptr< BlockCipher >	make_commoncrypto_block_cipher (const std::string &name)

Cipher_Mode *	make_commoncrypto_cipher_mode (const std::string &name, Cipher_Dir direction)

std::unique_ptr< HashFunction >	make_commoncrypto_hash (const std::string &name)

Compression_Algorithm *	make_compressor (const std::string &name)

Decompression_Algorithm *	make_decompressor (const std::string &name)

boost::system::error_code	make_error_code (Botan::ErrorType e)

std::unique_ptr< BlockCipher >	make_openssl_block_cipher (const std::string &name)

Cipher_Mode *	make_openssl_cipher_mode (const std::string &name, Cipher_Dir direction)

std::unique_ptr< HashFunction >	make_openssl_hash (const std::string &name)

constexpr uint16_t	make_uint16 (uint8_t i0, uint8_t i1)

constexpr uint32_t	make_uint32 (uint8_t i0, uint8_t i1, uint8_t i2, uint8_t i3)

constexpr uint64_t	make_uint64 (uint8_t i0, uint8_t i1, uint8_t i2, uint8_t i3, uint8_t i4, uint8_t i5, uint8_t i6, uint8_t i7)

template<class T , class... Args>
stlCompatibilityDetails::_Unique_if< T >::_Single_object	make_unique (Args &&... args)

template<class T >
stlCompatibilityDetails::_Unique_if< T >::_Unknown_bound	make_unique (size_t n)

template<class T , class... Args>
stlCompatibilityDetails::_Unique_if< T >::_Known_bound	make_unique (Args &&...)=delete

template<typename K , typename V >
std::set< K >	map_keys_as_set (const std::map< K, V > &kv)

template<typename T , typename Pred >
void	map_remove_if (Pred pred, T &assoc)

secure_vector< uint8_t >	mceies_decrypt (const McEliece_PrivateKey &privkey, const uint8_t ct[], size_t ct_len, const uint8_t ad[], size_t ad_len, const std::string &algo)

secure_vector< uint8_t >	mceies_encrypt (const McEliece_PublicKey &pubkey, const uint8_t pt[], size_t pt_len, const uint8_t ad[], size_t ad_len, RandomNumberGenerator &rng, const std::string &algo)

void	mceliece_decrypt (secure_vector< uint8_t > &plaintext_out, secure_vector< uint8_t > &error_mask_out, const secure_vector< uint8_t > &ciphertext, const McEliece_PrivateKey &key)

void	mceliece_decrypt (secure_vector< uint8_t > &plaintext, secure_vector< uint8_t > &error_mask, const uint8_t ciphertext[], size_t ciphertext_len, const McEliece_PrivateKey &key)

secure_vector< uint8_t >	mceliece_decrypt (secure_vector< gf2m > &error_pos, const uint8_t *ciphertext, size_t ciphertext_len, const McEliece_PrivateKey &key)

void	mceliece_encrypt (secure_vector< uint8_t > &ciphertext_out, secure_vector< uint8_t > &error_mask_out, const secure_vector< uint8_t > &plaintext, const McEliece_PublicKey &key, RandomNumberGenerator &rng)

size_t	mceliece_work_factor (size_t n, size_t t)

void	mgf1_mask (HashFunction &hash, const uint8_t in[], size_t in_len, uint8_t out[], size_t out_len)

size_t	miller_rabin_test_iterations (size_t n_bits, size_t prob, bool random)

BigInt	monty_execute (const Montgomery_Exponentation_State &precomputed_state, const BigInt &k, size_t max_k_bits)

BigInt	monty_execute_vartime (const Montgomery_Exponentation_State &precomputed_state, const BigInt &k)

word	monty_inverse (word a)

BigInt	monty_multi_exp (std::shared_ptr< const Montgomery_Params > params_p, const BigInt &x_bn, const BigInt &z1, const BigInt &y_bn, const BigInt &z2)

std::shared_ptr< const Montgomery_Exponentation_State >	monty_precompute (std::shared_ptr< const Montgomery_Params > params, const BigInt &g, size_t window_bits, bool const_time)

void	mul64x64_128 (uint64_t a, uint64_t b, uint64_t lo, uint64_t hi)

BigInt	mul_add (const BigInt &a, const BigInt &b, const BigInt &c)

BigInt	mul_sub (const BigInt &a, const BigInt &b, const BigInt &c)

PointGFp	multi_exponentiate (const PointGFp &p1, const BigInt &z1, const PointGFp &p2, const BigInt &z2)

template<typename K , typename V >
void	multimap_insert (std::multimap< K, V > &multimap, const K &key, const V &value)

void	newhope_keygen (uint8_t send[NEWHOPE_SENDABYTES], newhope_poly *sk, RandomNumberGenerator &rng, Newhope_Mode=Newhope_Mode::SHA3)

void	newhope_keygen (uint8_t send, poly sk, RandomNumberGenerator &rng, Newhope_Mode mode)

void	newhope_shareda (uint8_t sharedkey[NEWHOPE_SHARED_KEY_BYTES], const newhope_poly ska, const uint8_t received, Newhope_Mode mode=Newhope_Mode::SHA3)

void	newhope_shareda (uint8_t sharedkey[], const poly *sk, const uint8_t received[], Newhope_Mode mode)

void	newhope_sharedb (uint8_t sharedkey[NEWHOPE_SHARED_KEY_BYTES], uint8_t send[], const uint8_t *received, RandomNumberGenerator &rng, Newhope_Mode mode=Newhope_Mode::SHA3)

void	newhope_sharedb (uint8_t sharedkey, uint8_t send, const uint8_t *received, RandomNumberGenerator &rng, Newhope_Mode mode)

secure_vector< uint8_t >	nist_key_unwrap (const uint8_t input[], size_t input_len, const BlockCipher &bc)

secure_vector< uint8_t >	nist_key_unwrap_padded (const uint8_t input[], size_t input_len, const BlockCipher &bc)

std::vector< uint8_t >	nist_key_wrap (const uint8_t input[], size_t input_len, const BlockCipher &bc)

std::vector< uint8_t >	nist_key_wrap_padded (const uint8_t input[], size_t input_len, const BlockCipher &bc)

BigInt	normalized_montgomery_inverse (const BigInt &a, const BigInt &p)

secure_vector< uint8_t >	oaep_find_delim (uint8_t &valid_mask, const uint8_t input[], size_t input_len, const secure_vector< uint8_t > &Phash)

bool	operator!= (const CRL_Entry &a1, const CRL_Entry &a2)

template<typename T , typename U >
bool	operator!= (const secure_allocator< T > &, const secure_allocator< U > &)

bool	operator!= (const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)

bool	operator!= (const OctetString &s1, const OctetString &s2)

bool	operator!= (const X509_DN &dn1, const X509_DN &dn2)

bool	operator!= (const CurveGFp &lhs, const CurveGFp &rhs)

bool	operator!= (const OID &a, const OID &b)

bool	operator!= (const PointGFp &lhs, const PointGFp &rhs)

bool	operator!= (const ASN1_Time &, const ASN1_Time &)

bool	operator!= (const EC_Group &lhs, const EC_Group &rhs)

bool	operator!= (const X509_Certificate &cert1, const X509_Certificate &cert2)

bool	operator!= (const BigInt &a, const BigInt &b)

bool	operator!= (const BigInt &a, word b)

BigInt	operator% (const BigInt &n, const BigInt &mod)

word	operator% (const BigInt &n, word mod)

ECIES_Flags	operator& (ECIES_Flags a, ECIES_Flags b)

BigInt	operator* (const BigInt &x, const BigInt &y)

BigInt	operator* (const BigInt &x, word y)

donna128	operator* (const donna128 &x, uint64_t y)

donna128	operator* (uint64_t y, const donna128 &x)

PointGFp	operator* (const PointGFp &point, const BigInt &scalar)

PointGFp	operator* (const BigInt &scalar, const PointGFp &point)

BigInt	operator* (word x, const BigInt &y)

donna128	operator+ (const donna128 &x, const donna128 &y)

donna128	operator+ (const donna128 &x, uint64_t y)

OctetString	operator+ (const OctetString &k1, const OctetString &k2)

OID	operator+ (const OID &oid, uint32_t new_comp)

PointGFp	operator+ (const PointGFp &lhs, const PointGFp &rhs)

BigInt	operator+ (const BigInt &x, const BigInt &y)

BigInt	operator+ (const BigInt &x, word y)

BigInt	operator+ (word x, const BigInt &y)

template<typename T , typename Alloc , typename Alloc2 >
std::vector< T, Alloc > &	operator+= (std::vector< T, Alloc > &out, const std::vector< T, Alloc2 > &in)

template<typename T , typename Alloc >
std::vector< T, Alloc > &	operator+= (std::vector< T, Alloc > &out, T in)

template<typename T , typename Alloc , typename L >
std::vector< T, Alloc > &	operator+= (std::vector< T, Alloc > &out, const std::pair< const T *, L > &in)

template<typename T , typename Alloc , typename L >
std::vector< T, Alloc > &	operator+= (std::vector< T, Alloc > &out, const std::pair< T *, L > &in)

PointGFp	operator- (const PointGFp &lhs)

PointGFp	operator- (const PointGFp &lhs, const PointGFp &rhs)

BigInt	operator- (const BigInt &x, const BigInt &y)

BigInt	operator- (const BigInt &x, word y)

BigInt	operator/ (const BigInt &x, const BigInt &y)

BigInt	operator/ (const BigInt &x, word y)

bool	operator< (const X509_DN &dn1, const X509_DN &dn2)

bool	operator< (const OID &a, const OID &b)

bool	operator< (const ASN1_Time &, const ASN1_Time &)

bool	operator< (const BigInt &a, const BigInt &b)

bool	operator< (const BigInt &a, word b)

std::ostream &	operator<< (std::ostream &stream, const BigInt &n)

int	operator<< (int fd, Pipe &pipe)

std::ostream &	operator<< (std::ostream &out, const X509_DN &dn)

BigInt	operator<< (const BigInt &x, size_t shift)

std::ostream &	operator<< (std::ostream &os, const GeneralName &gn)

std::ostream &	operator<< (std::ostream &os, const GeneralSubtree &gs)

std::ostream &	operator<< (std::ostream &out, Pipe &pipe)

bool	operator<= (const ASN1_Time &, const ASN1_Time &)

bool	operator<= (const BigInt &a, const BigInt &b)

bool	operator<= (const BigInt &a, word b)

bool	operator== (const CRL_Entry &a1, const CRL_Entry &a2)

template<typename T , typename U >
bool	operator== (const secure_allocator< T > &, const secure_allocator< U > &)

bool	operator== (const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)

bool	operator== (const OctetString &s1, const OctetString &s2)

bool	operator== (const X509_DN &dn1, const X509_DN &dn2)

bool	operator== (const ASN1_Time &, const ASN1_Time &)

bool	operator== (const BigInt &a, const BigInt &b)

bool	operator== (const BigInt &a, word b)

bool	operator> (const ASN1_Time &, const ASN1_Time &)

bool	operator> (const BigInt &a, const BigInt &b)

bool	operator> (const BigInt &a, word b)

bool	operator>= (const ASN1_Time &, const ASN1_Time &)

bool	operator>= (const BigInt &a, const BigInt &b)

bool	operator>= (const BigInt &a, word b)

int	operator>> (int fd, Pipe &pipe)

std::istream &	operator>> (std::istream &stream, BigInt &n)

std::istream &	operator>> (std::istream &in, X509_DN &dn)

BigInt	operator>> (const BigInt &x, size_t shift)

std::istream &	operator>> (std::istream &in, Pipe &pipe)

OctetString	operator^ (const OctetString &k1, const OctetString &k2)

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

ECIES_Flags	operator\| (ECIES_Flags a, ECIES_Flags b)

donna128	operator\| (const donna128 &x, const donna128 &y)

template<typename Alloc >
PointGFp	OS2ECP (const std::vector< uint8_t, Alloc > &data, const CurveGFp &curve)

PointGFp	OS2ECP (const uint8_t data[], size_t data_len, const CurveGFp &curve)

std::pair< BigInt, BigInt >	OS2ECP (const uint8_t data[], size_t data_len, const BigInt &curve_p, const BigInt &curve_a, const BigInt &curve_b)

std::vector< std::string >	parse_algorithm_name (const std::string &namex)

std::vector< uint32_t >	parse_asn1_oid (const std::string &oid)

bool	passes_miller_rabin_test (const BigInt &n, const Modular_Reducer &mod_n, const std::shared_ptr< Montgomery_Params > &monty_n, const BigInt &a)

secure_vector< uint8_t >	pbes2_decrypt (const secure_vector< uint8_t > &key_bits, const std::string &passphrase, const std::vector< uint8_t > &params)

std::pair< AlgorithmIdentifier, std::vector< uint8_t > >	pbes2_encrypt (const secure_vector< uint8_t > &key_bits, const std::string &passphrase, std::chrono::milliseconds msec, const std::string &cipher, const std::string &digest, RandomNumberGenerator &rng)

std::pair< AlgorithmIdentifier, std::vector< uint8_t > >	pbes2_encrypt_iter (const secure_vector< uint8_t > &key_bits, const std::string &passphrase, size_t pbkdf_iter, const std::string &cipher, const std::string &digest, RandomNumberGenerator &rng)

std::pair< AlgorithmIdentifier, std::vector< uint8_t > >	pbes2_encrypt_msec (const secure_vector< uint8_t > &key_bits, const std::string &passphrase, std::chrono::milliseconds msec, size_t *out_iterations_if_nonnull, const std::string &cipher, const std::string &digest, RandomNumberGenerator &rng)

size_t	pbkdf2 (MessageAuthenticationCode &prf, uint8_t out[], size_t out_len, const std::string &password, const uint8_t salt[], size_t salt_len, size_t iterations, std::chrono::milliseconds msec)

void	pbkdf2 (MessageAuthenticationCode &prf, uint8_t out[], size_t out_len, const uint8_t salt[], size_t salt_len, size_t iterations)

std::vector< uint8_t >	pkcs_hash_id (const std::string &name)

void	poly_double_n (uint8_t buf[], size_t n)

void	poly_double_n (uint8_t out[], const uint8_t in[], size_t n)

void	poly_double_n_le (uint8_t out[], const uint8_t in[], size_t n)

bool	poly_double_supported_size (size_t n)

BigInt	power_mod (const BigInt &base, const BigInt &exp, const BigInt &mod)

template<typename T >
void	prefetch_readonly (const T *addr, size_t length)

template<typename T >
void	prefetch_readwrite (const T *addr, size_t length)

const BigInt &	prime_p192 ()

const BigInt &	prime_p224 ()

const BigInt &	prime_p256 ()

const BigInt &	prime_p384 ()

const BigInt &	prime_p521 ()

std::vector< std::string >	probe_provider_private_key (const std::string &alg_name, const std::vector< std::string > possible)

template<typename T >
std::vector< std::string >	probe_providers_of (const std::string &algo_spec, const std::vector< std::string > &possible)

bool	quick_check_prime (const BigInt &n, RandomNumberGenerator &rng)

gf2m	random_code_element (uint16_t code_length, RandomNumberGenerator &rng)

gf2m	random_gf2m (RandomNumberGenerator &rng)

BigInt	random_prime (RandomNumberGenerator &rng, size_t bits, const BigInt &coprime, size_t equiv, size_t modulo, size_t prob)

BigInt	random_safe_prime (RandomNumberGenerator &rng, size_t bits)

std::map< std::string, std::string >	read_cfg (std::istream &is)

std::map< std::string, std::string >	read_kv (const std::string &kv)

void	redc_mul (int64_t &s1, int64_t &s2, int64_t &s3, int64_t &s4, int64_t &s5, int64_t &s6, int64_t &X)

void	redc_p192 (BigInt &x, secure_vector< word > &ws)

void	redc_p224 (BigInt &x, secure_vector< word > &ws)

void	redc_p256 (BigInt &x, secure_vector< word > &ws)

void	redc_p384 (BigInt &x, secure_vector< word > &ws)

void	redc_p521 (BigInt &x, secure_vector< word > &ws)

std::string	replace_char (const std::string &str, char from_char, char to_char)

std::string	replace_chars (const std::string &str, const std::set< char > &chars, char to_char)

BigInt	ressol (const BigInt &x, const BigInt &p)

uint16_t	reverse_bytes (uint16_t val)

uint32_t	reverse_bytes (uint32_t val)

uint64_t	reverse_bytes (uint64_t val)

secure_vector< uint8_t >	rfc3394_keyunwrap (const secure_vector< uint8_t > &key, const SymmetricKey &kek)

secure_vector< uint8_t >	rfc3394_keywrap (const secure_vector< uint8_t > &key, const SymmetricKey &kek)

size_t	RFC4880_decode_count (uint8_t iter)

uint8_t	RFC4880_encode_count (size_t desired_iterations)

size_t	RFC4880_round_iterations (size_t iterations)

template<typename T >
T	rotate_left (T input, size_t rot)

template<typename T >
T	rotate_right (T input, size_t rot)

template<size_t ROT, typename T >
constexpr T	rotl (T input)

template<typename T >
T	rotl_var (T input, size_t rot)

template<size_t ROT, typename T >
constexpr T	rotr (T input)

template<typename T >
T	rotr_var (T input, size_t rot)

template<typename T >
constexpr T	round_down (T n, T align_to)

size_t	round_up (size_t n, size_t align_to)

std::string	runtime_version_check (uint32_t major, uint32_t minor, uint32_t patch)

template<typename T >
bool	same_mem (const T p1, const T p2, size_t n)

void	sc_muladd (uint8_t , const uint8_t , const uint8_t , const uint8_t )

void	sc_reduce (uint8_t *)

void	scrypt (uint8_t output[], size_t output_len, const std::string &password, const uint8_t salt[], size_t salt_len, size_t N, size_t r, size_t p)

void	scrypt (uint8_t output[], size_t output_len, const char *password, size_t password_len, const uint8_t salt[], size_t salt_len, size_t N, size_t r, size_t p)

size_t	scrypt_memory_usage (size_t N, size_t r, size_t p)

template<typename K , typename V >
V	search_map (const std::map< K, V > &mapping, const K &key, const V &null_result=V())

template<typename K , typename V , typename R >
R	search_map (const std::map< K, V > &mapping, const K &key, const R &null_result, const R &found_result)

void	secure_scrub_memory (void *ptr, size_t n)

void	set_mem (uint8_t *ptr, size_t n, uint8_t val)

const char *	short_version_cstr ()

std::string	short_version_string ()

bool	sig_algo_and_pad_ok (const std::string algo, const std::string padding)

template<typename T >
size_t	significant_bytes (T n)

std::vector< uint8_t >	sm2_compute_za (HashFunction &hash, const std::string &user_id, const EC_Group &domain, const PointGFp &pubkey)

std::vector< std::string >	split_on (const std::string &str, char delim)

std::vector< std::string >	split_on_pred (const std::string &str, std::function< bool(char)> pred)

BigInt	square (const BigInt &x)

std::pair< BigInt, SymmetricKey >	srp6_client_agree (const std::string &identifier, const std::string &password, const std::string &group_id, const std::string &hash_id, const std::vector< uint8_t > &salt, const BigInt &B, RandomNumberGenerator &rng)

std::pair< BigInt, SymmetricKey >	srp6_client_agree (const std::string &identifier, const std::string &password, const DL_Group &group, const std::string &hash_id, const std::vector< uint8_t > &salt, const BigInt &B, const size_t a_bits, RandomNumberGenerator &rng)

std::string	srp6_group_identifier (const BigInt &N, const BigInt &g)

void	store_be (uint16_t in, uint8_t out[2])

void	store_be (uint32_t in, uint8_t out[4])

void	store_be (uint64_t in, uint8_t out[8])

template<typename T >
void	store_be (uint8_t out[], T x0, T x1)

template<typename T >
void	store_be (uint8_t out[], T x0, T x1, T x2, T x3)

template<typename T >
void	store_be (uint8_t out[], T x0, T x1, T x2, T x3, T x4, T x5, T x6, T x7)

void	store_le (uint16_t in, uint8_t out[2])

void	store_le (uint32_t in, uint8_t out[4])

void	store_le (uint64_t in, uint8_t out[8])

template<typename T >
void	store_le (uint8_t out[], T x0, T x1)

template<typename T >
void	store_le (uint8_t out[], T x0, T x1, T x2, T x3)

template<typename T >
void	store_le (uint8_t out[], T x0, T x1, T x2, T x3, T x4, T x5, T x6, T x7)

std::string	string_join (const std::vector< std::string > &strs, char delim)

uint32_t	string_to_ipv4 (const std::string &str)

BigInt	sub_mul (const BigInt &a, const BigInt &b, const BigInt &c)

template<typename T >
void	swap_bits (T &x, T &y, T mask, size_t shift)

std::vector< polyn_gf2m >	syndrome_init (polyn_gf2m const &generator, std::vector< gf2m > const &support, int n)

RandomNumberGenerator &	system_rng ()

void	throw_invalid_argument (const char message, const char func, const char *file)

void	throw_invalid_state (const char expr, const char func, const char *file)

uint32_t	timespec_to_u32bit (const std::string &timespec)

std::vector< uint8_t >	to_byte_vector (const std::string &s)

std::string	to_string (ErrorType type)
	Convert an ErrorType to string. More...

const char *	to_string (Certificate_Status_Code code)

std::string	to_string (const secure_vector< uint8_t > &bytes)

uint32_t	to_u32bit (const std::string &str)

uint16_t	to_uint16 (const std::string &str)

std::string	tolower_string (const std::string &in)

template<typename T >
void	typecast_copy (uint8_t out[], T in[], size_t N)

template<typename T >
void	typecast_copy (T out[], const uint8_t in[], size_t N)

template<typename T >
void	typecast_copy (uint8_t out[], T in)

template<typename T >
void	typecast_copy (T &out, const uint8_t in[])

template<class To , class From >
To	typecast_copy (const From *src) noexcept

std::string	ucs2_to_utf8 (const uint8_t ucs2[], size_t len)

std::string	ucs4_to_utf8 (const uint8_t ucs4[], size_t len)

template<typename T >
std::vector< T >	unlock (const secure_vector< T > &in)

std::string	utf8_to_latin1 (const std::string &utf8)

template<typename T >
bool	value_exists (const std::vector< T > &vec, const T &val)

size_t	var_ctz32 (uint32_t n)

void	vartime_divide (const BigInt &x, const BigInt &y_arg, BigInt &q_out, BigInt &r_out)

void	verify_cert_constraints_valid_for_key_type (const Public_Key &pub_key, Key_Constraints constraints)

bool	verify_prime (const BigInt &n, RandomNumberGenerator &rng)

const char *	version_cstr ()

uint32_t	version_datestamp ()

uint32_t	version_major ()

uint32_t	version_minor ()

uint32_t	version_patch ()

std::string	version_string ()

void	word3_add (word w2, word w1, word *w0, word x)

void	word3_muladd (word w2, word w1, word *w0, word x, word y)

void	word3_muladd_2 (word w2, word w1, word *w0, word x, word y)

word	word8_add2 (word x[8], const word y[8], word carry)

word	word8_add3 (word z[8], const word x[8], const word y[8], word carry)

word	word8_linmul2 (word x[8], word y, word carry)

word	word8_linmul3 (word z[8], const word x[8], word y, word carry)

word	word8_madd3 (word z[8], const word x[8], word y, word carry)

word	word8_sub2 (word x[8], const word y[8], word carry)

word	word8_sub2_rev (word x[8], const word y[8], word carry)

word	word8_sub3 (word z[8], const word x[8], const word y[8], word carry)

word	word_add (word x, word y, word *carry)

word	word_madd2 (word a, word b, word *c)

word	word_madd3 (word a, word b, word c, word *d)

word	word_sub (word x, word y, word *carry)

bool	x500_name_cmp (const std::string &name1, const std::string &name2)

Path_Validation_Result	x509_path_validate (const std::vector< X509_Certificate > &end_certs, const Path_Validation_Restrictions &restrictions, const std::vector< Certificate_Store *> &trusted_roots, const std::string &hostname, Usage_Type usage, std::chrono::system_clock::time_point ref_time, std::chrono::milliseconds ocsp_timeout, const std::vector< std::shared_ptr< const OCSP::Response >> &ocsp_resp)

Path_Validation_Result	x509_path_validate (const X509_Certificate &end_cert, const Path_Validation_Restrictions &restrictions, const std::vector< Certificate_Store *> &trusted_roots, const std::string &hostname, Usage_Type usage, std::chrono::system_clock::time_point when, std::chrono::milliseconds ocsp_timeout, const std::vector< std::shared_ptr< const OCSP::Response >> &ocsp_resp)

Path_Validation_Result	x509_path_validate (const std::vector< X509_Certificate > &end_certs, const Path_Validation_Restrictions &restrictions, const Certificate_Store &store, const std::string &hostname, Usage_Type usage, std::chrono::system_clock::time_point when, std::chrono::milliseconds ocsp_timeout, const std::vector< std::shared_ptr< const OCSP::Response >> &ocsp_resp)

Path_Validation_Result	x509_path_validate (const X509_Certificate &end_cert, const Path_Validation_Restrictions &restrictions, const Certificate_Store &store, const std::string &hostname, Usage_Type usage, std::chrono::system_clock::time_point when, std::chrono::milliseconds ocsp_timeout, const std::vector< std::shared_ptr< const OCSP::Response >> &ocsp_resp)

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

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

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

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

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

template<typename T , typename Alloc >
void	zap (std::vector< T, Alloc > &vec)

template<typename T , typename Alloc >
void	zeroise (std::vector< T, Alloc > &vec)

Variables
const std::map< const std::string, std::vector< std::string > >	allowed_signature_paddings

const uint32_t	CAST_SBOX1 [256]

const uint32_t	CAST_SBOX2 [256]

const uint32_t	CAST_SBOX3 [256]

const uint32_t	CAST_SBOX4 [256]

const uint32_t	DES_SPBOX1 [256]

const uint32_t	DES_SPBOX2 [256]

const uint32_t	DES_SPBOX3 [256]

const uint32_t	DES_SPBOX4 [256]

const uint32_t	DES_SPBOX5 [256]

const uint32_t	DES_SPBOX6 [256]

const uint32_t	DES_SPBOX7 [256]

const uint32_t	DES_SPBOX8 [256]

const size_t	HEX_CODEC_BUFFER_SIZE = 256

const word	MP_WORD_MAX = ~static_cast<word>(0)

const size_t	PRIME_TABLE_SIZE = 6541

const uint16_t	PRIMES []

const uint64_t	STREEBOG_Ax [8][256]

const uint64_t	STREEBOG_C [12][8]

Detailed Description

Botan is released under the Simplified BSD License (see license.txt)

Ordinary applications should never need to include or use this header. It is exposed only for specialized applications which want to implement new versions of public key crypto without merging them as changes to the library. One actual example of such usage is an application which creates RSA signatures using a custom TPM library. Unless you're doing something like that, you don't need anything here. Instead use pubkey.h which wraps these types safely and provides a stable application-oriented API.

Botan is released under the Simplified BSD License (see license.txt)

Typedef Documentation

◆ Altivec32x4

typedef __vector unsigned int Botan::Altivec32x4

Definition at line 22 of file aes_power8.cpp.

◆ Altivec64x2

typedef __vector unsigned long long Botan::Altivec64x2

Definition at line 21 of file aes_power8.cpp.

◆ Altivec8x16

typedef __vector unsigned char Botan::Altivec8x16

Definition at line 23 of file aes_power8.cpp.

◆ Blake2b

typedef BLAKE2b Botan::Blake2b

Definition at line 56 of file blake2b.h.

◆ byte

using Botan::byte = typedef std::uint8_t

Definition at line 89 of file types.h.

◆ CertificatePathStatusCodes

typedef std::vector<std::set<Certificate_Status_Code> > Botan::CertificatePathStatusCodes

This type represents the validation status of an entire certificate path. There is one set of status codes for each certificate in the path.

Definition at line 29 of file x509path.h.

◆ EC_Domain_Params

typedef EC_Group Botan::EC_Domain_Params

Definition at line 394 of file ec_group.h.

◆ fe

typedef FE_25519 Botan::fe

Definition at line 134 of file ed25519_fe.h.

◆ gf2m

typedef uint16_t Botan::gf2m

Definition at line 22 of file gf2m_small_m.h.

◆ InitializationVector

using Botan::InitializationVector = typedef OctetString

Alternate name for octet string showing intent to use as an IV

Definition at line 146 of file symkey.h.

◆ Integrity_Failure

typedef Invalid_Authentication_Tag Botan::Integrity_Failure

For compatability with older versions

Definition at line 301 of file exceptn.h.

◆ lock_guard_type

template<typename T >

using Botan::lock_guard_type = typedef lock_guard<T>

Definition at line 54 of file mutex.h.

◆ MAC

typedef MessageAuthenticationCode Botan::MAC

Definition at line 139 of file mac.h.

◆ mutex_type

typedef noop_mutex Botan::mutex_type

Definition at line 52 of file mutex.h.

◆ PK_KA_Key

typedef PK_Key_Agreement_Key Botan::PK_KA_Key

Definition at line 311 of file pk_keys.h.

◆ PKCS8_PrivateKey

typedef Private_Key Botan::PKCS8_PrivateKey

Definition at line 313 of file pk_keys.h.

◆ poly

typedef newhope_poly Botan::poly

Definition at line 25 of file newhope.cpp.

◆ recursive_mutex_type

typedef noop_mutex Botan::recursive_mutex_type

Definition at line 53 of file mutex.h.

◆ RNG

typedef RandomNumberGenerator Botan::RNG

Convenience typedef

Definition at line 191 of file rng.h.

◆ S2K

typedef PBKDF Botan::S2K

Definition at line 224 of file pbkdf.h.

◆ s32bit

using Botan::s32bit = typedef std::int32_t

Definition at line 93 of file types.h.

◆ secure_deque

template<typename T >

using Botan::secure_deque = typedef std::deque<T, secure_allocator<T> >

Definition at line 66 of file secmem.h.

◆ secure_vector

template<typename T >

using Botan::secure_vector = typedef std::vector<T, secure_allocator<T> >

Definition at line 65 of file secmem.h.

◆ SecureVector

template<typename T >

using Botan::SecureVector = typedef secure_vector<T>

Definition at line 69 of file secmem.h.

◆ SHA_1

typedef SHA_160 Botan::SHA_1

Definition at line 71 of file sha160.h.

◆ SM2_Encryption_PrivateKey

typedef SM2_PrivateKey Botan::SM2_Encryption_PrivateKey

Definition at line 120 of file sm2.h.

◆ SM2_Encryption_PublicKey

typedef SM2_PublicKey Botan::SM2_Encryption_PublicKey

Definition at line 117 of file sm2.h.

◆ SM2_Signature_PrivateKey

typedef SM2_PrivateKey Botan::SM2_Signature_PrivateKey

Definition at line 119 of file sm2.h.

◆ SM2_Signature_PublicKey

typedef SM2_PublicKey Botan::SM2_Signature_PublicKey

Definition at line 116 of file sm2.h.

◆ SymmetricKey

using Botan::SymmetricKey = typedef OctetString

Alternate name for octet string showing intent to use as a key

Definition at line 141 of file symkey.h.

◆ Transform_Filter

typedef Cipher_Mode_Filter Botan::Transform_Filter

Definition at line 196 of file filters.h.

◆ Transformation_Filter

typedef Transform_Filter Botan::Transformation_Filter

Definition at line 197 of file filters.h.

◆ u16bit

using Botan::u16bit = typedef std::uint16_t

Definition at line 90 of file types.h.

◆ u32bit

using Botan::u32bit = typedef std::uint32_t

Definition at line 91 of file types.h.

◆ u64bit

using Botan::u64bit = typedef std::uint64_t

Definition at line 92 of file types.h.

◆ wots_keysig_t

typedef std::vector< secure_vector< uint8_t > > Botan::wots_keysig_t

Definition at line 21 of file xmss_common_ops.h.

◆ X25519_PrivateKey

typedef Curve25519_PrivateKey Botan::X25519_PrivateKey

Definition at line 103 of file curve25519.h.

◆ X25519_PublicKey

typedef Curve25519_PublicKey Botan::X25519_PublicKey

Definition at line 102 of file curve25519.h.

◆ X509_PublicKey

typedef Public_Key Botan::X509_PublicKey

Definition at line 312 of file pk_keys.h.

◆ X509_Time

typedef ASN1_Time Botan::X509_Time

Definition at line 386 of file asn1_obj.h.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
SM3_BLOCK_BYTES
SM3_DIGEST_BYTES

Definition at line 17 of file sm3.h.

      {
   SM3_BLOCK_BYTES = 64,
   SM3_DIGEST_BYTES = 32
 };

◆ ASN1_Tag

enum Botan::ASN1_Tag : uint32_t

ASN.1 Type and Class Tags This will become an enum class in a future major release

Enumerator
UNIVERSAL
APPLICATION
CONTEXT_SPECIFIC
CONSTRUCTED
PRIVATE
EOC
BOOLEAN
INTEGER
BIT_STRING
OCTET_STRING
NULL_TAG
OBJECT_ID
ENUMERATED
SEQUENCE
SET
UTF8_STRING
NUMERIC_STRING
PRINTABLE_STRING
T61_STRING
IA5_STRING
VISIBLE_STRING
UNIVERSAL_STRING
BMP_STRING
UTC_TIME
GENERALIZED_TIME
UTC_OR_GENERALIZED_TIME
NO_OBJECT
DIRECTORY_STRING

Definition at line 25 of file asn1_obj.h.

               : uint32_t {
    UNIVERSAL        = 0x00,
    APPLICATION      = 0x40,
    CONTEXT_SPECIFIC = 0x80,
 
    CONSTRUCTED      = 0x20,
 
    PRIVATE          = CONSTRUCTED | CONTEXT_SPECIFIC,
 
    EOC              = 0x00,
    BOOLEAN          = 0x01,
    INTEGER          = 0x02,
    BIT_STRING       = 0x03,
    OCTET_STRING     = 0x04,
    NULL_TAG         = 0x05,
    OBJECT_ID        = 0x06,
    ENUMERATED       = 0x0A,
    SEQUENCE         = 0x10,
    SET              = 0x11,
 
    UTF8_STRING      = 0x0C,
    NUMERIC_STRING   = 0x12,
    PRINTABLE_STRING = 0x13,
    T61_STRING       = 0x14,
    IA5_STRING       = 0x16,
    VISIBLE_STRING   = 0x1A,
    UNIVERSAL_STRING = 0x1C,
    BMP_STRING       = 0x1E,
 
    UTC_TIME                = 0x17,
    GENERALIZED_TIME        = 0x18,
    UTC_OR_GENERALIZED_TIME = 0x19,
 
    NO_OBJECT        = 0xFF00,
    DIRECTORY_STRING = 0xFF01
 };

◆ Certificate_Status_Code

enum Botan::Certificate_Status_Code

strong

Certificate validation status code

Enumerator
OK
VERIFIED
OCSP_RESPONSE_GOOD
OCSP_SIGNATURE_OK
VALID_CRL_CHECKED
OCSP_NO_HTTP
FIRST_WARNING_STATUS
CERT_SERIAL_NEGATIVE
DN_TOO_LONG
OCSP_NO_REVOCATION_URL
OCSP_SERVER_NOT_AVAILABLE
OSCP_NO_REVOCATION_URL
OSCP_SERVER_NOT_AVAILABLE
FIRST_ERROR_STATUS
SIGNATURE_METHOD_TOO_WEAK
UNTRUSTED_HASH
NO_REVOCATION_DATA
NO_MATCHING_CRLDP
CERT_NOT_YET_VALID
CERT_HAS_EXPIRED
OCSP_NOT_YET_VALID
OCSP_HAS_EXPIRED
CRL_NOT_YET_VALID
CRL_HAS_EXPIRED
OCSP_IS_TOO_OLD
CERT_ISSUER_NOT_FOUND
CANNOT_ESTABLISH_TRUST
CERT_CHAIN_LOOP
CHAIN_LACKS_TRUST_ROOT
CHAIN_NAME_MISMATCH
POLICY_ERROR
INVALID_USAGE
CERT_CHAIN_TOO_LONG
CA_CERT_NOT_FOR_CERT_ISSUER
NAME_CONSTRAINT_ERROR
CA_CERT_NOT_FOR_CRL_ISSUER
OCSP_CERT_NOT_LISTED
OCSP_BAD_STATUS
CERT_NAME_NOMATCH
UNKNOWN_CRITICAL_EXTENSION
DUPLICATE_CERT_EXTENSION
OCSP_SIGNATURE_ERROR
OCSP_ISSUER_NOT_FOUND
OCSP_RESPONSE_MISSING_KEYUSAGE
OCSP_RESPONSE_INVALID
EXT_IN_V1_V2_CERT
DUPLICATE_CERT_POLICY
V2_IDENTIFIERS_IN_V1_CERT
CERT_IS_REVOKED
CRL_BAD_SIGNATURE
SIGNATURE_ERROR
CERT_PUBKEY_INVALID
SIGNATURE_ALGO_UNKNOWN
SIGNATURE_ALGO_BAD_PARAMS

Definition at line 17 of file pkix_enums.h.

                                    {
    OK = 0,
    VERIFIED = 0,
 
    // Revocation status
    OCSP_RESPONSE_GOOD = 1,
    OCSP_SIGNATURE_OK = 2,
    VALID_CRL_CHECKED = 3,
    OCSP_NO_HTTP = 4,
 
    // Warnings
    FIRST_WARNING_STATUS = 500,
    CERT_SERIAL_NEGATIVE = 500,
    DN_TOO_LONG = 501,
    OCSP_NO_REVOCATION_URL = 502,
    OCSP_SERVER_NOT_AVAILABLE = 503,
 
    // Typo versions of above - will be removed in future major release
    OSCP_NO_REVOCATION_URL = 502,
    OSCP_SERVER_NOT_AVAILABLE = 503,
 
    // Errors
    FIRST_ERROR_STATUS = 1000,
 
    SIGNATURE_METHOD_TOO_WEAK = 1000,
    UNTRUSTED_HASH = 1001,
    NO_REVOCATION_DATA = 1002,
    NO_MATCHING_CRLDP = 1003,
 
    // Time problems
    CERT_NOT_YET_VALID = 2000,
    CERT_HAS_EXPIRED = 2001,
    OCSP_NOT_YET_VALID = 2002,
    OCSP_HAS_EXPIRED = 2003,
    CRL_NOT_YET_VALID = 2004,
    CRL_HAS_EXPIRED = 2005,
    OCSP_IS_TOO_OLD = 2006,
 
    // Chain generation problems
    CERT_ISSUER_NOT_FOUND = 3000,
    CANNOT_ESTABLISH_TRUST = 3001,
    CERT_CHAIN_LOOP = 3002,
    CHAIN_LACKS_TRUST_ROOT = 3003,
    CHAIN_NAME_MISMATCH = 3004,
 
    // Validation errors
    POLICY_ERROR = 4000,
    INVALID_USAGE = 4001,
    CERT_CHAIN_TOO_LONG = 4002,
    CA_CERT_NOT_FOR_CERT_ISSUER = 4003,
    NAME_CONSTRAINT_ERROR = 4004,
 
    // Revocation errors
    CA_CERT_NOT_FOR_CRL_ISSUER = 4005,
    OCSP_CERT_NOT_LISTED = 4006,
    OCSP_BAD_STATUS = 4007,
 
    // Other problems
    CERT_NAME_NOMATCH = 4008,
    UNKNOWN_CRITICAL_EXTENSION = 4009,
    DUPLICATE_CERT_EXTENSION = 4010,
    OCSP_SIGNATURE_ERROR = 4501,
    OCSP_ISSUER_NOT_FOUND = 4502,
    OCSP_RESPONSE_MISSING_KEYUSAGE = 4503,
    OCSP_RESPONSE_INVALID = 4504,
    EXT_IN_V1_V2_CERT = 4505,
    DUPLICATE_CERT_POLICY = 4506,
    V2_IDENTIFIERS_IN_V1_CERT = 4507,
 
    // Hard failures
    CERT_IS_REVOKED = 5000,
    CRL_BAD_SIGNATURE = 5001,
    SIGNATURE_ERROR = 5002,
    CERT_PUBKEY_INVALID = 5003,
    SIGNATURE_ALGO_UNKNOWN = 5004,
    SIGNATURE_ALGO_BAD_PARAMS = 5005
 };

◆ Character_Set

enum Botan::Character_Set

The different charsets (nominally) supported by Botan.

Enumerator
LOCAL_CHARSET
UCS2_CHARSET
UTF8_CHARSET
LATIN1_CHARSET

Definition at line 43 of file charset.h.

                    {
    LOCAL_CHARSET,
    UCS2_CHARSET,
    UTF8_CHARSET,
    LATIN1_CHARSET
 };

◆ Cipher_Dir

enum Botan::Cipher_Dir : int

The two possible directions for cipher filters, determining whether they actually perform encryption or decryption.

Enumerator
ENCRYPTION
DECRYPTION

Definition at line 23 of file cipher_mode.h.

23 : int { ENCRYPTION, DECRYPTION };

Botan::DECRYPTION

Definition: cipher_mode.h:23

Botan::ENCRYPTION

Definition: cipher_mode.h:23

◆ CRL_Code

enum Botan::CRL_Code : uint32_t

X.509v2 CRL Reason Code. This will become an enum class in a future major release

Enumerator
UNSPECIFIED
KEY_COMPROMISE
CA_COMPROMISE
AFFILIATION_CHANGED
SUPERSEDED
CESSATION_OF_OPERATION
CERTIFICATE_HOLD
REMOVE_FROM_CRL
PRIVLEDGE_WITHDRAWN
PRIVILEGE_WITHDRAWN
AA_COMPROMISE
DELETE_CRL_ENTRY
OCSP_GOOD
OCSP_UNKNOWN

Definition at line 123 of file pkix_enums.h.

               : uint32_t {
    UNSPECIFIED            = 0,
    KEY_COMPROMISE         = 1,
    CA_COMPROMISE          = 2,
    AFFILIATION_CHANGED    = 3,
    SUPERSEDED             = 4,
    CESSATION_OF_OPERATION = 5,
    CERTIFICATE_HOLD       = 6,
    REMOVE_FROM_CRL        = 8,
    PRIVLEDGE_WITHDRAWN    = 9,
    PRIVILEGE_WITHDRAWN    = 9,
    AA_COMPROMISE          = 10,
 
    DELETE_CRL_ENTRY       = 0xFF00,
    OCSP_GOOD              = 0xFF01,
    OCSP_UNKNOWN           = 0xFF02
 };

◆ Decoder_Checking

enum Botan::Decoder_Checking

The type of checking to be performed by decoders: NONE - no checks, IGNORE_WS - perform checks, but ignore whitespaces, FULL_CHECK - perform checks, also complain about white spaces.

Enumerator
NONE
IGNORE_WS
FULL_CHECK

Definition at line 171 of file filter.h.

171 { NONE, IGNORE_WS, FULL_CHECK };

Botan::FULL_CHECK

Definition: filter.h:171

Botan::IGNORE_WS

Definition: filter.h:171

Botan::NONE

Definition: filter.h:171

◆ DL_Group_Source

enum Botan::DL_Group_Source

strong

Enumerator
Builtin
RandomlyGenerated
ExternalSource

Definition at line 18 of file dl_group.h.

                            {
    Builtin,
    RandomlyGenerated,
    ExternalSource,
 };

◆ EC_Group_Encoding

enum Botan::EC_Group_Encoding

This class represents elliptic curce domain parameters

Enumerator
EC_DOMPAR_ENC_EXPLICIT
EC_DOMPAR_ENC_IMPLICITCA
EC_DOMPAR_ENC_OID

Definition at line 23 of file ec_group.h.

                        {
    EC_DOMPAR_ENC_EXPLICIT = 0,
    EC_DOMPAR_ENC_IMPLICITCA = 1,
    EC_DOMPAR_ENC_OID = 2
 };

◆ EC_Group_Source

enum Botan::EC_Group_Source

strong

Enumerator
Builtin
ExternalSource

Definition at line 29 of file ec_group.h.

                            {
    Builtin,
    ExternalSource,
 };

◆ ECIES_Flags

enum Botan::ECIES_Flags : uint32_t

strong

Enumerator
NONE
SINGLE_HASH_MODE	if set: prefix the input of the (ecdh) key agreement with the encoded (ephemeral) public key
COFACTOR_MODE	(decryption only) if set: use cofactor multiplication during (ecdh) key agreement
OLD_COFACTOR_MODE	if set: use ecdhc instead of ecdh
CHECK_MODE	(decryption only) if set: test if the (ephemeral) public key is on the curve

Definition at line 27 of file ecies.h.

                        : uint32_t
    {
    NONE = 0,
 
    /// if set: prefix the input of the (ecdh) key agreement with the encoded (ephemeral) public key
    SINGLE_HASH_MODE = 1,
 
    /// (decryption only) if set: use cofactor multiplication during (ecdh) key agreement
    COFACTOR_MODE = 2,
 
    /// if set: use ecdhc instead of ecdh
    OLD_COFACTOR_MODE = 4,
 
    /// (decryption only) if set: test if the (ephemeral) public key is on the curve
    CHECK_MODE = 8
    };

◆ ErrorType

enum Botan::ErrorType

strong

Different types of errors that might occur

Enumerator
Unknown	Some unknown error
SystemError	An error while calling a system interface
NotImplemented	An operation seems valid, but not supported by the current version
OutOfMemory	Memory allocation failure
InternalError	An internal error occurred
IoError	An I/O error occurred
InvalidObjectState	Invalid object state
KeyNotSet	A key was not set on an object when this is required
InvalidArgument	The application provided an argument which is invalid
InvalidKeyLength	A key with invalid length was provided
InvalidNonceLength	A nonce with invalid length was provided
LookupError	An object type was requested but cannot be found
EncodingFailure	Encoding a message or datum failed
DecodingFailure	Decoding a message or datum failed
TLSError	A TLS error (error_code will be the alert type)
HttpError	An error during an HTTP operation
InvalidTag	A message with an invalid authentication tag was detected
RoughtimeError	An error during Roughtime validation
OpenSSLError	An error when calling OpenSSL
CommonCryptoError	An error when interacting with CommonCrypto API
Pkcs11Error	An error when interacting with a PKCS11 device
TPMError	An error when interacting with a TPM device
DatabaseError	An error when interacting with a database
ZlibError	An error when interacting with zlib
Bzip2Error	An error when interacting with bzip2
LzmaError	An error when interacting with lzma

Definition at line 20 of file exceptn.h.

                      {
    /** Some unknown error */
    Unknown = 1,
    /** An error while calling a system interface */
    SystemError,
    /** An operation seems valid, but not supported by the current version */
    NotImplemented,
    /** Memory allocation failure */
    OutOfMemory,
    /** An internal error occurred */
    InternalError,
    /** An I/O error occurred */
    IoError,
 
    /** Invalid object state */
    InvalidObjectState = 100,
    /** A key was not set on an object when this is required */
    KeyNotSet,
    /** The application provided an argument which is invalid */
    InvalidArgument,
    /** A key with invalid length was provided */
    InvalidKeyLength,
    /** A nonce with invalid length was provided */
    InvalidNonceLength,
    /** An object type was requested but cannot be found */
    LookupError,
    /** Encoding a message or datum failed */
    EncodingFailure,
    /** Decoding a message or datum failed */
    DecodingFailure,
    /** A TLS error (error_code will be the alert type) */
    TLSError,
    /** An error during an HTTP operation */
    HttpError,
    /** A message with an invalid authentication tag was detected */
    InvalidTag,
    /** An error during Roughtime validation */
    RoughtimeError,
 
    /** An error when calling OpenSSL */
    OpenSSLError = 200,
    /** An error when interacting with CommonCrypto API */
    CommonCryptoError,
    /** An error when interacting with a PKCS11 device */
    Pkcs11Error,
    /** An error when interacting with a TPM device */
    TPMError,
    /** An error when interacting with a database */
    DatabaseError,
 
    /** An error when interacting with zlib */
    ZlibError = 300,
    /** An error when interacting with bzip2 */
    Bzip2Error,
    /** An error when interacting with lzma */
    LzmaError,
 
 };

◆ Key_Constraints

enum Botan::Key_Constraints

X.509v3 Key Constraints. If updating update copy in ffi.h

Enumerator
NO_CONSTRAINTS
DIGITAL_SIGNATURE
NON_REPUDIATION
KEY_ENCIPHERMENT
DATA_ENCIPHERMENT
KEY_AGREEMENT
KEY_CERT_SIGN
CRL_SIGN
ENCIPHER_ONLY
DECIPHER_ONLY

Definition at line 106 of file pkix_enums.h.

                      {
    NO_CONSTRAINTS     = 0,
    DIGITAL_SIGNATURE  = 1 << 15,
    NON_REPUDIATION    = 1 << 14,
    KEY_ENCIPHERMENT   = 1 << 13,
    DATA_ENCIPHERMENT  = 1 << 12,
    KEY_AGREEMENT      = 1 << 11,
    KEY_CERT_SIGN      = 1 << 10,
    CRL_SIGN           = 1 << 9,
    ENCIPHER_ONLY      = 1 << 8,
    DECIPHER_ONLY      = 1 << 7
 };

◆ Newhope_Mode

enum Botan::Newhope_Mode

strong

This chooses the XOF + hash for NewHope The official NewHope specification and reference implementation use SHA-3 and SHAKE-128. BoringSSL instead uses SHA-256 and AES-128 in CTR mode. CECPQ1 (x25519+NewHope) always uses BoringSSL's mode

Enumerator
SHA3
BoringSSL

Definition at line 58 of file newhope.h.

    {
    SHA3,
    BoringSSL
    };

◆ Newhope_Params

enum Botan::Newhope_Params

Enumerator
NEWHOPE_SENDABYTES
NEWHOPE_SENDBBYTES
NEWHOPE_OFFER_BYTES
NEWHOPE_ACCEPT_BYTES
NEWHOPE_SHARED_KEY_BYTES
NEWHOPE_SEED_BYTES
NEWHOPE_POLY_BYTES
CECPQ1_OFFER_BYTES
CECPQ1_ACCEPT_BYTES
CECPQ1_SHARED_KEY_BYTES

Definition at line 35 of file newhope.h.

    {
    NEWHOPE_SENDABYTES = 1824,
    NEWHOPE_SENDBBYTES = 2048,
 
    NEWHOPE_OFFER_BYTES  = 1824,
    NEWHOPE_ACCEPT_BYTES = 2048,
    NEWHOPE_SHARED_KEY_BYTES = 32,
 
    NEWHOPE_SEED_BYTES = 32,
    NEWHOPE_POLY_BYTES = 1792,
 
    CECPQ1_OFFER_BYTES   = NEWHOPE_OFFER_BYTES + 32,
    CECPQ1_ACCEPT_BYTES  = NEWHOPE_ACCEPT_BYTES + 32,
    CECPQ1_SHARED_KEY_BYTES = NEWHOPE_SHARED_KEY_BYTES + 32
    };

◆ Signature_Format

enum Botan::Signature_Format

The two types of signature format supported by Botan.

Enumerator
IEEE_1363
DER_SEQUENCE

Definition at line 23 of file pk_keys.h.

23 { IEEE_1363, DER_SEQUENCE };

Botan::IEEE_1363

Definition: pk_keys.h:23

Botan::DER_SEQUENCE

Definition: pk_keys.h:23

◆ TPM_Storage_Type

enum Botan::TPM_Storage_Type

strong

Enumerator
User
System

Definition at line 103 of file tpm.h.

103 { User, System };

Botan::TPM_Storage_Type::System

Botan::PKCS11::UserType::User

◆ Usage_Type

enum Botan::Usage_Type

strong

Enumerator
UNSPECIFIED
TLS_SERVER_AUTH
TLS_CLIENT_AUTH
CERTIFICATE_AUTHORITY
OCSP_RESPONDER
ENCRYPTION

Definition at line 22 of file x509cert.h.

    {
    UNSPECIFIED, // no restrictions
    TLS_SERVER_AUTH,
    TLS_CLIENT_AUTH,
    CERTIFICATE_AUTHORITY,
    OCSP_RESPONDER,
    ENCRYPTION
    };

◆ X509_Encoding

enum Botan::X509_Encoding

The two types of X509 encoding supported by Botan. This enum is not used anymore, and will be removed in a future major release.

Enumerator
RAW_BER
PEM

Definition at line 25 of file x509_key.h.

25 { RAW_BER, PEM };

Botan::PEM

Definition: x509_key.h:25

Botan::RAW_BER

Definition: x509_key.h:25

Function Documentation

◆ abs()

BigInt Botan::abs ( const BigInt & n )

inline

Return the absolute value

Parameters

n	an integer

Returns: absolute value of n

Definition at line 58 of file numthry.h.

References Botan::BigInt::abs().

Referenced by gcd().

58 { return n.abs(); }

◆ allocate_memory()

BOTAN_MALLOC_FN void * Botan::allocate_memory	(	size_t	elems,
		size_t	elem_size
	)

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

Parameters

elems	the number of elements
elem_size	the size of each element

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

Definition at line 18 of file mem_ops.cpp.

References Botan::mlock_allocator::instance().

Referenced by Botan::secure_allocator< T >::allocate().

    {
    if(elems == 0 || elem_size == 0)
       return nullptr;
 
 #if defined(BOTAN_HAS_LOCKING_ALLOCATOR)
    if(void* p = mlock_allocator::instance().allocate(elems, elem_size))
       return p;
 #endif
 
    void* ptr = std::calloc(elems, elem_size);
    if(!ptr)
       throw std::bad_alloc();
    return ptr;
    }

◆ almost_montgomery_inverse()

size_t Botan::almost_montgomery_inverse	(	BigInt &	result,
		const BigInt &	a,
		const BigInt &	b
	)

Return a^-1 * 2^k mod b Returns k, between n and 2n Not const time

Definition at line 27 of file mod_inv.cpp.

References Botan::BigInt::is_even().

Referenced by normalized_montgomery_inverse().

    {
    size_t k = 0;
 
    BigInt u = p, v = a, r = 0, s = 1;
 
    while(v > 0)
       {
       if(u.is_even())
          {
          u >>= 1;
          s <<= 1;
          }
       else if(v.is_even())
          {
          v >>= 1;
          r <<= 1;
          }
       else if(u > v)
          {
          u -= v;
          u >>= 1;
          r += s;
          s <<= 1;
          }
       else
          {
          v -= u;
          v >>= 1;
          s += r;
          r <<= 1;
          }
 
       ++k;
       }
 
    if(r >= p)
       {
       r -= p;
       }
 
    result = p - r;
 
    return k;
    }

◆ aont_package()

void Botan::aont_package	(	RandomNumberGenerator &	rng,
		BlockCipher *	cipher,
		const uint8_t	input[],
		size_t	input_len,
		uint8_t	output[]
	)

Rivest's Package Tranform

Parameters

rng	the random number generator to use
cipher	the block cipher to use (aont_package takes ownership)
input	the input data buffer
input_len	the length of the input data in bytes
output	the output data buffer (must be at least input_len + cipher->BLOCK_SIZE bytes long)

Definition at line 17 of file package.cpp.

References Botan::OctetString::begin(), Botan::BlockCipher::block_size(), BOTAN_ASSERT_EQUAL, clear_mem(), copy_mem(), Botan::BlockCipher::encrypt(), get_byte(), Botan::Pipe::process_msg(), Botan::Pipe::read(), Botan::Pipe::remaining(), Botan::SymmetricAlgorithm::set_key(), Botan::SymmetricAlgorithm::valid_keylength(), xor_buf(), and zeroise().

    {
    if(input_len <= 1)
       throw Encoding_Error("Package transform cannot encode small inputs");
 
    const size_t BLOCK_SIZE = cipher->block_size();
 
    if(!cipher->valid_keylength(BLOCK_SIZE))
       throw Invalid_Argument("AONT::package: Invalid cipher");
 
    // The all-zero string which is used both as the CTR IV and as K0
    const std::string all_zeros(BLOCK_SIZE*2, '0');
 
    SymmetricKey package_key(rng, BLOCK_SIZE);
 
    Pipe pipe(new StreamCipher_Filter(new CTR_BE(cipher), package_key));
 
    pipe.process_msg(input, input_len);
    const size_t remaining = pipe.remaining();
    BOTAN_ASSERT_EQUAL(remaining, pipe.read(output, remaining), "Expected read size");
 
    // Set K0 (the all zero key)
    cipher->set_key(SymmetricKey(all_zeros));
 
    secure_vector<uint8_t> buf(BLOCK_SIZE);
 
    const size_t blocks =
       (input_len + BLOCK_SIZE - 1) / BLOCK_SIZE;
 
    uint8_t* final_block = output + input_len;
    clear_mem(final_block, BLOCK_SIZE);
 
    // XOR the hash blocks into the final block
    for(size_t i = 0; i != blocks; ++i)
       {
       const size_t left = std::min<size_t>(BLOCK_SIZE,
                                            input_len - BLOCK_SIZE * i);
 
       zeroise(buf);
       copy_mem(buf.data(), output + (BLOCK_SIZE * i), left);
 
       for(size_t j = 0; j != sizeof(i); ++j)
          buf[BLOCK_SIZE - 1 - j] ^= get_byte(sizeof(i)-1-j, i);
 
       cipher->encrypt(buf.data());
 
       xor_buf(final_block, buf.data(), BLOCK_SIZE);
       }
 
    // XOR the random package key into the final block
    xor_buf(final_block, package_key.begin(), BLOCK_SIZE);
    }

◆ aont_unpackage()

void Botan::aont_unpackage	(	BlockCipher *	cipher,
		const uint8_t	input[],
		size_t	input_len,
		uint8_t	output[]
	)

Rivest's Package Tranform (Inversion)

Parameters

cipher	the block cipher to use (aont_package takes ownership)
input	the input data buffer
input_len	the length of the input data in bytes
output	the output data buffer (must be at least input_len - cipher->BLOCK_SIZE bytes long)

Definition at line 73 of file package.cpp.

References Botan::BlockCipher::block_size(), BOTAN_ASSERT_EQUAL, copy_mem(), Botan::BlockCipher::encrypt(), get_byte(), Botan::Pipe::process_msg(), Botan::Pipe::read(), Botan::Pipe::remaining(), Botan::SymmetricAlgorithm::set_key(), Botan::SymmetricAlgorithm::valid_keylength(), xor_buf(), and zeroise().

    {
    const size_t BLOCK_SIZE = cipher->block_size();
 
    if(!cipher->valid_keylength(BLOCK_SIZE))
       throw Invalid_Argument("AONT::unpackage: Invalid cipher");
 
    if(input_len < BLOCK_SIZE)
       throw Invalid_Argument("AONT::unpackage: Input too short");
 
    // The all-zero string which is used both as the CTR IV and as K0
    const std::string all_zeros(BLOCK_SIZE*2, '0');
 
    cipher->set_key(SymmetricKey(all_zeros));
 
    secure_vector<uint8_t> package_key(BLOCK_SIZE);
    secure_vector<uint8_t> buf(BLOCK_SIZE);
 
    // Copy the package key (masked with the block hashes)
    copy_mem(package_key.data(),
             input + (input_len - BLOCK_SIZE),
             BLOCK_SIZE);
 
    const size_t blocks = ((input_len - 1) / BLOCK_SIZE);
 
    // XOR the blocks into the package key bits
    for(size_t i = 0; i != blocks; ++i)
       {
       const size_t left = std::min<size_t>(BLOCK_SIZE,
                                            input_len - BLOCK_SIZE * (i+1));
 
       zeroise(buf);
       copy_mem(buf.data(), input + (BLOCK_SIZE * i), left);
 
       for(size_t j = 0; j != sizeof(i); ++j)
          buf[BLOCK_SIZE - 1 - j] ^= get_byte(sizeof(i)-1-j, i);
 
       cipher->encrypt(buf.data());
 
       xor_buf(package_key.data(), buf.data(), BLOCK_SIZE);
       }
 
    Pipe pipe(new StreamCipher_Filter(new CTR_BE(cipher), package_key));
 
    pipe.process_msg(input, input_len - BLOCK_SIZE);
 
    const size_t remaining = pipe.remaining();
    BOTAN_ASSERT_EQUAL(remaining, pipe.read(output, remaining), "Expected read size");
    }

◆ argon2()

void Botan::argon2	(	uint8_t	output[],
		size_t	output_len,
		const char *	password,
		size_t	password_len,
		const uint8_t	salt[],
		size_t	salt_len,
		const uint8_t	key[],
		size_t	key_len,
		const uint8_t	ad[],
		size_t	ad_len,
		uint8_t	y,
		size_t	p,
		size_t	M,
		size_t	t
	)

Argon2 key derivation function

Parameters

output	the output will be placed here
output_len	length of output
password	the user password
password_len	the length of password
salt	the salt
salt_len	length of salt
key	an optional secret key
key_len	the length of key
ad	an optional additional input
ad_len	the length of ad
y	the Argon2 variant (0 = Argon2d, 1 = Argon2i, 2 = Argon2id)
p	the parallelization parameter
M	the amount of memory to use in Kb
t	the number of iterations to use

Definition at line 410 of file argon2.cpp.

References BOTAN_ARG_CHECK, clear_mem(), Botan::HashFunction::create_or_throw(), and salt_len.

Referenced by argon2_check_pwhash(), argon2_generate_pwhash(), Botan::Argon2::derive_key(), and Botan::Argon2_Family::tune().

    {
    BOTAN_ARG_CHECK(mode == 0 || mode == 1 || mode == 2, "Unknown Argon2 mode parameter");
    BOTAN_ARG_CHECK(output_len >= 4, "Invalid Argon2 output length");
    BOTAN_ARG_CHECK(threads >= 1 && threads <= 128, "Invalid Argon2 threads parameter");
    BOTAN_ARG_CHECK(M >= 8*threads && M <= 8192*1024, "Invalid Argon2 M parameter");
    BOTAN_ARG_CHECK(t >= 1, "Invalid Argon2 t parameter");
 
    std::unique_ptr<HashFunction> blake2 = HashFunction::create_or_throw("BLAKE2b");
 
    const auto H0 = argon2_H0(*blake2, output_len,
                              password, password_len,
                              salt, salt_len,
                              key, key_len,
                              ad, ad_len,
                              mode, threads, M, t);
 
    const size_t memory = (M / (SYNC_POINTS*threads)) * (SYNC_POINTS*threads);
 
    secure_vector<uint64_t> B(memory * 1024/8);
 
    init_blocks(B, *blake2, H0, memory, threads);
    process_blocks(B, t, memory, threads, mode);
 
    clear_mem(output, output_len);
    extract_key(output, output_len, B, memory, threads);
    }

◆ argon2_check_pwhash()

bool Botan::argon2_check_pwhash	(	const char *	password,
		size_t	password_len,
		const std::string &	hash
	)

Check a previously created password hash

Parameters

password	the password to check against
password_len	the length of password
hash	the stored hash to check against

Definition at line 57 of file argon2fmt.cpp.

References argon2(), base64_decode(), base64_decode_max_output(), constant_time_compare(), hash, split_on(), and to_u32bit().

    {
    const std::vector<std::string> parts = split_on(input_hash, '$');
 
    if(parts.size() != 5)
       return false;
 
    uint8_t family = 0;
 
    if(parts[0] == "argon2d")
       family = 0;
    else if(parts[0] == "argon2i")
       family = 1;
    else if(parts[0] == "argon2id")
       family = 2;
    else
       return false;
 
    if(parts[1] != "v=19")
       return false;
 
    const std::vector<std::string> params = split_on(parts[2], ',');
 
    if(params.size() != 3)
       return false;
 
    size_t M = 0, t = 0, p = 0;
 
    for(auto param_str : params)
       {
       const std::vector<std::string> param = split_on(param_str, '=');
 
       if(param.size() != 2)
          return false;
 
       const std::string key = param[0];
       const size_t val = to_u32bit(param[1]);
       if(key == "m")
          M = val;
       else if(key == "t")
          t = val;
       else if(key == "p")
          p = val;
       else
          return false;
       }
 
    std::vector<uint8_t> salt(base64_decode_max_output(parts[3].size()));
    salt.resize(base64_decode(salt.data(), parts[3], false));
 
    std::vector<uint8_t> hash(base64_decode_max_output(parts[4].size()));
    hash.resize(base64_decode(hash.data(), parts[4], false));
 
    if(hash.size() < 4)
       return false;
 
    std::vector<uint8_t> generated(hash.size());
    argon2(generated.data(), generated.size(),
           password, password_len,
           salt.data(), salt.size(),
           nullptr, 0,
           nullptr, 0,
           family, p, M, t);
 
    return constant_time_compare(generated.data(), hash.data(), generated.size());
    }

◆ argon2_generate_pwhash()

std::string Botan::argon2_generate_pwhash	(	const char *	password,
		size_t	password_len,
		RandomNumberGenerator &	rng,
		size_t	p,
		size_t	M,
		size_t	t,
		uint8_t	y = `2`,
		size_t	salt_len = `16`,
		size_t	output_len = `32`
	)

Definition at line 26 of file argon2fmt.cpp.

References argon2(), base64_encode(), Botan::RandomNumberGenerator::randomize(), and salt_len.

    {
    std::vector<uint8_t> salt(salt_len);
    rng.randomize(salt.data(), salt.size());
 
    std::vector<uint8_t> output(output_len);
    argon2(output.data(), output.size(),
           password, password_len,
           salt.data(), salt.size(),
           nullptr, 0,
           nullptr, 0,
           y, p, M, t);
 
    std::ostringstream oss;
 
    if(y == 0)
       oss << "$argon2d$";
    else if(y == 1)
       oss << "$argon2i$";
    else
       oss << "$argon2id$";
 
    oss << "v=19$m=" << M << ",t=" << t << ",p=" << p << "$";
    oss << strip_padding(base64_encode(salt)) << "$" << strip_padding(base64_encode(output));
 
    return oss.str();
    }

◆ asn1_class_to_string()

std::string BOTAN_UNSTABLE_API Botan::asn1_class_to_string ( ASN1_Tag type )

Definition at line 87 of file asn1_obj.cpp.

References APPLICATION, CONSTRUCTED, CONTEXT_SPECIFIC, NO_OBJECT, Botan::ASN1::to_string(), type, and UNIVERSAL.

Referenced by Botan::BER_Object::assert_is_a().

    {
    switch(type)
       {
       case UNIVERSAL:
          return "UNIVERSAL";
       case CONSTRUCTED:
          return "CONSTRUCTED";
       case CONTEXT_SPECIFIC:
          return "CONTEXT_SPECIFIC";
       case APPLICATION:
          return "APPLICATION";
       case CONSTRUCTED | CONTEXT_SPECIFIC:
          return "PRIVATE";
       case Botan::NO_OBJECT:
          return "NO_OBJECT";
       default:
          return "CLASS(" + std::to_string(static_cast<size_t>(type)) + ")";
       }
    }

◆ asn1_tag_to_string()

std::string BOTAN_UNSTABLE_API Botan::asn1_tag_to_string ( ASN1_Tag type )

Definition at line 108 of file asn1_obj.cpp.

References BIT_STRING, BMP_STRING, BOOLEAN, ENUMERATED, GENERALIZED_TIME, IA5_STRING, INTEGER, NO_OBJECT, NULL_TAG, NUMERIC_STRING, OBJECT_ID, OCTET_STRING, PRINTABLE_STRING, SEQUENCE, SET, T61_STRING, Botan::ASN1::to_string(), type, UNIVERSAL_STRING, UTC_TIME, UTF8_STRING, and VISIBLE_STRING.

Referenced by Botan::BER_Object::assert_is_a().

    {
    switch(type)
       {
       case Botan::SEQUENCE:
          return "SEQUENCE";
 
       case Botan::SET:
          return "SET";
 
       case Botan::PRINTABLE_STRING:
          return "PRINTABLE STRING";
 
       case Botan::NUMERIC_STRING:
          return "NUMERIC STRING";
 
       case Botan::IA5_STRING:
          return "IA5 STRING";
 
       case Botan::T61_STRING:
          return "T61 STRING";
 
       case Botan::UTF8_STRING:
          return "UTF8 STRING";
 
       case Botan::VISIBLE_STRING:
          return "VISIBLE STRING";
 
       case Botan::BMP_STRING:
          return "BMP STRING";
 
       case Botan::UNIVERSAL_STRING:
          return "UNIVERSAL STRING";
 
       case Botan::UTC_TIME:
          return "UTC TIME";
 
       case Botan::GENERALIZED_TIME:
          return "GENERALIZED TIME";
 
       case Botan::OCTET_STRING:
          return "OCTET STRING";
 
       case Botan::BIT_STRING:
          return "BIT STRING";
 
       case Botan::ENUMERATED:
          return "ENUMERATED";
 
       case Botan::INTEGER:
          return "INTEGER";
 
       case Botan::NULL_TAG:
          return "NULL";
 
       case Botan::OBJECT_ID:
          return "OBJECT";
 
       case Botan::BOOLEAN:
          return "BOOLEAN";
 
       case Botan::NO_OBJECT:
          return "NO_OBJECT";
 
       default:
          return "TAG(" + std::to_string(static_cast<size_t>(type)) + ")";
       }
    }

◆ assertion_failure()

BOTAN_NORETURN void Botan::assertion_failure	(	const char *	expr_str,
		const char *	assertion_made,
		const char *	func,
		const char *	file,
		int	line
	)

Called when an assertion fails Throws an Exception object

Definition at line 31 of file assert.cpp.

    {
    std::ostringstream format;
 
    format << "False assertion ";
 
    if(assertion_made && assertion_made[0] != 0)
       format << "'" << assertion_made << "' (expression " << expr_str << ") ";
    else
       format << expr_str << " ";
 
    if(func)
       format << "in " << func << " ";
 
    format << "@" << file << ":" << line;
 
    throw Internal_Error(format.str());
    }

◆ base32_decode() [1/5]

size_t Botan::base32_decode	(	uint8_t	output[],
		const char	input[],
		size_t	input_length,
		size_t &	input_consumed,
		bool	final_inputs,
		bool	ignore_ws = `true`
	)

Perform base32 decoding

Parameters

output	an array of at least base32_decode_max_output bytes
input	some base32 input
input_length	length of input in bytes
input_consumed	is an output parameter which says how many bytes of input were actually consumed. If less than input_length, then the range input[consumed:length] should be passed in later along with more input.
final_inputs	true iff this is the last input, in which case padding is allowed
ignore_ws	ignore whitespace on input; if false, throw an exception if whitespace is encountered

Returns: number of bytes written to output

Definition at line 195 of file base32.cpp.

References base_decode().

Referenced by base32_decode().

    {
    return base_decode(Base32(), out, in, input_length, input_consumed, final_inputs, ignore_ws);
    }

◆ base32_decode() [2/5]

size_t Botan::base32_decode	(	uint8_t	output[],
		const char	input[],
		size_t	input_length,
		bool	ignore_ws = `true`
	)

Perform base32 decoding

Parameters

output	an array of at least base32_decode_max_output bytes
input	some base32 input
input_length	length of input in bytes
ignore_ws	ignore whitespace on input; if false, throw an exception if whitespace is encountered

Returns: number of bytes written to output

Definition at line 205 of file base32.cpp.

References base_decode_full().

    {
    return base_decode_full(Base32(), output, input, input_length, ignore_ws);
    }

◆ base32_decode() [3/5]

size_t Botan::base32_decode	(	uint8_t	output[],
		const std::string &	input,
		bool	ignore_ws = `true`
	)

Perform base32 decoding

Parameters

output	an array of at least base32_decode_max_output bytes
input	some base32 input
ignore_ws	ignore whitespace on input; if false, throw an exception if whitespace is encountered

Returns: number of bytes written to output

Definition at line 213 of file base32.cpp.

References base32_decode().

    {
    return base32_decode(output, input.data(), input.length(), ignore_ws);
    }

◆ base32_decode() [4/5]

secure_vector< uint8_t > Botan::base32_decode	(	const char	input[],
		size_t	input_length,
		bool	ignore_ws = `true`
	)

Perform base32 decoding

Parameters

input	some base32 input
input_length	the length of input in bytes
ignore_ws	ignore whitespace on input; if false, throw an exception if whitespace is encountered

Returns: decoded base32 output

Definition at line 220 of file base32.cpp.

    {
    return base_decode_to_vec<secure_vector<uint8_t>>(Base32(), input, input_length, ignore_ws);
    }

◆ base32_decode() [5/5]

secure_vector< uint8_t > Botan::base32_decode	(	const std::string &	input,
		bool	ignore_ws = `true`
	)

Perform base32 decoding

Parameters

input	some base32 input
ignore_ws	ignore whitespace on input; if false, throw an exception if whitespace is encountered

Returns: decoded base32 output

Definition at line 227 of file base32.cpp.

References base32_decode().

    {
    return base32_decode(input.data(), input.size(), ignore_ws);
    }

◆ base32_encode() [1/3]

template<typename Alloc >

std::string Botan::base32_encode ( const std::vector< uint8_t, Alloc > & input )

Perform base32 encoding

Parameters

input some input

Returns: base32 representation of input

Definition at line 50 of file base32.h.

References base32_encode().

    {
    return base32_encode(input.data(), input.size());
    }

◆ base32_encode() [2/3]

size_t Botan::base32_encode	(	char	output[],
		const uint8_t	input[],
		size_t	input_length,
		size_t &	input_consumed,
		bool	final_inputs
	)

Perform base32 encoding

Parameters

output	an array of at least base32_encode_max_output bytes
input	is some binary data
input_length	length of input in bytes
input_consumed	is an output parameter which says how many bytes of input were actually consumed. If less than input_length, then the range input[consumed:length] should be passed in later along with more input.
final_inputs	true iff this is the last input, in which case padding chars will be applied if needed

Returns: number of bytes written to output

Definition at line 180 of file base32.cpp.

References base_encode().

Referenced by base32_encode().

    {
    return base_encode(Base32(), out, in, input_length, input_consumed, final_inputs);
    }

◆ base32_encode() [3/3]

std::string Botan::base32_encode	(	const uint8_t	input[],
		size_t	input_length
	)

Perform base32 encoding

Parameters

input	some input
input_length	length of input in bytes

Returns: base32 representation of input

Definition at line 189 of file base32.cpp.

References base_encode_to_string().

    {
    return base_encode_to_string(Base32(), input, input_length);
    }

◆ base58_check_decode() [1/2]

std::vector<uint8_t> Botan::base58_check_decode ( const std::string & s )

inline

Definition at line 69 of file base58.h.

References base58_check_decode().

    {
    return base58_check_decode(s.data(), s.size());
    }

◆ base58_check_decode() [2/2]

std::vector< uint8_t > Botan::base58_check_decode	(	const char	input[],
		size_t	input_length
	)

Perform base58 decoding with checksum

Definition at line 171 of file base58.cpp.

References base58_decode(), and load_be< uint32_t >().

Referenced by base58_check_decode().

    {
    std::vector<uint8_t> dec = base58_decode(input, input_length);
 
    if(dec.size() < 4)
       throw Decoding_Error("Invalid base58 too short for checksum");
 
    const uint32_t computed_checksum = sha256_d_checksum(dec.data(), dec.size() - 4);
    const uint32_t checksum = load_be<uint32_t>(&dec[dec.size()-4], 0);
 
    if(checksum != computed_checksum)
       throw Decoding_Error("Invalid base58 checksum");
 
    dec.resize(dec.size() - 4);
 
    return dec;
    }

◆ base58_check_encode() [1/2]

template<typename Alloc >

std::string Botan::base58_check_encode ( const std::vector< uint8_t, Alloc > & vec )

inline

Definition at line 59 of file base58.h.

References base58_check_encode().

    {
    return base58_check_encode(vec.data(), vec.size());
    }

◆ base58_check_encode() [2/2]

std::string Botan::base58_check_encode	(	const uint8_t	input[],
		size_t	input_length
	)

Perform base58 encoding with checksum

Definition at line 136 of file base58.cpp.

References base58_encode().

Referenced by base58_check_encode().

    {
    BigInt v(input, input_length);
    v <<= 32;
    v += sha256_d_checksum(input, input_length);
    return base58_encode(v, count_leading_zeros(input, input_length, 0));
    }

◆ base58_decode() [1/2]

std::vector<uint8_t> Botan::base58_decode ( const std::string & s )

inline

Definition at line 64 of file base58.h.

References base58_decode().

    {
    return base58_decode(s.data(), s.size());
    }

◆ base58_decode() [2/2]

std::vector< uint8_t > Botan::base58_decode	(	const char	input[],
		size_t	input_length
	)

Perform base58 decoding

This is raw base58 encoding, without the checksum

Definition at line 144 of file base58.cpp.

References Botan::BigInt::binary_encode(), and Botan::BigInt::bytes().

Referenced by base58_check_decode(), and base58_decode().

    {
    const size_t leading_zeros = count_leading_zeros(input, input_length, '1');
 
    BigInt v;
 
    for(size_t i = leading_zeros; i != input_length; ++i)
       {
       const char c = input[i];
 
       if(c == ' ' || c == '\n')
          continue;
 
       const uint8_t idx = base58_value_of(c);
 
       if(idx == 0xFF)
          throw Decoding_Error("Invalid base58");
 
       v *= 58;
       v += idx;
       }
 
    std::vector<uint8_t> output(v.bytes() + leading_zeros);
    v.binary_encode(output.data() + leading_zeros);
    return output;
    }

◆ base58_encode() [1/2]

template<typename Alloc >

std::string Botan::base58_encode ( const std::vector< uint8_t, Alloc > & vec )

inline

Definition at line 53 of file base58.h.

References base58_encode().

    {
    return base58_encode(vec.data(), vec.size());
    }

◆ base58_encode() [2/2]

std::string Botan::base58_encode	(	const uint8_t	input[],
		size_t	input_length
	)

Perform base58 encoding

This is raw base58 encoding, without the checksum

Definition at line 130 of file base58.cpp.

Referenced by base58_check_encode(), and base58_encode().

    {
    BigInt v(input, input_length);
    return base58_encode(v, count_leading_zeros(input, input_length, 0));
    }

◆ base64_decode() [1/5]

size_t Botan::base64_decode	(	uint8_t	output[],
		const char	input[],
		size_t	input_length,
		size_t &	input_consumed,
		bool	final_inputs,
		bool	ignore_ws = `true`
	)

Perform base64 decoding

Parameters

output	an array of at least base64_decode_max_output bytes
input	some base64 input
input_length	length of input in bytes
input_consumed	is an output parameter which says how many bytes of input were actually consumed. If less than input_length, then the range input[consumed:length] should be passed in later along with more input.
final_inputs	true iff this is the last input, in which case padding is allowed
ignore_ws	ignore whitespace on input; if false, throw an exception if whitespace is encountered

Returns: number of bytes written to output

Definition at line 200 of file base64.cpp.

References base_decode().

Referenced by argon2_check_pwhash(), base64_decode(), botan_base64_decode(), Botan::Roughtime::Chain::Chain(), check_passhash9(), Botan::PEM_Code::decode(), Botan::Base64_Decoder::end_msg(), Botan::Encrypted_PSK_Database::get(), Botan::Encrypted_PSK_Database::list_names(), Botan::Roughtime::servers_from_str(), and Botan::Base64_Decoder::write().

    {
    return base_decode(Base64(), out, in, input_length, input_consumed, final_inputs, ignore_ws);
    }

◆ base64_decode() [2/5]

size_t Botan::base64_decode	(	uint8_t	output[],
		const char	input[],
		size_t	input_length,
		bool	ignore_ws = `true`
	)

Perform base64 decoding

Parameters

output	an array of at least base64_decode_max_output bytes
input	some base64 input
input_length	length of input in bytes
ignore_ws	ignore whitespace on input; if false, throw an exception if whitespace is encountered

Returns: number of bytes written to output

Definition at line 210 of file base64.cpp.

References base_decode_full().

    {
    return base_decode_full(Base64(), output, input, input_length, ignore_ws);
    }

◆ base64_decode() [3/5]

size_t Botan::base64_decode	(	uint8_t	output[],
		const std::string &	input,
		bool	ignore_ws = `true`
	)

Perform base64 decoding

Parameters

output	an array of at least base64_decode_max_output bytes
input	some base64 input
ignore_ws	ignore whitespace on input; if false, throw an exception if whitespace is encountered

Returns: number of bytes written to output

Definition at line 218 of file base64.cpp.

References base64_decode().

    {
    return base64_decode(output, input.data(), input.length(), ignore_ws);
    }

◆ base64_decode() [4/5]

secure_vector< uint8_t > Botan::base64_decode	(	const char	input[],
		size_t	input_length,
		bool	ignore_ws = `true`
	)

Perform base64 decoding

Parameters

input	some base64 input
input_length	the length of input in bytes
ignore_ws	ignore whitespace on input; if false, throw an exception if whitespace is encountered

Returns: decoded base64 output

Definition at line 225 of file base64.cpp.

    {
    return base_decode_to_vec<secure_vector<uint8_t>>(Base64(), input, input_length, ignore_ws);
    }

◆ base64_decode() [5/5]

secure_vector< uint8_t > Botan::base64_decode	(	const std::string &	input,
		bool	ignore_ws = `true`
	)

Perform base64 decoding

Parameters

input	some base64 input
ignore_ws	ignore whitespace on input; if false, throw an exception if whitespace is encountered

Returns: decoded base64 output

Definition at line 232 of file base64.cpp.

References base64_decode().

    {
    return base64_decode(input.data(), input.size(), ignore_ws);
    }

◆ base64_decode_max_output()

size_t Botan::base64_decode_max_output ( size_t input_length )

Calculate the size of output buffer for base64_decode

Parameters

input_length the length of input in bytes

Returns: the size of output buffer in bytes

Definition at line 243 of file base64.cpp.

Referenced by argon2_check_pwhash(), and botan_base64_decode().

    {
    return Base64::decode_max_output(input_length);
    }

◆ base64_encode() [1/3]

template<typename Alloc >

std::string Botan::base64_encode ( const std::vector< uint8_t, Alloc > & input )

Perform base64 encoding

Parameters

input some input

Returns: base64adecimal representation of input

Definition at line 50 of file base64.h.

References base64_encode().

    {
    return base64_encode(input.data(), input.size());
    }

◆ base64_encode() [2/3]

size_t Botan::base64_encode	(	char	output[],
		const uint8_t	input[],
		size_t	input_length,
		size_t &	input_consumed,
		bool	final_inputs
	)

Perform base64 encoding

Parameters

output	an array of at least base64_encode_max_output bytes
input	is some binary data
input_length	length of input in bytes
input_consumed	is an output parameter which says how many bytes of input were actually consumed. If less than input_length, then the range input[consumed:length] should be passed in later along with more input.
final_inputs	true iff this is the last input, in which case padding chars will be applied if needed

Returns: number of bytes written to output

Definition at line 185 of file base64.cpp.

References base_encode().

Referenced by argon2_generate_pwhash(), base64_encode(), Botan::OCSP::Request::base64_encode(), botan_base64_encode(), Botan::PEM_Code::encode(), generate_passhash9(), Botan::Encrypted_PSK_Database::get(), Botan::Encrypted_PSK_Database::remove(), Botan::Encrypted_PSK_Database::set(), and Botan::Roughtime::Chain::to_string().

    {
    return base_encode(Base64(), out, in, input_length, input_consumed, final_inputs);
    }

◆ base64_encode() [3/3]

std::string Botan::base64_encode	(	const uint8_t	input[],
		size_t	input_length
	)

Perform base64 encoding

Parameters

input	some input
input_length	length of input in bytes

Returns: base64adecimal representation of input

Definition at line 194 of file base64.cpp.

References base_encode_to_string().

    {
    return base_encode_to_string(Base64(), input, input_length);
    }

◆ base64_encode_max_output()

size_t Botan::base64_encode_max_output ( size_t input_length )

Calculate the size of output buffer for base64_encode

Parameters

input_length the length of input in bytes

Returns: the size of output buffer in bytes

Definition at line 238 of file base64.cpp.

    {
    return Base64::encode_max_output(input_length);
    }

◆ base_decode()

template<typename Base >

size_t Botan::base_decode	(	Base &&	base,
		uint8_t	output[],
		const char	input[],
		size_t	input_length,
		size_t &	input_consumed,
		bool	final_inputs,
		bool	ignore_ws = `true`
	)

Perform decoding using the base provided

Parameters

base	object giving access to the encodings specifications
output	an array of at least Base::decode_max_output bytes
input	some base input
input_length	length of input in bytes
input_consumed	is an output parameter which says how many bytes of input were actually consumed. If less than input_length, then the range input[consumed:length] should be passed in later along with more input.
final_inputs	true iff this is the last input, in which case padding is allowed
ignore_ws	ignore whitespace on input; if false, throw an exception if whitespace is encountered

Returns: number of bytes written to output

Definition at line 124 of file codec_base.h.

References clear_mem().

Referenced by base32_decode(), base64_decode(), and base_decode_full().

    {
    const size_t decoding_bytes_in = base.decoding_bytes_in();
    const size_t decoding_bytes_out = base.decoding_bytes_out();
 
    uint8_t* out_ptr = output;
    std::vector<uint8_t> decode_buf(decoding_bytes_in, 0);
    size_t decode_buf_pos = 0;
    size_t final_truncate = 0;
 
    clear_mem(output, base.decode_max_output(input_length));
 
    for(size_t i = 0; i != input_length; ++i)
       {
       const uint8_t bin = base.lookup_binary_value(input[i]);
 
       if(base.check_bad_char(bin, input[i], ignore_ws)) // May throw Invalid_Argument
          {
          decode_buf[decode_buf_pos] = bin;
          ++decode_buf_pos;
          }
 
       /*
       * If we're at the end of the input, pad with 0s and truncate
       */
       if(final_inputs && (i == input_length - 1))
          {
          if(decode_buf_pos)
             {
             for(size_t j = decode_buf_pos; j < decoding_bytes_in; ++j)
                { decode_buf[j] = 0; }
 
             final_truncate = decoding_bytes_in - decode_buf_pos;
             decode_buf_pos = decoding_bytes_in;
             }
          }
 
       if(decode_buf_pos == decoding_bytes_in)
          {
          base.decode(out_ptr, decode_buf.data());
 
          out_ptr += decoding_bytes_out;
          decode_buf_pos = 0;
          input_consumed = i+1;
          }
       }
 
    while(input_consumed < input_length &&
          base.lookup_binary_value(input[input_consumed]) == 0x80)
       {
       ++input_consumed;
       }
 
    size_t written = (out_ptr - output) - base.bytes_to_remove(final_truncate);
 
    return written;
    }

◆ base_decode_full()

template<typename Base >

size_t Botan::base_decode_full	(	Base &&	base,
		uint8_t	output[],
		const char	input[],
		size_t	input_length,
		bool	ignore_ws
	)

Definition at line 189 of file codec_base.h.

References base_decode().

Referenced by base32_decode(), base64_decode(), and base_decode_to_vec().

    {
    size_t consumed = 0;
    const size_t written = base_decode(base, output, input, input_length, consumed, true, ignore_ws);
 
    if(consumed != input_length)
       {
       throw Invalid_Argument(base.name() + " decoding failed, input did not have full bytes");
       }
 
    return written;
    }

◆ base_decode_to_vec()

template<typename Vector , typename Base >

Vector Botan::base_decode_to_vec	(	Base &&	base,
		const char	input[],
		size_t	input_length,
		bool	ignore_ws
	)

Definition at line 203 of file codec_base.h.

References base_decode_full().

    {
    const size_t output_length = base.decode_max_output(input_length);
    Vector bin(output_length);
 
    const size_t written =
       base_decode_full(base, bin.data(), input, input_length, ignore_ws);
 
    bin.resize(written);
    return bin;
    }

◆ base_encode()

template<class Base >

size_t Botan::base_encode	(	Base &&	base,
		char	output[],
		const uint8_t	input[],
		size_t	input_length,
		size_t &	input_consumed,
		bool	final_inputs
	)

Perform encoding using the base provided

Parameters

base	object giving access to the encodings specifications
output	an array of at least base.encode_max_output bytes
input	is some binary data
input_length	length of input in bytes
input_consumed	is an output parameter which says how many bytes of input were actually consumed. If less than input_length, then the range input[consumed:length] should be passed in later along with more input.
final_inputs	true iff this is the last input, in which case padding chars will be applied if needed

Returns: number of bytes written to output

Definition at line 34 of file codec_base.h.

Referenced by base32_encode(), base64_encode(), and base_encode_to_string().

    {
    input_consumed = 0;
 
    const size_t encoding_bytes_in = base.encoding_bytes_in();
    const size_t encoding_bytes_out = base.encoding_bytes_out();
 
    size_t input_remaining = input_length;
    size_t output_produced = 0;
 
    while(input_remaining >= encoding_bytes_in)
       {
       base.encode(output + output_produced, input + input_consumed);
 
       input_consumed += encoding_bytes_in;
       output_produced += encoding_bytes_out;
       input_remaining -= encoding_bytes_in;
       }
 
    if(final_inputs && input_remaining)
       {
       std::vector<uint8_t> remainder(encoding_bytes_in, 0);
       for(size_t i = 0; i != input_remaining; ++i)
          { remainder[i] = input[input_consumed + i]; }
 
       base.encode(output + output_produced, remainder.data());
 
       const size_t bits_consumed = base.bits_consumed();
       const size_t remaining_bits_before_padding = base.remaining_bits_before_padding();
 
       size_t empty_bits = 8 * (encoding_bytes_in - input_remaining);
       size_t index = output_produced + encoding_bytes_out - 1;
       while(empty_bits >= remaining_bits_before_padding)
          {
          output[index--] = '=';
          empty_bits -= bits_consumed;
          }
 
       input_consumed += input_remaining;
       output_produced += encoding_bytes_out;
       }
 
    return output_produced;
    }

◆ base_encode_to_string()

template<typename Base >

std::string Botan::base_encode_to_string	(	Base &&	base,
		const uint8_t	input[],
		size_t	input_length
	)

Definition at line 86 of file codec_base.h.

References base_encode(), and BOTAN_ASSERT_EQUAL.

Referenced by base32_encode(), and base64_encode().

    {
    const size_t output_length = base.encode_max_output(input_length);
    std::string output(output_length, 0);
 
    size_t consumed = 0;
    size_t produced = 0;
 
    if(output_length > 0)
       {
       produced = base_encode(base, &output.front(),
                                    input, input_length,
                                    consumed, true);
       }
 
    BOTAN_ASSERT_EQUAL(consumed, input_length, "Consumed the entire input");
    BOTAN_ASSERT_EQUAL(produced, output.size(), "Produced expected size");
 
    return output;
    }

◆ bcrypt_pbkdf()

void BOTAN_UNSTABLE_API Botan::bcrypt_pbkdf	(	uint8_t	output[],
		size_t	output_len,
		const char *	pass,
		size_t	pass_len,
		const uint8_t	salt[],
		size_t	salt_len,
		size_t	rounds
	)

Bcrypt PBKDF compatible with OpenBSD bcrypt_pbkdf

Definition at line 130 of file bcrypt_pbkdf.cpp.

References BOTAN_ARG_CHECK, clear_mem(), Botan::HashFunction::create_or_throw(), and salt_len.

Referenced by Botan::Bcrypt_PBKDF::derive_key(), and Botan::Bcrypt_PBKDF_Family::tune().

    {
    BOTAN_ARG_CHECK(rounds >= 1, "Invalid rounds for Bcrypt PBKDF");
 
    // No output desired, so we are all done already...
    if(output_len == 0)
       return;
 
    BOTAN_ARG_CHECK(output_len <= 10*1024*1024, "Too much output for Bcrypt PBKDF");
 
    const size_t BCRYPT_BLOCK_SIZE = 32;
    const size_t blocks = (output_len + BCRYPT_BLOCK_SIZE - 1) / BCRYPT_BLOCK_SIZE;
 
    std::unique_ptr<HashFunction> sha512 = HashFunction::create_or_throw("SHA-512");
    const secure_vector<uint8_t> pass_hash = sha512->process(reinterpret_cast<const uint8_t*>(pass), pass_len);
 
    secure_vector<uint8_t> salt_hash(sha512->output_length());
 
    Blowfish blowfish;
    secure_vector<uint8_t> out(BCRYPT_BLOCK_SIZE);
    secure_vector<uint8_t> tmp(BCRYPT_BLOCK_SIZE);
 
    for(size_t block = 0; block != blocks; ++block)
       {
       clear_mem(out.data(), out.size());
 
       sha512->update(salt, salt_len);
       sha512->update_be(static_cast<uint32_t>(block + 1));
       sha512->final(salt_hash.data());
 
       bcrypt_round(blowfish, pass_hash, salt_hash, out, tmp);
 
       for(size_t r = 1; r != rounds; ++r)
          {
          // Next salt is H(prev_output)
          sha512->update(tmp);
          sha512->final(salt_hash.data());
 
          bcrypt_round(blowfish, pass_hash, salt_hash, out, tmp);
          }
 
       for(size_t i = 0; i != BCRYPT_BLOCK_SIZE; ++i)
          {
          const size_t dest = i * blocks + block;
          if(dest < output_len)
             output[dest] = out[i];
          }
       }
    }

◆ bigint_add2()

void Botan::bigint_add2	(	word	x[],
		size_t	x_size,
		const word	y[],
		size_t	y_size
	)

inline

Two operand addition

Parameters

x	the first operand (and output)
x_size	size of x
y	the second operand
y_size	size of y (must be >= x_size)

Definition at line 280 of file mp_core.h.

References bigint_add2_nc().

Referenced by Botan::BigInt::add(), and mul_add().

    {
    x[x_size] += bigint_add2_nc(x, x_size, y, y_size);
    }

◆ bigint_add2_nc()

word Botan::bigint_add2_nc	(	word	x[],
		size_t	x_size,
		const word	y[],
		size_t	y_size
	)

inline

Two operand addition with carry out

Definition at line 227 of file mp_core.h.

References BOTAN_ASSERT, carry(), word8_add2(), and word_add().

Referenced by bigint_add2().

    {
    word carry = 0;
 
    BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
 
    const size_t blocks = y_size - (y_size % 8);
 
    for(size_t i = 0; i != blocks; i += 8)
       carry = word8_add2(x + i, y + i, carry);
 
    for(size_t i = blocks; i != y_size; ++i)
       x[i] = word_add(x[i], y[i], &carry);
 
    for(size_t i = y_size; i != x_size; ++i)
       x[i] = word_add(x[i], 0, &carry);
 
    return carry;
    }

◆ bigint_add3()

void Botan::bigint_add3	(	word	z[],
		const word	x[],
		size_t	x_size,
		const word	y[],
		size_t	y_size
	)

inline

Three operand addition

Definition at line 289 of file mp_core.h.

References bigint_add3_nc().

Referenced by Botan::BigInt::add2().

    {
    z[x_size > y_size ? x_size : y_size] +=
       bigint_add3_nc(z, x, x_size, y, y_size);
    }

◆ bigint_add3_nc()

word Botan::bigint_add3_nc	(	word	z[],
		const word	x[],
		size_t	x_size,
		const word	y[],
		size_t	y_size
	)

inline

Three operand addition with carry out

Definition at line 250 of file mp_core.h.

References carry(), word8_add3(), and word_add().

Referenced by bigint_add3(), Botan::BigInt::mod_add(), and redc_p521().

    {
    if(x_size < y_size)
       { return bigint_add3_nc(z, y, y_size, x, x_size); }
 
    word carry = 0;
 
    const size_t blocks = y_size - (y_size % 8);
 
    for(size_t i = 0; i != blocks; i += 8)
       carry = word8_add3(z + i, x + i, y + i, carry);
 
    for(size_t i = blocks; i != y_size; ++i)
       z[i] = word_add(x[i], y[i], &carry);
 
    for(size_t i = y_size; i != x_size; ++i)
       z[i] = word_add(x[i], 0, &carry);
 
    return carry;
    }

◆ bigint_cmp()

int32_t Botan::bigint_cmp	(	const word	x[],
		size_t	x_size,
		const word	y[],
		size_t	y_size
	)

inline

Compare x and y Return -1 if x < y Return 0 if x == y Return 1 if x > y

Definition at line 525 of file mp_core.h.

References BOTAN_DEBUG_ASSERT, Botan::CT::Mask< T >::is_equal(), Botan::CT::Mask< T >::is_lt(), Botan::CT::Mask< T >::is_zero(), and Botan::CT::unpoison().

Referenced by Botan::BigInt::add(), bigint_sub_abs(), Botan::BigInt::cmp(), and Botan::BigInt::cmp_word().

    {
    static_assert(sizeof(word) >= sizeof(uint32_t), "Size assumption");
 
    const word LT = static_cast<word>(-1);
    const word EQ = 0;
    const word GT = 1;
 
    const size_t common_elems = std::min(x_size, y_size);
 
    word result = EQ; // until found otherwise
 
    for(size_t i = 0; i != common_elems; i++)
       {
       const auto is_eq = CT::Mask<word>::is_equal(x[i], y[i]);
       const auto is_lt = CT::Mask<word>::is_lt(x[i], y[i]);
 
       result = is_eq.select(result, is_lt.select(LT, GT));
       }
 
    if(x_size < y_size)
       {
       word mask = 0;
       for(size_t i = x_size; i != y_size; i++)
          mask |= y[i];
 
       // If any bits were set in high part of y, then x < y
       result = CT::Mask<word>::is_zero(mask).select(result, LT);
       }
    else if(y_size < x_size)
       {
       word mask = 0;
       for(size_t i = y_size; i != x_size; i++)
          mask |= x[i];
 
       // If any bits were set in high part of x, then x > y
       result = CT::Mask<word>::is_zero(mask).select(result, GT);
       }
 
    CT::unpoison(result);
    BOTAN_DEBUG_ASSERT(result == LT || result == GT || result == EQ);
    return static_cast<int32_t>(result);
    }

◆ bigint_cnd_abs()

void Botan::bigint_cnd_abs	(	word	cnd,
		word	x[],
		size_t	size
	)

inline

Definition at line 212 of file mp_core.h.

References carry(), Botan::CT::Mask< T >::expand(), and word_add().

    {
    const auto mask = CT::Mask<word>::expand(cnd);
 
    word carry = mask.if_set_return(1);
    for(size_t i = 0; i != size; ++i)
       {
       const word z = word_add(~x[i], 0, &carry);
       x[i] = mask.select(z, x[i]);
       }
    }

◆ bigint_cnd_add() [1/2]

word Botan::bigint_cnd_add	(	word	cnd,
		word	x[],
		word	x_size,
		const word	y[],
		size_t	y_size
	)

inline

Definition at line 42 of file mp_core.h.

References BOTAN_ASSERT, carry(), Botan::CT::Mask< T >::expand(), word8_add3(), and word_add().

Referenced by bigint_cnd_add(), Botan::BigInt::ct_cond_add(), redc_p192(), redc_p224(), redc_p256(), and redc_p384().

    {
    BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
 
    const auto mask = CT::Mask<word>::expand(cnd);
 
    word carry = 0;
 
    const size_t blocks = y_size - (y_size % 8);
    word z[8] = { 0 };
 
    for(size_t i = 0; i != blocks; i += 8)
       {
       carry = word8_add3(z, x + i, y + i, carry);
       mask.select_n(x + i, z, x + i, 8);
       }
 
    for(size_t i = blocks; i != y_size; ++i)
       {
       z[0] = word_add(x[i], y[i], &carry);
       x[i] = mask.select(z[0], x[i]);
       }
 
    for(size_t i = y_size; i != x_size; ++i)
       {
       z[0] = word_add(x[i], 0, &carry);
       x[i] = mask.select(z[0], x[i]);
       }
 
    return mask.if_set_return(carry);
    }

◆ bigint_cnd_add() [2/2]

word Botan::bigint_cnd_add	(	word	cnd,
		word	x[],
		const word	y[],
		size_t	size
	)

inline

Definition at line 79 of file mp_core.h.

References bigint_cnd_add().

    {
    return bigint_cnd_add(cnd, x, size, y, size);
    }

◆ bigint_cnd_add_or_sub()

void Botan::bigint_cnd_add_or_sub	(	CT::Mask< word >	mask,
		word	x[],
		const word	y[],
		size_t	size
	)

inline

Definition at line 139 of file mp_core.h.

References carry(), Botan::CT::Mask< T >::select(), word8_add3(), word8_sub3(), word_add(), and word_sub().

    {
    const size_t blocks = size - (size % 8);
 
    word carry = 0;
    word borrow = 0;
 
    word t0[8] = { 0 };
    word t1[8] = { 0 };
 
    for(size_t i = 0; i != blocks; i += 8)
       {
       carry = word8_add3(t0, x + i, y + i, carry);
       borrow = word8_sub3(t1, x + i, y + i, borrow);
 
       for(size_t j = 0; j != 8; ++j)
          x[i+j] = mask.select(t0[j], t1[j]);
       }
 
    for(size_t i = blocks; i != size; ++i)
       {
       const word a = word_add(x[i], y[i], &carry);
       const word s = word_sub(x[i], y[i], &borrow);
 
       x[i] = mask.select(a, s);
       }
    }

◆ bigint_cnd_addsub()

word Botan::bigint_cnd_addsub	(	CT::Mask< word >	mask,
		word	x[],
		const word	y[],
		const word	z[],
		size_t	size
	)

inline

Definition at line 176 of file mp_core.h.

References carry(), Botan::CT::Mask< T >::select(), word8_add3(), word8_sub3(), word_add(), and word_sub().

Referenced by bigint_mod_sub(), and bigint_mod_sub_n().

    {
    const size_t blocks = size - (size % 8);
 
    word carry = 0;
    word borrow = 0;
 
    word t0[8] = { 0 };
    word t1[8] = { 0 };
 
    for(size_t i = 0; i != blocks; i += 8)
       {
       carry = word8_add3(t0, x + i, y + i, carry);
       borrow = word8_sub3(t1, x + i, z + i, borrow);
 
       for(size_t j = 0; j != 8; ++j)
          x[i+j] = mask.select(t0[j], t1[j]);
       }
 
    for(size_t i = blocks; i != size; ++i)
       {
       t0[0] = word_add(x[i], y[i], &carry);
       t1[0] = word_sub(x[i], z[i], &borrow);
       x[i] = mask.select(t0[0], t1[0]);
       }
 
    return mask.select(carry, borrow);
    }

◆ bigint_cnd_sub() [1/2]

word Botan::bigint_cnd_sub	(	word	cnd,
		word	x[],
		size_t	x_size,
		const word	y[],
		size_t	y_size
	)

inline

Definition at line 88 of file mp_core.h.

References BOTAN_ASSERT, carry(), Botan::CT::Mask< T >::expand(), word8_sub3(), and word_sub().

Referenced by bigint_cnd_sub(), and redc_p521().

    {
    BOTAN_ASSERT(x_size >= y_size, "Expected sizes");
 
    const auto mask = CT::Mask<word>::expand(cnd);
 
    word carry = 0;
 
    const size_t blocks = y_size - (y_size % 8);
    word z[8] = { 0 };
 
    for(size_t i = 0; i != blocks; i += 8)
       {
       carry = word8_sub3(z, x + i, y + i, carry);
       mask.select_n(x + i, z, x + i, 8);
       }
 
    for(size_t i = blocks; i != y_size; ++i)
       {
       z[0] = word_sub(x[i], y[i], &carry);
       x[i] = mask.select(z[0], x[i]);
       }
 
    for(size_t i = y_size; i != x_size; ++i)
       {
       z[0] = word_sub(x[i], 0, &carry);
       x[i] = mask.select(z[0], x[i]);
       }
 
    return mask.if_set_return(carry);
    }

◆ bigint_cnd_sub() [2/2]

word Botan::bigint_cnd_sub	(	word	cnd,
		word	x[],
		const word	y[],
		size_t	size
	)

inline

Definition at line 126 of file mp_core.h.

References bigint_cnd_sub().

    {
    return bigint_cnd_sub(cnd, x, size, y, size);
    }

◆ bigint_cnd_swap()

void Botan::bigint_cnd_swap	(	word	cnd,
		word	x[],
		word	y[],
		size_t	size
	)

inline

Definition at line 29 of file mp_core.h.

References Botan::CT::Mask< T >::expand().

Referenced by Botan::BigInt::ct_cond_swap().

    {
    const auto mask = CT::Mask<word>::expand(cnd);
 
    for(size_t i = 0; i != size; ++i)
       {
       const word a = x[i];
       const word b = y[i];
       x[i] = mask.select(b, a);
       y[i] = mask.select(a, b);
       }
    }

◆ bigint_comba_mul16()

void Botan::bigint_comba_mul16	(	word	z[32],
		const word	x[16],
		const word	y[16]
	)

Definition at line 805 of file mp_comba.cpp.

References word3_muladd().

Referenced by bigint_mul().

    {
    word w2 = 0, w1 = 0, w0 = 0;
 
    word3_muladd(&w2, &w1, &w0, x[ 0], y[ 0]);
    z[ 0] = w0; w0 = 0;
 
    word3_muladd(&w0, &w2, &w1, x[ 0], y[ 1]);
    word3_muladd(&w0, &w2, &w1, x[ 1], y[ 0]);
    z[ 1] = w1; w1 = 0;
 
    word3_muladd(&w1, &w0, &w2, x[ 0], y[ 2]);
    word3_muladd(&w1, &w0, &w2, x[ 1], y[ 1]);
    word3_muladd(&w1, &w0, &w2, x[ 2], y[ 0]);
    z[ 2] = w2; w2 = 0;
 
    word3_muladd(&w2, &w1, &w0, x[ 0], y[ 3]);
    word3_muladd(&w2, &w1, &w0, x[ 1], y[ 2]);
    word3_muladd(&w2, &w1, &w0, x[ 2], y[ 1]);
    word3_muladd(&w2, &w1, &w0, x[ 3], y[ 0]);
    z[ 3] = w0; w0 = 0;
 
    word3_muladd(&w0, &w2, &w1, x[ 0], y[ 4]);
    word3_muladd(&w0, &w2, &w1, x[ 1], y[ 3]);
    word3_muladd(&w0, &w2, &w1, x[ 2], y[ 2]);
    word3_muladd(&w0, &w2, &w1, x[ 3], y[ 1]);
    word3_muladd(&w0, &w2, &w1, x[ 4], y[ 0]);
    z[ 4] = w1; w1 = 0;
 
    word3_muladd(&w1, &w0, &w2, x[ 0], y[ 5]);
    word3_muladd(&w1, &w0, &w2, x[ 1], y[ 4]);
    word3_muladd(&w1, &w0, &w2, x[ 2], y[ 3]);
    word3_muladd(&w1, &w0, &w2, x[ 3], y[ 2]);
    word3_muladd(&w1, &w0, &w2, x[ 4], y[ 1]);
    word3_muladd(&w1, &w0, &w2, x[ 5], y[ 0]);
    z[ 5] = w2; w2 = 0;
 
    word3_muladd(&w2, &w1, &w0, x[ 0], y[ 6]);
    word3_muladd(&w2, &w1, &w0, x[ 1], y[ 5]);
    word3_muladd(&w2, &w1, &w0, x[ 2], y[ 4]);
    word3_muladd(&w2, &w1, &w0, x[ 3], y[ 3]);
    word3_muladd(&w2, &w1, &w0, x[ 4], y[ 2]);
    word3_muladd(&w2, &w1, &w0, x[ 5], y[ 1]);
    word3_muladd(&w2, &w1, &w0, x[ 6], y[ 0]);
    z[ 6] = w0; w0 = 0;
 
    word3_muladd(&w0, &w2, &w1, x[ 0], y[ 7]);
    word3_muladd(&w0, &w2, &w1, x[ 1], y[ 6]);
    word3_muladd(&w0, &w2, &w1, x[ 2], y[ 5]);
    word3_muladd(&w0, &w2, &w1, x[ 3], y[ 4]);
    word3_muladd(&w0, &w2, &w1, x[ 4], y[ 3]);
    word3_muladd(&w0, &w2, &w1, x[ 5], y[ 2]);
    word3_muladd(&w0, &w2, &w1, x[ 6], y[ 1]);
    word3_muladd(&w0, &w2, &w1, x[ 7], y[ 0]);
    z[ 7] = w1; w1 = 0;
 
    word3_muladd(&w1, &w0, &w2, x[ 0], y[ 8]);
    word3_muladd(&w1, &w0, &w2, x[ 1], y[ 7]);
    word3_muladd(&w1, &w0, &w2, x[ 2], y[ 6]);
    word3_muladd(&w1, &w0, &w2, x[ 3], y[ 5]);
    word3_muladd(&w1, &w0, &w2, x[ 4], y[ 4]);
    word3_muladd(&w1, &w0, &w2, x[ 5], y[ 3]);
    word3_muladd(&w1, &w0, &w2, x[ 6], y[ 2]);
    word3_muladd(&w1, &w0, &w2, x[ 7], y[ 1]);
    word3_muladd(&w1, &w0, &w2, x[ 8], y[ 0]);
    z[ 8] = w2; w2 = 0;
 
    word3_muladd(&w2, &w1, &w0, x[ 0], y[ 9]);
    word3_muladd(&w2, &w1, &w0, x[ 1], y[ 8]);
    word3_muladd(&w2, &w1, &w0, x[ 2], y[ 7]);
    word3_muladd(&w2, &w1, &w0, x[ 3], y[ 6]);
    word3_muladd(&w2, &w1, &w0, x[ 4], y[ 5]);
    word3_muladd(&w2, &w1, &w0, x[ 5], y[ 4]);
    word3_muladd(&w2, &w1, &w0, x[ 6], y[ 3]);
    word3_muladd(&w2, &w1, &w0, x[ 7], y[ 2]);
    word3_muladd(&w2, &w1, &w0, x[ 8], y[ 1]);
    word3_muladd(&w2, &w1, &w0, x[ 9], y[ 0]);
    z[ 9] = w0; w0 = 0;
 
    word3_muladd(&w0, &w2, &w1, x[ 0], y[10]);
    word3_muladd(&w0, &w2, &w1, x[ 1], y[ 9]);
    word3_muladd(&w0, &w2, &w1, x[ 2], y[ 8]);
    word3_muladd(&w0, &w2, &w1, x[ 3], y[ 7]);
    word3_muladd(&w0, &w2, &w1, x[ 4], y[ 6]);
    word3_muladd(&w0, &w2, &w1, x[ 5], y[ 5]);
    word3_muladd(&w0, &w2, &w1, x[ 6], y[ 4]);
    word3_muladd(&w0, &w2, &w1, x[ 7], y[ 3]);
    word3_muladd(&w0, &w2, &w1, x[ 8], y[ 2]);
    word3_muladd(&w0, &w2, &w1, x[ 9], y[ 1]);
    word3_muladd(&w0, &w2, &w1, x[10], y[ 0]);
    z[10] = w1; w1 = 0;
 
    word3_muladd(&w1, &w0, &w2, x[ 0], y[11]);
    word3_muladd(&w1, &w0, &w2, x[ 1], y[10]);
    word3_muladd(&w1, &w0, &w2, x[ 2], y[ 9]);
    word3_muladd(&w1, &w0, &w2, x[ 3], y[ 8]);
    word3_muladd(&w1, &w0, &w2, x[ 4], y[ 7]);
    word3_muladd(&w1, &w0, &w2, x[ 5], y[ 6]);
    word3_muladd(&w1, &w0, &w2, x[ 6], y[ 5]);
    word3_muladd(&w1, &w0, &w2, x[ 7], y[ 4]);
    word3_muladd(&w1, &w0, &w2, x[ 8], y[ 3]);
    word3_muladd(&w1, &w0, &w2, x[ 9], y[ 2]);
    word3_muladd(&w1, &w0, &w2, x[10], y[ 1]);
    word3_muladd(&w1, &w0, &w2, x[11], y[ 0]);
    z[11] = w2; w2 = 0;
 
    word3_muladd(&w2, &w1, &w0, x[ 0], y[12]);
    word3_muladd(&w2, &w1, &w0, x[ 1], y[11]);
    word3_muladd(&w2, &w1, &w0, x[ 2], y[10]);
    word3_muladd(&w2, &w1, &w0, x[ 3], y[ 9]);
    word3_muladd(&w2, &w1, &w0, x[ 4], y[ 8]);
    word3_muladd(&w2, &w1, &w0, x[ 5], y[ 7]);
    word3_muladd(&w2, &w1, &w0, x[ 6], y[ 6]);
    word3_muladd(&w2, &w1, &w0, x[ 7], y[ 5]);
    word3_muladd(&w2, &w1, &w0, x[ 8], y[ 4]);
    word3_muladd(&w2, &w1, &w0, x[ 9], y[ 3]);
    word3_muladd(&w2, &w1, &w0, x[10], y[ 2]);
    word3_muladd(&w2, &w1, &w0, x[11], y[ 1]);
    word3_muladd(&w2, &w1, &w0, x[12], y[ 0]);
    z[12] = w0; w0 = 0;
 
    word3_muladd(&w0, &w2, &w1, x[ 0], y[13]);
    word3_muladd(&w0, &w2, &w1, x[ 1], y[12]);
    word3_muladd(&w0, &w2, &w1, x[ 2], y[11]);
    word3_muladd(&w0, &w2, &w1, x[ 3], y[10]);
    word3_muladd(&w0, &w2, &w1, x[ 4], y[ 9]);
    word3_muladd(&w0, &w2, &w1, x[ 5], y[ 8]);
    word3_muladd(&w0, &w2, &w1, x[ 6], y[ 7]);
    word3_muladd(&w0, &w2, &w1, x[ 7], y[ 6]);
    word3_muladd(&w0, &w2, &w1, x[ 8], y[ 5]);
    word3_muladd(&w0, &w2, &w1, x[ 9], y[ 4]);
    word3_muladd(&w0, &w2, &w1, x[10], y[ 3]);
    word3_muladd(&w0, &w2, &w1, x[11], y[ 2]);
    word3_muladd(&w0, &w2, &w1, x[12], y[ 1]);
    word3_muladd(&w0, &w2, &w1, x[13], y[ 0]);
    z[13] = w1; w1 = 0;
 
    word3_muladd(&w1, &w0, &w2, x[ 0], y[14]);
    word3_muladd(&w1, &w0, &w2, x[ 1], y[13]);
    word3_muladd(&w1, &w0, &w2, x[ 2], y[12]);
    word3_muladd(&w1, &w0, &w2, x[ 3], y[11]);
    word3_muladd(&w1, &w0, &w2, x[ 4], y[10]);
    word3_muladd(&w1, &w0, &w2, x[ 5], y[ 9]);
    word3_muladd(&w1, &w0, &w2, x[ 6], y[ 8]);
    word3_muladd(&w1, &w0, &w2, x[ 7], y[ 7]);
    word3_muladd(&w1, &w0, &w2, x[ 8], y[ 6]);
    word3_muladd(&w1, &w0, &w2, x[ 9], y[ 5]);
    word3_muladd(&w1, &w0, &w2, x[10], y[ 4]);
    word3_muladd(&w1, &w0, &w2, x[11], y[ 3]);
    word3_muladd(&w1, &w0, &w2, x[12], y[ 2]);
    word3_muladd(&w1, &w0, &w2, x[13], y[ 1]);
    word3_muladd(&w1, &w0, &w2, x[14], y[ 0]);
    z[14] = w2; w2 = 0;
 
    word3_muladd(&w2, &w1, &w0, x[ 0], y[15]);
    word3_muladd(&w2, &w1, &w0, x[ 1], y[14]);
    word3_muladd(&w2, &w1, &w0, x[ 2], y[13]);
    word3_muladd(&w2, &w1, &w0, x[ 3], y[12]);
    word3_muladd(&w2, &w1, &w0, x[ 4], y[11]);
    word3_muladd(&w2, &w1, &w0, x[ 5], y[10]);
    word3_muladd(&w2, &w1, &w0, x[ 6], y[ 9]);
    word3_muladd(&w2, &w1, &w0, x[ 7], y[ 8]);
    word3_muladd(&w2, &w1, &w0, x[ 8], y[ 7]);
    word3_muladd(&w2, &w1, &w0, x[ 9], y[ 6]);
    word3_muladd(&w2, &w1, &w0, x[10], y[ 5]);
    word3_muladd(&w2, &w1, &w0, x[11], y[ 4]);
    word3_muladd(&w2, &w1, &w0, x[12], y[ 3]);
    word3_muladd(&w2, &w1, &w0, x[13], y[ 2]);
    word3_muladd(&w2, &w1, &w0, x[14], y[ 1]);
    word3_muladd(&w2, &w1, &w0, x[15], y[ 0]);
    z[15] = w0; w0 = 0;
 
    word3_muladd(&w0, &w2, &w1, x[ 1], y[15]);
    word3_muladd(&w0, &w2, &w1, x[ 2], y[14]);
    word3_muladd(&w0, &w2, &w1, x[ 3], y[13]);
    word3_muladd(&w0, &w2, &w1, x[ 4], y[12]);
    word3_muladd(&w0, &w2, &w1, x[ 5], y[11]);
    word3_muladd(&w0, &w2, &w1, x[ 6], y[10]);
    word3_muladd(&w0, &w2, &w1, x[ 7], y[ 9]);
    word3_muladd(&w0, &w2, &w1, x[ 8], y[ 8]);
    word3_muladd(&w0, &w2, &w1, x[ 9], y[ 7]);
    word3_muladd(&w0, &w2, &w1, x[10], y[ 6]);
    word3_muladd(&w0, &w2, &w1, x[11], y[ 5]);
    word3_muladd(&w0, &w2, &w1, x[12], y[ 4]);
    word3_muladd(&w0, &w2, &w1, x[13], y[ 3]);
    word3_muladd(&w0, &w2, &w1, x[14], y[ 2]);
    word3_muladd(&w0, &w2, &w1, x[15], y[ 1]);
    z[16] = w1; w1 = 0;
 
    word3_muladd(&w1, &w0, &w2, x[ 2], y[15]);
    word3_muladd(&w1, &w0, &w2, x[ 3], y[14]);
    word3_muladd(&w1, &w0, &w2, x[ 4], y[13]);
    word3_muladd(&w1, &w0, &w2, x[ 5], y[12]);
    word3_muladd(&w1, &w0, &w2, x[ 6], y[11]);
    word3_muladd(&w1, &w0, &w2, x[ 7], y[10]);
    word3_muladd(&w1, &w0, &w2, x[ 8], y[ 9]);
    word3_muladd(&w1, &w0, &w2, x[ 9], y[ 8]);
    word3_muladd(&w1, &w0, &w2, x[10], y[ 7]);
    word3_muladd(&w1, &w0, &w2, x[11], y[ 6]);
    word3_muladd(&w1, &w0, &w2, x[12], y[ 5]);
    word3_muladd(&w1, &w0, &w2, x[13], y[ 4]);
    word3_muladd(&w1, &w0, &w2, x[14], y[ 3]);
    word3_muladd(&w1, &w0, &w2, x[15], y[ 2]);
    z[17] = w2; w2 = 0;
 
    word3_muladd(&w2, &w1, &w0, x[ 3], y[15]);
    word3_muladd(&w2, &w1, &w0, x[ 4], y[14]);
    word3_muladd(&w2, &w1, &w0, x[ 5], y[13]);
    word3_muladd(&w2, &w1, &w0, x[ 6], y[12]);
    word3_muladd(&w2, &w1, &w0, x[ 7], y[11]);
    word3_muladd(&w2, &w1, &w0, x[ 8], y[10]);
    word3_muladd(&w2, &w1, &w0, x[ 9], y[ 9]);
    word3_muladd(&w2, &w1, &w0, x[10], y[ 8]);
    word3_muladd(&w2, &w1, &w0, x[11], y[ 7]);
    word3_muladd(&w2, &w1, &w0, x[12], y[ 6]);
    word3_muladd(&w2, &w1, &w0, x[13], y[ 5]);
    word3_muladd(&w2, &w1, &w0, x[14], y[ 4]);
    word3_muladd(&w2, &w1, &w0, x[15], y[ 3]);
    z[18] = w0; w0 = 0;
 
    word3_muladd(&w0, &w2, &w1, x[ 4], y[15]);
    word3_muladd(&w0, &w2, &w1, x[ 5], y[14]);
    word3_muladd(&w0, &w2, &w1, x[ 6], y[13]);
    word3_muladd(&w0, &w2, &w1, x[ 7], y[12]);
    word3_muladd(&w0, &w2, &w1, x[ 8], y[11]);
    word3_muladd(&w0, &w2, &w1, x[ 9], y[10]);
    word3_muladd(&w0, &w2, &w1, x[10], y[ 9]);
    word3_muladd(&w0, &w2, &w1, x[11], y[ 8]);
    word3_muladd(&w0, &w2, &w1, x[12], y[ 7]);
    word3_muladd(&w0, &w2, &w1, x[13], y[ 6]);
    word3_muladd(&w0, &w2, &w1, x[14], y[ 5]);
    word3_muladd(&w0, &w2, &w1, x[15], y[ 4]);
    z[19] = w1; w1 = 0;
 
    word3_muladd(&w1, &w0, &w2, x[ 5], y[15]);
    word3_muladd(&w1, &w0, &w2, x[ 6], y[14]);
    word3_muladd(&w1, &w0, &w2, x[ 7], y[13]);
    word3_muladd(&w1, &w0, &w2, x[ 8], y[12]);
    word3_muladd(&w1, &w0, &w2, x[ 9], y[11]);
    word3_muladd(&w1, &w0, &w2, x[10], y[10]);
    word3_muladd(&w1, &w0, &w2, x[11], y[ 9]);
    word3_muladd(&w1, &w0, &w2, x[12], y[ 8]);
    word3_muladd(&w1, &w0, &w2, x[13], y[ 7]);
    word3_muladd(&w1, &w0, &w2, x[14], y[ 6]);
    word3_muladd(&w1, &w0, &w2, x[15], y[ 5]);
    z[20] = w2; w2 = 0;
 
    word3_muladd(&w2, &w1, &w0, x[ 6], y[15]);
    word3_muladd(&w2, &w1, &w0, x[ 7], y[14]);
    word3_muladd(&w2, &w1, &w0, x[ 8], y[13]);
    word3_muladd(&w2, &w1, &w0, x[ 9], y[12]);
    word3_muladd(&w2, &w1, &w0, x[10], y[11]);
    word3_muladd(&w2, &w1, &w0, x[11], y[10]);
    word3_muladd(&w2, &w1, &w0, x[12], y[ 9]);
    word3_muladd(&w2, &w1, &w0, x[13], y[ 8]);
    word3_muladd(&w2, &w1, &w0, x[14], y[ 7]);
    word3_muladd(&w2, &w1, &w0, x[15], y[ 6]);
    z[21] = w0; w0 = 0;
 
    word3_muladd(&w0, &w2, &w1, x[ 7], y[15]);
    word3_muladd(&w0, &w2, &w1, x[ 8], y[14]);
    word3_muladd(&w0, &w2, &w1, x[ 9], y[13]);
    word3_muladd(&w0, &w2, &w1, x[10], y[12]);
    word3_muladd(&w0, &w2, &w1, x[11], y[11]);
    word3_muladd(&w0, &w2, &w1, x[12], y[10]);
    word3_muladd(&w0, &w2, &w1, x[13], y[ 9]);
    word3_muladd(&w0, &w2, &w1, x[14], y[ 8]);
    word3_muladd(&w0, &w2, &w1, x[15], y[ 7]);
    z[22] = w1; w1 = 0;
 
    word3_muladd(&w1, &w0, &w2, x[ 8], y[15]);
    word3_muladd(&w1, &w0, &w2, x[ 9], y[14]);
    word3_muladd(&w1, &w0, &w2, x[10], y[13]);
    word3_muladd(&w1, &w0, &w2, x[11], y[12]);
    word3_muladd(&w1, &w0, &w2, x[12], y[11]);
    word3_muladd(&w1, &w0, &w2, x[13], y[10]);
    word3_muladd(&w1, &w0, &w2, x[14], y[ 9]);
    word3_muladd(&w1, &w0, &w2, x[15], y[ 8]);
    z[23] = w2; w2 = 0;
 
    word3_muladd(&w2, &w1, &w0, x[ 9], y[15]);
    word3_muladd(&w2, &w1, &w0, x[10], y[14]);

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ Altivec32x4

◆ Altivec64x2

◆ Altivec8x16

◆ Blake2b

◆ byte

◆ CertificatePathStatusCodes

◆ EC_Domain_Params

◆ fe

◆ gf2m

◆ InitializationVector

◆ Integrity_Failure

◆ lock_guard_type

◆ MAC

◆ mutex_type

◆ PK_KA_Key

◆ PKCS8_PrivateKey

◆ poly

◆ recursive_mutex_type

◆ RNG

◆ S2K

◆ s32bit

◆ secure_deque

◆ secure_vector

◆ SecureVector

◆ SHA_1

◆ SM2_Encryption_PrivateKey

◆ SM2_Encryption_PublicKey

◆ SM2_Signature_PrivateKey

◆ SM2_Signature_PublicKey

◆ SymmetricKey

◆ Transform_Filter

◆ Transformation_Filter

◆ u16bit

◆ u32bit

◆ u64bit

◆ wots_keysig_t

◆ X25519_PrivateKey

◆ X25519_PublicKey

◆ X509_PublicKey

◆ X509_Time

Enumeration Type Documentation

◆ anonymous enum

◆ ASN1_Tag

◆ Certificate_Status_Code

◆ Character_Set

◆ Cipher_Dir

◆ CRL_Code

◆ Decoder_Checking

◆ DL_Group_Source

◆ EC_Group_Encoding

◆ EC_Group_Source

◆ ECIES_Flags

◆ ErrorType

◆ Key_Constraints

◆ Newhope_Mode

◆ Newhope_Params

◆ Signature_Format

◆ TPM_Storage_Type

◆ Usage_Type

◆ X509_Encoding

Function Documentation

◆ abs()

◆ allocate_memory()

◆ almost_montgomery_inverse()

◆ aont_package()

◆ aont_unpackage()

◆ argon2()

◆ argon2_check_pwhash()

◆ argon2_generate_pwhash()

◆ asn1_class_to_string()

◆ asn1_tag_to_string()

◆ assertion_failure()