Keith Makan

ELF Files are charged with using their magic to perform two holy tasks in the linux universe. The first being to tell the kernel where to place stuff in memory from the ELF file on disk as well as providing ways to invoke the dynamic loaders functions and maybe even help out with some debugging information. Essentially speaking its telling the kernel where to put it in memory and also the plethora of tools that interpret the file where all the data structures are that hold useful information for making sense of the file. Anyway that's as far as I've figured it out - the actual break down is a little less simple.

I'll demonstrate why this is so here and over the next series of posts in the classic "Learn things by breaking them" style.
ELF Header and Identification fields The first thing that appears in an ELF file is of course the header, which is like most things in file formats just a list of offsets in the file. Its purpose is to indicate essentially what kin…

Glibc Heap Exploitation Basics : Introduction to ptmalloc2 internals (Part 1)

In this post and the others in this series, I will unpack some of the internals to glibc's dynamic heap data structures and associated beasts. This post specifically will start you off with no background insight on the heap (perhaps a little on ELF internals and debugging), and detail some experiments you can perform to learn how the heap works.

Introduction
The Heap is essentially a list of memory regions an executing program uses to store data. The data stored in heap regions are requested during runtime. It allows runtime environments like glibc to offer programs dynamic memory for allocating data. So because this offer's memory regions as kind of a "service" (this is what it is for - giving out memory regions), it must mean some where in this whole mess, there needs to be some accounting information about the memory regions. To this aid; the heap describes or decorates user data regions with an internal structure called a chunk. Chunks are in turn classified an…

Introduction to the ELF Format (Part VI) : The Symbol Table and Relocations (Part 1)

This post is part of a series on the ELF format, if you haven't checked out the other parts of the series here they are:

(Part I) : ELF Header https://blog.k3170makan.com/2018/09/introduction-to-elf-format-elf-header.html (Part II) : Program Headers https://blog.k3170makan.com/2018/09/introduction-to-elf-format-part-ii.html (Part III) : Section Header Table https://blog.k3170makan.com/2018/09/introduction-to-elf-file-format-part.html (Part IV) : Section Types and Special Sections https://blog.k3170makan.com/2018/10/introduction-to-elf-format-part-iv.html(Part V) : C Start up https://blog.k3170makan.com/2018/10/introduction-to-elf-format-part-v.htmlthis
In this and the next post I'm going to explore how Elf files manage to pull off the magic of symbol resolution as well as the format, offsets and records in the Elf that represent this information. There are many facets to this mechanism in the format, and before I get into each of them I'd like to provide a gentle intro …

Introduction to the ELF Format Part II : Understanding Program Headers

Welcome back folks! In the previous post I covered pretty much the most trivial parts of the ELF file format. In this post we are actually going to work with one of the most interesting mechanisms in the file - the program headers! I skipped some parts of the ELF header in the previous post and decided to cover them here specifically because they inform on the Program Headers anyway. Lets get started!
Introduction : What are Program Headers?
I mentioned in part 1 that the ELF format performs two tasks. A recipe for how to sublimate dead files into living processes and adds the bells and whistles needed to make the file look pretty to gdb, the dynamic loader and a bunch of other tools. Program Headers (among other functions) are more often for telling the memory loader where to put stuff. It also has some house keeping functions.

We'll get into how these memory loading powers and formats work a little later for now its just important to keep in mind a good idea of what to expect …

Introduction to the ELF Format (Part V) : Understanding C start up .init_array and .fini_array sections

This post is part of a series on the ELF format, if you haven't checked out the other parts of the series here they are:

(Part I) : ELF Header https://blog.k3170makan.com/2018/09/introduction-to-elf-format-elf-header.html (Part II) : Program Headers https://blog.k3170makan.com/2018/09/introduction-to-elf-format-part-ii.html (Part III) : Section Header Table https://blog.k3170makan.com/2018/09/introduction-to-elf-file-format-part.html (Part IV) : Section Types and Special Sections https://blog.k3170makan.com/2018/10/introduction-to-elf-format-part-iv.htmlthis
In this post I'm going to cover how some of the aspects of C start up and mess around with the .init_array and .fini_array sections to show how they work.

C Start Up
So something must happen to get your code in the main function running. This process is called the C start up and it essentially involves running all the initialize code, setting up pointers to some important arrays and then branching over to main.

What the…

The Science of Google Dorking

In this post I'm in proposing some new and improved Google dorks for hackers/pentesters and generally any one that likes finding web based targets based on the vulnerabilities they expose, the dorks I will discuss here include servers exhibiting:

Local file inclusion / Remote File inclusion vulnerabilitiesSQL injectionError based injection

Glibc Heap Exploitation Basics : ptmalloc2 internals (Part 2) - Fast Bins and First Fit Redirection

This post is part of a series, check out the others in the series here:

Introduction to ptmalloc2 internals (Part 1) - https://blog.k3170makan.com/2018/11/glibc-heap-exploitation-basics.html(this) As I mentioned in the previous post the heap management will keep meta-data about the free chunks in case these chunks can be reallocated. To improve my language from the last post as well I should mention that there are different kinds of lists to manage different sizes of free chunks, namely:

Unsorted Bin - This is basically a list that is meant to temporarily hold any chunks that don't fit into the Fast, Large or Small bin categories. To quote some random persons paper about this:When freeing chunks not in the range of fastbin, they are inserted into unsorted bin at first rather than the small bins or large bins - https://loccs.sjtu.edu.cn/wiki/lib/exe/fetch.php?media=gossip:overview:ptmalloc_camera.pdf Small bins - again, as with many things this is just another list or group of lists …

Labels

About.me
addJavascriptInterface
Adult Swim
AI.
Alan Turing
Altcoin
Androguard
Android
Android Application Hacking
Android Application Security

Android Hacking
Android Secure Random vulnerability
Android Security
Anonymity
Application Vulnerabilities
ARM
Bit Substring-ing
Bitcoin
Blind MySQL injection
Blind SQL injection
Blind SQLi
Blind-Error Based Injection
Block Chain
Block Ciphers
Blockchain
Blogger.com
Blogger.com vulnerability
Browsers
Cartoons
Cascading Style Sheets
Chrome
Chrome 19
Chrome 19 XSS bypass
Computation
Computer Science
conciousness
Content Providers
Cookie Precedence
Cramfs
Critical Theory
Cross Site Request Forgery
Cross Site scripting
Cryptanalysis
Cryptocurrency
Cryptography
CSRF
CSS
CSS Cross Origin
Debate
Dialectic
Dynamic Linking
Dynamic Loading
Egyptian Magic
ELF
ELF Format
Embedded
Embedded ARM
Embedded Linux
Encryption
Error Based MySQLi
Ethics
Executable Formats
Executable Linkable Format
Existentialism
Exploit Development
Fast Blind SQL injection
Field Programmable Gate Arrays
File Explorer (FX)
Filter Evasion
Firefox
Firmware
FPGA
GDB
George Cantor
Global Offset Table
GooDork
Google
Google Dorking
Google Hacking
Google Web Cache
Hacking
Hardware
Hardware Engineering
Hardware Reverse Engineering
Hash Length Extension Attacks
Hashing
HDL
Heap
Heap Exploitation
Hegel
Homomorphic Encryption
HTML5
HTTP Response Splitting
ICEStick40
infomration gathering
information gathering techniques
Information Security
InfoSec
Internet
IO File Manager
Java
Javascript
k3170makan
Kurt Godel
Lacan
Lattice FPGA
LFI
Linux
Linux Exploit Development
MACS
Magic
Man in the Middle Attack
Masked Bit Shifting
MD5
Memory Corruption
Merkle-Trees
Message Authentication Codes
Meta-analysis
Mirror Phase
MITM
Mixed Display
Mixed Scripting
Mixed Scripting Vulnerability
Morty
MySQL
MySQLi
Mysticism
Next Browser
NoScript
NoScript Bypass
Occult
Ontology
Open Source
Opera
Padding Oracle
Path Traversal Vulnerability
penetration testing
Phenomenology
Philosophy
Philosophy of Hacking
Philosophy of Software
PHP
Physics
Privacy
PRNG
Procedure Linkage Table
Pseudo Random number security
Psychology
ptmalloc
ptmalloc2
Relocation
Reverse Engineering
Reverse Engineering ARM
Reverse Engineering Black Lists
Reviews
RFI
Rick
Rick 'n Morty
Rights
Robots
Safari
Same Origin Policy
Sartre
Sci-Fi
Scroll of Ani
Security
Security Testing
Set Theory
SHA-1
SHA-2
Shared libraries
SharedPreferences
Simulation Theory
Smart File Manager
Software
SQL Exploitation
SQL injection
SQLi_XSS
Structured Exception Handler
Theoretical Physics
Theory of Computation
Threat Modelling Android Applications
Time based SQLi
Trident
TV Review
TV Reviews
Tv Show
UART
Understanding ELF Format
Vaudenay
Verilog
Video Formats
W3 Total Cache
Web Attacks
Web Hacking
Web Security
WebKit
WebView
WebViewClient
WebVTT
whitehats
WinDBG
Windows
Windows Exploit Development
Word Press
Word Press CSRF
Word Press Exploit
Word Press Photo Album Plus
Word Press Plugin
Word Press Vulnerability
Word Press W3 Total Cache Vulnerability
Word Press XSS
Wppa
XSS
XSS Filter by pass
XSS Filters
XSSAuditor
XSSSQLi

Show more Show less

Report Abuse

Keith Makan