The executable runs with the privileges of the file owner instead of those of the calling user (e.g., with root privileges if it is owned by root)

A C3 is a near return. It is equivalent to

pop rip

Near call of addr is equivalent to

push rip
jmp addr

• Overwriting local variables
• ret 2 win
• ret 2 shellcode buffer

A remote bind shell opens a socket with a shell at a port on the victim machine. The problem is that firewalls might block exposing a port online

The attacker opens a port on their system and lets the victim machine connect to it. Less likely to be blocked by a firewall, especially when using inconspicuous ports like 80

An offset relative to the base, when the function is loaded into memory. It is not a file offset. RVA + base address = effective address

1. Unnatural use of bytes (not alphanumerical), no English words, bad grammar
2. Signature for common decoders
3. Dynamic execution

⇒ We have to know the address of this instruction, and not a stack address. Find gadget.

The address to a single ret

• Find string in program and gadget that loads address of it into register
• Place string on stack. Get stack address into register

Data Execution Prevention (DEP) #

• Mark writable memory as non-executable (NX)
  • W^X (write XOR eXecute)

ASCII Armor #

• For a 32-bit address space, place executable code at addresses with at least one 00-byte
• Prevents copy of ROP chain with str* functions
• In a 64-bit address space, we always have 00-bytes at the beginning of the address for user space addresses.

How to bypass this mitigation?

Null bytes can be generated with ending a string. Multiple null bytes with empty strings.

When redirecting the stack pointer to the environment, we need to be careful, so that the stack stays aligned

Dynamic Linking #

External function call steps:

• Call PLT

call 401030 <puts@plt[1]>

• PLT contains code

plt[0]:  ; special plt entry. Calls dynamic linker
push [rip+0x2fe2]
jmp [rip+0x2fe4]  ; dynamic linker call
										 ; Updates GOT entry with external function address.
										 ; The dynamic linker also calls the function.
										 ; Due to the ret the execution continues at the original call.
nop  ; never executed
puts@plt[1]:
jmp [rip+0x2fe2]  ; GOT entry (initially points to address of init_plt)
init_plt: push 0x0  ; index of GOT entry
jmp plt[0]

• On the next call, the GOT entry already contains the external function address.
• The code after init_plt will not be executed, because the function ends with return and will go back to the original call

ASLR Randomness #

How much entropy does ASLR give us on 64-bit?

But not uniformly distributed!

High correlation between sections

ASLR Secrecy #

Examples for ASLR Secrecy leaks

• Address leaks in crash logs with stack traces, debug messages, etc.
• Direct address leaks of the program, e.g. format string vulnerabilities
• Implementation issues
  

  

Explain the discussed ActionScript vulnerability that allowed defeating ASLR

Re-randomize the binary on crash/code probing

Problem: System-wide sharing of randomized binaries

Stack canary stored in thread descriptor (glibc!tcbhead_t), which is in the general purpose segment fs.

• Stack canary is accessed via segment register fs:0x28
  ⇒ The canary does not lie at a fixed address, so it can’t simply be read from a known address

• terminator canary: Fixed value composed of string terminators
  • Ineffective against non-str*-based overflows
• Random canary
  • Ineffective against direct write into controllable area
• Random XOR canary
  • Stack canary is XORed with control area
  • Higher run-time overhead

• The glibc canary is a random canary whose least significant byte is a null byte (the first byte in memory on little-endian x86), so string functions can neither leak it nor copy past it

• If read-primitive available
  • Retrieve canary from current stack frame
  • Retrieve reference canary
• Byte-by-byte attacks
  • forked processes share canary value
• Don’t overwrite canary. With direct write primitive, just overwrite return address
• Overwrite pointer to reference canary in local function

• Copy arguments at top of stack frame
• Place buffers below other local variables
  • Reordering does not happen for structs

Only allow valid edges in CFG. Each callee checks if caller is valid. Caller checks if return happened from callee.

• Generally undecidable
• Even if solution exists, high run-time overhead

Can be further mitigated by strict CFG, which does not allow non-CFG modules

Once enabled (the program can choose the point in time), the process can no longer allocate new executable memory or make existing code writable (no W+X). This closes the gap left by CFG, where an attacker could otherwise inject and run new code.

https://www.ndss-symposium.org/wp-content/uploads/2018/02/ndss2018_05A-3_Biondo_paper.pdf

Hundreds of PR- and S-gadgets on modern Windows 10
Spread over important system and program DLLs (msvcrt.dll!)
Applicability shown for (legacy) Edge browser

• Make sure that return address can’t be tampered with
• Have a shadow stack that stores the return addresses and compare with return address on actual stack

RFG weaknesses

• Hardware-enforced coarse-grained CFI
  • Verifies address is any legitimate indirect jump target
• Joint development of Microsoft and Intel

• Features:
  • Indirect Branch Tracking (IBT), protects forward edge
  • Hardware enforced shadow stack (SS), protects backward edge

• Mark valid jump targets with new instruction: ENDBR{32/64} instruction
  • ENDBR must be executed after indirect call
  • Interpreted as NOP on old CPUs
  • Encoded as a 4-byte instruction (ENDBR64: F3 0F 1E FA)
  • No-track prefix 0x3E can be set for call/jmp to exclude from ENDBR checking for near calls
• ENDBR is implemented with state machine in CPU
  

  

  • separate state machines for kernel and user mode
  • System call entries are marked with ENDBR. So the kernel state machine is always in wait on entry.
  • For thread switches, the state machine is saved as part of the context
• Legacy code support with a bitmap of page granularity
  • Linux does not implement legacy support

• Hardware Shadow Stack (SS)
  • New internal register
  • can’t be accessed directly. Only the following operations are possible
    • incssp reg Increment SSP by 4/8*reg[7:0]
    • rdssp reg Read SSP into general-purpose register
    • wrss reg/[mem] Write content to shadow stack at SSP (Can be disabled)
    • wruss reg/[mem] Write content to user shadow stack at SSP (kernel instruction)
  • Shadow stack pages are marked as read only, write can only happen to save return addresses. Implemented by setting the dirty and read only bit for page.
• Shadow stack switching
  • rstorssp [mem] and saveprevssp
  • Implemented via shadow stack tokens

• Arithmetic overflow
• Signedness bugs
• Truncation

void *calloc(size_t nmemb, size_t size)

Infer secret data by observing artifacts of execution across security domains.

Examples: Timing, cache, power-analysis, electromagnetic measurements

• Construct an array of 256 pages in memory (probing array)
• Register a SIGSEGV handler that suppresses the segmentation fault caused by the illegal access
• Flush the probing array pages
• Use a byte in kernel memory as index into the array and make the access
• Go through all pages in the probing array and measure how long it takes for the page to load
  • Surround page access with memory fence (mfence instructions) to prevent reordering of the timing measurement
• The kernel byte value is the index to the page that took the least time to load
• (Because of 0-bias, the CPU assumes 0 as index for speculative execution, do multiple retries)

• Mitigation for meltdown
• Have user page table and kernel page table
  • Separate page global directories
  • Switch by toggling 12th bit in CR3 register
• Only map kernel page that is required for entry into the kernel
• We can also use process-context identifier bits (PCID, 12 bits) to reduce overhead

• Performance overhead because of TLB flush

• Train the branch predictor to predict with legal indices in array1.
• Clear caches
• Then make an out-of-bounds access to an illegal address relative to array1
• Analyze the access speed of array2

#define PAGESIZE 4096
unsigned int array1_size = 16;
uint8_t array1[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
uint8_t array2[256 * PAGESIZE];
uint8_t y;
void victim_function(size_t x) {
   if (x < array1_size) {                 // this comparison is exploited via branch misprediction
       y &= array2[array1[x] * PAGESIZE]; // the access to array2[] loads a page into the cache whose address
   }                                      // depends on the value of array1[x]. This is the covert channel.
}

• Do not offer precise timers
  • Ineffective, because a precise timer can be constructed in many ways
• Isolate processes on other hyperthreads
• memory fences
  • Throws away speculative execution speedup, if used too frequently
  • No solution exists to detect critical points to insert (Microsoft tried and failed)