pythoneth挖礦

㈠ 想用python語言修改Linux下/etc/sysconfig/network-scrips/ifcfg-eth1下的IP內容並保存。請指點~~

eth1= raw_input("eth1 configure:\n")

with open("/etc/sysconfig/network-scrips/ifcfg-eth1","a") as f:
f.write(eth1)

㈡ python有沒有挖礦的類庫

下載下來，安裝唄。有pip install *.whl ， 有 easy_install *.egg 還有源碼安裝 python setup.py install，最後windos還有exe安裝包。

㈢ 在linux下，python怎麼才能抓到網卡上的所有TCP數據包

Ethereal 自帶許多協議的 decoder,簡單,易用,基於winpcap的一個開源的軟體.但是它的架構並不靈活,如何你要加入一個自己定義的的解碼器,得去修改 Ethereal的代碼,再重新編譯,很煩瑣.對於一般的明文 協議,沒有什麼問題,但是對於加密協議,比如網路游戲,客戶端程序一般會在剛連接上的時候,發送一個隨機密鑰,而後的報文都會用這個密鑰進行加密,如此. 要想破解,得要有一個可編程的抓包器.
libpcap是一個不錯的選擇,但是對於抓包這樣需要反復進行」試 驗->修改」這個過程的操作,c 語言顯然不是明智的選擇.
Python提供了幾個libpcapbind。在windows平台上,你需要先安裝winpcap,如果你已經安裝了Ethereal非常好用
一個規范的抓包過程
import pcap
import dpkt
pc=pcap.pcap() #注，參數可為網卡名，如eth0
pc.setfilter('tcp port 80') #設置監聽過濾器
for ptime,pdata in pc: #ptime為收到時間，pdata為收到數據
print ptime,pdata #...
對抓到的乙太網V2數據包(raw packet)進行解包
p=dpkt.ethernet.Ethernet(pdata)
if p.data.__class__.__name__=='IP':
ip='%d.%d.%d.%d'%tuple(map(ord,list(p.data.dst)))
if p.data.data.__class__.__name__=='TCP':
if data.dport==80:
print p.data.data.data # by gashero
一些顯示參數
nrecv,ndrop,nifdrop=pc.stats()
返回的元組中，第一個參數為接收到的數據包，(by gashero)第二個參數為被核心丟棄的數據包。

㈣ 如何利用libpcap和Python嗅探數據包

一提到Python獲取數據包的方式，相信很多Python愛好者會利用Linux的libpcap軟體包或利用Windows下的WinPcap可移植版的方式進行抓取數據包，然後再利用dpkt軟體包進行協議分析，我們這里想換一個角度去思考：
1. Python版本的pcap存儲內存數據過小，也就是說緩存不夠，在高並發下容易發生丟包現象，其實C版本的也同樣存在這樣的問題，只不過Python版本的緩存實在是過低，讓人很郁悶。
2. dpkt協議分析並非必須，如果你對RFC 791和RFC 793等協議熟悉的話，完全可以使用struct.unpack的方式進行分析。
如果你平常習慣使用tcpmp抓取數據包的話，完全可以使用它來代替pcap軟體包，只不過我們需要利用tcpmp將抓取的數據以pcap格式進行保存，說道這里大家一定會想到Wireshark工具，具體命令如下：
tcpmp dst 10.13.202.116 and tcp dst port 80 -s 0 -i eth1 -w ../pcap/tcpmp.pcap -C 1k -W 5
我們首先需要對pcap文件格式有所了解，具體信息大家可以參考其他資料文檔，我這里只說其重要的結構體組成，如下：
sturct pcap_file_header
{
DWORD magic;
WORD version_major;
WORD version_minor;
DWORD thiszone;
DWORD sigfigs;
DWORD snaplen;
DWORD linktype;
}
struct pcap_pkthdr
{
struct timeval ts;
DWORD caplen;
DWORD len;
}
struct timeval
{
DWORD GMTtime;
DWORD microTime;
}
這里需要說明的一點是，因為在Python的世界裡一切都是對象，所以往往Python在處理數據包的時候感覺讓人比較麻煩。Python提供了幾個libpcapbind,http://monkey.org/~gsong/pypcap/這里有 一個最簡單的。在windows平台上,你需要先安裝winpcap,如果你已經安裝了Ethereal非常好用。一個規范的抓包過程:
import pcap
import dpkt
pc=pcap.pcap() #注，參數可為網卡名，如eth0
pc.setfilter('tcp port 80') #設置監聽過濾器
for ptime,pdata in pc: #ptime為收到時間，pdata為收到數據
print ptime,pdata #...
對抓到的乙太網V2數據包(raw packet)進行解包:
p=dpkt.ethernet.Ethernet(pdata)
if p.data.__class__.__name__=='IP':
ip='%d.%d.%d.%d'%tuple(map(ord,list(p.data.dst)))
if p.data.data.__class__.__name__=='TCP':
if data.dport==80:
print p.data.data.data
一些顯示參數nrecv,ndrop,nifdrop=pc.stats()返回的元組中，第一個參數為接收到的數據包，第二個參數為被核心丟棄的數據包。
至於對於如何監控tcpmp生成的pcap文件數據，大家可以通過pyinotify軟體包來實現，如下：
class Packer(pyinotify.ProcessEvent):
def __init__(self, proct):
self.proct = proct
self.process = None
def process_IN_CREATE(self, event):
logger.debug("create file: %s in queue" % self.process_IF_START_THREAD(event))
def process_IN_MODIFY(self, event):
self.process_IF_START_THREAD(event)
logger.debug("modify file: %s in queue" % self.process_IF_START_THREAD(event))
def process_IN_DELETE(self, event):
filename = os.path.join(event.path, event.name)
logger.debug("delete file: %s" % filename)
def process_IF_START_THREAD(self, event):
filename = os.path.join(event.path, event.name)
if filename != self.process:
self.process = filename
self.proct.put(filename)
if self.proct.qsize() > 1:
try:
logger.debug("create consumer proct.qsize: %s" % self.proct.qsize())
consumer = Consumer(self.proct)
consumer.start()
except Exception, errmsg:
logger.error("create consumer failed: %s" % errmsg)
return filename
class Factory(object):
def __init__(self, proct):
self.proct = proct
self.manager = pyinotify.WatchManager()
self.mask = pyinotify.IN_CREATE | pyinotify.IN_DELETE | pyinotify.IN_MODIFY
def work(self):
try:
try:
notifier = pyinotify.ThreadedNotifier(self.manager, Packer(self.proct))
notifier.start()
self.manager.add_watch("../pcap", self.mask, rec = True)
notifier.join()
except Exception, errmsg:
logger.error("create notifier failed: %s" % errmsg)
except KeyboardInterrupt, errmsg:
logger.error("factory has been terminated: %s" % errmsg)
在獲得要分析的pcap文件數據之後，就要對其分析了，只要你足夠了解pcap文件格式就可以了，對於我們來講只需要獲得TCP數據段的數據即可，如下：
class Writer(threading.Thread):
def __init__(self, proct, stack):
threading.Thread.__init__(self)
self.proct = proct
self.stack = stack
self.pcap_pkthdr = {}
def run(self):
while True:
filename = self.proct.get()
try:
f = open(filename, "rb")
readlines = f.read()
f.close()
offset = 24
while len(readlines) > offset:
self.pcap_pkthdr["len"] = readlines[offset+12:offset+16]
try:
length = struct.unpack("I", self.pcap_pkthdr["len"])[0]
self.stack.put(readlines[offset+16:offset+16+length])
offset += length + 16
except Exception, errmsg:
logger.error("unpack pcap_pkthdr failed: %s" % errmsg)
except IOError, errmsg:
logger.error("open file failed: %s" % errmsg)
在獲得TCP數據段的數據包之後，問題就簡單多了，根據大家的具體需求就可以進行相應的分析了，我這里是想分析其HTTP協議數據，同樣也藉助了dpkt軟體包進行分析，如下：
def worker(memcache, packet, local_address, remote_address):
try:
p = dpkt.ethernet.Ethernet(packet)
if p.data.__class__.__name__ == "IP":
srcip = "%d.%d.%d.%d" % tuple(map(ord, list(p.data.src)))
dstip = "%d.%d.%d.%d" % tuple(map(ord, list(p.data.dst)))
if p.data.data.__class__.__name__ == "TCP":
tcpacket = p.data.data
if tcpacket.dport == 80 and dstip == local_address:
srcport = tcpacket.sport
key = srcip + ":" + str(srcport)
if tcpacket.data:
if not memcache.has_key(key):
memcache[key] = {}
if not memcache[key].has_key("response"):
memcache[key]["response"] = None
if memcache[key].has_key("data"):
memcache[key]["data"] += tcpacket.data
else:
memcache[key]["data"] = tcpacket.data
else:
if memcache.has_key(key):
memcache[key]["response"] = dpkt.http.Request(memcache[key]["data"])
try:
stackless.tasklet(connection)(memcache[key]["response"], local_address, remote_address)
stackless.run()
except Exception, errmsg:
logger.error("connect remote remote_address failed: %s", errmsg)
logger.debug("old headers(none content-length): %s", memcache[key]["response"])
memcache.pop(key)
except Exception, errmsg:
logger.error("dpkt.ethernet.Ethernet failed in worker: %s", errmsg)
如果大家只是想單純的獲取IP地址、埠、流量信息，那麼問題就更簡單了，這里只是拋磚引玉。另外再提供一段代碼供參考:
import pcap, dpkt, struct
import binascii
def main():
a = pcap.pcap()
a.setfilter('udp portrange 4000-4050')
try:
for i,pdata in a:
p=dpkt.ethernet.Ethernet(pdata)
src='%d.%d.%d.%d' % tuple(map(ord,list(p.data.src)))
dst='%d.%d.%d.%d' % tuple(map(ord,list(p.data.dst)))
sport = p.data.data.sport
dport = p.data.data.dport
qq = int( binascii.hexlify(p.data.data.data[7:11]) , 16 )
print 'QQ: %d, From: %s:%d , To: %s:%d' % (qq,src,sport,dst,dport)
except Exception,e:
print '%s' % e
n = raw_input()
if __name__ == '__main__':
main()

㈤ python,pip已經正常安裝庫lxml,但是卻引用不動，求大神幫忙

到http://www.lfd.uci.e/~gohlke/pythonlibs/#lxml

下載已經編譯的安裝包，注意選擇Python的版本和操作系統的位數

在命令行中輸入

pipinstall下載安裝包的路徑

㈥ 什麼是以太幣/以太坊ETH

以太幣（ETH）是以太坊（Ethereum）的一種數字代幣，被視為「比特幣2.0版」，採用與比特幣不同的區塊鏈技術「以太坊」（Ethereum），一個開源的有智能合約成果的民眾區塊鏈平台，由全球成千上萬的計算機構成的共鳴網路。開發者們需要支付以太幣（ETH）來支撐應用的運行。和其他數字貨幣一樣，以太幣可以在交易平台上進行買賣 。

溫馨提示：以上解釋僅供參考，不作任何建議。入市有風險，投資需謹慎。您在做任何投資之前，應確保自己完全明白該產品的投資性質和所涉及的風險，詳細了解和謹慎評估產品後，再自身判斷是否參與交易。
應答時間：2020-12-02，最新業務變化請以平安銀行官網公布為准。
[平安銀行我知道]想要知道更多？快來看「平安銀行我知道」吧~
https://b.pingan.com.cn/paim/iknow/index.html

㈦ 人工智慧入門書籍

人工智慧是計算機科學的一個分支，並不是一個單一學科，圖像識別、自然語言處理、機器人、語言識別、專家系統等等，每一個研究都富有挑戰。對人工智慧感興趣，但無法確定具體方向，如何了解人工智慧現狀和研究領域？

筆者推薦4本科普書，對於大多數人來說，閱讀難度不高，公式和理論少，內容有趣，能讀得下去；信息較新鮮且全，要有一定閱讀價值，能夠有深入的思考當然更好。書單不長，只用做科普入門。

1、《超級智能》

2、《我們最後的發明：人工智慧與人類時代的終結》

3、《智能時代》

4、《人工智慧：國家人工智慧戰略行動抓手》

㈧ 如何利用Python嗅探數據包

一提到Python獲取數據包的方式，相信很多Python愛好者會利用Linux的libpcap軟體包或利用Windows下的WinPcap可移植版的方式進行抓取數據包，然後再利用dpkt軟體包進行協議分析，我們這里想換一個角度去思考：
1. Python版本的pcap存儲內存數據過小，也就是說緩存不夠，在高並發下容易發生丟包現象，其實C版本的也同樣存在這樣的問題，只不過Python版本的緩存實在是過低，讓人很郁悶。
2. dpkt協議分析並非必須，如果你對RFC 791和RFC 793等協議熟悉的話，完全可以使用struct.unpack的方式進行分析。
如果你平常習慣使用tcpmp抓取數據包的話，完全可以使用它來代替pcap軟體包，只不過我們需要利用tcpmp將抓取的數據以pcap格式進行保存，說道這里大家一定會想到Wireshark工具，具體命令如下：
1. tcpmp dst 10.13.202.116 and tcp dst port 80 -s 0 -i eth1 -w ../pcap/tcpmp.pcap -C 1k -W 5
我們首先需要對pcap文件格式有所了解，具體信息大家可以參考其他資料文檔，我這里只說其重要的結構體組成，如下：
1. sturct pcap_file_header
2. {
3. DWORD magic;
4. WORD version_major;
5. WORD version_minor;
6. DWORD thiszone;
7. DWORD sigfigs;
8. DWORD snaplen;
9. DWORD linktype;
10. }
11.
12. struct pcap_pkthdr
13. {
14. struct timeval ts;
15. DWORD caplen;
16. DWORD len;
17. }
18.
19. struct timeval
20. {
21. DWORD GMTtime;
22. DWORD microTime;
23. }
這里需要說明的一點是，因為在Python的世界裡一切都是對象，所以往往Python在處理數據包的時候感覺讓人比較麻煩。
至於對於如何監控tcpmp生成的pcap文件數據，大家可以通過pyinotify軟體包來實現（相信大家一定對於rsync+inotify的組合比較熟悉），如下：
1. class Packer(pyinotify.ProcessEvent):
2. def __init__(self, proct):
3. self.proct = proct
4. self.process = None
5.
6. def process_IN_CREATE(self, event):
7. logger.debug("create file: %s in queue" % self.process_IF_START_THREAD(event))
8.
9. def process_IN_MODIFY(self, event):
10. self.process_IF_START_THREAD(event)
11. logger.debug("modify file: %s in queue" % self.process_IF_START_THREAD(event))
12.
13. def process_IN_DELETE(self, event):
14. filename = os.path.join(event.path, event.name)
15. logger.debug("delete file: %s" % filename)
16.
17. def process_IF_START_THREAD(self, event):
18. filename = os.path.join(event.path, event.name)
19.
20. if filename != self.process:
21. self.process = filename
22. self.proct.put(filename)
23.
24. if self.proct.qsize() > 1:
25. try:
26. logger.debug("create consumer proct.qsize: %s" % self.proct.qsize())
27. consumer = Consumer(self.proct)
28. consumer.start()
29. except Exception, errmsg:
30. logger.error("create consumer failed: %s" % errmsg)
31.
32. return filename
33.
34. class Factory(object):
35. def __init__(self, proct):
36. self.proct = proct
37. self.manager = pyinotify.WatchManager()
38. self.mask = pyinotify.IN_CREATE | pyinotify.IN_DELETE | pyinotify.IN_MODIFY
39.
40. def work(self):
41. try:
42. try:
43. notifier = pyinotify.ThreadedNotifier(self.manager, Packer(self.proct))
44. notifier.start()
45. self.manager.add_watch("../pcap", self.mask, rec = True)
46. notifier.join()
47. except Exception, errmsg:
48. logger.error("create notifier failed: %s" % errmsg)
49. except KeyboardInterrupt, errmsg:
50. logger.error("factory has been terminated: %s" % errmsg)
在獲得要分析的pcap文件數據之後，就要對其分析了，只要你足夠了解pcap文件格式就可以了，對於我們來講只需要獲得TCP數據段的數據即可，如下：
1. class Writer(threading.Thread):
2. def __init__(self, proct, stack):
3. threading.Thread.__init__(self)
4. self.proct = proct
5. self.stack = stack
6.
7. self.pcap_pkthdr = {}
8.
9. def run(self):
10. while True:
11. filename = self.proct.get()
12. try:
13. f = open(filename, "rb")
14. readlines = f.read()
15. f.close()
16. offset = 24
17. while len(readlines) > offset:
18. self.pcap_pkthdr["len"] = readlines[offset+12:offset+16]
19. try:
20. length = struct.unpack("I", self.pcap_pkthdr["len"])[0]
21. self.stack.put(readlines[offset+16:offset+16+length])
22. offset += length + 16
23. except Exception, errmsg:
24. logger.error("unpack pcap_pkthdr failed: %s" % errmsg)
25. except IOError, errmsg:
26. logger.error("open file failed: %s" % errmsg)
在獲得TCP數據段的數據包之後，問題就簡單多了，根據大家的具體需求就可以進行相應的分析了，我這里是想分析其HTTP協議數據，同樣也藉助了dpkt軟體包進行分析，如下：
1. def worker(memcache, packet, local_address, remote_address):
2. try:
3. p = dpkt.ethernet.Ethernet(packet)
4. if p.data.__class__.__name__ == "IP":
5. srcip = "%d.%d.%d.%d" % tuple(map(ord, list(p.data.src)))
6. dstip = "%d.%d.%d.%d" % tuple(map(ord, list(p.data.dst)))
7. if p.data.data.__class__.__name__ == "TCP":
8. tcpacket = p.data.data
9. if tcpacket.dport == 80 and dstip == local_address:
10. srcport = tcpacket.sport
11. key = srcip + ":" + str(srcport)
12. if tcpacket.data:
13. if not memcache.has_key(key):
14. memcache[key] = {}
15.
16. if not memcache[key].has_key("response"):
17. memcache[key]["response"] = None
18.
19. if memcache[key].has_key("data"):
20. memcache[key]["data"] += tcpacket.data
21. else:
22. memcache[key]["data"] = tcpacket.data
23. else:
24. if memcache.has_key(key):
25. memcache[key]["response"] = dpkt.http.Request(memcache[key]["data"])
26. try:
27. stackless.tasklet(connection)(memcache[key]["response"], local_address, remote_address)
28. stackless.run()
29. except Exception, errmsg:
30. logger.error("connect remote remote_address failed: %s", errmsg)
31. logger.debug("old headers(none content-length): %s", memcache[key]["response"])
32. memcache.pop(key)
33. except Exception, errmsg:
34. logger.error("dpkt.ethernet.Ethernet failed in worker: %s", errmsg)
如果大家只是想單純的獲取IP地址、埠、流量信息，那麼問題就更簡單了，這里只是拋磚引玉。

㈨ python中pypcap的參數問題

win10系統。使用pcap創建對象時候，無法給定網卡名。比如：mem1=pcap.pcap()這樣的話可以創建對象，對應的網卡就是無線網卡，程序可以運行想指定網卡的時候：mem1=pcap.pcap('MYPC')#MYPC是網卡名就無法運行所以我是網卡名弄錯了嘛==如果是的話去哪找網卡名==...展開

實際上就是pcap的網卡參數應該填什麼

㈩ 區塊鏈中平台類項目的以太坊是什麼

以太坊，Ethereum，簡稱ETH。2013年底，Vitalik發布以太坊白皮書，2014年7月，開始以太幣的預售。那時候圈內人稱這種代幣發行叫「幣眾籌」。通過為期42天的預售，以太坊團隊通過預售60102216個以太幣，募集了3萬多個比特幣；另外還對預售之前參與開發的早期貢獻者、長期從事項目研究的開發者分別按照當時以太幣發售總量的9.9%進行分配。所以以太坊正式發行時有 7200多萬個以太幣。以太坊預售結束後，採用工作量證明機制PoW進行挖礦，每年按照當時發行總量的26%獎勵礦工。2014年10月，以太坊將區塊的出塊時間從60秒縮減到了12秒，目前基本穩定在15秒，每個區塊獎勵5個以太幣。
雖然都是採用PoW挖礦機制，但是以太坊的出塊機制和比特幣還是有所區別。由於以太坊的出塊時間短，導致以太坊很容易形成孤塊，孤塊是指不在最長鏈上的區塊。比特幣的孤塊沒有任何區塊獎勵，但是在以太坊中，孤塊可以被引用，被引用的孤塊被稱為「叔塊」(uncle block)，它們打包的數據也會記錄在區塊鏈中。和比特幣不一樣，以太坊的叔塊有獎勵，每個叔塊最多可以獲得4.375個以太幣的獎勵。
以太坊是一個可編程的、圖靈完備的區塊鏈開發平台，相當於一個去中心化的全球計算機。在一個編程系統之上，通常會有一些編譯和執行的虛擬機來去做支撐。JAVA有JVM，在以太坊里，也有以太坊的虛擬機EVM，可以執行任意復雜的演算法代碼。開發者可以使用現有的JavaScript 或Python等編程語言，在以太坊上創造出自己想要的應用。通過以太坊的虛擬機，你可以很簡便地發行數字資產，編寫智能合約，建立和運行去中心化的應用，成立去中心化自治組織等。
以太幣（ETH）又被稱為以太坊內部的燃料。和幣類數字資產不同，以太坊除了用於轉賬，還用於支付智能合約的費用。
為了避免以太坊區塊鏈上充斥垃圾合約和垃圾應用，在以太坊上建立和運行智能合約，你必須用ETH支付智能合約費用。舉個例子，在以太坊區塊鏈上轉賬你新創造的數字資產，需要用ETH支付手續費，而不是你新創造的數字資產。