Assembly is Too High Level: Subtracting by Comparing (Propeller)

If you’re familiar with x86, you’d know that a CMP (compare) instruction is the same as a SUB (subtract) instruction, with exception to the destination operand being written to. In other words, CMP is like a subtract, it just doesn’t write the value when done (but it does set all of the flags that a […]

Assembly is Too High-Level: AAD/AAM, Even the Math is Too High-Level

Oh boy, I love seeing words like these! Even though this post will focus on the AAD instruction, this applies to the below two instructions: I particularly love this one; because we get to see an illustration of abstractions being misleading on a few levels (assembly being too abstract, and even a mathematical formula being […]

Assembly is Too High Level: Propeller NOPs, like if_never 2

This post is not about x86/64, as the title goes, this is about the Propeller architecture. But first, here’s some x86 (hahaha): Note that if you encode the XCHG instruction with EAX, EAX, it would just be 0x90; the exact same machine code as: Sorry to have to put everyone though so much x86 for […]

Obscure FISTing 2

In the realms of assembly obfuscations, this isn’t extremely high in complexity. This is me finding an excuse to use the “FIST” instruction. In the context of the PoC, it is being used as a decoder for some encoded shellcode. Before going into the super technical details, below is a video of the PoC in […]

Assembly Is Too High Level: Undocumented Code Exploration

With an assembler, your code gets assembled into machine code. All valid assembly instructions should be translated to corresponding machine code bytes. But in reverse, not every possible byte sequence is something that can be produced from assembly source. There a few categories of reasons for this: Reason 1:   Simple redundancies. XOR EAX, EAX […]

Assembly Is Too High-Level: Full Offsets

This is one of those times were I get kind of annoyed that what I tell my ‘high-level’ language gets ‘interpreted’ for me, because it knows better. I feel this post may be slightly less arbitrary than the rest; in the sense that the machine-level hack covers something that you should be able to use, […]

Assembly Is Too High-Level: Better Call SAL

  When it comes down to it, this is logically true. But it seems like everything tries to sweep SAL under the rug, therefore: I WANT!     I get it, it’s the same thing. And for the record, I verified that they operate exactly the same down to the eflags being set identically. Lets […]

Assembly Is Too High-Level: OP REG,imm redundancies 3

About a week ago I came accross one of Ange’s pages ( Before that point I only knew him as a major contributor to my favorite zine (PoC||GTFO) and author of some very useful technical info-graphics; his ELF diagram jump started my ability to create my script. Looking at his x86 oddities page, it looks […]

How to Machine 1

I’ve been making a few posts on how I find situations where assembly language would be too high-level, almost to the point of evangelizing it. However, I realized that I have not yet gone into any kind of explanation on exactly what tricks I am using to directly code in machine code. There are actually […]

Bass + Computer 1

Summary: While I was at the NYC 2600 this month (September), I was talking with someone involved in chiptunes and it reminded me of one of my ‘secret’ projects that I somehow forgot to mention more publicly. This was a project that I put together all the way back in 2008/2009 (hardware/software respectively). Pretty much […]