added phase 3

1 files changed, 276 insertions, 2 deletions

diff --git a/Content/posts/2023-10-04-bomb-lab.md b/Content/posts/2023-10-04-bomb-lab.md
index 4919f61..fdbf87c 100644
--- a/Content/posts/2023-10-04-bomb-lab.md
+++ b/Content/posts/2023-10-04-bomb-lab.md
@@ -1,15 +1,19 @@
 ---
 date: 2023-10-04 13:12
-description: Introduction, Phase 1 and Phase 2 of Bomb Lab for CSCI 2400 Lab - 2
+description: Introduction, Phases 1-3 of Bomb Lab for CSCI 2400 Lab - 2
 tags: gdb, reverse-engineering, c++, csci2400, assembly
 ---
 
-# Bomb Lab
+# Bomb Lab Phases 1 & 2
 
 ## Introduction
 
 Lab 2 for CSCI 2400 - Computer Systems. 
 
+I like using objdump to disassemble the code and see a broad overview of what is happening. 
+
+`objdump -d bomb > dis.txt`
+
 ## Phase 1
 
 ```
@@ -179,3 +183,273 @@ Breakpoint 1, 0x00005555555555eb in phase_2 ()
 Continuing.
 That's number 2.  Keep going!
 ```
+
+## Phase 3
+
+Let us look at the disassembled code first
+
+```
+0000000000001638 <phase_3>:
+    1638:	f3 0f 1e fa          	endbr64 
+    163c:	48 83 ec 18          	sub    $0x18,%rsp
+    1640:	48 8d 4c 24 07       	lea    0x7(%rsp),%rcx
+    1645:	48 8d 54 24 0c       	lea    0xc(%rsp),%rdx
+    164a:	4c 8d 44 24 08       	lea    0x8(%rsp),%r8
+    164f:	48 8d 35 60 1b 00 00 	lea    0x1b60(%rip),%rsi        # 31b6 <_IO_stdin_used+0x1b6>
+    1656:	b8 00 00 00 00       	mov    $0x0,%eax
+    165b:	e8 80 fc ff ff       	call   12e0 <__isoc99_sscanf@plt>
+    1660:	83 f8 02             	cmp    $0x2,%eax
+    1663:	7e 20                	jle    1685 <phase_3+0x4d>
+    1665:	83 7c 24 0c 07       	cmpl   $0x7,0xc(%rsp)
+    166a:	0f 87 0d 01 00 00    	ja     177d <phase_3+0x145>
+    1670:	8b 44 24 0c          	mov    0xc(%rsp),%eax
+    1674:	48 8d 15 55 1b 00 00 	lea    0x1b55(%rip),%rdx        # 31d0 <_IO_stdin_used+0x1d0>
+    167b:	48 63 04 82          	movslq (%rdx,%rax,4),%rax
+    167f:	48 01 d0             	add    %rdx,%rax
+    1682:	3e ff e0             	notrack jmp *%rax
+    1685:	e8 c0 06 00 00       	call   1d4a <explode_bomb>
+    168a:	eb d9                	jmp    1665 <phase_3+0x2d>
+    168c:	b8 63 00 00 00       	mov    $0x63,%eax
+    1691:	81 7c 24 08 3d 02 00 	cmpl   $0x23d,0x8(%rsp)
+    1698:	00 
+    1699:	0f 84 e8 00 00 00    	je     1787 <phase_3+0x14f>
+    169f:	e8 a6 06 00 00       	call   1d4a <explode_bomb>
+    16a4:	b8 63 00 00 00       	mov    $0x63,%eax
+    16a9:	e9 d9 00 00 00       	jmp    1787 <phase_3+0x14f>
+    16ae:	b8 61 00 00 00       	mov    $0x61,%eax
+    16b3:	81 7c 24 08 27 01 00 	cmpl   $0x127,0x8(%rsp)
+    16ba:	00 
+    16bb:	0f 84 c6 00 00 00    	je     1787 <phase_3+0x14f>
+    16c1:	e8 84 06 00 00       	call   1d4a <explode_bomb>
+    16c6:	b8 61 00 00 00       	mov    $0x61,%eax
+    16cb:	e9 b7 00 00 00       	jmp    1787 <phase_3+0x14f>
+    16d0:	b8 78 00 00 00       	mov    $0x78,%eax
+    16d5:	81 7c 24 08 e7 02 00 	cmpl   $0x2e7,0x8(%rsp)
+    16dc:	00 
+    16dd:	0f 84 a4 00 00 00    	je     1787 <phase_3+0x14f>
+    16e3:	e8 62 06 00 00       	call   1d4a <explode_bomb>
+    16e8:	b8 78 00 00 00       	mov    $0x78,%eax
+    16ed:	e9 95 00 00 00       	jmp    1787 <phase_3+0x14f>
+    16f2:	b8 64 00 00 00       	mov    $0x64,%eax
+    16f7:	81 7c 24 08 80 02 00 	cmpl   $0x280,0x8(%rsp)
+    16fe:	00 
+    16ff:	0f 84 82 00 00 00    	je     1787 <phase_3+0x14f>
+    1705:	e8 40 06 00 00       	call   1d4a <explode_bomb>
+    170a:	b8 64 00 00 00       	mov    $0x64,%eax
+    170f:	eb 76                	jmp    1787 <phase_3+0x14f>
+    1711:	b8 6d 00 00 00       	mov    $0x6d,%eax
+    1716:	81 7c 24 08 ff 02 00 	cmpl   $0x2ff,0x8(%rsp)
+    171d:	00 
+    171e:	74 67                	je     1787 <phase_3+0x14f>
+    1720:	e8 25 06 00 00       	call   1d4a <explode_bomb>
+    1725:	b8 6d 00 00 00       	mov    $0x6d,%eax
+    172a:	eb 5b                	jmp    1787 <phase_3+0x14f>
+    172c:	b8 71 00 00 00       	mov    $0x71,%eax
+    1731:	81 7c 24 08 75 03 00 	cmpl   $0x375,0x8(%rsp)
+    1738:	00 
+    1739:	74 4c                	je     1787 <phase_3+0x14f>
+    173b:	e8 0a 06 00 00       	call   1d4a <explode_bomb>
+    1740:	b8 71 00 00 00       	mov    $0x71,%eax
+    1745:	eb 40                	jmp    1787 <phase_3+0x14f>
+    1747:	b8 79 00 00 00       	mov    $0x79,%eax
+    174c:	81 7c 24 08 94 02 00 	cmpl   $0x294,0x8(%rsp)
+    1753:	00 
+    1754:	74 31                	je     1787 <phase_3+0x14f>
+    1756:	e8 ef 05 00 00       	call   1d4a <explode_bomb>
+    175b:	b8 79 00 00 00       	mov    $0x79,%eax
+    1760:	eb 25                	jmp    1787 <phase_3+0x14f>
+    1762:	b8 79 00 00 00       	mov    $0x79,%eax
+    1767:	81 7c 24 08 88 02 00 	cmpl   $0x288,0x8(%rsp)
+    176e:	00 
+    176f:	74 16                	je     1787 <phase_3+0x14f>
+    1771:	e8 d4 05 00 00       	call   1d4a <explode_bomb>
+    1776:	b8 79 00 00 00       	mov    $0x79,%eax
+    177b:	eb 0a                	jmp    1787 <phase_3+0x14f>
+    177d:	e8 c8 05 00 00       	call   1d4a <explode_bomb>
+    1782:	b8 68 00 00 00       	mov    $0x68,%eax
+    1787:	38 44 24 07          	cmp    %al,0x7(%rsp)
+    178b:	75 05                	jne    1792 <phase_3+0x15a>
+    178d:	48 83 c4 18          	add    $0x18,%rsp
+    1791:	c3                   	ret    
+    1792:	e8 b3 05 00 00       	call   1d4a <explode_bomb>
+    1797:	eb f4                	jmp    178d <phase_3+0x155>
+```
+
+```
+...
+    165b:	e8 80 fc ff ff       	call   12e0 <__isoc99_sscanf@plt>
+...
+```
+
+We can see that `scanf` is being called which means we need to figure out what datatype(s) the program is expecting.
+
+Because I do not want to enter the solutions to phases 1 and 2 again and again, I am goig to pass a file which has these solutions.
+
+```
+jovyan@jupyter-nach6988:~/lab2-bomblab-navanchauhan/bombbomb$ gdb -ex 'break phase_3' -ex 'break explode_bomb' -ex 'run' -args ./bomb sol.txt 
+GNU gdb (Ubuntu 12.1-0ubuntu1~22.04) 12.1
+Copyright (C) 2022 Free Software Foundation, Inc.
+License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
+This is free software: you are free to change and redistribute it.
+There is NO WARRANTY, to the extent permitted by law.
+Type "show copying" and "show warranty" for details.
+This GDB was configured as "x86_64-linux-gnu".
+Type "show configuration" for configuration details.
+For bug reporting instructions, please see:
+<https://www.gnu.org/software/gdb/bugs/>.
+Find the GDB manual and other documentation resources online at:
+    <http://www.gnu.org/software/gdb/documentation/>.
+
+For help, type "help".
+Type "apropos word" to search for commands related to "word"...
+Reading symbols from ./bomb...
+Breakpoint 1 at 0x1638
+Breakpoint 2 at 0x1d4a
+Starting program: /home/jovyan/lab2-bomblab-navanchauhan/bombbomb/bomb sol.txt
+[Thread debugging using libthread_db enabled]
+Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
+Welcome to my fiendish little bomb. You have 6 phases with
+which to blow yourself up. Have a nice day!
+Phase 1 defused. How about the next one?
+That's number 2.  Keep going!
+random string
+
+Breakpoint 1, 0x0000555555555638 in phase_3 ()
+(gdb) disas
+Dump of assembler code for function phase_3:
+=> 0x0000555555555638 <+0>:     endbr64 
+   0x000055555555563c <+4>:     sub    $0x18,%rsp
+   0x0000555555555640 <+8>:     lea    0x7(%rsp),%rcx
+   0x0000555555555645 <+13>:    lea    0xc(%rsp),%rdx
+   0x000055555555564a <+18>:    lea    0x8(%rsp),%r8
+   0x000055555555564f <+23>:    lea    0x1b60(%rip),%rsi        # 0x5555555571b6
+   0x0000555555555656 <+30>:    mov    $0x0,%eax
+   0x000055555555565b <+35>:    call   0x5555555552e0 <__isoc99_sscanf@plt>
+   0x0000555555555660 <+40>:    cmp    $0x2,%eax
+   0x0000555555555663 <+43>:    jle    0x555555555685 <phase_3+77>
+   0x0000555555555665 <+45>:    cmpl   $0x7,0xc(%rsp)
+   0x000055555555566a <+50>:    ja     0x55555555577d <phase_3+325>
+   0x0000555555555670 <+56>:    mov    0xc(%rsp),%eax
+   0x0000555555555674 <+60>:    lea    0x1b55(%rip),%rdx        # 0x5555555571d0
+   0x000055555555567b <+67>:    movslq (%rdx,%rax,4),%rax
+   0x000055555555567f <+71>:    add    %rdx,%rax
+   0x0000555555555682 <+74>:    notrack jmp *%rax
+   0x0000555555555685 <+77>:    call   0x555555555d4a <explode_bomb>
+   0x000055555555568a <+82>:    jmp    0x555555555665 <phase_3+45>
+   0x000055555555568c <+84>:    mov    $0x63,%eax
+   0x0000555555555691 <+89>:    cmpl   $0x23d,0x8(%rsp)
+   0x0000555555555699 <+97>:    je     0x555555555787 <phase_3+335>
+   0x000055555555569f <+103>:   call   0x555555555d4a <explode_bomb>
+   0x00005555555556a4 <+108>:   mov    $0x63,%eax
+   0x00005555555556a9 <+113>:   jmp    0x555555555787 <phase_3+335>
+--Type <RET> for more, q to quit, c to continue without paging--
+```
+
+
+`gdb` has thankfully marked the address which is being passed to `scanf`. We can access the value:
+
+```
+(gdb) x/1s 0x5555555571b6
+0x5555555571b6: "%d %c %d"
+(gdb) 
+```
+
+BINGO! The program expects an integer, character, and another integer. Onwards.
+
+```
+   0x0000555555555660 <+40>:    cmp    $0x2,%eax
+   0x0000555555555663 <+43>:    jle    0x555555555685 <phase_3+77>
+...
+   0x0000555555555685 <+77>:    call   0x555555555d4a <explode_bomb>
+```
+
+The program checks whether `scanf` returns a value <= 2, if it does then it calls the `explode_bomb` function. 
+
+*Note: `scanf` returns the number of fields that were succesfully converted and assigned*
+
+```
+   0x0000555555555665 <+45>:    cmpl   $0x7,0xc(%rsp)
+   0x000055555555566a <+50>:    ja     0x55555555577d <phase_3+325>
+...
+   0x000055555555577d <+325>:   call   0x555555555d4a <explode_bomb>
+```
+
+Similarly, the program checks and ensures the returned value is not > 7. 
+
+
+```
+   0x0000555555555670 <+56>:    mov    0xc(%rsp),%eax
+   0x0000555555555674 <+60>:    lea    0x1b55(%rip),%rdx        # 0x5555555571d0
+   0x000055555555567b <+67>:    movslq (%rdx,%rax,4),%rax
+   0x000055555555567f <+71>:    add    %rdx,%rax
+   0x0000555555555682 <+74>:    notrack jmp *%rax
+   0x0000555555555685 <+77>:    call   0x555555555d4a <explode_bomb>
+```
+
+* `0x0000555555555670 <+56>:    mov    0xc(%rsp),%eax` - Moves value located at `0xc` (12 in Decimal) bytes above the stack pointer to `%eax` register. 
+* `0x0000555555555674 <+60>:    lea    0x1b55(%rip),%rdx        # 0x5555555571d0` - This instruction calculates an effective address by adding `0x1b55` to the current instruction pointer (`%rip`). The result is stored in the `%rdx` register. 
+* `0x000055555555567b <+67>:    movslq (%rdx,%rax,4),%rax`
+   * `movslq` stands for "move with sign-extension from a 32-bit value to a 64-bit value." (if the 32-bit value is negative, the 64-bit result will have all its upper 32 bits set to 1; otherwise, they'll be set to 0). 
+   * `(%rdx,%rax,4)` - First start with the value in the %rdx register, then add to it the value in the %rax register multiplied by 4.
+   * `%rax` - Destination Register
+* `0x000055555555567f <+71>:    add    %rdx,%rax` - Adds base address in `%rdx` to the offset in `%rax` 
+* `0x0000555555555682 <+74>:    notrack jmp *%rax` - Jumps to the address stored in `%rax`
+* `0x0000555555555685 <+77>:    call   0x555555555d4a <explode_bomb>` - If we are unable to jump to the specified instruction, call `explode_bomb`
+
+Let us try to run the program again with a valid input for the first number and see what the program is computing for the address.
+
+I used the input: `3 c 123`.
+
+To check what is the computed address, we can switch to the asm layout by running `layout asm`, and then going through instructions `ni` or `si` until we reach the line `movslq (%rdx,%rax,4),%rax`
+
+`%rax` should hold the value 3.
+
+```
+(gdb) print $rax
+$1 = 3
+```
+
+![Screenshot of GDB terminal depicting us checking the value of the instruction to be jumped to](/assets/bomb-lab/phase-3.png)
+
+We can see that this makes us jump to `<phase_3+186>` (Continue to step through the code by using `ni`)
+
+```
+   0x00005555555556f2 <+186>:   mov    $0x64,%eax
+   0x00005555555556f7 <+191>:   cmpl   $0x280,0x8(%rsp)
+   0x00005555555556ff <+199>:   je     0x555555555787 <phase_3+335>
+   0x0000555555555705 <+205>:   call   0x555555555d4a <explode_bomb>
+```
+
+We see that `0x64` (Decimal 100) is being stored in `%eax`. Then, the program compares `0x280` (Decimal 640) with memory address `0x8` bytes above the stack pointer (`%rsp`). If the values are equal, then it jumps to `<phase_3+335>`, otherwise `explode_bomb` is called.
+
+```
+   0x0000555555555787 <+335>:   cmp    %al,0x7(%rsp)
+   0x000055555555578b <+339>:   jne    0x555555555792 <phase_3+346>
+   0x000055555555578d <+341>:   add    $0x18,%rsp
+   0x0000555555555791 <+345>:   ret    
+   0x0000555555555792 <+346>:   call   0x555555555d4a <explode_bomb>
+```
+
+Here, the program is comparing the value of our given character to the value stored in `%al` (lower 8 bits of `EAX`), and checks if they are not equal.
+
+Knowing that the character is stored at an offset of 7 bytes to `%rsp`, we can print and check the value by running:
+
+```
+(gdb) x/1cw $rsp+7
+c
+(gdb) print $al
+$1 = 100
+```
+
+We can simply lookup the [ASCII table](https://www.cs.cmu.edu/~pattis/15-1XX/common/handouts/ascii.html), and see that 100 in decimal stands for the character `d`. Let us try this answer:
+
+```
+...
+That's number 2.  Keep going!
+3 d 640
+
+Breakpoint 1, 0x0000555555555638 in phase_3 ()
+(gdb) continue
+Continuing.
+Halfway there!
+```