Fixed a spurious warning on some compilers.

Added support for getrandom()/getentropy(), and a fix for the RDRAND bug on AMD CPU (family 22).

Fixed mishandling of UTF-8 codepoints in the FDF0..FEDF range (these were unduly rejected when extracting names from certificates, thereby preventing use of the extra presentation forms of Arabic).

Fixed efficiency pre-test on RSA prime generation (no security issue, but RSA key generation with pubexp 5, 7 or 11 may be slightly more efficient).

Normalize use of BR_DOXYGEN_IGNORE.

Small workaround for CompCert compatibility.

Fixed computing of intermediate buffer size for maximum-size RSA keys.

Added detection for MIPS64 with n32 ABI.

Some small performance improvements on 32-bit architectures.

Fixed fd leak in test code.

Made m64 implementations of elliptic curves the default (when available).

Added new 64-bit implementations of Curve25519 and P-256.

Made ec_c25519_m62 implementation the default on supported architectures.

Fixed endianness in Curve25519 implementation (no consequence on security). Also added new Curve25519 code for 64-bit platforms.

Cosmetic fix (value did not conform to its announced bit length, but this did not have bad consequences since br_i31_decode_mod() is lenient on that).

Changed speed benchmark for i31 to a 521-bit modulus.

Fixed warning on GCC 4.6 to 4.9 (macro redefinition).

Added stand-alone RSA/PSS implementation.

Added SHAKE implementation.

Some documentation fixes.

Added generic HKDF implementation.

Added POWER8 implementation for AES/CTR+CBC-MAC (for CCM and EAX modes).

Made Base64 decoding constant-time (with regards to actual data byte contents).

Added support code for RSA and EC key encoding (including reconstruction of all public and private key elements from the private key structure), with raw and PKCS#8 formats, both in DER and PEM.

Added AESCTR_DRBG implementation (beta).

Added RSA key generation code (i15, i31, i62).

Fixed computation of product size.

Added support for CCM and CCM_8 cipher suites.

Added guard code to avoid issue when decoding PEM but not keeping data.

Fixed some typographic errors in comments.

Small typo fixes (harmless).

Added RSA/OAEP implementation.

Added stricter rule on input for RSA private key operation (mathematically correct but out-of-range values are now rejected).

Made client stricter in cipher suite selection (better consistency with server behaviour).

Fixed bug in bit length computation (implied some wrong RSA signatures in case of carry propagation with some specific key/factor lengths).

Simple documentation fix.

Added API to share precomputations in EAX.

Fixed test code (removed static reference to aes_x86ni code).

Make Rules.mk more compatible with merges and local diffs.

Added generic EAX and CCM implementations.

Worked around some compiler errors with GCC 4.4 and 4.5.

Added seeder API. Also overhauled compile-time detection of features.

Switch C compiler to the generic 'cc' (to use the default compiler, not necessarily GCC -- this is for systems that offer both GCC and Clang, and use Clang as default).

Extra Makefile hack for compatibility with OpenBSD 'make'.

Some more extra casts to avoid alignment warnings with Clang and -Wcast-align on 32-bit systems with 64-bit alignment requirements (e.g. ARMv7).

Added intermediate casts to void* to prevent spurious warnings (with Clang and -Wcast-align).

Some more renaming to avoid shadowing.

Some renaming to avoid spurious warnings on some old GCC versions.

Fixed documentation (new include file for AEAD).

Added Twrch support.

Fixed br_ssl_session_cache_lru_forget().

Added name for new ChaCha20 implementation.

Added ChaCha20 implementation with SSE2 opcodes.

Added function to forget saved session parameters (for tests).

Added general-purpose API for AEAD algorithms, and GCM implementation.

Fixed behaviour in case of rejected renegotiation.

Fixed selection of ECDHE_RSA suites for pre-1.2 TLS versions.

Added implementation of keying material export (RFC 5705) (API for PRF implementations changed, to handle chunked seeds).

Fixed modular reduction bug in the special field for P-256 (in some rare cases, value would end up being negative, which would corrupt subsequent operations).

Fixed mishandling of tree structure in the cache for session parameters.

Added an explicit initialisation to a stack buffer to prevent an (harmless) uninitialised read reported by valgrind.

Fixed IV processing for CBC decryption with AES (x86ni implementation) when data length is not multiple of 64 bytes (the bug was breaking TLS 1.0 AES/CBC on recent x86 systems).

Added encoded OID for hash functions (for use with PKCS#1 v1.5 signatures) into the public API.

Fixed proper handling of clients with no "secure renegotiation" support.

Fixed handling of incoming application data after sending a close_notify (data shall be discarded silently, not trigger an error). Also fixed a couple of bugs in the command-line test tool.

Added minimal support of Certificate Policies extension (ability to ignore its contents even if marked critical, in situations where it's safe to do that).

Small fix on sample server code (displaying of IPv6 addresses).

Workaround for compiler bug (GCC 4.8 and 4.9 when targetting 32-bit x86).

When using Clang, use it also for linking (compatibility with core FreeBSD systems).

Made headers compatible with C++.

Documentation fixes.

Small patch to allow compilation on old systems that predate the IPV6_V6ONLY option (Debian 2.2 "potato").

Small improvement to tolerate PEM files missing the terminating newline in the brssl command-line tool.

Fixed typo in C preprocessor expression.

New "i62" code for big integers with 64x64->128 opcodes; also improved "i31" modular exponentiation.

Optimised code for encoding/decoding integers when the underlying architecture has the right endianness and allows unaligned accesses.

Added "ctmulq" implementation of Poly1305 (using 64->128 multiplications when available).

Fixed compilation for GCC 4.4 to 4.8 (AES-NI opcodes; intrinsics headers require target options to be set).

Improved GHASH pclmul implementation (parallel processing of four blocks, +70% speed).

New AES and GHASH implementations using POWER8 crypto opcodes.

Cosmetic fixes in comments.

Added AES+GHASH implementation using AES-NI opcodes; also ARM-Thumb assembly for faster Montgomery multiplication on Cortex-M0+. Added selection functions for "default" implementations.

Improved modular exponentiation (automatic window optimisation if there is enough room).

Slight speed improvement for Curve25519 (m15 implementation on Cortex-M0+).

New Makefile structure; added compatibility with Windows + Visual C + nmake.

Some cleanups (removed unused files, split i15 code into per-function files).

Added optimised implementation of P-256 that uses 32->64 multiplications (MUL31).

Two new Curve25519 implementations (generic "i31" code, and optimised code with MUL31).

Activated Curve25519 support for ECDHE cipher suites.

New implementation of Curve25519 (using multiplications of words of 15 bits or so, should be much faster on Cortex M0).

New basic implementation of Curve25519 (generic i15 code, experimental).

Added API for external hashing of ServerKeyExchange, and signature algorithm identifiers in the 0x080* format (preparatory steps for EdDSA support).

More optimisations for EC P-256 "i15" (specialised squaring function, mixed coordinates addition with a 4-bit window when the base point is the conventional generator).

Improved performance on dedicated P-256/i15 EC implementation.

Simple grammar fix in header.

Fixed wrong check on length overflow (unsigned/signed issue).

Two new Poly1305 implementations: ctmul32 uses pure 32-bit multiplications (MUL15, constant-time on about everything); i15 uses the generic i15 big integers (MUL15 again), which is quite slow but also small.

New "i15" implementation of big integers (faster, and constant-time, on ARM Cortex M0/M0+); imported into EC, ECDSA, RSA.

New experimental EC implementation (P-256, only 32-bit multiplications, meant for Cortex-M0/M0+).

Fixed RSA "i32" PKCS#1 v1.5 signature generation.