Example of Self modifying ASM code :P

Here's a simple code that modifies one of its instructions when certain conditions are met. (like changing an add instruction to a subtract)
I dunno I was just bored XD

Press L+R to add to your bells if less than 99,900. If it is more than 99,900, it'll start subtracting instead, until it reaches 100 or less. It'll keep going back and forth :P

Code:

---

023FF090 012FFF11
E0000000 00000040
E28F2001 E12FFF12
8800480A 01122230
D10D4210 68214C08
42A94D08 2339DB01
2964E002 2331DC02
7053A200 60213164
00004770 04000130
021D891C 0001863C
023FF090 E3520003

---

ASM source:

Code:

---

@convert to thumb
add r2,pc,#1
bx r2
.thumb

ldr r0, IOKeys
ldrh r0, [r0]

@Activate if L+R pressed
mov r2, #0x30
lsl r2, #0x4
tst r0, r2
bne Exit

ldr r4, Bell_Amount
ldr r1, [r4]
ldr r5, TestAmount

@Check if bells 99,900 or more
cmp r1, r5
blt CheckZero

@#0x39 is value for sub r1
mov r3, #0x39
b StoreInstruction

@check if bells 100 or less
CheckZero:
cmp r1, #100
bgt AddOrSubtract

@#0x31 is value for add r1
mov r3, #0x31

StoreInstruction:

@store instruction
adr r2, AddOrSubtract
strb r3, [r2, #1]

AddOrSubtract:
add r1, #100
str r1, [r4]
Exit:
bx lr

.arm
IOKeys:
.long 0x4000130
Bell_Amount:
.long 0x21D891C
TestAmount:
.long 0x1863C

---

It works a lot easier in ARM mode, but...it's just an example.

From the looks of the source, I'm assuming 'adr' points to AddOrSubtract label.

Neat. So it kind of cycles through to the amount you need?

I think his code adds 100 bells to your current amount until you reach 99,000. After that, the code subtracts 100 bells until you get to 100 bells then it adds back up to 99,000 bells and keeps repeating itself.

In regular ARM mod, you could just the pc to overwrite any instruction. In THUMB it says it's not allowed (cause the pc is r15)
(the pc stands for program counter, it basically tells where the next instruction to be executed is)
In ARM everything is 32 bit though, including the instructions, so it'd take up more room, but it's definitely more powerful.
Like, let's say in ARM you wanted to overwrite the very next instruction. Let's say r5 has the instruction you wanna write. To overwrite the very next instruction you'd put....
str r5, [pc, #-0x4]

to overwrite the instruction after that instead
str r5, [pc]
etc.

I don't know about "self-modifying". Makes it sound like polymorphism. It's more like an ASM switch case.

Quote:

---

Originally Posted by Vash

I don't know about "self-modifying". Makes it sound like polymorphism. It's more like an ASM switch case.

---

Well, it might not be exactly, but...
according to wikipedia
"In computer science, self-modifying code is code that alters its own instructions while it is executing."
and that alters a single instruction while executing XD (it directly overwrites an "add" instruction with a "subtract" instruction, or vice versa)
Although I'm probably wrong, you're the more advanced hacker.

Self modifying suggest to me that it actively changes it's own base level instructions, i.e. I could put it in - run it and then go and look at it later and it would have changed - this is obviously impossible as the instructions are stored on your ARDS :)

It's a neat idea though, it almost has a "mind" to where it knows when to change action.

Better watch out. One of these days your codes will start modifying themselves to the point where your DS comes self-aware. The world is in danger when your DS suddenly flares to life and declares it supreme to mankind. Resistance is futile.

Quote:

---

Originally Posted by yoshisrock

It's a neat idea though, it almost has a "mind" to where it knows when to change action.

Better watch out. One of these days your codes will start modifying themselves to the point where your DS comes self-aware. The world is in danger when your DS suddenly flares to life and declares it supreme to mankind. Resistance is futile.

---

I don't agree with this theory. Technology will never run the world. Even if it did, we would be too busy to care anyways.
Also, i lol'd.