Appendix K: ASCII, Encoding, and Number Reference

ASCII Table (0–127)

Control Characters (0–31)

Printable Characters (32–127)

Key ASCII Ranges (useful for validation code)

UTF-8 Encoding

UTF-8 is the dominant text encoding on the internet and in Linux systems. It is a variable-width encoding of Unicode code points.

Encoding Rules

The leading byte type is identified by its high bits: - 0xxxxxxx: single-byte (ASCII range) - 110xxxxx: start of 2-byte sequence - 1110xxxx: start of 3-byte sequence - 11110xxx: start of 4-byte sequence - 10xxxxxx: continuation byte

Examples

Assembly: Testing for ASCII vs. Multi-byte UTF-8

; Test if a byte is ASCII (single-byte UTF-8):
test    al, 0x80        ; if bit 7 is 0, it is ASCII
jz      .is_ascii

; Test if a byte is a UTF-8 continuation byte:
and     al, 0xC0
cmp     al, 0x80        ; 10xxxxxx = continuation
je      .is_continuation

Number Base Conversion Reference

Powers of 2

Hexadecimal Quick Reference

Two's Complement Quick Reference

For an N-bit signed integer: - Range: -2^(N-1) to +2^(N-1) - 1 - Negative number: invert all bits, add 1

Common Small Negatives in Hex (32-bit and 64-bit)

When you see a value like 0xFFFFFFFFFFFFF000 as a return value from a system call, it is -4096 = -0x1000, which is the error code -ENOMEM (negated errno 12) if it's in the expected error range, or a valid large address if it's from mmap.

Byte Order (Endianness)

Little-Endian (x86-64, ARM64, RISC-V default)

The least significant byte is stored at the lowest address. The value 0x0000000000401160 in memory (as stored by x86-64):

Address:  0x7fff0000  0x7fff0001  0x7fff0002  0x7fff0003  0x7fff0004  0x7fff0005  0x7fff0006  0x7fff0007
Value:    0x60        0x11        0x40        0x00        0x00        0x00        0x00        0x00

Reading left to right: 60 11 40 00 00 00 00 00 is 0x0000000000401160 in little-endian.

Big-Endian (network byte order, some MIPS/SPARC configurations)

The most significant byte is stored at the lowest address. The same value 0x0000000000401160 big-endian:

Address:  0x7fff0000  0x7fff0001  ...  0x7fff0007
Value:    0x00        0x00        ...  0x60

Conversion in Assembly (x86-64)

; Swap bytes of RAX (convert between endianness):
bswap   rax         ; reverse byte order of 64-bit register
bswap   eax         ; reverse byte order of 32-bit register (clears upper 32 bits)

Python Packing Conventions

import struct

# Little-endian (x86-64, ARM64):
struct.pack('<Q', 0x401160)   # b'\x60\x11\x40\x00\x00\x00\x00\x00'
struct.pack('<I', 0x401160)   # b'\x60\x11\x40\x00'

# Big-endian (network):
struct.pack('>Q', 0x401160)   # b'\x00\x00\x00\x00\x00\x40\x11\x60'

# pwntools:
from pwn import p64, p32, u64, u32
p64(0x401160)                  # little-endian 8 bytes
u64(b'\x60\x11\x40\x00' + b'\x00' * 4)  # unpack

IEEE 754 Floating-Point Quick Reference

Single Precision (32-bit, float)

Special values: - 0x7F800000 = +Infinity - 0xFF800000 = -Infinity - 0x7FC00000 = NaN (quiet) - 0x00000000 = +0.0 - 0x3F800000 = 1.0 - 0x40000000 = 2.0 - 0x3F000000 = 0.5

Double Precision (64-bit, double)

Special values: - 0x7FF0000000000000 = +Infinity - 0x3FF0000000000000 = 1.0 - 0x4000000000000000 = 2.0 - 0x3FE0000000000000 = 0.5

Assembly: Examining Floats

; Store float 1.0 to memory and read back as integer:
mov     DWORD [rsp - 4], 0x3F800000   ; 1.0f as raw bits
movss   xmm0, DWORD [rsp - 4]         ; load as float

; Convert float to integer representation in GDB:
; (gdb) p/f $xmm0.v4_float[0]         shows as 1.0
; (gdb) p/x $xmm0.v4_int32[0]         shows as 0x3f800000