Botan Namespace Reference

Namespaces
	ASN1
	Camellia_F
	Cert_Extension
	Charset
	CryptoBox
	CT
	FPE
	HTTP
	KeyPair
	OCSP
	OIDS
	OS
	PEM_Code
	PK_Ops
	PKCS11
	PKCS8
	PKIX
	SHA1_F
	SHA1_SSE2_F
	SHA2_32
	SHA2_64
	stlCompatibilityDetails
	TLS
	X509

Classes
class	Adler32
class	AEAD_Filter
class	AEAD_Mode
class	AES_128
class	AES_192
class	AES_256
struct	Algorithm_Not_Found
class	AlgorithmIdentifier
class	AlternativeName
class	ANSI_X919_MAC
class	ANSI_X923_Padding
class	ASN1_Object
class	ASN1_String
class	Atomic
class	Attribute
class	AutoSeeded_RNG
class	Base64_Decoder
class	Base64_Encoder
struct	BER_Bad_Tag
class	BER_Decoder
struct	BER_Decoding_Error
class	BER_Object
class	BigInt
struct	BitBucket
class	Blake2b
class	Blinded_Point_Multiply
class	Blinder
class	Block_Cipher_Fixed_Params
class	BlockCipher
class	BlockCipherModePaddingMethod
class	Blowfish
class	Buffered_Computation
class	Buffered_Filter
class	Bzip2_Compression
class	Bzip2_Decompression
struct	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	CFB_Decryption
class	CFB_Encryption
class	CFB_Mode
class	ChaCha
class	ChaCha20Poly1305_Decryption
class	ChaCha20Poly1305_Encryption
class	ChaCha20Poly1305_Mode
class	Chain
class	Cipher_Mode
class	Cipher_Mode_Filter
class	CMAC
class	Comb4P
class	Compression_Algorithm
class	Compression_Alloc_Info
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	Darwin_SecRandom
class	Data_Store
class	DataSink
class	DataSink_Stream
class	DataSource
class	DataSource_Memory
class	DataSource_Stream
struct	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	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
struct	Encoding_Error
class	Entropy_Source
class	Entropy_Sources
class	ESP_Padding
class	Exception
class	Extensions
class	Fanout_Filter
class	File_Descriptor_Source
class	Filter
class	Fixed_Base_Power_Mod
class	Fixed_Exponent_Power_Mod
class	Fixed_Window_Exponentiator
class	Fork
class	GCM_Decryption
class	GCM_Encryption
class	GCM_Mode
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	Hash_Filter
class	HashFunction
class	Hex_Decoder
class	Hex_Encoder
class	HKDF
class	HKDF_Expand
class	HKDF_Extract
class	HMAC
class	HMAC_DRBG
class	IDEA
struct	Illegal_Point
struct	Illegal_Transformation
class	Integer_Overflow_Detected
struct	Integrity_Failure
class	Intel_Rdrand
class	Intel_Rdseed
struct	Internal_Error
struct	Invalid_Algorithm_Name
class	Invalid_Argument
struct	Invalid_IV_Length
struct	Invalid_Key_Length
struct	Invalid_OID
struct	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	Keyed_Filter
class	Lion
struct	Lookup_Error
class	LZMA_Compression
class	LZMA_Decompression
class	MAC_Filter
class	McEliece_PrivateKey
class	McEliece_PublicKey
class	MD4
class	MD5
class	MDx_HashFunction
class	MessageAuthenticationCode
class	MISTY1
class	mlock_allocator
class	Modular_Exponentiator
class	Modular_Reducer
class	Montgomery_Exponentiator
class	NameConstraints
	Name Constraints. More...
class	newhope_poly
struct	No_Filesystem_Access
struct	No_Provider_Found
class	Noekeon
struct	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	OpenSSL_Error
class	Output_Buffers
class	Parallel
class	Path_Validation_Restrictions
class	Path_Validation_Result
class	PBKDF
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
struct	PKCS8_Exception
class	PointGFp
struct	Policy_Violation
class	Poly1305
struct	polyn_gf2m
class	Power_Mod
class	Private_Key
struct	PRNG_Unseeded
class	ProcWalking_EntropySource
struct	Provider_Not_Found
class	PSSR
class	Public_Key
class	RandomNumberGenerator
class	RC4
class	RDRAND_RNG
class	RFC6979_Nonce_Generator
class	RIPEMD_160
class	RSA_PrivateKey
class	RSA_PublicKey
class	RTSS_Share
class	Salsa20
class	SCAN_Name
class	secure_allocator
class	SecureQueue
class	SEED
struct	Self_Test_Failure
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	SHAKE_128
class	SHAKE_128_Cipher
class	SHAKE_256
class	SIMD_4x32
class	SipHash
class	SIV_Decryption
class	SIV_Encryption
class	SIV_Mode
class	Skein_512
class	SP800_108_Counter
class	SP800_108_Feedback
class	SP800_108_Pipeline
class	SP800_56C
class	SQL_Database
class	Sqlite3_Database
class	SRP6_Server_Session
class	Stateful_RNG
class	Stream_Cipher_Mode
class	Stream_Compression
class	Stream_Decompression
struct	Stream_IO_Error
class	StreamCipher
class	StreamCipher_Filter
class	SymmetricAlgorithm
class	System_RNG
class	Threefish_512
class	Tiger
class	TLS_12_PRF
class	TLS_PRF
class	TPM_Context
class	TPM_Error
class	TPM_PrivateKey
class	TPM_RNG
class	TripleDES
class	Twofish
struct	Unsupported_Argument
class	UUID
class	Whirlpool
class	Win32_CAPI_EntropySource
class	Win32_EntropySource
class	X509_CA
class	X509_Cert_Options
class	X509_Certificate
class	X509_CRL
class	X509_DN
class	X509_Object
class	X509_Time
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_Common_Ops
class	XMSS_WOTS_Parameters
class	XMSS_WOTS_PrivateKey
class	XMSS_WOTS_PublicKey
class	XMSS_WOTS_Signature_Operation
class	XMSS_WOTS_Verification_Operation
class	XTEA
class	XTS_Decryption
class	XTS_Encryption
class	XTS_Mode
class	Zlib_Compression
class	Zlib_Decompression
class	Zlib_Style_Stream

Typedefs
using	byte = std::uint8_t
typedef std::vector< std::set< Certificate_Status_Code > >	CertificatePathStatusCodes
typedef EC_Group	EC_Domain_Params
typedef limb	felem[5]
typedef uint16_t	gf2m
using	InitializationVector = OctetString
typedef uint64_t	limb
typedef MessageAuthenticationCode	MAC
typedef PK_Key_Agreement_Key	PK_KA_Key
typedef Private_Key	PKCS8_PrivateKey
typedef newhope_poly	poly
typedef RandomNumberGenerator	RNG
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 > >
typedef SHA_160	SHA_1
typedef SIMD_4x32	SIMD_32
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 uint8_t	u8
typedef donna128	uint128_t
typedef std::vector< secure_vector< uint8_t > >	wots_keysig_t
typedef Public_Key	X509_PublicKey

Enumerations
enum	ASN1_Tag {   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, BMP_STRING = 0x1E, UTC_TIME = 0x17, GENERALIZED_TIME = 0x18,   UTC_OR_GENERALIZED_TIME = 0x19, NO_OBJECT = 0xFF00, DIRECTORY_STRING = 0xFF01 }
enum	blake2b_constant { BLAKE2B_BLOCKBYTES = 128, BLAKE2B_OUTBYTES = 64, BLAKE2B_IVU64COUNT = 8 }
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_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::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::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::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::CERT_IS_REVOKED = 5000,   Certificate_Status_Code::CRL_BAD_SIGNATURE = 5001, Certificate_Status_Code::SIGNATURE_ERROR = 5002, Certificate_Status_Code::CERT_PUBKEY_INVALID = 5003 }
enum	Character_Set { LOCAL_CHARSET, UCS2_CHARSET, UTF8_CHARSET, LATIN1_CHARSET }
enum	Cipher_Dir { ENCRYPTION, DECRYPTION }
enum	CRL_Code {   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, AA_COMPROMISE = 10, DELETE_CRL_ENTRY = 0xFF00, OCSP_GOOD = 0xFF01,   OCSP_UNKNOWN = 0xFF02 }
enum	Decoder_Checking { NONE, IGNORE_WS, FULL_CHECK }
enum	EC_Group_Encoding { EC_DOMPAR_ENC_EXPLICIT = 0, EC_DOMPAR_ENC_IMPLICITCA = 1, EC_DOMPAR_ENC_OID = 2 }
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	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, 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 }
enum	X509_Encoding { RAW_BER, PEM }

Functions
BigInt	abs (const BigInt &n)
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	assertion_failure (const char *expr_str, const char *assertion_made, const char *func, const char *file, int line)
size_t	base64_decode (uint8_t output[], const char input[], 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)
size_t	base64_encode (char out[], const uint8_t in[], size_t input_length, size_t &input_consumed, bool final_inputs)
template<typename Alloc >
std::string	base64_encode (const std::vector< uint8_t, Alloc > &input)
std::string	base64_encode (const uint8_t input[], size_t input_length)
size_t	base64_encode_max_output (size_t input_length)
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[], const word y[], size_t 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_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_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])
word	bigint_divop (word n1, word n0, word d)
void	bigint_linmul2 (word x[], size_t x_size, word y)
void	bigint_linmul3 (word z[], const word x[], size_t x_size, word y)
word	bigint_modop (word n1, word n0, word d)
void	bigint_monty_mul (BigInt &z, const BigInt &x, const BigInt &y, const word p[], size_t p_size, word p_dash, word workspace[])
void	bigint_monty_redc (word z[], const word p[], size_t p_size, word p_dash, word workspace[])
void	bigint_monty_sqr (BigInt &z, const BigInt &x, const word p[], size_t p_size, word p_dash, word workspace[])
void	bigint_mul (BigInt &z, const BigInt &x, const BigInt &y, word workspace[])
void	bigint_shl1 (word x[], size_t x_size, 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, word workspace[], const word x[], size_t x_size, size_t x_sw)
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)
uint32_t	bit_size_to_32bit_size (uint32_t bit_size)
uint32_t	bit_size_to_byte_size (uint32_t bit_size)
class BOTAN_DLL	BOTAN_DEPRECATED ("LibraryInitializer is no longer required") LibraryInitializer
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)
uint64_t	carry_shift (const donna128 &a, size_t shift)
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 BOTAN_DLL	CECPQ1_accept (uint8_t *shared_key, uint8_t *accept_message, const uint8_t *offer_message, RandomNumberGenerator &rng)
void BOTAN_DLL	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 BOTAN_DLL	CECPQ1_offer (uint8_t *offer_message, CECPQ1_key *offer_key_output, RandomNumberGenerator &rng)
template<typename T >
size_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)
size_t	clamp (size_t n, size_t lower_bound, size_t upper_bound)
std::string BOTAN_DLL	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)
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::unique_ptr< Private_Key >	create_private_key (const std::string &alg_name, RandomNumberGenerator &rng, const std::string &params)
BigInt	ct_inverse_mod_odd_modulus (const BigInt &n, const BigInt &mod)
template<typename T >
size_t	ctz (T n)
void	curve25519_basepoint (uint8_t mypublic[32], const uint8_t secret[32])
void BOTAN_DLL	curve25519_donna (uint8_t mypublic[32], const uint8_t secret[32], const uint8_t basepoint[32])
void	curve25519_donna (u8 *mypublic, const u8 *secret, const u8 *basepoint)
gf2m	decode_gf2m (const uint8_t *mem)
void	divide (const BigInt &x, const BigInt &y_arg, BigInt &q, BigInt &r)
size_t	dl_exponent_size (size_t bits)
size_t	dl_work_factor (size_t bits)
secure_vector< uint8_t >	EC2OSP (const PointGFp &point, uint8_t format)
size_t	ecp_work_factor (size_t bits)
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)
secure_vector< gf2m >	find_roots_gf2m_decomp (const polyn_gf2m &polyn, uint32_t code_length)
BigInt	gcd (const BigInt &a, const BigInt &b)
void	gcm_multiply_clmul (uint8_t x[16], const uint8_t H[16])
std::string	generate_bcrypt (const std::string &pass, RandomNumberGenerator &rng, uint16_t work_factor)
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, uint32_t ext_deg, uint32_t code_length, uint32_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_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)
AEAD_Mode *	get_aead (const std::string &algo, Cipher_Dir dir)
BlockCipherModePaddingMethod *	get_bc_pad (const std::string &algo_spec)
BlockCipher *	get_block_cipher (const std::string &algo_spec, const std::string &provider="")
std::vector< std::string >	get_block_cipher_providers (const std::string &algo_spec)
template<typename T >
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, const InitializationVector &iv, Cipher_Dir direction)
Keyed_Filter *	get_cipher (const std::string &algo_spec, const SymmetricKey &key, Cipher_Dir direction)
Cipher_Mode *	get_cipher_mode (const std::string &algo, Cipher_Dir direction)
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)
HashFunction *	get_hash (const std::string &algo_spec, const std::string &provider="")
HashFunction *	get_hash_function (const std::string &algo_spec, const std::string &provider="")
std::vector< std::string >	get_hash_function_providers (const std::string &algo_spec)
KDF *	get_kdf (const std::string &algo_spec)
MessageAuthenticationCode *	get_mac (const std::string &algo_spec, const std::string &provider="")
std::vector< std::string >	get_mac_providers (const std::string &algo_spec)
PBKDF *	get_pbkdf (const std::string &algo_spec, const std::string &provider="")
StreamCipher *	get_stream_cipher (const std::string &algo_spec, const std::string &provider="")
std::vector< std::string >	get_stream_cipher_providers (const std::string &algo_spec)
gf2m	gray_to_lex (gf2m gray)
template<typename T >
size_t	hamming_weight (T n)
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)
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)
BigInt	inverse_mod (const BigInt &n, const BigInt &mod)
std::string	ipv4_to_string (uint32_t ip)
template<typename T >
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)
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)
template<typename T >
size_t	low_bit (T n)
size_t	low_zero_bits (const BigInt &n)
std::unique_ptr< BlockCipher >	make_block_cipher (const std::string &algo_spec, const std::string &provider="")
Compression_Algorithm *	make_compressor (const std::string &name)
Decompression_Algorithm *	make_decompressor (const std::string &name)
std::unique_ptr< HashFunction >	make_hash_function (const std::string &algo_spec, const std::string &provider="")
std::unique_ptr< MessageAuthenticationCode >	make_message_auth (const std::string &algo_spec, const std::string &provider="")
std::unique_ptr< BlockCipher >	make_openssl_block_cipher (const std::string &name)
std::unique_ptr< HashFunction >	make_openssl_hash (const std::string &name)
std::unique_ptr< StreamCipher >	make_stream_cipher (const std::string &algo_spec, const std::string &provider="")
uint16_t	make_uint16 (uint8_t i0, uint8_t i1)
uint32_t	make_uint32 (uint8_t i0, uint8_t i1, uint8_t i2, uint8_t i3)
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, uint32_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)
word	monty_inverse (word input)
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, poly *sk, RandomNumberGenerator &rng, Newhope_Mode mode)
void	newhope_shareda (uint8_t *sharedkey, const poly *sk, const uint8_t *received, Newhope_Mode mode)
void	newhope_sharedb (uint8_t *sharedkey, uint8_t *send, const uint8_t *received, RandomNumberGenerator &rng, Newhope_Mode mode)
BigInt	normalized_montgomery_inverse (const BigInt &a, const BigInt &p)
bool	operator!= (const CRL_Entry &a1, const CRL_Entry &a2)
bool	operator!= (const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)
bool	operator!= (const OID &a, const OID &b)
bool	operator!= (const OctetString &s1, const OctetString &s2)
template<typename T , typename U >
bool	operator!= (const secure_allocator< T > &, const secure_allocator< U > &)
bool	operator!= (const EC_Group &lhs, const EC_Group &rhs)
bool	operator!= (const X509_DN &dn1, const X509_DN &dn2)
bool	operator!= (const CurveGFp &lhs, const CurveGFp &rhs)
bool	operator!= (const PointGFp &lhs, const PointGFp &rhs)
bool	operator!= (const X509_Time &t1, const X509_Time &t2)
bool	operator!= (const X509_Certificate &cert1, const X509_Certificate &cert2)
bool	operator!= (const BigInt &a, const BigInt &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)
donna128	operator* (const donna128 &x, uint64_t y)
BigInt	operator* (const BigInt &x, const BigInt &y)
PointGFp	operator* (const PointGFp &point, const BigInt &scalar)
PointGFp	operator* (const BigInt &scalar, const PointGFp &point)
BigInt	operator+ (const BigInt &x, const BigInt &y)
OID	operator+ (const OID &oid, uint32_t component)
donna128	operator+ (const donna128 &x, const donna128 &y)
donna128	operator+ (const donna128 &x, uint64_t y)
OctetString	operator+ (const OctetString &k1, const OctetString &k2)
PointGFp	operator+ (const PointGFp &lhs, const PointGFp &rhs)
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)
BigInt	operator- (const BigInt &x, const BigInt &y)
PointGFp	operator- (const PointGFp &lhs)
PointGFp	operator- (const PointGFp &lhs, const PointGFp &rhs)
BigInt	operator/ (const BigInt &x, const BigInt &y)
bool	operator< (const OID &a, const OID &b)
bool	operator< (const X509_DN &dn1, const X509_DN &dn2)
bool	operator< (const X509_Time &t1, const X509_Time &t2)
bool	operator< (const BigInt &a, const BigInt &b)
std::ostream &	operator<< (std::ostream &stream, const BigInt &n)
int	operator<< (int fd, Pipe &pipe)
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, const X509_DN &dn)
BOTAN_DLL std::ostream &	operator<< (std::ostream &out, Pipe &pipe)
bool	operator<= (const X509_Time &t1, const X509_Time &t2)
bool	operator<= (const BigInt &a, const BigInt &b)
bool	operator== (const CRL_Entry &a1, const CRL_Entry &a2)
bool	operator== (const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)
bool	operator== (const OctetString &s1, const OctetString &s2)
template<typename T , typename U >
bool	operator== (const secure_allocator< T > &, const secure_allocator< U > &)
bool	operator== (const X509_DN &dn1, const X509_DN &dn2)
bool	operator== (const CurveGFp &lhs, const CurveGFp &rhs)
bool	operator== (const X509_Time &t1, const X509_Time &t2)
bool	operator== (const BigInt &a, const BigInt &b)
bool	operator> (const X509_Time &t1, const X509_Time &t2)
bool	operator> (const BigInt &a, const BigInt &b)
bool	operator>= (const X509_Time &t1, const X509_Time &t2)
bool	operator>= (const BigInt &a, const BigInt &b)
int	operator>> (int fd, Pipe &pipe)
std::istream &	operator>> (std::istream &stream, BigInt &n)
BigInt	operator>> (const BigInt &x, size_t shift)
std::istream &	operator>> (std::istream &in, X509_DN &dn)
BOTAN_DLL std::istream &	operator>> (std::istream &in, Pipe &pipe)
OctetString	operator^ (const OctetString &k1, const OctetString &k2)
template<typename T , typename Alloc , typename Alloc2 >
std::vector< T, Alloc > &	operator^= (std::vector< T, Alloc > &out, const std::vector< 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::vector< std::string >	parse_algorithm_name (const std::string &namex)
std::vector< uint32_t >	parse_asn1_oid (const std::string &oid)
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 &passphrase, const uint8_t salt[], size_t salt_len, size_t iterations, std::chrono::milliseconds msec)
std::vector< uint8_t >	pkcs_hash_id (const std::string &name)
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_p521 ()
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 (unsigned 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)
BigInt	random_safe_prime (RandomNumberGenerator &rng, size_t bits)
std::map< std::string, std::string > BOTAN_DLL	read_cfg (std::istream &is)
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 BOTAN_DLL	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)
template<typename T >
T	rotate_left (T input, size_t rot)
template<typename T >
T	rotate_right (T input, size_t rot)
template<typename T >
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)
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)
template<typename T >
void	set_mem (T *ptr, size_t n, uint8_t val)
template<typename T >
size_t	significant_bytes (T n)
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::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)
std::vector< polyn_gf2m >	syndrome_init (polyn_gf2m const &generator, std::vector< gf2m > const &support, int n)
RandomNumberGenerator &	system_rng ()
uint32_t	timespec_to_u32bit (const std::string &timespec)
std::vector< uint8_t >	to_byte_vector (const std::string &s)
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)
template<typename T >
std::vector< T >	unlock (const secure_vector< T > &in)
template<typename T >
bool	value_exists (const std::vector< T > &vec, const T &val)
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_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)
template<typename T >
void	xor_buf (T out[], const T in[], size_t length)
template<typename T >
void	xor_buf (T out[], const T in[], const 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 uint32_t	CAST_SBOX1 [256]
const uint32_t	CAST_SBOX2 [256]
const uint32_t	CAST_SBOX3 [256]
const uint32_t	CAST_SBOX4 [256]
const uint64_t	DES_FPTAB1 [256]
const uint64_t	DES_FPTAB2 [256]
const uint64_t	DES_IPTAB1 [256]
const uint64_t	DES_IPTAB2 [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 size_t	MP_WORD_BITS = BOTAN_MP_WORD_BITS
const word	MP_WORD_MASK = ~static_cast<word>(0)
const word	MP_WORD_MAX = MP_WORD_MASK
const word	MP_WORD_TOP_BIT = static_cast<word>(1) << (8*sizeof(word) - 1)
const size_t	PRIME_TABLE_SIZE = 6541
const uint16_t BOTAN_DLL	PRIMES []

Detailed Description

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.

XMSS WOTS Addressed Private Key (C) 2016 Matthias Gierlings

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

XMSS WOTS Addressed Public Key (C) 2016 Matthias Gierlings

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

XMSS WOTS Common Ops Operations shared by XMSS WOTS signature generation and verification operations.

(C) 2016 Matthias Gierlings

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

XMSS WOTS Common Operations (C) 2016 Matthias Gierlings

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

XMSS WOTS Signature Operation Signature generation operation for Winternitz One Time Signatures for use in Extended Hash-Based Signatures (XMSS).

This operation is not intended for stand-alone use and thus not registered in the Botan algorithm registry.

(C) 2016 Matthias Gierlings

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

XMSS WOTS Signature Operation (C) 2016 Matthias Gierlings

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

XMSS WOTS Verification Operation Provides signature verification capabilities for Winternitz One Time Signatures used in Extended Hash-Based Signatures (XMSS).

This operation is not intended for stand-alone use and thus not registered in the Botan algorithm registry.

(C) 2016 Matthias Gierlings

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

XMSS_WOTS_Verification_Operation.h (C) 2016 Matthias Gierlings

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

The primary namespace for the botan library

Typedef Documentation

byte

using Botan::byte = typedef std::uint8_t

Definition at line 36 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 151 of file ec_group.h.

felem

typedef limb Botan::felem[5]

Definition at line 40 of file donna.cpp.

gf2m

typedef uint16_t Botan::gf2m

Definition at line 20 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 141 of file symkey.h.

limb

typedef uint64_t Botan::limb

Definition at line 39 of file donna.cpp.

MAC

typedef MessageAuthenticationCode Botan::MAC

Definition at line 143 of file mac.h.

PK_KA_Key

typedef PK_Key_Agreement_Key Botan::PK_KA_Key

Definition at line 289 of file pk_keys.h.

PKCS8_PrivateKey

typedef Private_Key Botan::PKCS8_PrivateKey

Definition at line 291 of file pk_keys.h.

poly

typedef newhope_poly Botan::poly

Definition at line 19 of file newhope.cpp.

RNG

typedef RandomNumberGenerator Botan::RNG

Convenience typedef

Definition at line 174 of file rng.h.

s32bit

using Botan::s32bit = typedef std::int32_t

Definition at line 40 of file types.h.

secure_deque

template<typename T >

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

Definition at line 122 of file secmem.h.

secure_vector

template<typename T >

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

Definition at line 121 of file secmem.h.

SHA_1

typedef SHA_160 Botan::SHA_1

Definition at line 55 of file sha160.h.

SIMD_32

typedef SIMD_4x32 Botan::SIMD_32

Definition at line 650 of file simd_32.h.

SymmetricKey

using Botan::SymmetricKey = typedef OctetString

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

Definition at line 136 of file symkey.h.

Transform_Filter

typedef Cipher_Mode_Filter Botan::Transform_Filter

Definition at line 67 of file cipher_filter.h.

Transformation_Filter

typedef Transform_Filter Botan::Transformation_Filter

Definition at line 68 of file cipher_filter.h.

u16bit

using Botan::u16bit = typedef std::uint16_t

Definition at line 37 of file types.h.

u32bit

using Botan::u32bit = typedef std::uint32_t

Definition at line 38 of file types.h.

u64bit

using Botan::u64bit = typedef std::uint64_t

Definition at line 39 of file types.h.

u8

typedef uint8_t Botan::u8

Definition at line 38 of file donna.cpp.

uint128_t

typedef donna128 Botan::uint128_t

Definition at line 63 of file donna.cpp.

wots_keysig_t

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

Definition at line 20 of file xmss_common_ops.h.

X509_PublicKey

typedef Public_Key Botan::X509_PublicKey

Definition at line 290 of file pk_keys.h.

Enumeration Type Documentation

ASN1_Tag

enum Botan::ASN1_Tag

ASN.1 Type and Class Tags

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
BMP_STRING
UTC_TIME
GENERALIZED_TIME
UTC_OR_GENERALIZED_TIME
NO_OBJECT
DIRECTORY_STRING

Definition at line 22 of file asn1_obj.h.

              {
   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,
   BMP_STRING       = 0x1E,

   UTC_TIME                = 0x17,
   GENERALIZED_TIME        = 0x18,
   UTC_OR_GENERALIZED_TIME = 0x19,

   NO_OBJECT        = 0xFF00,
   DIRECTORY_STRING = 0xFF01
};

blake2b_constant

enum Botan::blake2b_constant

Enumerator
BLAKE2B_BLOCKBYTES
BLAKE2B_OUTBYTES
BLAKE2B_IVU64COUNT

Definition at line 17 of file blake2b.h.

                      {
  BLAKE2B_BLOCKBYTES = 128,
  BLAKE2B_OUTBYTES   = 64,
  BLAKE2B_IVU64COUNT = 8
};

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_ERROR_STATUS
SIGNATURE_METHOD_TOO_WEAK
UNTRUSTED_HASH
NO_REVOCATION_DATA
CERT_NOT_YET_VALID
CERT_HAS_EXPIRED
OCSP_NOT_YET_VALID
OCSP_HAS_EXPIRED
CRL_NOT_YET_VALID
CRL_HAS_EXPIRED
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
OCSP_SIGNATURE_ERROR
OCSP_ISSUER_NOT_FOUND
OCSP_RESPONSE_MISSING_KEYUSAGE
OCSP_RESPONSE_INVALID
CERT_IS_REVOKED
CRL_BAD_SIGNATURE
SIGNATURE_ERROR
CERT_PUBKEY_INVALID

Definition at line 18 of file cert_status.h.

                                   {
   OK = 0,
   VERIFIED = 0,

   // Revocation status
   OCSP_RESPONSE_GOOD = 1,
   OCSP_SIGNATURE_OK = 2,
   VALID_CRL_CHECKED = 3,
   OCSP_NO_HTTP = 4,

   // Errors
   FIRST_ERROR_STATUS = 1000,

   SIGNATURE_METHOD_TOO_WEAK = 1000,
   UNTRUSTED_HASH = 1001,
   NO_REVOCATION_DATA = 1002,

   // 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,

   // 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,
   OCSP_SIGNATURE_ERROR = 4501,
   OCSP_ISSUER_NOT_FOUND = 4502,
   OCSP_RESPONSE_MISSING_KEYUSAGE = 4503,
   OCSP_RESPONSE_INVALID = 4504,

   // Hard failures
   CERT_IS_REVOKED = 5000,
   CRL_BAD_SIGNATURE = 5001,
   SIGNATURE_ERROR = 5002,
   CERT_PUBKEY_INVALID = 5003,
};

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 19 of file charset.h.

                   {
   LOCAL_CHARSET,
   UCS2_CHARSET,
   UTF8_CHARSET,
   LATIN1_CHARSET
};

Cipher_Dir

enum Botan::Cipher_Dir

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

Enumerator
ENCRYPTION
DECRYPTION

Definition at line 212 of file cipher_mode.h.

{ ENCRYPTION, DECRYPTION };

CRL_Code

enum Botan::CRL_Code

X.509v2 CRL Reason Code.

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

Definition at line 20 of file crl_ent.h.

              {
   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,
   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 179 of file filter.h.

{ NONE, IGNORE_WS, FULL_CHECK };

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 22 of file ec_group.h.

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

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 28 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
   };

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 21 of file key_constraint.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 52 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
CECPQ1_OFFER_BYTES
CECPQ1_ACCEPT_BYTES
CECPQ1_SHARED_KEY_BYTES

Definition at line 33 of file newhope.h.

                    {
   NEWHOPE_SENDABYTES = 1824,
   NEWHOPE_SENDBBYTES = 2048,

   NEWHOPE_OFFER_BYTES  = 1824,
   NEWHOPE_ACCEPT_BYTES = 2048,
   NEWHOPE_SHARED_KEY_BYTES = 32,

   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 29 of file pubkey.h.

{ IEEE_1363, DER_SEQUENCE };

TPM_Storage_Type

enum Botan::TPM_Storage_Type

strong

Enumerator
User
System

Definition at line 100 of file tpm.h.

{ User, System };

Usage_Type

enum Botan::Usage_Type

strong

Enumerator
UNSPECIFIED
TLS_SERVER_AUTH
TLS_CLIENT_AUTH
CERTIFICATE_AUTHORITY
OCSP_RESPONDER

Definition at line 24 of file x509cert.h.

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

X509_Encoding

enum Botan::X509_Encoding

The two types of X509 encoding supported by Botan.

Enumerator
RAW_BER
PEM

Definition at line 21 of file x509_key.h.

{ RAW_BER, PEM };

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 55 of file numthry.h.

References Botan::BigInt::abs(), almost_montgomery_inverse(), ct_inverse_mod_odd_modulus(), gcd(), inverse_mod(), is_prime(), jacobi(), lcm(), low_zero_bits(), monty_inverse(), normalized_montgomery_inverse(), power_mod(), ressol(), and square().

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

{ return n.abs(); }

almost_montgomery_inverse()

size_t BOTAN_DLL 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 90 of file numthry.cpp.

References Botan::BigInt::is_even().

Referenced by abs(), and 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 = r - p;
      }

   result = p - r;

   return k;
   }

aont_package()

void BOTAN_DLL 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 16 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().

   {
   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_DLL 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 69 of file package.cpp.

References Botan::BlockCipher::block_size(), BOTAN_ASSERT_EQUAL, copy_mem(), Botan::BlockCipher::encrypt(), get_byte(), 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");
   }

assertion_failure()

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

Called when an assertion fails

Definition at line 13 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 Exception(format.str());
   }

base64_decode() [1/5]

size_t BOTAN_DLL 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 100 of file base64.cpp.

References clear_mem().

Referenced by base64_decode(), base64_encode(), check_passhash9(), Botan::PEM_Code::decode(), Botan::Base64_Decoder::end_msg(), and Botan::Base64_Decoder::write().

   {
   /*
   * Base64 Decoder Lookup Table
   * Warning: assumes ASCII encodings
   */
   static const uint8_t BASE64_TO_BIN[256] = {
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80,
      0x80, 0xFF, 0xFF, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0xFF, 0xFF, 0x3F, 0x34, 0x35,
      0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0xFF, 0xFF,
      0xFF, 0x81, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04,
      0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
      0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
      0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1A, 0x1B, 0x1C,
      0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
      0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
      0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };

   uint8_t* out_ptr = output;
   uint8_t decode_buf[4];
   size_t decode_buf_pos = 0;
   size_t final_truncate = 0;

   clear_mem(output, input_length * 3 / 4);

   for(size_t i = 0; i != input_length; ++i)
      {
      const uint8_t bin = BASE64_TO_BIN[static_cast<uint8_t>(input[i])];

      if(bin <= 0x3F)
         {
         decode_buf[decode_buf_pos] = bin;
         decode_buf_pos += 1;
         }
      else if(!(bin == 0x81 || (bin == 0x80 && ignore_ws)))
         {
         std::string bad_char(1, input[i]);
         if(bad_char == "\t")
           bad_char = "\\t";
         else if(bad_char == "\n")
           bad_char = "\\n";
         else if(bad_char == "\r")
           bad_char = "\\r";

         throw Invalid_Argument(
           std::string("base64_decode: invalid base64 character '") +
           bad_char + "'");
         }

      /*
      * 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 != 4; ++j)
               decode_buf[j] = 0;
            final_truncate = (4 - decode_buf_pos);
            decode_buf_pos = 4;
            }
         }

      if(decode_buf_pos == 4)
         {
         out_ptr[0] = (decode_buf[0] << 2) | (decode_buf[1] >> 4);
         out_ptr[1] = (decode_buf[1] << 4) | (decode_buf[2] >> 2);
         out_ptr[2] = (decode_buf[2] << 6) | decode_buf[3];

         out_ptr += 3;
         decode_buf_pos = 0;
         input_consumed = i+1;
         }
      }

   while(input_consumed < input_length &&
         BASE64_TO_BIN[static_cast<uint8_t>(input[input_consumed])] == 0x80)
      {
      ++input_consumed;
      }

   size_t written = (out_ptr - output) - final_truncate;

   return written;
   }

base64_decode() [2/5]

size_t BOTAN_DLL 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 207 of file base64.cpp.

References base64_decode().

   {
   size_t consumed = 0;
   size_t written = base64_decode(output, input, input_length,
                                  consumed, true, ignore_ws);

   if(consumed != input_length)
      throw Invalid_Argument("base64_decode: input did not have full bytes");

   return written;
   }

base64_decode() [3/5]

size_t BOTAN_DLL 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 222 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_DLL 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 229 of file base64.cpp.

References base64_decode(), and base64_decode_max_output().

   {
   const size_t output_length = base64_decode_max_output(input_length);
   secure_vector<uint8_t> bin(output_length);

   size_t written = base64_decode(bin.data(),
                                  input,
                                  input_length,
                                  ignore_ws);

   bin.resize(written);
   return bin;
   }

base64_decode() [5/5]

secure_vector< uint8_t > BOTAN_DLL 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 245 of file base64.cpp.

References base64_decode().

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

base64_decode_max_output()

size_t BOTAN_DLL 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 256 of file base64.cpp.

References round_up().

Referenced by base64_decode(), and base64_encode().

   {
   return (round_up(input_length, 4) * 3) / 4;
   }

base64_encode() [1/3]

size_t BOTAN_DLL 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 35 of file base64.cpp.

Referenced by Botan::OCSP::Request::base64_encode(), base64_encode(), Botan::Base64_Encoder::Base64_Encoder(), Botan::PEM_Code::encode(), and generate_passhash9().

   {
   input_consumed = 0;

   size_t input_remaining = input_length;
   size_t output_produced = 0;

   while(input_remaining >= 3)
      {
      do_base64_encode(out + output_produced, in + input_consumed);

      input_consumed += 3;
      output_produced += 4;
      input_remaining -= 3;
      }

   if(final_inputs && input_remaining)
      {
      uint8_t remainder[3] = { 0 };
      for(size_t i = 0; i != input_remaining; ++i)
         remainder[i] = in[input_consumed + i];

      do_base64_encode(out + output_produced, remainder);

      size_t empty_bits = 8 * (3 - input_remaining);
      size_t index = output_produced + 4 - 1;
      while(empty_bits >= 8)
         {
         out[index--] = '=';
         empty_bits -= 6;
         }

      input_consumed += input_remaining;
      output_produced += 4;
      }

   return output_produced;
   }

base64_encode() [2/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_decode(), base64_decode_max_output(), base64_encode(), and base64_encode_max_output().

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

base64_encode() [3/3]

std::string BOTAN_DLL 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 78 of file base64.cpp.

References base64_encode(), base64_encode_max_output(), and BOTAN_ASSERT_EQUAL.

   {
   const size_t output_length = base64_encode_max_output(input_length);
   std::string output(output_length, 0);

   size_t consumed = 0;
   size_t produced = 0;
   
   if (output_length > 0)
   {
      produced = base64_encode(&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;
   }

base64_encode_max_output()

size_t BOTAN_DLL 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 251 of file base64.cpp.

References round_up().

Referenced by base64_encode().

   {
   return (round_up(input_length, 3) / 3) * 4;
   }

bigint_add2()

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

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 138 of file mp_core.cpp.

References bigint_add2_nc().

Referenced by mul_add(), Botan::BigInt::operator+=(), and Botan::BigInt::operator-=().

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

bigint_add2_nc()

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

Two operand addition with carry out

Definition at line 90 of file mp_core.cpp.

References BOTAN_ASSERT, 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
	)

Three operand addition

Definition at line 147 of file mp_core.cpp.

References bigint_add3_nc().

Referenced by operator+(), and operator-().

   {
   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
	)

Three operand addition with carry out

Definition at line 113 of file mp_core.cpp.

References word8_add3(), and word_add().

Referenced by bigint_add3(), 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
	)

Compare x and y

Definition at line 378 of file mp_core.cpp.

Referenced by Botan::BigInt::cmp(), operator+(), Botan::BigInt::operator+=(), operator-(), and Botan::BigInt::operator-=().

   {
   if(x_size < y_size) { return (-bigint_cmp(y, y_size, x, x_size)); }

   while(x_size > y_size)
      {
      if(x[x_size-1])
         return 1;
      x_size--;
      }

   for(size_t i = x_size; i > 0; --i)
      {
      if(x[i-1] > y[i-1])
         return 1;
      if(x[i-1] < y[i-1])
         return -1;
      }

   return 0;
   }

bigint_cnd_abs()

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

Definition at line 75 of file mp_core.cpp.

References Botan::CT::expand_mask(), Botan::CT::select(), and word_add().

Referenced by ct_inverse_mod_odd_modulus().

   {
   const word mask = CT::expand_mask(cnd);

   word carry = mask & 1;
   for(size_t i = 0; i != size; ++i)
      {
      const word z = word_add(~x[i], 0, &carry);
      x[i] = CT::select(mask, z, x[i]);
      }
   }

bigint_cnd_add()

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

Definition at line 39 of file mp_core.cpp.

References Botan::CT::expand_mask(), Botan::CT::select(), and word_add().

Referenced by ct_inverse_mod_odd_modulus().

   {
   const word mask = CT::expand_mask(cnd);

   word carry = 0;
   for(size_t i = 0; i != size; ++i)
      {
      /*
      Here we are relying on asm version of word_add being
      a single addcl or equivalent. Fix this.
      */
      const word z = word_add(x[i], y[i], &carry);
      x[i] = CT::select(mask, z, x[i]);
      }

   return carry & mask;
   }

bigint_cnd_sub()

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

Definition at line 61 of file mp_core.cpp.

References Botan::CT::expand_mask(), Botan::CT::select(), and word_sub().

Referenced by ct_inverse_mod_odd_modulus().

   {
   const word mask = CT::expand_mask(cnd);

   word carry = 0;
   for(size_t i = 0; i != size; ++i)
      {
      const word z = word_sub(x[i], y[i], &carry);
      x[i] = CT::select(mask, z, x[i]);
      }

   return carry & mask;
   }

bigint_cnd_swap()

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

Definition at line 22 of file mp_core.cpp.

References Botan::CT::expand_mask(), and Botan::CT::select().

Referenced by ct_inverse_mod_odd_modulus().

   {
   const word mask = CT::expand_mask(cnd);

   for(size_t i = 0; i != size; ++i)
      {
      word a = x[i];
      word b = y[i];
      x[i] = CT::select(mask, b, a);
      y[i] = CT::select(mask, 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]);
   word3_muladd(&w2, &w1, &w0, x[11], y[13]);
   word3_muladd(&w2, &w1, &w0, x[12], y[12]);
   word3_muladd(&w2, &w1, &w0, x[13], y[11]);
   word3_muladd(&w2, &w1, &w0, x[14], y[10]);
   word3_muladd(&w2, &w1, &w0, x[15], y[ 9]);
   z[24] = w0; w0 = 0;

   word3_muladd(&w0, &w2, &w1, x[10], y[15]);
   word3_muladd(&w0, &w2, &w1, x[11], y[14]);
   word3_muladd(&w0, &w2, &w1, x[12], y[13]);
   word3_muladd(&w0, &w2, &w1, x[13], y[12]);
   word3_muladd(&w0, &w2, &w1, x[14], y[11]);
   word3_muladd(&w0, &w2, &w1, x[15], y[10]);
   z[25] = w1; w1 = 0;

   word3_muladd(&w1, &w0, &w2, x[11], y[15]);
   word3_muladd(&w1, &w0, &w2, x[12], y[14]);
   word3_muladd(&w1, &w0, &w2, x[13], y[13]);
   word3_muladd(&w1, &w0, &w2, x[14], y[12]);
   word3_muladd(&w1, &w0, &w2, x[15], y[11]);
   z[26] = w2; w2 = 0;

   word3_muladd(&w2, &w1, &w0, x[12], y[15]);
   word3_muladd(&w2, &w1, &w0, x[13], y[14]);
   word3_muladd(&w2, &w1, &w0, x[14], y[13]);
   word3_muladd(&w2, &w1, &w0, x[15], y[12]);
   z[27] = w0; w0 = 0;

   word3_muladd(&w0, &w2, &w1, x[13], y[15]);
   word3_muladd(&w0, &w2, &w1, x[14], y[14]);
   word3_muladd(&w0, &w2, &w1, x[15], y[13]);
   z[28] = w1; w1 = 0;

   word3_muladd(&w1, &w0, &w2, x[14], y[15]);
   word3_muladd(&w1, &w0, &w2, x[15], y[14]);
   z[29] = w2; w2 = 0;

   word3_muladd(&w2, &w1, &w0, x[15], y[15]);
   z[30] = w0;
   z[31] = w1;
   }

bigint_comba_mul4()

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

Definition at line 50 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[ 1], y[ 3]);
   word3_muladd(&w0, &w2, &w1, x[ 2], y[ 2]);
   word3_muladd(&w0, &w2, &w1, x[ 3], y[ 1]);
   z[ 4] = w1; w1 = 0;

   word3_muladd(&w1, &w0, &w2, x[ 2], y[ 3]);
   word3_muladd(&w1, &w0, &w2, x[ 3], y[ 2]);
   z[ 5] = w2; w2 = 0;

   word3_muladd(&w2, &w1, &w0, x[ 3], y[ 3]);
   z[ 6] = w0;
   z[ 7] = w1;
   }

bigint_comba_mul6()

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

Definition at line 141 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[ 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]);
   z[ 6] = w0; w0 = 0;

   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]);
   z[ 7] = w1; w1 = 0;

   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]);
   z[ 8] = w2; w2 = 0;

   word3_muladd(&w2, &w1, &w0, x[ 4], y[ 5]);
   word3_muladd(&w2, &w1, &w0, x[ 5], y[ 4]);
   z[ 9] = w0; w0 = 0;

   word3_muladd(&w0, &w2, &w1, x[ 5], y[ 5]);
   z[10] = w1;
   z[11] = w2;
   }

bigint_comba_mul8()

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

Definition at line 283 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[ 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]);
   z[ 8] = w2; w2 = 0;

   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]);
   z[ 9] = w0; w0 = 0;

   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]);
   z[10] = w1; w1 = 0;

   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]);
   z[11] = w2; w2 = 0;

   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]);
   z[12] = w0; w0 = 0;

   word3_muladd(&w0, &w2, &w1, x[ 6], y[ 7]);
   word3_muladd(&w0, &w2, &w1, x[ 7], y[ 6]);
   z[13] = w1; w1 = 0;

   word3_muladd(&w1, &w0, &w2, x[ 7], y[ 7]);
   z[14] = w2;
   z[15] = w0;
   }

bigint_comba_mul9()

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

Definition at line 474 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[ 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]);
   z[ 9] = w0; w0 = 0;

   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]);
   z[10] = w1; w1 = 0;

   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]);
   z[11] = w2; w2 = 0;

   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]);
   z[12] = w0; w0 = 0;

   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]);
   z[13] = w1; w1 = 0;

   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]);
   z[14] = w2; w2 = 0;

   word3_muladd(&w2, &w1, &w0, x[ 7], y[ 8]);
   word3_muladd(&w2, &w1, &w0, x[ 8], y[ 7]);
   z[15] = w0; w0 = 0;

   word3_muladd(&w0, &w2, &w1, x[ 8], y[ 8]);
   z[16] = w1;
   z[17] = w2;
   }

bigint_comba_sqr16()

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

Definition at line 598 of file mp_comba.cpp.

References word3_muladd(), and word3_muladd_2().

Referenced by bigint_sqr().

   {
   word w2 = 0, w1 = 0, w0 = 0;

   word3_muladd  (&w2, &w1, &w0, x[ 0], x[ 0]);
   z[ 0] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 1]);
   z[ 1] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[ 2]);
   word3_muladd  (&w1, &w0, &w2, x[ 1], x[ 1]);
   z[ 2] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 0], x[ 3]);
   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[ 2]);
   z[ 3] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 4]);
   word3_muladd_2(&w0, &w2, &w1, x[ 1], x[ 3]);
   word3_muladd  (&w0, &w2, &w1, x[ 2], x[ 2]);
   z[ 4] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[ 5]);
   word3_muladd_2(&w1, &w0, &w2, x[ 1], x[ 4]);
   word3_muladd_2(&w1, &w0, &w2, x[ 2], x[ 3]);
   z[ 5] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 0], x[ 6]);
   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[ 5]);
   word3_muladd_2(&w2, &w1, &w0, x[ 2], x[ 4]);
   word3_muladd  (&w2, &w1, &w0, x[ 3], x[ 3]);
   z[ 6] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 7]);
   word3_muladd_2(&w0, &w2, &w1, x[ 1], x[ 6]);
   word3_muladd_2(&w0, &w2, &w1, x[ 2], x[ 5]);
   word3_muladd_2(&w0, &w2, &w1, x[ 3], x[ 4]);
   z[ 7] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[ 8]);
   word3_muladd_2(&w1, &w0, &w2, x[ 1], x[ 7]);
   word3_muladd_2(&w1, &w0, &w2, x[ 2], x[ 6]);
   word3_muladd_2(&w1, &w0, &w2, x[ 3], x[ 5]);
   word3_muladd  (&w1, &w0, &w2, x[ 4], x[ 4]);
   z[ 8] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 0], x[ 9]);
   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[ 8]);
   word3_muladd_2(&w2, &w1, &w0, x[ 2], x[ 7]);
   word3_muladd_2(&w2, &w1, &w0, x[ 3], x[ 6]);
   word3_muladd_2(&w2, &w1, &w0, x[ 4], x[ 5]);
   z[ 9] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[10]);
   word3_muladd_2(&w0, &w2, &w1, x[ 1], x[ 9]);
   word3_muladd_2(&w0, &w2, &w1, x[ 2], x[ 8]);
   word3_muladd_2(&w0, &w2, &w1, x[ 3], x[ 7]);
   word3_muladd_2(&w0, &w2, &w1, x[ 4], x[ 6]);
   word3_muladd  (&w0, &w2, &w1, x[ 5], x[ 5]);
   z[10] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[11]);
   word3_muladd_2(&w1, &w0, &w2, x[ 1], x[10]);
   word3_muladd_2(&w1, &w0, &w2, x[ 2], x[ 9]);
   word3_muladd_2(&w1, &w0, &w2, x[ 3], x[ 8]);
   word3_muladd_2(&w1, &w0, &w2, x[ 4], x[ 7]);
   word3_muladd_2(&w1, &w0, &w2, x[ 5], x[ 6]);
   z[11] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 0], x[12]);
   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[11]);
   word3_muladd_2(&w2, &w1, &w0, x[ 2], x[10]);
   word3_muladd_2(&w2, &w1, &w0, x[ 3], x[ 9]);
   word3_muladd_2(&w2, &w1, &w0, x[ 4], x[ 8]);
   word3_muladd_2(&w2, &w1, &w0, x[ 5], x[ 7]);
   word3_muladd  (&w2, &w1, &w0, x[ 6], x[ 6]);
   z[12] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[13]);
   word3_muladd_2(&w0, &w2, &w1, x[ 1], x[12]);
   word3_muladd_2(&w0, &w2, &w1, x[ 2], x[11]);
   word3_muladd_2(&w0, &w2, &w1, x[ 3], x[10]);
   word3_muladd_2(&w0, &w2, &w1, x[ 4], x[ 9]);
   word3_muladd_2(&w0, &w2, &w1, x[ 5], x[ 8]);
   word3_muladd_2(&w0, &w2, &w1, x[ 6], x[ 7]);
   z[13] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[14]);
   word3_muladd_2(&w1, &w0, &w2, x[ 1], x[13]);
   word3_muladd_2(&w1, &w0, &w2, x[ 2], x[12]);
   word3_muladd_2(&w1, &w0, &w2, x[ 3], x[11]);
   word3_muladd_2(&w1, &w0, &w2, x[ 4], x[10]);
   word3_muladd_2(&w1, &w0, &w2, x[ 5], x[ 9]);
   word3_muladd_2(&w1, &w0, &w2, x[ 6], x[ 8]);
   word3_muladd  (&w1, &w0, &w2, x[ 7], x[ 7]);
   z[14] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 0], x[15]);
   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[14]);
   word3_muladd_2(&w2, &w1, &w0, x[ 2], x[13]);
   word3_muladd_2(&w2, &w1, &w0, x[ 3], x[12]);
   word3_muladd_2(&w2, &w1, &w0, x[ 4], x[11]);
   word3_muladd_2(&w2, &w1, &w0, x[ 5], x[10]);
   word3_muladd_2(&w2, &w1, &w0, x[ 6], x[ 9]);
   word3_muladd_2(&w2, &w1, &w0, x[ 7], x[ 8]);
   z[15] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 1], x[15]);
   word3_muladd_2(&w0, &w2, &w1, x[ 2], x[14]);
   word3_muladd_2(&w0, &w2, &w1, x[ 3], x[13]);
   word3_muladd_2(&w0, &w2, &w1, x[ 4], x[12]);
   word3_muladd_2(&w0, &w2, &w1, x[ 5], x[11]);
   word3_muladd_2(&w0, &w2, &w1, x[ 6], x[10]);
   word3_muladd_2(&w0, &w2, &w1, x[ 7], x[ 9]);
   word3_muladd  (&w0, &w2, &w1, x[ 8], x[ 8]);
   z[16] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 2], x[15]);
   word3_muladd_2(&w1, &w0, &w2, x[ 3], x[14]);
   word3_muladd_2(&w1, &w0, &w2, x[ 4], x[13]);
   word3_muladd_2(&w1, &w0, &w2, x[ 5], x[12]);
   word3_muladd_2(&w1, &w0, &w2, x[ 6], x[11]);
   word3_muladd_2(&w1, &w0, &w2, x[ 7], x[10]);
   word3_muladd_2(&w1, &w0, &w2, x[ 8], x[ 9]);
   z[17] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 3], x[15]);
   word3_muladd_2(&w2, &w1, &w0, x[ 4], x[14]);
   word3_muladd_2(&w2, &w1, &w0, x[ 5], x[13]);
   word3_muladd_2(&w2, &w1, &w0, x[ 6], x[12]);
   word3_muladd_2(&w2, &w1, &w0, x[ 7], x[11]);
   word3_muladd_2(&w2, &w1, &w0, x[ 8], x[10]);
   word3_muladd  (&w2, &w1, &w0, x[ 9], x[ 9]);
   z[18] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 4], x[15]);
   word3_muladd_2(&w0, &w2, &w1, x[ 5], x[14]);
   word3_muladd_2(&w0, &w2, &w1, x[ 6], x[13]);
   word3_muladd_2(&w0, &w2, &w1, x[ 7], x[12]);
   word3_muladd_2(&w0, &w2, &w1, x[ 8], x[11]);
   word3_muladd_2(&w0, &w2, &w1, x[ 9], x[10]);
   z[19] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 5], x[15]);
   word3_muladd_2(&w1, &w0, &w2, x[ 6], x[14]);
   word3_muladd_2(&w1, &w0, &w2, x[ 7], x[13]);
   word3_muladd_2(&w1, &w0, &w2, x[ 8], x[12]);
   word3_muladd_2(&w1, &w0, &w2, x[ 9], x[11]);
   word3_muladd  (&w1, &w0, &w2, x[10], x[10]);
   z[20] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 6], x[15]);
   word3_muladd_2(&w2, &w1, &w0, x[ 7], x[14]);
   word3_muladd_2(&w2, &w1, &w0, x[ 8], x[13]);
   word3_muladd_2(&w2, &w1, &w0, x[ 9], x[12]);
   word3_muladd_2(&w2, &w1, &w0, x[10], x[11]);
   z[21] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 7], x[15]);
   word3_muladd_2(&w0, &w2, &w1, x[ 8], x[14]);
   word3_muladd_2(&w0, &w2, &w1, x[ 9], x[13]);
   word3_muladd_2(&w0, &w2, &w1, x[10], x[12]);
   word3_muladd  (&w0, &w2, &w1, x[11], x[11]);
   z[22] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 8], x[15]);
   word3_muladd_2(&w1, &w0, &w2, x[ 9], x[14]);
   word3_muladd_2(&w1, &w0, &w2, x[10], x[13]);
   word3_muladd_2(&w1, &w0, &w2, x[11], x[12]);
   z[23] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 9], x[15]);
   word3_muladd_2(&w2, &w1, &w0, x[10], x[14]);
   word3_muladd_2(&w2, &w1, &w0, x[11], x[13]);
   word3_muladd  (&w2, &w1, &w0, x[12], x[12]);
   z[24] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[10], x[15]);
   word3_muladd_2(&w0, &w2, &w1, x[11], x[14]);
   word3_muladd_2(&w0, &w2, &w1, x[12], x[13]);
   z[25] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[11], x[15]);
   word3_muladd_2(&w1, &w0, &w2, x[12], x[14]);
   word3_muladd  (&w1, &w0, &w2, x[13], x[13]);
   z[26] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[12], x[15]);
   word3_muladd_2(&w2, &w1, &w0, x[13], x[14]);
   z[27] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[13], x[15]);
   word3_muladd  (&w0, &w2, &w1, x[14], x[14]);
   z[28] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[14], x[15]);
   z[29] = w2; w2 = 0;

   word3_muladd  (&w2, &w1, &w0, x[15], x[15]);
   z[30] = w0;
   z[31] = w1;
   }

bigint_comba_sqr4()

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

Definition at line 17 of file mp_comba.cpp.

References word3_muladd(), and word3_muladd_2().

Referenced by bigint_sqr().

   {
   word w2 = 0, w1 = 0, w0 = 0;

   word3_muladd  (&w2, &w1, &w0, x[ 0], x[ 0]);
   z[ 0] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 1]);
   z[ 1] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[ 2]);
   word3_muladd  (&w1, &w0, &w2, x[ 1], x[ 1]);
   z[ 2] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 0], x[ 3]);
   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[ 2]);
   z[ 3] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 1], x[ 3]);
   word3_muladd  (&w0, &w2, &w1, x[ 2], x[ 2]);
   z[ 4] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 2], x[ 3]);
   z[ 5] = w2; w2 = 0;

   word3_muladd  (&w2, &w1, &w0, x[ 3], x[ 3]);
   z[ 6] = w0;
   z[ 7] = w1;
   }

bigint_comba_sqr6()

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

Definition at line 89 of file mp_comba.cpp.

References word3_muladd(), and word3_muladd_2().

Referenced by bigint_sqr().

   {
   word w2 = 0, w1 = 0, w0 = 0;

   word3_muladd  (&w2, &w1, &w0, x[ 0], x[ 0]);
   z[ 0] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 1]);
   z[ 1] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[ 2]);
   word3_muladd  (&w1, &w0, &w2, x[ 1], x[ 1]);
   z[ 2] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 0], x[ 3]);
   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[ 2]);
   z[ 3] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 4]);
   word3_muladd_2(&w0, &w2, &w1, x[ 1], x[ 3]);
   word3_muladd  (&w0, &w2, &w1, x[ 2], x[ 2]);
   z[ 4] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[ 5]);
   word3_muladd_2(&w1, &w0, &w2, x[ 1], x[ 4]);
   word3_muladd_2(&w1, &w0, &w2, x[ 2], x[ 3]);
   z[ 5] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[ 5]);
   word3_muladd_2(&w2, &w1, &w0, x[ 2], x[ 4]);
   word3_muladd  (&w2, &w1, &w0, x[ 3], x[ 3]);
   z[ 6] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 2], x[ 5]);
   word3_muladd_2(&w0, &w2, &w1, x[ 3], x[ 4]);
   z[ 7] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 3], x[ 5]);
   word3_muladd  (&w1, &w0, &w2, x[ 4], x[ 4]);
   z[ 8] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 4], x[ 5]);
   z[ 9] = w0; w0 = 0;

   word3_muladd  (&w0, &w2, &w1, x[ 5], x[ 5]);
   z[10] = w1;
   z[11] = w2;
   }

bigint_comba_sqr8()

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

Definition at line 208 of file mp_comba.cpp.

References word3_muladd(), and word3_muladd_2().

Referenced by bigint_sqr().

   {
   word w2 = 0, w1 = 0, w0 = 0;

   word3_muladd  (&w2, &w1, &w0, x[ 0], x[ 0]);
   z[ 0] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 1]);
   z[ 1] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[ 2]);
   word3_muladd  (&w1, &w0, &w2, x[ 1], x[ 1]);
   z[ 2] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 0], x[ 3]);
   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[ 2]);
   z[ 3] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 4]);
   word3_muladd_2(&w0, &w2, &w1, x[ 1], x[ 3]);
   word3_muladd  (&w0, &w2, &w1, x[ 2], x[ 2]);
   z[ 4] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[ 5]);
   word3_muladd_2(&w1, &w0, &w2, x[ 1], x[ 4]);
   word3_muladd_2(&w1, &w0, &w2, x[ 2], x[ 3]);
   z[ 5] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 0], x[ 6]);
   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[ 5]);
   word3_muladd_2(&w2, &w1, &w0, x[ 2], x[ 4]);
   word3_muladd  (&w2, &w1, &w0, x[ 3], x[ 3]);
   z[ 6] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 7]);
   word3_muladd_2(&w0, &w2, &w1, x[ 1], x[ 6]);
   word3_muladd_2(&w0, &w2, &w1, x[ 2], x[ 5]);
   word3_muladd_2(&w0, &w2, &w1, x[ 3], x[ 4]);
   z[ 7] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 1], x[ 7]);
   word3_muladd_2(&w1, &w0, &w2, x[ 2], x[ 6]);
   word3_muladd_2(&w1, &w0, &w2, x[ 3], x[ 5]);
   word3_muladd  (&w1, &w0, &w2, x[ 4], x[ 4]);
   z[ 8] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 2], x[ 7]);
   word3_muladd_2(&w2, &w1, &w0, x[ 3], x[ 6]);
   word3_muladd_2(&w2, &w1, &w0, x[ 4], x[ 5]);
   z[ 9] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 3], x[ 7]);
   word3_muladd_2(&w0, &w2, &w1, x[ 4], x[ 6]);
   word3_muladd  (&w0, &w2, &w1, x[ 5], x[ 5]);
   z[10] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 4], x[ 7]);
   word3_muladd_2(&w1, &w0, &w2, x[ 5], x[ 6]);
   z[11] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 5], x[ 7]);
   word3_muladd  (&w2, &w1, &w0, x[ 6], x[ 6]);
   z[12] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 6], x[ 7]);
   z[13] = w1; w1 = 0;

   word3_muladd  (&w1, &w0, &w2, x[ 7], x[ 7]);
   z[14] = w2;
   z[15] = w0;
   }

bigint_comba_sqr9()

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

Definition at line 386 of file mp_comba.cpp.

References word3_muladd(), and word3_muladd_2().

Referenced by bigint_sqr().

   {
   word w2 = 0, w1 = 0, w0 = 0;

   word3_muladd  (&w2, &w1, &w0, x[ 0], x[ 0]);
   z[ 0] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 1]);
   z[ 1] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[ 2]);
   word3_muladd  (&w1, &w0, &w2, x[ 1], x[ 1]);
   z[ 2] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 0], x[ 3]);
   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[ 2]);
   z[ 3] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 4]);
   word3_muladd_2(&w0, &w2, &w1, x[ 1], x[ 3]);
   word3_muladd  (&w0, &w2, &w1, x[ 2], x[ 2]);
   z[ 4] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[ 5]);
   word3_muladd_2(&w1, &w0, &w2, x[ 1], x[ 4]);
   word3_muladd_2(&w1, &w0, &w2, x[ 2], x[ 3]);
   z[ 5] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 0], x[ 6]);
   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[ 5]);
   word3_muladd_2(&w2, &w1, &w0, x[ 2], x[ 4]);
   word3_muladd  (&w2, &w1, &w0, x[ 3], x[ 3]);
   z[ 6] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 0], x[ 7]);
   word3_muladd_2(&w0, &w2, &w1, x[ 1], x[ 6]);
   word3_muladd_2(&w0, &w2, &w1, x[ 2], x[ 5]);
   word3_muladd_2(&w0, &w2, &w1, x[ 3], x[ 4]);
   z[ 7] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 0], x[ 8]);
   word3_muladd_2(&w1, &w0, &w2, x[ 1], x[ 7]);
   word3_muladd_2(&w1, &w0, &w2, x[ 2], x[ 6]);
   word3_muladd_2(&w1, &w0, &w2, x[ 3], x[ 5]);
   word3_muladd  (&w1, &w0, &w2, x[ 4], x[ 4]);
   z[ 8] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 1], x[ 8]);
   word3_muladd_2(&w2, &w1, &w0, x[ 2], x[ 7]);
   word3_muladd_2(&w2, &w1, &w0, x[ 3], x[ 6]);
   word3_muladd_2(&w2, &w1, &w0, x[ 4], x[ 5]);
   z[ 9] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 2], x[ 8]);
   word3_muladd_2(&w0, &w2, &w1, x[ 3], x[ 7]);
   word3_muladd_2(&w0, &w2, &w1, x[ 4], x[ 6]);
   word3_muladd  (&w0, &w2, &w1, x[ 5], x[ 5]);
   z[10] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 3], x[ 8]);
   word3_muladd_2(&w1, &w0, &w2, x[ 4], x[ 7]);
   word3_muladd_2(&w1, &w0, &w2, x[ 5], x[ 6]);
   z[11] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 4], x[ 8]);
   word3_muladd_2(&w2, &w1, &w0, x[ 5], x[ 7]);
   word3_muladd  (&w2, &w1, &w0, x[ 6], x[ 6]);
   z[12] = w0; w0 = 0;

   word3_muladd_2(&w0, &w2, &w1, x[ 5], x[ 8]);
   word3_muladd_2(&w0, &w2, &w1, x[ 6], x[ 7]);
   z[13] = w1; w1 = 0;

   word3_muladd_2(&w1, &w0, &w2, x[ 6], x[ 8]);
   word3_muladd  (&w1, &w0, &w2, x[ 7], x[ 7]);
   z[14] = w2; w2 = 0;

   word3_muladd_2(&w2, &w1, &w0, x[ 7], x[ 8]);
   z[15] = w0; w0 = 0;

   word3_muladd  (&w0, &w2, &w1, x[ 8], x[ 8]);
   z[16] = w1;
   z[17] = w2;
   }

bigint_divop()

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

Compute ((n1<<bits) + n0) / d

Definition at line 404 of file mp_core.cpp.

References MP_WORD_BITS, and MP_WORD_TOP_BIT.

Referenced by bigint_modop(), divide(), and monty_inverse().

   {
   if(d == 0)
      throw Invalid_Argument("bigint_divop divide by zero");

   word high = n1 % d, quotient = 0;

   for(size_t i = 0; i != MP_WORD_BITS; ++i)
      {
      word high_top_bit = (high & MP_WORD_TOP_BIT);

      high <<= 1;
      high |= (n0 >> (MP_WORD_BITS-1-i)) & 1;
      quotient <<= 1;

      if(high_top_bit || high >= d)
         {
         high -= d;
         quotient |= 1;
         }
      }

   return quotient;
   }

bigint_linmul2()

void Botan::bigint_linmul2	(	word	x[],
		size_t	x_size,
		word	y
	)

Definition at line 222 of file mp_core.cpp.

References word8_linmul2(), and word_madd2().

Referenced by Botan::BigInt::operator*=().

   {
   const size_t blocks = x_size - (x_size % 8);

   word carry = 0;

   for(size_t i = 0; i != blocks; i += 8)
      carry = word8_linmul2(x + i, y, carry);

   for(size_t i = blocks; i != x_size; ++i)
      x[i] = word_madd2(x[i], y, &carry);

   x[x_size] = carry;
   }

bigint_linmul3()

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

Definition at line 240 of file mp_core.cpp.

References word8_linmul3(), and word_madd2().

Referenced by bigint_mul(), bigint_sqr(), operator*(), and Botan::BigInt::operator*=().

   {
   const size_t blocks = x_size - (x_size % 8);

   word carry = 0;

   for(size_t i = 0; i != blocks; i += 8)
      carry = word8_linmul3(z + i, x + i, y, carry);

   for(size_t i = blocks; i != x_size; ++i)
      z[i] = word_madd2(x[i], y, &carry);

   z[x_size] = carry;
   }

bigint_modop()

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

Compute ((n1<<bits) + n0) % d

Definition at line 432 of file mp_core.cpp.

References bigint_divop(), and word_madd2().

Referenced by operator%(), and Botan::BigInt::operator%=().

   {
   word z = bigint_divop(n1, n0, d);
   word dummy = 0;
   z = word_madd2(z, d, &dummy);
   return (n0-z);
   }

bigint_monty_mul()

void Botan::bigint_monty_mul	(	BigInt &	z,
		const BigInt &	x,
		const BigInt &	y,
		const word	p[],
		size_t	p_size,
		word	p_dash,
		word	workspace[]
	)

Definition at line 97 of file mp_monty.cpp.

References bigint_monty_redc(), bigint_mul(), and Botan::BigInt::mutable_data().

Referenced by Botan::Montgomery_Exponentiator::execute(), and Botan::Montgomery_Exponentiator::set_base().

   {
   bigint_mul(z, x, y, &ws[0]);

   bigint_monty_redc(z.mutable_data(),
                     &p[0], p_size, p_dash,
                     &ws[0]);

   }

bigint_monty_redc()

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

Montgomery Reduction

Parameters

z	integer to reduce, of size exactly 2*(p_size+1). Output is in the first p_size+1 words, higher words are set to zero.
p	modulus
p_size	size of p
p_dash	Montgomery value
workspace	array of at least 2*(p_size+1) words

Definition at line 22 of file mp_monty.cpp.

References BOTAN_ASSERT, clear_mem(), Botan::CT::conditional_copy_mem(), copy_mem(), Botan::CT::poison(), Botan::CT::unpoison(), word8_madd3(), word_madd3(), and word_sub().

Referenced by bigint_monty_mul(), bigint_monty_sqr(), and Botan::Montgomery_Exponentiator::execute().

   {
   const size_t z_size = 2*(p_size+1);

   CT::poison(z, z_size);
   CT::poison(p, p_size);
   CT::poison(ws, 2*(p_size+1));

   const size_t blocks_of_8 = p_size - (p_size % 8);

   for(size_t i = 0; i != p_size; ++i)
      {
      word* z_i = z + i;

      const word y = z_i[0] * p_dash;

      /*
      bigint_linmul3(ws, p, p_size, y);
      bigint_add2(z_i, z_size - i, ws, p_size+1);
      */

      word carry = 0;

      for(size_t j = 0; j != blocks_of_8; j += 8)
         carry = word8_madd3(z_i + j, p + j, y, carry);

      for(size_t j = blocks_of_8; j != p_size; ++j)
         z_i[j] = word_madd3(p[j], y, z_i[j], &carry);

      word z_sum = z_i[p_size] + carry;
      carry = (z_sum < z_i[p_size]);
      z_i[p_size] = z_sum;

      for(size_t j = p_size + 1; j < z_size - i; ++j)
         {
         z_i[j] += carry;
         carry = carry & !z_i[j];
         }
      }

   /*
   * The result might need to be reduced mod p. To avoid a timing
   * channel, always perform the subtraction. If in the compution
   * of x - p a borrow is required then x was already < p.
   *
   * x - p starts at ws[0] and is p_size+1 bytes long
   * x starts at ws[p_size+1] and is also p_size+1 bytes log
   * (that's the copy_mem)
   *
   * Select which address to copy from indexing off of the final
   * borrow.
   */

   word borrow = 0;
   for(size_t i = 0; i != p_size; ++i)
      ws[i] = word_sub(z[p_size + i], p[i], &borrow);

   ws[p_size] = word_sub(z[p_size+p_size], 0, &borrow);

   copy_mem(ws + p_size + 1, z + p_size, p_size + 1);

   CT::conditional_copy_mem(borrow, z, ws + (p_size + 1), ws, (p_size + 1));
   clear_mem(z + p_size + 1, z_size - p_size - 1);

   CT::unpoison(z, z_size);
   CT::unpoison(p, p_size);
   CT::unpoison(ws, 2*(p_size+1));

   // This check comes after we've used it but that's ok here
   CT::unpoison(&borrow, 1);
   BOTAN_ASSERT(borrow == 0 || borrow == 1, "Expected borrow");
   }

bigint_monty_sqr()

void Botan::bigint_monty_sqr	(	BigInt &	z,
		const BigInt &	x,
		const word	p[],
		size_t	p_size,
		word	p_dash,
		word	workspace[]
	)

Definition at line 109 of file mp_monty.cpp.

References bigint_monty_redc(), bigint_sqr(), Botan::BigInt::data(), Botan::BigInt::mutable_data(), Botan::BigInt::sig_words(), and Botan::BigInt::size().

Referenced by Botan::Montgomery_Exponentiator::execute().

   {
   bigint_sqr(z.mutable_data(), z.size(), &ws[0],
              x.data(), x.size(), x.sig_words());

   bigint_monty_redc(z.mutable_data(),
                     &p[0], p_size, p_dash,
                     &ws[0]);
   }

bigint_mul()

void Botan::bigint_mul	(	BigInt &	z,
		const BigInt &	x,
		const BigInt &	y,
		word	workspace[]
	)

Definition at line 252 of file mp_karat.cpp.

References bigint_comba_mul16(), bigint_comba_mul4(), bigint_comba_mul6(), bigint_comba_mul8(), bigint_comba_mul9(), bigint_linmul3(), clear_mem(), Botan::BigInt::data(), Botan::BigInt::mutable_data(), Botan::BigInt::sig_words(), and Botan::BigInt::size().

Referenced by bigint_monty_mul(), mul_add(), operator*(), and Botan::BigInt::operator*=().

   {
   const size_t x_sig_words = x.sig_words();
   const size_t y_sig_words = y.sig_words();

   clear_mem(z.mutable_data(), z.size());

   if(x_sig_words == 1)
      {
      bigint_linmul3(z.mutable_data(), y.data(), y_sig_words, x.data()[0]);
      }
   else if(y_sig_words == 1)
      {
      bigint_linmul3(z.mutable_data(), x.data(), x_sig_words, y.data()[0]);
      }
   else if(x_sig_words <= 4 && x.size() >= 4 &&
           y_sig_words <= 4 && y.size() >= 4 && z.size() >= 8)
      {
      bigint_comba_mul4(z.mutable_data(), x.data(), y.data());
      }
   else if(x_sig_words <= 6 && x.size() >= 6 &&
           y_sig_words <= 6 && y.size() >= 6 && z.size() >= 12)
      {
      bigint_comba_mul6(z.mutable_data(), x.data(), y.data());
      }
   else if(x_sig_words <= 8 && x.size() >= 8 &&
           y_sig_words <= 8 && y.size() >= 8 && z.size() >= 16)
      {
      bigint_comba_mul8(z.mutable_data(), x.data(), y.data());
      }
   else if(x_sig_words <= 9 && x.size() >= 9 &&
           y_sig_words <= 9 && y.size() >= 9 && z.size() >= 18)
      {
      bigint_comba_mul9(z.mutable_data(), x.data(), y.data());
      }
   else if(x_sig_words <= 16 && x.size() >= 16 &&
           y_sig_words <= 16 && y.size() >= 16 && z.size() >= 32)
      {
      bigint_comba_mul16(z.mutable_data(), x.data(), y.data());
      }
   else if(x_sig_words < KARATSUBA_MULTIPLY_THRESHOLD ||
           y_sig_words < KARATSUBA_MULTIPLY_THRESHOLD ||
           !workspace)
      {
      basecase_mul(z.mutable_data(), x.data(), x_sig_words, y.data(), y_sig_words);
      }
   else
      {
      const size_t N = karatsuba_size(z.size(), x.size(), x_sig_words, y.size(), y_sig_words);

      if(N)
         karatsuba_mul(z.mutable_data(), x.data(), y.data(), N, workspace);
      else
         basecase_mul(z.mutable_data(), x.data(), x_sig_words, y.data(), y_sig_words);
      }
   }

bigint_shl1()

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

Definition at line 258 of file mp_core.cpp.

References clear_mem(), copy_mem(), and MP_WORD_BITS.

Referenced by Botan::BigInt::operator-=(), and Botan::BigInt::operator<<=().

   {
   if(word_shift)
      {
      copy_mem(x + word_shift, x, x_size);
      clear_mem(x, word_shift);
      }

   if(bit_shift)
      {
      word carry = 0;
      for(size_t j = word_shift; j != x_size + word_shift + 1; ++j)
         {
         word temp = x[j];
         x[j] = (temp << bit_shift) | carry;
         carry = (temp >> (MP_WORD_BITS - bit_shift));
         }
      }
   }

bigint_shl2()

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

Definition at line 336 of file mp_core.cpp.

References MP_WORD_BITS.

Referenced by operator-(), and operator<<().

   {
   for(size_t j = 0; j != x_size; ++j)
      y[j + word_shift] = x[j];
   if(bit_shift)
      {
      word carry = 0;
      for(size_t j = word_shift; j != x_size + word_shift + 1; ++j)
         {
         word w = y[j];
         y[j] = (w << bit_shift) | carry;
         carry = (w >> (MP_WORD_BITS - bit_shift));
         }
      }
   }

bigint_shr1()

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

Definition at line 281 of file mp_core.cpp.

References clear_mem(), copy_mem(), and MP_WORD_BITS.

Referenced by ct_inverse_mod_odd_modulus(), and Botan::BigInt::operator>>=().

   {
   if(x_size < word_shift)
      {
      clear_mem(x, x_size);
      return;
      }

   if(word_shift)
      {
      copy_mem(x, x + word_shift, x_size - word_shift);
      clear_mem(x + x_size - word_shift, word_shift);
      }

   if(bit_shift)
      {
      word carry = 0;

      size_t top = x_size - word_shift;

      while(top >= 4)
         {
         word w = x[top-1];
         x[top-1] = (w >> bit_shift) | carry;
         carry = (w << (MP_WORD_BITS - bit_shift));

         w = x[top-2];
         x[top-2] = (w >> bit_shift) | carry;
         carry = (w << (MP_WORD_BITS - bit_shift));

         w = x[top-3];
         x[top-3] = (w >> bit_shift) | carry;
         carry = (w << (MP_WORD_BITS - bit_shift));

         w = x[top-4];
         x[top-4] = (w >> bit_shift) | carry;
         carry = (w << (MP_WORD_BITS - bit_shift));

         top -= 4;
         }

      while(top)
         {
         word w = x[top-1];
         x[top-1] = (w >> bit_shift) | carry;
         carry = (w << (MP_WORD_BITS - bit_shift));

         top--;
         }
      }
   }

bigint_shr2()

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

Definition at line 356 of file mp_core.cpp.

References MP_WORD_BITS.

Referenced by operator>>(), and redc_p521().

   {
   if(x_size < word_shift) return;

   for(size_t j = 0; j != x_size - word_shift; ++j)
      y[j] = x[j + word_shift];
   if(bit_shift)
      {
      word carry = 0;
      for(size_t j = x_size - word_shift; j > 0; --j)
         {
         word w = y[j-1];
         y[j-1] = (w >> bit_shift) | carry;
         carry = (w << (MP_WORD_BITS - bit_shift));
         }
      }
   }

bigint_sqr()

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

Definition at line 312 of file mp_karat.cpp.

References bigint_comba_sqr16(), bigint_comba_sqr4(), bigint_comba_sqr6(), bigint_comba_sqr8(), bigint_comba_sqr9(), bigint_linmul3(), and BOTAN_ASSERT.

Referenced by bigint_monty_sqr(), and square().

   {
   BOTAN_ASSERT(z_size/2 >= x_sw, "Output size is sufficient");

   if(x_sw == 1)
      {
      bigint_linmul3(z, x, x_sw, x[0]);
      }
   else if(x_sw <= 4 && x_size >= 4 && z_size >= 8)
      {
      bigint_comba_sqr4(z, x);
      }
   else if(x_sw <= 6 && x_size >= 6 && z_size >= 12)
      {
      bigint_comba_sqr6(z, x);
      }
   else if(x_sw <= 8 && x_size >= 8 && z_size >= 16)
      {
      bigint_comba_sqr8(z, x);
      }
   else if(x_sw == 9 && x_size >= 9 && z_size >= 18)
      {
      bigint_comba_sqr9(z, x);
      }
   else if(x_sw <= 16 && x_size >= 16 && z_size >= 32)
      {
      bigint_comba_sqr16(z, x);
      }
   else if(x_size < KARATSUBA_SQUARE_THRESHOLD || !workspace)
      {
      basecase_mul(z, x, x_sw, x, x_sw);
      }
   else
      {
      const size_t N = karatsuba_size(z_size, x_size, x_sw);

      if(N)
         karatsuba_sqr(z, x, N, workspace);
      else
         basecase_mul(z, x, x_sw, x, x_sw);
      }
   }

bigint_sub2()

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

Two operand subtraction

Definition at line 157 of file mp_core.cpp.

References BOTAN_ASSERT, word8_sub2(), and word_sub().

Referenced by Botan::BigInt::operator+=(), and Botan::BigInt::operator-=().

   {
   word borrow = 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)
      borrow = word8_sub2(x + i, y + i, borrow);

   for(size_t i = blocks; i != y_size; ++i)
      x[i] = word_sub(x[i], y[i], &borrow);

   for(size_t i = y_size; i != x_size; ++i)
      x[i] = word_sub(x[i], 0, &borrow);

   return borrow;
   }

bigint_sub2_rev()

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

Two operand subtraction, x = y - x; assumes y >= x

Definition at line 180 of file mp_core.cpp.

References BOTAN_ASSERT, word8_sub2_rev(), and word_sub().

Referenced by Botan::BigInt::operator-=().

   {
   word borrow = 0;

   const size_t blocks = y_size - (y_size % 8);

   for(size_t i = 0; i != blocks; i += 8)
      borrow = word8_sub2_rev(x + i, y + i, borrow);

   for(size_t i = blocks; i != y_size; ++i)
      x[i] = word_sub(y[i], x[i], &borrow);

   BOTAN_ASSERT(!borrow, "y must be greater than x");
   }

bigint_sub3()

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

Three operand subtraction

Definition at line 198 of file mp_core.cpp.

References BOTAN_ASSERT, word8_sub3(), and word_sub().

Referenced by operator+(), Botan::BigInt::operator+=(), and operator-().

   {
   word borrow = 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)
      borrow = word8_sub3(z + i, x + i, y + i, borrow);

   for(size_t i = blocks; i != y_size; ++i)
      z[i] = word_sub(x[i], y[i], &borrow);

   for(size_t i = y_size; i != x_size; ++i)
      z[i] = word_sub(x[i], 0, &borrow);

   return borrow;
   }

bit_size_to_32bit_size()

uint32_t Botan::bit_size_to_32bit_size ( uint32_t  bit_size )

inline

Definition at line 50 of file code_based_util.h.

Referenced by generate_mceliece_key(), mceliece_decrypt(), and Botan::McEliece_PrivateKey::McEliece_PrivateKey().

   {
   return (bit_size - 1) / 32 + 1;
   }

bit_size_to_byte_size()

uint32_t Botan::bit_size_to_byte_size ( uint32_t  bit_size )

inline

Definition at line 45 of file code_based_util.h.

Referenced by mceliece_decrypt().

   {
   return (bit_size - 1) / 8 + 1;
   }

BOTAN_DEPRECATED()

class BOTAN_DLL Botan::BOTAN_DEPRECATED

(

"LibraryInitializer is no longer required"

)

Definition at line 22 of file init.h.

Referenced by Botan::TLS::Compat_Callbacks::Compat_Callbacks(), get_block_cipher(), get_block_cipher_providers(), get_hash(), get_hash_function(), get_hash_function_providers(), get_mac(), get_stream_cipher(), get_stream_cipher_providers(), make_block_cipher(), make_hash_function(), make_message_auth(), make_stream_cipher(), and Botan::RandomNumberGenerator::next_nonzero_byte().

   {
   public:
      explicit LibraryInitializer(const std::string& /*ignored*/ = "") { }

      static void initialize(const std::string& /*ignored*/ = "") {}
      static void deinitialize() {}
   };

bswap_4()

template<typename T >

void Botan::bswap_4 ( T  x[4] )

inline

Swap 4 Ts in an array

Definition at line 112 of file bswap.h.

References reverse_bytes().

Referenced by Botan::SIMD_4x32::load_be(), load_be(), Botan::SIMD_4x32::load_le(), and load_le().

   {
   x[0] = reverse_bytes(x[0]);
   x[1] = reverse_bytes(x[1]);
   x[2] = reverse_bytes(x[2]);
   x[3] = reverse_bytes(x[3]);
   }

buffer_insert() [1/2]

template<typename T , typename Alloc >

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

Definition at line 133 of file secmem.h.

References copy_mem(), and Botan::CT::min().

Referenced by Botan::MDx_HashFunction::add_data(), Botan::GOST_34_11::clear(), Botan::Poly1305::clear(), Botan::Skein_512::clear(), Botan::DLIES_Encryptor::DLIES_Encryptor(), Botan::ECIES_Encryptor::ECIES_Encryptor(), Botan::CMAC::poly_double(), Botan::OFB::set_iv(), Botan::CTR_BE::set_iv(), Botan::Base64_Encoder::write(), and Botan::Hex_Encoder::write().

   {
   const size_t to_copy = std::min(input_length, buf.size() - buf_offset);
   if (to_copy > 0)
      {
      copy_mem(&buf[buf_offset], input, to_copy);
      }
   return to_copy;
   }

buffer_insert() [2/2]

template<typename T , typename Alloc , typename Alloc2 >

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

Definition at line 147 of file secmem.h.

References copy_mem(), and Botan::CT::min().

   {
   const size_t to_copy = std::min(input.size(), buf.size() - buf_offset);
   if (to_copy > 0)
      {
      copy_mem(&buf[buf_offset], input.data(), to_copy);
      }
   return to_copy;
   }

calendar_value()

BOTAN_DLL calendar_point Botan::calendar_value

(

const std::chrono::system_clock::time_point &

time_point

)

Convert a time_point to a calendar_point

Parameters

time_point

a time point from the system clock

Returns

calendar_point object representing this time point

Definition at line 177 of file calendar.cpp.

Referenced by Botan::calendar_point::calendar_point(), and Botan::X509_Time::X509_Time().

   {
   std::tm tm = do_gmtime(std::chrono::system_clock::to_time_t(time_point));

   return calendar_point(tm.tm_year + 1900,
                         tm.tm_mon + 1,
                         tm.tm_mday,
                         tm.tm_hour,
                         tm.tm_min,
                         tm.tm_sec);
   }

carry_shift()

uint64_t Botan::carry_shift ( const donna128 &  a, size_t  shift  )

inline

Definition at line 108 of file donna128.h.

Referenced by combine_lower().

   {
   return (a >> shift).lo();
   }

CECPQ1_accept() [1/2]

void Botan::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
	)

Definition at line 25 of file cecpq1.cpp.

References BoringSSL, curve25519_basepoint(), curve25519_donna(), newhope_sharedb(), and Botan::RandomNumberGenerator::random_vec().

Referenced by Botan::TLS::Client_Key_Exchange::Client_Key_Exchange().

   {
   secure_vector<uint8_t> x25519_key = rng.random_vec(32);

   curve25519_basepoint(send, x25519_key.data());

   curve25519_donna(shared_key, x25519_key.data(), received);

   newhope_sharedb(shared_key + 32, send + 32, received + 32,
                   rng, Newhope_Mode::BoringSSL);
   }

CECPQ1_accept() [2/2]

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

CECPQ1_finish() [1/2]

void BOTAN_DLL Botan::CECPQ1_finish	(	uint8_t *	shared_key,
		const CECPQ1_key &	offer_key,
		const uint8_t *	accept_message
	)

CECPQ1_finish() [2/2]

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

Definition at line 40 of file cecpq1.cpp.

References BoringSSL, curve25519_donna(), Botan::CECPQ1_key::m_newhope, Botan::CECPQ1_key::m_x25519, and newhope_shareda().

Referenced by Botan::TLS::Client_Key_Exchange::Client_Key_Exchange().

   {
   curve25519_donna(shared_key, offer_key.m_x25519.data(), received);

   newhope_shareda(shared_key + 32, &offer_key.m_newhope, received + 32,
                   Newhope_Mode::BoringSSL);
   }

CECPQ1_offer() [1/2]

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

Definition at line 14 of file cecpq1.cpp.

References BoringSSL, curve25519_basepoint(), Botan::CECPQ1_key::m_newhope, Botan::CECPQ1_key::m_x25519, newhope_keygen(), and Botan::RandomNumberGenerator::random_vec().

Referenced by Botan::TLS::Server_Key_Exchange::Server_Key_Exchange().

   {
   offer_key_output->m_x25519 = rng.random_vec(32);
   curve25519_basepoint(send, offer_key_output->m_x25519.data());

   newhope_keygen(send + 32, &offer_key_output->m_newhope,
                  rng, Newhope_Mode::BoringSSL);
   }

CECPQ1_offer() [2/2]

void BOTAN_DLL Botan::CECPQ1_offer	(	uint8_t *	offer_message,
		CECPQ1_key *	offer_key_output,
		RandomNumberGenerator &	rng
	)

ceil_log2()

template<typename T >

size_t Botan::ceil_log2

(

T

x

)

Definition at line 106 of file bit_ops.h.

Referenced by Botan::McEliece_PublicKey::get_message_word_bit_length(), Botan::McEliece_PrivateKey::McEliece_PrivateKey(), and mceliece_work_factor().

   {
   if(x >> (sizeof(T)*8-1))
      return sizeof(T)*8;

   size_t result = 0;
   T compare = 1;

   while(compare < x)
      {
      compare <<= 1;
      result++;
      }

   return result;
   }

check_bcrypt()

bool BOTAN_DLL Botan::check_bcrypt	(	const std::string &	password,
		const std::string &	hash
	)

Check a previously created password hash

Parameters

password	the password to check against
hash	the stored hash to check against

Definition at line 132 of file bcrypt.cpp.

References same_mem(), and to_u32bit().

Referenced by botan_bcrypt_is_valid().

   {
   if(hash.size() != 60 ||
      hash[0] != '$' || hash[1] != '2' || hash[2] != 'a' ||
      hash[3] != '$' || hash[6] != '$')
      {
      return false;
      }

   const uint16_t workfactor = to_u32bit(hash.substr(4, 2));

   const std::vector<uint8_t> salt = bcrypt_base64_decode(hash.substr(7, 22));
   if(salt.size() != 16)
      return false;

   const std::string compare = make_bcrypt(pass, salt, workfactor);

   return same_mem(hash.data(), compare.data(), compare.size());
   }

check_passhash9()

bool BOTAN_DLL Botan::check_passhash9	(	const std::string &	password,
		const std::string &	hash
	)

Check a previously created password hash

Parameters

password	the password to check against
hash	the stored hash to check against

Definition at line 75 of file passhash9.cpp.

References base64_decode(), Botan::OctetString::bits_of(), Botan::PBKDF::derive_key(), load_be< uint16_t >(), same_mem(), and Botan::ASN1::to_string().

   {
   const size_t BINARY_LENGTH =
     ALGID_BYTES +
     WORKFACTOR_BYTES +
     PASSHASH9_PBKDF_OUTPUT_LEN +
     SALT_BYTES;

   const size_t BASE64_LENGTH =
      MAGIC_PREFIX.size() + (BINARY_LENGTH * 8) / 6;

   if(hash.size() != BASE64_LENGTH)
      return false;

   for(size_t i = 0; i != MAGIC_PREFIX.size(); ++i)
      if(hash[i] != MAGIC_PREFIX[i])
         return false;

   secure_vector<uint8_t> bin = base64_decode(hash.c_str() + MAGIC_PREFIX.size());

   if(bin.size() != BINARY_LENGTH)
      return false;

   uint8_t alg_id = bin[0];

   const size_t work_factor = load_be<uint16_t>(&bin[ALGID_BYTES], 0);

   // Bug in the format, bad states shouldn't be representable, but are...
   if(work_factor == 0)
      return false;

   if(work_factor > 512)
      throw Invalid_Argument("Requested Bcrypt work factor " +
                                  std::to_string(work_factor) + " too large");

   const size_t kdf_iterations = WORK_FACTOR_SCALE * work_factor;

   std::unique_ptr<MessageAuthenticationCode> pbkdf_prf = get_pbkdf_prf(alg_id);

   if(!pbkdf_prf)
      return false; // unknown algorithm, reject

   PKCS5_PBKDF2 kdf(pbkdf_prf.release()); // takes ownership of pointer

   secure_vector<uint8_t> cmp = kdf.derive_key(
      PASSHASH9_PBKDF_OUTPUT_LEN,
      pass,
      &bin[ALGID_BYTES + WORKFACTOR_BYTES], SALT_BYTES,
      kdf_iterations).bits_of();

   return same_mem(cmp.data(),
                   &bin[ALGID_BYTES + WORKFACTOR_BYTES + SALT_BYTES],
                   PASSHASH9_PBKDF_OUTPUT_LEN);
   }

check_prime()

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

inline

Definition at line 174 of file numthry.h.

References is_prime().

   { return is_prime(n, rng, 56); }

checked_add()

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

inline

Definition at line 24 of file safeint.h.

References Botan::Integer_Overflow_Detected::Integer_Overflow_Detected().

   {
   // TODO: use __builtin_x_overflow on GCC and Clang
   size_t z = x + y;
   if(z < x)
      {
      throw Integer_Overflow_Detected(file, line);
      }
   return z;
   }

choose_sig_format()

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

Choose the default signature format for a certain public key signature scheme.

Parameters

key	will be the key to choose a padding scheme for
rng	the random generator to use
hash_fn	is the desired hash function
alg_id	will be set to the chosen scheme

Returns

A PK_Signer object for generating signatures

Definition at line 228 of file x509_ca.cpp.

References Botan::Public_Key::algo_name(), Botan::Public_Key::algorithm_identifier(), Botan::HashFunction::create_or_throw(), DER_SEQUENCE, hash, IEEE_1363, Botan::OIDS::lookup(), Botan::Public_Key::message_parts(), Botan::AlgorithmIdentifier::oid, and Botan::AlgorithmIdentifier::parameters.

Referenced by Botan::X509::create_cert_req(), Botan::X509::create_self_signed_cert(), and Botan::X509_CA::X509_CA().

   {
   const std::string algo_name = key.algo_name();

   std::unique_ptr<HashFunction> hash(HashFunction::create_or_throw(hash_fn));

   std::string padding;
   if(algo_name == "RSA")
      {
      padding = "EMSA3";
      }
   else if(algo_name == "DSA" ||
           algo_name == "ECDSA" ||
           algo_name == "ECGDSA" ||
           algo_name == "ECKCDSA" ||
           algo_name == "GOST-34.10")
      {
      padding = "EMSA1";
      }
   else
      {
      throw Invalid_Argument("Unknown X.509 signing key type: " + algo_name);
      }

   const Signature_Format format = (key.message_parts() > 1) ? DER_SEQUENCE : IEEE_1363;

   padding = padding + "(" + hash->name() + ")";

   sig_algo.oid = OIDS::lookup(algo_name + "/" + padding);
   sig_algo.parameters = key.algorithm_identifier().parameters;

   return new PK_Signer(key, rng, padding, format);
   }

clamp()

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

inline

Clamp

Definition at line 49 of file rounding.h.

   {
   if(n < lower_bound)
      return lower_bound;
   if(n > upper_bound)
      return upper_bound;
   return n;
   }

clean_ws()

std::string Botan::clean_ws

(

const std::string &

s

)

Definition at line 13 of file read_cfg.cpp.

Referenced by read_cfg().

   {
   const char* ws = " \t\n";
   auto start = s.find_first_not_of(ws);
   auto end = s.find_last_not_of(ws);

   if(start == std::string::npos)
      return "";

   if(end == std::string::npos)
      return s.substr(start, end);
   else
      return s.substr(start, start + end + 1);
   }

clear_bytes()

void Botan::clear_bytes ( void *  ptr, size_t  bytes  )

inline

Zero out some bytes

Parameters

ptr	a pointer to memory to zero
bytes	the number of bytes to zero in ptr

Definition at line 39 of file mem_ops.h.

Referenced by clear_mem().

   {
   if(bytes > 0)
      {
      std::memset(ptr, 0, bytes);
      }
   }

clear_mem()

template<typename T >

void Botan::clear_mem ( T *  ptr, size_t  n  )

inline

Zero memory before use. This simply calls memset and should not be used in cases where the compiler cannot see the call as a side-effecting operation (for example, if calling clear_mem before deallocating memory, the compiler would be allowed to omit the call to memset entirely under the as-if rule.)

Parameters

ptr	a pointer to an array of Ts to zero
n	the number of Ts pointed to by ptr

Definition at line 57 of file mem_ops.h.

References clear_bytes().

Referenced by Botan::mlock_allocator::allocate(), Botan::secure_allocator< T >::allocate(), aont_package(), base64_decode(), bigint_monty_redc(), bigint_mul(), bigint_shl1(), bigint_shr1(), Botan::Poly1305::clear(), Botan::GOST_34_11::clear(), hex_decode(), Botan::BigInt::mask_bits(), pbkdf2(), redc_p521(), Botan::polyn_gf2m::set_to_zero(), Botan::polyn_gf2m::sqmod_init(), zeroise(), Botan::Zlib_Style_Stream< Stream, ByteType >::Zlib_Style_Stream(), and Botan::Zlib_Style_Stream< Stream, ByteType >::~Zlib_Style_Stream().

   {
   clear_bytes(ptr, sizeof(T)*n);
   }

combine_lower()

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

inline

Definition at line 113 of file donna128.h.

References carry_shift(), and Botan::donna128::lo().

   {
   donna128 z = (a >> s1) | (b << s2);
   return z.lo();
   }

copy_mem()

template<typename T >

void Botan::copy_mem ( T *  out, const T *  in, size_t  n  )

inline

Copy memory

Parameters

out	the destination array
in	the source array
n	the number of elements of in/out

Definition at line 68 of file mem_ops.h.

Referenced by Botan::TLS::Connection_Cipher_State::aead_nonce(), aont_package(), aont_unpackage(), bigint_monty_redc(), bigint_shl1(), bigint_shr1(), botan_cipher_update(), buffer_insert(), Botan::GOST_34_11::clear(), Botan::Comb4P::clear(), Botan::Stream_Compression::clear(), Botan::Stream_Decompression::clear(), Botan::BER_Decoder::decode(), Botan::Blowfish::decrypt_n(), Botan::Lion::decrypt_n(), Botan::TripleDES::decrypt_n(), Botan::Blowfish::eks_key_schedule(), Botan::CryptoBox::encrypt(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), Botan::TLS::Stream_Handshake_IO::format(), Botan::CCM_Mode::format_b0(), Botan::CCM_Mode::format_c0(), Botan::TLS::Datagram_Handshake_IO::get_next_record(), Botan::BER_Decoder::get_next_value(), Botan::X942_PRF::kdf(), Botan::KDF1::kdf(), Botan::KDF2::kdf(), Botan::KDF1_18033::kdf(), Botan::HKDF_Extract::kdf(), Botan::HKDF_Expand::kdf(), mceies_encrypt(), mceliece_decrypt(), operator+=(), operator^(), Botan::GMAC::output_length(), Botan::PKCS5_PBKDF1::pbkdf(), Botan::DataSource_Memory::peek(), Botan::CMAC::poly_double(), Botan::CFB_Encryption::process(), Botan::CFB_Decryption::process(), Botan::CBC_Decryption::process(), Botan::HMAC_DRBG::randomize_with_input(), Botan::DataSource_Memory::read(), rfc3394_keyunwrap(), rfc3394_keywrap(), Botan::GCM_Mode::set_associated_data(), Botan::OCB_Mode::set_associated_data(), Botan::polyn_gf2m::sqmod_init(), unlock(), Botan::XTS_Mode::valid_nonce_length(), Botan::Buffered_Filter::write(), Botan::Base64_Encoder::write(), Botan::Hex_Encoder::write(), Botan::Hex_Decoder::write(), and Botan::Base64_Decoder::write().

   {
   if(n > 0)
      {
      std::memmove(out, in, sizeof(T)*n);
      }
   }

copy_out_be()

template<typename T >

void Botan::copy_out_be	(	uint8_t	out[],
		size_t	out_bytes,
		const T	in[]
	)

Definition at line 661 of file loadstor.h.

References get_byte(), and store_be().

Referenced by copy_out_vec_be(), and Botan::SIMD_4x32::store_be().

   {
   while(out_bytes >= sizeof(T))
      {