Botan Namespace Reference

Namespaces
namespace	ASN1
namespace	BER
namespace	Camellia_F
namespace	Cert_Extension
namespace	Charset
namespace	CryptoBox
namespace	CT
namespace	CVC_EAC
namespace	DE_EAC
namespace	FPE
namespace	Global_State_Management
namespace	HAS_160_F
namespace	KeyPair
namespace	OIDS
namespace	PEM_Code
namespace	PK_Ops
namespace	PKCS8
namespace	RIPEMD_128_F
namespace	SHA1_F
namespace	SHA1_SSE2_F
namespace	SHA2_32
namespace	SHA2_64
namespace	X509

Classes
class	Adler32
class	AES_128
class	AES_128_NI
class	AES_128_SSSE3
class	AES_192
class	AES_192_NI
class	AES_192_SSSE3
class	AES_256
class	AES_256_NI
class	AES_256_SSSE3
class	AES_ISA_Engine
class	Alert
class	Algorithm
class	Algorithm_Cache
class	Algorithm_Factory
struct	Algorithm_Not_Found
class	AlgorithmIdentifier
class	Allocator
class	AlternativeName
class	ANSI_X919_MAC
class	ANSI_X923_Padding
class	ANSI_X931_RNG
class	ARC4
class	ASN1_Car
class	ASN1_Ced
class	ASN1_Cex
class	ASN1_Chr
class	ASN1_EAC_String
class	ASN1_Object
class	ASN1_String
class	Assembler_Engine
class	Attribute
class	AutoSeeded_RNG
class	Base64_Decoder
class	Base64_Encoder
class	BeOS_EntropySource
struct	BER_Bad_Tag
class	BER_Decoder
struct	BER_Decoding_Error
class	BER_Object
class	BigInt
struct	BitBucket
class	Blinder
class	Block_Cipher_Fixed_Params
class	BlockCipher
class	BlockCipherModePaddingMethod
class	Blowfish
class	BMW_512
class	Buffered_Computation
class	Buffered_Filter
class	Bzip_Compression
class	Bzip_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	Certificate
class	Certificate_Extension
class	Certificate_Req
class	Certificate_Store
class	Certificate_Store_Memory
class	Certificate_Verify
class	CFB_Decryption
class	CFB_Encryption
class	Chain
class	CipherSuite
class	Client_Hello
class	Client_Key_Exchange
class	CMAC
class	CMS_Decoder
class	CMS_Encoder
class	Comb4P
class	Core_Engine
class	CPUID
class	CRC24
class	CRC32
class	CRL_Entry
class	CTR_BE
class	CTS_Decryption
class	CTS_Encryption
class	CurveGFp
class	Data_Store
class	DataSink
class	DataSink_Stream
class	DataSource
class	DataSource_Command
class	DataSource_Memory
class	DataSource_Stream
struct	Decoding_Error
class	del_fun
class	DER_Encoder
class	DES
class	DESX
class	Device_EntropySource
class	DH_KA_Operation
class	DH_PrivateKey
class	DH_PublicKey
class	DL_Group
class	DL_Scheme_PrivateKey
class	DL_Scheme_PublicKey
class	DLIES_Decryptor
class	DLIES_Encryptor
class	DSA_PrivateKey
class	DSA_PublicKey
class	DSA_Signature_Operation
class	DSA_Verification_Operation
class	Dynamically_Loaded_Engine
class	Dynamically_Loaded_Library
class	EAC1_1_ADO
class	EAC1_1_CVC
class	EAC1_1_CVC_Options
class	EAC1_1_gen_CVC
class	EAC1_1_obj
class	EAC1_1_Req
class	EAC_Signed_Object
class	EAC_Time
class	EAX_Base
class	EAX_Decryption
class	EAX_Encryption
class	EC_Group
class	EC_PrivateKey
class	EC_PublicKey
class	ECB_Decryption
class	ECB_Encryption
class	ECDH_KA_Operation
class	ECDH_PrivateKey
class	ECDH_PublicKey
class	ECDSA_PrivateKey
class	ECDSA_PublicKey
class	ECDSA_Signature
class	ECDSA_Signature_Operation
class	ECDSA_Verification_Operation
class	EGD_EntropySource
class	ElGamal_Decryption_Operation
class	ElGamal_Encryption_Operation
class	ElGamal_PrivateKey
class	ElGamal_PublicKey
class	EME
class	EME1
class	EME_PKCS1v15
class	EMSA
class	EMSA1
class	EMSA1_BSI
class	EMSA2
class	EMSA3
class	EMSA3_Raw
class	EMSA4
class	EMSA_Raw
struct	Encoding_Error
class	Engine
class	Entropy_Accumulator
class	Entropy_Accumulator_BufferedComputation
class	EntropySource
class	Extensions
class	Fanout_Filter
class	Filter
class	Finished
class	Fixed_Base_Power_Mod
class	Fixed_Exponent_Power_Mod
class	Fixed_Window_Exponentiator
class	Fork
class	FTW_EntropySource
class	GMP_Engine
class	GMP_MPZ
class	GOST_28147_89
class	GOST_28147_89_Params
class	GOST_34_11
class	Handshake_State
class	HandshakeHash
class	HandshakeMessage
class	HAS_160
class	Hash_Filter
class	HashFunction
class	Hello_Request
class	Hex_Decoder
class	Hex_Encoder
class	High_Resolution_Timestamp
class	HMAC
class	HMAC_RNG
class	IDEA
class	IDEA_SSE2
class	IF_Scheme_PrivateKey
class	IF_Scheme_PublicKey
struct	Illegal_Point
struct	Illegal_Transformation
class	Integer_Overflow_Detected
struct	Integrity_Failure
class	Intel_Rdrand
struct	Internal_Error
struct	Invalid_Algorithm_Name
struct	Invalid_Block_Size
struct	Invalid_IV_Length
struct	Invalid_Key_Length
struct	Invalid_OID
struct	Invalid_State
class	KASUMI
class	KDF
class	KDF1
class	KDF2
class	Keccak_1600
class	Key_Length_Specification
class	Keyed_Filter
class	Library_State
class	LibraryInitializer
class	Lion
class	Locking_Allocator
struct	Lookup_Error
class	LubyRackoff
class	MAC_Filter
class	Malloc_Allocator
class	MARS
class	MD2
class	MD4
class	MD4_X86_32
class	MD5
class	MD5_X86_32
class	MDx_HashFunction
struct	Memory_Exhaustion
class	MemoryMapping_Allocator
class	MemoryRegion
class	MemoryVector
class	MessageAuthenticationCode
class	MGF
class	MGF1
class	MISTY1
class	Modular_Exponentiator
class	Modular_Reducer
class	Montgomery_Exponentiator
class	Mutex
class	Mutex_Factory
class	Mutex_Holder
class	Noekeon
class	Noekeon_SIMD
class	Noop_Mutex_Factory
class	NR_PrivateKey
class	NR_PublicKey
class	NR_Signature_Operation
class	NR_Verification_Operation
class	Null_Padding
class	Null_RNG
class	OctetString
class	OFB
class	OID
class	OneAndZeros_Padding
class	OpenPGP_S2K
class	OpenSSL_Engine
class	OSSL_BN
class	OSSL_BN_CTX
class	Output_Buffers
class	Parallel
class	PBE
class	PBE_PKCS5v15
class	PBE_PKCS5v20
class	PBKDF
class	Pipe
class	PK_Decryptor
class	PK_Decryptor_EME
class	PK_Decryptor_Filter
class	PK_Encryptor
class	PK_Encryptor_EME
class	PK_Encryptor_Filter
class	PK_Key_Agreement
class	PK_Key_Agreement_Key
class	PK_Signer
class	PK_Signer_Filter
class	PK_Verifier
class	PK_Verifier_Filter
class	PKCS10_Request
class	PKCS5_PBKDF1
class	PKCS5_PBKDF2
class	PKCS7_Padding
struct	PKCS8_Exception
class	PointGFp
struct	Policy_Violation
class	Pooling_Allocator
class	Power_Mod
class	Private_Key
struct	PRNG_Unseeded
class	Pthread_Mutex_Factory
class	Public_Key
class	RandomNumberGenerator
class	Randpool
class	RC2
class	Record_Reader
class	Record_Writer
class	RIPEMD_128
class	RIPEMD_160
class	RSA_Private_Operation
class	RSA_PrivateKey
class	RSA_Public_Operation
class	RSA_PublicKey
class	RTSS_Share
class	RW_PrivateKey
class	RW_PublicKey
class	RW_Signature_Operation
class	RW_Verification_Operation
class	SAFER_SK
class	Salsa20
class	SCAN_Name
class	SecureQueue
class	SecureVector
class	SEED
struct	Self_Test_Failure
class	Serpent
class	Serpent_SIMD
class	Serpent_X86_32
class	Server_Hello
class	Server_Hello_Done
class	Server_Key_Exchange
class	SessionKeys
class	SHA_160
class	SHA_160_SSE2
class	SHA_160_X86_32
class	SHA_160_X86_64
class	SHA_224
class	SHA_256
class	SHA_384
class	SHA_512
class	SIMD_Engine
class	SIMD_Scalar
class	Skein_512
class	Skipjack
class	Square
class	SRP6_Server_Session
class	SSL3_MAC
class	SSL3_PRF
struct	Stream_IO_Error
class	StreamCipher
class	StreamCipher_Filter
class	SymmetricAlgorithm
class	TEA
class	Tiger
class	TLS_12_PRF
class	TLS_Client
class	TLS_Connection
class	TLS_Data_Reader
class	TLS_Exception
class	TLS_Policy
class	TLS_PRF
class	TLS_Server
class	TripleDES
class	Turing
class	Twofish
struct	Unexpected_Message
class	Unix_EntropySource
struct	Unix_Program
class	User_Interface
class	Whirlpool
class	WiderWake_41_BE
class	Win32_CAPI_EntropySource
class	Win32_EntropySource
class	Win32_Mutex_Factory
class	X509_CA
class	X509_Cert_Options
class	X509_Certificate
class	X509_CRL
class	X509_DN
class	X509_Object
class	X509_Store
class	X509_Time
class	X942_PRF
class	XTEA
class	XTEA_SIMD
class	XTS_Decryption
class	XTS_Encryption
class	Zlib_Compression
class	Zlib_Decompression

Typedefs
typedef unsigned char	byte
typedef EC_Group	EC_Domain_Params
typedef std::runtime_error	Exception
typedef OctetString	InitializationVector
typedef std::invalid_argument	Invalid_Argument
typedef PK_Decryptor_EME	PK_Decryptor_MR_with_EME
typedef PK_Encryptor_EME	PK_Encryptor_MR_with_EME
typedef PK_Key_Agreement_Key	PK_KA_Key
typedef Private_Key	PKCS8_PrivateKey
typedef PBKDF	S2K
typedef signed int	s32bit
typedef OctetString	SymmetricKey
typedef unsigned short	u16bit
typedef unsigned int	u32bit
typedef unsigned long long	u64bit
typedef Public_Key	X509_PublicKey

Enumerations
enum	Alert_Level { WARNING = 1 , FATAL = 2 }
enum	Alert_Type {   CLOSE_NOTIFY = 0 , UNEXPECTED_MESSAGE = 10 , BAD_RECORD_MAC = 20 , DECRYPTION_FAILED = 21 ,   RECORD_OVERFLOW = 22 , DECOMPRESSION_FAILURE = 30 , HANDSHAKE_FAILURE = 40 , BAD_CERTIFICATE = 42 ,   UNSUPPORTED_CERTIFICATE = 43 , CERTIFICATE_REVOKED = 44 , CERTIFICATE_EXPIRED = 45 , CERTIFICATE_UNKNOWN = 46 ,   ILLEGAL_PARAMETER = 47 , UNKNOWN_CA = 48 , ACCESS_DENIED = 49 , DECODE_ERROR = 50 ,   DECRYPT_ERROR = 51 , EXPORT_RESTRICTION = 60 , PROTOCOL_VERSION = 70 , INSUFFICIENT_SECURITY = 71 ,   INTERNAL_ERROR = 80 , USER_CANCELED = 90 , NO_RENEGOTIATION = 100 , UNKNOWN_PSK_IDENTITY = 115 ,   NO_ALERT_TYPE = 0xFFFF }
enum	ASN1_Tag {   UNIVERSAL = 0x00 , APPLICATION = 0x40 , CONTEXT_SPECIFIC = 0x80 , PRIVATE = 0xC0 ,   CONSTRUCTED = 0x20 , 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 ,   NO_OBJECT = 0xFF00 , DIRECTORY_STRING = 0xFF01 }
enum	Certificate_Type { RSA_CERT = 1 , DSS_CERT = 2 , DH_RSA_CERT = 3 , DH_DSS_CERT = 4 }
enum	Character_Set { LOCAL_CHARSET , UCS2_CHARSET , UTF8_CHARSET , LATIN1_CHARSET }
enum	Cipher_Dir { ENCRYPTION , DECRYPTION }
enum	Ciphersuite_Code {   TLS_RSA_WITH_RC4_128_MD5 = 0x0004 , TLS_RSA_WITH_RC4_128_SHA = 0x0005 , TLS_RSA_WITH_3DES_EDE_CBC_SHA = 0x000A , TLS_RSA_WITH_AES_128_CBC_SHA = 0x002F ,   TLS_RSA_WITH_AES_256_CBC_SHA = 0x0035 , TLS_RSA_WITH_AES_128_CBC_SHA256 = 0x003C , TLS_RSA_WITH_AES_256_CBC_SHA256 = 0x003D , TLS_RSA_WITH_SEED_CBC_SHA = 0x0096 ,   TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA = 0x0013 , TLS_DHE_DSS_WITH_AES_128_CBC_SHA = 0x0032 , TLS_DHE_DSS_WITH_AES_256_CBC_SHA = 0x0038 , TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 = 0x0040 ,   TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 = 0x006A , TLS_DHE_DSS_WITH_SEED_CBC_SHA = 0x0099 , TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA = 0x0016 , TLS_DHE_RSA_WITH_AES_128_CBC_SHA = 0x0033 ,   TLS_DHE_RSA_WITH_AES_256_CBC_SHA = 0x0039 , TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = 0x0067 , TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = 0x006B , TLS_DHE_RSA_WITH_SEED_CBC_SHA = 0x009A ,   TLS_ECDHE_ECDSA_WITH_RC4_128_SHA = 0xC007 , TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA = 0xC008 , TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = 0xC009 , TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = 0xC00A ,   TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 0xC023 , TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = 0xC024 , TLS_ECDHE_RSA_WITH_RC4_128_SHA = 0xC011 , TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA = 0xC012 ,   TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = 0xC013 , TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014 , TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 0xC027 , TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = 0xC028 ,   TLS_NO_RENEGOTIATION_SCSV = 0x00FF }
enum	Compression_Algo { NO_COMPRESSION = 0x00 }
enum	Connection_Side { CLIENT , SERVER }
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	Fault_Protection { ENABLE_FAULT_PROTECTION , DISABLE_FAULT_PROTECTION }
enum	Handshake_Type {   HELLO_REQUEST = 0 , CLIENT_HELLO = 1 , CLIENT_HELLO_SSLV2 = 255 , SERVER_HELLO = 2 ,   CERTIFICATE = 11 , SERVER_KEX = 12 , CERTIFICATE_REQUEST = 13 , SERVER_HELLO_DONE = 14 ,   CERTIFICATE_VERIFY = 15 , CLIENT_KEX = 16 , FINISHED = 20 , HANDSHAKE_CCS = 100 ,   HANDSHAKE_NONE = 101 }
enum	Key_Constraints {   NO_CONSTRAINTS = 0 , DIGITAL_SIGNATURE = 32768 , NON_REPUDIATION = 16384 , KEY_ENCIPHERMENT = 8192 ,   DATA_ENCIPHERMENT = 4096 , KEY_AGREEMENT = 2048 , KEY_CERT_SIGN = 1024 , CRL_SIGN = 512 ,   ENCIPHER_ONLY = 256 , DECIPHER_ONLY = 128 }
enum	Record_Type {   CONNECTION_CLOSED = 0 , CHANGE_CIPHER_SPEC = 20 , ALERT = 21 , HANDSHAKE = 22 ,   APPLICATION_DATA = 23 }
enum	Signature_Format { IEEE_1363 , DER_SEQUENCE }
enum	Size_Limits { MAX_PLAINTEXT_SIZE = 16*1024 , MAX_COMPRESSED_SIZE = MAX_PLAINTEXT_SIZE + 1024 , MAX_CIPHERTEXT_SIZE = MAX_COMPRESSED_SIZE + 1024 }
enum	TLS_Ciphersuite_Algos {   TLS_ALGO_SIGNER_MASK = 0xFF000000 , TLS_ALGO_SIGNER_ANON = 0x01000000 , TLS_ALGO_SIGNER_RSA = 0x02000000 , TLS_ALGO_SIGNER_DSA = 0x03000000 ,   TLS_ALGO_SIGNER_ECDSA = 0x04000000 , TLS_ALGO_KEYEXCH_MASK = 0x00FF0000 , TLS_ALGO_KEYEXCH_NOKEX = 0x00010000 , TLS_ALGO_KEYEXCH_RSA = 0x00020000 ,   TLS_ALGO_KEYEXCH_DH = 0x00030000 , TLS_ALGO_KEYEXCH_ECDH = 0x00040000 , TLS_ALGO_MAC_MASK = 0x0000FF00 , TLS_ALGO_MAC_MD5 = 0x00000100 ,   TLS_ALGO_MAC_SHA1 = 0x00000200 , TLS_ALGO_MAC_SHA256 = 0x00000300 , TLS_ALGO_MAC_SHA384 = 0x00000400 , TLS_ALGO_CIPHER_MASK = 0x000000FF ,   TLS_ALGO_CIPHER_RC4_128 = 0x00000001 , TLS_ALGO_CIPHER_3DES_CBC = 0x00000002 , TLS_ALGO_CIPHER_AES128_CBC = 0x00000003 , TLS_ALGO_CIPHER_AES256_CBC = 0x00000004 ,   TLS_ALGO_CIPHER_SEED_CBC = 0x00000005 }
enum	TLS_Handshake_Extension_Type {   TLSEXT_SERVER_NAME_INDICATION = 0 , TLSEXT_MAX_FRAGMENT_LENGTH = 1 , TLSEXT_CLIENT_CERT_URL = 2 , TLSEXT_TRUSTED_CA_KEYS = 3 ,   TLSEXT_TRUNCATED_HMAC = 4 , TLSEXT_USABLE_ELLIPTIC_CURVES = 10 , TLSEXT_EC_POINT_FORMATS = 11 , TLSEXT_SRP_IDENTIFIER = 12 ,   TLSEXT_CERTIFICATE_TYPES = 9 , TLSEXT_SESSION_TICKET = 35 }
enum	Version_Code { NO_VERSION_SET = 0x0000 , SSL_V3 = 0x0300 , TLS_V10 = 0x0301 , TLS_V11 = 0x0302 }
enum	X509_Code {   VERIFIED , UNKNOWN_X509_ERROR , CANNOT_ESTABLISH_TRUST , CERT_CHAIN_TOO_LONG ,   SIGNATURE_ERROR , POLICY_ERROR , INVALID_USAGE , CERT_FORMAT_ERROR ,   CERT_ISSUER_NOT_FOUND , CERT_NOT_YET_VALID , CERT_HAS_EXPIRED , CERT_IS_REVOKED ,   CRL_FORMAT_ERROR , CRL_ISSUER_NOT_FOUND , CRL_NOT_YET_VALID , CRL_HAS_EXPIRED ,   CA_CERT_CANNOT_SIGN , CA_CERT_NOT_FOR_CERT_ISSUER , CA_CERT_NOT_FOR_CRL_ISSUER }
enum	X509_Encoding { RAW_BER , PEM }

Functions
BigInt	abs (const BigInt &n)
std::map< std::string, double >	algorithm_benchmark (const std::string &name, Algorithm_Factory &af, RandomNumberGenerator &rng, u32bit milliseconds, size_t buf_size)
std::map< std::string, bool >	algorithm_kat (const SCAN_Name &algo_name, const std::map< std::string, std::string > &vars, Algorithm_Factory &af)
void	aont_package (RandomNumberGenerator &rng, BlockCipher *cipher, const byte input[], size_t input_len, byte output[])
void	aont_unpackage (BlockCipher *cipher, const byte input[], size_t input_len, byte output[])
template<typename T>
void	append_tls_length_value (MemoryRegion< byte > &buf, const MemoryRegion< T > &vals, size_t tag_size)
template<typename T>
void	append_tls_length_value (MemoryRegion< byte > &buf, const std::vector< T > &vals, size_t tag_size)
template<typename T>
void	append_tls_length_value (MemoryRegion< byte > &buf, const T *vals, size_t vals_size, size_t tag_size)
void	assertion_failure (const char *expr_str, const char *msg, const char *func, const char *file, int line)
size_t	base64_decode (byte output[], const char input[], size_t input_length, bool ignore_ws)
size_t	base64_decode (byte output[], const char input[], size_t input_length, size_t &input_consumed, bool final_inputs, bool ignore_ws)
size_t	base64_decode (byte output[], const std::string &input, bool ignore_ws)
SecureVector< byte >	base64_decode (const char input[], size_t input_length, bool ignore_ws)
SecureVector< byte >	base64_decode (const std::string &input, bool ignore_ws)
size_t	base64_encode (char out[], const byte in[], size_t input_length, size_t &input_consumed, bool final_inputs)
std::string	base64_encode (const byte input[], size_t input_length)
std::string	base64_encode (const MemoryRegion< byte > &input)
void	bigint_2word_mul (word a, word b, word *z1, word *z0)
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)
s32bit	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_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])
size_t	bigint_divcore (word q, word y2, word y1, word x3, word x2, word x1)
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 (word z[], size_t z_size, const word x[], size_t x_size, size_t x_sw, const word y[], size_t y_size, size_t y_sw, const word p[], size_t p_size, word p_dash, word workspace[])
void	bigint_monty_redc (word z[], size_t z_size, const word p[], size_t p_size, word p_dash, word workspace[])
void	bigint_monty_sqr (word z[], size_t z_size, const word x[], size_t x_size, size_t x_sw, const word p[], size_t p_size, word p_dash, word workspace[])
void	bigint_mul (word z[], size_t z_size, word workspace[], const word x[], size_t x_size, size_t x_sw, const word y[], size_t y_size, size_t y_sw)
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_simple_mul (word z[], const word x[], size_t x_size, const word y[], size_t y_size)
void	bigint_simple_sqr (word z[], const word x[], size_t x_size)
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)
size_t	block_size_of (const std::string &name)
void	botan_md4_x86_32_compress (u32bit digest[4], const byte input[64], u32bit M[16])
void	botan_serpent_x86_32_decrypt (const byte in[16], byte out[16], const u32bit ks[132])
void	botan_serpent_x86_32_encrypt (const byte in[16], byte out[16], const u32bit ks[132])
void	botan_serpent_x86_32_key_schedule (u32bit ks[140])
template<typename T>
void	bswap_4 (T x[4])
calendar_point	calendar_value (u64bit a_time_t)
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, const std::string &hash_fn, AlgorithmIdentifier &sig_algo)
template<typename T>
void	clear_mem (T *ptr, size_t n)
void	confirm_startup_self_tests (Algorithm_Factory &af)
template<typename InputIterator, typename OutputIterator, typename Predicate>
OutputIterator	copy_if (InputIterator current, InputIterator end, OutputIterator dest, Predicate copy_p)
template<typename T>
void	copy_mem (T *out, const T *in, size_t n)
AlternativeName	create_alt_name (const Data_Store &info)
X509_DN	create_dn (const Data_Store &info)
template<typename T>
size_t	ctz (T n)
ECDSA_Signature	decode_concatenation (const MemoryRegion< byte > &concat)
ECDSA_PublicKey *	decode_eac1_1_key (const MemoryRegion< byte > &, AlgorithmIdentifier &)
template<typename Pair>
void	delete2nd (Pair &pair)
void	divide (const BigInt &x, const BigInt &y_arg, BigInt &q, BigInt &r)
size_t	dl_work_factor (size_t bits)
SecureVector< byte >	EC2OSP (const PointGFp &point, byte format)
BigInt	gcd (const BigInt &a, const BigInt &b)
std::string	generate_bcrypt (const std::string &pass, RandomNumberGenerator &rng, u16bit work_factor)
SecureVector< byte >	generate_dsa_primes (RandomNumberGenerator &rng, Algorithm_Factory &af, BigInt &p, BigInt &q, size_t pbits, size_t qbits)
bool	generate_dsa_primes (RandomNumberGenerator &rng, Algorithm_Factory &af, BigInt &p, BigInt &q, size_t pbits, size_t qbits, const MemoryRegion< byte > &seed_c)
std::string	generate_passhash9 (const std::string &pass, RandomNumberGenerator &rng, u16bit work_factor, byte alg_id)
BigInt	generate_srp6_verifier (const std::string &identifier, const std::string &password, const MemoryRegion< byte > &salt, const std::string &group_id, const std::string &hash_id)
BlockCipher *	get_block_cipher (const std::string &algo_spec)
template<typename T>
byte	get_byte (size_t byte_num, T input)
Keyed_Filter *	get_cipher (const std::string &algo_spec, Cipher_Dir direction)
Keyed_Filter *	get_cipher (const std::string &algo_spec, const SymmetricKey &key, Cipher_Dir direction)
Keyed_Filter *	get_cipher (const std::string &algo_spec, const SymmetricKey &key, const InitializationVector &iv, Cipher_Dir direction)
Keyed_Filter *	get_cipher_mode (const BlockCipher *block_cipher, Cipher_Dir direction, const std::string &mode, const std::string &padding)
EME *	get_eme (const std::string &algo_spec)
EMSA *	get_emsa (const std::string &algo_spec)
HashFunction *	get_hash (const std::string &algo_spec)
KDF *	get_kdf (const std::string &algo_spec)
MessageAuthenticationCode *	get_mac (const std::string &algo_spec)
u64bit	get_nanoseconds_clock ()
PBE *	get_pbe (const OID &pbe_oid, DataSource &params)
PBE *	get_pbe (const std::string &algo_spec)
PBKDF *	get_pbkdf (const std::string &algo_spec)
PK_Decryptor *	get_pk_decryptor (const Private_Key &key, const std::string &eme)
PK_Encryptor *	get_pk_encryptor (const Public_Key &key, const std::string &eme)
PK_Key_Agreement *	get_pk_kas (const PK_Key_Agreement_Key &key, const std::string &kdf)
PK_Signer *	get_pk_signer (const Private_Key &key, const std::string &emsa, Signature_Format sig_format=IEEE_1363)
PK_Verifier *	get_pk_verifier (const Public_Key &key, const std::string &emsa, Signature_Format sig_format=IEEE_1363)
PBKDF *	get_s2k (const std::string &algo_spec)
StreamCipher *	get_stream_cipher (const std::string &algo_spec)
Library_State &	global_state ()
template<typename T>
size_t	hamming_weight (T n)
bool	has_mlock ()
bool	have_algorithm (const std::string &name)
bool	have_block_cipher (const std::string &algo_spec)
bool	have_hash (const std::string &algo_spec)
bool	have_mac (const std::string &algo_spec)
bool	have_stream_cipher (const std::string &algo_spec)
size_t	hex_decode (byte output[], const char input[], size_t input_length, bool ignore_ws)
size_t	hex_decode (byte output[], const char input[], size_t input_length, size_t &input_consumed, bool ignore_ws)
size_t	hex_decode (byte output[], const std::string &input, bool ignore_ws)
SecureVector< byte >	hex_decode (const char input[], size_t input_length, bool ignore_ws)
SecureVector< byte >	hex_decode (const std::string &input, bool ignore_ws)
void	hex_encode (char output[], const byte input[], size_t input_length, bool uppercase)
std::string	hex_encode (const byte input[], size_t input_length, bool uppercase)
std::string	hex_encode (const MemoryRegion< byte > &input, bool uppercase)
template<typename T>
size_t	high_bit (T n)
byte	ieee1363_hash_id (const std::string &name)
BigInt	inverse_mod (const BigInt &n, const BigInt &mod)
std::string	ipv4_to_string (u32bit ip)
s32bit	jacobi (const BigInt &a, const BigInt &n)
size_t	keylength_multiple_of (const std::string &name)
BigInt	lcm (const BigInt &a, const BigInt &b)
template<typename T>
T	load_be (const byte in[], size_t off)
template<typename T>
void	load_be (const byte in[], T &x0, T &x1)
template<typename T>
void	load_be (const byte in[], T &x0, T &x1, T &x2, T &x3)
template<typename T>
void	load_be (const byte 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 byte in[], size_t count)
template<>
u16bit	load_be< u16bit > (const byte in[], size_t off)
template<>
u32bit	load_be< u32bit > (const byte in[], size_t off)
template<>
u64bit	load_be< u64bit > (const byte in[], size_t off)
template<typename T>
T	load_le (const byte in[], size_t off)
template<typename T>
void	load_le (const byte in[], T &x0, T &x1)
template<typename T>
void	load_le (const byte in[], T &x0, T &x1, T &x2, T &x3)
template<typename T>
void	load_le (const byte 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 byte in[], size_t count)
template<>
u16bit	load_le< u16bit > (const byte in[], size_t off)
template<>
u32bit	load_le< u32bit > (const byte in[], size_t off)
template<>
u64bit	load_le< u64bit > (const byte in[], size_t off)
bool	lock_mem (void *ptr, size_t bytes)
template<typename T>
size_t	low_bit (T n)
size_t	low_zero_bits (const BigInt &n)
EAC1_1_CVC	make_cvc_cert (PK_Signer &signer, MemoryRegion< byte > const &public_key, ASN1_Car const &car, ASN1_Chr const &chr, byte holder_auth_templ, ASN1_Ced ced, ASN1_Cex cex, RandomNumberGenerator &rng)
Private_Key *	make_private_key (const AlgorithmIdentifier &alg_id, const MemoryRegion< byte > &key_bits, RandomNumberGenerator &rng)
Public_Key *	make_public_key (const AlgorithmIdentifier &alg_id, const MemoryRegion< byte > &key_bits)
u16bit	make_u16bit (byte i0, byte i1)
u32bit	make_u32bit (byte i0, byte i1, byte i2, byte i3)
u64bit	make_u64bit (byte i0, byte i1, byte i2, byte i3, byte i4, byte i5, byte i6, byte i7)
size_t	max_keylength_of (const std::string &name)
size_t	min_keylength_of (const std::string &name)
BigInt	mul_add (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)
bool	operator!= (const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)
bool	operator!= (const ASN1_EAC_String &lhs, const ASN1_EAC_String &rhs)
bool	operator!= (const BigInt &a, const BigInt &b)
bool	operator!= (const CRL_Entry &a1, const CRL_Entry &a2)
bool	operator!= (const CurveGFp &lhs, const CurveGFp &rhs)
bool	operator!= (const EAC_Time &t1, const EAC_Time &t2)
bool	operator!= (const EC_Group &lhs, const EC_Group &rhs)
bool	operator!= (const ECDSA_Signature &lhs, const ECDSA_Signature &rhs)
bool	operator!= (const OctetString &s1, const OctetString &s2)
bool	operator!= (const OID &a, const OID &b)
bool	operator!= (const PointGFp &lhs, const PointGFp &rhs)
bool	operator!= (const X509_Certificate &cert1, const X509_Certificate &cert2)
bool	operator!= (const X509_DN &dn1, const X509_DN &dn2)
bool BOTAN_DLL	operator!= (const X509_Time &, const X509_Time &)
bool	operator!= (EAC1_1_ADO const &lhs, EAC1_1_ADO const &rhs)
bool	operator!= (EAC1_1_CVC const &lhs, EAC1_1_CVC const &rhs)
bool	operator!= (EAC1_1_Req const &lhs, EAC1_1_Req const &rhs)
BigInt	operator% (const BigInt &n, const BigInt &mod)
word	operator% (const BigInt &n, word mod)
PointGFp	operator* (const BigInt &scalar, const PointGFp &point)
BigInt	operator* (const BigInt &x, const BigInt &y)
PointGFp	operator* (const PointGFp &point, const BigInt &scalar)
BigInt	operator+ (const BigInt &x, const BigInt &y)
OctetString	operator+ (const OctetString &k1, const OctetString &k2)
OID	operator+ (const OID &oid, u32bit component)
PointGFp	operator+ (const PointGFp &lhs, const PointGFp &rhs)
template<typename T>
MemoryRegion< T > &	operator+= (MemoryRegion< T > &out, const MemoryRegion< T > &in)
template<typename T, typename L>
MemoryRegion< T > &	operator+= (MemoryRegion< T > &out, const std::pair< const T *, L > &in)
template<typename T, typename L>
MemoryRegion< T > &	operator+= (MemoryRegion< T > &out, const std::pair< T *, L > &in)
template<typename T>
MemoryRegion< T > &	operator+= (MemoryRegion< T > &out, T 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 BigInt &a, const BigInt &b)
bool	operator< (const EAC_Time &t1, const EAC_Time &t2)
bool	operator< (const OID &a, const OID &b)
bool	operator< (const X509_DN &dn1, const X509_DN &dn2)
bool BOTAN_DLL	operator< (const X509_Time &, const X509_Time &)
BigInt	operator<< (const BigInt &x, size_t shift)
int	operator<< (int fd, Pipe &pipe)
BOTAN_DLL std::ostream &	operator<< (std::ostream &out, Pipe &pipe)
std::ostream &	operator<< (std::ostream &stream, const BigInt &n)
bool	operator<= (const BigInt &a, const BigInt &b)
bool	operator<= (const EAC_Time &t1, const EAC_Time &t2)
bool BOTAN_DLL	operator<= (const X509_Time &, const X509_Time &)
bool	operator== (const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)
bool	operator== (const ASN1_EAC_String &lhs, const ASN1_EAC_String &rhs)
bool	operator== (const BigInt &a, const BigInt &b)
bool	operator== (const CRL_Entry &a1, const CRL_Entry &a2)
bool	operator== (const EAC_Time &t1, const EAC_Time &t2)
bool	operator== (const OctetString &s1, const OctetString &s2)
bool	operator== (const X509_DN &dn1, const X509_DN &dn2)
bool BOTAN_DLL	operator== (const X509_Time &, const X509_Time &)
bool	operator> (const BigInt &a, const BigInt &b)
bool	operator> (const EAC_Time &t1, const EAC_Time &t2)
bool BOTAN_DLL	operator> (const X509_Time &, const X509_Time &)
bool	operator>= (const BigInt &a, const BigInt &b)
bool	operator>= (const EAC_Time &t1, const EAC_Time &t2)
bool BOTAN_DLL	operator>= (const X509_Time &, const X509_Time &)
BigInt	operator>> (const BigInt &x, size_t shift)
int	operator>> (int fd, Pipe &pipe)
BOTAN_DLL std::istream &	operator>> (std::istream &in, Pipe &pipe)
std::istream &	operator>> (std::istream &stream, BigInt &n)
OctetString	operator^ (const OctetString &k1, const OctetString &k2)
PointGFp	OS2ECP (const byte data[], size_t data_len, const CurveGFp &curve)
PointGFp	OS2ECP (const MemoryRegion< byte > &data, const CurveGFp &curve)
size_t	output_length_of (const std::string &name)
std::vector< std::string >	parse_algorithm_name (const std::string &namex)
std::vector< u32bit >	parse_asn1_oid (const std::string &oid)
bool	passes_self_tests (Algorithm_Factory &af)
SecureVector< byte >	PGP_decode (DataSource &source, std::string &label)
SecureVector< byte >	PGP_decode (DataSource &source, std::string &label, std::map< std::string, std::string > &headers)
std::string	PGP_encode (const byte input[], size_t length, const std::string &label, const std::map< std::string, std::string > &headers)
std::string	PGP_encode (const byte input[], size_t length, const std::string &type)
MemoryVector< byte >	pkcs_hash_id (const std::string &name)
BigInt	power_mod (const BigInt &base, const BigInt &exp, const BigInt &mod)
template<typename T>
bool	power_of_2 (T arg)
template<typename T>
void	prefetch_readonly (const T *addr, size_t length)
template<typename T>
void	prefetch_readwrite (const T *addr, size_t length)
bool	primality_test (const BigInt &n, RandomNumberGenerator &rng, size_t level)
bool	quick_check_prime (const BigInt &n, 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)
BigInt BOTAN_DLL	ressol (const BigInt &x, const BigInt &p)
const BlockCipher *	retrieve_block_cipher (const std::string &algo_spec)
const HashFunction *	retrieve_hash (const std::string &algo_spec)
const MessageAuthenticationCode *	retrieve_mac (const std::string &algo_spec)
const StreamCipher *	retrieve_stream_cipher (const std::string &algo_spec)
u16bit	reverse_bytes (u16bit val)
u32bit	reverse_bytes (u32bit val)
u64bit	reverse_bytes (u64bit val)
SecureVector< byte >	rfc3394_keyunwrap (const MemoryRegion< byte > &key, const SymmetricKey &kek, Algorithm_Factory &af)
SecureVector< byte >	rfc3394_keywrap (const MemoryRegion< byte > &key, const SymmetricKey &kek, Algorithm_Factory &af)
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)
template<typename T>
T	round_up (T n, T align_to)
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 T>
void	set_mem (T *ptr, size_t n, byte val)
template<typename T>
size_t	significant_bytes (T n)
std::vector< std::string >	split_on (const std::string &str, char delim)
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 MemoryRegion< byte > &salt, const BigInt &B, RandomNumberGenerator &rng)
std::string	srp6_group_identifier (const BigInt &N, const BigInt &g)
size_t	static_provider_weight (const std::string &prov_name)
template<typename T>
void	store_be (byte out[], T x0, T x1)
template<typename T>
void	store_be (byte out[], T x0, T x1, T x2, T x3)
template<typename T>
void	store_be (byte out[], T x0, T x1, T x2, T x3, T x4, T x5, T x6, T x7)
void	store_be (u16bit in, byte out[2])
void	store_be (u32bit in, byte out[4])
void	store_be (u64bit in, byte out[8])
template<typename T>
void	store_le (byte out[], T x0, T x1)
template<typename T>
void	store_le (byte out[], T x0, T x1, T x2, T x3)
template<typename T>
void	store_le (byte out[], T x0, T x1, T x2, T x3, T x4, T x5, T x6, T x7)
void	store_le (u16bit in, byte out[2])
void	store_le (u32bit in, byte out[4])
void	store_le (u64bit in, byte out[8])
u32bit	string_to_ipv4 (const std::string &str)
BigInt	sub_mul (const BigInt &a, const BigInt &b, const BigInt &c)
u64bit	system_time ()
u32bit	timespec_to_u32bit (const std::string &timespec)
std::string	to_string (u64bit n, size_t min_len)
u32bit	to_u32bit (const std::string &number)
void	unlock_mem (void *ptr, size_t bytes)
bool	verify_prime (const BigInt &n, RandomNumberGenerator &rng)
u32bit	version_datestamp ()
u32bit	version_major ()
u32bit	version_minor ()
u32bit	version_patch ()
std::string	version_string ()
void	word3_muladd (word *w2, word *w1, word *w0, word a, word b)
void	word3_muladd_2 (word *w2, word *w1, word *w0, word a, word b)
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[4], const word x[4], 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_muladd (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)
void	xor_buf (byte out[], const byte in[], const byte in2[], size_t length)
void	xor_buf (byte out[], const byte in[], size_t length)
template<typename T>
void	zeroise (MemoryRegion< T > &vec)

Variables
const u64bit	Camellia_SBOX1 [256]
const u64bit	Camellia_SBOX2 [256]
const u64bit	Camellia_SBOX3 [256]
const u64bit	Camellia_SBOX4 [256]
const u64bit	Camellia_SBOX5 [256]
const u64bit	Camellia_SBOX6 [256]
const u64bit	Camellia_SBOX7 [256]
const u64bit	Camellia_SBOX8 [256]
const u32bit	CAST_SBOX1 [256]
const u32bit	CAST_SBOX2 [256]
const u32bit	CAST_SBOX3 [256]
const u32bit	CAST_SBOX4 [256]
const u64bit	DES_FPTAB1 [256]
const u64bit	DES_FPTAB2 [256]
const u64bit	DES_IPTAB1 [256]
const u64bit	DES_IPTAB2 [256]
const u32bit	DES_SPBOX1 [256]
const u32bit	DES_SPBOX2 [256]
const u32bit	DES_SPBOX3 [256]
const u32bit	DES_SPBOX4 [256]
const u32bit	DES_SPBOX5 [256]
const u32bit	DES_SPBOX6 [256]
const u32bit	DES_SPBOX7 [256]
const u32bit	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 u16bit BOTAN_DLL	PRIMES []

Detailed Description

Dynamically Loaded Engine (C) 2010 Jack Lloyd

Distributed under the terms of the Botan license

Dynamically Loaded Object (C) 2010 Jack Lloyd

Distributed under the terms of the Botan license

The primary namespace for the botan library

Typedef Documentation

byte

typedef unsigned char Botan::byte

Typedef representing an unsigned 8-bit quantity

Definition at line 22 of file types.h.

EC_Domain_Params

typedef EC_Group Botan::EC_Domain_Params

Definition at line 139 of file ec_group.h.

Exception

typedef std::runtime_error Botan::Exception

Definition at line 19 of file exceptn.h.

InitializationVector

typedef OctetString Botan::InitializationVector

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

Definition at line 152 of file symkey.h.

Invalid_Argument

typedef std::invalid_argument Botan::Invalid_Argument

Definition at line 20 of file exceptn.h.

PK_Decryptor_MR_with_EME

typedef PK_Decryptor_EME Botan::PK_Decryptor_MR_with_EME

Definition at line 446 of file pubkey.h.

PK_Encryptor_MR_with_EME

typedef PK_Encryptor_EME Botan::PK_Encryptor_MR_with_EME

Definition at line 445 of file pubkey.h.

PK_KA_Key

typedef PK_Key_Agreement_Key Botan::PK_KA_Key

Definition at line 132 of file pk_keys.h.

PKCS8_PrivateKey

typedef Private_Key Botan::PKCS8_PrivateKey

Definition at line 134 of file pk_keys.h.

S2K

typedef PBKDF Botan::S2K

For compatability with 1.8

Definition at line 49 of file pbkdf.h.

s32bit

typedef signed int Botan::s32bit

Typedef representing a signed 32-bit quantity

Definition at line 37 of file types.h.

SymmetricKey

typedef OctetString Botan::SymmetricKey

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

Definition at line 147 of file symkey.h.

u16bit

typedef unsigned short Botan::u16bit

Typedef representing an unsigned 16-bit quantity

Definition at line 27 of file types.h.

u32bit

typedef unsigned int Botan::u32bit

Typedef representing an unsigned 32-bit quantity

Definition at line 32 of file types.h.

u64bit

typedef unsigned long long Botan::u64bit

Typedef representing an unsigned 64-bit quantity

Definition at line 49 of file types.h.

X509_PublicKey

typedef Public_Key Botan::X509_PublicKey

Definition at line 133 of file pk_keys.h.

Enumeration Type Documentation

Alert_Level

enum Botan::Alert_Level

Enumerator
WARNING
FATAL

Definition at line 57 of file tls_magic.h.

                 {
   WARNING                 = 1,
   FATAL                   = 2
};

Alert_Type

enum Botan::Alert_Type

Enumerator
CLOSE_NOTIFY
UNEXPECTED_MESSAGE
BAD_RECORD_MAC
DECRYPTION_FAILED
RECORD_OVERFLOW
DECOMPRESSION_FAILURE
HANDSHAKE_FAILURE
BAD_CERTIFICATE
UNSUPPORTED_CERTIFICATE
CERTIFICATE_REVOKED
CERTIFICATE_EXPIRED
CERTIFICATE_UNKNOWN
ILLEGAL_PARAMETER
UNKNOWN_CA
ACCESS_DENIED
DECODE_ERROR
DECRYPT_ERROR
EXPORT_RESTRICTION
PROTOCOL_VERSION
INSUFFICIENT_SECURITY
INTERNAL_ERROR
USER_CANCELED
NO_RENEGOTIATION
UNKNOWN_PSK_IDENTITY
NO_ALERT_TYPE

Definition at line 62 of file tls_magic.h.

                {
   CLOSE_NOTIFY            = 0,
   UNEXPECTED_MESSAGE      = 10,
   BAD_RECORD_MAC          = 20,
   DECRYPTION_FAILED       = 21,
   RECORD_OVERFLOW         = 22,
   DECOMPRESSION_FAILURE   = 30,
   HANDSHAKE_FAILURE       = 40,
   BAD_CERTIFICATE         = 42,
   UNSUPPORTED_CERTIFICATE = 43,
   CERTIFICATE_REVOKED     = 44,
   CERTIFICATE_EXPIRED     = 45,
   CERTIFICATE_UNKNOWN     = 46,
   ILLEGAL_PARAMETER       = 47,
   UNKNOWN_CA              = 48,
   ACCESS_DENIED           = 49,
   DECODE_ERROR            = 50,
   DECRYPT_ERROR           = 51,
   EXPORT_RESTRICTION      = 60,
   PROTOCOL_VERSION        = 70,
   INSUFFICIENT_SECURITY   = 71,
   INTERNAL_ERROR          = 80,
   USER_CANCELED           = 90,
   NO_RENEGOTIATION        = 100,
 
   UNKNOWN_PSK_IDENTITY    = 115,
 
   NO_ALERT_TYPE           = 0xFFFF
};

ASN1_Tag

enum Botan::ASN1_Tag

ASN.1 Type and Class Tags

Enumerator
UNIVERSAL
APPLICATION
CONTEXT_SPECIFIC
PRIVATE
CONSTRUCTED
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
NO_OBJECT
DIRECTORY_STRING

Definition at line 19 of file asn1_int.h.

              {
   UNIVERSAL        = 0x00,
   APPLICATION      = 0x40,
   CONTEXT_SPECIFIC = 0x80,
   PRIVATE          = 0xC0,
 
   CONSTRUCTED      = 0x20,
 
   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,
 
   NO_OBJECT        = 0xFF00,
   DIRECTORY_STRING = 0xFF01
};

Certificate_Type

enum Botan::Certificate_Type

Enumerator
RSA_CERT
DSS_CERT
DH_RSA_CERT
DH_DSS_CERT

Definition at line 92 of file tls_magic.h.

                      {
   RSA_CERT    = 1,
   DSS_CERT    = 2,
   DH_RSA_CERT = 3,
   DH_DSS_CERT = 4
};

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 87 of file sym_algo.h.

{ ENCRYPTION, DECRYPTION };

Ciphersuite_Code

enum Botan::Ciphersuite_Code

Enumerator
TLS_RSA_WITH_RC4_128_MD5
TLS_RSA_WITH_RC4_128_SHA
TLS_RSA_WITH_3DES_EDE_CBC_SHA
TLS_RSA_WITH_AES_128_CBC_SHA
TLS_RSA_WITH_AES_256_CBC_SHA
TLS_RSA_WITH_AES_128_CBC_SHA256
TLS_RSA_WITH_AES_256_CBC_SHA256
TLS_RSA_WITH_SEED_CBC_SHA
TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA
TLS_DHE_DSS_WITH_AES_128_CBC_SHA
TLS_DHE_DSS_WITH_AES_256_CBC_SHA
TLS_DHE_DSS_WITH_AES_128_CBC_SHA256
TLS_DHE_DSS_WITH_AES_256_CBC_SHA256
TLS_DHE_DSS_WITH_SEED_CBC_SHA
TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA
TLS_DHE_RSA_WITH_AES_128_CBC_SHA
TLS_DHE_RSA_WITH_AES_256_CBC_SHA
TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
TLS_DHE_RSA_WITH_SEED_CBC_SHA
TLS_ECDHE_ECDSA_WITH_RC4_128_SHA
TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
TLS_ECDHE_RSA_WITH_RC4_128_SHA
TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
TLS_NO_RENEGOTIATION_SCSV

Definition at line 99 of file tls_magic.h.

                      {
   TLS_RSA_WITH_RC4_128_MD5                 = 0x0004,
   TLS_RSA_WITH_RC4_128_SHA                 = 0x0005,
 
   TLS_RSA_WITH_3DES_EDE_CBC_SHA            = 0x000A,
   TLS_RSA_WITH_AES_128_CBC_SHA             = 0x002F,
   TLS_RSA_WITH_AES_256_CBC_SHA             = 0x0035,
   TLS_RSA_WITH_AES_128_CBC_SHA256          = 0x003C,
   TLS_RSA_WITH_AES_256_CBC_SHA256          = 0x003D,
   TLS_RSA_WITH_SEED_CBC_SHA                = 0x0096,
 
   TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA        = 0x0013,
   TLS_DHE_DSS_WITH_AES_128_CBC_SHA         = 0x0032,
   TLS_DHE_DSS_WITH_AES_256_CBC_SHA         = 0x0038,
   TLS_DHE_DSS_WITH_AES_128_CBC_SHA256      = 0x0040,
   TLS_DHE_DSS_WITH_AES_256_CBC_SHA256      = 0x006A,
   TLS_DHE_DSS_WITH_SEED_CBC_SHA            = 0x0099,
 
   TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA        = 0x0016,
   TLS_DHE_RSA_WITH_AES_128_CBC_SHA         = 0x0033,
   TLS_DHE_RSA_WITH_AES_256_CBC_SHA         = 0x0039,
   TLS_DHE_RSA_WITH_AES_128_CBC_SHA256      = 0x0067,
   TLS_DHE_RSA_WITH_AES_256_CBC_SHA256      = 0x006B,
   TLS_DHE_RSA_WITH_SEED_CBC_SHA            = 0x009A,
 
   TLS_ECDHE_ECDSA_WITH_RC4_128_SHA         = 0xC007,
   TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA    = 0xC008,
   TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA     = 0xC009,
   TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA     = 0xC00A,
   TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256  = 0xC023,
   TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384  = 0xC024,
 
   TLS_ECDHE_RSA_WITH_RC4_128_SHA           = 0xC011,
   TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA      = 0xC012,
   TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA       = 0xC013,
   TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA       = 0xC014,
   TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256    = 0xC027,
   TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384    = 0xC028,
 
   TLS_NO_RENEGOTIATION_SCSV                = 0x00FF,
};

Compression_Algo

enum Botan::Compression_Algo

Enumerator
NO_COMPRESSION

Definition at line 172 of file tls_magic.h.

                      {
   NO_COMPRESSION      = 0x00
};

Connection_Side

enum Botan::Connection_Side

Enumerator
CLIENT
SERVER

Definition at line 29 of file tls_magic.h.

{ CLIENT, SERVER };

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 43 of file pubkey_enums.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 155 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
};

Fault_Protection

enum Botan::Fault_Protection

Enum marking if protection against fault attacks should be used

Enumerator
ENABLE_FAULT_PROTECTION
DISABLE_FAULT_PROTECTION

Definition at line 29 of file pubkey.h.

                      {
   ENABLE_FAULT_PROTECTION,
   DISABLE_FAULT_PROTECTION
};

Handshake_Type

enum Botan::Handshake_Type

Enumerator
HELLO_REQUEST
CLIENT_HELLO
CLIENT_HELLO_SSLV2
SERVER_HELLO
CERTIFICATE
SERVER_KEX
CERTIFICATE_REQUEST
SERVER_HELLO_DONE
CERTIFICATE_VERIFY
CLIENT_KEX
FINISHED
HANDSHAKE_CCS
HANDSHAKE_NONE

Definition at line 40 of file tls_magic.h.

                    {
   HELLO_REQUEST       = 0,
   CLIENT_HELLO        = 1,
   CLIENT_HELLO_SSLV2  = 255, // not a wire value
   SERVER_HELLO        = 2,
   CERTIFICATE         = 11,
   SERVER_KEX          = 12,
   CERTIFICATE_REQUEST = 13,
   SERVER_HELLO_DONE   = 14,
   CERTIFICATE_VERIFY  = 15,
   CLIENT_KEX          = 16,
   FINISHED            = 20,
 
   HANDSHAKE_CCS       = 100,
   HANDSHAKE_NONE      = 101
};

Key_Constraints

enum Botan::Key_Constraints

X.509v3 Key Constraints.

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 18 of file pubkey_enums.h.

                     {
   NO_CONSTRAINTS     = 0,
   DIGITAL_SIGNATURE  = 32768,
   NON_REPUDIATION    = 16384,
   KEY_ENCIPHERMENT   = 8192,
   DATA_ENCIPHERMENT  = 4096,
   KEY_AGREEMENT      = 2048,
   KEY_CERT_SIGN      = 1024,
   CRL_SIGN           = 512,
   ENCIPHER_ONLY      = 256,
   DECIPHER_ONLY      = 128
};

Record_Type

enum Botan::Record_Type

Enumerator
CONNECTION_CLOSED
CHANGE_CIPHER_SPEC
ALERT
HANDSHAKE
APPLICATION_DATA

Definition at line 31 of file tls_magic.h.

                 {
   CONNECTION_CLOSED  = 0,
 
   CHANGE_CIPHER_SPEC = 20,
   ALERT              = 21,
   HANDSHAKE          = 22,
   APPLICATION_DATA   = 23
};

Signature_Format

enum Botan::Signature_Format

The two types of signature format supported by Botan.

Enumerator
IEEE_1363
DER_SEQUENCE

Definition at line 24 of file pubkey.h.

{ IEEE_1363, DER_SEQUENCE };

Size_Limits

enum Botan::Size_Limits

Protocol Constants for SSL/TLS

Enumerator
MAX_PLAINTEXT_SIZE
MAX_COMPRESSED_SIZE
MAX_CIPHERTEXT_SIZE

Definition at line 16 of file tls_magic.h.

                 {
   MAX_PLAINTEXT_SIZE = 16*1024,
   MAX_COMPRESSED_SIZE = MAX_PLAINTEXT_SIZE + 1024,
   MAX_CIPHERTEXT_SIZE = MAX_COMPRESSED_SIZE + 1024
};

TLS_Ciphersuite_Algos

enum Botan::TLS_Ciphersuite_Algos

Enumerator
TLS_ALGO_SIGNER_MASK
TLS_ALGO_SIGNER_ANON
TLS_ALGO_SIGNER_RSA
TLS_ALGO_SIGNER_DSA
TLS_ALGO_SIGNER_ECDSA
TLS_ALGO_KEYEXCH_MASK
TLS_ALGO_KEYEXCH_NOKEX
TLS_ALGO_KEYEXCH_RSA
TLS_ALGO_KEYEXCH_DH
TLS_ALGO_KEYEXCH_ECDH
TLS_ALGO_MAC_MASK
TLS_ALGO_MAC_MD5
TLS_ALGO_MAC_SHA1
TLS_ALGO_MAC_SHA256
TLS_ALGO_MAC_SHA384
TLS_ALGO_CIPHER_MASK
TLS_ALGO_CIPHER_RC4_128
TLS_ALGO_CIPHER_3DES_CBC
TLS_ALGO_CIPHER_AES128_CBC
TLS_ALGO_CIPHER_AES256_CBC
TLS_ALGO_CIPHER_SEED_CBC

Definition at line 145 of file tls_magic.h.

                           {
   TLS_ALGO_SIGNER_MASK       = 0xFF000000,
   TLS_ALGO_SIGNER_ANON       = 0x01000000,
   TLS_ALGO_SIGNER_RSA        = 0x02000000,
   TLS_ALGO_SIGNER_DSA        = 0x03000000,
   TLS_ALGO_SIGNER_ECDSA      = 0x04000000,
 
   TLS_ALGO_KEYEXCH_MASK      = 0x00FF0000,
   TLS_ALGO_KEYEXCH_NOKEX     = 0x00010000,
   TLS_ALGO_KEYEXCH_RSA       = 0x00020000,
   TLS_ALGO_KEYEXCH_DH        = 0x00030000,
   TLS_ALGO_KEYEXCH_ECDH      = 0x00040000,
 
   TLS_ALGO_MAC_MASK          = 0x0000FF00,
   TLS_ALGO_MAC_MD5           = 0x00000100,
   TLS_ALGO_MAC_SHA1          = 0x00000200,
   TLS_ALGO_MAC_SHA256        = 0x00000300,
   TLS_ALGO_MAC_SHA384        = 0x00000400,
 
   TLS_ALGO_CIPHER_MASK       = 0x000000FF,
   TLS_ALGO_CIPHER_RC4_128    = 0x00000001,
   TLS_ALGO_CIPHER_3DES_CBC   = 0x00000002,
   TLS_ALGO_CIPHER_AES128_CBC = 0x00000003,
   TLS_ALGO_CIPHER_AES256_CBC = 0x00000004,
   TLS_ALGO_CIPHER_SEED_CBC   = 0x00000005
};

TLS_Handshake_Extension_Type

enum Botan::TLS_Handshake_Extension_Type

Enumerator
TLSEXT_SERVER_NAME_INDICATION
TLSEXT_MAX_FRAGMENT_LENGTH
TLSEXT_CLIENT_CERT_URL
TLSEXT_TRUSTED_CA_KEYS
TLSEXT_TRUNCATED_HMAC
TLSEXT_USABLE_ELLIPTIC_CURVES
TLSEXT_EC_POINT_FORMATS
TLSEXT_SRP_IDENTIFIER
TLSEXT_CERTIFICATE_TYPES
TLSEXT_SESSION_TICKET

Definition at line 176 of file tls_magic.h.

                                  {
   TLSEXT_SERVER_NAME_INDICATION = 0,
   TLSEXT_MAX_FRAGMENT_LENGTH    = 1,
   TLSEXT_CLIENT_CERT_URL        = 2,
   TLSEXT_TRUSTED_CA_KEYS        = 3,
   TLSEXT_TRUNCATED_HMAC         = 4,
 
   TLSEXT_USABLE_ELLIPTIC_CURVES = 10,
   TLSEXT_EC_POINT_FORMATS       = 11,
 
   TLSEXT_SRP_IDENTIFIER         = 12,
 
   TLSEXT_CERTIFICATE_TYPES      = 9,
   TLSEXT_SESSION_TICKET         = 35
};

Version_Code

enum Botan::Version_Code

Enumerator
NO_VERSION_SET
SSL_V3
TLS_V10
TLS_V11

Definition at line 22 of file tls_magic.h.

                  {
   NO_VERSION_SET     = 0x0000,
   SSL_V3             = 0x0300,
   TLS_V10            = 0x0301,
   TLS_V11            = 0x0302
};

X509_Code

enum Botan::X509_Code

X.509 Certificate Validation Result

Enumerator
VERIFIED
UNKNOWN_X509_ERROR
CANNOT_ESTABLISH_TRUST
CERT_CHAIN_TOO_LONG
SIGNATURE_ERROR
POLICY_ERROR
INVALID_USAGE
CERT_FORMAT_ERROR
CERT_ISSUER_NOT_FOUND
CERT_NOT_YET_VALID
CERT_HAS_EXPIRED
CERT_IS_REVOKED
CRL_FORMAT_ERROR
CRL_ISSUER_NOT_FOUND
CRL_NOT_YET_VALID
CRL_HAS_EXPIRED
CA_CERT_CANNOT_SIGN
CA_CERT_NOT_FOR_CERT_ISSUER
CA_CERT_NOT_FOR_CRL_ISSUER

Definition at line 20 of file x509stor.h.

               {
   VERIFIED,
   UNKNOWN_X509_ERROR,
   CANNOT_ESTABLISH_TRUST,
   CERT_CHAIN_TOO_LONG,
   SIGNATURE_ERROR,
   POLICY_ERROR,
   INVALID_USAGE,
 
   CERT_FORMAT_ERROR,
   CERT_ISSUER_NOT_FOUND,
   CERT_NOT_YET_VALID,
   CERT_HAS_EXPIRED,
   CERT_IS_REVOKED,
 
   CRL_FORMAT_ERROR,
   CRL_ISSUER_NOT_FOUND,
   CRL_NOT_YET_VALID,
   CRL_HAS_EXPIRED,
 
   CA_CERT_CANNOT_SIGN,
   CA_CERT_NOT_FOR_CERT_ISSUER,
   CA_CERT_NOT_FOR_CRL_ISSUER
};

X509_Encoding

enum Botan::X509_Encoding

The two types of X509 encoding supported by Botan.

Enumerator
RAW_BER
PEM

Definition at line 67 of file pubkey_enums.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 44 of file numthry.h.

{ return n.abs(); }

References abs(), and Botan::BigInt::abs().

Referenced by abs().

algorithm_benchmark()

std::map< std::string, double > BOTAN_DLL Botan::algorithm_benchmark	(	const std::string &	name,
		Algorithm_Factory &	af,
		RandomNumberGenerator &	rng,
		u32bit	milliseconds,
		size_t	buf_size )

Algorithm benchmark

Parameters

name	the name of the algorithm to test (cipher, hash, or MAC)
af	the algorithm factory used to create objects
rng	the rng to use to generate random inputs
milliseconds	total time for the benchmark to run
buf_size	size of buffer to benchmark against, in KiB

Returns

results a map from provider to speed in mebibytes per second

Definition at line 122 of file benchmark.cpp.

   {
   std::vector<std::string> providers = af.providers_of(name);
   std::map<std::string, double> all_results;
 
   if(providers.empty()) // no providers, nothing to do
      return all_results;
 
   const u64bit ns_per_provider =
      (static_cast<u64bit>(milliseconds) * 1000 * 1000) / providers.size();
 
   std::vector<byte> buf(buf_size * 1024);
   rng.randomize(&buf[0], buf.size());
 
   for(size_t i = 0; i != providers.size(); ++i)
      {
      const std::string provider = providers[i];
 
      std::pair<u64bit, u64bit> results(0, 0);
 
      if(const BlockCipher* proto =
            af.prototype_block_cipher(name, provider))
         {
         std::auto_ptr<BlockCipher> block_cipher(proto->clone());
         results = bench_block_cipher(block_cipher.get(),
                                      ns_per_provider,
                                      &buf[0], buf.size());
         }
      else if(const StreamCipher* proto =
                 af.prototype_stream_cipher(name, provider))
         {
         std::auto_ptr<StreamCipher> stream_cipher(proto->clone());
         results = bench_stream_cipher(stream_cipher.get(),
                                       ns_per_provider,
                                       &buf[0], buf.size());
         }
      else if(const HashFunction* proto =
                 af.prototype_hash_function(name, provider))
         {
         std::auto_ptr<HashFunction> hash(proto->clone());
         results = bench_hash(hash.get(), ns_per_provider,
                              &buf[0], buf.size());
         }
      else if(const MessageAuthenticationCode* proto =
                 af.prototype_mac(name, provider))
         {
         std::auto_ptr<MessageAuthenticationCode> mac(proto->clone());
         results = bench_mac(mac.get(), ns_per_provider,
                             &buf[0], buf.size());
         }
 
      if(results.first && results.second)
         {
         /* 953.67 == 1000 * 1000 * 1000 / 1024 / 1024 - the conversion
            factor from bytes per nanosecond to mebibytes per second.
         */
         double speed = (953.67 * results.first) / results.second;
         all_results[provider] = speed;
         }
      }
 
   return all_results;
   }

References algorithm_benchmark(), Botan::Algorithm_Factory::prototype_block_cipher(), Botan::Algorithm_Factory::prototype_hash_function(), Botan::Algorithm_Factory::prototype_mac(), Botan::Algorithm_Factory::prototype_stream_cipher(), Botan::Algorithm_Factory::providers_of(), and Botan::RandomNumberGenerator::randomize().

Referenced by algorithm_benchmark().

algorithm_kat()

BOTAN_DLL std::map< std::string, bool > Botan::algorithm_kat	(	const SCAN_Name &	algo_name,
		const std::map< std::string, std::string > &	vars,
		Algorithm_Factory &	af )

Run a set of algorithm KATs (known answer tests)

Parameters

algo_name	the algorithm we are testing
vars	a set of input variables for this test, all hex encoded. Keys used: "input", "output", "key", and "iv"
af	an algorithm factory

Returns

map from provider name to test result for that provider

Definition at line 38 of file selftest.cpp.

   {
   const std::string& algo = algo_name.algo_name_and_args();
 
   std::vector<std::string> providers = af.providers_of(algo);
   std::map<std::string, bool> all_results;
 
   if(providers.empty()) // no providers, nothing to do
      return all_results;
 
   const std::string input = search_map(vars, std::string("input"));
   const std::string output = search_map(vars, std::string("output"));
 
   SymmetricKey key(search_map(vars, std::string("key")));
   InitializationVector iv(search_map(vars, std::string("iv")));
 
   for(size_t i = 0; i != providers.size(); ++i)
      {
      const std::string provider = providers[i];
 
      if(const HashFunction* proto =
            af.prototype_hash_function(algo, provider))
         {
         Filter* filt = new Hash_Filter(proto->clone());
         all_results[provider] = test_filter_kat(filt, input, output);
         }
      else if(const MessageAuthenticationCode* proto =
                 af.prototype_mac(algo, provider))
         {
         Keyed_Filter* filt = new MAC_Filter(proto->clone(), key);
         all_results[provider] = test_filter_kat(filt, input, output);
         }
      else if(const StreamCipher* proto =
                 af.prototype_stream_cipher(algo, provider))
         {
         Keyed_Filter* filt = new StreamCipher_Filter(proto->clone());
         filt->set_key(key);
         filt->set_iv(iv);
 
         all_results[provider] = test_filter_kat(filt, input, output);
         }
      else if(const BlockCipher* proto =
                 af.prototype_block_cipher(algo, provider))
         {
         Keyed_Filter* enc = get_cipher_mode(proto, ENCRYPTION,
                                             algo_name.cipher_mode(),
                                             algo_name.cipher_mode_pad());
 
         Keyed_Filter* dec = get_cipher_mode(proto, DECRYPTION,
                                             algo_name.cipher_mode(),
                                             algo_name.cipher_mode_pad());
 
         if(!enc || !dec)
            {
            delete enc;
            delete dec;
            continue;
            }
 
         enc->set_key(key);
 
         if(enc->valid_iv_length(iv.length()))
            enc->set_iv(iv);
         else if(!enc->valid_iv_length(0))
            throw Invalid_IV_Length(algo, iv.length());
 
         dec->set_key(key);
 
         if(dec->valid_iv_length(iv.length()))
            dec->set_iv(iv);
         else if(!dec->valid_iv_length(0))
            throw Invalid_IV_Length(algo, iv.length());
 
         bool enc_ok = test_filter_kat(enc, input, output);
         bool dec_ok = test_filter_kat(dec, output, input);
 
         all_results[provider] = enc_ok && dec_ok;
         }
      }
 
   return all_results;
   }

References Botan::SCAN_Name::algo_name_and_args(), algorithm_kat(), Botan::SCAN_Name::cipher_mode(), Botan::SCAN_Name::cipher_mode_pad(), DECRYPTION, ENCRYPTION, get_cipher_mode(), Botan::Hash_Filter::Hash_Filter(), Botan::Invalid_IV_Length::Invalid_IV_Length(), Botan::OctetString::length(), Botan::MAC_Filter::MAC_Filter(), Botan::Algorithm_Factory::prototype_block_cipher(), Botan::Algorithm_Factory::prototype_hash_function(), Botan::Algorithm_Factory::prototype_mac(), Botan::Algorithm_Factory::prototype_stream_cipher(), Botan::Algorithm_Factory::providers_of(), search_map(), Botan::Keyed_Filter::set_iv(), Botan::Keyed_Filter::set_key(), Botan::StreamCipher_Filter::StreamCipher_Filter(), and Botan::Keyed_Filter::valid_iv_length().

Referenced by algorithm_kat().

aont_package()

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

Rivest's Package Tranform

Parameters

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

Definition at line 17 of file package.cpp.

   {
   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);
   pipe.read(output, pipe.remaining());
 
   // Set K0 (the all zero key)
   cipher->set_key(SymmetricKey(all_zeros));
 
   SecureVector<byte> buf(BLOCK_SIZE);
 
   const size_t blocks =
      (input_len + BLOCK_SIZE - 1) / BLOCK_SIZE;
 
   byte* 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[0], 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);
 
      xor_buf(final_block, buf, BLOCK_SIZE);
      }
 
   // XOR the random package key into the final block
   xor_buf(final_block, package_key.begin(), BLOCK_SIZE);
   }

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

Referenced by aont_package().

aont_unpackage()

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

Rivest's Package Tranform (Inversion)

Parameters

cipher	the block cipher to use
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.

   {
   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));
 
   SecureVector<byte> package_key(BLOCK_SIZE);
   SecureVector<byte> buf(BLOCK_SIZE);
 
   // Copy the package key (masked with the block hashes)
   copy_mem(&package_key[0],
            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[0], 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);
 
      xor_buf(&package_key[0], buf, BLOCK_SIZE);
      }
 
   Pipe pipe(new StreamCipher_Filter(new CTR_BE(cipher), package_key));
 
   pipe.process_msg(input, input_len - BLOCK_SIZE);
 
   pipe.read(output, pipe.remaining());
   }

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

Referenced by aont_unpackage().

append_tls_length_value() [1/3]

template<typename T>

void Botan::append_tls_length_value	(	MemoryRegion< byte > &	buf,
		const MemoryRegion< T > &	vals,
		size_t	tag_size )

Definition at line 169 of file tls_reader.h.

   {
   append_tls_length_value(buf, &vals[0], vals.size(), tag_size);
   }

References append_tls_length_value(), and Botan::MemoryRegion< T >::size().

append_tls_length_value() [2/3]

template<typename T>

void Botan::append_tls_length_value	(	MemoryRegion< byte > &	buf,
		const std::vector< T > &	vals,
		size_t	tag_size )

Definition at line 177 of file tls_reader.h.

   {
   append_tls_length_value(buf, &vals[0], vals.size(), tag_size);
   }

References append_tls_length_value(), and Botan::MemoryRegion< T >::size().

append_tls_length_value() [3/3]

template<typename T>

void Botan::append_tls_length_value	(	MemoryRegion< byte > &	buf,
		const T *	vals,
		size_t	vals_size,
		size_t	tag_size )

Helper function for encoding length-tagged vectors

Definition at line 145 of file tls_reader.h.

   {
   const size_t T_size = sizeof(T);
   const size_t val_bytes = T_size * vals_size;
 
   if(tag_size != 1 && tag_size != 2)
      throw std::invalid_argument("append_tls_length_value: invalid tag size");
 
   if((tag_size == 1 && val_bytes > 255) ||
      (tag_size == 2 && val_bytes > 65535))
      throw std::invalid_argument("append_tls_length_value: value too large");
 
   for(size_t i = 0; i != tag_size; ++i)
      buf.push_back(get_byte(sizeof(val_bytes)-tag_size+i, val_bytes));
 
   for(size_t i = 0; i != vals_size; ++i)
      for(size_t j = 0; j != T_size; ++j)
         buf.push_back(get_byte(j, vals[i]));
   }

References append_tls_length_value(), get_byte(), and Botan::MemoryRegion< T >::push_back().

Referenced by append_tls_length_value(), append_tls_length_value(), and append_tls_length_value().

assertion_failure()

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

Definition at line 14 of file assert.cpp.

   {
   std::ostringstream format;
 
   format << "Assertion " << expr_str << " failed ";
 
   if(msg)
      format << "(" << msg << ") ";
 
   if(func)
      format << "in " << func << " ";
 
   format << "@" << file << ":" << line;
 
   throw Internal_Error(format.str());
   }

References assertion_failure(), and Botan::Internal_Error::Internal_Error().

Referenced by assertion_failure().

base64_decode() [1/5]

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

Perform base64 decoding

Parameters

output	an array of at least input_length*3/4 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.

   {
   size_t consumed = 0;
   size_t written = base64_decode(output, input, input_length,
                                  consumed, true, ignore_ws);
 
   if(consumed != input_length)
      throw std::invalid_argument("base64_decode: input did not have full bytes");
 
   return written;
   }

References base64_decode().

base64_decode() [2/5]

size_t BOTAN_DLL Botan::base64_decode	(	byte	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 input_length*3/4 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.

   {
   /*
   * Base64 Decoder Lookup Table
   * Warning: assumes ASCII encodings
   */
   static const byte 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 };
 
   byte* out_ptr = output;
   byte 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 byte bin = BASE64_TO_BIN[static_cast<byte>(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 std::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 i = decode_buf_pos; i != 4; ++i)
               decode_buf[i] = 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<byte>(input[input_consumed])] == 0x80)
      {
      ++input_consumed;
      }
 
   size_t written = (out_ptr - output) - final_truncate;
 
   return written;
   }

References base64_decode(), and clear_mem().

Referenced by base64_decode(), base64_decode(), base64_decode(), base64_decode(), base64_decode(), Botan::Base64_Decoder::end_msg(), and Botan::Base64_Decoder::write().

base64_decode() [3/5]

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

Perform base64 decoding

Parameters

output	an array of at least input_length/3*4 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.

   {
   return base64_decode(output, &input[0], input.length(), ignore_ws);
   }

References base64_decode().

base64_decode() [4/5]

SecureVector< byte > 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.

   {
   SecureVector<byte> bin((round_up<size_t>(input_length, 4) * 3) / 4);
 
   size_t written = base64_decode(&bin[0],
                                  input,
                                  input_length,
                                  ignore_ws);
 
   bin.resize(written);
   return bin;
   }

References base64_decode(), Botan::MemoryRegion< T >::resize(), and round_up().

base64_decode() [5/5]

SecureVector< byte > 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 244 of file base64.cpp.

   {
   return base64_decode(&input[0], input.size(), ignore_ws);
   }

References base64_decode().

base64_encode() [1/3]

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

Perform base64 encoding

Parameters

output	an array of at least input_length*4/3 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 36 of file base64.cpp.

   {
   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)
      {
      byte 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;
   }

References base64_encode().

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

base64_encode() [2/3]

std::string BOTAN_DLL Botan::base64_encode	(	const byte	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 79 of file base64.cpp.

   {
   std::string output((round_up<size_t>(input_length, 3) / 3) * 4, 0);
 
   size_t consumed = 0;
   size_t produced = base64_encode(&output[0],
                                   input, input_length,
                                   consumed, true);
 
   BOTAN_ASSERT_EQUAL(consumed, input_length, "Did not consume all input");
   BOTAN_ASSERT_EQUAL(produced, output.size(), "Did not produce right amount");
 
   return output;
   }

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

base64_encode() [3/3]

std::string BOTAN_DLL Botan::base64_encode

(

const MemoryRegion< byte > &

input

)

Perform base64 encoding

Parameters

input

some input

Returns

base64adecimal representation of input

Definition at line 95 of file base64.cpp.

   {
   return base64_encode(&input[0], input.size());
   }

References base64_encode(), and Botan::MemoryRegion< T >::size().

bigint_2word_mul()

void Botan::bigint_2word_mul ( word a, word b, word * z1, word * z0 )

inline

Definition at line 54 of file mp_asm.h.

   {
   const size_t MP_HWORD_BITS = BOTAN_MP_WORD_BITS / 2;
   const word MP_HWORD_MASK = ((word)1 << MP_HWORD_BITS) - 1;
 
   const word a_hi = (a >> MP_HWORD_BITS);
   const word a_lo = (a & MP_HWORD_MASK);
   const word b_hi = (b >> MP_HWORD_BITS);
   const word b_lo = (b & MP_HWORD_MASK);
 
   word x0 = a_hi * b_hi;
   word x1 = a_lo * b_hi;
   word x2 = a_hi * b_lo;
   word x3 = a_lo * b_lo;
 
   x2 += x3 >> (MP_HWORD_BITS);
   x2 += x1;
 
   if(x2 < x1) // timing channel
      x0 += ((word)1 << MP_HWORD_BITS);
 
   *z0 = x0 + (x2 >> MP_HWORD_BITS);
   *z1 = ((x2 & MP_HWORD_MASK) << MP_HWORD_BITS) + (x3 & MP_HWORD_MASK);
   }

References bigint_2word_mul().

Referenced by bigint_2word_mul().

bigint_add2()

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

Definition at line 139 of file mp_asm.cpp.

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

References bigint_add2(), and bigint_add2_nc().

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

bigint_add2_nc()

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

Definition at line 93 of file mp_asm.cpp.

   {
   word carry = 0;
 
   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;
   }

References bigint_add2_nc(), word8_add2(), and word_add().

Referenced by bigint_add2(), and bigint_add2_nc().

bigint_add3()

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

Definition at line 148 of file mp_asm.cpp.

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

References bigint_add3(), and bigint_add3_nc().

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

bigint_add3_nc()

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

Definition at line 114 of file mp_asm.cpp.

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

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

Referenced by bigint_add3(), and bigint_add3_nc().

bigint_cmp()

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

Compare x and y

Definition at line 41 of file mp_misc.cpp.

   {
   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 j = x_size; j > 0; --j)
      {
      if(x[j-1] > y[j-1])
         return 1;
      if(x[j-1] < y[j-1])
         return -1;
      }
 
   return 0;
   }

References bigint_cmp().

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

bigint_cnd_abs()

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

Definition at line 78 of file mp_asm.cpp.

   {
   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]);
      }
   }

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

Referenced by bigint_cnd_abs().

bigint_cnd_add()

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

Definition at line 42 of file mp_asm.cpp.

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

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

Referenced by bigint_cnd_add().

bigint_cnd_sub()

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

Definition at line 64 of file mp_asm.cpp.

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

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

Referenced by bigint_cnd_sub().

bigint_cnd_swap()

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

Definition at line 25 of file mp_asm.cpp.

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

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

Referenced by bigint_cnd_swap().

bigint_comba_mul16()

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

Definition at line 594 of file mp_comba.cpp.

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

References bigint_comba_mul16(), and word3_muladd().

Referenced by bigint_comba_mul16(), and bigint_mul().

bigint_comba_mul4()

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

Definition at line 51 of file mp_comba.cpp.

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

References bigint_comba_mul4(), and word3_muladd().

Referenced by bigint_comba_mul4(), and bigint_mul().

bigint_comba_mul6()

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

Definition at line 142 of file mp_comba.cpp.

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

References bigint_comba_mul6(), and word3_muladd().

Referenced by bigint_comba_mul6(), and bigint_mul().

bigint_comba_mul8()

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

Definition at line 284 of file mp_comba.cpp.

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

References bigint_comba_mul8(), and word3_muladd().

Referenced by bigint_comba_mul8(), and bigint_mul().

bigint_comba_sqr16()

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

Definition at line 387 of file mp_comba.cpp.

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

References bigint_comba_sqr16(), word3_muladd(), and word3_muladd_2().

Referenced by bigint_comba_sqr16(), and bigint_sqr().

bigint_comba_sqr4()

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

Definition at line 18 of file mp_comba.cpp.

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

References bigint_comba_sqr4(), word3_muladd(), and word3_muladd_2().

Referenced by bigint_comba_sqr4(), and bigint_sqr().

bigint_comba_sqr6()

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

Definition at line 90 of file mp_comba.cpp.

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

References bigint_comba_sqr6(), word3_muladd(), and word3_muladd_2().

Referenced by bigint_comba_sqr6(), and bigint_sqr().

bigint_comba_sqr8()

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

Definition at line 209 of file mp_comba.cpp.

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

References bigint_comba_sqr8(), word3_muladd(), and word3_muladd_2().

Referenced by bigint_comba_sqr8(), and bigint_sqr().

bigint_divcore()

size_t Botan::bigint_divcore	(	word	q,
		word	y2,
		word	y1,
		word	x3,
		word	x2,
		word	x1 )

Definition at line 18 of file mp_misc.cpp.

   {
   // Compute (y2,y1) * q
 
   word y3 = 0;
   y1 = word_madd2(q, y1, &y3);
   y2 = word_madd2(q, y2, &y3);
 
   // Return (y3,y2,y1) >? (x3,x2,x1)
 
   if(y3 > x3) return 1;
   if(y3 < x3) return 0;
   if(y2 > x2) return 1;
   if(y2 < x2) return 0;
   if(y1 > x1) return 1;
   if(y1 < x1) return 0;
   return 0;
   }

References bigint_divcore(), and word_madd2().

Referenced by bigint_divcore(), and divide().

bigint_divop()

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

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

Definition at line 67 of file mp_misc.cpp.

   {
   word high = n1 % d, quotient = 0;
 
   for(size_t j = 0; j != MP_WORD_BITS; ++j)
      {
      word high_top_bit = (high & MP_WORD_TOP_BIT);
 
      high <<= 1;
      high |= (n0 >> (MP_WORD_BITS-1-j)) & 1;
      quotient <<= 1;
 
      if(high_top_bit || high >= d)
         {
         high -= d;
         quotient |= 1;
         }
      }
 
   return quotient;
   }

References bigint_divop(), MP_WORD_BITS, and MP_WORD_TOP_BIT.

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

bigint_linmul2()

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

Definition at line 220 of file mp_asm.cpp.

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

References bigint_linmul2(), word8_linmul2(), and word_madd2().

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

bigint_linmul3()

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

Definition at line 238 of file mp_asm.cpp.

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

References bigint_linmul3(), word8_linmul3(), and word_madd2().

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

bigint_modop()

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

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

Definition at line 92 of file mp_misc.cpp.

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

References bigint_divop(), bigint_modop(), and word_madd2().

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

bigint_monty_mul()

void Botan::bigint_monty_mul	(	word	z[],
		size_t	z_size,
		const word	x[],
		size_t	x_size,
		size_t	x_sw,
		const word	y[],
		size_t	y_size,
		size_t	y_sw,
		const word	p[],
		size_t	p_size,
		word	p_dash,
		word	workspace[] )

Definition at line 69 of file mp_monty.cpp.

   {
   bigint_mul(&z[0], z_size, &ws[0],
              &x[0], x_size, x_sw,
              &y[0], y_size, y_sw);
 
   bigint_monty_redc(&z[0], z_size,
                     &p[0], p_size, p_dash,
                     &ws[0]);
   }

References bigint_monty_mul(), bigint_monty_redc(), and bigint_mul().

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

bigint_monty_redc()

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

Montgomery Reduction

Parameters

z	integer to reduce (also output in first p_size+1 words)
z_size	size of z (should be >= 2*p_size+1)
p	modulus
p_size	size of p
p_dash	Montgomery value
workspace	array of at least 2*(p_size+1) words

Definition at line 21 of file mp_monty.cpp.

   {
   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; carry && j != z_size - i; ++j)
         {
         ++z_i[j];
         carry = !z_i[j];
         }
      }
 
   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);
 
   copy_mem(z, ws + borrow*(p_size+1), p_size + 1);
   clear_mem(z + p_size + 1, z_size - p_size - 1);
   }

References bigint_monty_redc(), clear_mem(), copy_mem(), word8_madd3(), word_madd3(), and word_sub().

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

bigint_monty_sqr()

void Botan::bigint_monty_sqr	(	word	z[],
		size_t	z_size,
		const word	x[],
		size_t	x_size,
		size_t	x_sw,
		const word	p[],
		size_t	p_size,
		word	p_dash,
		word	workspace[] )

Definition at line 84 of file mp_monty.cpp.

   {
   bigint_sqr(&z[0], z_size, &ws[0],
              &x[0], x_size, x_sw);
 
   bigint_monty_redc(&z[0], z_size,
                     &p[0], p_size, p_dash,
                     &ws[0]);
   }

References bigint_monty_redc(), bigint_monty_sqr(), and bigint_sqr().

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

bigint_mul()

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

Definition at line 249 of file mp_karat.cpp.

   {
   BOTAN_ASSERT(z_size > x_sw && z_size > y_sw && z_size - x_sw >= y_sw, "Sufficient output size");
 
   if(x_sw == 1)
      {
      bigint_linmul3(z, y, y_sw, x[0]);
      }
   else if(y_sw == 1)
      {
      bigint_linmul3(z, x, x_sw, y[0]);
      }
   else if(x_sw <= 4 && x_size >= 4 &&
           y_sw <= 4 && y_size >= 4 && z_size >= 8)
      {
      bigint_comba_mul4(z, x, y);
      }
   else if(x_sw <= 6 && x_size >= 6 &&
           y_sw <= 6 && y_size >= 6 && z_size >= 12)
      {
      bigint_comba_mul6(z, x, y);
      }
   else if(x_sw <= 8 && x_size >= 8 &&
           y_sw <= 8 && y_size >= 8 && z_size >= 16)
      {
      bigint_comba_mul8(z, x, y);
      }
   else if(x_sw <= 16 && x_size >= 16 &&
           y_sw <= 16 && y_size >= 16 && z_size >= 32)
      {
      bigint_comba_mul16(z, x, y);
      }
   else if(x_sw < BOTAN_KARAT_MUL_THRESHOLD ||
           y_sw < BOTAN_KARAT_MUL_THRESHOLD ||
           !workspace)
      {
      bigint_simple_mul(z, x, x_sw, y, y_sw);
      }
   else
      {
      const size_t N = karatsuba_size(z_size, x_size, x_sw, y_size, y_sw);
 
      if(N)
         {
         clear_mem(workspace, 2*N);
         karatsuba_mul(z, x, y, N, workspace);
         }
      else
         bigint_simple_mul(z, x, x_sw, y, y_sw);
      }
   }

References bigint_comba_mul16(), bigint_comba_mul4(), bigint_comba_mul6(), bigint_comba_mul8(), bigint_linmul3(), bigint_mul(), bigint_simple_mul(), BOTAN_ASSERT, and clear_mem().

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

bigint_shl1()

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

Definition at line 18 of file mp_shift.cpp.

   {
   if(word_shift)
      {
      for(size_t j = 1; j != x_size + 1; ++j)
         x[(x_size - j) + word_shift] = x[x_size - j];
      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));
         }
      }
   }

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

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

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 97 of file mp_shift.cpp.

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

References bigint_shl2(), and MP_WORD_BITS.

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

bigint_shr1()

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

Definition at line 42 of file mp_shift.cpp.

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

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

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

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 117 of file mp_shift.cpp.

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

References bigint_shr2(), and MP_WORD_BITS.

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

bigint_simple_mul()

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

Definition at line 20 of file mp_mulop.cpp.

   {
   const size_t x_size_8 = x_size - (x_size % 8);
 
   clear_mem(z, x_size + y_size);
 
   for(size_t i = 0; i != y_size; ++i)
      {
      const word y_i = y[i];
 
      word carry = 0;
 
      for(size_t j = 0; j != x_size_8; j += 8)
         carry = word8_madd3(z + i + j, x + j, y_i, carry);
 
      for(size_t j = x_size_8; j != x_size; ++j)
         z[i+j] = word_madd3(x[j], y_i, z[i+j], &carry);
 
      z[x_size+i] = carry;
      }
   }

References bigint_simple_mul(), clear_mem(), word8_madd3(), and word_madd3().

Referenced by bigint_mul(), and bigint_simple_mul().

bigint_simple_sqr()

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

Definition at line 54 of file mp_mulop.cpp.

   {
   const size_t x_size_8 = x_size - (x_size % 8);
 
   clear_mem(z, 2*x_size);
 
   for(size_t i = 0; i != x_size; ++i)
      {
      const word x_i = x[i];
      word carry = 0;
 
      for(size_t j = 0; j != x_size_8; j += 8)
         carry = word8_madd3(z + i + j, x + j, x_i, carry);
 
      for(size_t j = x_size_8; j != x_size; ++j)
         z[i+j] = word_madd3(x[j], x_i, z[i+j], &carry);
 
      z[x_size+i] = carry;
      }
   }

References bigint_simple_sqr(), clear_mem(), word8_madd3(), and word_madd3().

Referenced by bigint_simple_sqr(), and bigint_sqr().

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 306 of file mp_karat.cpp.

   {
   BOTAN_ASSERT(z_size/2 >= x_sw, "Sufficient output size");
 
   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 <= 16 && x_size >= 16 && z_size >= 32)
      {
      bigint_comba_sqr16(z, x);
      }
   else if(x_size < BOTAN_KARAT_SQR_THRESHOLD || !workspace)
      {
      bigint_simple_sqr(z, x, x_sw);
      }
   else
      {
      const size_t N = karatsuba_size(z_size, x_size, x_sw);
 
      if(N)
         {
         clear_mem(workspace, 2*N);
         karatsuba_sqr(z, x, N, workspace);
         }
      else
         bigint_simple_sqr(z, x, x_sw);
      }
   }

References bigint_comba_sqr16(), bigint_comba_sqr4(), bigint_comba_sqr6(), bigint_comba_sqr8(), bigint_linmul3(), bigint_simple_sqr(), bigint_sqr(), BOTAN_ASSERT, and clear_mem().

Referenced by bigint_monty_sqr(), bigint_sqr(), and square().

bigint_sub2()

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

Definition at line 158 of file mp_asm.cpp.

   {
   word borrow = 0;
 
   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;
   }

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

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

bigint_sub2_rev()

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

x = y - x; assumes y >= x

Definition at line 179 of file mp_asm.cpp.

   {
   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);
 
   if(borrow)
      throw Internal_Error("bigint_sub2_rev: x >= y");
   }

References bigint_sub2_rev(), Botan::Internal_Error::Internal_Error(), word8_sub2_rev(), and word_sub().

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

bigint_sub3()

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

Definition at line 198 of file mp_asm.cpp.

   {
   word borrow = 0;
 
   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;
   }

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

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

block_size_of()

BOTAN_DLL size_t Botan::block_size_of

(

const std::string &

algo_spec

)

Find out the block size of a certain symmetric algorithm.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the algorithm

Returns

block size of the specified algorithm

Definition at line 35 of file lookup.cpp.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
 
   if(const BlockCipher* cipher = af.prototype_block_cipher(name))
      return cipher->block_size();
 
   if(const HashFunction* hash = af.prototype_hash_function(name))
      return hash->hash_block_size();
 
   throw Algorithm_Not_Found(name);
   }

References Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), block_size_of(), global_state(), Botan::Algorithm_Factory::prototype_block_cipher(), and Botan::Algorithm_Factory::prototype_hash_function().

Referenced by block_size_of(), Botan::SessionKeys::SessionKeys(), Botan::Record_Reader::set_keys(), and Botan::Record_Writer::set_keys().

botan_md4_x86_32_compress()

void Botan::botan_md4_x86_32_compress	(	u32bit	digest[4],
		const byte	input[64],
		u32bit	M[16] )

MD4 compression function in x86-32 asm

Parameters

digest	the current digest
input	the input block
M	the message buffer

References botan_md4_x86_32_compress().

Referenced by botan_md4_x86_32_compress().

botan_serpent_x86_32_decrypt()

void Botan::botan_serpent_x86_32_decrypt	(	const byte	in[16],
		byte	out[16],
		const u32bit	ks[132] )

Entry point for Serpent decryption in x86 asm

Parameters

in	the input block
out	the output block
ks	the key schedule

References botan_serpent_x86_32_decrypt().

Referenced by botan_serpent_x86_32_decrypt(), and Botan::Serpent_X86_32::decrypt_n().

botan_serpent_x86_32_encrypt()

void Botan::botan_serpent_x86_32_encrypt	(	const byte	in[16],
		byte	out[16],
		const u32bit	ks[132] )

Entry point for Serpent encryption in x86 asm

Parameters

in	the input block
out	the output block
ks	the key schedule

References botan_serpent_x86_32_encrypt().

Referenced by botan_serpent_x86_32_encrypt(), and Botan::Serpent_X86_32::encrypt_n().

botan_serpent_x86_32_key_schedule()

void Botan::botan_serpent_x86_32_key_schedule

(

u32bit

ks[140]

)

Entry point for Serpent key schedule in x86 asm

Parameters

ks	holds the initial working key (padded), and is set to the final key schedule

References botan_serpent_x86_32_key_schedule().

Referenced by botan_serpent_x86_32_key_schedule().

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.

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

References bswap_4(), and reverse_bytes().

Referenced by bswap_4(), load_be(), and load_le().

calendar_value()

BOTAN_DLL calendar_point Botan::calendar_value

(

u64bit

time_point

)

Parameters

time_point

a time point from the system clock

Returns

calendar_point object representing this time point

Definition at line 81 of file time.cpp.

   {
   std::tm tm = do_gmtime(static_cast<std::time_t>(a_time_t));
 
   return calendar_point(tm.tm_year + 1900,
                         tm.tm_mon + 1,
                         tm.tm_mday,
                         tm.tm_hour,
                         tm.tm_min,
                         tm.tm_sec);
   }

References Botan::calendar_point::calendar_point(), and calendar_value().

Referenced by calendar_value(), Botan::EAC_Time::EAC_Time(), and Botan::X509_Time::X509_Time().

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 128 of file bcrypt.cpp.

   {
   if(hash.size() != 60 ||
      hash[0] != '$' || hash[1] != '2' || hash[2] != 'a' ||
      hash[3] != '$' || hash[6] != '$')
      {
      return false;
      }
 
   const u16bit workfactor = to_u32bit(hash.substr(4, 2));
 
   MemoryVector<byte> salt = bcrypt_base64_decode(hash.substr(7, 22));
 
   const std::string compare = make_bcrypt(pass, salt, workfactor);
 
   return (hash == compare);
   }

References check_bcrypt(), and to_u32bit().

Referenced by check_bcrypt().

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 84 of file passhash9.cpp.

   {
   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;
 
   Pipe pipe(new Base64_Decoder);
   pipe.start_msg();
   pipe.write(hash.c_str() + MAGIC_PREFIX.size());
   pipe.end_msg();
 
   SecureVector<byte> bin = pipe.read_all();
 
   if(bin.size() != BINARY_LENGTH)
      return false;
 
   byte alg_id = bin[0];
 
   const size_t kdf_iterations =
      WORK_FACTOR_SCALE * load_be<u16bit>(&bin[ALGID_BYTES], 0);
 
   if(kdf_iterations == 0)
      return false;
 
   MessageAuthenticationCode* pbkdf_prf = get_pbkdf_prf(alg_id);
 
   if(pbkdf_prf == 0)
      return false; // unknown algorithm, reject
 
   PKCS5_PBKDF2 kdf(pbkdf_prf); // takes ownership of pointer
 
   SecureVector<byte> cmp = kdf.derive_key(
      PASSHASH9_PBKDF_OUTPUT_LEN,
      pass,
      &bin[ALGID_BYTES + WORKFACTOR_BYTES], SALT_BYTES,
      kdf_iterations).bits_of();
 
   return same_mem(&cmp[0],
                   &bin[ALGID_BYTES + WORKFACTOR_BYTES + SALT_BYTES],
                   PASSHASH9_PBKDF_OUTPUT_LEN);
   }

References Botan::OctetString::bits_of(), check_passhash9(), Botan::PKCS5_PBKDF2::derive_key(), Botan::Pipe::end_msg(), load_be(), Botan::Pipe::read_all(), same_mem(), Botan::MemoryRegion< T >::size(), Botan::Pipe::start_msg(), and Botan::Pipe::write().

Referenced by check_passhash9().

check_prime()

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

inline

Check for primality

Parameters

n	a positive integer to test for primality
rng	a random number generator

Returns

true if all primality tests passed, otherwise false

Definition at line 143 of file numthry.h.

   { return primality_test(n, rng, 1); }

References check_prime(), and primality_test().

Referenced by Botan::IF_Scheme_PrivateKey::check_key(), check_prime(), Botan::DL_Group::DL_Group(), generate_dsa_primes(), random_prime(), random_safe_prime(), and Botan::DL_Group::verify_group().

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.

   {
   // 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;
   }

References checked_add(), and Botan::Integer_Overflow_Detected::Integer_Overflow_Detected().

Referenced by checked_add().

choose_sig_format()

BOTAN_DLL PK_Signer * Botan::choose_sig_format	(	const Private_Key &	key,
		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
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 218 of file x509_ca.cpp.

   {
   std::string padding;
 
   const std::string algo_name = key.algo_name();
 
   const HashFunction* proto_hash = retrieve_hash(hash_fn);
   if(!proto_hash)
      throw Algorithm_Not_Found(hash_fn);
 
   if(key.max_input_bits() < proto_hash->output_length()*8)
      throw Invalid_Argument("Key is too small for chosen hash function");
 
   if(algo_name == "RSA")
      padding = "EMSA3";
   else if(algo_name == "DSA")
      padding = "EMSA1";
   else if(algo_name == "ECDSA")
      padding = "EMSA1_BSI";
   else
      throw Invalid_Argument("Unknown X.509 signing key type: " + algo_name);
 
   Signature_Format format =
      (key.message_parts() > 1) ? DER_SEQUENCE : IEEE_1363;
 
   padding = padding + '(' + proto_hash->name() + ')';
 
   sig_algo.oid = OIDS::lookup(algo_name + "/" + padding);
   sig_algo.parameters = key.algorithm_identifier().parameters;
 
   return new PK_Signer(key, padding, format);
   }

References Botan::Public_Key::algo_name(), Botan::Public_Key::algorithm_identifier(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), choose_sig_format(), DER_SEQUENCE, IEEE_1363, Botan::OIDS::lookup(), Botan::Public_Key::max_input_bits(), Botan::Public_Key::message_parts(), Botan::Algorithm::name(), Botan::AlgorithmIdentifier::oid, Botan::Buffered_Computation::output_length(), Botan::AlgorithmIdentifier::parameters, Botan::PK_Signer::PK_Signer(), and retrieve_hash().

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

clear_mem()

template<typename T>

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

inline

Zeroize memory

Parameters

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

Definition at line 32 of file mem_ops.h.

   {
   if(n) // avoid glibc warning if n == 0
      std::memset(ptr, 0, sizeof(T)*n);
   }

References clear_mem().

Referenced by aont_package(), base64_decode(), bigint_monty_redc(), bigint_mul(), bigint_shl1(), bigint_shr1(), bigint_simple_mul(), bigint_simple_sqr(), bigint_sqr(), clear_mem(), Botan::BigInt::const_time_lookup(), hex_decode(), Botan::Unix_EntropySource::poll(), Botan::MemoryRegion< T >::resize(), and zeroise().

confirm_startup_self_tests()

BOTAN_DLL void Botan::confirm_startup_self_tests

(

Algorithm_Factory &

af

)

Run a set of self tests on some basic algorithms like AES and SHA-1

Parameters

af	an algorithm factory

Exceptions

Self_Test_Error

if a failure occured

Definition at line 226 of file selftest.cpp.

  {
  cipher_kat(af, "DES",
             "0123456789ABCDEF", "1234567890ABCDEF",
             "4E6F77206973207468652074696D6520666F7220616C6C20",
             "3FA40E8A984D48156A271787AB8883F9893D51EC4B563B53",
             "E5C7CDDE872BF27C43E934008C389C0F683788499A7C05F6",
             "F3096249C7F46E51A69E839B1A92F78403467133898EA622",
             "F3096249C7F46E5135F24A242EEB3D3F3D6D5BE3255AF8C3",
             "F3096249C7F46E51163A8CA0FFC94C27FA2F80F480B86F75");
 
  cipher_kat(af, "TripleDES",
             "385D7189A5C3D485E1370AA5D408082B5CCCCB5E19F2D90E",
             "C141B5FCCD28DC8A",
             "6E1BD7C6120947A464A6AAB293A0F89A563D8D40D3461B68",
             "64EAAD4ACBB9CEAD6C7615E7C7E4792FE587D91F20C7D2F4",
             "6235A461AFD312973E3B4F7AA7D23E34E03371F8E8C376C9",
             "E26BA806A59B0330DE40CA38E77A3E494BE2B212F6DD624B",
             "E26BA806A59B03307DE2BCC25A08BA40A8BA335F5D604C62",
             "E26BA806A59B03303C62C2EFF32D3ACDD5D5F35EBCC53371");
 
  cipher_kat(af, "AES-128",
             "2B7E151628AED2A6ABF7158809CF4F3C",
             "000102030405060708090A0B0C0D0E0F",
             "6BC1BEE22E409F96E93D7E117393172A"
             "AE2D8A571E03AC9C9EB76FAC45AF8E51",
             "3AD77BB40D7A3660A89ECAF32466EF97"
             "F5D3D58503B9699DE785895A96FDBAAF",
             "7649ABAC8119B246CEE98E9B12E9197D"
             "5086CB9B507219EE95DB113A917678B2",
             "3B3FD92EB72DAD20333449F8E83CFB4A"
             "C8A64537A0B3A93FCDE3CDAD9F1CE58B",
             "3B3FD92EB72DAD20333449F8E83CFB4A"
             "7789508D16918F03F53C52DAC54ED825",
             "3B3FD92EB72DAD20333449F8E83CFB4A"
             "010C041999E03F36448624483E582D0E");
 
  hash_test(af, "SHA-1",
            "", "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709");
 
  hash_test(af, "SHA-1",
            "616263", "A9993E364706816ABA3E25717850C26C9CD0D89D");
 
  hash_test(af, "SHA-1",
            "6162636462636465636465666465666765666768666768696768696A"
            "68696A6B696A6B6C6A6B6C6D6B6C6D6E6C6D6E6F6D6E6F706E6F7071",
            "84983E441C3BD26EBAAE4AA1F95129E5E54670F1");
 
  mac_test(af, "HMAC(SHA-1)",
           "4869205468657265",
           "B617318655057264E28BC0B6FB378C8EF146BE00",
           "0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B");
 
  hash_test(af, "SHA-256",
            "",
            "E3B0C44298FC1C149AFBF4C8996FB924"
            "27AE41E4649B934CA495991B7852B855");
 
  hash_test(af, "SHA-256",
            "616263",
            "BA7816BF8F01CFEA414140DE5DAE2223"
            "B00361A396177A9CB410FF61F20015AD");
 
  hash_test(af, "SHA-256",
            "6162636462636465636465666465666765666768666768696768696A"
            "68696A6B696A6B6C6A6B6C6D6B6C6D6E6C6D6E6F6D6E6F706E6F7071",
            "248D6A61D20638B8E5C026930C3E6039"
            "A33CE45964FF2167F6ECEDD419DB06C1");
 
  mac_test(af, "HMAC(SHA-256)",
           "4869205468657265",
           "198A607EB44BFBC69903A0F1CF2BBDC5"
           "BA0AA3F3D9AE3C1C7A3B1696A0B68CF7",
           "0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B"
           "0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B");
  }

References confirm_startup_self_tests().

Referenced by confirm_startup_self_tests(), Botan::Library_State::initialize(), and passes_self_tests().

copy_if()

template<typename InputIterator, typename OutputIterator, typename Predicate>

OutputIterator Botan::copy_if	(	InputIterator	current,
		InputIterator	end,
		OutputIterator	dest,
		Predicate	copy_p )

Copy-on-Predicate Algorithm

Parameters

current	the first iterator value
end	the final iterator value
dest	an output iterator
copy_p	the predicate

Definition at line 23 of file stl_util.h.

   {
   while(current != end)
      {
      if(copy_p(*current))
         *dest++ = *current;
      ++current;
      }
   return dest;
   }

References copy_if().

Referenced by copy_if().

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

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

References copy_mem().

Referenced by aont_package(), aont_unpackage(), Botan::BigInt::assign(), bigint_monty_redc(), bigint_shr1(), Botan::MemoryRegion< T >::copy(), Botan::MemoryRegion< T >::copy(), copy_mem(), Botan::BER_Decoder::decode(), Botan::CryptoBox::encrypt(), Botan::Record_Reader::get_record(), Botan::BigInt::operator+=(), operator+=(), operator+=(), operator+=(), Botan::DataSource_Memory::peek(), Botan::ANSI_X931_RNG::randomize(), Botan::HMAC_RNG::randomize(), Botan::Randpool::randomize(), Botan::DataSource_Memory::read(), Botan::MemoryRegion< T >::resize(), rfc3394_keyunwrap(), rfc3394_keywrap(), Botan::CMS_Encoder::set_data(), Botan::Serpent::set_round_keys(), Botan::PK_Verifier_Filter::set_signature(), Botan::Base64_Decoder::write(), Botan::Buffered_Filter::write(), and Botan::Hex_Decoder::write().

create_alt_name()

BOTAN_DLL AlternativeName Botan::create_alt_name

(

const Data_Store &

info

)

Definition at line 442 of file x509cert.cpp.

   {
   class AltName_Matcher : public Data_Store::Matcher
      {
      public:
         bool operator()(const std::string& key, const std::string&) const
            {
            for(size_t i = 0; i != matches.size(); ++i)
               if(key.compare(matches[i]) == 0)
                  return true;
            return false;
            }
 
         AltName_Matcher(const std::string& match_any_of)
            {
            matches = split_on(match_any_of, '/');
            }
      private:
         std::vector<std::string> matches;
      };
 
   std::multimap<std::string, std::string> names =
      info.search_with(AltName_Matcher("RFC822/DNS/URI/IP"));
 
   AlternativeName alt_name;
 
   std::multimap<std::string, std::string>::iterator i;
   for(i = names.begin(); i != names.end(); ++i)
      alt_name.add_attribute(i->first, i->second);
 
   return alt_name;
   }

References Botan::AlternativeName::add_attribute(), create_alt_name(), Botan::Data_Store::search_with(), and split_on().

Referenced by create_alt_name(), and Botan::PKCS10_Request::subject_alt_name().

create_dn()

BOTAN_DLL X509_DN Botan::create_dn

(

const Data_Store &

info

)

Definition at line 414 of file x509cert.cpp.

   {
   class DN_Matcher : public Data_Store::Matcher
      {
      public:
         bool operator()(const std::string& key, const std::string&) const
            {
            if(key.find("X520.") != std::string::npos)
               return true;
            return false;
            }
      };
 
   std::multimap<std::string, std::string> names =
      info.search_with(DN_Matcher());
 
   X509_DN dn;
 
   std::multimap<std::string, std::string>::iterator i;
   for(i = names.begin(); i != names.end(); ++i)
      dn.add_attribute(i->first, i->second);
 
   return dn;
   }

References Botan::X509_DN::add_attribute(), create_dn(), and Botan::Data_Store::search_with().

Referenced by create_dn(), Botan::X509_Certificate::issuer_dn(), Botan::X509_CRL::issuer_dn(), Botan::PKCS10_Request::subject_dn(), and Botan::X509_Certificate::subject_dn().

ctz()

template<typename T>

size_t Botan::ctz ( T n )

inline

Count the trailing zero bits in n

Parameters

n	an integer value

Returns

maximum x st 2^x divides n

Definition at line 93 of file bit_ops.h.

   {
   for(size_t i = 0; i != 8*sizeof(T); ++i)
      if((n >> i) & 0x01)
         return i;
   return 8*sizeof(T);
   }

References ctz().

Referenced by ctz(), and low_zero_bits().

decode_concatenation()

ECDSA_Signature Botan::decode_concatenation

(

const MemoryRegion< byte > &

concat

)

Definition at line 46 of file ecdsa_sig.cpp.

   {
   if(concat.size() % 2 != 0)
      throw Invalid_Argument("Erroneous length of signature");
 
   const size_t rs_len = concat.size() / 2;
 
   BigInt r = BigInt::decode(&concat[0], rs_len);
   BigInt s = BigInt::decode(&concat[rs_len], rs_len);
 
   return ECDSA_Signature(r, s);
   }

References Botan::BigInt::decode(), decode_concatenation(), Botan::ECDSA_Signature::ECDSA_Signature(), and Botan::MemoryRegion< T >::size().

Referenced by decode_concatenation(), and Botan::EAC1_1_gen_CVC< Derived >::decode_info().

decode_eac1_1_key()

BOTAN_DLL ECDSA_PublicKey * Botan::decode_eac1_1_key	(	const MemoryRegion< byte > &	enc_key,
		AlgorithmIdentifier &	sig_algo )

Decode an EAC encoding ECDSA key

Definition at line 91 of file cvc_cert.cpp.

   {
   throw Internal_Error("decode_eac1_1_key: Unimplemented");
   return 0;
   }

References decode_eac1_1_key(), and Botan::Internal_Error::Internal_Error().

Referenced by decode_eac1_1_key(), and Botan::EAC1_1_CVC::EAC1_1_obj< EAC1_1_CVC >.

delete2nd()

template<typename Pair>

void Botan::delete2nd

(

Pair &

pair

)

Delete the second half of a pair of objects

Definition at line 67 of file stl_util.h.

   {
   delete pair.second;
   }

References delete2nd().

Referenced by delete2nd().

divide()

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

BigInt Division

Parameters

x	an integer
y	a non-zero integer
q	will be set to x / y
r	will be set to x % y

Definition at line 34 of file divide.cpp.

   {
   if(y_arg.is_zero())
      throw BigInt::DivideByZero();
 
   BigInt y = y_arg;
   const size_t y_words = y.sig_words();
 
   r = x;
   q = 0;
 
   r.set_sign(BigInt::Positive);
   y.set_sign(BigInt::Positive);
 
   s32bit compare = r.cmp(y);
 
   if(compare == 0)
      {
      q = 1;
      r = 0;
      }
   else if(compare > 0)
      {
      size_t shifts = 0;
      word y_top = y[y.sig_words()-1];
      while(y_top < MP_WORD_TOP_BIT) { y_top <<= 1; ++shifts; }
      y <<= shifts;
      r <<= shifts;
 
      const size_t n = r.sig_words() - 1, t = y_words - 1;
 
      if(n < t)
         throw Internal_Error("BigInt division word sizes");
 
      q.get_reg().resize(n - t + 1);
      if(n <= t)
         {
         while(r > y) { r -= y; ++q; }
         r >>= shifts;
         sign_fixup(x, y_arg, q, r);
         return;
         }
 
      BigInt temp = y << (MP_WORD_BITS * (n-t));
 
      while(r >= temp) { r -= temp; ++q[n-t]; }
 
      for(size_t j = n; j != t; --j)
         {
         const word x_j0  = r.word_at(j);
         const word x_j1 = r.word_at(j-1);
         const word y_t  = y.word_at(t);
 
         if(x_j0 == y_t)
            q[j-t-1] = MP_WORD_MAX;
         else
            q[j-t-1] = bigint_divop(x_j0, x_j1, y_t);
 
         while(bigint_divcore(q[j-t-1], y_t, y.word_at(t-1),
                              x_j0, x_j1, r.word_at(j-2)))
            --q[j-t-1];
 
         r -= (q[j-t-1] * y) << (MP_WORD_BITS * (j-t-1));
         if(r.is_negative())
            {
            r += y << (MP_WORD_BITS * (j-t-1));
            --q[j-t-1];
            }
         }
      r >>= shifts;
      }
 
   sign_fixup(x, y_arg, q, r);
   }

References bigint_divcore(), bigint_divop(), Botan::BigInt::cmp(), divide(), Botan::BigInt::get_reg(), Botan::Internal_Error::Internal_Error(), Botan::BigInt::is_negative(), Botan::BigInt::is_zero(), MP_WORD_BITS, MP_WORD_MAX, MP_WORD_TOP_BIT, Botan::BigInt::Positive, Botan::MemoryRegion< T >::resize(), Botan::BigInt::set_sign(), Botan::BigInt::sig_words(), and Botan::BigInt::word_at().

Referenced by divide(), Botan::BigInt::encode(), operator%(), and operator/().

dl_work_factor()

size_t Botan::dl_work_factor

(

size_t

prime_group_size

)

Estimate work factor for discrete logarithm

Parameters

prime_group_size

size of the group in bits

Returns

estimated security level for this group

Definition at line 14 of file workfactor.cpp.

   {
   /*
   Based on GNFS work factors. Constant is 1.43 times the asymptotic
   value; I'm not sure but I believe that came from a paper on 'real
   world' runtimes, but I don't remember where now.
 
   Sample return values:
      |512|  -> 64
      |1024| -> 86
      |1536| -> 102
      |2048| -> 116
      |3072| -> 138
      |4096| -> 155
      |8192| -> 206
 
   For DL algos, we use an exponent of twice the size of the result;
   the assumption is that an arbitrary discrete log on a group of size
   bits would take about 2^n effort, and thus using an exponent of
   size 2^(2*n) implies that all available attacks are about as easy
   (as e.g Pollard's kangaroo algorithm can compute the DL in sqrt(x)
   operations) while minimizing the exponent size for performance
   reasons.
   */
 
   const size_t MIN_WORKFACTOR = 64;
 
   // approximates natural logarithm of p
   const double log_p = bits / 1.4426;
 
   const double strength =
      2.76 * std::pow(log_p, 1.0/3.0) * std::pow(std::log(log_p), 2.0/3.0);
 
   return std::max(static_cast<size_t>(strength), MIN_WORKFACTOR);
   }

References dl_work_factor().

Referenced by Botan::DH_PrivateKey::DH_PrivateKey(), Botan::DL_Group::DL_Group(), dl_work_factor(), Botan::ElGamal_PrivateKey::ElGamal_PrivateKey(), and Botan::ElGamal_Encryption_Operation::encrypt().

EC2OSP()

SecureVector< byte > BOTAN_DLL Botan::EC2OSP	(	const PointGFp &	point,
		byte	format )

Definition at line 490 of file point_gfp.cpp.

   {
   if(point.is_zero())
      return SecureVector<byte>(1); // single 0 byte
 
   const size_t p_bytes = point.get_curve().get_p().bytes();
 
   BigInt x = point.get_affine_x();
   BigInt y = point.get_affine_y();
 
   SecureVector<byte> bX = BigInt::encode_1363(x, p_bytes);
   SecureVector<byte> bY = BigInt::encode_1363(y, p_bytes);
 
   if(format == PointGFp::UNCOMPRESSED)
      {
      SecureVector<byte> result;
      result.push_back(0x04);
 
      result += bX;
      result += bY;
 
      return result;
      }
   else if(format == PointGFp::COMPRESSED)
      {
      SecureVector<byte> result;
      result.push_back(0x02 | static_cast<byte>(y.get_bit(0)));
 
      result += bX;
 
      return result;
      }
   else if(format == PointGFp::HYBRID)
      {
      SecureVector<byte> result;
      result.push_back(0x06 | static_cast<byte>(y.get_bit(0)));
 
      result += bX;
      result += bY;
 
      return result;
      }
   else
      throw Invalid_Argument("illegal point encoding format specification");
   }

References Botan::BigInt::bytes(), Botan::PointGFp::COMPRESSED, EC2OSP(), Botan::BigInt::encode_1363(), Botan::PointGFp::get_affine_x(), Botan::PointGFp::get_affine_y(), Botan::BigInt::get_bit(), Botan::PointGFp::get_curve(), Botan::CurveGFp::get_p(), Botan::PointGFp::HYBRID, Botan::PointGFp::is_zero(), Botan::MemoryRegion< T >::push_back(), and Botan::PointGFp::UNCOMPRESSED.

Referenced by Botan::EC_Group::DER_encode(), EC2OSP(), Botan::ECDH_PublicKey::public_value(), and Botan::EC_PublicKey::x509_subject_public_key().

gcd()

BigInt BOTAN_DLL Botan::gcd	(	const BigInt &	x,
		const BigInt &	y )

Compute the greatest common divisor

Parameters

x	a positive integer
y	a positive integer

Returns

gcd(x,y)

Definition at line 168 of file numthry.cpp.

   {
   if(a.is_zero() || b.is_zero()) return 0;
   if(a == 1 || b == 1)           return 1;
 
   BigInt x = a, y = b;
   x.set_sign(BigInt::Positive);
   y.set_sign(BigInt::Positive);
   size_t shift = std::min(low_zero_bits(x), low_zero_bits(y));
 
   x >>= shift;
   y >>= shift;
 
   while(x.is_nonzero())
      {
      x >>= low_zero_bits(x);
      y >>= low_zero_bits(y);
      if(x >= y) { x -= y; x >>= 1; }
      else       { y -= x; y >>= 1; }
      }
 
   return (y << shift);
   }

References gcd(), Botan::BigInt::is_nonzero(), Botan::BigInt::is_zero(), low_zero_bits(), Botan::BigInt::Positive, and Botan::BigInt::set_sign().

Referenced by gcd(), lcm(), and random_prime().

generate_bcrypt()

std::string BOTAN_DLL Botan::generate_bcrypt	(	const std::string &	password,
		RandomNumberGenerator &	rng,
		u16bit	work_factor = 10 )

Create a password hash using Bcrypt

Parameters

password	the password
rng	a random number generator
work_factor	how much work to do to slow down guessing attacks

See also

http://www.usenix.org/events/usenix99/provos/provos_html/

Definition at line 121 of file bcrypt.cpp.

   {
   return make_bcrypt(pass, rng.random_vec(16), work_factor);
   }

References generate_bcrypt(), and Botan::RandomNumberGenerator::random_vec().

Referenced by generate_bcrypt().

generate_dsa_primes() [1/2]

SecureVector< byte > BOTAN_DLL Botan::generate_dsa_primes	(	RandomNumberGenerator &	rng,
		Algorithm_Factory &	af,
		BigInt &	p_out,
		BigInt &	q_out,
		size_t	pbits,
		size_t	qbits )

Generate DSA parameters using the FIPS 186 kosherizer

Parameters

rng	a random number generator
af	an algorithm factory
p_out	where the prime p will be stored
q_out	where the prime q will be stored
pbits	how long p will be in bits
qbits	how long q will be in bits

Returns

random seed used to generate this parameter set

Definition at line 119 of file dsa_gen.cpp.

   {
   while(true)
      {
      SecureVector<byte> seed = rng.random_vec(qbits / 8);
 
      if(generate_dsa_primes(rng, af, p, q, pbits, qbits, seed))
         return seed;
      }
   }

References generate_dsa_primes(), and Botan::RandomNumberGenerator::random_vec().

generate_dsa_primes() [2/2]

bool BOTAN_DLL Botan::generate_dsa_primes	(	RandomNumberGenerator &	rng,
		Algorithm_Factory &	af,
		BigInt &	p_out,
		BigInt &	q_out,
		size_t	pbits,
		size_t	qbits,
		const MemoryRegion< byte > &	seed )

Generate DSA parameters using the FIPS 186 kosherizer

Parameters

rng	a random number generator
af	an algorithm factory
p_out	where the prime p will be stored
q_out	where the prime q will be stored
pbits	how long p will be in bits
qbits	how long q will be in bits
seed	the seed used to generate the parameters

Returns

true if seed generated a valid DSA parameter set, otherwise false. p_out and q_out are only valid if true was returned.

Definition at line 41 of file dsa_gen.cpp.

   {
   if(!fips186_3_valid_size(pbits, qbits))
      throw Invalid_Argument(
         "FIPS 186-3 does not allow DSA domain parameters of " +
         to_string(pbits) + "/" + to_string(qbits) + " bits long");
 
   if(seed_c.size() * 8 < qbits)
      throw Invalid_Argument(
         "Generating a DSA parameter set with a " + to_string(qbits) +
         "long q requires a seed at least as many bits long");
 
   std::auto_ptr<HashFunction> hash(
      af.make_hash_function("SHA-" + to_string(qbits)));
 
   const size_t HASH_SIZE = hash->output_length();
 
   class Seed
      {
      public:
         Seed(const MemoryRegion<byte>& s) : seed(s) {}
 
         operator MemoryRegion<byte>& () { return seed; }
 
         Seed& operator++()
            {
            for(size_t j = seed.size(); j > 0; --j)
               if(++seed[j-1])
                  break;
            return (*this);
            }
      private:
         SecureVector<byte> seed;
      };
 
   Seed seed(seed_c);
 
   q.binary_decode(hash->process(seed));
   q.set_bit(qbits-1);
   q.set_bit(0);
 
   if(!check_prime(q, rng))
      return false;
 
   const size_t n = (pbits-1) / (HASH_SIZE * 8),
                b = (pbits-1) % (HASH_SIZE * 8);
 
   BigInt X;
   SecureVector<byte> V(HASH_SIZE * (n+1));
 
   for(size_t j = 0; j != 4096; ++j)
      {
      for(size_t k = 0; k <= n; ++k)
         {
         ++seed;
         hash->update(seed);
         hash->final(&V[HASH_SIZE * (n-k)]);
         }
 
      X.binary_decode(&V[HASH_SIZE - 1 - b/8],
                      V.size() - (HASH_SIZE - 1 - b/8));
      X.set_bit(pbits-1);
 
      p = X - (X % (2*q) - 1);
 
      if(p.bits() == pbits && check_prime(p, rng))
         return true;
      }
   return false;
   }

References Botan::BigInt::binary_decode(), Botan::BigInt::bits(), check_prime(), generate_dsa_primes(), Botan::Algorithm_Factory::make_hash_function(), Botan::BigInt::set_bit(), Botan::MemoryRegion< T >::size(), and to_string().

Referenced by Botan::DL_Group::DL_Group(), Botan::DL_Group::DL_Group(), generate_dsa_primes(), and generate_dsa_primes().

generate_passhash9()

std::string BOTAN_DLL Botan::generate_passhash9	(	const std::string &	password,
		RandomNumberGenerator &	rng,
		u16bit	work_factor = 10,
		byte	alg_id = 0 )

Create a password hash using PBKDF2

Parameters

password	the password
rng	a random number generator
work_factor	how much work to do to slow down guessing attacks
alg_id	specifies which PRF to use with PBKDF2 0 is HMAC(SHA-1) 1 is HMAC(SHA-256) 2 is CMAC(Blowfish) all other values are currently undefined

Definition at line 48 of file passhash9.cpp.

   {
   MessageAuthenticationCode* prf = get_pbkdf_prf(alg_id);
 
   if(!prf)
      throw Invalid_Argument("Passhash9: Algorithm id " + to_string(alg_id) +
                             " is not defined");
 
   PKCS5_PBKDF2 kdf(prf); // takes ownership of pointer
 
   SecureVector<byte> salt(SALT_BYTES);
   rng.randomize(&salt[0], salt.size());
 
   const size_t kdf_iterations = WORK_FACTOR_SCALE * work_factor;
 
   SecureVector<byte> pbkdf2_output =
      kdf.derive_key(PASSHASH9_PBKDF_OUTPUT_LEN,
                     pass,
                     &salt[0], salt.size(),
                     kdf_iterations).bits_of();
 
   Pipe pipe(new Base64_Encoder);
   pipe.start_msg();
   pipe.write(alg_id);
   pipe.write(get_byte(0, work_factor));
   pipe.write(get_byte(1, work_factor));
   pipe.write(salt);
   pipe.write(pbkdf2_output);
   pipe.end_msg();
 
   return MAGIC_PREFIX + pipe.read_all_as_string();
   }

References Botan::OctetString::bits_of(), Botan::PKCS5_PBKDF2::derive_key(), Botan::Pipe::end_msg(), generate_passhash9(), get_byte(), Botan::RandomNumberGenerator::randomize(), Botan::Pipe::read_all_as_string(), Botan::MemoryRegion< T >::size(), Botan::Pipe::start_msg(), to_string(), and Botan::Pipe::write().

Referenced by generate_passhash9().

generate_srp6_verifier()

BigInt BOTAN_DLL Botan::generate_srp6_verifier	(	const std::string &	identifier,
		const std::string &	password,
		const MemoryRegion< byte > &	salt,
		const std::string &	group_id,
		const std::string &	hash_id )

Generate a new SRP-6 verifier

Parameters

identifier	a username or other client identifier
password	the secret used to authenticate user
salt	a randomly chosen value, at least 128 bits long

Definition at line 130 of file srp6.cpp.

   {
   const BigInt x = compute_x(hash_id, identifier, password, salt);
 
   DL_Group group(group_id);
   return power_mod(group.get_g(), x, group.get_p());
   }

References generate_srp6_verifier(), Botan::DL_Group::get_g(), Botan::DL_Group::get_p(), and power_mod().

Referenced by generate_srp6_verifier().

get_block_cipher()

BlockCipher * Botan::get_block_cipher ( const std::string & algo_spec )

inline

Block cipher factory method.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the desired block cipher

Returns

pointer to the block cipher object

Definition at line 87 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return af.make_block_cipher(algo_spec);
   }

References Botan::Library_State::algorithm_factory(), get_block_cipher(), global_state(), and Botan::Algorithm_Factory::make_block_cipher().

Referenced by get_block_cipher().

get_byte()

template<typename T>

byte Botan::get_byte ( size_t byte_num, T input )

inline

Byte extraction

Parameters

byte_num	which byte to extract, 0 == highest byte
input	the value to extract from

Returns

byte byte_num of input

Definition at line 21 of file get_byte.h.

   {
   return static_cast<byte>(
      input >> ((sizeof(T)-1-(byte_num&(sizeof(T)-1))) << 3)
      );
   }

References get_byte().

Referenced by aont_package(), aont_unpackage(), append_tls_length_value(), Botan::BigInt::byte_at(), Botan::CryptoBox::decrypt(), Botan::Blowfish::decrypt_n(), Botan::DES::decrypt_n(), Botan::Square::decrypt_n(), Botan::TripleDES::decrypt_n(), Botan::Twofish::decrypt_n(), Botan::CryptoBox::encrypt(), Botan::Blowfish::encrypt_n(), Botan::DES::encrypt_n(), Botan::Square::encrypt_n(), Botan::TripleDES::encrypt_n(), Botan::Twofish::encrypt_n(), generate_passhash9(), get_byte(), Botan::Record_Reader::get_record(), ipv4_to_string(), Botan::HandshakeMessage::send(), Botan::Turing::set_iv(), significant_bytes(), Botan::RTSS_Share::split(), store_be(), store_be(), store_be(), store_le(), store_le(), store_le(), and Botan::Buffered_Computation::update_be().

get_cipher() [1/3]

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

Factory method for general symmetric cipher filters. No key will be set in the filter.

Parameters

algo_spec	the name of the desired cipher
direction	determines whether the filter will be an encrypting or decrypting filter

Returns

pointer to the encryption or decryption filter

Definition at line 124 of file lookup.cpp.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
 
   Algorithm_Factory::Engine_Iterator i(af);
 
   while(Engine* engine = i.next())
      {
      if(Keyed_Filter* algo = engine->get_cipher(algo_spec, direction, af))
         return algo;
      }
 
   throw Algorithm_Not_Found(algo_spec);
   }

References Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), get_cipher(), global_state(), and Botan::Algorithm_Factory::Engine_Iterator::next().

Referenced by Botan::CryptoBox::decrypt(), Botan::CryptoBox::encrypt(), get_cipher(), get_cipher(), get_cipher(), Botan::Record_Reader::set_keys(), and Botan::Record_Writer::set_keys().

get_cipher() [2/3]

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

Factory method for general symmetric cipher filters.

Parameters

algo_spec	the name of the desired cipher
key	the key to be used for encryption/decryption performed by the filter
direction	determines whether the filter will be an encrypting or decrypting filter

Returns

pointer to the encryption or decryption filter

Definition at line 160 of file lookup.cpp.

   {
   return get_cipher(algo_spec,
                     key, InitializationVector(), direction);
   }

References get_cipher().

get_cipher() [3/3]

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

Factory method for general symmetric cipher filters.

Parameters

algo_spec	the name of the desired cipher
key	the key to be used for encryption/decryption performed by the filter
iv	the initialization vector to be used
direction	determines whether the filter will be an encrypting or decrypting filter

Returns

pointer to newly allocated encryption or decryption filter

Definition at line 143 of file lookup.cpp.

   {
   Keyed_Filter* cipher = get_cipher(algo_spec, direction);
   cipher->set_key(key);
 
   if(iv.length())
      cipher->set_iv(iv);
 
   return cipher;
   }

References get_cipher(), Botan::OctetString::length(), Botan::Keyed_Filter::set_iv(), and Botan::Keyed_Filter::set_key().

get_cipher_mode()

Keyed_Filter * Botan::get_cipher_mode	(	const BlockCipher *	block_cipher,
		Cipher_Dir	direction,
		const std::string &	mode,
		const std::string &	padding )

Create a cipher mode filter object

Parameters

block_cipher	a block cipher object
direction	are we encrypting or decrypting?
mode	the name of the cipher mode to use
padding	the mode padding to use (only used for ECB, CBC)

Definition at line 77 of file core_modes.cpp.

   {
#if defined(BOTAN_HAS_OFB)
   if(mode == "OFB")
      return new StreamCipher_Filter(new OFB(block_cipher->clone()));
#endif
 
#if defined(BOTAN_HAS_CTR_BE)
   if(mode == "CTR-BE")
      return new StreamCipher_Filter(new CTR_BE(block_cipher->clone()));
#endif
 
#if defined(BOTAN_HAS_ECB)
   if(mode == "ECB" || mode == "")
      {
      if(direction == ENCRYPTION)
         return new ECB_Encryption(block_cipher->clone(),
                                   get_bc_pad(padding, "NoPadding"));
      else
         return new ECB_Decryption(block_cipher->clone(),
                                   get_bc_pad(padding, "NoPadding"));
      }
#endif
 
   if(mode == "CBC")
      {
      if(padding == "CTS")
         {
#if defined(BOTAN_HAS_CTS)
         if(direction == ENCRYPTION)
            return new CTS_Encryption(block_cipher->clone());
         else
            return new CTS_Decryption(block_cipher->clone());
#else
         return 0;
#endif
         }
 
#if defined(BOTAN_HAS_CBC)
      if(direction == ENCRYPTION)
         return new CBC_Encryption(block_cipher->clone(),
                                   get_bc_pad(padding, "PKCS7"));
      else
         return new CBC_Decryption(block_cipher->clone(),
                                   get_bc_pad(padding, "PKCS7"));
#else
      return 0;
#endif
      }
 
#if defined(BOTAN_HAS_XTS)
   if(mode == "XTS")
      {
      if(direction == ENCRYPTION)
         return new XTS_Encryption(block_cipher->clone());
      else
         return new XTS_Decryption(block_cipher->clone());
      }
#endif
 
   if(mode.find("CFB") != std::string::npos ||
      mode.find("EAX") != std::string::npos)
      {
      size_t bits = 0;
 
      std::vector<std::string> algo_info = parse_algorithm_name(mode);
      std::string mode_name = algo_info[0];
      if(algo_info.size() == 1)
         bits = 8 * block_cipher->block_size();
      else if(algo_info.size() == 2)
         bits = to_u32bit(algo_info[1]);
      else
         return 0;
 
#if defined(BOTAN_HAS_CFB)
      if(mode_name == "CFB")
         {
         if(direction == ENCRYPTION)
            return new CFB_Encryption(block_cipher->clone(), bits);
         else
            return new CFB_Decryption(block_cipher->clone(), bits);
         }
#endif
 
#if defined(BOTAN_HAS_EAX)
      if(mode_name == "EAX")
         {
         if(direction == ENCRYPTION)
            return new EAX_Encryption(block_cipher->clone(), bits);
         else
            return new EAX_Decryption(block_cipher->clone(), bits);
         }
#endif
      }
 
   return 0;
   }

References Botan::BlockCipher::block_size(), Botan::CBC_Decryption::CBC_Decryption(), Botan::CBC_Encryption::CBC_Encryption(), Botan::CFB_Decryption::CFB_Decryption(), Botan::CFB_Encryption::CFB_Encryption(), Botan::BlockCipher::clone(), Botan::CTR_BE::CTR_BE(), Botan::CTS_Decryption::CTS_Decryption(), Botan::CTS_Encryption::CTS_Encryption(), Botan::EAX_Decryption::EAX_Decryption(), Botan::EAX_Encryption::EAX_Encryption(), Botan::ECB_Decryption::ECB_Decryption(), Botan::ECB_Encryption::ECB_Encryption(), ENCRYPTION, get_cipher_mode(), Botan::OFB::OFB(), parse_algorithm_name(), Botan::StreamCipher_Filter::StreamCipher_Filter(), to_u32bit(), Botan::XTS_Decryption::XTS_Decryption(), and Botan::XTS_Encryption::XTS_Encryption().

Referenced by algorithm_kat(), Botan::Core_Engine::get_cipher(), and get_cipher_mode().

get_eme()

BOTAN_DLL EME * Botan::get_eme

(

const std::string &

algo_spec

)

Factory method for EME (message-encoding methods for encryption) objects

Parameters

algo_spec

the name of the EME to create

Returns

pointer to newly allocated object of that type

Definition at line 143 of file get_enc.cpp.

   {
   SCAN_Name request(algo_spec);
 
   Algorithm_Factory& af = global_state().algorithm_factory();
 
   if(request.algo_name() == "Raw")
      return 0; // No padding
 
#if defined(BOTAN_HAS_EME_PKCS1v15)
   if(request.algo_name() == "PKCS1v15" && request.arg_count() == 0)
      return new EME_PKCS1v15;
#endif
 
#if defined(BOTAN_HAS_EME1)
   if(request.algo_name() == "EME1" && request.arg_count_between(1, 2))
      {
      if(request.arg_count() == 1 ||
         (request.arg_count() == 2 && request.arg(1) == "MGF1"))
         {
         return new EME1(af.make_hash_function(request.arg(0)));
         }
      }
#endif
 
   throw Algorithm_Not_Found(algo_spec);
   }

References Botan::SCAN_Name::algo_name(), Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_count(), Botan::SCAN_Name::arg_count_between(), Botan::EME1::EME1(), get_eme(), global_state(), and Botan::Algorithm_Factory::make_hash_function().

Referenced by get_eme(), Botan::PK_Decryptor_EME::PK_Decryptor_EME(), and Botan::PK_Encryptor_EME::PK_Encryptor_EME().

get_emsa()

BOTAN_DLL EMSA * Botan::get_emsa

(

const std::string &

algo_spec

)

Factory method for EMSA (message-encoding methods for signatures with appendix) objects

Parameters

algo_spec

the name of the EME to create

Returns

pointer to newly allocated object of that type

Definition at line 86 of file get_enc.cpp.

   {
   SCAN_Name request(algo_spec);
 
   Algorithm_Factory& af = global_state().algorithm_factory();
 
#if defined(BOTAN_HAS_EMSA_RAW)
   if(request.algo_name() == "Raw" && request.arg_count() == 0)
      return new EMSA_Raw;
#endif
 
#if defined(BOTAN_HAS_EMSA1)
   if(request.algo_name() == "EMSA1" && request.arg_count() == 1)
      return new EMSA1(af.make_hash_function(request.arg(0)));
#endif
 
#if defined(BOTAN_HAS_EMSA1_BSI)
   if(request.algo_name() == "EMSA1_BSI" && request.arg_count() == 1)
      return new EMSA1_BSI(af.make_hash_function(request.arg(0)));
#endif
 
#if defined(BOTAN_HAS_EMSA2)
   if(request.algo_name() == "EMSA2" && request.arg_count() == 1)
      return new EMSA2(af.make_hash_function(request.arg(0)));
#endif
 
#if defined(BOTAN_HAS_EMSA3)
   if(request.algo_name() == "EMSA3" && request.arg_count() == 1)
      {
      if(request.arg(0) == "Raw")
         return new EMSA3_Raw;
      return new EMSA3(af.make_hash_function(request.arg(0)));
      }
#endif
 
#if defined(BOTAN_HAS_EMSA4)
   if(request.algo_name() == "EMSA4" && request.arg_count_between(1, 3))
      {
      // 3 args: Hash, MGF, salt size (MGF is hardcoded MGF1 in Botan)
      if(request.arg_count() == 1)
         return new EMSA4(af.make_hash_function(request.arg(0)));
 
      if(request.arg_count() == 2 && request.arg(1) != "MGF1")
         return new EMSA4(af.make_hash_function(request.arg(0)));
 
      if(request.arg_count() == 3)
         return new EMSA4(af.make_hash_function(request.arg(0)),
                          request.arg_as_integer(2, 0));
      }
#endif
 
   throw Algorithm_Not_Found(algo_spec);
   }

References Botan::SCAN_Name::algo_name(), Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_as_integer(), Botan::SCAN_Name::arg_count(), Botan::SCAN_Name::arg_count_between(), Botan::EMSA1::EMSA1(), Botan::EMSA1_BSI::EMSA1_BSI(), Botan::EMSA2::EMSA2(), Botan::EMSA3::EMSA3(), Botan::EMSA4::EMSA4(), get_emsa(), global_state(), and Botan::Algorithm_Factory::make_hash_function().

Referenced by get_emsa(), Botan::PK_Signer::PK_Signer(), and Botan::PK_Verifier::PK_Verifier().

get_hash()

HashFunction * Botan::get_hash ( const std::string & algo_spec )

inline

Hash function factory method.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the desired hash function

Returns

pointer to the hash function object

Definition at line 113 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return af.make_hash_function(algo_spec);
   }

References Botan::Library_State::algorithm_factory(), get_hash(), global_state(), and Botan::Algorithm_Factory::make_hash_function().

Referenced by get_hash().

get_kdf()

BOTAN_DLL KDF * Botan::get_kdf

(

const std::string &

algo_spec

)

Factory method for KDF (key derivation function)

Parameters

algo_spec

the name of the KDF to create

Returns

pointer to newly allocated object of that type

Definition at line 174 of file get_enc.cpp.

   {
   SCAN_Name request(algo_spec);
 
   Algorithm_Factory& af = global_state().algorithm_factory();
 
   if(request.algo_name() == "Raw")
      return 0; // No KDF
 
#if defined(BOTAN_HAS_KDF1)
   if(request.algo_name() == "KDF1" && request.arg_count() == 1)
      return new KDF1(af.make_hash_function(request.arg(0)));
#endif
 
#if defined(BOTAN_HAS_KDF2)
   if(request.algo_name() == "KDF2" && request.arg_count() == 1)
      return new KDF2(af.make_hash_function(request.arg(0)));
#endif
 
#if defined(BOTAN_HAS_X942_PRF)
   if(request.algo_name() == "X9.42-PRF" && request.arg_count() == 1)
      return new X942_PRF(request.arg(0)); // OID
#endif
 
#if defined(BOTAN_HAS_TLS_V10_PRF)
   if(request.algo_name() == "TLS-PRF" && request.arg_count() == 0)
      return new TLS_PRF;
#endif
 
#if defined(BOTAN_HAS_SSL_V3_PRF)
   if(request.algo_name() == "SSL3-PRF" && request.arg_count() == 0)
      return new SSL3_PRF;
#endif
 
   throw Algorithm_Not_Found(algo_spec);
   }

References Botan::SCAN_Name::algo_name(), Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_count(), get_kdf(), global_state(), Botan::KDF1::KDF1(), Botan::KDF2::KDF2(), Botan::Algorithm_Factory::make_hash_function(), and Botan::X942_PRF::X942_PRF().

Referenced by get_kdf(), and Botan::PK_Key_Agreement::PK_Key_Agreement().

get_mac()

MessageAuthenticationCode * Botan::get_mac ( const std::string & algo_spec )

inline

MAC factory method.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the desired MAC

Returns

pointer to the MAC object

Definition at line 126 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return af.make_mac(algo_spec);
   }

References Botan::Library_State::algorithm_factory(), get_mac(), global_state(), and Botan::Algorithm_Factory::make_mac().

Referenced by get_mac().

get_nanoseconds_clock()

BOTAN_DLL u64bit Botan::get_nanoseconds_clock

(

)

Returns

nanoseconds resolution timestamp, unknown epoch

Definition at line 93 of file time.cpp.

   {
#if defined(BOTAN_TARGET_OS_HAS_CLOCK_GETTIME)
 
   struct ::timespec tv;
   ::clock_gettime(CLOCK_REALTIME, &tv);
   return combine_timers(tv.tv_sec, tv.tv_nsec, 1000000000);
 
#elif defined(BOTAN_TARGET_OS_HAS_GETTIMEOFDAY)
 
   struct ::timeval tv;
   ::gettimeofday(&tv, 0);
   return combine_timers(tv.tv_sec, tv.tv_usec, 1000000);
 
#elif defined(BOTAN_TARGET_OS_HAS_WIN32_GET_SYSTEMTIME)
 
   // Returns time since January 1, 1601 in 100-ns increments
   ::FILETIME tv;
   ::GetSystemTimeAsFileTime(&tv);
   u64bit tstamp = (static_cast<u64bit>(tv.dwHighDateTime) << 32) |
                   tv.dwLowDateTime;
 
   return (tstamp * 100); // Scale to 1 nanosecond units
 
#else
 
   return combine_timers(static_cast<u32bit>(std::time(0)),
                         std::clock(), CLOCKS_PER_SEC);
 
#endif
   }

References get_nanoseconds_clock().

Referenced by get_nanoseconds_clock().

get_pbe() [1/2]

BOTAN_DLL PBE * Botan::get_pbe	(	const OID &	pbe_oid,
		DataSource &	params )

Factory function for PBEs.

Parameters

pbe_oid	the oid of the desired PBE
params	a DataSource providing the DER encoded parameters to use

Returns

pointer to the PBE with the specified parameters

Definition at line 77 of file get_pbe.cpp.

   {
   SCAN_Name request(OIDS::lookup(pbe_oid));
 
   const std::string pbe = request.algo_name();
 
#if defined(BOTAN_HAS_PBE_PKCS_V15)
   if(pbe == "PBE-PKCS5v15")
      {
      if(request.arg_count() != 2)
         throw Invalid_Algorithm_Name(request.as_string());
 
      std::string digest_name = request.arg(0);
      const std::string cipher = request.arg(1);
 
      std::vector<std::string> cipher_spec = split_on(cipher, '/');
      if(cipher_spec.size() != 2)
         throw Invalid_Argument("PBE: Invalid cipher spec " + cipher);
 
      const std::string cipher_algo = global_state().deref_alias(cipher_spec[0]);
      const std::string cipher_mode = cipher_spec[1];
 
      if(cipher_mode != "CBC")
         throw Invalid_Argument("PBE: Invalid cipher mode " + cipher);
 
      Algorithm_Factory& af = global_state().algorithm_factory();
 
      const BlockCipher* block_cipher = af.prototype_block_cipher(cipher_algo);
      if(!block_cipher)
         throw Algorithm_Not_Found(cipher_algo);
 
      const HashFunction* hash_function =
         af.prototype_hash_function(digest_name);
 
      if(!hash_function)
         throw Algorithm_Not_Found(digest_name);
 
      PBE* pbe = new PBE_PKCS5v15(block_cipher->clone(),
                                  hash_function->clone(),
                                  DECRYPTION);
      pbe->decode_params(params);
      return pbe;
      }
#endif
 
#if defined(BOTAN_HAS_PBE_PKCS_V20)
   if(pbe == "PBE-PKCS5v20")
      return new PBE_PKCS5v20(params);
#endif
 
   throw Algorithm_Not_Found(pbe_oid.as_string());
   }

References Botan::SCAN_Name::algo_name(), Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_count(), Botan::OID::as_string(), Botan::SCAN_Name::as_string(), Botan::BlockCipher::clone(), Botan::HashFunction::clone(), Botan::PBE::decode_params(), DECRYPTION, Botan::Library_State::deref_alias(), get_pbe(), global_state(), Botan::Invalid_Algorithm_Name::Invalid_Algorithm_Name(), Botan::OIDS::lookup(), Botan::PBE_PKCS5v15::PBE_PKCS5v15(), Botan::PBE_PKCS5v20::PBE_PKCS5v20(), Botan::Algorithm_Factory::prototype_block_cipher(), Botan::Algorithm_Factory::prototype_hash_function(), and split_on().

get_pbe() [2/2]

BOTAN_DLL PBE * Botan::get_pbe

(

const std::string &

algo_spec

)

Factory function for PBEs.

Parameters

algo_spec

the name of the PBE algorithm to retrieve

Returns

pointer to a PBE with randomly created parameters

Definition at line 27 of file get_pbe.cpp.

   {
   SCAN_Name request(algo_spec);
 
   const std::string pbe = request.algo_name();
   std::string digest_name = request.arg(0);
   const std::string cipher = request.arg(1);
 
   std::vector<std::string> cipher_spec = split_on(cipher, '/');
   if(cipher_spec.size() != 2)
      throw Invalid_Argument("PBE: Invalid cipher spec " + cipher);
 
   const std::string cipher_algo = global_state().deref_alias(cipher_spec[0]);
   const std::string cipher_mode = cipher_spec[1];
 
   if(cipher_mode != "CBC")
      throw Invalid_Argument("PBE: Invalid cipher mode " + cipher);
 
   Algorithm_Factory& af = global_state().algorithm_factory();
 
   const BlockCipher* block_cipher = af.prototype_block_cipher(cipher_algo);
   if(!block_cipher)
      throw Algorithm_Not_Found(cipher_algo);
 
   const HashFunction* hash_function = af.prototype_hash_function(digest_name);
   if(!hash_function)
      throw Algorithm_Not_Found(digest_name);
 
   if(request.arg_count() != 2)
      throw Invalid_Algorithm_Name(algo_spec);
 
#if defined(BOTAN_HAS_PBE_PKCS_V15)
   if(pbe == "PBE-PKCS5v15")
      return new PBE_PKCS5v15(block_cipher->clone(),
                              hash_function->clone(),
                              ENCRYPTION);
#endif
 
#if defined(BOTAN_HAS_PBE_PKCS_V20)
   if(pbe == "PBE-PKCS5v20")
      return new PBE_PKCS5v20(block_cipher->clone(),
                              hash_function->clone());
#endif
 
   throw Algorithm_Not_Found(algo_spec);
   }

References Botan::SCAN_Name::algo_name(), Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_count(), Botan::BlockCipher::clone(), Botan::HashFunction::clone(), Botan::Library_State::deref_alias(), ENCRYPTION, get_pbe(), global_state(), Botan::Invalid_Algorithm_Name::Invalid_Algorithm_Name(), Botan::PBE_PKCS5v15::PBE_PKCS5v15(), Botan::PBE_PKCS5v20::PBE_PKCS5v20(), Botan::Algorithm_Factory::prototype_block_cipher(), Botan::Algorithm_Factory::prototype_hash_function(), and split_on().

Referenced by Botan::PKCS8::BER_encode(), get_pbe(), and get_pbe().

get_pbkdf()

BOTAN_DLL PBKDF * Botan::get_pbkdf

(

const std::string &

algo_spec

)

Password based key derivation function factory method

Parameters

algo_spec

the name of the desired PBKDF algorithm

Returns

pointer to newly allocated object of that type

Definition at line 73 of file get_enc.cpp.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
 
   if(PBKDF* pbkdf = af.make_pbkdf(algo_spec))
      return pbkdf;
 
   throw Algorithm_Not_Found(algo_spec);
   }

References Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), get_pbkdf(), global_state(), and Botan::Algorithm_Factory::make_pbkdf().

Referenced by get_pbkdf(), and get_s2k().

get_pk_decryptor()

PK_Decryptor * Botan::get_pk_decryptor ( const Private_Key & key, const std::string & eme )

inline

Public key decryptor factory method.

Deprecated

Instantiate object from pubkey.h directly

Parameters

key	the key that will work inside the decryptor
eme	determines the algorithm and encoding

Returns

public key decryptor object

Definition at line 40 of file look_pk.h.

   {
   return new PK_Decryptor_EME(key, eme);
   }

References get_pk_decryptor(), and Botan::PK_Decryptor_EME::PK_Decryptor_EME().

Referenced by get_pk_decryptor().

get_pk_encryptor()

PK_Encryptor * Botan::get_pk_encryptor ( const Public_Key & key, const std::string & eme )

inline

Public key encryptor factory method.

Deprecated

Instantiate object from pubkey.h directly

Parameters

key	the key that will work inside the encryptor
eme	determines the algorithm and encoding

Returns

public key encryptor object

Definition at line 25 of file look_pk.h.

   {
   return new PK_Encryptor_EME(key, eme);
   }

References get_pk_encryptor(), and Botan::PK_Encryptor_EME::PK_Encryptor_EME().

Referenced by get_pk_encryptor().

get_pk_kas()

PK_Key_Agreement * Botan::get_pk_kas ( const PK_Key_Agreement_Key & key, const std::string & kdf )

inline

Public key key agreement factory method.

Deprecated

Instantiate object from pubkey.h directly

Parameters

key	the key that will work inside the key agreement
kdf	the kdf algorithm to use

Returns

key agreement algorithm

Definition at line 89 of file look_pk.h.

   {
   return new PK_Key_Agreement(key, kdf);
   }

References get_pk_kas(), and Botan::PK_Key_Agreement::PK_Key_Agreement().

Referenced by get_pk_kas().

get_pk_signer()

PK_Signer * Botan::get_pk_signer ( const Private_Key & key, const std::string & emsa, Signature_Format sig_format = IEEE_1363 )

inline

Public key signer factory method.

Deprecated

Instantiate object from pubkey.h directly

Parameters

key	the key that will work inside the signer
emsa	determines the algorithm, encoding and hash algorithm
sig_format	the signature format to be used

Returns

public key signer object

Definition at line 56 of file look_pk.h.

   {
   return new PK_Signer(key, emsa, sig_format);
   }

References get_pk_signer(), IEEE_1363, and Botan::PK_Signer::PK_Signer().

Referenced by get_pk_signer().

get_pk_verifier()

PK_Verifier * Botan::get_pk_verifier ( const Public_Key & key, const std::string & emsa, Signature_Format sig_format = IEEE_1363 )

inline

Public key verifier factory method.

Deprecated

Instantiate object from pubkey.h directly

Parameters

key	the key that will work inside the verifier
emsa	determines the algorithm, encoding and hash algorithm
sig_format	the signature format to be used

Returns

public key verifier object

Definition at line 73 of file look_pk.h.

   {
   return new PK_Verifier(key, emsa, sig_format);
   }

References get_pk_verifier(), IEEE_1363, and Botan::PK_Verifier::PK_Verifier().

Referenced by get_pk_verifier().

get_s2k()

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

inline

Deprecated

Use get_pbkdf

Parameters

algo_spec

the name of the desired algorithm

Returns

pointer to newly allocated object of that type

Definition at line 144 of file lookup.h.

   {
   return get_pbkdf(algo_spec);
   }

References get_pbkdf(), and get_s2k().

Referenced by get_s2k().

get_stream_cipher()

StreamCipher * Botan::get_stream_cipher ( const std::string & algo_spec )

inline

Stream cipher factory method.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the desired stream cipher

Returns

pointer to the stream cipher object

Definition at line 100 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return af.make_stream_cipher(algo_spec);
   }

References Botan::Library_State::algorithm_factory(), get_stream_cipher(), global_state(), and Botan::Algorithm_Factory::make_stream_cipher().

Referenced by get_stream_cipher().

global_state()

BOTAN_DLL Library_State & Botan::Global_State_Management::global_state

(

)

Access the global library state

Returns

reference to the global library state

Definition at line 32 of file global_state.cpp.

   {
   /* Lazy initialization. Botan still needs to be deinitialized later
      on or memory might leak.
   */
   if(!global_lib_state)
      {
      global_lib_state = new Library_State;
      global_lib_state->initialize(true);
      }
 
   return (*global_lib_state);
   }

Referenced by Botan::OIDS::add_oid(), Botan::AutoSeeded_RNG::AutoSeeded_RNG(), block_size_of(), Botan::DH_KA_Operation::DH_KA_Operation(), Botan::DL_Group::DL_Group(), Botan::DL_Group::DL_Group(), Botan::DL_Group::DL_Group(), Botan::EC_Group::EC_Group(), Botan::ElGamal_Decryption_Operation::ElGamal_Decryption_Operation(), Botan::Allocator::get(), get_block_cipher(), get_cipher(), get_eme(), get_emsa(), get_hash(), get_kdf(), get_mac(), get_pbe(), get_pbe(), get_pbkdf(), get_stream_cipher(), Botan::Hash_Filter::Hash_Filter(), have_algorithm(), have_block_cipher(), have_hash(), have_mac(), Botan::OIDS::have_oid(), have_stream_cipher(), Botan::LibraryInitializer::initialize(), keylength_multiple_of(), Botan::OIDS::lookup(), Botan::OIDS::lookup(), Botan::MAC_Filter::MAC_Filter(), Botan::MAC_Filter::MAC_Filter(), max_keylength_of(), min_keylength_of(), output_length_of(), Botan::PK_Decryptor_EME::PK_Decryptor_EME(), Botan::PK_Encryptor_EME::PK_Encryptor_EME(), Botan::PK_Key_Agreement::PK_Key_Agreement(), Botan::PK_Signer::PK_Signer(), Botan::PK_Verifier::PK_Verifier(), retrieve_block_cipher(), retrieve_hash(), retrieve_mac(), retrieve_stream_cipher(), Botan::RSA_Private_Operation::RSA_Private_Operation(), Botan::SCAN_Name::SCAN_Name(), Botan::Record_Reader::set_keys(), Botan::Record_Writer::set_keys(), Botan::Power_Mod::set_modulus(), Botan::StreamCipher_Filter::StreamCipher_Filter(), and Botan::StreamCipher_Filter::StreamCipher_Filter().

hamming_weight()

template<typename T>

size_t Botan::hamming_weight ( T n )

inline

Compute Hamming weights

Parameters

n	an integer value

Returns

number of bits in n set to 1

Definition at line 76 of file bit_ops.h.

   {
   const byte NIBBLE_WEIGHTS[] = {
      0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
 
   size_t weight = 0;
   for(size_t i = 0; i != 2*sizeof(T); ++i)
      weight += NIBBLE_WEIGHTS[(n >> (4*i)) & 0x0F];
   return weight;
   }

References hamming_weight().

Referenced by hamming_weight().

has_mlock()

bool Botan::has_mlock

(

)

Check if we can at least potentially lock memory

Definition at line 19 of file mlock.cpp.

   {
   byte buf[4096];
   if(!lock_mem(&buf, sizeof(buf)))
      return false;
   unlock_mem(&buf, sizeof(buf));
   return true;
   }

References has_mlock(), lock_mem(), and unlock_mem().

Referenced by has_mlock(), and Botan::Library_State::initialize().

have_algorithm()

BOTAN_DLL bool Botan::have_algorithm

(

const std::string &

algo_spec

)

Check if an algorithm exists.

Parameters

algo_spec

the name of the algorithm to check for

Returns

true if the algorithm exists, false otherwise

Definition at line 17 of file lookup.cpp.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
 
   if(af.prototype_block_cipher(name))
      return true;
   if(af.prototype_stream_cipher(name))
      return true;
   if(af.prototype_hash_function(name))
      return true;
   if(af.prototype_mac(name))
      return true;
   return false;
   }

References Botan::Library_State::algorithm_factory(), global_state(), have_algorithm(), Botan::Algorithm_Factory::prototype_block_cipher(), Botan::Algorithm_Factory::prototype_hash_function(), Botan::Algorithm_Factory::prototype_mac(), and Botan::Algorithm_Factory::prototype_stream_cipher().

Referenced by have_algorithm().

have_block_cipher()

bool Botan::have_block_cipher ( const std::string & algo_spec )

inline

Check if a block cipher algorithm exists.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the algorithm to check for

Returns

true if the algorithm exists, false otherwise

Definition at line 235 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return (af.prototype_block_cipher(algo_spec) != 0);
   }

References Botan::Library_State::algorithm_factory(), global_state(), have_block_cipher(), and Botan::Algorithm_Factory::prototype_block_cipher().

Referenced by have_block_cipher(), Botan::SessionKeys::SessionKeys(), Botan::Record_Reader::set_keys(), and Botan::Record_Writer::set_keys().

have_hash()

bool Botan::have_hash ( const std::string & algo_spec )

inline

Check if a hash algorithm exists.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the algorithm to check for

Returns

true if the algorithm exists, false otherwise

Definition at line 261 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return (af.prototype_hash_function(algo_spec) != 0);
   }

References Botan::Library_State::algorithm_factory(), global_state(), have_hash(), and Botan::Algorithm_Factory::prototype_hash_function().

Referenced by have_hash(), Botan::Record_Reader::set_keys(), and Botan::Record_Writer::set_keys().

have_mac()

bool Botan::have_mac ( const std::string & algo_spec )

inline

Check if a MAC algorithm exists.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the algorithm to check for

Returns

true if the algorithm exists, false otherwise

Definition at line 274 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return (af.prototype_mac(algo_spec) != 0);
   }

References Botan::Library_State::algorithm_factory(), global_state(), have_mac(), and Botan::Algorithm_Factory::prototype_mac().

Referenced by have_mac().

have_stream_cipher()

bool Botan::have_stream_cipher ( const std::string & algo_spec )

inline

Check if a stream cipher algorithm exists.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the algorithm to check for

Returns

true if the algorithm exists, false otherwise

Definition at line 248 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return (af.prototype_stream_cipher(algo_spec) != 0);
   }

References Botan::Library_State::algorithm_factory(), global_state(), have_stream_cipher(), and Botan::Algorithm_Factory::prototype_stream_cipher().

Referenced by have_stream_cipher(), Botan::Record_Reader::set_keys(), and Botan::Record_Writer::set_keys().

hex_decode() [1/5]

size_t BOTAN_DLL Botan::hex_decode	(	byte	output[],
		const char	input[],
		size_t	input_length,
		bool	ignore_ws = true )

Perform hex decoding

Parameters

output	an array of at least input_length/2 bytes
input	some hex 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 146 of file hex.cpp.

   {
   size_t consumed = 0;
   size_t written = hex_decode(output, input, input_length,
                               consumed, ignore_ws);
 
   if(consumed != input_length)
      throw std::invalid_argument("hex_decode: input did not have full bytes");
 
   return written;
   }

References hex_decode().

hex_decode() [2/5]

size_t BOTAN_DLL Botan::hex_decode	(	byte	output[],
		const char	input[],
		size_t	input_length,
		size_t &	input_consumed,
		bool	ignore_ws = true )

Perform hex decoding

Parameters

output	an array of at least input_length/2 bytes
input	some hex 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.
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 55 of file hex.cpp.

   {
   /*
   * Mapping of hex characters to either their binary equivalent
   * or to an error code.
   *  If valid hex (0-9 A-F a-f), the value.
   *  If whitespace, then 0x80
   *  Otherwise 0xFF
   * Warning: this table assumes ASCII character encodings
   */
 
   static const byte HEX_TO_BIN[256] = {
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80,
      0x80, 0xFF, 0xFF, 0xFF, 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, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01,
      0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
      0x0F, 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, 0x0A, 0x0B, 0x0C,
      0x0D, 0x0E, 0x0F, 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, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
 
   byte* out_ptr = output;
   bool top_nibble = true;
 
   clear_mem(output, input_length / 2);
 
   for(size_t i = 0; i != input_length; ++i)
      {
      const byte bin = HEX_TO_BIN[static_cast<byte>(input[i])];
 
      if(bin >= 0x10)
         {
         if(bin == 0x80 && ignore_ws)
            continue;
 
         std::string bad_char(1, input[i]);
         if(bad_char == "\t")
           bad_char = "\\t";
         else if(bad_char == "\n")
           bad_char = "\\n";
 
         throw std::invalid_argument(
           std::string("hex_decode: invalid hex character '") +
           bad_char + "'");
         }
 
      *out_ptr |= bin << (top_nibble*4);
 
      top_nibble = !top_nibble;
      if(top_nibble)
         ++out_ptr;
      }
 
   input_consumed = input_length;
   size_t written = (out_ptr - output);
 
   /*
   * We only got half of a byte at the end; zap the half-written
   * output and mark it as unread
   */
   if(!top_nibble)
      {
      *out_ptr = 0;
      input_consumed -= 1;
      }
 
   return written;
   }

References clear_mem(), and hex_decode().

Referenced by Botan::OctetString::change(), Botan::BigInt::decode(), Botan::Hex_Decoder::end_msg(), Botan::Data_Store::get1_memvec(), hex_decode(), hex_decode(), hex_decode(), hex_decode(), hex_decode(), Botan::RTSS_Share::RTSS_Share(), and Botan::Hex_Decoder::write().

hex_decode() [3/5]

size_t BOTAN_DLL Botan::hex_decode	(	byte	output[],
		const std::string &	input,
		bool	ignore_ws = true )

Perform hex decoding

Parameters

output	an array of at least input_length/2 bytes
input	some hex 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 161 of file hex.cpp.

   {
   return hex_decode(output, &input[0], input.length(), ignore_ws);
   }

References hex_decode().

hex_decode() [4/5]

SecureVector< byte > BOTAN_DLL Botan::hex_decode	(	const char	input[],
		size_t	input_length,
		bool	ignore_ws = true )

Perform hex decoding

Parameters

input	some hex 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 hex output

Definition at line 168 of file hex.cpp.

   {
   SecureVector<byte> bin(1 + input_length / 2);
 
   size_t written = hex_decode(&bin[0],
                               input,
                               input_length,
                               ignore_ws);
 
   bin.resize(written);
   return bin;
   }

References hex_decode(), and Botan::MemoryRegion< T >::resize().

hex_decode() [5/5]

SecureVector< byte > BOTAN_DLL Botan::hex_decode	(	const std::string &	input,
		bool	ignore_ws = true )

Perform hex decoding

Parameters

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

Returns

decoded hex output

Definition at line 183 of file hex.cpp.

   {
   return hex_decode(&input[0], input.size(), ignore_ws);
   }

References hex_decode().

hex_encode() [1/3]

void BOTAN_DLL Botan::hex_encode	(	char	output[],
		const byte	input[],
		size_t	input_length,
		bool	uppercase = true )

Perform hex encoding

Parameters

output	an array of at least input_length*2 bytes
input	is some binary data
input_length	length of input in bytes
uppercase	should output be upper or lower case?

Definition at line 14 of file hex.cpp.

   {
   static const byte BIN_TO_HEX_UPPER[16] = {
      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
      'A', 'B', 'C', 'D', 'E', 'F' };
 
   static const byte BIN_TO_HEX_LOWER[16] = {
      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
      'a', 'b', 'c', 'd', 'e', 'f' };
 
   const byte* tbl = uppercase ? BIN_TO_HEX_UPPER : BIN_TO_HEX_LOWER;
 
   for(size_t i = 0; i != input_length; ++i)
      {
      byte x = input[i];
      output[2*i  ] = tbl[(x >> 4) & 0x0F];
      output[2*i+1] = tbl[(x     ) & 0x0F];
      }
   }

References hex_encode().

Referenced by Botan::Data_Store::add(), Botan::OctetString::as_string(), Botan::BigInt::encode(), hex_encode(), hex_encode(), hex_encode(), Botan::RTSS_Share::to_string(), and Botan::X509_Certificate::to_string().

hex_encode() [2/3]

std::string BOTAN_DLL Botan::hex_encode	(	const byte	input[],
		size_t	input_length,
		bool	uppercase = true )

Perform hex encoding

Parameters

input	some input
input_length	length of input in bytes
uppercase	should output be upper or lower case?

Returns

hexadecimal representation of input

Definition at line 43 of file hex.cpp.

   {
   std::string output(2 * input_length, 0);
 
   if(input_length)
      hex_encode(&output[0], input, input_length, uppercase);
 
   return output;
   }

References hex_encode().

hex_encode() [3/3]

std::string BOTAN_DLL Botan::hex_encode	(	const MemoryRegion< byte > &	input,
		bool	uppercase = true )

Perform hex encoding

Parameters

input	some input
uppercase	should output be upper or lower case?

Returns

hexadecimal representation of input

Definition at line 37 of file hex.cpp.

   {
   return hex_encode(&input[0], input.size(), uppercase);
   }

References hex_encode(), and Botan::MemoryRegion< T >::size().

high_bit()

template<typename T>

size_t Botan::high_bit ( T n )

inline

Return the index of the highest set bit T is an unsigned integer type

Parameters

n	an integer value

Returns

index of the highest set bit in n

Definition at line 33 of file bit_ops.h.

   {
   for(size_t i = 8*sizeof(T); i > 0; --i)
      if((n >> (i - 1)) & 0x01)
         return i;
   return 0;
   }

References high_bit().

Referenced by Botan::OID::encode_into(), and high_bit().

ieee1363_hash_id()

BOTAN_DLL byte Botan::ieee1363_hash_id

(

const std::string &

hash_name

)

Return the IEEE 1363 hash identifier

Parameters

hash_name

the name of the hash function

Returns

byte code identifying the hash, or 0 if not known

Definition at line 93 of file hash_id.cpp.

   {
   if(name == "SHA-160")    return 0x33;
 
   if(name == "SHA-224")    return 0x38;
   if(name == "SHA-256")    return 0x34;
   if(name == "SHA-384")    return 0x36;
   if(name == "SHA-512")    return 0x35;
 
   if(name == "RIPEMD-160") return 0x31;
   if(name == "RIPEMD-128") return 0x32;
 
   if(name == "Whirlpool")  return 0x37;
 
   return 0;
   }

References ieee1363_hash_id().

Referenced by Botan::EMSA2::EMSA2(), and ieee1363_hash_id().

inverse_mod()

BigInt BOTAN_DLL Botan::inverse_mod	(	const BigInt &	x,
		const BigInt &	modulus )

Modular inversion

Parameters

x	a positive integer
modulus	a positive integer

Returns

y st (x*y) % modulus == 1

Definition at line 314 of file numthry.cpp.

   {
   if(mod.is_zero())
      throw BigInt::DivideByZero();
   if(mod.is_negative() || n.is_negative())
      throw Invalid_Argument("inverse_mod: arguments must be non-negative");
 
   if(n.is_zero() || (n.is_even() && mod.is_even()))
      return 0;
 
   if(mod.is_odd())
      return ct_inverse_mod_odd_modulus(n % mod, mod);
 
   BigInt x = mod, y = n, u = mod, v = n;
   BigInt A = 1, B = 0, C = 0, D = 1;
 
   while(u.is_nonzero())
      {
      size_t zero_bits = low_zero_bits(u);
      u >>= zero_bits;
      for(size_t i = 0; i != zero_bits; ++i)
         {
         if(A.is_odd() || B.is_odd())
            { A += y; B -= x; }
         A >>= 1; B >>= 1;
         }
 
      zero_bits = low_zero_bits(v);
      v >>= zero_bits;
      for(size_t i = 0; i != zero_bits; ++i)
         {
         if(C.is_odd() || D.is_odd())
            { C += y; D -= x; }
         C >>= 1; D >>= 1;
         }
 
      if(u >= v) { u -= v; A -= C; B -= D; }
      else       { v -= u; C -= A; D -= B; }
      }
 
   if(v != 1)
      return 0;
 
   while(D.is_negative()) D += mod;
   while(D >= mod) D -= mod;
 
   return D;
   }

References inverse_mod(), Botan::BigInt::is_even(), Botan::BigInt::is_negative(), Botan::BigInt::is_odd(), Botan::BigInt::is_zero(), and low_zero_bits().

Referenced by Botan::IF_Scheme_PrivateKey::check_key(), Botan::CurveGFp::CurveGFp(), Botan::ElGamal_Decryption_Operation::decrypt(), Botan::DH_KA_Operation::DH_KA_Operation(), Botan::ECDH_KA_Operation::ECDH_KA_Operation(), Botan::PointGFp::get_affine_x(), Botan::PointGFp::get_affine_y(), Botan::IF_Scheme_PrivateKey::IF_Scheme_PrivateKey(), inverse_mod(), Botan::Montgomery_Exponentiator::Montgomery_Exponentiator(), Botan::RSA_Private_Operation::RSA_Private_Operation(), Botan::RSA_PrivateKey::RSA_PrivateKey(), Botan::RW_PrivateKey::RW_PrivateKey(), Botan::DSA_Signature_Operation::sign(), Botan::ECDSA_Signature_Operation::sign(), Botan::RW_Signature_Operation::sign(), Botan::DSA_Verification_Operation::verify(), and Botan::ECDSA_Verification_Operation::verify().

ipv4_to_string()

BOTAN_DLL std::string Botan::ipv4_to_string

(

u32bit

ip_addr

)

Convert an IPv4 address to a string

Parameters

ip_addr

the IPv4 address to convert

Returns

string representation of the IPv4 address

Definition at line 279 of file parsing.cpp.

   {
   std::string str;
 
   for(size_t i = 0; i != sizeof(ip); ++i)
      {
      if(i)
         str += ".";
      str += to_string(get_byte(i, ip));
      }
 
   return str;
   }

References get_byte(), ipv4_to_string(), and to_string().

Referenced by Botan::AlternativeName::decode_from(), and ipv4_to_string().

jacobi()

s32bit BOTAN_DLL Botan::jacobi	(	const BigInt &	a,
		const BigInt &	n )

Compute the Jacobi symbol. If n is prime, this is equivalent to the Legendre symbol.

See also

http://mathworld.wolfram.com/JacobiSymbol.html

Parameters

a	is a non-negative integer
n	is an odd integer > 1

Returns

(n / m)

Definition at line 15 of file jacobi.cpp.

   {
   if(a.is_negative())
      throw Invalid_Argument("jacobi: first argument must be non-negative");
   if(n.is_even() || n < 2)
      throw Invalid_Argument("jacobi: second argument must be odd and > 1");
 
   BigInt x = a, y = n;
   s32bit J = 1;
 
   while(y > 1)
      {
      x %= y;
      if(x > y / 2)
         {
         x = y - x;
         if(y % 4 == 3)
            J = -J;
         }
      if(x.is_zero())
         return 0;
 
      size_t shifts = low_zero_bits(x);
      x >>= shifts;
      if(shifts % 2)
         {
         word y_mod_8 = y % 8;
         if(y_mod_8 == 3 || y_mod_8 == 5)
            J = -J;
         }
 
      if(x % 4 == 3 && y % 4 == 3)
         J = -J;
      std::swap(x, y);
      }
   return J;
   }

References Botan::BigInt::is_even(), Botan::BigInt::is_negative(), Botan::BigInt::is_zero(), jacobi(), low_zero_bits(), and std::swap().

Referenced by jacobi(), ressol(), and Botan::RW_Signature_Operation::sign().

keylength_multiple_of()

BOTAN_DLL size_t Botan::keylength_multiple_of

(

const std::string &

algo_spec

)

Find out the size any valid key is a multiple of for a certain algorithm.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the algorithm

Returns

size any valid key is a multiple of

Definition at line 105 of file lookup.cpp.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
 
   if(const BlockCipher* bc = af.prototype_block_cipher(name))
      return bc->key_spec().keylength_multiple();
 
   if(const StreamCipher* sc = af.prototype_stream_cipher(name))
      return sc->key_spec().keylength_multiple();
 
   if(const MessageAuthenticationCode* mac = af.prototype_mac(name))
      return mac->key_spec().keylength_multiple();
 
   throw Algorithm_Not_Found(name);
   }

References Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), global_state(), keylength_multiple_of(), Botan::Algorithm_Factory::prototype_block_cipher(), Botan::Algorithm_Factory::prototype_mac(), and Botan::Algorithm_Factory::prototype_stream_cipher().

Referenced by keylength_multiple_of().

lcm()

BigInt BOTAN_DLL Botan::lcm	(	const BigInt &	x,
		const BigInt &	y )

Least common multiple

Parameters

x	a positive integer
y	a positive integer

Returns

z, smallest integer such that z % x == 0 and z % y == 0

Definition at line 195 of file numthry.cpp.

   {
   return ((a * b) / gcd(a, b));
   }

References gcd(), and lcm().

Referenced by Botan::RSA_PrivateKey::check_key(), Botan::RW_PrivateKey::check_key(), Botan::IF_Scheme_PrivateKey::IF_Scheme_PrivateKey(), lcm(), Botan::RSA_PrivateKey::RSA_PrivateKey(), and Botan::RW_PrivateKey::RW_PrivateKey().

load_be() [1/5]

template<typename T>

T Botan::load_be ( const byte in[], size_t off )

inline

Load a big-endian word

Parameters

in	a pointer to some bytes
off	an offset into the array

Returns

off'th T of in, as a big-endian value

Definition at line 100 of file loadstor.h.

   {
   in += off * sizeof(T);
   T out = 0;
   for(size_t i = 0; i != sizeof(T); ++i)
      out = (out << 8) | in[i];
   return out;
   }

References load_be().

Referenced by check_passhash9(), Botan::SHA_160::compress_n(), Botan::AlternativeName::decode_from(), Botan::Blowfish::decrypt_n(), Botan::CAST_128::decrypt_n(), Botan::CAST_256::decrypt_n(), Botan::KASUMI::decrypt_n(), Botan::MISTY1::decrypt_n(), Botan::Noekeon::decrypt_n(), Botan::SEED::decrypt_n(), Botan::TEA::decrypt_n(), Botan::XTEA::decrypt_n(), Botan::Blowfish::encrypt_n(), Botan::CAST_128::encrypt_n(), Botan::CAST_256::encrypt_n(), Botan::KASUMI::encrypt_n(), Botan::MISTY1::encrypt_n(), Botan::Noekeon::encrypt_n(), Botan::SEED::encrypt_n(), Botan::TEA::encrypt_n(), Botan::XTEA::encrypt_n(), Botan::TLS_Data_Reader::get_elem(), load_be(), load_be(), load_be(), load_be(), load_be(), Botan::SIMD_Scalar::load_be(), load_be< u16bit >(), load_be< u32bit >(), load_be< u64bit >(), rfc3394_keyunwrap(), and Botan::WiderWake_41_BE::set_iv().

load_be() [2/5]

template<typename T>

void Botan::load_be ( const byte in[], T & x0, T & x1 )

inline

Load two big-endian words

Parameters

in	a pointer to some bytes
x0	where the first word will be written
x1	where the second word will be written

Definition at line 325 of file loadstor.h.

   {
   x0 = load_be<T>(in, 0);
   x1 = load_be<T>(in, 1);
   }

References load_be().

load_be() [3/5]

template<typename T>

void Botan::load_be ( const byte in[], T & x0, T & x1, T & x2, T & x3 )

inline

Load four big-endian words

Parameters

in	a pointer to some bytes
x0	where the first word will be written
x1	where the second word will be written
x2	where the third word will be written
x3	where the fourth word will be written

Definition at line 340 of file loadstor.h.

   {
   x0 = load_be<T>(in, 0);
   x1 = load_be<T>(in, 1);
   x2 = load_be<T>(in, 2);
   x3 = load_be<T>(in, 3);
   }

References load_be().

load_be() [4/5]

template<typename T>

void Botan::load_be ( const byte in[], T & x0, T & x1, T & x2, T & x3, T & x4, T & x5, T & x6, T & x7 )

inline

Load eight big-endian words

Parameters

in	a pointer to some bytes
x0	where the first word will be written
x1	where the second word will be written
x2	where the third word will be written
x3	where the fourth word will be written
x4	where the fifth word will be written
x5	where the sixth word will be written
x6	where the seventh word will be written
x7	where the eighth word will be written

Definition at line 362 of file loadstor.h.

   {
   x0 = load_be<T>(in, 0);
   x1 = load_be<T>(in, 1);
   x2 = load_be<T>(in, 2);
   x3 = load_be<T>(in, 3);
   x4 = load_be<T>(in, 4);
   x5 = load_be<T>(in, 5);
   x6 = load_be<T>(in, 6);
   x7 = load_be<T>(in, 7);
   }

References load_be().

load_be() [5/5]

template<typename T>

void Botan::load_be ( T out[], const byte in[], size_t count )

inline

Load a variable number of big-endian words

Parameters

out	the output array of words
in	the input array of bytes
count	how many words are in in

Definition at line 383 of file loadstor.h.

   {
#if defined(BOTAN_TARGET_CPU_HAS_KNOWN_ENDIANNESS)
   std::memcpy(out, in, sizeof(T)*count);
 
#if defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
   const size_t blocks = count - (count % 4);
   const size_t left = count - blocks;
 
   for(size_t i = 0; i != blocks; i += 4)
      bswap_4(out + i);
 
   for(size_t i = 0; i != left; ++i)
      out[blocks+i] = reverse_bytes(out[blocks+i]);
#endif
 
#else
   for(size_t i = 0; i != count; ++i)
      out[i] = load_be<T>(in, i);
#endif
   }

References bswap_4(), load_be(), and reverse_bytes().

load_be< u16bit >()

template<>

u16bit Botan::load_be< u16bit > ( const byte in[], size_t off )

inline

Load a big-endian u16bit

Parameters

in	a pointer to some bytes
off	an offset into the array

Returns

off'th u16bit of in, as a big-endian value

Definition at line 132 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   return BOTAN_ENDIAN_N2B(*(reinterpret_cast<const u16bit*>(in) + off));
#else
   in += off * sizeof(u16bit);
   return make_u16bit(in[0], in[1]);
#endif
   }

References load_be(), and make_u16bit().

load_be< u32bit >()

template<>

u32bit Botan::load_be< u32bit > ( const byte in[], size_t off )

inline

Load a big-endian u32bit

Parameters

in	a pointer to some bytes
off	an offset into the array

Returns

off'th u32bit of in, as a big-endian value

Definition at line 166 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   return BOTAN_ENDIAN_N2B(*(reinterpret_cast<const u32bit*>(in) + off));
#else
   in += off * sizeof(u32bit);
   return make_u32bit(in[0], in[1], in[2], in[3]);
#endif
   }

References load_be(), and make_u32bit().

load_be< u64bit >()

template<>

u64bit Botan::load_be< u64bit > ( const byte in[], size_t off )

inline

Load a big-endian u64bit

Parameters

in	a pointer to some bytes
off	an offset into the array

Returns

off'th u64bit of in, as a big-endian value

Definition at line 200 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   return BOTAN_ENDIAN_N2B(*(reinterpret_cast<const u64bit*>(in) + off));
#else
   in += off * sizeof(u64bit);
   return make_u64bit(in[0], in[1], in[2], in[3],
                      in[4], in[5], in[6], in[7]);
#endif
   }

References load_be(), and make_u64bit().

load_le() [1/5]

template<typename T>

T Botan::load_le ( const byte in[], size_t off )

inline

Load a little-endian word

Parameters

in	a pointer to some bytes
off	an offset into the array

Returns

off'th T of in, as a litte-endian value

Definition at line 116 of file loadstor.h.

   {
   in += off * sizeof(T);
   T out = 0;
   for(size_t i = 0; i != sizeof(T); ++i)
      out = (out << 8) | in[sizeof(T)-1-i];
   return out;
   }

References load_le().

Referenced by Botan::MD4::compress_n(), Botan::MD5::compress_n(), Botan::GOST_28147_89::decrypt_n(), Botan::MARS::decrypt_n(), Botan::RC2::decrypt_n(), Botan::Serpent::decrypt_n(), Botan::Skipjack::decrypt_n(), Botan::Twofish::decrypt_n(), Botan::GOST_28147_89::encrypt_n(), Botan::MARS::encrypt_n(), Botan::RC2::encrypt_n(), Botan::Serpent::encrypt_n(), Botan::Skipjack::encrypt_n(), Botan::Twofish::encrypt_n(), load_le(), load_le(), load_le(), load_le(), load_le(), Botan::SIMD_Scalar::load_le(), load_le< u16bit >(), load_le< u32bit >(), load_le< u64bit >(), and Botan::Salsa20::set_iv().

load_le() [2/5]

template<typename T>

void Botan::load_le ( const byte in[], T & x0, T & x1 )

inline

Load two little-endian words

Parameters

in	a pointer to some bytes
x0	where the first word will be written
x1	where the second word will be written

Definition at line 236 of file loadstor.h.

   {
   x0 = load_le<T>(in, 0);
   x1 = load_le<T>(in, 1);
   }

References load_le().

load_le() [3/5]

template<typename T>

void Botan::load_le ( const byte in[], T & x0, T & x1, T & x2, T & x3 )

inline

Load four little-endian words

Parameters

in	a pointer to some bytes
x0	where the first word will be written
x1	where the second word will be written
x2	where the third word will be written
x3	where the fourth word will be written

Definition at line 251 of file loadstor.h.

   {
   x0 = load_le<T>(in, 0);
   x1 = load_le<T>(in, 1);
   x2 = load_le<T>(in, 2);
   x3 = load_le<T>(in, 3);
   }

References load_le().

load_le() [4/5]

template<typename T>

void Botan::load_le ( const byte in[], T & x0, T & x1, T & x2, T & x3, T & x4, T & x5, T & x6, T & x7 )

inline

Load eight little-endian words

Parameters

in	a pointer to some bytes
x0	where the first word will be written
x1	where the second word will be written
x2	where the third word will be written
x3	where the fourth word will be written
x4	where the fifth word will be written
x5	where the sixth word will be written
x6	where the seventh word will be written
x7	where the eighth word will be written

Definition at line 273 of file loadstor.h.

   {
   x0 = load_le<T>(in, 0);
   x1 = load_le<T>(in, 1);
   x2 = load_le<T>(in, 2);
   x3 = load_le<T>(in, 3);
   x4 = load_le<T>(in, 4);
   x5 = load_le<T>(in, 5);
   x6 = load_le<T>(in, 6);
   x7 = load_le<T>(in, 7);
   }

References load_le().

load_le() [5/5]

template<typename T>

void Botan::load_le ( T out[], const byte in[], size_t count )

inline

Load a variable number of little-endian words

Parameters

out	the output array of words
in	the input array of bytes
count	how many words are in in

Definition at line 294 of file loadstor.h.

   {
#if defined(BOTAN_TARGET_CPU_HAS_KNOWN_ENDIANNESS)
   std::memcpy(out, in, sizeof(T)*count);
 
#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   const size_t blocks = count - (count % 4);
   const size_t left = count - blocks;
 
   for(size_t i = 0; i != blocks; i += 4)
      bswap_4(out + i);
 
   for(size_t i = 0; i != left; ++i)
      out[blocks+i] = reverse_bytes(out[blocks+i]);
#endif
 
#else
   for(size_t i = 0; i != count; ++i)
      out[i] = load_le<T>(in, i);
#endif
   }

References bswap_4(), load_le(), and reverse_bytes().

load_le< u16bit >()

template<>

u16bit Botan::load_le< u16bit > ( const byte in[], size_t off )

inline

Load a little-endian u16bit

Parameters

in	a pointer to some bytes
off	an offset into the array

Returns

off'th u16bit of in, as a little-endian value

Definition at line 149 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   return BOTAN_ENDIAN_N2L(*(reinterpret_cast<const u16bit*>(in) + off));
#else
   in += off * sizeof(u16bit);
   return make_u16bit(in[1], in[0]);
#endif
   }

References load_le(), and make_u16bit().

load_le< u32bit >()

template<>

u32bit Botan::load_le< u32bit > ( const byte in[], size_t off )

inline

Load a little-endian u32bit

Parameters

in	a pointer to some bytes
off	an offset into the array

Returns

off'th u32bit of in, as a little-endian value

Definition at line 183 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   return BOTAN_ENDIAN_N2L(*(reinterpret_cast<const u32bit*>(in) + off));
#else
   in += off * sizeof(u32bit);
   return make_u32bit(in[3], in[2], in[1], in[0]);
#endif
   }

References load_le(), and make_u32bit().

load_le< u64bit >()

template<>

u64bit Botan::load_le< u64bit > ( const byte in[], size_t off )

inline

Load a little-endian u64bit

Parameters

in	a pointer to some bytes
off	an offset into the array

Returns

off'th u64bit of in, as a little-endian value

Definition at line 218 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   return BOTAN_ENDIAN_N2L(*(reinterpret_cast<const u64bit*>(in) + off));
#else
   in += off * sizeof(u64bit);
   return make_u64bit(in[7], in[6], in[5], in[4],
                      in[3], in[2], in[1], in[0]);
#endif
   }

References load_le(), and make_u64bit().

lock_mem()

bool Botan::lock_mem	(	void *	addr,
		size_t	length )

Lock memory into RAM if possible

Parameters

addr	the start of the memory block
length	the length of the memory block in bytes

Returns

true if successful, false otherwise

Definition at line 31 of file mlock.cpp.

   {
#if defined(BOTAN_TARGET_OS_HAS_POSIX_MLOCK)
   return (::mlock(static_cast<char*>(ptr), bytes) == 0);
#elif defined(BOTAN_TARGET_OS_HAS_WIN32_VIRTUAL_LOCK)
   return (::VirtualLock(ptr, bytes) != 0);
#else
   return false;
#endif
   }

References lock_mem().

Referenced by has_mlock(), and lock_mem().

low_bit()

template<typename T>

size_t Botan::low_bit ( T n )

inline

Return the index of the lowest set bit T is an unsigned integer type

Parameters

n	an integer value

Returns

index of the lowest set bit in n

Definition at line 48 of file bit_ops.h.

   {
   for(size_t i = 0; i != 8*sizeof(T); ++i)
      if((n >> i) & 0x01)
         return (i + 1);
   return 0;
   }

References low_bit().

Referenced by low_bit().

low_zero_bits()

size_t BOTAN_DLL Botan::low_zero_bits

(

const BigInt &

x

)

Parameters

x	an integer

Returns

count of the zero bits in x, or, equivalently, the largest value of n such that 2^n divides x evently

Definition at line 142 of file numthry.cpp.

   {
   size_t low_zero = 0;
 
   if(n.is_positive() && n.is_nonzero())
      {
      for(size_t i = 0; i != n.size(); ++i)
         {
         word x = n[i];
 
         if(x)
            {
            low_zero += ctz(x);
            break;
            }
         else
            low_zero += BOTAN_MP_WORD_BITS;
         }
      }
 
   return low_zero;
   }

References ctz(), Botan::BigInt::is_nonzero(), Botan::BigInt::is_positive(), low_zero_bits(), and Botan::BigInt::size().

Referenced by gcd(), inverse_mod(), jacobi(), low_zero_bits(), and ressol().

make_cvc_cert()

EAC1_1_CVC BOTAN_DLL Botan::make_cvc_cert	(	PK_Signer &	signer,
		const MemoryRegion< byte > &	public_key,
		ASN1_Car const &	car,
		ASN1_Chr const &	chr,
		byte	holder_auth_templ,
		ASN1_Ced	ced,
		ASN1_Cex	cex,
		RandomNumberGenerator &	rng )

Create an arbitrary EAC 1.1 CVC. The desired key encoding must be set within the key (if applicable).

Parameters

signer	the signer used to sign the certificate
public_key	the DER encoded public key to appear in the certificate
car	the CAR of the certificate
chr	the CHR of the certificate
holder_auth_templ	the holder authorization value byte to appear in the CHAT of the certificate
ced	the CED to appear in the certificate
cex	the CEX to appear in the certificate
rng	a random number generator

Definition at line 98 of file cvc_cert.cpp.

   {
   OID chat_oid(OIDS::lookup("CertificateHolderAuthorizationTemplate"));
   MemoryVector<byte> enc_chat_val;
   enc_chat_val.push_back(holder_auth_templ);
 
   MemoryVector<byte> enc_cpi;
   enc_cpi.push_back(0x00);
   MemoryVector<byte> tbs = DER_Encoder()
      .encode(enc_cpi, OCTET_STRING, ASN1_Tag(41), APPLICATION) // cpi
      .encode(car)
      .raw_bytes(public_key)
      .encode(chr)
      .start_cons(ASN1_Tag(76), APPLICATION)
      .encode(chat_oid)
      .encode(enc_chat_val, OCTET_STRING, ASN1_Tag(19), APPLICATION)
      .end_cons()
      .encode(ced)
      .encode(cex)
      .get_contents();
 
   MemoryVector<byte> signed_cert =
      EAC1_1_CVC::make_signed(signer,
                              EAC1_1_CVC::build_cert_body(tbs),
                              rng);
 
   DataSource_Memory source(signed_cert);
   return EAC1_1_CVC(source);
   }

References APPLICATION, Botan::EAC1_1_gen_CVC< EAC1_1_CVC >::build_cert_body(), Botan::EAC1_1_CVC::EAC1_1_CVC(), Botan::DER_Encoder::encode(), Botan::DER_Encoder::end_cons(), Botan::DER_Encoder::get_contents(), Botan::OIDS::lookup(), make_cvc_cert(), Botan::EAC1_1_gen_CVC< EAC1_1_CVC >::make_signed(), OCTET_STRING, Botan::MemoryRegion< T >::push_back(), Botan::DER_Encoder::raw_bytes(), and Botan::DER_Encoder::start_cons().

Referenced by Botan::CVC_EAC::create_self_signed_cert(), Botan::DE_EAC::link_cvca(), make_cvc_cert(), and Botan::DE_EAC::sign_request().

make_private_key()

Private_Key * Botan::make_private_key	(	const AlgorithmIdentifier &	alg_id,
		const MemoryRegion< byte > &	key_bits,
		RandomNumberGenerator &	rng )

Definition at line 104 of file pk_algs.cpp.

   {
   const std::string alg_name = OIDS::lookup(alg_id.oid);
   if(alg_name == "")
      throw Decoding_Error("Unknown algorithm OID: " + alg_id.oid.as_string());
 
#if defined(BOTAN_HAS_RSA)
   if(alg_name == "RSA")
      return new RSA_PrivateKey(alg_id, key_bits, rng);
#endif
 
#if defined(BOTAN_HAS_RW)
   if(alg_name == "RW")
      return new RW_PrivateKey(alg_id, key_bits, rng);
#endif
 
#if defined(BOTAN_HAS_DSA)
   if(alg_name == "DSA")
      return new DSA_PrivateKey(alg_id, key_bits, rng);
#endif
 
#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
   if(alg_name == "DH")
      return new DH_PrivateKey(alg_id, key_bits, rng);
#endif
 
#if defined(BOTAN_HAS_NYBERG_RUEPPEL)
   if(alg_name == "NR")
      return new NR_PrivateKey(alg_id, key_bits, rng);
#endif
 
#if defined(BOTAN_HAS_ELGAMAL)
   if(alg_name == "ElGamal")
      return new ElGamal_PrivateKey(alg_id, key_bits, rng);
#endif
 
#if defined(BOTAN_HAS_ECDSA)
   if(alg_name == "ECDSA")
      return new ECDSA_PrivateKey(alg_id, key_bits);
#endif
 
#if defined(BOTAN_HAS_GOST_34_10_2001)
   if(alg_name == "GOST-34.10")
      return new GOST_3410_PrivateKey(alg_id, key_bits);
#endif
 
#if defined(BOTAN_HAS_ECDH)
   if(alg_name == "ECDH")
      return new ECDH_PrivateKey(alg_id, key_bits);
#endif
 
   return 0;
   }

References Botan::OID::as_string(), Botan::Decoding_Error::Decoding_Error(), Botan::DH_PrivateKey::DH_PrivateKey(), Botan::DSA_PrivateKey::DSA_PrivateKey(), Botan::ECDH_PrivateKey::ECDH_PrivateKey(), Botan::ECDSA_PrivateKey::ECDSA_PrivateKey(), Botan::ElGamal_PrivateKey::ElGamal_PrivateKey(), Botan::OIDS::lookup(), make_private_key(), Botan::NR_PrivateKey::NR_PrivateKey(), Botan::AlgorithmIdentifier::oid, Botan::RSA_PrivateKey::RSA_PrivateKey(), and Botan::RW_PrivateKey::RW_PrivateKey().

Referenced by Botan::PKCS8::load_key(), and make_private_key().

make_public_key()

Public_Key * Botan::make_public_key	(	const AlgorithmIdentifier &	alg_id,
		const MemoryRegion< byte > &	key_bits )

Definition at line 49 of file pk_algs.cpp.

   {
   const std::string alg_name = OIDS::lookup(alg_id.oid);
   if(alg_name == "")
      throw Decoding_Error("Unknown algorithm OID: " + alg_id.oid.as_string());
 
#if defined(BOTAN_HAS_RSA)
   if(alg_name == "RSA")
      return new RSA_PublicKey(alg_id, key_bits);
#endif
 
#if defined(BOTAN_HAS_RW)
   if(alg_name == "RW")
      return new RW_PublicKey(alg_id, key_bits);
#endif
 
#if defined(BOTAN_HAS_DSA)
   if(alg_name == "DSA")
      return new DSA_PublicKey(alg_id, key_bits);
#endif
 
#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
   if(alg_name == "DH")
      return new DH_PublicKey(alg_id, key_bits);
#endif
 
#if defined(BOTAN_HAS_NYBERG_RUEPPEL)
   if(alg_name == "NR")
      return new NR_PublicKey(alg_id, key_bits);
#endif
 
#if defined(BOTAN_HAS_ELGAMAL)
   if(alg_name == "ElGamal")
      return new ElGamal_PublicKey(alg_id, key_bits);
#endif
 
#if defined(BOTAN_HAS_ECDSA)
   if(alg_name == "ECDSA")
      return new ECDSA_PublicKey(alg_id, key_bits);
#endif
 
#if defined(BOTAN_HAS_GOST_34_10_2001)
   if(alg_name == "GOST-34.10")
      return new GOST_3410_PublicKey(alg_id, key_bits);
#endif
 
#if defined(BOTAN_HAS_ECDH)
   if(alg_name == "ECDH")
      return new ECDH_PublicKey(alg_id, key_bits);
#endif
 
   return 0;
   }

References Botan::OID::as_string(), Botan::Decoding_Error::Decoding_Error(), Botan::DH_PublicKey::DH_PublicKey(), Botan::DSA_PublicKey::DSA_PublicKey(), Botan::ECDH_PublicKey::ECDH_PublicKey(), Botan::ECDSA_PublicKey::ECDSA_PublicKey(), Botan::ElGamal_PublicKey::ElGamal_PublicKey(), Botan::OIDS::lookup(), make_public_key(), Botan::NR_PublicKey::NR_PublicKey(), Botan::AlgorithmIdentifier::oid, Botan::RSA_PublicKey::RSA_PublicKey(), and Botan::RW_PublicKey::RW_PublicKey().

Referenced by Botan::X509::load_key(), and make_public_key().

make_u16bit()

u16bit Botan::make_u16bit ( byte i0, byte i1 )

inline

Make a u16bit from two bytes

Parameters

i0	the first byte
i1	the second byte

Returns

i0 || i1

Definition at line 47 of file loadstor.h.

   {
   return ((static_cast<u16bit>(i0) << 8) | i1);
   }

References make_u16bit().

Referenced by Botan::Record_Reader::get_record(), Botan::TLS_Data_Reader::get_u16bit(), load_be< u16bit >(), load_le< u16bit >(), make_u16bit(), Botan::Client_Key_Exchange::pre_master_secret(), and Botan::RTSS_Share::reconstruct().

make_u32bit()

u32bit Botan::make_u32bit ( byte i0, byte i1, byte i2, byte i3 )

inline

Make a u32bit from four bytes

Parameters

i0	the first byte
i1	the second byte
i2	the third byte
i3	the fourth byte

Returns

i0 || i1 || i2 || i3

Definition at line 60 of file loadstor.h.

   {
   return ((static_cast<u32bit>(i0) << 24) |
           (static_cast<u32bit>(i1) << 16) |
           (static_cast<u32bit>(i2) <<  8) |
           (static_cast<u32bit>(i3)));
   }

References make_u32bit().

Referenced by load_be< u32bit >(), load_le< u32bit >(), and make_u32bit().

make_u64bit()

u64bit Botan::make_u64bit ( byte i0, byte i1, byte i2, byte i3, byte i4, byte i5, byte i6, byte i7 )

inline

Make a u32bit from eight bytes

Parameters

i0	the first byte
i1	the second byte
i2	the third byte
i3	the fourth byte
i4	the fifth byte
i5	the sixth byte
i6	the seventh byte
i7	the eighth byte

Returns

i0 || i1 || i2 || i3 || i4 || i5 || i6 || i7

Definition at line 80 of file loadstor.h.

    {
   return ((static_cast<u64bit>(i0) << 56) |
           (static_cast<u64bit>(i1) << 48) |
           (static_cast<u64bit>(i2) << 40) |
           (static_cast<u64bit>(i3) << 32) |
           (static_cast<u64bit>(i4) << 24) |
           (static_cast<u64bit>(i5) << 16) |
           (static_cast<u64bit>(i6) <<  8) |
           (static_cast<u64bit>(i7)));
    }

References make_u64bit().

Referenced by load_be< u64bit >(), load_le< u64bit >(), and make_u64bit().

max_keylength_of()

BOTAN_DLL size_t Botan::max_keylength_of

(

const std::string &

algo_spec

)

Find out the maximum key size of a certain symmetric algorithm.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the algorithm

Returns

maximum key length of the specified algorithm

Definition at line 86 of file lookup.cpp.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
 
   if(const BlockCipher* bc = af.prototype_block_cipher(name))
      return bc->key_spec().maximum_keylength();
 
   if(const StreamCipher* sc = af.prototype_stream_cipher(name))
      return sc->key_spec().maximum_keylength();
 
   if(const MessageAuthenticationCode* mac = af.prototype_mac(name))
      return mac->key_spec().maximum_keylength();
 
   throw Algorithm_Not_Found(name);
   }

References Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), global_state(), max_keylength_of(), Botan::Algorithm_Factory::prototype_block_cipher(), Botan::Algorithm_Factory::prototype_mac(), and Botan::Algorithm_Factory::prototype_stream_cipher().

Referenced by max_keylength_of().

min_keylength_of()

BOTAN_DLL size_t Botan::min_keylength_of

(

const std::string &

algo_spec

)

Find out the minimum key size of a certain symmetric algorithm.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the algorithm

Returns

minimum key length of the specified algorithm

Definition at line 67 of file lookup.cpp.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
 
   if(const BlockCipher* bc = af.prototype_block_cipher(name))
      return bc->key_spec().minimum_keylength();
 
   if(const StreamCipher* sc = af.prototype_stream_cipher(name))
      return sc->key_spec().minimum_keylength();
 
   if(const MessageAuthenticationCode* mac = af.prototype_mac(name))
      return mac->key_spec().minimum_keylength();
 
   throw Algorithm_Not_Found(name);
   }

References Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), global_state(), min_keylength_of(), Botan::Algorithm_Factory::prototype_block_cipher(), Botan::Algorithm_Factory::prototype_mac(), and Botan::Algorithm_Factory::prototype_stream_cipher().

Referenced by min_keylength_of().

mul_add()

BigInt BOTAN_DLL Botan::mul_add	(	const BigInt &	a,
		const BigInt &	b,
		const BigInt &	c )

Fused multiply-add

Parameters

a	an integer
b	an integer
c	an integer

Returns

(a*b)+c

Definition at line 33 of file mp_numth.cpp.

   {
   if(c.is_negative() || c.is_zero())
      throw Invalid_Argument("mul_add: Third argument must be > 0");
 
   BigInt::Sign sign = BigInt::Positive;
   if(a.sign() != b.sign())
      sign = BigInt::Negative;
 
   const size_t a_sw = a.sig_words();
   const size_t b_sw = b.sig_words();
   const size_t c_sw = c.sig_words();
 
   BigInt r(sign, std::max(a.size() + b.size(), c_sw) + 1);
   SecureVector<word> workspace(r.size());
 
   bigint_mul(r.get_reg(), r.size(), workspace,
              a.data(), a.size(), a_sw,
              b.data(), b.size(), b_sw);
   const size_t r_size = std::max(r.sig_words(), c_sw);
   bigint_add2(r.get_reg(), r_size, c.data(), c_sw);
   return r;
   }

References bigint_add2(), bigint_mul(), Botan::BigInt::data(), Botan::BigInt::get_reg(), Botan::BigInt::is_negative(), Botan::BigInt::is_zero(), mul_add(), Botan::BigInt::Negative, Botan::BigInt::Positive, Botan::BigInt::sig_words(), Botan::BigInt::sign(), and Botan::BigInt::size().

Referenced by mul_add(), Botan::DSA_Signature_Operation::sign(), Botan::ECDSA_Signature_Operation::sign(), and Botan::RW_Signature_Operation::sign().

multi_exponentiate()

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

Multiexponentiation

Parameters

p1	a point
z1	a scalar
p2	a point
z2	a scalar

Returns

(p1 * z1 + p2 * z2)

Definition at line 265 of file point_gfp.cpp.

   {
   const PointGFp p3 = p1 + p2;
 
   PointGFp H(p1.curve); // create as zero
   size_t bits_left = std::max(z1.bits(), z2.bits());
 
   std::vector<BigInt> ws(9);
 
   while(bits_left)
      {
      H.mult2(ws);
 
      const bool z1_b = z1.get_bit(bits_left - 1);
      const bool z2_b = z2.get_bit(bits_left - 1);
 
      if(z1_b == true && z2_b == true)
         H.add(p3, ws);
      else if(z1_b)
         H.add(p1, ws);
      else if(z2_b)
         H.add(p2, ws);
 
      --bits_left;
      }
 
   if(z1.is_negative() != z2.is_negative())
      H.negate();
 
   return H;
   }

Referenced by Botan::ECDSA_Verification_Operation::verify().

multimap_insert()

template<typename K, typename V>

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

Insert a key/value pair into a multimap

Definition at line 76 of file stl_util.h.

   {
#if defined(BOTAN_BUILD_COMPILER_IS_SUN_STUDIO)
   // Work around a strange bug in Sun Studio
   multimap.insert(std::make_pair<const K, V>(key, value));
#else
   multimap.insert(std::make_pair(key, value));
#endif
   }

References multimap_insert().

Referenced by Botan::Data_Store::add(), Botan::AlternativeName::add_attribute(), Botan::X509_DN::add_attribute(), Botan::AlternativeName::add_othername(), Botan::AlternativeName::contents(), Botan::X509_DN::contents(), Botan::X509_DN::get_attributes(), multimap_insert(), and Botan::Data_Store::search_with().

operator!=() [1/17]

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

Definition at line 84 of file alg_id.cpp.

   {
   return !(a1 == a2);
   }

References operator!=().

operator!=() [2/17]

bool Botan::operator!= ( const ASN1_EAC_String & lhs, const ASN1_EAC_String & rhs )

inline

Definition at line 235 of file eac_asn_obj.h.

   {
   return !(lhs == rhs);
   }

References operator!=().

operator!=() [3/17]

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

inline

Definition at line 531 of file bigint.h.

   { return (a.cmp(b) != 0); }

References Botan::BigInt::cmp(), and operator!=().

operator!=() [4/17]

BOTAN_DLL bool Botan::operator!=	(	const CRL_Entry &	,
		const CRL_Entry &	)

Test two CRL entries for inequality in at least one field.

Definition at line 55 of file crl_ent.cpp.

   {
   return !(a1 == a2);
   }

References operator!=().

operator!=() [5/17]

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

inline

Equality operator

Parameters

lhs	a curve
rhs	a curve

Returns

true iff lhs is not the same as rhs

Definition at line 142 of file curve_gfp.h.

   {
   return !(lhs == rhs);
   }

References operator!=().

operator!=() [6/17]

bool BOTAN_DLL Botan::operator!=	(	const EAC_Time &	t1,
		const EAC_Time &	t2 )

Definition at line 230 of file asn1_eac_tm.cpp.

   {
   return (t1.cmp(t2) != 0);
   }

References Botan::EAC_Time::cmp(), and operator!=().

operator!=() [7/17]

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

inline

Definition at line 132 of file ec_group.h.

   {
   return !(lhs == rhs);
   }

References operator!=().

operator!=() [8/17]

bool Botan::operator!= ( const ECDSA_Signature & lhs, const ECDSA_Signature & rhs )

inline

Definition at line 52 of file ecdsa_sig.h.

   {
   return !(lhs == rhs);
   }

References operator!=().

operator!=() [9/17]

BOTAN_DLL bool Botan::operator!=	(	const OctetString &	x,
		const OctetString &	y )

Compare two strings

Parameters

x	an octet string
y	an octet string

Returns

if x is not equal to y

Definition at line 106 of file symkey.cpp.

   {
   return !(s1 == s2);
   }

References operator!=().

Referenced by Botan::EAC1_1_ADO::EAC1_1_obj< EAC1_1_ADO >, operator!=(), operator!=(), operator!=(), operator!=(), operator!=(), operator!=(), operator!=(), operator!=(), operator!=(), operator!=(), operator!=(), operator!=(), operator!=(), operator!=(), operator!=(), and operator!=().

operator!=() [10/17]

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

Compare two OIDs.

Parameters

a	the first OID
b	the second OID

Returns

true if a is not equal to b

Definition at line 97 of file asn1_oid.cpp.

   {
   return !(a == b);
   }

References operator!=().

operator!=() [11/17]

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

inline

Definition at line 227 of file point_gfp.h.

   {
   return !(rhs == lhs);
   }

References operator!=().

operator!=() [12/17]

BOTAN_DLL bool Botan::operator!=	(	const X509_Certificate &	,
		const X509_Certificate &	)

Check two certificates for inequality

Returns

true if the arguments represent different certificates, false if they are binary identical

Definition at line 302 of file x509cert.cpp.

   {
   return !(cert1 == cert2);
   }

References operator!=().

operator!=() [13/17]

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

Definition at line 173 of file x509_dn.cpp.

   {
   return !(dn1 == dn2);
   }

References operator!=().

operator!=() [14/17]

bool Botan::operator!=	(	const X509_Time &	t1,
		const X509_Time &	t2 )

Definition at line 278 of file asn1_tm.cpp.

   { return (t1.cmp(t2) != 0); }

References Botan::X509_Time::cmp(), and operator!=().

operator!=() [15/17]

bool Botan::operator!= ( EAC1_1_ADO const & lhs, EAC1_1_ADO const & rhs )

inline

Definition at line 89 of file cvc_ado.h.

   {
   return (!(lhs == rhs));
   }

operator!=() [16/17]

bool Botan::operator!= ( EAC1_1_CVC const & lhs, EAC1_1_CVC const & rhs )

inline

Definition at line 79 of file cvc_cert.h.

   {
   return !(lhs == rhs);
   }

References operator!=().

operator!=() [17/17]

bool Botan::operator!= ( EAC1_1_Req const & lhs, EAC1_1_Req const & rhs )

inline

Definition at line 52 of file cvc_req.h.

   {
   return !(lhs == rhs);
   }

References operator!=().

operator%() [1/2]

BigInt BOTAN_DLL Botan::operator%	(	const BigInt &	n,
		const BigInt &	mod )

Definition at line 119 of file big_ops3.cpp.

   {
   if(mod.is_zero())
      throw BigInt::DivideByZero();
   if(mod.is_negative())
      throw Invalid_Argument("BigInt::operator%: modulus must be > 0");
   if(n.is_positive() && mod.is_positive() && n < mod)
      return n;
 
   BigInt q, r;
   divide(n, mod, q, r);
   return r;
   }

References divide(), Botan::BigInt::is_negative(), Botan::BigInt::is_positive(), Botan::BigInt::is_zero(), and operator%().

Referenced by operator%(), and operator%().

operator%() [2/2]

word BOTAN_DLL Botan::operator%	(	const BigInt &	n,
		word	mod )

Definition at line 136 of file big_ops3.cpp.

   {
   if(mod == 0)
      throw BigInt::DivideByZero();
   if(power_of_2(mod))
      return (n.word_at(0) & (mod - 1));
 
   word remainder = 0;
 
   for(size_t j = n.sig_words(); j > 0; --j)
      remainder = bigint_modop(remainder, n.word_at(j-1), mod);
 
   if(remainder && n.sign() == BigInt::Negative)
      return mod - remainder;
   return remainder;
   }

References bigint_modop(), Botan::BigInt::Negative, operator%(), power_of_2(), Botan::BigInt::sig_words(), Botan::BigInt::sign(), and Botan::BigInt::word_at().

operator*() [1/3]

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

Multiplication Operator

Parameters

scalar	the scalar value
point	the point value

Returns

scalar*point on the curve

Definition at line 298 of file point_gfp.cpp.

   {
   const CurveGFp& curve = point.get_curve();
 
   if(scalar.is_zero())
      return PointGFp(curve); // zero point
 
   std::vector<BigInt> ws(9);
 
   if(scalar.abs() <= 2) // special cases for small values
      {
      byte value = scalar.abs().byte_at(0);
 
      PointGFp result = point;
 
      if(value == 2)
         result.mult2(ws);
 
      if(scalar.is_negative())
         result.negate();
 
      return result;
      }
 
   const size_t scalar_bits = scalar.bits();
 
#if 0
 
   PointGFp x1 = PointGFp(curve);
   PointGFp x2 = point;
 
   size_t bits_left = scalar_bits;
 
   // Montgomery Ladder
   while(bits_left)
      {
      const bool bit_set = scalar.get_bit(bits_left - 1);
 
      if(bit_set)
         {
         x1.add(x2, ws);
         x2.mult2(ws);
         }
      else
         {
         x2.add(x1, ws);
         x1.mult2(ws);
         }
 
      --bits_left;
      }
 
   if(scalar.is_negative())
      x1.negate();
 
   return x1;
 
#else
   const size_t window_size = 4;
 
   std::vector<PointGFp> Ps(1 << window_size);
   Ps[0] = PointGFp(curve);
   Ps[1] = point;
 
   for(size_t i = 2; i != Ps.size(); ++i)
      {
      Ps[i] = Ps[i-1];
      Ps[i].add(point, ws);
      }
 
   PointGFp H(curve); // create as zero
   size_t bits_left = scalar_bits;
 
   while(bits_left >= window_size)
      {
      for(size_t i = 0; i != window_size; ++i)
         H.mult2(ws);
 
      const u32bit nibble = scalar.get_substring(bits_left - window_size,
                                                 window_size);
 
      H.add(Ps[nibble], ws);
 
      bits_left -= window_size;
      }
 
   while(bits_left)
      {
      H.mult2(ws);
      if(scalar.get_bit(bits_left-1))
         H.add(point, ws);
 
      --bits_left;
      }
 
   if(scalar.is_negative())
      H.negate();
 
   return H;
#endif
   }

operator*() [2/3]

BigInt BOTAN_DLL Botan::operator*	(	const BigInt &	x,
		const BigInt &	y )

Definition at line 83 of file big_ops3.cpp.

   {
   const size_t x_sw = x.sig_words(), y_sw = y.sig_words();
 
   BigInt z(BigInt::Positive, x.size() + y.size());
 
   if(x_sw == 1 && y_sw)
      bigint_linmul3(z.get_reg(), y.data(), y_sw, x.word_at(0));
   else if(y_sw == 1 && x_sw)
      bigint_linmul3(z.get_reg(), x.data(), x_sw, y.word_at(0));
   else if(x_sw && y_sw)
      {
      SecureVector<word> workspace(z.size());
      bigint_mul(z.get_reg(), z.size(), workspace,
                 x.data(), x.size(), x_sw,
                 y.data(), y.size(), y_sw);
      }
 
   if(x_sw && y_sw && x.sign() != y.sign())
      z.flip_sign();
   return z;
   }

References bigint_linmul3(), bigint_mul(), Botan::BigInt::data(), Botan::BigInt::flip_sign(), Botan::BigInt::get_reg(), operator*(), Botan::BigInt::Positive, Botan::BigInt::sig_words(), Botan::BigInt::sign(), Botan::BigInt::size(), and Botan::BigInt::word_at().

Referenced by operator*(), and operator*().

operator*() [3/3]

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

inline

Definition at line 250 of file point_gfp.h.

   {
   return scalar * point;
   }

References operator*().

operator+() [1/4]

BigInt BOTAN_DLL Botan::operator+	(	const BigInt &	x,
		const BigInt &	y )

Definition at line 19 of file big_ops3.cpp.

   {
   const size_t x_sw = x.sig_words(), y_sw = y.sig_words();
 
   BigInt z(x.sign(), std::max(x_sw, y_sw) + 1);
 
   if((x.sign() == y.sign()))
      bigint_add3(z.get_reg(), x.data(), x_sw, y.data(), y_sw);
   else
      {
      s32bit relative_size = bigint_cmp(x.data(), x_sw, y.data(), y_sw);
 
      if(relative_size < 0)
         {
         bigint_sub3(z.get_reg(), y.data(), y_sw, x.data(), x_sw);
         z.set_sign(y.sign());
         }
      else if(relative_size == 0)
         z.set_sign(BigInt::Positive);
      else if(relative_size > 0)
         bigint_sub3(z.get_reg(), x.data(), x_sw, y.data(), y_sw);
      }
 
   return z;
   }

References bigint_add3(), bigint_cmp(), bigint_sub3(), Botan::BigInt::data(), Botan::BigInt::get_reg(), operator+(), Botan::BigInt::Positive, Botan::BigInt::set_sign(), Botan::BigInt::sig_words(), and Botan::BigInt::sign().

operator+() [2/4]

BOTAN_DLL OctetString Botan::operator+	(	const OctetString &	x,
		const OctetString &	y )

Concatenate two strings

Parameters

x	an octet string
y	an octet string

Returns

x concatenated with y

Definition at line 114 of file symkey.cpp.

   {
   SecureVector<byte> out;
   out += k1.bits_of();
   out += k2.bits_of();
   return OctetString(out);
   }

References Botan::OctetString::bits_of(), Botan::OctetString::OctetString(), and operator+().

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

operator+() [3/4]

OID Botan::operator+	(	const OID &	oid,
		u32bit	new_comp )

Append another component onto the OID.

Parameters

oid	the OID to add the new component to
new_comp	the new component to add

Definition at line 87 of file asn1_oid.cpp.

   {
   OID new_oid(oid);
   new_oid += component;
   return new_oid;
   }

References operator+().

operator+() [4/4]

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

inline

Definition at line 238 of file point_gfp.h.

   {
   PointGFp tmp(lhs);
   return tmp += rhs;
   }

References operator+().

operator+=() [1/4]

template<typename T>

MemoryRegion< T > & Botan::operator+=	(	MemoryRegion< T > &	out,
		const MemoryRegion< T > &	in )

Definition at line 386 of file secmem.h.

   {
   const size_t copy_offset = out.size();
   out.resize(out.size() + in.size());
   copy_mem(&out[copy_offset], &in[0], in.size());
   return out;
   }

References copy_mem(), operator+=(), Botan::MemoryRegion< T >::resize(), and Botan::MemoryRegion< T >::size().

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

operator+=() [2/4]

template<typename T, typename L>

MemoryRegion< T > & Botan::operator+=	(	MemoryRegion< T > &	out,
		const std::pair< const T *, L > &	in )

Definition at line 404 of file secmem.h.

   {
   const size_t copy_offset = out.size();
   out.resize(out.size() + in.second);
   copy_mem(&out[copy_offset], in.first, in.second);
   return out;
   }

References copy_mem(), operator+=(), Botan::MemoryRegion< T >::resize(), and Botan::MemoryRegion< T >::size().

operator+=() [3/4]

template<typename T, typename L>

MemoryRegion< T > & Botan::operator+=	(	MemoryRegion< T > &	out,
		const std::pair< T *, L > &	in )

Definition at line 414 of file secmem.h.

   {
   const size_t copy_offset = out.size();
   out.resize(out.size() + in.second);
   copy_mem(&out[copy_offset], in.first, in.second);
   return out;
   }

References copy_mem(), operator+=(), Botan::MemoryRegion< T >::resize(), and Botan::MemoryRegion< T >::size().

operator+=() [4/4]

template<typename T>

MemoryRegion< T > & Botan::operator+=	(	MemoryRegion< T > &	out,
		T	in )

Definition at line 396 of file secmem.h.

   {
   out.push_back(in);
   return out;
   }

References operator+=(), and Botan::MemoryRegion< T >::push_back().

operator-() [1/3]

BigInt BOTAN_DLL Botan::operator-	(	const BigInt &	x,
		const BigInt &	y )

Definition at line 48 of file big_ops3.cpp.

   {
   const size_t x_sw = x.sig_words(), y_sw = y.sig_words();
 
   s32bit relative_size = bigint_cmp(x.data(), x_sw, y.data(), y_sw);
 
   BigInt z(BigInt::Positive, std::max(x_sw, y_sw) + 1);
 
   if(relative_size < 0)
      {
      if(x.sign() == y.sign())
         bigint_sub3(z.get_reg(), y.data(), y_sw, x.data(), x_sw);
      else
         bigint_add3(z.get_reg(), x.data(), x_sw, y.data(), y_sw);
      z.set_sign(y.reverse_sign());
      }
   else if(relative_size == 0)
      {
      if(x.sign() != y.sign())
         bigint_shl2(z.get_reg(), x.data(), x_sw, 0, 1);
      }
   else if(relative_size > 0)
      {
      if(x.sign() == y.sign())
         bigint_sub3(z.get_reg(), x.data(), x_sw, y.data(), y_sw);
      else
         bigint_add3(z.get_reg(), x.data(), x_sw, y.data(), y_sw);
      z.set_sign(x.sign());
      }
   return z;
   }

References bigint_add3(), bigint_cmp(), bigint_shl2(), bigint_sub3(), Botan::BigInt::data(), Botan::BigInt::get_reg(), operator-(), Botan::BigInt::Positive, Botan::BigInt::reverse_sign(), Botan::BigInt::set_sign(), Botan::BigInt::sig_words(), and Botan::BigInt::sign().

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

operator-() [2/3]

PointGFp Botan::operator- ( const PointGFp & lhs )

inline

Definition at line 233 of file point_gfp.h.

   {
   return PointGFp(lhs).negate();
   }

References operator-(), and Botan::PointGFp::PointGFp().

operator-() [3/3]

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

inline

Definition at line 244 of file point_gfp.h.

   {
   PointGFp tmp(lhs);
   return tmp -= rhs;
   }

References operator-().

operator/()

BigInt BOTAN_DLL Botan::operator/	(	const BigInt &	x,
		const BigInt &	y )

Definition at line 109 of file big_ops3.cpp.

   {
   BigInt q, r;
   divide(x, y, q, r);
   return q;
   }

References divide(), and operator/().

Referenced by operator/().

operator<() [1/5]

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

inline

Definition at line 537 of file bigint.h.

   { return (a.cmp(b) < 0); }

References Botan::BigInt::cmp(), and operator<().

operator<() [2/5]

bool BOTAN_DLL Botan::operator<	(	const EAC_Time &	t1,
		const EAC_Time &	t2 )

Definition at line 250 of file asn1_eac_tm.cpp.

   {
   return (t1.cmp(t2) < 0);
   }

References Botan::EAC_Time::cmp(), and operator<().

operator<() [3/5]

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

Compare two OIDs.

Parameters

a	the first OID
b	the second OID

Returns

true if a is lexicographically smaller than b

Definition at line 105 of file asn1_oid.cpp.

   {
   std::vector<u32bit> oid1 = a.get_id();
   std::vector<u32bit> oid2 = b.get_id();
 
   if(oid1.size() < oid2.size())
      return true;
   if(oid1.size() > oid2.size())
      return false;
   for(size_t i = 0; i != oid1.size(); ++i)
      {
      if(oid1[i] < oid2[i])
         return true;
      if(oid1[i] > oid2[i])
         return false;
      }
   return false;
   }

References Botan::OID::get_id(), and operator<().

operator<() [4/5]

bool BOTAN_DLL Botan::operator<	(	const X509_DN &	dn1,
		const X509_DN &	dn2 )

Definition at line 181 of file x509_dn.cpp.

   {
   typedef std::multimap<OID, std::string>::const_iterator rdn_iter;
 
   std::multimap<OID, std::string> attr1 = dn1.get_attributes();
   std::multimap<OID, std::string> attr2 = dn2.get_attributes();
 
   if(attr1.size() < attr2.size()) return true;
   if(attr1.size() > attr2.size()) return false;
 
   for(rdn_iter p1 = attr1.begin(); p1 != attr1.end(); ++p1)
      {
      std::multimap<OID, std::string>::const_iterator p2;
      p2 = attr2.find(p1->first);
      if(p2 == attr2.end())       return false;
      if(p1->second > p2->second) return false;
      if(p1->second < p2->second) return true;
      }
   return false;
   }

References Botan::X509_DN::get_attributes(), and operator<().

operator<() [5/5]

bool Botan::operator<	(	const X509_Time &	t1,
		const X509_Time &	t2 )

Definition at line 286 of file asn1_tm.cpp.

   { return (t1.cmp(t2) < 0); }

References Botan::X509_Time::cmp(), and operator<().

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

operator<<() [1/4]

BigInt BOTAN_DLL Botan::operator<<	(	const BigInt &	x,
		size_t	shift )

Definition at line 156 of file big_ops3.cpp.

   {
   if(shift == 0)
      return x;
 
   const size_t shift_words = shift / MP_WORD_BITS,
                shift_bits  = shift % MP_WORD_BITS;
 
   const size_t x_sw = x.sig_words();
 
   BigInt y(x.sign(), x_sw + shift_words + (shift_bits ? 1 : 0));
   bigint_shl2(y.get_reg(), x.data(), x_sw, shift_words, shift_bits);
   return y;
   }

References bigint_shl2(), Botan::BigInt::data(), Botan::BigInt::get_reg(), MP_WORD_BITS, operator<<(), Botan::BigInt::sig_words(), and Botan::BigInt::sign().

operator<<() [2/4]

int BOTAN_DLL Botan::operator<<	(	int	out,
		Pipe &	pipe )

Stream output operator; dumps the results from pipe's default message to the output stream.

Parameters

out	file descriptor for an open output stream
pipe	the pipe

Definition at line 17 of file fd_unix.cpp.

   {
   SecureVector<byte> buffer(DEFAULT_BUFFERSIZE);
   while(pipe.remaining())
      {
      size_t got = pipe.read(&buffer[0], buffer.size());
      size_t position = 0;
      while(got)
         {
         ssize_t ret = write(fd, &buffer[position], got);
         if(ret == -1)
            throw Stream_IO_Error("Pipe output operator (unixfd) has failed");
         position += ret;
         got -= ret;
         }
      }
   return fd;
   }

References operator<<(), Botan::Pipe::read(), Botan::Pipe::remaining(), Botan::MemoryRegion< T >::size(), and Botan::Stream_IO_Error::Stream_IO_Error().

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

operator<<() [3/4]

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

Stream output operator; dumps the results from pipe's default message to the output stream.

Parameters

out	an output stream
pipe	the pipe

Definition at line 16 of file pipe_io.cpp.

   {
   SecureVector<byte> buffer(DEFAULT_BUFFERSIZE);
   while(stream.good() && pipe.remaining())
      {
      size_t got = pipe.read(&buffer[0], buffer.size());
      stream.write(reinterpret_cast<const char*>(&buffer[0]), got);
      }
   if(!stream.good())
      throw Stream_IO_Error("Pipe output operator (iostream) has failed");
   return stream;
   }

References operator<<(), Botan::Pipe::read(), Botan::Pipe::remaining(), Botan::MemoryRegion< T >::size(), and Botan::Stream_IO_Error::Stream_IO_Error().

operator<<() [4/4]

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

Definition at line 16 of file big_io.cpp.

   {
   BigInt::Base base = BigInt::Decimal;
   if(stream.flags() & std::ios::hex)
      base = BigInt::Hexadecimal;
   else if(stream.flags() & std::ios::oct)
      base = BigInt::Octal;
 
   if(n == 0)
      stream.write("0", 1);
   else
      {
      if(n < 0)
         stream.write("-", 1);
      SecureVector<byte> buffer = BigInt::encode(n, base);
      size_t skip = 0;
      while(buffer[skip] == '0' && skip < buffer.size())
         ++skip;
      stream.write(reinterpret_cast<const char*>(&buffer[0]) + skip,
                   buffer.size() - skip);
      }
   if(!stream.good())
      throw Stream_IO_Error("BigInt output operator has failed");
   return stream;
   }

References Botan::BigInt::Decimal, Botan::BigInt::encode(), Botan::BigInt::Hexadecimal, Botan::BigInt::Octal, operator<<(), Botan::MemoryRegion< T >::size(), and Botan::Stream_IO_Error::Stream_IO_Error().

operator<=() [1/3]

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

inline

Definition at line 533 of file bigint.h.

   { return (a.cmp(b) <= 0); }

References Botan::BigInt::cmp(), and operator<=().

operator<=() [2/3]

bool BOTAN_DLL Botan::operator<=	(	const EAC_Time &	t1,
		const EAC_Time &	t2 )

Definition at line 235 of file asn1_eac_tm.cpp.

   {
   return (t1.cmp(t2) <= 0);
   }

References Botan::EAC_Time::cmp(), and operator<=().

operator<=() [3/3]

bool Botan::operator<=	(	const X509_Time &	t1,
		const X509_Time &	t2 )

Definition at line 281 of file asn1_tm.cpp.

   { return (t1.cmp(t2) <= 0); }

References Botan::X509_Time::cmp(), and operator<=().

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

operator==() [1/8]

bool BOTAN_DLL Botan::operator==	(	const AlgorithmIdentifier &	a1,
		const AlgorithmIdentifier &	a2 )

Definition at line 72 of file alg_id.cpp.

   {
   if(a1.oid != a2.oid)
      return false;
   if(a1.parameters != a2.parameters)
      return false;
   return true;
   }

References Botan::AlgorithmIdentifier::oid, operator==(), and Botan::AlgorithmIdentifier::parameters.

operator==() [2/8]

bool BOTAN_DLL Botan::operator==	(	const ASN1_EAC_String &	lhs,
		const ASN1_EAC_String &	rhs )

Definition at line 114 of file asn1_eac_str.cpp.

   {
   return (lhs.iso_8859() == rhs.iso_8859());
   }

References Botan::ASN1_EAC_String::iso_8859(), and operator==().

operator==() [3/8]

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

inline

Definition at line 529 of file bigint.h.

   { return (a.cmp(b) == 0); }

References Botan::BigInt::cmp(), and operator==().

operator==() [4/8]

BOTAN_DLL bool Botan::operator==	(	const CRL_Entry &	,
		const CRL_Entry &	)

Test two CRL entries for equality in all fields.

Definition at line 41 of file crl_ent.cpp.

   {
   if(a1.serial_number() != a2.serial_number())
      return false;
   if(a1.expire_time() != a2.expire_time())
      return false;
   if(a1.reason_code() != a2.reason_code())
      return false;
   return true;
   }

References Botan::CRL_Entry::expire_time(), operator==(), Botan::CRL_Entry::reason_code(), and Botan::CRL_Entry::serial_number().

operator==() [5/8]

bool BOTAN_DLL Botan::operator==	(	const EAC_Time &	t1,
		const EAC_Time &	t2 )

Definition at line 225 of file asn1_eac_tm.cpp.

   {
   return (t1.cmp(t2) == 0);
   }

References Botan::EAC_Time::cmp(), and operator==().

operator==() [6/8]

BOTAN_DLL bool Botan::operator==	(	const OctetString &	x,
		const OctetString &	y )

Compare two strings

Parameters

x	an octet string
y	an octet string

Returns

if x is equal to y

Definition at line 98 of file symkey.cpp.

   {
   return (s1.bits_of() == s2.bits_of());
   }

References Botan::OctetString::bits_of(), and operator==().

Referenced by operator==(), operator==(), operator==(), operator==(), operator==(), operator==(), operator==(), and operator==().

operator==() [7/8]

bool BOTAN_DLL Botan::operator==	(	const X509_DN &	dn1,
		const X509_DN &	dn2 )

Definition at line 143 of file x509_dn.cpp.

   {
   typedef std::multimap<OID, std::string>::const_iterator rdn_iter;
 
   std::multimap<OID, std::string> attr1 = dn1.get_attributes();
   std::multimap<OID, std::string> attr2 = dn2.get_attributes();
 
   if(attr1.size() != attr2.size()) return false;
 
   rdn_iter p1 = attr1.begin();
   rdn_iter p2 = attr2.begin();
 
   while(true)
      {
      if(p1 == attr1.end() && p2 == attr2.end())
         break;
      if(p1 == attr1.end())      return false;
      if(p2 == attr2.end())      return false;
      if(p1->first != p2->first) return false;
      if(!x500_name_cmp(p1->second, p2->second))
         return false;
      ++p1;
      ++p2;
      }
   return true;
   }

References Botan::X509_DN::get_attributes(), operator==(), and x500_name_cmp().

operator==() [8/8]

bool Botan::operator==	(	const X509_Time &	t1,
		const X509_Time &	t2 )

Definition at line 276 of file asn1_tm.cpp.

   { return (t1.cmp(t2) == 0); }

References Botan::X509_Time::cmp(), and operator==().

operator>() [1/3]

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

inline

Definition at line 539 of file bigint.h.

   { return (a.cmp(b) > 0); }

References Botan::BigInt::cmp(), and operator>().

operator>() [2/3]

bool BOTAN_DLL Botan::operator>	(	const EAC_Time &	t1,
		const EAC_Time &	t2 )

Definition at line 245 of file asn1_eac_tm.cpp.

   {
   return (t1.cmp(t2) > 0);
   }

References Botan::EAC_Time::cmp(), and operator>().

operator>() [3/3]

bool Botan::operator>	(	const X509_Time &	t1,
		const X509_Time &	t2 )

Definition at line 288 of file asn1_tm.cpp.

   { return (t1.cmp(t2) > 0); }

References Botan::X509_Time::cmp(), and operator>().

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

operator>=() [1/3]

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

inline

Definition at line 535 of file bigint.h.

   { return (a.cmp(b) >= 0); }

References Botan::BigInt::cmp(), and operator>=().

operator>=() [2/3]

bool BOTAN_DLL Botan::operator>=	(	const EAC_Time &	t1,
		const EAC_Time &	t2 )

Definition at line 240 of file asn1_eac_tm.cpp.

   {
   return (t1.cmp(t2) >= 0);
   }

References Botan::EAC_Time::cmp(), and operator>=().

operator>=() [3/3]

bool Botan::operator>=	(	const X509_Time &	t1,
		const X509_Time &	t2 )

Definition at line 283 of file asn1_tm.cpp.

   { return (t1.cmp(t2) >= 0); }

References Botan::X509_Time::cmp(), and operator>=().

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

operator>>() [1/4]

BigInt BOTAN_DLL Botan::operator>>	(	const BigInt &	x,
		size_t	shift )

Definition at line 174 of file big_ops3.cpp.

   {
   if(shift == 0)
      return x;
   if(x.bits() <= shift)
      return 0;
 
   const size_t shift_words = shift / MP_WORD_BITS,
                shift_bits  = shift % MP_WORD_BITS,
                x_sw = x.sig_words();
 
   BigInt y(x.sign(), x_sw - shift_words);
   bigint_shr2(y.get_reg(), x.data(), x_sw, shift_words, shift_bits);
   return y;
   }

References bigint_shr2(), Botan::BigInt::bits(), Botan::BigInt::data(), Botan::BigInt::get_reg(), MP_WORD_BITS, operator>>(), Botan::BigInt::sig_words(), and Botan::BigInt::sign().

operator>>() [2/4]

int BOTAN_DLL Botan::operator>>	(	int	in,
		Pipe &	pipe )

File descriptor input operator; dumps the remaining bytes of input to the (assumed open) pipe message.

Parameters

in	file descriptor for an open input stream
pipe	the pipe

Definition at line 39 of file fd_unix.cpp.

   {
   SecureVector<byte> buffer(DEFAULT_BUFFERSIZE);
   while(true)
      {
      ssize_t ret = read(fd, &buffer[0], buffer.size());
      if(ret == 0) break;
      if(ret == -1)
         throw Stream_IO_Error("Pipe input operator (unixfd) has failed");
      pipe.write(&buffer[0], ret);
      }
   return fd;
   }

References operator>>(), Botan::MemoryRegion< T >::size(), Botan::Stream_IO_Error::Stream_IO_Error(), and Botan::Pipe::write().

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

operator>>() [3/4]

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

Stream input operator; dumps the remaining bytes of input to the (assumed open) pipe message.

Parameters

in	the input stream
pipe	the pipe

Definition at line 32 of file pipe_io.cpp.

   {
   SecureVector<byte> buffer(DEFAULT_BUFFERSIZE);
   while(stream.good())
      {
      stream.read(reinterpret_cast<char*>(&buffer[0]), buffer.size());
      pipe.write(&buffer[0], stream.gcount());
      }
   if(stream.bad() || (stream.fail() && !stream.eof()))
      throw Stream_IO_Error("Pipe input operator (iostream) has failed");
   return stream;
   }

References operator>>(), Botan::MemoryRegion< T >::size(), Botan::Stream_IO_Error::Stream_IO_Error(), and Botan::Pipe::write().

operator>>() [4/4]

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

Definition at line 45 of file big_io.cpp.

   {
   std::string str;
   std::getline(stream, str);
   if(stream.bad() || (stream.fail() && !stream.eof()))
      throw Stream_IO_Error("BigInt input operator has failed");
   n = BigInt(str);
   return stream;
   }

References Botan::BigInt::BigInt(), operator>>(), and Botan::Stream_IO_Error::Stream_IO_Error().

operator^()

BOTAN_DLL OctetString Botan::operator^	(	const OctetString &	x,
		const OctetString &	y )

XOR two strings

Parameters

x	an octet string
y	an octet string

Returns

x XORed with y

Definition at line 125 of file symkey.cpp.

   {
   SecureVector<byte> ret(std::max(k1.length(), k2.length()));
   ret.copy(k1.begin(), k1.length());
   xor_buf(ret, k2.begin(), k2.length());
   return OctetString(ret);
   }

References Botan::OctetString::begin(), Botan::MemoryRegion< T >::copy(), Botan::OctetString::length(), Botan::OctetString::OctetString(), operator^(), and xor_buf().

Referenced by operator^().

OS2ECP() [1/2]

PointGFp BOTAN_DLL Botan::OS2ECP	(	const byte	data[],
		size_t	data_len,
		const CurveGFp &	curve )

Definition at line 562 of file point_gfp.cpp.

   {
   if(data_len <= 1)
      return PointGFp(curve); // return zero
 
   const byte pc = data[0];
 
   BigInt x, y;
 
   if(pc == 2 || pc == 3)
      {
      //compressed form
      x = BigInt::decode(&data[1], data_len - 1);
 
      const bool y_mod_2 = ((pc & 0x01) == 1);
      y = decompress_point(y_mod_2, x, curve);
      }
   else if(pc == 4)
      {
      const size_t l = (data_len - 1) / 2;
 
      // uncompressed form
      x = BigInt::decode(&data[1], l);
      y = BigInt::decode(&data[l+1], l);
      }
   else if(pc == 6 || pc == 7)
      {
      const size_t l = (data_len - 1) / 2;
 
      // hybrid form
      x = BigInt::decode(&data[1], l);
      y = BigInt::decode(&data[l+1], l);
 
      const bool y_mod_2 = ((pc & 0x01) == 1);
 
      if(decompress_point(y_mod_2, x, curve) != y)
         throw Illegal_Point("OS2ECP: Decoding error in hybrid format");
      }
   else
      throw Invalid_Argument("OS2ECP: Unknown format type");
 
   PointGFp result(curve, x, y);
 
   if(!result.on_the_curve())
      throw Illegal_Point("OS2ECP: Decoded point was not on the curve");
 
   return result;
   }

References Botan::BigInt::decode(), Botan::Illegal_Point::Illegal_Point(), Botan::PointGFp::on_the_curve(), OS2ECP(), and Botan::PointGFp::PointGFp().

Referenced by Botan::ECDH_KA_Operation::agree(), Botan::EC_Group::EC_Group(), Botan::EC_PublicKey::EC_PublicKey(), OS2ECP(), and OS2ECP().

OS2ECP() [2/2]

PointGFp Botan::OS2ECP ( const MemoryRegion< byte > & data, const CurveGFp & curve )

inline

Definition at line 261 of file point_gfp.h.

   { return OS2ECP(&data[0], data.size(), curve); }

References OS2ECP(), and Botan::MemoryRegion< T >::size().

output_length_of()

BOTAN_DLL size_t Botan::output_length_of

(

const std::string &

algo_spec

)

Find out the output length of a certain symmetric algorithm.

Deprecated

Call algorithm_factory() directly

Parameters

algo_spec

the name of the algorithm

Returns

output length of the specified algorithm

Definition at line 51 of file lookup.cpp.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
 
   if(const HashFunction* hash = af.prototype_hash_function(name))
      return hash->output_length();
 
   if(const MessageAuthenticationCode* mac = af.prototype_mac(name))
      return mac->output_length();
 
   throw Algorithm_Not_Found(name);
   }

References Botan::Library_State::algorithm_factory(), Botan::Algorithm_Not_Found::Algorithm_Not_Found(), global_state(), output_length_of(), Botan::Algorithm_Factory::prototype_hash_function(), and Botan::Algorithm_Factory::prototype_mac().

Referenced by output_length_of(), and Botan::SessionKeys::SessionKeys().

parse_algorithm_name()

BOTAN_DLL std::vector< std::string > Botan::parse_algorithm_name

(

const std::string &

scan_name

)

Parse a SCAN-style algorithm name

Parameters

scan_name

the name

Returns

the name components

Definition at line 96 of file parsing.cpp.

   {
   if(namex.find('(') == std::string::npos &&
      namex.find(')') == std::string::npos)
      return std::vector<std::string>(1, namex);
 
   std::string name = namex, substring;
   std::vector<std::string> elems;
   size_t level = 0;
 
   elems.push_back(name.substr(0, name.find('(')));
   name = name.substr(name.find('('));
 
   for(std::string::const_iterator i = name.begin(); i != name.end(); ++i)
      {
      char c = *i;
 
      if(c == '(')
         ++level;
      if(c == ')')
         {
         if(level == 1 && i == name.end() - 1)
            {
            if(elems.size() == 1)
               elems.push_back(substring.substr(1));
            else
               elems.push_back(substring);
            return elems;
            }
 
         if(level == 0 || (level == 1 && i != name.end() - 1))
            throw Invalid_Algorithm_Name(namex);
         --level;
         }
 
      if(c == ',' && level == 1)
         {
         if(elems.size() == 1)
            elems.push_back(substring.substr(1));
         else
            elems.push_back(substring);
         substring.clear();
         }
      else
         substring += c;
      }
 
   if(substring != "")
      throw Invalid_Algorithm_Name(namex);
 
   return elems;
   }

References Botan::Invalid_Algorithm_Name::Invalid_Algorithm_Name(), and parse_algorithm_name().

Referenced by get_cipher_mode(), Botan::X509_Object::hash_used_for_signature(), and parse_algorithm_name().

parse_asn1_oid()

BOTAN_DLL std::vector< u32bit > Botan::parse_asn1_oid

(

const std::string &

oid

)

Parse an ASN.1 OID

Parameters

oid	the OID in string form

Returns

OID components

Definition at line 180 of file parsing.cpp.

   {
   std::string substring;
   std::vector<u32bit> oid_elems;
 
   for(std::string::const_iterator i = oid.begin(); i != oid.end(); ++i)
      {
      char c = *i;
 
      if(c == '.')
         {
         if(substring == "")
            throw Invalid_OID(oid);
         oid_elems.push_back(to_u32bit(substring));
         substring.clear();
         }
      else
         substring += c;
      }
 
   if(substring == "")
      throw Invalid_OID(oid);
   oid_elems.push_back(to_u32bit(substring));
 
   if(oid_elems.size() < 2)
      throw Invalid_OID(oid);
 
   return oid_elems;
   }

References Botan::Invalid_OID::Invalid_OID(), parse_asn1_oid(), and to_u32bit().

Referenced by Botan::OID::OID(), and parse_asn1_oid().

passes_self_tests()

BOTAN_DLL bool Botan::passes_self_tests

(

Algorithm_Factory &

af

)

Run a set of self tests on some basic algorithms like AES and SHA-1

Parameters

af	an algorithm factory

Returns

false if a failure occured, otherwise true

Definition at line 209 of file selftest.cpp.

   {
   try
      {
      confirm_startup_self_tests(af);
      }
   catch(Self_Test_Failure)
      {
      return false;
      }
 
   return true;
   }

References confirm_startup_self_tests(), and passes_self_tests().

Referenced by passes_self_tests().

PGP_decode() [1/2]

BOTAN_DLL SecureVector< byte > Botan::PGP_decode	(	DataSource &	source,
		std::string &	label )

Parameters

source	the input source
label	is set to the human-readable label

Returns

decoded output as raw binary

Definition at line 189 of file openpgp.cpp.

   {
   std::map<std::string, std::string> ignored;
   return PGP_decode(source, label, ignored);
   }

References PGP_decode().

PGP_decode() [2/2]

BOTAN_DLL SecureVector< byte > Botan::PGP_decode	(	DataSource &	source,
		std::string &	label,
		std::map< std::string, std::string > &	headers )

Parameters

source	the input source
label	is set to the human-readable label
headers	is set to any headers

Returns

decoded output as raw binary

Definition at line 70 of file openpgp.cpp.

   {
   const size_t RANDOM_CHAR_LIMIT = 5;
 
   const std::string PGP_HEADER1 = "-----BEGIN PGP ";
   const std::string PGP_HEADER2 = "-----";
   size_t position = 0;
 
   while(position != PGP_HEADER1.length())
      {
      byte b;
      if(!source.read_byte(b))
         throw Decoding_Error("PGP: No PGP header found");
      if(b == PGP_HEADER1[position])
         ++position;
      else if(position >= RANDOM_CHAR_LIMIT)
         throw Decoding_Error("PGP: Malformed PGP header");
      else
         position = 0;
      }
   position = 0;
   while(position != PGP_HEADER2.length())
      {
      byte b;
      if(!source.read_byte(b))
         throw Decoding_Error("PGP: No PGP header found");
      if(b == PGP_HEADER2[position])
         ++position;
      else if(position)
         throw Decoding_Error("PGP: Malformed PGP header");
 
      if(position == 0)
         label += static_cast<char>(b);
      }
 
   headers.clear();
   bool end_of_headers = false;
   while(!end_of_headers)
      {
      std::string this_header;
      byte b = 0;
      while(b != '\n')
         {
         if(!source.read_byte(b))
            throw Decoding_Error("PGP: Bad armor header");
         if(b != '\n')
            this_header += static_cast<char>(b);
         }
 
      end_of_headers = true;
      for(size_t j = 0; j != this_header.length(); ++j)
         if(!Charset::is_space(this_header[j]))
            end_of_headers = false;
 
      if(!end_of_headers)
         {
         std::string::size_type pos = this_header.find(": ");
         if(pos == std::string::npos)
            throw Decoding_Error("OpenPGP: Bad headers");
 
         std::string key = this_header.substr(0, pos);
         std::string value = this_header.substr(pos + 2, std::string::npos);
         headers[key] = value;
         }
      }
 
   Pipe base64(new Base64_Decoder,
               new Fork(0,
                        new Chain(new Hash_Filter(new CRC24),
                                  new Base64_Encoder)
                  )
      );
   base64.start_msg();
 
   const std::string PGP_TRAILER = "-----END PGP " + label + "-----";
   position = 0;
   bool newline_seen = 0;
   std::string crc;
   while(position != PGP_TRAILER.length())
      {
      byte b;
      if(!source.read_byte(b))
         throw Decoding_Error("PGP: No PGP trailer found");
      if(b == PGP_TRAILER[position])
         ++position;
      else if(position)
         throw Decoding_Error("PGP: Malformed PGP trailer");
 
      if(b == '=' && newline_seen)
         {
         while(b != '\n')
            {
            if(!source.read_byte(b))
               throw Decoding_Error("PGP: Bad CRC tail");
            if(b != '\n')
               crc += static_cast<char>(b);
            }
         }
      else if(b == '\n')
         newline_seen = true;
      else if(position == 0)
         {
         base64.write(b);
         newline_seen = false;
         }
      }
   base64.end_msg();
 
   if(crc != "" && crc != base64.read_all_as_string(1))
      throw Decoding_Error("PGP: Corrupt CRC");
 
   return base64.read_all();
   }

References Botan::Chain::Chain(), Botan::MemoryRegion< T >::clear(), Botan::Decoding_Error::Decoding_Error(), Botan::Pipe::end_msg(), Botan::Fork::Fork(), Botan::Hash_Filter::Hash_Filter(), Botan::Charset::is_space(), PGP_decode(), Botan::Pipe::read_all(), Botan::Pipe::read_all_as_string(), Botan::DataSource::read_byte(), Botan::Pipe::start_msg(), and Botan::Pipe::write().

Referenced by PGP_decode(), and PGP_decode().

PGP_encode() [1/2]

BOTAN_DLL std::string Botan::PGP_encode	(	const byte	input[],
		size_t	length,
		const std::string &	label,
		const std::map< std::string, std::string > &	headers )

Parameters

input	the input data
length	length of input in bytes
label	the human-readable label
headers	a set of key/value pairs included in the header

Definition at line 19 of file openpgp.cpp.

   {
   const std::string PGP_HEADER = "-----BEGIN PGP " + label + "-----\n";
   const std::string PGP_TRAILER = "-----END PGP " + label + "-----\n";
   const size_t PGP_WIDTH = 64;
 
   std::string pgp_encoded = PGP_HEADER;
 
   if(headers.find("Version") != headers.end())
      pgp_encoded += "Version: " + headers.find("Version")->second + '\n';
 
   std::map<std::string, std::string>::const_iterator i = headers.begin();
   while(i != headers.end())
      {
      if(i->first != "Version")
         pgp_encoded += i->first + ": " + i->second + '\n';
      ++i;
      }
   pgp_encoded += '\n';
 
   Pipe pipe(new Fork(
                new Base64_Encoder(true, PGP_WIDTH),
                new Chain(new Hash_Filter(new CRC24), new Base64_Encoder)
                )
      );
 
   pipe.process_msg(input, length);
 
   pgp_encoded += pipe.read_all_as_string(0);
   pgp_encoded += '=' + pipe.read_all_as_string(1) + '\n';
   pgp_encoded += PGP_TRAILER;
 
   return pgp_encoded;
   }

References Botan::Base64_Encoder::Base64_Encoder(), Botan::Chain::Chain(), Botan::Fork::Fork(), Botan::Hash_Filter::Hash_Filter(), PGP_encode(), Botan::Pipe::process_msg(), and Botan::Pipe::read_all_as_string().

Referenced by PGP_encode(), and PGP_encode().

PGP_encode() [2/2]

BOTAN_DLL std::string Botan::PGP_encode	(	const byte	input[],
		size_t	length,
		const std::string &	label )

Parameters

input	the input data
length	length of input in bytes
label	the human-readable label

Definition at line 60 of file openpgp.cpp.

   {
   std::map<std::string, std::string> empty;
   return PGP_encode(input, length, type, empty);
   }

References PGP_encode().

pkcs_hash_id()

BOTAN_DLL MemoryVector< byte > Botan::pkcs_hash_id

(

const std::string &

hash_name

)

Return the PKCS #1 hash identifier

See also

RFC 3447 section 9.2

Parameters

hash_name

the name of the hash function

Returns

byte sequence identifying the hash

Exceptions

Invalid_Argument

if the hash has no known PKCS #1 hash id

Definition at line 60 of file hash_id.cpp.

   {
   // Special case for SSL/TLS RSA signatures
   if(name == "Parallel(MD5,SHA-160)")
      return MemoryVector<byte>();
 
   if(name == "MD2")
      return MemoryVector<byte>(MD2_PKCS_ID, sizeof(MD2_PKCS_ID));
   if(name == "MD5")
      return MemoryVector<byte>(MD5_PKCS_ID, sizeof(MD5_PKCS_ID));
   if(name == "RIPEMD-128")
      return MemoryVector<byte>(RIPEMD_128_PKCS_ID, sizeof(RIPEMD_128_PKCS_ID));
   if(name == "RIPEMD-160")
      return MemoryVector<byte>(RIPEMD_160_PKCS_ID, sizeof(RIPEMD_160_PKCS_ID));
   if(name == "SHA-160")
      return MemoryVector<byte>(SHA_160_PKCS_ID, sizeof(SHA_160_PKCS_ID));
   if(name == "SHA-224")
      return MemoryVector<byte>(SHA_224_PKCS_ID, sizeof(SHA_224_PKCS_ID));
   if(name == "SHA-256")
      return MemoryVector<byte>(SHA_256_PKCS_ID, sizeof(SHA_256_PKCS_ID));
   if(name == "SHA-384")
      return MemoryVector<byte>(SHA_384_PKCS_ID, sizeof(SHA_384_PKCS_ID));
   if(name == "SHA-512")
      return MemoryVector<byte>(SHA_512_PKCS_ID, sizeof(SHA_512_PKCS_ID));
   if(name == "Tiger(24,3)")
      return MemoryVector<byte>(TIGER_PKCS_ID, sizeof(TIGER_PKCS_ID));
 
   throw Invalid_Argument("No PKCS #1 identifier for " + name);
   }

References pkcs_hash_id().

Referenced by Botan::EMSA3::EMSA3(), and pkcs_hash_id().

power_mod()

BigInt BOTAN_DLL Botan::power_mod	(	const BigInt &	b,
		const BigInt &	x,
		const BigInt &	m )

Modular exponentation

Parameters

b	an integer base
x	a positive exponent
m	a positive modulus

Returns

(b^x) % m

Definition at line 366 of file numthry.cpp.

   {
   Power_Mod pow_mod(mod);
   pow_mod.set_base(base);
   pow_mod.set_exponent(exp);
   return pow_mod.execute();
   }

References Botan::Power_Mod::execute(), power_mod(), Botan::Power_Mod::set_base(), and Botan::Power_Mod::set_exponent().

Referenced by Botan::DL_Scheme_PrivateKey::check_key(), Botan::DH_PrivateKey::DH_PrivateKey(), Botan::DH_PrivateKey::DH_PrivateKey(), Botan::DSA_PrivateKey::DSA_PrivateKey(), Botan::DSA_PrivateKey::DSA_PrivateKey(), Botan::ElGamal_PrivateKey::ElGamal_PrivateKey(), Botan::ElGamal_PrivateKey::ElGamal_PrivateKey(), generate_srp6_verifier(), Botan::NR_PrivateKey::NR_PrivateKey(), Botan::NR_PrivateKey::NR_PrivateKey(), power_mod(), ressol(), Botan::RW_Signature_Operation::sign(), srp6_client_agree(), Botan::SRP6_Server_Session::step1(), and Botan::SRP6_Server_Session::step2().

power_of_2()

template<typename T>

bool Botan::power_of_2 ( T arg )

inline

Power of 2 test. T should be an unsigned integer type

Parameters

arg	an integer value

Returns

true iff arg is 2^n for some n > 0

Definition at line 21 of file bit_ops.h.

   {
   return ((arg != 0 && arg != 1) && ((arg & (arg-1)) == 0));
   }

References power_of_2().

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

prefetch_readonly()

template<typename T>

void Botan::prefetch_readonly ( const T * addr, size_t length )

inline

Definition at line 16 of file prefetch.h.

   {
#if defined(__GNUG__)
   const size_t Ts_per_cache_line = CPUID::cache_line_size() / sizeof(T);
 
   for(size_t i = 0; i <= length; i += Ts_per_cache_line)
      __builtin_prefetch(addr + i, 0);
#endif
   }

References Botan::CPUID::cache_line_size(), and prefetch_readonly().

Referenced by prefetch_readonly().

prefetch_readwrite()

template<typename T>

void Botan::prefetch_readwrite ( const T * addr, size_t length )

inline

Definition at line 27 of file prefetch.h.

   {
#if defined(__GNUG__)
   const size_t Ts_per_cache_line = CPUID::cache_line_size() / sizeof(T);
 
   for(size_t i = 0; i <= length; i += Ts_per_cache_line)
      __builtin_prefetch(addr + i, 1);
#endif
   }

References Botan::CPUID::cache_line_size(), and prefetch_readwrite().

Referenced by prefetch_readwrite().

primality_test()

bool BOTAN_DLL Botan::primality_test	(	const BigInt &	n,
		RandomNumberGenerator &	rng,
		size_t	level = 1 )

Primality Testing

Parameters

n	a positive integer to test for primality
rng	a random number generator
level	how hard to test

Returns

true if all primality tests passed, otherwise false

Definition at line 377 of file numthry.cpp.

   {
   const size_t PREF_NONCE_BITS = 128;
 
   if(n == 2)
      return true;
   if(n <= 1 || n.is_even())
      return false;
 
   // Fast path testing for small numbers (<= 65521)
   if(n <= PRIMES[PRIME_TABLE_SIZE-1])
      {
      const word num = n.word_at(0);
 
      for(size_t i = 0; PRIMES[i]; ++i)
         {
         if(num == PRIMES[i])
            return true;
         if(num < PRIMES[i])
            return false;
         }
 
      return false;
      }
 
   if(level > 2)
      level = 2;
 
   const size_t NONCE_BITS = std::min(n.bits() - 2, PREF_NONCE_BITS);
 
   MillerRabin_Test mr(n);
 
   if(mr.is_witness(2))
      return false;
 
   const size_t tests = miller_rabin_test_iterations(n.bits(), level);
 
   for(size_t i = 0; i != tests; ++i)
      {
      BigInt nonce;
      while(nonce < 2 || nonce >= (n-1))
         nonce.randomize(rng, NONCE_BITS);
 
      if(mr.is_witness(nonce))
         return false;
      }
 
   return true;
   }

References Botan::BigInt::bits(), Botan::BigInt::is_even(), primality_test(), PRIME_TABLE_SIZE, PRIMES, Botan::BigInt::randomize(), and Botan::BigInt::word_at().

Referenced by check_prime(), primality_test(), quick_check_prime(), and verify_prime().

quick_check_prime()

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

inline

Quickly check for primality

Parameters

n	a positive integer to test for primality
rng	a random number generator

Returns

true if all primality tests passed, otherwise false

Definition at line 134 of file numthry.h.

   { return primality_test(n, rng, 0); }

References primality_test(), and quick_check_prime().

Referenced by quick_check_prime().

random_prime()

BigInt BOTAN_DLL Botan::random_prime	(	RandomNumberGenerator &	rng,
		size_t	bits,
		const BigInt &	coprime = 1,
		size_t	equiv = 1,
		size_t	equiv_mod = 2 )

Randomly generate a prime

Parameters

rng	a random number generator
bits	how large the resulting prime should be in bits
coprime	a positive integer the result should be coprime to
equiv	a non-negative number that the result should be equivalent to modulo equiv_mod
equiv_mod	the modulus equiv should be checked against

Returns

random prime with the specified criteria

Definition at line 17 of file make_prm.cpp.

   {
   if(bits <= 1)
      throw Invalid_Argument("random_prime: Can't make a prime of " +
                             to_string(bits) + " bits");
   else if(bits == 2)
      return ((rng.next_byte() % 2) ? 2 : 3);
   else if(bits == 3)
      return ((rng.next_byte() % 2) ? 5 : 7);
   else if(bits == 4)
      return ((rng.next_byte() % 2) ? 11 : 13);
 
   if(coprime <= 0)
      throw Invalid_Argument("random_prime: coprime must be > 0");
   if(modulo % 2 == 1 || modulo == 0)
      throw Invalid_Argument("random_prime: Invalid modulo value");
   if(equiv >= modulo || equiv % 2 == 0)
      throw Invalid_Argument("random_prime: equiv must be < modulo, and odd");
 
   while(true)
      {
      BigInt p(rng, bits);
 
      // Force lowest and two top bits on
      p.set_bit(bits - 1);
      p.set_bit(bits - 2);
      p.set_bit(0);
 
      if(p % modulo != equiv)
         p += (modulo - p % modulo) + equiv;
 
      const size_t sieve_size = std::min(bits / 2, PRIME_TABLE_SIZE);
      SecureVector<size_t> sieve(sieve_size);
 
      for(size_t j = 0; j != sieve.size(); ++j)
         sieve[j] = p % PRIMES[j];
 
      size_t counter = 0;
      while(true)
         {
         if(counter == 4096 || p.bits() > bits)
            break;
 
         bool passes_sieve = true;
         ++counter;
         p += modulo;
 
         if(p.bits() > bits)
            break;
 
         for(size_t j = 0; j != sieve.size(); ++j)
            {
            sieve[j] = (sieve[j] + modulo) % PRIMES[j];
            if(sieve[j] == 0)
               passes_sieve = false;
            }
 
         if(!passes_sieve || gcd(p - 1, coprime) != 1)
            continue;
         if(check_prime(p, rng))
            return p;
         }
      }
   }

References Botan::BigInt::bits(), check_prime(), gcd(), Botan::RandomNumberGenerator::next_byte(), PRIME_TABLE_SIZE, PRIMES, random_prime(), Botan::BigInt::set_bit(), Botan::MemoryRegion< T >::size(), and to_string().

Referenced by Botan::DL_Group::DL_Group(), random_prime(), random_safe_prime(), Botan::RSA_PrivateKey::RSA_PrivateKey(), and Botan::RW_PrivateKey::RW_PrivateKey().

random_safe_prime()

BigInt BOTAN_DLL Botan::random_safe_prime	(	RandomNumberGenerator &	rng,
		size_t	bits )

Return a 'safe' prime, of the form p=2*q+1 with q prime

Parameters

rng	a random number generator
bits	is how long the resulting prime should be

Returns

prime randomly chosen from safe primes of length bits

Definition at line 87 of file make_prm.cpp.

   {
   if(bits <= 64)
      throw Invalid_Argument("random_safe_prime: Can't make a prime of " +
                             to_string(bits) + " bits");
 
   BigInt p;
   do
      p = (random_prime(rng, bits - 1) << 1) + 1;
   while(!check_prime(p, rng));
   return p;
   }

References check_prime(), random_prime(), random_safe_prime(), and to_string().

Referenced by Botan::DL_Group::DL_Group(), and random_safe_prime().

ressol()

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

Compute the square root of x modulo a prime using the Shanks-Tonnelli algorithm

Parameters

x	the input
p	the prime

Returns

y such that (y*y)p == x, or -1 if no such integer

Definition at line 17 of file ressol.cpp.

   {
   if(a < 0)
      throw Invalid_Argument("ressol(): a to solve for must be positive");
   if(p <= 1)
      throw Invalid_Argument("ressol(): prime must be > 1");
 
   if(a == 0)
      return 0;
   if(p == 2)
      return a;
 
   if(jacobi(a, p) != 1) // not a quadratic residue
      return -BigInt(1);
 
   if(p % 4 == 3)
      return power_mod(a, ((p+1) >> 2), p);
 
   size_t s = low_zero_bits(p - 1);
   BigInt q = p >> s;
 
   q -= 1;
   q >>= 1;
 
   Modular_Reducer mod_p(p);
 
   BigInt r = power_mod(a, q, p);
   BigInt n = mod_p.multiply(a, mod_p.square(r));
   r = mod_p.multiply(r, a);
 
   if(n == 1)
      return r;
 
   // find random non quadratic residue z
   BigInt z = 2;
   while(jacobi(z, p) == 1) // while z quadratic residue
      ++z;
 
   BigInt c = power_mod(z, (q << 1) + 1, p);
 
   while(n > 1)
      {
      q = n;
 
      size_t i = 0;
      while(q != 1)
         {
         q = mod_p.square(q);
         ++i;
 
         if(i >= s)
            return -BigInt(1);
         }
 
      c = power_mod(c, BigInt(BigInt::Power2, s-i-1), p);
      r = mod_p.multiply(r, c);
      c = mod_p.square(c);
      n = mod_p.multiply(n, c);
      s = i;
      }
 
   return r;
   }

References Botan::BigInt::BigInt(), jacobi(), low_zero_bits(), Botan::Modular_Reducer::multiply(), Botan::BigInt::Power2, power_mod(), ressol(), and Botan::Modular_Reducer::square().

Referenced by ressol().

retrieve_block_cipher()

const BlockCipher * Botan::retrieve_block_cipher ( const std::string & algo_spec )

inline

Retrieve an object prototype from the global factory

Parameters

algo_spec

an algorithm name

Returns

constant prototype object (use clone to create usable object), library retains ownership

Definition at line 29 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return af.prototype_block_cipher(algo_spec);
   }

References Botan::Library_State::algorithm_factory(), global_state(), Botan::Algorithm_Factory::prototype_block_cipher(), and retrieve_block_cipher().

Referenced by retrieve_block_cipher().

retrieve_hash()

const HashFunction * Botan::retrieve_hash ( const std::string & algo_spec )

inline

Retrieve an object prototype from the global factory

Parameters

algo_spec

an algorithm name

Returns

constant prototype object (use clone to create usable object), library retains ownership

Definition at line 55 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return af.prototype_hash_function(algo_spec);
   }

References Botan::Library_State::algorithm_factory(), global_state(), Botan::Algorithm_Factory::prototype_hash_function(), and retrieve_hash().

Referenced by choose_sig_format(), and retrieve_hash().

retrieve_mac()

const MessageAuthenticationCode * Botan::retrieve_mac ( const std::string & algo_spec )

inline

Retrieve an object prototype from the global factory

Parameters

algo_spec

an algorithm name

Returns

constant prototype object (use clone to create usable object), library retains ownership

Definition at line 68 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return af.prototype_mac(algo_spec);
   }

References Botan::Library_State::algorithm_factory(), global_state(), Botan::Algorithm_Factory::prototype_mac(), and retrieve_mac().

Referenced by retrieve_mac().

retrieve_stream_cipher()

const StreamCipher * Botan::retrieve_stream_cipher ( const std::string & algo_spec )

inline

Retrieve an object prototype from the global factory

Parameters

algo_spec

an algorithm name

Returns

constant prototype object (use clone to create usable object), library retains ownership

Definition at line 42 of file lookup.h.

   {
   Algorithm_Factory& af = global_state().algorithm_factory();
   return af.prototype_stream_cipher(algo_spec);
   }

References Botan::Library_State::algorithm_factory(), global_state(), Botan::Algorithm_Factory::prototype_stream_cipher(), and retrieve_stream_cipher().

Referenced by retrieve_stream_cipher().

reverse_bytes() [1/3]

u16bit Botan::reverse_bytes ( u16bit val )

inline

Swap a 16 bit integer

Definition at line 24 of file bswap.h.

   {
   return rotate_left(val, 8);
   }

References reverse_bytes(), and rotate_left().

Referenced by Botan::SIMD_Scalar::bswap(), bswap_4(), load_be(), load_le(), reverse_bytes(), reverse_bytes(), and reverse_bytes().

reverse_bytes() [2/3]

u32bit Botan::reverse_bytes ( u32bit val )

inline

Swap a 32 bit integer

Definition at line 32 of file bswap.h.

   {
#if BOTAN_GCC_VERSION >= 430 && !defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
   /*
   GCC intrinsic added in 4.3, works for a number of CPUs
 
   However avoid under ARM, as it branches to a function in libgcc
   instead of generating inline asm, so slower even than the generic
   rotate version below.
   */
   return __builtin_bswap32(val);
 
#elif BOTAN_USE_GCC_INLINE_ASM && defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
 
   // GCC-style inline assembly for x86 or x86-64
   asm("bswapl %0" : "=r" (val) : "0" (val));
   return val;
 
#elif BOTAN_USE_GCC_INLINE_ASM && defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
 
   asm ("eor r3, %1, %1, ror #16\n\t"
        "bic r3, r3, #0x00FF0000\n\t"
        "mov %0, %1, ror #8\n\t"
        "eor %0, %0, r3, lsr #8"
        : "=r" (val)
        : "0" (val)
        : "r3", "cc");
 
   return val;
 
#elif defined(_MSC_VER) && defined(BOTAN_TARGET_ARCH_IS_X86_32)
 
   // Visual C++ inline asm for 32-bit x86, by Yves Jerschow
   __asm mov eax, val;
   __asm bswap eax;
 
#else
 
   // Generic implementation
   return (rotate_right(val, 8) & 0xFF00FF00) |
          (rotate_left (val, 8) & 0x00FF00FF);
 
#endif
   }

References reverse_bytes(), rotate_left(), and rotate_right().

reverse_bytes() [3/3]

u64bit Botan::reverse_bytes ( u64bit val )

inline

Swap a 64 bit integer

Definition at line 80 of file bswap.h.

   {
#if BOTAN_GCC_VERSION >= 430
 
   // GCC intrinsic added in 4.3, works for a number of CPUs
   return __builtin_bswap64(val);
 
#elif BOTAN_USE_GCC_INLINE_ASM && defined(BOTAN_TARGET_ARCH_IS_X86_64)
   // GCC-style inline assembly for x86-64
   asm("bswapq %0" : "=r" (val) : "0" (val));
   return val;
 
#else
   /* Generic implementation. Defined in terms of 32-bit bswap so any
    * optimizations in that version can help here (particularly
    * useful for 32-bit x86).
    */
 
   u32bit hi = static_cast<u32bit>(val >> 32);
   u32bit lo = static_cast<u32bit>(val);
 
   hi = reverse_bytes(hi);
   lo = reverse_bytes(lo);
 
   return (static_cast<u64bit>(lo) << 32) | hi;
#endif
   }

References reverse_bytes().

rfc3394_keyunwrap()

SecureVector< byte > BOTAN_DLL Botan::rfc3394_keyunwrap	(	const MemoryRegion< byte > &	key,
		const SymmetricKey &	kek,
		Algorithm_Factory &	af )

Decrypt a key under a key encryption key using the algorithm described in RFC 3394

Parameters

key	the encrypted key to decrypt
kek	the key encryption key
af	an algorithm factory

Returns

key decrypted under kek

Definition at line 77 of file rfc3394.cpp.

   {
   if(key.size() < 16 || key.size() % 8 != 0)
      throw std::invalid_argument("Bad input key size for NIST key unwrap");
 
   std::auto_ptr<BlockCipher> aes(make_aes(kek.length(), af));
   aes->set_key(kek);
 
   const size_t n = (key.size() - 8) / 8;
 
   SecureVector<byte> R(n * 8);
   SecureVector<byte> A(16);
 
   for(size_t i = 0; i != 8; ++i)
      A[i] = key[i];
 
   copy_mem(&R[0], key.begin() + 8, key.size() - 8);
 
   for(size_t j = 0; j <= 5; ++j)
      {
      for(size_t i = n; i != 0; --i)
         {
         const u32bit t = (5 - j) * n + i;
 
         byte t_buf[4] = { 0 };
         store_be(t, t_buf);
 
         xor_buf(&A[4], &t_buf[0], 4);
 
         copy_mem(&A[8], &R[8*(i-1)], 8);
 
         aes->decrypt(&A[0]);
 
         copy_mem(&R[8*(i-1)], &A[8], 8);
         }
      }
 
   if(load_be<u64bit>(&A[0], 0) != 0xA6A6A6A6A6A6A6A6)
      throw Integrity_Failure("NIST key unwrap failed");
 
   return R;
   }

References Botan::MemoryRegion< T >::begin(), copy_mem(), Botan::Integrity_Failure::Integrity_Failure(), Botan::OctetString::length(), load_be(), rfc3394_keyunwrap(), Botan::MemoryRegion< T >::size(), store_be(), and xor_buf().

Referenced by rfc3394_keyunwrap().

rfc3394_keywrap()

SecureVector< byte > BOTAN_DLL Botan::rfc3394_keywrap	(	const MemoryRegion< byte > &	key,
		const SymmetricKey &	kek,
		Algorithm_Factory &	af )

Encrypt a key under a key encryption key using the algorithm described in RFC 3394

Parameters

key	the plaintext key to encrypt
kek	the key encryption key
af	an algorithm factory

Returns

key encrypted under kek

Definition at line 35 of file rfc3394.cpp.

   {
   if(key.size() % 8 != 0)
      throw std::invalid_argument("Bad input key size for NIST key wrap");
 
   std::auto_ptr<BlockCipher> aes(make_aes(kek.length(), af));
   aes->set_key(kek);
 
   const size_t n = key.size() / 8;
 
   SecureVector<byte> R((n + 1) * 8);
   SecureVector<byte> A(16);
 
   for(size_t i = 0; i != 8; ++i)
      A[i] = 0xA6;
 
   copy_mem(&R[8], key.begin(), key.size());
 
   for(size_t j = 0; j <= 5; ++j)
      {
      for(size_t i = 1; i <= n; ++i)
         {
         const u32bit t = (n * j) + i;
 
         copy_mem(&A[8], &R[8*i], 8);
 
         aes->encrypt(&A[0]);
         copy_mem(&R[8*i], &A[8], 8);
 
         byte t_buf[4] = { 0 };
         store_be(t, t_buf);
         xor_buf(&A[4], &t_buf[0], 4);
         }
      }
 
   copy_mem(&R[0], &A[0], 8);
 
   return R;
   }

References Botan::MemoryRegion< T >::begin(), copy_mem(), Botan::OctetString::length(), rfc3394_keywrap(), Botan::MemoryRegion< T >::size(), store_be(), and xor_buf().

Referenced by rfc3394_keywrap().

rotate_left()

template<typename T>

T Botan::rotate_left ( T input, size_t rot )

inline

Bit rotation left

Parameters

input	the input word
rot	the number of bits to rotate

Returns

input rotated left by rot bits

Definition at line 21 of file rotate.h.

   {
   if(rot == 0)
      return input;
   return static_cast<T>((input << rot) | (input >> (8*sizeof(T)-rot)));;
   }

References rotate_left().

Referenced by Botan::SHA_160::compress_n(), Botan::DES::decrypt_n(), Botan::KASUMI::decrypt_n(), Botan::Noekeon::decrypt_n(), Botan::TripleDES::decrypt_n(), Botan::Twofish::decrypt_n(), Botan::DES::encrypt_n(), Botan::KASUMI::encrypt_n(), Botan::Noekeon::encrypt_n(), Botan::RC2::encrypt_n(), Botan::TripleDES::encrypt_n(), Botan::Twofish::encrypt_n(), Botan::HAS_160_F::F1(), Botan::RIPEMD_128_F::F1(), Botan::HAS_160_F::F2(), Botan::RIPEMD_128_F::F2(), Botan::HAS_160_F::F3(), Botan::RIPEMD_128_F::F3(), Botan::HAS_160_F::F4(), Botan::RIPEMD_128_F::F4(), Botan::GOST_28147_89::GOST_28147_89(), reverse_bytes(), reverse_bytes(), rotate_left(), and Botan::SIMD_Scalar::rotate_left().

rotate_right()

template<typename T>

T Botan::rotate_right ( T input, size_t rot )

inline

Bit rotation right

Parameters

input	the input word
rot	the number of bits to rotate

Returns

input rotated right by rot bits

Definition at line 34 of file rotate.h.

   {
   if(rot == 0)
      return input;
   return static_cast<T>((input >> rot) | (input << (8*sizeof(T)-rot)));
   }

References rotate_right().

Referenced by Botan::Noekeon::decrypt_n(), Botan::RC2::decrypt_n(), Botan::Twofish::decrypt_n(), Botan::Noekeon::encrypt_n(), Botan::Twofish::encrypt_n(), reverse_bytes(), rotate_right(), and Botan::SIMD_Scalar::rotate_right().

round_down()

template<typename T>

T Botan::round_down ( T n, T align_to )

inline

Round down

Parameters

n	an integer
align_to	the alignment boundary

Returns

n rounded down to a multiple of align_to

Definition at line 36 of file rounding.h.

   {
   return (n - (n % align_to));
   }

References round_down().

Referenced by round_down(), and Botan::Buffered_Filter::write().

round_up()

template<typename T>

T Botan::round_up ( T n, T align_to )

inline

Round up

Parameters

n	an integer
align_to	the alignment boundary

Returns

n rounded up to a multiple of align_to

Definition at line 22 of file rounding.h.

   {
   if(n % align_to || n == 0)
      n += align_to - (n % align_to);
   return n;
   }

References round_up().

Referenced by Botan::Pooling_Allocator::allocate(), base64_decode(), base64_encode(), Botan::BigInt::BigInt(), Botan::BigInt::BigInt(), Botan::BigInt::binary_decode(), Botan::Pooling_Allocator::deallocate(), Botan::BigInt::grow_reg(), Botan::BigInt::grow_to(), round_up(), and square().

same_mem()

template<typename T>

bool Botan::same_mem ( const T * p1, const T * p2, size_t n )

inline

Memory comparison, input insensitive

Parameters

p1	a pointer to an array
p2	a pointer to another array
n	the number of Ts in p1 and p2

Returns

true iff p1[i] == p2[i] forall i in [0...n)

Definition at line 57 of file mem_ops.h.

   {
   bool is_same = true;
 
   for(size_t i = 0; i != n; ++i)
      is_same &= (p1[i] == p2[i]);
 
   return is_same;
   }

References same_mem().

Referenced by check_passhash9(), Botan::CryptoBox::decrypt(), Botan::MemoryRegion< T >::operator==(), Botan::RTSS_Share::reconstruct(), same_mem(), and Botan::MessageAuthenticationCode::verify_mac().

search_map()

template<typename K, typename V>

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

inline

Searching through a std::map

Parameters

mapping	the map to search
key	is what to look for
null_result	is the value to return if key is not in mapping

Returns

mapping[key] or null_result

Definition at line 43 of file stl_util.h.

   {
   typename std::map<K, V>::const_iterator i = mapping.find(key);
   if(i == mapping.end())
      return null_result;
   return i->second;
   }

References search_map().

Referenced by algorithm_kat(), Botan::Algorithm_Cache< T >::get(), Botan::Library_State::get(), Botan::Library_State::get_allocator(), and search_map().

set_mem()

template<typename T>

void Botan::set_mem ( T * ptr, size_t n, byte val )

inline

Set memory to a fixed value

Parameters

ptr	a pointer to an array
n	the number of Ts pointed to by ptr
val	the value to set each byte to

Definition at line 45 of file mem_ops.h.

   {
   std::memset(ptr, val, sizeof(T)*n);
   }

References set_mem().

Referenced by set_mem().

significant_bytes()

template<typename T>

size_t Botan::significant_bytes ( T n )

inline

Return the number of significant bytes in n

Parameters

n	an integer value

Returns

number of significant bytes in n

Definition at line 62 of file bit_ops.h.

   {
   for(size_t i = 0; i != sizeof(T); ++i)
      if(get_byte(i, n))
         return sizeof(T)-i;
   return 0;
   }

References get_byte(), and significant_bytes().

Referenced by significant_bytes().

split_on()

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

Split a string

Parameters

str	the input string
delim	the delimitor

Returns

string split by delim

Definition at line 152 of file parsing.cpp.

   {
   std::vector<std::string> elems;
   if(str == "") return elems;
 
   std::string substr;
   for(std::string::const_iterator i = str.begin(); i != str.end(); ++i)
      {
      if(*i == delim)
         {
         if(substr != "")
            elems.push_back(substr);
         substr.clear();
         }
      else
         substr += *i;
      }
 
   if(substr == "")
      throw Invalid_Argument("Unable to split string: " + str);
   elems.push_back(substr);
 
   return elems;
   }

References split_on().

Referenced by Botan::EAC_Signed_Object::check_signature(), Botan::X509_Object::check_signature(), create_alt_name(), Botan::DataSource_Command::DataSource_Command(), Botan::Core_Engine::get_cipher(), get_pbe(), get_pbe(), Botan::X509_Object::hash_used_for_signature(), Botan::LibraryInitializer::initialize(), split_on(), string_to_ipv4(), Botan::Win32_CAPI_EntropySource::Win32_CAPI_EntropySource(), and Botan::X509_Cert_Options::X509_Cert_Options().

square()

BigInt BOTAN_DLL Botan::square

(

const BigInt &

x

)

Parameters

x	an integer

Returns

(x*x)

Definition at line 18 of file mp_numth.cpp.

   {
   const size_t x_sw = x.sig_words();
 
   BigInt z(BigInt::Positive, round_up<size_t>(2*x_sw, 16));
   SecureVector<word> workspace(z.size());
 
   bigint_sqr(z.get_reg(), z.size(), workspace,
              x.data(), x.size(), x_sw);
   return z;
   }

References bigint_sqr(), Botan::BigInt::data(), Botan::BigInt::get_reg(), Botan::BigInt::Positive, round_up(), Botan::BigInt::sig_words(), Botan::BigInt::size(), and square().

Referenced by Botan::Modular_Reducer::Modular_Reducer(), Botan::Modular_Reducer::square(), and square().

srp6_client_agree()

std::pair< BigInt, SymmetricKey > BOTAN_DLL Botan::srp6_client_agree	(	const std::string &	username,
		const std::string &	password,
		const std::string &	group_id,
		const std::string &	hash_id,
		const MemoryRegion< byte > &	salt,
		const BigInt &	B,
		RandomNumberGenerator &	rng )

SRP6a Client side

Parameters

username	the username we are attempting login for
password	the password we are attempting to use
group_id	specifies the shared SRP group
hash_id	specifies a secure hash function
salt	is the salt value sent by the server
B	is the server's public value
rng	is a random number generator

Returns

(A,K) the client public key and the shared secret key

Definition at line 96 of file srp6.cpp.

   {
   DL_Group group(group_id);
   const BigInt& g = group.get_g();
   const BigInt& p = group.get_p();
 
   const size_t p_bytes = group.get_p().bytes();
 
   if(B <= 0 || B >= p)
      throw std::runtime_error("Invalid SRP parameter from server");
 
   BigInt k = hash_seq(hash_id, p_bytes, p, g);
 
   BigInt a(rng, 256);
 
   BigInt A = power_mod(g, a, p);
 
   BigInt u = hash_seq(hash_id, p_bytes, A, B);
 
   const BigInt x = compute_x(hash_id, identifier, password, salt);
 
   BigInt S = power_mod((B - (k * power_mod(g, x, p))) % p, (a + (u * x)), p);
 
   SymmetricKey Sk(BigInt::encode_1363(S, p_bytes));
 
   return std::make_pair(A, Sk);
   }

References Botan::BigInt::bytes(), Botan::BigInt::encode_1363(), Botan::DL_Group::get_g(), Botan::DL_Group::get_p(), power_mod(), and srp6_client_agree().

Referenced by srp6_client_agree().

srp6_group_identifier()

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

Return the group id for this SRP param set, or else thrown an exception

Definition at line 72 of file srp6.cpp.

   {
   /*
   This function assumes that only one 'standard' SRP parameter set has
   been defined for a particular bitsize. As of this writing that is the case.
   */
   try
      {
      const std::string group_name = "modp/srp/" + to_string(N.bits());
 
      DL_Group group(group_name);
 
      if(group.get_p() == N && group.get_g() == g)
         return group_name;
 
      throw std::runtime_error("Unknown SRP params");
      }
   catch(...)
      {
      throw Invalid_Argument("Bad SRP group parameters");
      }
   }

References Botan::BigInt::bits(), Botan::DL_Group::get_g(), Botan::DL_Group::get_p(), srp6_group_identifier(), and to_string().

Referenced by srp6_group_identifier().

static_provider_weight()

size_t Botan::static_provider_weight

(

const std::string &

prov_name

)

Parameters

prov_name

a provider name

Returns

weight for this provider

Return a static provider weighing

Definition at line 15 of file prov_weight.cpp.

   {
   /*
   * Prefer asm over C++, but prefer anything over OpenSSL or GNU MP; to use
   * them, set the provider explicitly for the algorithms you want
   */
 
   if(prov_name == "aes_isa") return 9;
   if(prov_name == "simd") return 8;
   if(prov_name == "asm") return 7;
 
   if(prov_name == "core") return 5;
 
   if(prov_name == "openssl") return 2;
   if(prov_name == "gmp") return 1;
 
   return 0; // other/unknown
   }

References static_provider_weight().

Referenced by Botan::Algorithm_Cache< T >::get(), and static_provider_weight().

store_be() [1/6]

template<typename T>

void Botan::store_be ( byte out[], T x0, T x1 )

inline

Store two big-endian words

Parameters

out	the output byte array
x0	the first word
x1	the second word

Definition at line 533 of file loadstor.h.

   {
   store_be(x0, out + (0 * sizeof(T)));
   store_be(x1, out + (1 * sizeof(T)));
   }

References store_be().

store_be() [2/6]

template<typename T>

void Botan::store_be ( byte out[], T x0, T x1, T x2, T x3 )

inline

Store four big-endian words

Parameters

out	the output byte array
x0	the first word
x1	the second word
x2	the third word
x3	the fourth word

Definition at line 565 of file loadstor.h.

   {
   store_be(x0, out + (0 * sizeof(T)));
   store_be(x1, out + (1 * sizeof(T)));
   store_be(x2, out + (2 * sizeof(T)));
   store_be(x3, out + (3 * sizeof(T)));
   }

References store_be().

store_be() [3/6]

template<typename T>

void Botan::store_be ( byte out[], T x0, T x1, T x2, T x3, T x4, T x5, T x6, T x7 )

inline

Store eight big-endian words

Parameters

out	the output byte array
x0	the first word
x1	the second word
x2	the third word
x3	the fourth word
x4	the fifth word
x5	the sixth word
x6	the seventh word
x7	the eighth word

Definition at line 612 of file loadstor.h.

   {
   store_be(x0, out + (0 * sizeof(T)));
   store_be(x1, out + (1 * sizeof(T)));
   store_be(x2, out + (2 * sizeof(T)));
   store_be(x3, out + (3 * sizeof(T)));
   store_be(x4, out + (4 * sizeof(T)));
   store_be(x5, out + (5 * sizeof(T)));
   store_be(x6, out + (6 * sizeof(T)));
   store_be(x7, out + (7 * sizeof(T)));
   }

References store_be().

store_be() [4/6]

void Botan::store_be ( u16bit in, byte out[2] )

inline

Store a big-endian u16bit

Parameters

in	the input u16bit
out	the byte array to write to

Definition at line 412 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   *reinterpret_cast<u16bit*>(out) = BOTAN_ENDIAN_B2N(in);
#else
   out[0] = get_byte(0, in);
   out[1] = get_byte(1, in);
#endif
   }

References get_byte(), and store_be().

Referenced by Botan::SHA_160::copy_out(), Botan::Blowfish::decrypt_n(), Botan::CAST_128::decrypt_n(), Botan::CAST_256::decrypt_n(), Botan::DES::decrypt_n(), Botan::KASUMI::decrypt_n(), Botan::MISTY1::decrypt_n(), Botan::Noekeon::decrypt_n(), Botan::SEED::decrypt_n(), Botan::TEA::decrypt_n(), Botan::TripleDES::decrypt_n(), Botan::XTEA::decrypt_n(), Botan::Blowfish::encrypt_n(), Botan::CAST_128::encrypt_n(), Botan::CAST_256::encrypt_n(), Botan::DES::encrypt_n(), Botan::KASUMI::encrypt_n(), Botan::MISTY1::encrypt_n(), Botan::Noekeon::encrypt_n(), Botan::SEED::encrypt_n(), Botan::TEA::encrypt_n(), Botan::TripleDES::encrypt_n(), Botan::XTEA::encrypt_n(), rfc3394_keyunwrap(), rfc3394_keywrap(), Botan::SIMD_Scalar::store_be(), store_be(), store_be(), store_be(), store_be(), store_be(), store_be(), and Botan::MDx_HashFunction::write_count().

store_be() [5/6]

void Botan::store_be ( u32bit in, byte out[4] )

inline

Store a big-endian u32bit

Parameters

in	the input u32bit
out	the byte array to write to

Definition at line 442 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   *reinterpret_cast<u32bit*>(out) = BOTAN_ENDIAN_B2N(in);
#else
   out[0] = get_byte(0, in);
   out[1] = get_byte(1, in);
   out[2] = get_byte(2, in);
   out[3] = get_byte(3, in);
#endif
   }

References get_byte(), and store_be().

store_be() [6/6]

void Botan::store_be ( u64bit in, byte out[8] )

inline

Store a big-endian u64bit

Parameters

in	the input u64bit
out	the byte array to write to

Definition at line 476 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   *reinterpret_cast<u64bit*>(out) = BOTAN_ENDIAN_B2N(in);
#else
   out[0] = get_byte(0, in);
   out[1] = get_byte(1, in);
   out[2] = get_byte(2, in);
   out[3] = get_byte(3, in);
   out[4] = get_byte(4, in);
   out[5] = get_byte(5, in);
   out[6] = get_byte(6, in);
   out[7] = get_byte(7, in);
#endif
   }

References get_byte(), and store_be().

store_le() [1/6]

template<typename T>

void Botan::store_le ( byte out[], T x0, T x1 )

inline

Store two little-endian words

Parameters

out	the output byte array
x0	the first word
x1	the second word

Definition at line 520 of file loadstor.h.

   {
   store_le(x0, out + (0 * sizeof(T)));
   store_le(x1, out + (1 * sizeof(T)));
   }

References store_le().

store_le() [2/6]

template<typename T>

void Botan::store_le ( byte out[], T x0, T x1, T x2, T x3 )

inline

Store four little-endian words

Parameters

out	the output byte array
x0	the first word
x1	the second word
x2	the third word
x3	the fourth word

Definition at line 548 of file loadstor.h.

   {
   store_le(x0, out + (0 * sizeof(T)));
   store_le(x1, out + (1 * sizeof(T)));
   store_le(x2, out + (2 * sizeof(T)));
   store_le(x3, out + (3 * sizeof(T)));
   }

References store_le().

store_le() [3/6]

template<typename T>

void Botan::store_le ( byte out[], T x0, T x1, T x2, T x3, T x4, T x5, T x6, T x7 )

inline

Store eight little-endian words

Parameters

out	the output byte array
x0	the first word
x1	the second word
x2	the third word
x3	the fourth word
x4	the fifth word
x5	the sixth word
x6	the seventh word
x7	the eighth word

Definition at line 586 of file loadstor.h.

   {
   store_le(x0, out + (0 * sizeof(T)));
   store_le(x1, out + (1 * sizeof(T)));
   store_le(x2, out + (2 * sizeof(T)));
   store_le(x3, out + (3 * sizeof(T)));
   store_le(x4, out + (4 * sizeof(T)));
   store_le(x5, out + (5 * sizeof(T)));
   store_le(x6, out + (6 * sizeof(T)));
   store_le(x7, out + (7 * sizeof(T)));
   }

References store_le().

store_le() [4/6]

void Botan::store_le ( u16bit in, byte out[2] )

inline

Store a little-endian u16bit

Parameters

in	the input u16bit
out	the byte array to write to

Definition at line 427 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   *reinterpret_cast<u16bit*>(out) = BOTAN_ENDIAN_L2N(in);
#else
   out[0] = get_byte(1, in);
   out[1] = get_byte(0, in);
#endif
   }

References get_byte(), and store_le().

Referenced by Botan::MD4::copy_out(), Botan::MD5::copy_out(), Botan::GOST_28147_89::decrypt_n(), Botan::MARS::decrypt_n(), Botan::RC2::decrypt_n(), Botan::Serpent::decrypt_n(), Botan::Skipjack::decrypt_n(), Botan::Twofish::decrypt_n(), Botan::GOST_28147_89::encrypt_n(), Botan::MARS::encrypt_n(), Botan::RC2::encrypt_n(), Botan::Serpent::encrypt_n(), Botan::Skipjack::encrypt_n(), Botan::Twofish::encrypt_n(), Botan::SIMD_Scalar::store_le(), store_le(), store_le(), store_le(), store_le(), store_le(), store_le(), and Botan::MDx_HashFunction::write_count().

store_le() [5/6]

void Botan::store_le ( u32bit in, byte out[4] )

inline

Store a little-endian u32bit

Parameters

in	the input u32bit
out	the byte array to write to

Definition at line 459 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   *reinterpret_cast<u32bit*>(out) = BOTAN_ENDIAN_L2N(in);
#else
   out[0] = get_byte(3, in);
   out[1] = get_byte(2, in);
   out[2] = get_byte(1, in);
   out[3] = get_byte(0, in);
#endif
   }

References get_byte(), and store_le().

store_le() [6/6]

void Botan::store_le ( u64bit in, byte out[8] )

inline

Store a little-endian u64bit

Parameters

in	the input u64bit
out	the byte array to write to

Definition at line 497 of file loadstor.h.

   {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
   *reinterpret_cast<u64bit*>(out) = BOTAN_ENDIAN_L2N(in);
#else
   out[0] = get_byte(7, in);
   out[1] = get_byte(6, in);
   out[2] = get_byte(5, in);
   out[3] = get_byte(4, in);
   out[4] = get_byte(3, in);
   out[5] = get_byte(2, in);
   out[6] = get_byte(1, in);
   out[7] = get_byte(0, in);
#endif
   }

References get_byte(), and store_le().

string_to_ipv4()

BOTAN_DLL u32bit Botan::string_to_ipv4

(

const std::string &

ip_str

)

Convert a string representation of an IPv4 address to a number

Parameters

ip_str

the string representation

Returns

integer IPv4 address

Definition at line 254 of file parsing.cpp.

   {
   std::vector<std::string> parts = split_on(str, '.');
 
   if(parts.size() != 4)
      throw Decoding_Error("Invalid IP string " + str);
 
   u32bit ip = 0;
 
   for(size_t i = 0; i != parts.size(); ++i)
      {
      u32bit octet = to_u32bit(parts[i]);
 
      if(octet > 255)
         throw Decoding_Error("Invalid IP string " + str);
 
      ip = (ip << 8) | (octet & 0xFF);
      }
 
   return ip;
   }

References Botan::Decoding_Error::Decoding_Error(), split_on(), string_to_ipv4(), and to_u32bit().

Referenced by string_to_ipv4().

sub_mul()

BigInt BOTAN_DLL Botan::sub_mul	(	const BigInt &	a,
		const BigInt &	b,
		const BigInt &	c )

Fused subtract-multiply

Parameters

a	an integer
b	an integer
c	an integer

Returns

(a-b)*c

Definition at line 60 of file mp_numth.cpp.

   {
   if(a.is_negative() || b.is_negative())
      throw Invalid_Argument("sub_mul: First two arguments must be >= 0");
 
   BigInt r = a;
   r -= b;
   r *= c;
   return r;
   }

References Botan::BigInt::is_negative(), and sub_mul().

Referenced by Botan::RW_Signature_Operation::sign(), and sub_mul().

system_time()

BOTAN_DLL u64bit Botan::system_time

(

)

Returns

seconds resolution timestamp, unknown epoch

Definition at line 73 of file time.cpp.

   {
   return static_cast<u64bit>(std::time(0));
   }

References system_time().

Referenced by Botan::X509_Store::add_crl(), Botan::DE_EAC::create_cvca(), Botan::CRL_Entry::CRL_Entry(), Botan::DE_EAC::link_cvca(), Botan::DE_EAC::sign_request(), system_time(), Botan::X509_Store::validate_cert(), and Botan::X509_Cert_Options::X509_Cert_Options().

timespec_to_u32bit()

BOTAN_DLL u32bit Botan::timespec_to_u32bit

(

const std::string &

timespec

)

Convert a time specification to a number

Parameters

timespec

the time specification

Returns

number of seconds represented by timespec

Definition at line 65 of file parsing.cpp.

   {
   if(timespec == "")
      return 0;
 
   const char suffix = timespec[timespec.size()-1];
   std::string value = timespec.substr(0, timespec.size()-1);
 
   u32bit scale = 1;
 
   if(Charset::is_digit(suffix))
      value += suffix;
   else if(suffix == 's')
      scale = 1;
   else if(suffix == 'm')
      scale = 60;
   else if(suffix == 'h')
      scale = 60 * 60;
   else if(suffix == 'd')
      scale = 24 * 60 * 60;
   else if(suffix == 'y')
      scale = 365 * 24 * 60 * 60;
   else
      throw Decoding_Error("timespec_to_u32bit: Bad input " + timespec);
 
   return scale * to_u32bit(value);
   }

References Botan::Decoding_Error::Decoding_Error(), Botan::Charset::is_digit(), timespec_to_u32bit(), and to_u32bit().

Referenced by timespec_to_u32bit().

to_string()

BOTAN_DLL std::string Botan::to_string	(	u64bit	n,
		size_t	min_len = 0 )

Convert a number to a string

Parameters

n	the integer to convert to a string
min_len	the min length of the output string

Returns

n convert to a string

Definition at line 42 of file parsing.cpp.

   {
   std::string lenstr;
   if(n)
      {
      while(n > 0)
         {
         lenstr = Charset::digit2char(n % 10) + lenstr;
         n /= 10;
         }
      }
   else
      lenstr = "0";
 
   while(lenstr.size() < min_len)
      lenstr = "0" + lenstr;
 
   return lenstr;
   }

References Botan::Charset::digit2char(), and to_string().

Referenced by Botan::Data_Store::add(), Botan::EAC_Time::as_string(), Botan::OID::as_string(), Botan::X509_Time::as_string(), Botan::ASN1_String::ASN1_String(), Botan::BER_Bad_Tag::BER_Bad_Tag(), Botan::BER_Bad_Tag::BER_Bad_Tag(), Botan::DL_Group::BER_decode(), Botan::CFB_Decryption::CFB_Decryption(), Botan::CFB_Decryption::CFB_Decryption(), Botan::CFB_Encryption::CFB_Encryption(), Botan::CFB_Encryption::CFB_Encryption(), Botan::PK_Verifier::check_signature(), Botan::CipherSuite::CipherSuite(), Botan::DL_Group::DER_encode(), Botan::PKCS5_PBKDF2::derive_key(), Botan::DL_Group::DL_Group(), Botan::Dynamically_Loaded_Engine::Dynamically_Loaded_Engine(), Botan::EAX_Base::EAX_Base(), generate_dsa_primes(), generate_passhash9(), Botan::Integer_Overflow_Detected::Integer_Overflow_Detected(), Botan::Invalid_IV_Length::Invalid_IV_Length(), Botan::Invalid_Key_Length::Invalid_Key_Length(), Botan::Pipe::Invalid_Message_Number::Invalid_Message_Number(), ipv4_to_string(), Botan::Keccak_1600::Keccak_1600(), Botan::MISTY1::MISTY1(), Botan::ARC4::name(), Botan::Keccak_1600::name(), Botan::Lion::name(), Botan::SAFER_SK::name(), Botan::Skein_512::name(), Botan::Tiger::name(), Botan::DL_Group::PEM_encode(), random_prime(), random_safe_prime(), Botan::EAC_Time::readable_string(), Botan::X509_Time::readable_string(), Botan::RSA_PrivateKey::RSA_PrivateKey(), Botan::RW_PrivateKey::RW_PrivateKey(), Botan::X509_Time::set_to(), Botan::DE_EAC::sign_request(), Botan::PK_Signer::signature(), srp6_group_identifier(), Botan::Tiger::Tiger(), to_string(), and Botan::Charset::transcode().

to_u32bit()

BOTAN_DLL u32bit Botan::to_u32bit

(

const std::string &

str

)

Convert a string to a number

Parameters

str	the string to convert

Returns

number value of the string

Definition at line 18 of file parsing.cpp.

   {
   u32bit n = 0;
 
   for(std::string::const_iterator i = number.begin(); i != number.end(); ++i)
      {
      const u32bit OVERFLOW_MARK = 0xFFFFFFFF / 10;
 
      if(*i == ' ')
         continue;
 
      byte digit = Charset::char2digit(*i);
 
      if((n > OVERFLOW_MARK) || (n == OVERFLOW_MARK && digit > 5))
         throw Decoding_Error("to_u32bit: Integer overflow");
      n *= 10;
      n += digit;
      }
   return n;
   }

References Botan::Charset::char2digit(), Botan::Decoding_Error::Decoding_Error(), and to_u32bit().

Referenced by Botan::SCAN_Name::arg_as_integer(), check_bcrypt(), Botan::Data_Store::get1_u32bit(), get_cipher_mode(), parse_asn1_oid(), Botan::EAC_Time::set_to(), Botan::X509_Time::set_to(), Botan::X509_Time::set_to(), string_to_ipv4(), timespec_to_u32bit(), and to_u32bit().

unlock_mem()

void Botan::unlock_mem	(	void *	addr,
		size_t	length )

Unlock memory locked with lock_mem()

Parameters

addr	the start of the memory block
length	the length of the memory block in bytes

Definition at line 45 of file mlock.cpp.

   {
#if defined(BOTAN_TARGET_OS_HAS_POSIX_MLOCK)
   ::munlock(static_cast<char*>(ptr), bytes);
#elif defined(BOTAN_TARGET_OS_HAS_WIN32_VIRTUAL_LOCK)
   ::VirtualUnlock(ptr, bytes);
#endif
   }

References unlock_mem().

Referenced by has_mlock(), and unlock_mem().

verify_prime()

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

inline

Verify primality - this function is slow but useful if you want to ensure that a possibly malicious entity did not provide you with something that 'looks like' a prime

Parameters

n	a positive integer to test for primality
rng	a random number generator

Returns

true if all primality tests passed, otherwise false

Definition at line 154 of file numthry.h.

   { return primality_test(n, rng, 2); }

References primality_test(), and verify_prime().

Referenced by verify_prime().

version_datestamp()

BOTAN_DLL u32bit Botan::version_datestamp

(

)

Return the date this version of botan was released, in an integer of the form YYYYMMDD. For instance a version released on May 21, 2013 would return the integer 20130521. If the currently running version is not an official release, this function will return 0 instead.

Returns

release date, or zero if unreleased

Definition at line 44 of file version.cpp.

{ return BOTAN_VERSION_DATESTAMP; }

References version_datestamp().

Referenced by version_datestamp().

version_major()

BOTAN_DLL u32bit Botan::version_major

(

)

Get the major version number.

Returns

major version number

Definition at line 49 of file version.cpp.

{ return BOTAN_VERSION_MAJOR; }

References version_major().

Referenced by version_major().

version_minor()

BOTAN_DLL u32bit Botan::version_minor

(

)

Get the minor version number.

Returns

minor version number

Definition at line 50 of file version.cpp.

{ return BOTAN_VERSION_MINOR; }

References version_minor().

Referenced by version_minor().

version_patch()

BOTAN_DLL u32bit Botan::version_patch

(

)

Get the patch number.

Returns

patch number

Definition at line 51 of file version.cpp.

{ return BOTAN_VERSION_PATCH; }

References version_patch().

Referenced by version_patch().

version_string()

BOTAN_DLL std::string Botan::version_string

(

)

Get a human-readable string identifying the version of Botan. No particular format should be assumed.

Returns

version string

Definition at line 23 of file version.cpp.

   {
#define QUOTE(name) #name
#define STR(macro) QUOTE(macro)
 
   return "Botan " STR(BOTAN_VERSION_MAJOR) "."
                   STR(BOTAN_VERSION_MINOR) "."
                   STR(BOTAN_VERSION_PATCH) " ("
 
#if (BOTAN_VERSION_DATESTAMP == 0)
      "unreleased version"
#else
      "released " STR(BOTAN_VERSION_DATESTAMP)
#endif
      ", revision " BOTAN_VERSION_VC_REVISION
      ", distribution " BOTAN_DISTRIBUTION_INFO ")";
 
#undef STR
#undef QUOTE
   }

References STR, and version_string().

Referenced by version_string().

word3_muladd()

void Botan::word3_muladd ( word * w2, word * w1, word * w0, word a, word b )

inline

Definition at line 175 of file mp_asmi.h.

   {
   word carry = *w0;
   *w0 = word_madd2(a, b, &carry);
   *w1 += carry;
   *w2 += (*w1 < carry) ? 1 : 0;
   }

References word3_muladd(), and word_madd2().

Referenced by bigint_comba_mul16(), bigint_comba_mul4(), bigint_comba_mul6(), bigint_comba_mul8(), bigint_comba_sqr16(), bigint_comba_sqr4(), bigint_comba_sqr6(), bigint_comba_sqr8(), and word3_muladd().

word3_muladd_2()

void Botan::word3_muladd_2 ( word * w2, word * w1, word * w0, word a, word b )

inline

Definition at line 186 of file mp_asmi.h.

   {
   word carry = 0;
   a = word_madd2(a, b, &carry);
   b = carry;
 
   word top = (b >> (BOTAN_MP_WORD_BITS-1));
   b <<= 1;
   b |= (a >> (BOTAN_MP_WORD_BITS-1));
   a <<= 1;
 
   carry = 0;
   *w0 = word_add(*w0, a, &carry);
   *w1 = word_add(*w1, b, &carry);
   *w2 = word_add(*w2, top, &carry);
   }

References word3_muladd_2(), word_add(), and word_madd2().

Referenced by bigint_comba_sqr16(), bigint_comba_sqr4(), bigint_comba_sqr6(), bigint_comba_sqr8(), and word3_muladd_2().

word8_add2()

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

inline

Definition at line 33 of file mp_asmi.h.

   {
   x[0] = word_add(x[0], y[0], &carry);
   x[1] = word_add(x[1], y[1], &carry);
   x[2] = word_add(x[2], y[2], &carry);
   x[3] = word_add(x[3], y[3], &carry);
   x[4] = word_add(x[4], y[4], &carry);
   x[5] = word_add(x[5], y[5], &carry);
   x[6] = word_add(x[6], y[6], &carry);
   x[7] = word_add(x[7], y[7], &carry);
   return carry;
   }

References word8_add2(), and word_add().

Referenced by bigint_add2_nc(), and word8_add2().

word8_add3()

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

inline

Definition at line 49 of file mp_asmi.h.

   {
   z[0] = word_add(x[0], y[0], &carry);
   z[1] = word_add(x[1], y[1], &carry);
   z[2] = word_add(x[2], y[2], &carry);
   z[3] = word_add(x[3], y[3], &carry);
   z[4] = word_add(x[4], y[4], &carry);
   z[5] = word_add(x[5], y[5], &carry);
   z[6] = word_add(x[6], y[6], &carry);
   z[7] = word_add(x[7], y[7], &carry);
   return carry;
   }

References word8_add3(), and word_add().

Referenced by bigint_add3_nc(), and word8_add3().

word8_linmul2()

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

inline

Definition at line 127 of file mp_asmi.h.

   {
   x[0] = word_madd2(x[0], y, &carry);
   x[1] = word_madd2(x[1], y, &carry);
   x[2] = word_madd2(x[2], y, &carry);
   x[3] = word_madd2(x[3], y, &carry);
   x[4] = word_madd2(x[4], y, &carry);
   x[5] = word_madd2(x[5], y, &carry);
   x[6] = word_madd2(x[6], y, &carry);
   x[7] = word_madd2(x[7], y, &carry);
   return carry;
   }

References word8_linmul2(), and word_madd2().

Referenced by bigint_linmul2(), and word8_linmul2().

word8_linmul3() [1/2]

word Botan::word8_linmul3 ( word z[4], const word x[4], word y, word carry )

inline

Definition at line 368 of file mp_asmi.h.

   {
   __asm {
#if 0
      //it's slower!!!
      mov edx,[z]
      mov eax,[x]
      movd mm7,[y]
 
      movd mm0,[eax]
      movd mm1,[eax+4]
      movd mm2,[eax+8]
      pmuludq mm0,mm7
      pmuludq mm1,mm7
      pmuludq mm2,mm7
 
      movd mm6,[carry]
      paddq mm0,mm6
      movd [edx],mm0
 
      psrlq mm0,32
      paddq mm1,mm0
      movd [edx+4],mm1
 
      movd mm3,[eax+12]
      psrlq mm1,32
      paddq mm2,mm1
      movd [edx+8],mm2
 
      pmuludq mm3,mm7
      movd mm4,[eax+16]
      psrlq mm2,32
      paddq mm3,mm2
      movd [edx+12],mm3
 
      pmuludq mm4,mm7
      movd mm5,[eax+20]
      psrlq mm3,32
      paddq mm4,mm3
      movd [edx+16],mm4
 
      pmuludq mm5,mm7
      movd mm0,[eax+24]
      psrlq mm4,32
      paddq mm5,mm4
      movd [edx+20],mm5
 
      pmuludq mm0,mm7
      movd mm1,[eax+28]
      psrlq mm5,32
      paddq mm0,mm5
      movd [edx+24],mm0
 
      pmuludq mm1,mm7
      psrlq mm0,32
      paddq mm1,mm0
      movd [edx+28],mm1
      psrlq mm1,32
 
      movd eax,mm1
      emms
#else
      mov edi,[z]
      mov esi,[x]
      mov eax,[esi]        //load a
      mul [y]           //edx(hi):eax(lo)=a*b
      add eax,[carry]    //sum lo carry
      adc edx,0          //sum hi carry
      mov ecx,edx      //store carry
      mov [edi],eax        //load a
 
      mov eax,[esi+4]        //load a
      mul [y]           //edx(hi):eax(lo)=a*b
      add eax,ecx      //sum lo carry
      adc edx,0          //sum hi carry
      mov ecx,edx      //store carry
      mov [edi+4],eax        //load a
 
      mov eax,[esi+8]        //load a
      mul [y]           //edx(hi):eax(lo)=a*b
      add eax,ecx      //sum lo carry
      adc edx,0          //sum hi carry
      mov ecx,edx      //store carry
      mov [edi+8],eax        //load a
 
      mov eax,[esi+12]        //load a
      mul [y]           //edx(hi):eax(lo)=a*b
      add eax,ecx      //sum lo carry
      adc edx,0          //sum hi carry
      mov ecx,edx      //store carry
      mov [edi+12],eax        //load a
 
      mov eax,[esi+16]        //load a
      mul [y]           //edx(hi):eax(lo)=a*b
      add eax,ecx      //sum lo carry
      adc edx,0          //sum hi carry
      mov ecx,edx      //store carry
      mov [edi+16],eax        //load a
 
      mov eax,[esi+20]        //load a
      mul [y]           //edx(hi):eax(lo)=a*b
      add eax,ecx      //sum lo carry
      adc edx,0          //sum hi carry
      mov ecx,edx      //store carry
      mov [edi+20],eax        //load a
 
      mov eax,[esi+24]        //load a
      mul [y]           //edx(hi):eax(lo)=a*b
      add eax,ecx      //sum lo carry
      adc edx,0          //sum hi carry
      mov ecx,edx      //store carry
      mov [edi+24],eax        //load a
 
      mov eax,[esi+28]        //load a
      mul [y]           //edx(hi):eax(lo)=a*b
      add eax,ecx      //sum lo carry
      adc edx,0          //sum hi carry
      mov [edi+28],eax        //load a
      mov eax,edx      //store carry
#endif
      }
   }

References word8_linmul3().

word8_linmul3() [2/2]

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

inline

Definition at line 143 of file mp_asmi.h.

   {
   z[0] = word_madd2(x[0], y, &carry);
   z[1] = word_madd2(x[1], y, &carry);
   z[2] = word_madd2(x[2], y, &carry);
   z[3] = word_madd2(x[3], y, &carry);
   z[4] = word_madd2(x[4], y, &carry);
   z[5] = word_madd2(x[5], y, &carry);
   z[6] = word_madd2(x[6], y, &carry);
   z[7] = word_madd2(x[7], y, &carry);
   return carry;
   }

References word8_linmul3(), and word_madd2().

Referenced by bigint_linmul3(), word8_linmul3(), and word8_linmul3().

word8_madd3()

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

inline

Definition at line 159 of file mp_asmi.h.

   {
   z[0] = word_madd3(x[0], y, z[0], &carry);
   z[1] = word_madd3(x[1], y, z[1], &carry);
   z[2] = word_madd3(x[2], y, z[2], &carry);
   z[3] = word_madd3(x[3], y, z[3], &carry);
   z[4] = word_madd3(x[4], y, z[4], &carry);
   z[5] = word_madd3(x[5], y, z[5], &carry);
   z[6] = word_madd3(x[6], y, z[6], &carry);
   z[7] = word_madd3(x[7], y, z[7], &carry);
   return carry;
   }

References word8_madd3(), and word_madd3().

Referenced by bigint_monty_redc(), bigint_simple_mul(), bigint_simple_sqr(), and word8_madd3().

word8_muladd()

word Botan::word8_muladd ( word z[8], const word x[8], word y, word carry )

inline

Definition at line 287 of file mp_asmi.h.

   {
   __asm {
      mov esi,[x]
      mov ebx,[y]
      mov edi,[z]
      mov eax,[esi]     //load a
      mul ebx           //edx(hi):eax(lo)=a*b
      add eax,[carry]   //sum lo carry
      adc edx,0         //sum hi carry
      add eax,[edi]     //sum lo z
      adc edx,0         //sum hi z
      mov ecx,edx       //carry for next block = hi z
      mov [edi],eax     //save lo z
 
      mov eax,[esi+4]
      mul ebx
      add eax,ecx
      adc edx,0
      add eax,[edi+4]
      adc edx,0
      mov ecx,edx
      mov [edi+4],eax
 
      mov eax,[esi+8]
      mul ebx
      add eax,ecx
      adc edx,0
      add eax,[edi+8]
      adc edx,0
      mov ecx,edx
      mov [edi+8],eax
 
      mov eax,[esi+12]
      mul ebx
      add eax,ecx
      adc edx,0
      add eax,[edi+12]
      adc edx,0
      mov ecx,edx
      mov [edi+12],eax
 
      mov eax,[esi+16]
      mul ebx
      add eax,ecx
      adc edx,0
      add eax,[edi+16]
      adc edx,0
      mov ecx,edx
      mov [edi+16],eax
 
      mov eax,[esi+20]
      mul ebx
      add eax,ecx
      adc edx,0
      add eax,[edi+20]
      adc edx,0
      mov ecx,edx
      mov [edi+20],eax
 
      mov eax,[esi+24]
      mul ebx
      add eax,ecx
      adc edx,0
      add eax,[edi+24]
      adc edx,0
      mov ecx,edx
      mov [edi+24],eax
 
      mov eax,[esi+28]
      mul ebx
      add eax,ecx
      adc edx,0
      add eax,[edi+28]
      adc edx,0
      mov [edi+28],eax
      mov eax,edx
      }
   }

References word8_muladd().

Referenced by word8_muladd().

word8_sub2()

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

inline

Definition at line 78 of file mp_asmi.h.

   {
   x[0] = word_sub(x[0], y[0], &carry);
   x[1] = word_sub(x[1], y[1], &carry);
   x[2] = word_sub(x[2], y[2], &carry);
   x[3] = word_sub(x[3], y[3], &carry);
   x[4] = word_sub(x[4], y[4], &carry);
   x[5] = word_sub(x[5], y[5], &carry);
   x[6] = word_sub(x[6], y[6], &carry);
   x[7] = word_sub(x[7], y[7], &carry);
   return carry;
   }

References word8_sub2(), and word_sub().

Referenced by bigint_sub2(), and word8_sub2().

word8_sub2_rev()

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

inline

Definition at line 94 of file mp_asmi.h.

   {
   x[0] = word_sub(y[0], x[0], &carry);
   x[1] = word_sub(y[1], x[1], &carry);
   x[2] = word_sub(y[2], x[2], &carry);
   x[3] = word_sub(y[3], x[3], &carry);
   x[4] = word_sub(y[4], x[4], &carry);
   x[5] = word_sub(y[5], x[5], &carry);
   x[6] = word_sub(y[6], x[6], &carry);
   x[7] = word_sub(y[7], x[7], &carry);
   return carry;
   }

References word8_sub2_rev(), and word_sub().

Referenced by bigint_sub2_rev(), and word8_sub2_rev().

word8_sub3()

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

inline

Definition at line 110 of file mp_asmi.h.

   {
   z[0] = word_sub(x[0], y[0], &carry);
   z[1] = word_sub(x[1], y[1], &carry);
   z[2] = word_sub(x[2], y[2], &carry);
   z[3] = word_sub(x[3], y[3], &carry);
   z[4] = word_sub(x[4], y[4], &carry);
   z[5] = word_sub(x[5], y[5], &carry);
   z[6] = word_sub(x[6], y[6], &carry);
   z[7] = word_sub(x[7], y[7], &carry);
   return carry;
   }

References word8_sub3(), and word_sub().

Referenced by bigint_sub3(), and word8_sub3().

word_add()

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

inline

Definition at line 21 of file mp_asmi.h.

   {
   word z = x + y;
   word c1 = (z < x);
   z += *carry;
   *carry = c1 | (z < *carry);
   return z;
   }

References word_add().

Referenced by bigint_add2_nc(), bigint_add3_nc(), bigint_cnd_abs(), bigint_cnd_add(), word3_muladd_2(), word8_add2(), word8_add3(), and word_add().

word_madd2()

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

inline

Definition at line 86 of file mp_asm.h.

   {
   word z0 = 0, z1 = 0;
 
   BOTAN_WORD_MUL(a, b, z1, z0);
 
   z1 += *c;
   z0 += (z1 < *c);
 
   *c = z0;
   return z1;
   }

References BOTAN_WORD_MUL, and word_madd2().

Referenced by bigint_divcore(), bigint_linmul2(), bigint_linmul3(), bigint_modop(), word3_muladd(), word3_muladd_2(), word8_linmul2(), word8_linmul3(), and word_madd2().

word_madd3()

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

inline

Definition at line 102 of file mp_asm.h.

   {
   word z0 = 0, z1 = 0;
 
   BOTAN_WORD_MUL(a, b, z1, z0);
 
   z1 += c;
   z0 += (z1 < c);
 
   z1 += *d;
   z0 += (z1 < *d);
 
   *d = z0;
   return z1;
   }

References BOTAN_WORD_MUL, and word_madd3().

Referenced by bigint_monty_redc(), bigint_simple_mul(), bigint_simple_sqr(), word8_madd3(), and word_madd3().

word_sub()

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

inline

Definition at line 66 of file mp_asmi.h.

   {
   word t0 = x - y;
   word c1 = (t0 > x);
   word z = t0 - *carry;
   *carry = c1 | (z > t0);
   return z;
   }

References word_sub().

Referenced by bigint_cnd_sub(), bigint_monty_redc(), bigint_sub2(), bigint_sub2_rev(), bigint_sub3(), word8_sub2(), word8_sub2_rev(), word8_sub3(), and word_sub().

x500_name_cmp()

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

Compare two names using the X.509 comparison algorithm

Parameters

name1	the first name
name2	the second name

Returns

true if name1 is the same as name2 by the X.509 comparison rules

Definition at line 213 of file parsing.cpp.

   {
   std::string::const_iterator p1 = name1.begin();
   std::string::const_iterator p2 = name2.begin();
 
   while((p1 != name1.end()) && Charset::is_space(*p1)) ++p1;
   while((p2 != name2.end()) && Charset::is_space(*p2)) ++p2;
 
   while(p1 != name1.end() && p2 != name2.end())
      {
      if(Charset::is_space(*p1))
         {
         if(!Charset::is_space(*p2))
            return false;
 
         while((p1 != name1.end()) && Charset::is_space(*p1)) ++p1;
         while((p2 != name2.end()) && Charset::is_space(*p2)) ++p2;
 
         if(p1 == name1.end() && p2 == name2.end())
            return true;
         if(p1 == name1.end() || p2 == name2.end())
            return false;
         }
 
      if(!Charset::caseless_cmp(*p1, *p2))
         return false;
      ++p1;
      ++p2;
      }
 
   while((p1 != name1.end()) && Charset::is_space(*p1)) ++p1;
   while((p2 != name2.end()) && Charset::is_space(*p2)) ++p2;
 
   if((p1 != name1.end()) || (p2 != name2.end()))
      return false;
   return true;
   }

References Botan::Charset::caseless_cmp(), Botan::Charset::is_space(), and x500_name_cmp().

Referenced by operator==(), and x500_name_cmp().

xor_buf() [1/2]

void Botan::xor_buf ( byte out[], const byte in[], const byte in2[], size_t length )

inline

XOR arrays. Postcondition out[i] = in[i] ^ in2[i] forall i = 0...length

Parameters

out	the output buffer
in	the first input buffer
in2	the second output buffer
length	the length of the three buffers

Definition at line 48 of file xor_buf.h.

   {
   while(length >= 8)
      {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
      *reinterpret_cast<u64bit*>(out) =
         *reinterpret_cast<const u64bit*>(in) ^
         *reinterpret_cast<const u64bit*>(in2);
#else
      out[0] = in[0] ^ in2[0]; out[1] = in[1] ^ in2[1];
      out[2] = in[2] ^ in2[2]; out[3] = in[3] ^ in2[3];
      out[4] = in[4] ^ in2[4]; out[5] = in[5] ^ in2[5];
      out[6] = in[6] ^ in2[6]; out[7] = in[7] ^ in2[7];
#endif
 
      in += 8; in2 += 8; out += 8; length -= 8;
      }
 
   for(size_t i = 0; i != length; ++i)
      out[i] = in[i] ^ in2[i];
   }

References xor_buf().

xor_buf() [2/2]

void Botan::xor_buf ( byte out[], const byte in[], size_t length )

inline

XOR arrays. Postcondition out[i] = in[i] ^ out[i] forall i = 0...length

Parameters

out	the input/output buffer
in	the read-only input buffer
length	the length of the buffers

Definition at line 21 of file xor_buf.h.

   {
   while(length >= 8)
      {
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
      *reinterpret_cast<u64bit*>(out) ^= *reinterpret_cast<const u64bit*>(in);
#else
      out[0] ^= in[0]; out[1] ^= in[1];
      out[2] ^= in[2]; out[3] ^= in[3];
      out[4] ^= in[4]; out[5] ^= in[5];
      out[6] ^= in[6]; out[7] ^= in[7];
#endif
 
      out += 8; in += 8; length -= 8;
      }
 
   for(size_t i = 0; i != length; ++i)
      out[i] ^= in[i];
   }

References xor_buf().

Referenced by Botan::Randpool::add_entropy(), aont_package(), aont_unpackage(), Botan::ARC4::cipher(), Botan::CTR_BE::cipher(), Botan::OFB::cipher(), Botan::Salsa20::cipher(), Botan::Turing::cipher(), Botan::WiderWake_41_BE::cipher(), Botan::DESX::decrypt_n(), Botan::Lion::decrypt_n(), Botan::LubyRackoff::decrypt_n(), Botan::PKCS5_PBKDF2::derive_key(), Botan::DESX::encrypt_n(), Botan::Lion::encrypt_n(), Botan::LubyRackoff::encrypt_n(), Botan::MGF1::mask(), operator^(), Botan::OctetString::operator^=(), Botan::Randpool::reseed(), rfc3394_keyunwrap(), rfc3394_keywrap(), xor_buf(), and xor_buf().

zeroise()

template<typename T>

void Botan::zeroise

(

MemoryRegion< T > &

vec

)

Zeroise the values; length remains unchanged

Parameters

vec	the vector to zeroise

Definition at line 428 of file secmem.h.

   {
   clear_mem(&vec[0], vec.size());
   }

References clear_mem(), Botan::MemoryRegion< T >::size(), and zeroise().

Referenced by aont_package(), aont_unpackage(), Botan::AES_128::clear(), Botan::AES_128_NI::clear(), Botan::AES_128_SSSE3::clear(), Botan::AES_192::clear(), Botan::AES_192_NI::clear(), Botan::AES_192_SSSE3::clear(), Botan::AES_256::clear(), Botan::AES_256_NI::clear(), Botan::AES_256_SSSE3::clear(), Botan::ANSI_X919_MAC::clear(), Botan::ANSI_X931_RNG::clear(), Botan::ARC4::clear(), Botan::BigInt::clear(), Botan::BMW_512::clear(), Botan::CAST_128::clear(), Botan::CAST_256::clear(), Botan::CBC_MAC::clear(), Botan::CMAC::clear(), Botan::CTR_BE::clear(), Botan::DES::clear(), Botan::DESX::clear(), Botan::GOST_28147_89::clear(), Botan::GOST_34_11::clear(), Botan::HAS_160::clear(), Botan::HMAC::clear(), Botan::HMAC_RNG::clear(), Botan::IDEA::clear(), Botan::KASUMI::clear(), Botan::Keccak_1600::clear(), Botan::Lion::clear(), Botan::LubyRackoff::clear(), Botan::MARS::clear(), Botan::MD2::clear(), Botan::MD4::clear(), Botan::MD5::clear(), Botan::MDx_HashFunction::clear(), Botan::MISTY1::clear(), Botan::Noekeon::clear(), Botan::OFB::clear(), Botan::Randpool::clear(), Botan::RC2::clear(), Botan::RIPEMD_128::clear(), Botan::RIPEMD_160::clear(), Botan::SAFER_SK::clear(), Botan::Salsa20::clear(), Botan::SEED::clear(), Botan::Serpent::clear(), Botan::SHA_160::clear(), Botan::Skein_512::clear(), Botan::Skipjack::clear(), Botan::Square::clear(), Botan::SSL3_MAC::clear(), Botan::TEA::clear(), Botan::Tiger::clear(), Botan::TripleDES::clear(), Botan::Turing::clear(), Botan::Twofish::clear(), Botan::Whirlpool::clear(), Botan::WiderWake_41_BE::clear(), Botan::XTEA::clear(), Botan::Montgomery_Exponentiator::execute(), Botan::MDx_HashFunction::final_result(), Botan::BigInt::operator+=(), Botan::OctetString::operator^=(), Botan::HMAC_RNG::reseed(), Botan::Record_Writer::reset(), Botan::Montgomery_Exponentiator::set_base(), Botan::CFB_Decryption::set_iv(), Botan::CFB_Encryption::set_iv(), Botan::CTR_BE::set_iv(), Botan::CTS_Decryption::set_iv(), Botan::CTS_Encryption::set_iv(), Botan::OFB::set_iv(), and zeroise().

Variable Documentation

Camellia_SBOX1

const u64bit Botan::Camellia_SBOX1[256]

Definition at line 15 of file camellia_sbox.h.

Camellia_SBOX2

const u64bit Botan::Camellia_SBOX2[256]

Definition at line 81 of file camellia_sbox.h.

Camellia_SBOX3

const u64bit Botan::Camellia_SBOX3[256]

Definition at line 147 of file camellia_sbox.h.

Camellia_SBOX4

const u64bit Botan::Camellia_SBOX4[256]

Definition at line 213 of file camellia_sbox.h.

Camellia_SBOX5

const u64bit Botan::Camellia_SBOX5[256]

Definition at line 279 of file camellia_sbox.h.

Camellia_SBOX6

const u64bit Botan::Camellia_SBOX6[256]

Definition at line 345 of file camellia_sbox.h.

Camellia_SBOX7

const u64bit Botan::Camellia_SBOX7[256]

Definition at line 411 of file camellia_sbox.h.

Camellia_SBOX8

const u64bit Botan::Camellia_SBOX8[256]

Definition at line 477 of file camellia_sbox.h.

CAST_SBOX1

const u32bit Botan::CAST_SBOX1

Definition at line 39 of file cast256.h.

CAST_SBOX2

const u32bit Botan::CAST_SBOX2

Definition at line 40 of file cast256.h.

CAST_SBOX3

const u32bit Botan::CAST_SBOX3

Definition at line 41 of file cast256.h.

CAST_SBOX4

const u32bit Botan::CAST_SBOX4

Definition at line 42 of file cast256.h.

DES_FPTAB1

const u64bit Botan::DES_FPTAB1

Definition at line 504 of file des_tab.cpp.

Referenced by Botan::DES::decrypt_n(), Botan::TripleDES::decrypt_n(), Botan::DES::encrypt_n(), and Botan::TripleDES::encrypt_n().

DES_FPTAB2

const u64bit Botan::DES_FPTAB2

Definition at line 570 of file des_tab.cpp.

Referenced by Botan::DES::decrypt_n(), Botan::TripleDES::decrypt_n(), Botan::DES::encrypt_n(), and Botan::TripleDES::encrypt_n().

DES_IPTAB1

const u64bit Botan::DES_IPTAB1

Definition at line 372 of file des_tab.cpp.

Referenced by Botan::DES::decrypt_n(), Botan::TripleDES::decrypt_n(), Botan::DES::encrypt_n(), and Botan::TripleDES::encrypt_n().

DES_IPTAB2

const u64bit Botan::DES_IPTAB2

Definition at line 438 of file des_tab.cpp.

Referenced by Botan::DES::decrypt_n(), Botan::TripleDES::decrypt_n(), Botan::DES::encrypt_n(), and Botan::TripleDES::encrypt_n().

DES_SPBOX1

const u32bit Botan::DES_SPBOX1

Definition at line 12 of file des_tab.cpp.

DES_SPBOX2

const u32bit Botan::DES_SPBOX2

Definition at line 57 of file des_tab.cpp.

DES_SPBOX3

const u32bit Botan::DES_SPBOX3

Definition at line 102 of file des_tab.cpp.

DES_SPBOX4

const u32bit Botan::DES_SPBOX4

Definition at line 147 of file des_tab.cpp.

DES_SPBOX5

const u32bit Botan::DES_SPBOX5

Definition at line 192 of file des_tab.cpp.

DES_SPBOX6

const u32bit Botan::DES_SPBOX6

Definition at line 237 of file des_tab.cpp.

DES_SPBOX7

const u32bit Botan::DES_SPBOX7

Definition at line 282 of file des_tab.cpp.

DES_SPBOX8

const u32bit Botan::DES_SPBOX8

Definition at line 327 of file des_tab.cpp.

HEX_CODEC_BUFFER_SIZE

const size_t Botan::HEX_CODEC_BUFFER_SIZE = 256

Size used for internal buffer in hex encoder/decoder

Definition at line 20 of file hex_filt.cpp.

Referenced by Botan::Hex_Decoder::Hex_Decoder(), Botan::Hex_Encoder::Hex_Encoder(), and Botan::Hex_Encoder::Hex_Encoder().

MP_WORD_BITS

const size_t Botan::MP_WORD_BITS = BOTAN_MP_WORD_BITS

Definition at line 18 of file mp_core.h.

Referenced by Botan::BigInt::BigInt(), bigint_divop(), bigint_shl1(), bigint_shl2(), bigint_shr1(), bigint_shr2(), Botan::BigInt::bits(), Botan::BigInt::clear_bit(), divide(), Botan::BigInt::get_bit(), Botan::BigInt::mask_bits(), Botan::Modular_Reducer::Modular_Reducer(), operator<<(), Botan::BigInt::operator<<=(), operator>>(), Botan::BigInt::operator>>=(), Botan::Modular_Reducer::reduce(), and Botan::BigInt::set_bit().

MP_WORD_MASK

const word Botan::MP_WORD_MASK = ~static_cast<word>(0)

Definition at line 27 of file mp_types.h.

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

MP_WORD_MAX

const word Botan::MP_WORD_MAX = MP_WORD_MASK

Definition at line 29 of file mp_types.h.

Referenced by divide().

MP_WORD_TOP_BIT

const word Botan::MP_WORD_TOP_BIT = static_cast<word>(1) << (8*sizeof(word) - 1)

Definition at line 28 of file mp_types.h.

Referenced by bigint_divop(), Botan::BigInt::bits(), and divide().

PRIME_TABLE_SIZE

const size_t Botan::PRIME_TABLE_SIZE = 6541

The size of the PRIMES[] array

Definition at line 220 of file numthry.h.

Referenced by primality_test(), and random_prime().

PRIMES

const u16bit Botan::PRIMES

A const array of all primes less than 65535

Definition at line 12 of file primes.cpp.

Referenced by primality_test(), and random_prime().