Surreal Engine Documentation

Crypto++ is a free C++ class library providing a wide range of cryptographic schemes. Supported algorithms include:

• Authenticated Encryption: GCM, CCM, EAX, ChaCha20Poly1305, XChaCha20Poly1305.
• Stream Ciphers: ChaCha (8/12/20, IETF), Panama, Salsa20, Sosemanuk, XSalsa20, XChaCha20.
• Block Ciphers: AES (Rijndael), RC6, MARS, Twofish, Serpent, CAST-256, ARIA, Blowfish, Camellia, and many others (e.g., Triple-DES, TEA, XTEA).
• Hash Functions: SHA-1, SHA-2 (224/256/384/512), SHA-3, SHAKE, BLAKE2s, BLAKE2b, Keccack, etc.
• Public-Key Cryptography: RSA, DSA, ElGamal, and various EC-based schemes (ECDSA, ed25519, x25519, ECDH).
• Key Agreement: Diffie-Hellman (DH), MQV, and others.
• Message Authentication (MAC): HMAC, Poly1305, CMAC, GMAC, SipHash, etc.
• Key Derivation (KDF): PBKDF1, PBKDF2, HKDF, and Scrypt.
• Other Features: Pseudo random number generators (PRNG), Shamir's secret sharing, bignum/polynomial operations, and non-cryptographic utilities like DEFLATE compression and Base64 encoding.

Miniz provides several specialized compression and archive capabilities:

• Zlib/Deflate Compatibility: Implements zlib (RFC 1950) and Deflate (RFC 1951) standards. It is a drop-in replacement for many zlib APIs.
• Stream-based Processing: Unlike block-based compressors, miniz supports stream-based processing using a coroutine-style implementation. The zlib-style API functions can be called one byte at a time.
• Low-level Codecs: The tdefl (compressor) and tinfl (decompressor) low-level APIs use simple state structs that can be saved/restored via memcpy. These APIs do not use the heap.
• Archive Manipulation: Includes a set of APIs for reading, writing, and appending to .ZIP format archives, designed for embedded, mobile, or game development.
• Image Support: Contains functions for writing .PNG format image files.
• Real-time Compression: Includes specialized real-time compressor functions designed to compete with fastlz/minilzo.

Unreal Engine 1 package files use little-endian encoding. The format utilizes several custom data types for compression and string handling:

• Standard Integers: byte (uint8), uint16, uint32, uint64.
• Index: A compressed 32-bit integer. The two high bits of the first byte indicate the sign and if more bytes follow. Subsequent bytes use the high bit to indicate additional data. This allows for efficient storage of small integers while supporting up to 32 bits.
• Name: String encoding depends on the PackageVersion:
  • Version < 64: A zero-terminated list of bytes.
  • Version >= 64: An index representing the size, followed by the string bytes.

// Example of reading the compressed Index type
int32_t ReadIndex()
{
	uint8_t value = ReadByte();
	bool signbit = value & (1 << 7);
	bool nextbyte = value & (1 << 6);
	int32_t index = value & 0x3f;
	if (nextbyte)
	{
		int shift = 6;
		do
		{
			value = ReadByte();
			index |= static_cast<int32_t>(value & 0x7f) << shift;
			shift += 7;
		} while ((value & (1 << 7)) && shift < 32);
	}
	if (signbit)
		index = -index;
	return index;
}

Crypto++ implements several best-effort remediations to resist side-channel attacks (targeting CPU caches and internal buffers), though they may be incomplete due to hardware vulnerabilities like Spectre or Meltdown.

Mitigation Strategies

• Hardware Acceleration: The library uses hardware instructions for block ciphers and hashes where available to mitigate timing attacks.
• Cache-Awareness: Uses cache-aware algorithms and access patterns to minimize cache eviction leakage.
• Spectre: The library does not implement Spectre remediations by default. To use them, add the following GCC options to your CXXFLAGS during the library build:
  • -mfunction-return=thunk
  • -mindirect-branch=thunk

Recommendations for Users

• Disable Hyperthreading: To help resist attacks, it is recommended to disable hyperthreading on your CPUs.
• Report Leaks: If you discover an information leak, please report it to the Crypto++ mailing list.