top of page

Binary Executables Hacking: A Dive Into Binary Exploitation

Binary exploitation is a fascinating area of cybersecurity where attackers leverage vulnerabilities in binary programs to control or corrupt their behavior. In this blog, we'll explore the basics of binary executables hacking and discuss some classic vulnerabilities with examples.

What is a Binary Executable?

A binary executable is a compiled program that can be run by a computer without the need to be read or processed by a compiler or interpreter. These executables are primarily written in languages like C or C++ and then compiled down to machine code.

Why Hack Binary Executables a.ka Binary exploitation ?

Understanding how to exploit binaries provides valuable insights into how software vulnerabilities occur, how attackers exploit them, and how developers can prevent them.

Classic Vulnerabilities

1. Buffer Overflow

One of the most infamous types of vulnerabilities. It occurs when data is written to a buffer and exceeds its bounds, potentially overwriting adjacent memory.


#include <stdio.h>
#include <string.h>

void giveFlag() {
    printf("You got the flag!\n");

void echo() {
    char buffer[64];
    gets(buffer);  // Vulnerable function!
    printf("You said: %s\n", buffer);

int main() {
    return 0;

In this example, the gets() function doesn't check the size of the input, leading to a potential buffer overflow. An attacker can overwrite the return address to execute the giveFlag() function.

2. Format String Vulnerability

Occurs when uncontrolled user input is used as a format string in functions like printf.


#include <stdio.h>
int main() {
    char buffer[100];
    printf("Enter a string: ");
    gets(buffer); // Unsafe input
    printf(buffer); // Vulnerable print 
    return 0;

An attacker can input format specifiers (e.g., %x) to leak memory or %n to write to memory.

3. Integer Overflows

When an integer variable in a program is made to go out of its bounds, it can result in unexpected behavior.


#include <stdio.h>
#include <stdlib.h>

int main() {
    unsigned int size;
    printf("Enter the size of the data you want to input: ");
    scanf("%u", &size);

    if(size > 1000) {
        printf("Size too large!\n");

    char* data = malloc(size);
    // ... rest of the program

If an attacker inputs a value close to the maximum value of an unsigned integer, it may wrap around and allocate a small buffer, leading to potential overflows.

Tools of the Trade

  1. GDB: The GNU Debugger is essential for examining binary behavior.

  2. Ghidra/IDA Pro: For advanced binary analysis and reverse engineering.

  3. Checksec: Checks binary hardening settings.

  4. ROPgadget: Helps in finding ROP (Return Oriented Programming) gadgets.

  5. pwntools: A Python library that provides utilities for binary exploitation.

Mitigations and Protections

Over the years, multiple defense mechanisms have been devised:

  1. ASLR (Address Space Layout Randomization): Randomizes memory addresses to make exploits harder.

  2. DEP/NX (Data Execution Prevention/No Execute): Marks memory regions as non-executable.

  3. Canaries: Uses random values to detect stack buffer overflows.

  4. Safe functions: Always prefer using fgets() over gets(), snprintf() over sprintf(), etc.


Binary exploitation is a challenging yet rewarding domain in cybersecurity. While the above examples provide a glimpse, the real-world scenarios are much more complex and intricate. Dive deeper, practice, participate in CTFs, and always remember to use your knowledge ethically!



Get Started with Listing of your Bug Bounty Program

  • Black LinkedIn Icon
  • Black Twitter Icon
bottom of page