pythonudp埠掃描

❶ 如何用python方法檢測UDP埠

本文實例講述了python檢測遠程udp埠是否打開的方法。分享給大家供大家參考。具體實現方法如下：

復制代碼代碼如下:
import socket
import threading
import time
import struct
import Queue
queue = Queue.Queue()
def udp_sender(ip,port):
try:
ADDR = (ip,port)
sock_udp = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
sock_udp.sendto("abcd...",ADDR)
sock_udp.close()
except:
pass
def icmp_receiver(ip,port):
icmp = socket.getprotobyname("icmp")
try:
sock_icmp = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp)
except socket.error, (errno, msg):
if errno == 1:
# Operation not permitted
msg = msg + (
" - Note that ICMP messages can only be sent from processes"
" running as root."
)
raise socket.error(msg)
raise # raise the original error
sock_icmp.settimeout(3)
try:
recPacket,addr = sock_icmp.recvfrom(64)
except:
queue.put(True)
return
icmpHeader = recPacket[20:28]
icmpPort = int(recPacket.encode('hex')[100:104],16)
head_type, code, checksum, packetID, sequence = struct.unpack(
"bbHHh", icmpHeader
)
sock_icmp.close()
if code == 3 and icmpPort == port and addr[0] == ip:
queue.put(False)
return
def checker_udp(ip,port):
thread_udp = threading.Thread(target=udp_sender,args=(ip,port))
thread_icmp = threading.Thread(target=icmp_receiver,args=(ip,port))
thread_udp.daemon= True
thread_icmp.daemon = True
thread_icmp.start()
time.sleep(0.1)
thread_udp.start()

thread_icmp.join()
thread_udp.join()
return queue.get(False)
if __name__ == '__main__':
import sys
print checker_udp(sys.argv[1],int(sys.argv[2]))

希望本文所述對大家的Python程序設計有所幫助。

❷ 如何掃描網路中的埠 python

>>>fromsocketimportsocket
>>>defscan_address(host,port):
	s=socket()
	s.settimeout(3)
	try:
		s.connect((host,port))
	except:
		returnFalse
	s.close()
	returnTrue

>>>scan_address('localhost',5432)
True

❸ Python 實現埠掃描

一、常見埠掃描的原理

0、秘密掃描

秘密掃描是一種不被審計工具所檢測的掃描技術。

它通常用於在通過普通的防火牆或路由器的篩選（filtering）時隱藏自己。

秘密掃描能躲避IDS、防火牆、包過濾器和日誌審計，從而獲取目標埠的開放或關閉的信息。由於沒有包含TCP 3次握手協議的任何部分，所以無法被記錄下來，比半連接掃描更為隱蔽。

但是這種掃描的缺點是掃描結果的不可靠性會增加，而且掃描主機也需要自己構造IP包。現有的秘密掃描有TCP FIN掃描、TCP ACK掃描、NULL掃描、XMAS掃描和SYN/ACK掃描等。

1、Connect()掃描

此掃描試圖與每一個TCP埠進行「三次握手」通信。如果能夠成功建立接連，則證明埠開發，否則為關閉。准確度很高，但是最容易被防火牆和IDS檢測到，並且在目標主機的日誌中會記錄大量的連接請求以及錯誤信息。

TCP connect埠掃描服務端與客戶端建立連接成功（目標埠開放）的過程：

① Client端發送SYN；

② Server端返回SYN/ACK，表明埠開放；

③ Client端返回ACK，表明連接已建立；

④ Client端主動斷開連接。

建立連接成功（目標埠開放）

TCP connect埠掃描服務端與客戶端未建立連接成功（目標埠關閉）過程：

① Client端發送SYN；

② Server端返回RST/ACK，表明埠未開放。

優點：實現簡單，對操作者的許可權沒有嚴格要求（有些類型的埠掃描需要操作者具有root許可權），系統中的任何用戶都有權力使用這個調用，而且如果想要得到從目標埠返回banners信息，也只能採用這一方法。

另一優點是掃描速度快。如果對每個目標埠以線性的方式，使用單獨的connect()調用，可以通過同時打開多個套接字，從而加速掃描。

缺點：是會在目標主機的日誌記錄中留下痕跡，易被發現，並且數據包會被過濾掉。目標主機的logs文件會顯示一連串的連接和連接出錯的服務信息，並且能很快地使它關閉。

2、SYN掃描

掃描器向目標主機的一個埠發送請求連接的SYN包，掃描器在收到SYN/ACK後，不是發送的ACK應答而是發送RST包請求斷開連接。這樣，三次握手就沒有完成，無法建立正常的TCP連接，因此，這次掃描就不會被記錄到系統日誌中。這種掃描技術一般不會在目標主機上留下掃描痕跡。但是，這種掃描需要有root許可權。

·埠開放：（1）Client發送SYN；（2）Server端發送SYN/ACK；（3）Client發送RST斷開（只需要前兩步就可以判斷埠開放）

·埠關閉：（1）Client發送SYN；（2）Server端回復RST（表示埠關閉）

優點：SYN掃描要比TCP Connect()掃描隱蔽一些，SYN僅僅需要發送初始的SYN數據包給目標主機，如果埠開放，則相應SYN-ACK數據包；如果關閉，則響應RST數據包；

3、NULL掃描

反向掃描—-原理是將一個沒有設置任何標志位的數據包發送給TCP埠，在正常的通信中至少要設置一個標志位，根據FRC 793的要求，在埠關閉的情況下，若收到一個沒有設置標志位的數據欄位，那麼主機應該舍棄這個分段，並發送一個RST數據包，否則不會響應發起掃描的客戶端計算機。也就是說，如果TCP埠處於關閉則響應一個RST數據包，若處於開放則無相應。但是應該知道理由NULL掃描要求所有的主機都符合RFC 793規定，但是windows系統主機不遵從RFC 793標准，且只要收到沒有設置任何標志位的數據包時，不管埠是處於開放還是關閉都響應一個RST數據包。但是基於Unix(*nix,如Linux)遵從RFC 793標准，所以可以用NULL掃描。 經過上面的分析，我們知道NULL可以辨別某台主機運行的操作系統是什麼操作系統。

埠開放：Client發送Null，server沒有響應

埠關閉：（1）Client發送NUll；（2）Server回復RST

說明：Null掃描和前面的TCP Connect（）和SYN的判斷條件正好相反。在前兩種掃描中，有響應數據包的表示埠開放，但在NUll掃描中，收到響應數據包表示埠關閉。反向掃描比前兩種隱蔽性高些，當精確度也相對低一些。

用途：判斷是否為Windows系統還是Linux。

4、FIN掃描

與NULL有點類似，只是FIN為指示TCP會話結束，在FIN掃描中一個設置了FIN位的數據包被發送後，若響應RST數據包，則表示埠關閉，沒有響應則表示開放。此類掃描同樣不能准確判斷windows系統上埠開發情況。

·埠開放：發送FIN，沒有響應

·埠關閉：（1）發送FIN；（2）回復RST

5、ACK掃描

掃描主機向目標主機發送ACK數據包。根據返回的RST數據包有兩種方法可以得到埠的信息。方法一是： 若返回的RST數據包的TTL值小於或等於64，則埠開放，反之埠關閉。

6、Xmas-Tree掃描

通過發送帶有下列標志位的tcp數據包。

·URG：指示數據時緊急數據，應立即處理。

·PSH：強制將數據壓入緩沖區。

·FIN：在結束TCP會話時使用。

正常情況下，三個標志位不能被同時設置，但在此種掃描中可以用來判斷哪些埠關閉還是開放，與上面的反向掃描情況相同，依然不能判斷windows平台上的埠。

·埠開放：發送URG/PSH/FIN，沒有響應

·埠關閉：（1）發送URG/PSH/FIN，沒有響應；（2）響應RST

XMAS掃描原理和NULL掃描的類似，將TCP數據包中的ACK、FIN、RST、SYN、URG、PSH標志位置1後發送給目標主機。在目標埠開放的情況下，目標主機將不返回任何信息。

7、Dump掃描

也被稱為Idle掃描或反向掃描，在掃描主機時應用了第三方僵屍計算機掃描。由僵屍主機向目標主機發送SYN包。目標主機埠開發時回應SYN|ACK，關閉時返回RST，僵屍主機對SYN|ACK回應RST，對RST不做回應。從僵屍主機上進行掃描時，進行的是一個從本地計算機到僵屍主機的、連續的ping操作。查看僵屍主機返回的Echo響應的ID欄位，能確定目標主機上哪些埠是開放的還是關閉的。

二、Python 代碼實現

1、利用Python的Socket包中的connect方法，直接對目標IP和埠進行連接並且嘗試返回結果，而無需自己構建SYN包。

2、對IP埠進行多線程掃描，注意的是不同的電腦不同的CPU每次最多創建的線程是不一樣的，如果創建過多可能會報錯，需要根據自己電腦情況修改每次掃描的個數或者將seelp的時間加長都可以。

看完了嗎？感覺動手操作一下把！

python學習網，免費的在線學習python平台，歡迎關注！

本文轉自：https://www.jianshu.com/p/243bb7cfc40f

❹ 如何用Scapy寫一個埠掃描器

常見的埠掃描類型有：
1. TCP 連接掃描
2. TCP SYN 掃描(也稱為半開放掃描或stealth掃描)
3. TCP 聖誕樹(Xmas Tree)掃描
4. TCP FIN 掃描
5. TCP 空掃描(Null)
6. TCP ACK 掃描
7. TCP 窗口掃描
8. UDP 掃描

下面先講解每種掃描的原理，隨後提供具體實現代碼。
TCP 連接掃描
客戶端與伺服器建立 TCP 連接要進行一次三次握手，如果進行了一次成功的三次握手，則說明埠開放。

客戶端想要連接伺服器80埠時，會先發送一個帶有 SYN 標識和埠號的 TCP 數據包給伺服器(本例中為80埠)。如果埠是開放的，則伺服器會接受這個連接並返回一個帶有 SYN 和 ACK 標識的數據包給客戶端。隨後客戶端會返回帶有 ACK 和 RST 標識的數據包，此時客戶端與伺服器建立了連接。如果完成一次三次握手，那麼伺服器上對應的埠肯定就是開放的。

當客戶端發送一個帶有 SYN 標識和埠號的 TCP 數據包給伺服器後，如果伺服器端返回一個帶 RST 標識的數據包，則說明埠處於關閉狀態。
代碼：
#! /usr/bin/python

import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *

dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80

tcp_connect_scan_resp = sr1(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="S"),timeout=10)
if(str(type(tcp_connect_scan_resp))=="<type 'NoneType'>"):
print "Closed"
elif(tcp_connect_scan_resp.haslayer(TCP)):
if(tcp_connect_scan_resp.getlayer(TCP).flags == 0x12):
send_rst = sr(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="AR"),timeout=10)
print "Open"
elif (tcp_connect_scan_resp.getlayer(TCP).flags == 0x14):
print "Closed"

TCP SYN 掃描

這個技術同 TCP 連接掃描非常相似。同樣是客戶端向伺服器發送一個帶有 SYN 標識和埠號的數據包，如果目標埠開發，則會返回帶有 SYN 和 ACK 標識的 TCP 數據包。但是，這時客戶端不會返回 RST+ACK 而是返回一個只帶有 RST 標識的數據包。這種技術主要用於躲避防火牆的檢測。

如果目標埠處於關閉狀態，那麼同之前一樣，伺服器會返回一個 RST 數據包。
代碼：
#! /usr/bin/python
import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *

dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80

stealth_scan_resp = sr1(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="S"),timeout=10)
if(str(type(stealth_scan_resp))=="<type 'NoneType'>"):
print "Filtered"
elif(stealth_scan_resp.haslayer(TCP)):
if(stealth_scan_resp.getlayer(TCP).flags == 0x12):
send_rst = sr(IP(dst=dst_ip)/TCP(sport=src_port,dport=dst_port,flags="R"),timeout=10)
print "Open"
elif (stealth_scan_resp.getlayer(TCP).flags == 0x14):
print "Closed"
elif(stealth_scan_resp.haslayer(ICMP)):
if(int(stealth_scan_resp.getlayer(ICMP).type)==3 and int(stealth_scan_resp.getlayer(ICMP).code) in [1,2,3,9,10,13]):
print "Filtered"

TCP 聖誕樹(Xmas Tree)掃描

在聖誕樹掃描中，客戶端會向伺服器發送帶有 PSH,FIN,URG 標識和埠號的數據包給伺服器。如果目標埠是開放的，那麼不會有任何來自伺服器的回應。

如果伺服器返回了一個帶有 RST 標識的 TCP 數據包，那麼說明埠處於關閉狀態。

但如果伺服器返回了一個 ICMP 數據包，其中包含 ICMP 目標不可達錯誤類型3以及 ICMP 狀態碼為1，2，3，9，10或13，則說明目標埠被過濾了無法確定是否處於開放狀態。
代碼：
#! /usr/bin/python

import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *

dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80

xmas_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="FPU"),timeout=10)
if (str(type(xmas_scan_resp))=="<type 'NoneType'>"):
print "Open|Filtered"
elif(xmas_scan_resp.haslayer(TCP)):
if(xmas_scan_resp.getlayer(TCP).flags == 0x14):
print "Closed"
elif(xmas_scan_resp.haslayer(ICMP)):
if(int(xmas_scan_resp.getlayer(ICMP).type)==3 and int(xmas_scan_resp.getlayer(ICMP).code) in [1,2,3,9,10,13]):
print "Filtered"

TCP FIN掃描

FIN 掃描會向伺服器發送帶有 FIN 標識和埠號的 TCP 數據包。如果沒有伺服器端回應則說明埠開放。

如果伺服器返回一個 RST 數據包，則說明目標埠是關閉的。

如果伺服器返回了一個 ICMP 數據包，其中包含 ICMP 目標不可達錯誤類型3以及 ICMP 代碼為1，2，3，9，10或13，則說明目標埠被過濾了無法確定埠狀態。
代碼：
#! /usr/bin/python

import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *

dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80

fin_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="F"),timeout=10)
if (str(type(fin_scan_resp))=="<type 'NoneType'>"):
print "Open|Filtered"
elif(fin_scan_resp.haslayer(TCP)):
if(fin_scan_resp.getlayer(TCP).flags == 0x14):
print "Closed"
elif(fin_scan_resp.haslayer(ICMP)):
if(int(fin_scan_resp.getlayer(ICMP).type)==3 and int(fin_scan_resp.getlayer(ICMP).code) in [1,2,3,9,10,13]):
print "Filtered"

TCP 空掃描(Null)

在空掃描中，客戶端發出的 TCP 數據包僅僅只會包含埠號而不會有其他任何的標識信息。如果目標埠是開放的則不會回復任何信息。

如果伺服器返回了一個 RST 數據包，則說明目標埠是關閉的。

如果返回 ICMP 錯誤類型3且代碼為1，2，3，9，10或13的數據包，則說明埠被伺服器過濾了。
代碼：
#! /usr/bin/python

import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *

dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80

null_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags=""),timeout=10)
if (str(type(null_scan_resp))=="<type 'NoneType'>"):
print "Open|Filtered"
elif(null_scan_resp.haslayer(TCP)):
if(null_scan_resp.getlayer(TCP).flags == 0x14):
print "Closed"
elif(null_scan_resp.haslayer(ICMP)):
if(int(null_scan_resp.getlayer(ICMP).type)==3 and int(null_scan_resp.getlayer(ICMP).code) in [1,2,3,9,10,13]):
print "Filtered"

TCP ACK掃描
ACK 掃描不是用於發現埠開啟或關閉狀態的，而是用於發現伺服器上是否存在有狀態防火牆的。它的結果只能說明埠是否被過濾。再次強調，ACK 掃描不能發現埠是否處於開啟或關閉狀態。

客戶端會發送一個帶有 ACK 標識和埠號的數據包給伺服器。如果伺服器返回一個帶有 RST 標識的 TCP 數據包，則說明埠沒有被過濾，不存在狀態防火牆。

如果目標伺服器沒有任何回應或者返回ICMP 錯誤類型3且代碼為1，2，3，9，10或13的數據包，則說明埠被過濾且存在狀態防火牆。
#! /usr/bin/python

import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *

dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80

ack_flag_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="A"),timeout=10)
if (str(type(ack_flag_scan_resp))=="<type 'NoneType'>"):
print "Stateful firewall presentn(Filtered)"
elif(ack_flag_scan_resp.haslayer(TCP)):
if(ack_flag_scan_resp.getlayer(TCP).flags == 0x4):
print "No firewalln(Unfiltered)"
elif(ack_flag_scan_resp.haslayer(ICMP)):
if(int(ack_flag_scan_resp.getlayer(ICMP).type)==3 and int(ack_flag_scan_resp.getlayer(ICMP).code) in [1,2,3,9,10,13]):
print "Stateful firewall presentn(Filtered)"

TCP窗口掃描

TCP 窗口掃描的流程同 ACK 掃描類似，同樣是客戶端向伺服器發送一個帶有 ACK 標識和埠號的 TCP 數據包，但是這種掃描能夠用於發現目標伺服器埠的狀態。在 ACK 掃描中返回 RST 表明沒有被過濾，但在窗口掃描中，當收到返回的 RST 數據包後，它會檢查窗口大小的值。如果窗口大小的值是個非零值，則說明目標埠是開放的。

如果返回的 RST 數據包中的窗口大小為0，則說明目標埠是關閉的。
代碼：
#! /usr/bin/python

import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *

dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=80

window_scan_resp = sr1(IP(dst=dst_ip)/TCP(dport=dst_port,flags="A"),timeout=10)
if (str(type(window_scan_resp))=="<type 'NoneType'>"):
print "No response"
elif(window_scan_resp.haslayer(TCP)):
if(window_scan_resp.getlayer(TCP).window == 0):
print "Closed"
elif(window_scan_resp.getlayer(TCP).window > 0):
print "Open"

UDP掃描
TCP 是面向連接的協議，而UDP則是無連接的協議。
面向連接的協議會先在客戶端和伺服器之間建立通信信道，然後才會開始傳輸數據。如果客戶端和伺服器之間沒有建立通信信道，則不會有任何產生任何通信數據。
無連接的協議則不會事先建立客戶端和伺服器之間的通信信道，只要客戶端到伺服器存在可用信道，就會假設目標是可達的然後向對方發送數據。

客戶端會向伺服器發送一個帶有埠號的 UDP 數據包。如果伺服器回復了 UDP 數據包，則目標埠是開放的。

如果伺服器返回了一個 ICMP 目標不可達的錯誤和代碼3，則意味著目標埠處於關閉狀態。

如果伺服器返回一個 ICMP 錯誤類型3且代碼為1，2，3，9，10或13的數據包，則說明目標埠被伺服器過濾了。

但如果伺服器沒有任何相應客戶端的 UDP 請求，則可以斷定目標埠可能是開放或被過濾的，無法判斷埠的最終狀態。
代碼：
#! /usr/bin/python

import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *

dst_ip = "10.0.0.1"
src_port = RandShort()
dst_port=53
dst_timeout=10

def udp_scan(dst_ip,dst_port,dst_timeout):
udp_scan_resp = sr1(IP(dst=dst_ip)/UDP(dport=dst_port),timeout=dst_timeout)
if (str(type(udp_scan_resp))=="<type 'NoneType'>"):
retrans = []
for count in range(0,3):
retrans.append(sr1(IP(dst=dst_ip)/UDP(dport=dst_port),timeout=dst_timeout))
for item in retrans:
if (str(type(item))!="<type 'NoneType'>"):
udp_scan(dst_ip,dst_port,dst_timeout)
return "Open|Filtered"
elif (udp_scan_resp.haslayer(UDP)):
return "Open"
elif(udp_scan_resp.haslayer(ICMP)):
if(int(udp_scan_resp.getlayer(ICMP).type)==3 and int(udp_scan_resp.getlayer(ICMP).code)==3):
return "Closed"
elif(int(udp_scan_resp.getlayer(ICMP).type)==3 and int(udp_scan_resp.getlayer(ICMP).code) in [1,2,9,10,13]):
return "Filtered"

print udp_scan(dst_ip,dst_port,dst_timeout)

下面解釋下上述代碼中的一些函數和變數：
RandShort()：產生隨機數
type()：獲取數據類型
sport：源埠號
dport：目標埠號
timeout：等待相應的時間
haslayer()：查找指定層：TCP或UDP或ICMP
getlayer()：獲取指定層：TCP或UDP或ICMP

以上掃描的概念可以被用於「多埠掃描」，源碼可以參考這里：https://github.com/interference-security/Multiport
Scapy 是一個非常好用的工具，使用它可以非常簡單的構建自己的數據包，還可以很輕易的處理數據包的發送和相應。
（譯者註：上述所有代碼均在Kali 2.0下測試通過，建議讀者在Linux環境下測試代碼，如想在Windows上測試，請參見 Scapy官方文檔 配置好scapy環境）

❺ python 埠掃描 延時設置多久

#!/usr/bin/python
# -*- coding:utf8 -*-
# Python: 2.7.8
# Platform: Windows
# Authro: wucl
# Program: 埠掃描
# History: 2015.6.1

import socket, time, thread
socket.setdefaulttimeout(3)

def socket_port(ip,port):
"""
輸入IP和埠號，掃描判斷埠是否開放
"""
try:
if port>=65535:
print u'埠掃描結束'
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result=s.connect_ex((ip,port))
if result==0:
lock.acquire()
print ip,u':',port,u'埠開放'
lock.release()
s.close()
except:
print u'埠掃描異常'

def ip_scan(ip):
"""
輸入IP，掃描IP的0-65534埠情況
"""
try:
print u'開始掃描 %s' % ip
start_time=time.time()
for i in range(0,65534):
thread.start_new_thread(socket_port,(ip,int(i)))
print u'掃描埠完成，總共用時 ：%.2f' %(time.time()-start_time)
raw_input("Press Enter to Exit")
except:
print u'掃描ip出錯'

if __name__=='__main__':
url=raw_input('Input the ip you want to scan:\n')
lock=thread.allocate_lock()
ip_scan(url)

❻ python中如何去學習那些socket

這個星期剛剛用Python寫了幾個 ping，dns(UDP 53)掃描以及tcp埠掃描的程序，總結有以下幾點：
1. 多線程，一個線程負責發，一個線程負責收
2. 使用raw socket，需要有root許可權，其中ICMP的raw socket需要設置參數告訴kernel IP頭有你的程序添加。我在check sum這里卡了點時間，手裡最好有本網路參考書，《TCP/IP illustrated》最好，在寫代碼之前必須對報文格式以及各欄位做到心中有數。
3. 看看Python的struct/array文檔看看怎麼組包，解包
4. 除非你異常牛逼，否則還是需要debug工具，比如wireshark/tcpmp等工具配合讓你看看自己發出來的包那裡出了問題。如果用GUI的wireshark記得將option中的tcp/ip部分checksum option打開
把代碼貼給你就讓你失去自己動手的樂趣了！呵呵have fun！