哈哈哈逗你玩-刘mark

原创已于 2024-10-11 16:16:45 修改 · 1k 阅读

5 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#dsp开发

于 2024-10-11 10:40:28 首次发布

Python3.8

Conda

Python

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

**import telnetlib
import threading
import time
tel=telnetlib.Telnet(host=‘192.168.43.207’)
time.sleep(1)
print(tel.read_until(b’name:‘).decode(‘utf-8’))
time.sleep(1)
tel.write(b’huawei\r’)
time.sleep(1)
print(tel.read_until(b’assword:‘).decode(‘utf-8’))
time.sleep(1)
tel.write(b’Admin_123!!\r’)
def print_tel(tel):
while True:
str=tel.read_very_eager().decode(‘utf-8’)
if str != ‘’:
print(str)
def send_tel(tel):
while True:
str=input(‘input:’)
if str.find(‘?’)!=-1:
tel.write((str).encode(‘utf-8’))
elif str.find(‘\t’)!=-1:
tel.write((str).encode(‘utf-8’))
else:
tel.write((str+‘\n’).encode(‘utf-8’))
thread1=threading.Thread(target=print_tel,kwargs={‘tel’:tel})
thread2=threading.Thread(target=send_tel,kwargs={‘tel’:tel})
thread1.start()
thread2.start()
time.sleep(1)
print(tel.read_until(b’name:‘).decode(‘utf-8’))
time.sleep(1)
tel.write(b’huawei\r’)
time.sleep(1)
print(tel.read_until(b’assword:‘).decode(‘utf-8’))
time.sleep(1)
tel.write(b’Admin_123!!\r’)
time.sleep(1)
print(tel.read_until(b’>‘).decode(‘utf-8’))
time.sleep(1)
tel.write(b’scr 0 t\r’)
time.sleep(1)
print(tel.read_until(b’>‘).decode(‘utf-8’))
time.sleep(1)
tel.write(b’dis cur\r’)
time.sleep(1)
import paramiko
ssh=paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)
ssh.connect(hostname=‘192.168.43.206’,username=‘huawei’,password=‘Admin_123!!!’)
ssh_invoke=ssh.invoke_shell()
def print_invoke(ssh_invoke):
while True:
str=ssh_invoke.recv(65535).decode(‘utf-8’)
if str!=‘’:
print(str)
def send_invoke(ssh_invoke):
while True:
str=input()
if str.find(‘?’)!=-1:
ssh_invoke.send(str)
elif str.find(‘\t’)!=-1:
ssh_invoke.send(str)
else:
ssh_invoke.send(str+‘\n’)
def sftp_ssh():
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)
ssh.connect(hostname=‘192.168.43.206’, username=‘huawei’, password=‘Admin_123!!!’)
ssh_sftp_client=ssh.open_sftp()
print(ssh_sftp_client.listdir())
ssh_sftp_client.get(‘logfile/log.log’,‘log.log’)
thread3=threading.Thread(target=print_invoke,kwargs={‘ssh_invoke’:ssh_invoke})
thread4=threading.Thread(target=send_invoke,kwargs={‘ssh_invoke’:ssh_invoke})
thread5=threading.Thread(target=sftp_ssh)
import pandas as pd
ssh2=paramiko.SSHClient()
ssh2.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)
ssh2.connect(hostname=‘192.168.43.206’,username=‘huawei’,password=‘Admin_123!!!’)
ssh2_invoke=ssh2.invoke_shell()
time.sleep(1)
ssh2_invoke.send(b’sc 0 t\n’)
time.sleep(1)
df= pd.DataFrame()
def statistics_interface():
ssh2_invoke.send(b’disp interface\n’)
time.sleep(2)
return ssh2_invoke.recv(65535).decode(‘utf-8’)
def des_interface():
ssh2_invoke.send(b’disp interface des\n’)
time.sleep(2)
return ssh2_invoke.recv(65535).decode(‘utf-8’)
def add_pd():
str_des_interface_list=des_interface().split()
str_statistics_interface_list=statistics_interface().split(‘GE’)
i=0
for str in str_des_interface_list:
if ‘GE’ in str:
df.loc[i,‘interface’]=str
df.loc[i,‘statics’]=str_statistics_interface_list[i+1]
i+=1
def rx_tx(s):
int1=s.find(‘input rate:’)
int3 = s.find(‘output rate:’)
int2=s.find(‘bits/sec’,int1,int3)
rx=s[int1:int2]
int4= s.find(‘bits/sec’,int3,len(s))
tx = s[int3:int4]
return {‘rx’:rx.replace(‘input rate:’,‘’),‘tx’:tx.replace(‘output rate:’,‘’)}
df[‘rx_tx’]=df[‘statics’].apply(rx_tx)
print(df.iloc[:,[0,2]])
import netmiko
def netmiko_ssh():
try:
ssh_net=netmiko.ConnectHandler(ip=‘192.168.43.208’, username=‘huawei’,password=‘Admin_123!’,device_type=‘huawei’,port=22)
print(ssh_net.send_command(‘disp cur’))
ssh_net.write_channel(‘sys i\t’)
time.sleep(1)
print(ssh_net.read_channel())
except Exception as e:
print(e)
finally:
pass
from pysnmp.hlapi import *
def snmp_get():
it = getCmd(SnmpEngine(),UsmUserData(userName=‘huawei’,
authKey=‘Admin_123!’, privKey=‘Admin_123!’,
authProtocol=usmHMACSHAAuthProtocol, privProtocol=usmAesCfb128Protocol),
UdpTransportTarget((‘2.2.2.2’,161)),ContextData(),
ObjectType(ObjectIdentity(‘1.3.6.1.4.1.2011.5.25.31.1.1.1.1.5.16842753’)))
a,b,c,d=next(it)
for item in d:
print(item)
it = getCmd(SnmpEngine(),
CommunityData(‘Admin_123!’),
UdpTransportTarget((‘192.168.43.206’, 161)),
ContextData(),
ObjectType(ObjectIdentity(‘1.3.6.1.4.1.2011.5.25.31.1.1.1.1.5.16842753’)))
# 1.3.6.1.2.1.31.1.1.1.6.
a, b, c, d = next(it)
for x in d:
print(x)
thread6=threading.Thread(target=snmp_get)
import scapy.layers.inet
from scapy.all import *
from scapy.layers.inet import *
from scapy.layers.l2 import *
import datetime
import threading

pkt=(Ether(src=‘00:00:00:00:00:01’,dst=‘00:00:00:00:00:01’,type=0x800)/IP(src=‘1.1.1.1’,dst=‘2.2.2.2’,ttl=100)

/TCP(sport=100,dport=100,flags=‘PASFR’)/Raw(‘AAAAAAA’))

pkt2=(Ether(src=‘00:00:00:00:00:01’,dst=‘00:00:00:00:00:01’,type=0x800)/IP(src=‘1.1.1.1’,dst=‘2.2.2.2’,ttl=100)

/ICMP(type=‘echo-reply’)/Raw(‘AAAAAAA’))

hexdump(pkt)

ls(Ether)

ls(IP)

ls(TCP)

ls(ICMP)

dict1=dict()

dict2=dict()

wrpcap(r’.\2222.pcap’,[pkt,pkt2],append=True)

def process_packet(packet):

if packet.haslayer(ICMP):

# print( packet[ICMP].type)

if packet[ICMP].type==8:

# print(str(packet[ICMP].seq))

dict1[str(packet[ICMP].seq)]=time.time()

elif packet[ICMP].type==0:

if str(packet[ICMP].seq) in dict1.keys():

dict1[str(packet[ICMP].seq)]=time.time()-dict1[str(packet[ICMP].seq)]

elif packet.haslayer(TCP):

if ‘SA’ in str(packet[TCP].flags) :

print(str(packet[TCP].flags))

print(packet)

sniff(prn=process_packet,filter=‘tcp’)

print(dict1)

i=0

sum1=0

for k,v in dict1.items():

print(k)

sum1=sum1+v

i=i+1

print(i)

print(str(sum1/i*1000)+‘ms’)

from scapy.all import *
from scapy.layers.all import *

import gzip

from base64 import b85decode

def _d(x: str) -> str:

return gzip.decompress(

b85decode(x.replace(“\n”, “”))

).decode()

DATA = _d(“”"

ABzY8N|hyM0{^91ZExbZ7XI#Eaioz}AWb2>6zJa3jGPeKXcNeglyY@-KbXWoE+IxqXv@Ff<IvJNyVvd

RMru`2KTnQ*-kxK=kS}1DTb^{gUgmupL9Lm#y7x?k{3AafB>m=n6}CHTV6)&I=xJ;}8aq!6UL>!9?$pv

`GMJXbYp80SsD}m)4js=fFWN&Z9pC^&;iWd2T;Oc#8Qj`#hV;aMX!&)3O3HkNH4X`cC!>{f3)6-KcVH

s<QeA8w{k!-R(&&s0BU)Zm<9@~S;x9lG&iU2I=)OS_{4K+y`7Yt#w2}0pYQOEr3ouK-&?KL`On_<c

lct7y<|chvh?8HV;Dvs{@?Qj9NV@5F|8gPShT~#^zVITjnOp>4Z)J<;u$39a{5<La1I7F3`s`A&yz_S

8pk;=3J7zS6)7tdbliopL#BZWG6s6{rU60}8ziKohy1A#jh?r{kVsEWGInRT9ffhAGeRzh#*Z_utKvG

J!8!h;;zVPl-L&)O46+<vLk+6kd<)k*S$R&ZsTtJ4T@6?+zhG_4qcv<#gRPcdz}6j|1u9q<#np0&TXz

4j+iUG^alOkQc?vy3=YAbK&|qIf1b>P2SVhR?&?j@145>yMs!3G@=R9R6kif=#Vs(Z_r%4vh)K<>Hq+

<<{$+8p6phA&wP968%zdMFDXfV{V<mRtsU~DPggHE@n^MG7_1>P|&lZX{1Sy0z`Z)r!Lrsw6wsVMpW?

HK2ltJ-jLqx0sNmFysrtOQHs2a&&|tz=2rn|GRIdZ)S?i&94$))<;o{#?SHIG~#@{`Oxho^)8Z*Xts+

>08!2bkEWTZVwAL^809Umhnh-p#34`C5KFu7+M?bN<8PW<Q?Ctyu;7%$}`zuctImgcD$->&e(6(>3vI

0^nSOmOLV#1WJMBznTlw4ISAr-uKC_)eM`&ZWNVS{&wla*c6)G>vc$%3CL3_+lz20L{GM;1_te<703i

?`_lI^WSS$(VmPk51VPUC0-X?v44uu1t2PkH(J-3Atb2f5W<EZ!WPz7Kp>%>Y0p*g=mT&CA#?gLQG

nOiHyYraJt+m_{t@zxV%GtwEUqJ4&4M%5Y*%gLH0kL?>Di_?FQ|Df#>3p6Bv4y1YER}}7d5RxDen3MKl

%l=PF){8<F!LndaJfe_2vz3m&oiG{AUNPBNw&cn $KaTeX parse error: Expected 'EOF', got '}' at position 16: ~l<@>TwVCUY`Z+8}̲O1S7f+~F(R&tk6?\dots$ >

Rn<4K#*sU<g`u+3ZU>iR>aI8mom)CpaNUWnS0o#jeZ};RS_A`+dJ44vVVpi<t6{4oP0AB^D2VY;QF7-

n#(IQ$|5&1452|KRNC4Z%1vK#EY77t=2Nd>_s9>i;mNIOV_R?23er;;32udbPPYetAO)8EQ`17Gf7XE

xTR#_{jS#DYC0ZV@}Ed*NEwwe3d}neYn)M>#>D8)Mv#ZOs&hfi8v?oJXQkPgv{a;n8C$T7-sS&5nVt64

3CMka!ezgMt}S4aQ?-&d7LdIqO<wT(I}c2#QvJLS7F7g@3+o;`O$l|;=9?z5VMKOw)VH3sxy3dkFI

VNI0ZDow2cBUb9e^Y30bhgn0_TP}DJK|GIDZnGc(&<5;MHt0_SeI2E2UA)*lCdrm9n%8|33&dPMA!($

BeGp4+_@b(ONDKsYh!a>CeMV{6fJ^!pV>J`AX&IdMSxL9KXbeelAWJWK~Z;XWKC==mrL15*J%=!MU$A

biCg2<ZRLTd={n`S{1;TnhM99#Zecb-t+3`zIPA&-{(_{AmKf(1?$G}lBDq8;}cl6&%9*#QNLVCwec<N

OhmKqF8P+pvEf7)U&VIVDTU23X?x<0nJ1(&U)3KeMCOEtquZmEVvr>9HoDTYBRLpzO|C_&2yd7U9S8d

x8u6XzCe5C^{HBn#8;J{Mv?fHQZ~T0kKTOV#{)L7MZw?8Zw=}F6I|`@;_cB9iCQFa!km})NMjV)0p5O0

It9Wbs6j_{N)eT^HLjgRUss%_=PMf&%F;P9u*ST}6hdA9j;chuibd1ImYp4qN$S<NtF8BPxssUBkQWnD

F&U$qCRv7lZBIj8;lIoec7~~f;fHt<+&bZd%3<qlx^{>!Ng6a)JBa`D>F0hdWe=uaEi`5|7}7xoy<ESn

?*0PX={#UqjeBZeWLU{q9#KCAV9)Iov0;<qJeLo=cam}bzQiLf)I5b|i7iBxP(mEZtL^NHVfqK

C4iRV~;jg|flR!@ $S5(GomD)aR0pt_-A~S5(GomD)aR0p%!kR2I@NomVW!P0cT<_uPI-J%$ u+d+}VRdhdoI{H!^yy9*

dz!#na_nk<X=;-}YF(<9U<#e(i8ahOW)Y<qfft(+$o!tCRd-W@8cYU3I6UzOFu1%Q63}nV&A58unUyf

%2RbGM)EFiI+9304%UFfb)cx46Ei!h!Wkw4sF> $k ‘1 Y > R 9 - R Y f 3 V A$ lCJ?Ts%S*%w&BF4{>)YAMz+=w

*xr_asB;yN6Dpn6q|b<UwHk}oTKi9D`m;tb`p5<hhN{OFC5v{lZo96UTceSs3s5)7cG#Uxypr6JsG8?

xi1$siwk3P`kwrfx{4t4<(L|e8QlwYYk+g0a+^K{&{mCav{ficYJI*Ap%%4%uFtE%{gW&zhaigCotIL

qaMC5x^QeKO^{v+fXnNMHCN9=Np+<jT7Lay-GBZvWNl-a_>=dIZJd|iQBr*L}VHN1f55%`jsx>}L6

<P-b`7X_NHCi!!f`?;IvE<E5`PAoA2^CPK^9J^45O2YRs)*m6e`G-%d(f9M+|!lJh2@=9txZ;RQWT(M

>}0SC;Q_b9 $KaTeX parse error: Expected '}', got 'EOF' at end of input: …{i@cIQy_4UqIdGU$ ?!ejC~XT@GkQ5paM

“”")

print(DATA)

ls(IP)
ls(TCP)

ls(ICMP)

ls(Dot1Q)

pkt=Ether(src=‘00:00:00:00:00:01’,dst=‘00:00:00:00:00:02’,type=‘VLAN’)/Dot1Q(vlan=100,type=‘IPv4’)/IP()/ICMP(type=8)/Raw(‘aaaaa’)

hexdump(pkt)

wrpcap(r’./3333.pcap’,pkt,append=True)

import os

dict3=dict()

for i in range(256):

dict3[‘192.168.43.’+str(i)]=[]

def send_packet(ip_addr):

for i in range(100):

send(IP(src=ip_addr)/TCP(dport=i,flags=‘S’),verbose=False)

time.sleep(0.1)

def process_packet(pkt):

if pkt.haslayer(IP):

if pkt[IP].src in dict3.keys():

if pkt.haslayer(TCP):

if ‘A’ in pkt[TCP].flags:

dict3[pkt[IP].src].append(pkt[TCP].sport)

def sniff_packet(prn):

sniff(prn=prn,iface=‘VMware Virtual Ethernet Adapter for VMnet1’)

print(conf.ifaces)

thread1=threading.Thread(target=sniff_packet,kwargs={‘prn’:process_packet})

thread1.start()

time.sleep(1)

for k,v in dict3.items():

threading.Thread(target=send_packet,kwargs={‘ip_addr’:k}).start()

while True:

time.sleep(1)

os.system(‘cls’)

for k,v in dict3.items():

if len(v)!=0:

print(‘%s open %s’%(k,v))

from pysnmp.hlapi import *
it = bulkCmd(SnmpEngine(),UsmUserData(userName=‘huawei’,
authKey=‘Admin_123!’, privKey=‘Admin_123!’,
authProtocol=usmHMACSHAAuthProtocol, privProtocol=usmAesCfb128Protocol),
UdpTransportTarget((‘2.2.2.2’,161)),ContextData(),
1,50,
ObjectType(ObjectIdentity(‘1.3.6.1.2.1.31.1.1.1.6.66’)))
it1 = getCmd(SnmpEngine(),UsmUserData(userName=‘huawei’,
authKey=‘Admin_123!’, privKey=‘Admin_123!’,
authProtocol=usmHMACSHAAuthProtocol, privProtocol=usmAesCfb128Protocol),
UdpTransportTarget((‘2.2.2.2’,161)),ContextData(),
ObjectType(ObjectIdentity(‘1.3.6.1.2.1.31.1.1.1.6.1’)))

1.3.6.1.2.1.31.1.1.1.6.66

1.3.6.1.2.1.31.1.1.1.18

for a,b,c,d in it:
for item in d:
for x in item:
if r’LIUJQ’ in str(str(x)):
for y in item:
print(y)
import socket
import netmiko
import time
import paramiko
import re
def handler1(title, instructions, prompt_list):
answers = []
if title:
print(title.strip())
if instructions:
print(instructions.strip())
if len(prompt_list)!=0:
for prompt, show_input in prompt_list:
print(prompt.strip(), end=" “)
if ‘Enter password1:’ in prompt :
answers.append(‘Admin_123!’)
time.sleep(1)
elif ‘initial password poses security risks’ in prompt :
answers.append(input())
else:
answers.append(input())
print(answers)
return answers
# response = []
#
# for prompt, echo in prompt_list:
# print(prompt.strip(), end=” ")
# if ‘Enter password:’ in prompt:
# response.append(input()A)
# time.sleep(1)
# elif ‘Continue? [Y/N]:’ in prompt:
# response.append(‘Y’)
# elif ‘old’ in prompt:
# response.append(‘Admin_123!’)
# elif ‘enter new password:’ in prompt:
# response.append(‘Admin_123!!!’)
# elif ‘confirm new password:’ in prompt:
# response.append(‘Admin_123!!!’)
# print(response)
#
# return response

ssh_client=paramiko.SSHClient()

ssh_client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)

ssh_client.connect(hostname=‘192.168.43.208’,username=‘huawei’,password=‘Admin_123!’)

transport=paramiko.Transport((‘192.168.43.208’,22))

transport.start_client(timeout=1000)

transport.auth_interactive_dumb(username=‘huawei’,handler= handler1,submethods=‘disp cur’)

sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)

sock.connect((“192.168.43.206”, 22))

transport=paramiko.Transport(sock)

transport.start_client(timeout=1000)

transport.auth_interactive_dumb(username=‘huawei’)

channel=transport.open_channel(kind=‘session’)

channel.exec_command(‘disp cur\n’)

time.sleep(1)

print(channel.recv(65535).decode(‘utf-8’))

str1=“”“GigabitEthernet1/1/0 current state : UP
Line protocol current state : DOWN
Link quality grade : GOOD
Description:CNET DNS2 SERVER
Route Port,The Maximum Transmit Unit is 4470
Internet protocol processing : disabled
IP Sending Frames’ Format is PKTFMT_ETHNT_2, Hardware address is 286e-d495-abe1
The Vendor PN is MXPD-243S
The Vendor Name is HG GENUINE
Port BW: 1G, Transceiver max BW: 1G, Transceiver Mode: SingleMode
WaveLength: 1310nm, Transmission Distance: 10km
Rx Power: -5.44dBm, Warning range: [-20.00, -3.00]dBm
Tx Power: -6.44dBm, Warning range: [-9.00, -3.00]dBm
Loopback:none, full-duplex mode, negotiation: disable, Pause Flowcontrol:Receive Enable and Send Enable
Last physical up time : 2023-08-11 10:36:48 UTC+08:00
Last physical down time : 2023-08-11 10:36:43 UTC+08:00
Current system time: 2024-10-05 14:25:52+08:00
Statistics last cleared:never
Last 10 seconds input rate: 119640 bits/sec, 201 packets/sec
Last 10 seconds output rate: 155256 bits/sec, 267 packets/sec
Input: 184349502270134 bytes, 277953494937 packets
Output: 488142456561621 bytes, 1352682789974 packets
Input:
Unicast: 277863860229 packets, Multicast: 84176453 packets
Broadcast: 5458255 packets, JumboOctets: 3426481045 packets
CRC: 50 packets, Symbol: 0 packets
Overrun: 0 packets, InRangeLength: 0 packets
LongPacket: 0 packets, Jabber: 0 packets, Alignment: 0 packets
Fragment: 14 packets, Undersized Frame: 0 packets
RxPause: 0 packets
Output:
Unicast: 1344254474787 packets, Multicast: 178140518 packets
Broadcast: 8250174669 packets, JumboOctets: 32009948077 packets
Lost: 0 packets, Overflow: 0 packets, Underrun: 0 packets
System: 0 packets, Overrun: 0 packets
TxPause: 0 packets
Input bandwidth utilization : 0.02%
Output bandwidth utilization : 0.02% “””
import os
import threading

os.system(‘cls’)

rx_tx=re.finditer(‘Gi\D*\d/\d/\d|(input rate:|output rate:)\s\d{1,}’,str1)

for it in rx_tx:

str2=it.group()

print(str2)

print(re.split(r’:',str1))

re_split=re.split(r"😐,|\s+",str1)

print(re_split)

import socket

def server1():

server=socket.socket()

server.bind((‘192.168.43.1’,4000))

server.listen(100)

recv, addr = server.accept()

while True:

print(‘%s’% str(addr))

print(recv.recv(65535).decode(‘utf-8’))

def client1():

client=socket.socket()

client.connect((‘192.168.43.1’,4000))

while True:

client.send(‘fuck!’.encode(‘utf-8’))

time.sleep(10)

thread1=threading.Thread(target=server1)

thread2=threading.Thread(target=client1)

thread1.start()

thread2.start()

from scapy.all import *
from scapy.layers.inet import *
from scapy.layers.l2 import *
import re
def process_packet(pkt):
if pkt.haslayer(TCP):
if pkt.haslayer(Raw):
payload_str=str(pkt[Raw].load)
items=re.finditer(r’user.*pass’,payload_str,re.I)
if items==None:
print(‘None’)
for item in items:
print(payload_str)
sniff(offline=r’C:\Users\86186\Desktop\111.pcap.pcapng’,prn=process_packet)
print(conf.ifaces)
wrpcap(r’./11111.pcap’,sniff(count=10))

# print(conf.ifaces)

pkt=Ether()/IP(src=‘1.1.1.1’)/TCP(sport=1000,flags=‘S’)/Raw(‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA’)

# ls(pkt)

# print(explore(scapy.layers.l2))

print(explore(scapy.layers.inet))

# explore(scapy.layers.inet6)

ls(Ether)

dir(TCP)

sendp(pkt,iface=‘VMware Virtual Ethernet Adapter for VMnet1’)

if pkt.haslayer(‘TCP’):

print(pkt[‘TCP’].dport)

def packet_callback(packet):

if packet[TCP].payload:

mypacket = str(packet[TCP].payload)

if ‘user’ in mypacket.lower() or ‘pass’ in mypacket.lower():

print(f"[*] Destination: {packet[IP].dst}")

print(f"[*] {str(packet[TCP].payload)}")

def main():

# ç›‘å¬é‚®ä»¶åè®®å¸¸ç”¨ç«¯å£

# å‚æ•°storeï¼ŒæŠŠå®ƒè®¾ä¸º0ä»¥åŽï¼ŒScapyå°±ä¸ä¼šå°†ä»»ä½•æ•°æ®åŒ…ä¿ç•™åœ¨å†…å˜é‡Œ

sniff(filter=‘tcp port 110 or tcp port 25 or tcp port 143’,

prn=packet_callback, store=0)

def fengxi(pkt):

flag = False

ip_layer = pkt.getlayer(‘IP’)

tcp_layer = pkt.getlayer(‘TCP’)

if tcp_layer:

data = {

‘time’: ip_layer.time,

“ip”: {‘src’: ip_layer.src, ‘dst’: ip_layer.dst, ‘version’: ip_layer.version},

“tcp”: {‘seq’: tcp_layer.seq, ‘ack’: tcp_layer.ack}

}

if pkt.haslayer(HTTPRequest):

data[‘type’] = ‘request’

http_header = pkt[HTTPRequest].fields

http_header.pop(“Headers”)

data[‘hearder’] = http_header

flag = True

elif pkt.haslayer(HTTPResponse):

data[‘type’] = ‘response’

http_header = pkt[HTTPResponse].fields

http_header.pop(“Headers”)

data[‘hearder’] = http_header

flag = True

if flag:

if ‘Raw’ in pkt:

payload = pkt[‘Raw’].load

if payload:

if isinstance(payload, str):

data[‘data’] = payload

print data

from ncclient import manager
from ncclient.xml_ import to_ele
m=manager.connect(host=‘2.2.2.2’,username=‘dlunicom1’,password=‘Admin_123!’,hostkey_verify=False,look_for_keys=False,
device_params={‘name’:‘huawei’})
edit=“”“

merge
rollback-on-error

300

1
0

“””
to_xml=to_ele(edit)
print(to_xml)
print(m.rpc(to_xml))

import paramiko

import time

ssh=paramiko.SSHClient()

ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)

ssh.connect(hostname=‘2.2.2.2’,username=‘huawei’,password=‘Admin@123’)

vty=ssh.invoke_shell()

vty.send(‘scr 0 t\n’)

time.sleep(1)

print(vty.recv(65535).decode(‘utf-8’))

vty.send(‘sys i\n’)

time.sleep(1)

vty.send(‘vlan 1\n’)

time.sleep(1)

vty.send(‘interface vlan 1\n’)

time.sleep(1)

vty.send(‘ip address 192.168.255.1 30\n’)

time.sleep(1)

print(vty.recv(65535).decode(‘utf-8’))

vty.send(‘disp cur interface vlan 1\n’)

time.sleep(1)

print(vty.recv(65535).decode(‘utf-8’))

vty.send(‘ip route-static 0.0.0.0 0.0.0.0 null0\n’)

time.sleep(1)

print(vty.recv(65535).decode(‘utf-8’))

vty.send(‘disp ip routing\n’)

time.sleep(1)

print(vty.recv(65535).decode(‘utf-8’))

vty.send(‘interface ge1/0/1\n’)

time.sleep(1)

vty.send(‘undo portsw\n’)

vty.send(‘ip address 10.1.1.1 24\n’)

time.sleep(1)

vty.send(‘interface ge1/0/2\n’)

time.sleep(1)

vty.send(‘undo portsw\n’)

vty.send(‘ip address 10.1.2.1 24\n’)

time.sleep(1)

vty.send(‘disp cur int ge1/0/1\n’)

time.sleep(1)

print(vty.recv(65535).decode(‘utf-8’))

vty.send(‘disp cur int ge1/0/2\n’)

time.sleep(1)

print(vty.recv(65535).decode(‘utf-8’))

import paramiko
import time
ssh=paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)
ssh.connect(hostname=‘2.2.2.2’,username=‘huawei’,password=‘Admin@123’)
vty=ssh.invoke_shell()
vty.send(‘dir\n’)
time.sleep(1)
print(vty.recv(65535).decode(‘utf-8’))

sftp1=ssh.open_sftp()

sftp=sftp1.put(‘command.txt’,‘command.txt’)

from pysnmp.hlapi import *
it = getCmd(SnmpEngine(),UsmUserData(userName=‘admin’,
authKey=‘Huawei@123’, privKey=‘Huawei@123’,
authProtocol=usmHMACSHAAuthProtocol, privProtocol=usmAesCfb128Protocol),
UdpTransportTarget((‘2.2.2.2’,161)),
ContextData(),
ObjectType(ObjectIdentity(‘1.3.6.1.4.1.2011.5.25.31.1.1.1.1.5.16842753’)))
a,b,c,d=next(it)
for x in d:
print(x)

import paramiko

import time

ssh=paramiko.SSHClient()

ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)

ssh.connect(hostname=‘2.2.2.2’,username=‘huawei’,password=‘Admin@123’)

str1=‘’

vty=ssh.invoke_shell()

vty.send(‘scr 0 t\n’)

file=open(‘command.txt’,‘r+’)

for line in file:

time.sleep(2)

vty.send(line+‘\n’)

time.sleep(1)

print(vty.recv(65535).decode(‘utf-8’))

# vty.send(‘scr 0 t\n’)

# time.sleep(1)

# print(vty.recv(65535).decode(‘utf-8’))

from ncclient import manager
from ncclient.xml_ import to_ele
m=manager.connect(device_params={‘name’:‘huawei’},host=‘2.2.2.2’,username=‘huawei’,password=‘Admin@123’,hostkey_verify=False)

config=“”"

merge

rollback-on-error

IPv4

“”"

cc=to_ele(config)

print(m.rpc(cc))

get=“”"

“”"

getxml=to_ele(get)

print(m.rpc(getxml))

sniff(prn=process_packet,iface=‘Intel® Wi-Fi 6 AX201 160MHz’,filter=(‘icmp[icmptype]=icmp-echo’))
from paramiko import SSHClient
from pysnmp.hlapi import *
from ncclient import manager
from ncclient.xml_ import to_ele
import paramiko
import threading
import time
import socket
def print_help():
# print(help(SSHClient))
# print(help(pysnmp.hlapi.cmdgen))
pass
def ssh_client():
ssh_session=SSHClient()
ssh_session.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)
ssh_session.connect(hostname=‘192.168.43.200’,username=‘huawei’,password=‘Admin_123!’,
port=22)
ssh_invoke=ssh_session.invoke_shell()
ssh_invoke.send(b’n\n’)
print(ssh_invoke.recv(65535).decode(‘utf-8’))
time.sleep(1)
ssh_invoke.send(b’scr 0 t \n’)
print(ssh_invoke.recv(65535).decode(‘utf-8’))
time.sleep(1)
ssh_invoke.send(b’sys i\n’)
print(ssh_invoke.recv(65535).decode(‘utf-8’))
time.sleep(1)
ssh_invoke.send(b’bgp 100\n’)
print(ssh_invoke.recv(65535).decode(‘utf-8’))
time.sleep(1)
ssh_invoke.send(b’peer \n’)
time.sleep(1)
print(ssh_invoke.recv(65535).decode(‘utf-8’))
time.sleep(1)
ssh_invoke.send(b’disp cur\n’)
time.sleep(1)
print(ssh_invoke.recv(65535).decode(‘utf-8’))
time.sleep(1)
def snmp_getcmd():
g = getCmd(SnmpEngine(),
UsmUserData(userName=‘huawei’, authKey=‘Admin_123!’, privKey=‘Admin_123!’,authProtocol=usmHMACSHAAuthProtocol,
privProtocol=usmAesCfb128Protocol),
UdpTransportTarget((‘192.168.56.2’, 161)),
ContextData(),
ObjectType(ObjectIdentity(‘SNMPv2-MIB’, ‘sysDescr’, 0)))
a,b,c,d=next(g)
for item in d:
for x in item:
print(x)
def netconf_rpc():
nc=manager.connect(host=‘192.168.43.200’,device_params={‘name’:‘huawei’},username=‘huawei’,password=‘Admin_123!’,hostkey_verify=False)
get=“”"

“”"
getxml=to_ele(get)
print(nc.rpc(getxml))
def socket_1():
print(help(socket))
def socket_server():
sk1=socket.socket()
sk1.bind((‘192.168.43.1’,8800))
sk1.listen(1)
conn,address=sk1.accept()
while True:
data=conn.recv(1024).decode(‘utf-8’)
print(f’client: {data}‘)
if data==‘break’:
break
msg = input(“è¯·è¾“å…¥æœåŠ¡ç«¯å‘é€çš„æ¶ˆæ¯ï¼š”)
conn.send(msg.encode(“UTF-8”))
thread1 = threading.Thread(target=socket_server)
thread1.start()
def socket_client():
skt2=socket.socket()
skt2.connect((‘192.168.43.1’,8800))
while True:
msg=input(‘send to server:’)
if msg==‘break’:
break
skt2.send(msg.encode(‘utf-8’))
data = skt2.recv(1024).decode(‘utf-8’)
print(f’client: {data}’)
thread2=threading.Thread(target=socket_client)
thread2.start()
#1. åº“æ–‡ä»¶ä½¿ç”¨ï¼šä½¿ç”¨pysnmpåº“ï¼Œç¼–å†™ä¸€ä¸ªPythonè„šæœ¬ï¼Œä»ŽIPåœ°å€ä¸º192.168.0.2çš„äº¤æ¢æœº1èŽ·å–ç³»ç»Ÿåç§°ï¼ˆsysNameï¼‰å’Œç³»ç»Ÿæè¿°ï¼ˆsysDescrï¼‰
import threading
from pysnmp.hlapi import *
it=getCmd(SnmpEngine(),
UsmUserData(userName=‘huawei’,authKey=‘Admin_123!’, privKey=‘Admin_123!’, authProtocol=usmHMACSHAAuthProtocol, privProtocol=usmAesCfb128Protocol),
UdpTransportTarget((‘2.2.2.2’,161)),ContextData(),
ObjectType(ObjectIdentity(‘SNMPv2-MIB’, ‘sysDescr’, 0)))
for a,b,c,d in it:
for item in d:
print(item)
it2=getCmd(SnmpEngine(),
UsmUserData(userName=‘huawei’,authKey=‘Admin_123!’, privKey=‘Admin_123!’, authProtocol=usmHMACSHAAuthProtocol, privProtocol=usmAesCfb128Protocol),
UdpTransportTarget((‘2.2.2.2’,161)),ContextData(),
ObjectType(ObjectIdentity(‘SNMPv2-MIB’, ‘sysName’, 0)))
for a,b,c,d in it2:
for item in d:
print(item)
#2. åº“æ–‡ä»¶ä½¿ç”¨ï¼šä½¿ç”¨scapyåº“ï¼Œæž„é€ ä¸€ä¸ªICMPè¯·æ±‚æ•°æ®åŒ…ï¼ŒæºIPä¸º192.168.0.1ï¼Œç›®æ ‡IPä¸º192.168.1.2ï¼Œå¹¶å‘é€è¯¥æ•°æ®åŒ…ã€‚
from scapy.all import *
from scapy.layers.inet import *
print(conf.ifaces)

def process_packet(pkt):

hexdump(pkt)

def sniff_packet(prn):

sniff(prn=prn,iface=‘Intel® Wi-Fi 6 AX201 160MHz’,filter=‘icmp’)

thread1=threading.Thread(target=sniff_packet,kwargs={‘prn’:process_packet})

thread1.start()

pkt=IP(src=‘192.168.0.1’,dst=‘192.168.1.2’)/ICMP(type=‘echo-request’)/Raw(‘AAAAAAAAAA’)
send(pkt)
time.sleep(1)
#ä½¿ç”¨pythonpingå’Œsocketåº“ï¼Œåˆ†åˆ«å®žçŽ°å¯¹192.168.1.2çš„è¿žé€šæ€§æ£€æµ‹ã€‚æ¯”è¾ƒä¸¤ç§æ–¹æ³•çš„ä¼˜ç¼ºç‚¹ã€‚
import pythonping
import socket

print(pythonping.ping(‘2.2.2.2’))

sock=socket.socket()

try:

sock.connect((‘2.2.2.2’,2222))

except Exception as e:

print(e)

print(‘2.2.2.2:2222 is not alive’)

else:

print(‘2.2.2.2:22 is alive’)

finally:

pass

#pythonping åªèƒ½æ£€æµ‹åœ°å€æ˜¯å¦å˜æ´»ï¼Œsocketå¯ä»¥æŽ¢æµ‹ç«¯å£

ä½¿ç”¨pysharkæ•èŽ·ç½‘ç»œæµé‡ï¼Œç„¶åŽä½¿ç”¨numpyå’Œpandaså¯¹æ•èŽ·çš„æ•°æ®è¿›è¡Œåˆ†æžï¼Œæå–å‡ºæ‰€æœ‰ICMPæ•°æ®åŒ…çš„ç»Ÿè®¡ä¿¡æ¯ï¼Œå¦‚å¹³å‡å¤§å°ã€æœ€å¤§å¤§å°ã€æœ€å°å¤§å°ç‰

import pyshark
import pandas
from scapy.all import *
import numpy
pd=pandas.DataFrame({‘ip_address’:[],‘send_time’:[],‘receive_time’:[],‘seq’:[],‘rtt_time’:[]})

ls(ICMP)

ls(IP)

def process_icmp_packet(pkt):
if pkt.haslayer(ICMP):
if pkt[ICMP].type8:
ip_address = str(pkt[IP].dst)
pd.loc[len(pd)]=[ip_address,time.time(),‘’,pkt[ICMP].seq,‘’]
elif pkt[ICMP].type0:
ip_address = str(pkt[IP].src)
pd.loc[(pd[‘seq’]==pkt[ICMP].seq)&(pd[‘ip_address’]==ip_address),‘receive_time’]=time.time()
pd[‘rtt_time’]=pd[[‘receive_time’,‘send_time’]].apply(lambda x: x[‘receive_time’]-x[‘send_time’],axis=1)

def sniff_packet(prn):

sniff(prn=prn,iface=‘Intel® Wi-Fi 6 AX201 160MHz’,filter=‘icmp’,count=10)

thread1=threading.Thread(target=sniff_packet,kwargs={‘prn’:process_icmp_packet})

thread1.start()

def process_icmp_packet2(pkt):
if ‘ICMP’ in pkt.highest_layer and ‘ICMPv6’ not in pkt:
if int(pkt.icmp.type)==8:
ip_address = str(pkt.ip.dst)
pd.loc[len(pd)] = [ip_address, time.time(), ‘’, int(pkt.icmp.seq), ‘’]
elif int(pkt.icmp.type)0:
ip_address = str(pkt.ip.src)
pd.loc[(pd[‘seq’] == int(pkt.icmp.seq)) & (pd[‘ip_address’] == ip_address), ‘receive_time’] = time.time()
pd[‘rtt_time’] = pd[[‘receive_time’, ‘send_time’]].apply(lambda x: x[‘receive_time’] - x[‘send_time’],axis=1)
elif ‘TCP’ in pkt:
print(pkt.tcp.field_names)
cap=pyshark.LiveCapture(interface=r’\Device\NPF_{3B71C1E1-4D16-40C1-AD4D-9FDFF01E7B89}‘)
cap.apply_on_packets(process_icmp_packet2,packet_count=100)
time.sleep(10)
print(pandas.pivot_table(pd,index=[‘ip_address’],values=[‘rtt_time’],aggfunc=‘mean’))
print(pandas.pivot_table(pd,index=[‘ip_address’],values=[‘rtt_time’],aggfunc=‘max’))
print(pandas.pivot_table(pd,index=[‘ip_address’],values=[‘rtt_time’],aggfunc=‘min’))
import pyshark
packets=pyshark.FileCapture(input_file=r’C:\Users\86186\Desktop\03.pcapng’,display_filter='tcp.port23’)
#test=pyshark.LiveCapture(interface=r’\Device\NPF_{3B71C1E1-4D16-40C1-AD4D-9FDFF01E7B89}')

æŠ“å–telnetç”¨æˆ·åå¯†ç ï¼š

for packet in packets:
# print(packet.highest_layer)
if packet.highest_layer==‘TELNET’:
print(packet.TELNET.get_field(‘data’))
packets.close()
packets2=pyshark.FileCapture(input_file=r’C:\Users\86186\Desktop\03.pcapng’,display_filter=‘ip’)
#test=pyshark.LiveCapture(interface=r’\Device\NPF_{3B71C1E1-4D16-40C1-AD4D-9FDFF01E7B89}')

ç»Ÿè®¡IPæºè¿žæŽ¥æ•°é‡

dict1=dict()
for packet in packets2:
if packet.ip.src in dict1.keys():
dict1[packet.ip.src]+=1
elif packet.ip.src not in dict1.keys():
dict1[packet.ip.src]=1
print(dict1)
packets2.close()
packets3=pyshark.FileCapture(input_file=r’C:\Users\86186\Desktop\03.pcapng’,display_filter=‘ip’)
#test=pyshark.LiveCapture(interface=r’\Device\NPF_{3B71C1E1-4D16-40C1-AD4D-9FDFF01E7B89}')

ç»Ÿè®¡tcpç«¯å£å·

dict2=dict()
for packet in packets3:
if ‘tcp’ in packet:
if packet.tcp.srcport in dict2.keys():
dict2[packet.tcp.srcport]+=1
elif packet.tcp.srcport not in dict1.keys():
dict2[packet.tcp.srcport]=1
print(dict2)
packets3.close()
packets4=pyshark.FileCapture(input_file=r’C:\Users\86186\Desktop\03.pcapng’)
#test=pyshark.LiveCapture(interface=r’\Device\NPF_{3B71C1E1-4D16-40C1-AD4D-9FDFF01E7B89}')

ç»Ÿè®¡mac

dict3=dict()
for packet in packets4:
if ‘eth’ in packet:
if packet.eth.src in dict3.keys():
dict3[packet.eth.src]+=1
elif packet.eth.src not in dict3.keys():
dict3[packet.eth.src] = 1
list1=dict3.values()
#èŽ·å–æœ€å¤šçš„MACæ•°é‡
for key,value in dict3.items():
if value==max(list1):
print(key+“:”+str(value))
packets4.close()
import pyshark
packets=pyshark.FileCapture(input_file=r’C:\Users\86186\Desktop\03.pcapng’)
‘’’
def print_highest_layer(pkt):
print(pkt.highest_layer)
packets.apply_on_packets(print_highest_layer)
‘’’
for packet in packets:
if ‘tcp’ in packet:
########## æ‰“å°tcp udp è½½è·
‘’’
if ‘payload’ in packet.tcp.field_names:
str=‘’
for c in packet.tcp.payload.split(‘:’):
str=str+chr(int(c,16))
if ‘baidu’ in str:
print(str)
if ‘payload’ in packet.tcp.field_names:
print(packet.tcp.time_delta)
print(packet.tcp.len)
float1=float(packet.tcp.time_delta)
print(type(float1))
print(packet.tcp.field_names)
‘’’
if ‘TLS’ in packet.highest_layer:
print(packet.TLS.field_names)
elif ‘HTTP’ in packet.highest_layer:
print(packet.http.field_names)
elif ‘SSH’ in packet.highest_layer:
print(packet.ssh.field_names)
elif ‘TELNET’ in packet.highest_layer:
print(packet.telnet.field_names)
print(packet.telnet.get_field_value(‘data’))
elif ‘udp’ in packet:
print(packet.udp.field_names)
if ‘DNS’ in packet.highest_layer:
print(packet.dns.field_names)
elif ‘ICMP’ in packet.highest_layer:
if ‘ICMPV6’ in packet.highest_layer:
print(packet.icmpv6.field_names)
else :
pass
# print(packet.icmp.field_names)
elif ‘ISIS’ in packet.highest_layer:
print(packet.isis.field_names)
elif ‘ARP’ in packet.highest_layer:
print(packet.arp.field_names)
‘’’
getCmdåªèƒ½ç”¨é€‚ç”¨äºŽOIDå€¼æ˜¯ä¸€ä¸ªå¶åèŠ‚ç‚¹çš„æƒ…å†µå°±æ¯”å¦‚è®¾å¤‡çš„åå—åªæœ‰ä¸€ä¸ªï¼Œè€ŒbulkCmdæ˜¯ç”¨äºŽèŠ‚ç‚¹ä¸‹è¿˜æœ‰å¶åèŠ‚ç‚¹çš„æƒ…å†µï¼Œ
å°±æ¯”å¦‚æŸ¥æŽ¥å£åç§°ï¼Œæ¯ä¸ªæŽ¥å£æ˜¯ä¸€ä¸ªèŠ‚ç‚¹ï¼Œä½†æ˜¯çˆ¶èŠ‚ç‚¹æ˜¯åŒä¸€ä¸ªï¼Œå°±ç”¨è¿™ä¸ªçˆ¶èŠ‚ç‚¹æŸ¥è¯¢ã€‚
‘’’
from pysnmp.hlapi import *
ip = ‘10.154.157.102’
getinfos = bulkCmd(
SnmpEngine(),
UsmUserData(userName=‘admin’,authKey=‘Huawei@123’,privKey=‘Huawei@123’,authProtocol=usmHMACSHAAuthProtocol,privProtocol=usmAesCfb128Protocol),
UdpTransportTarget((ip,161)) ,
ContextData(),0,50,
ObjectType(ObjectIdentity(‘1.3.6.1’)),
)
print(getinfos)
result = []
for (errorIndication, errorStatus, errorIndex, varBinds) in getinfos:
if not errorIndication and not errorStatus:
oid_value = []
for varBind in varBinds:
# result = ‘,’.join([x.prettyPrint() for x in varBind])
#oid_value = [x.prettyPrint() for x in varBind]
oid_value = [x for x in varBind]
result.append(oid_value)
for i in result:
print(i)**