rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
def __elt2pkt(self, elt): | def _elt2pkt(self, elt): | def __elt2pkt(self, elt): return elt |
def __elt2sum(self, elt): | def _elt2sum(self, elt): | def __elt2sum(self, elt): return elt.summary() |
if self.__elt2pkt(r).haslayer(p): | if self._elt2pkt(r).haslayer(p): | def __repr__(self): stats={TCP:0,UDP:0,ICMP:0} other = 0 for r in self.res: f = 0 for p in stats: if self.__elt2pkt(r).haslayer(p): stats[p] += 1 f = 1 break if not f: other += 1 s = "" for p in stats: s += " %s:%i" % (p.name,stats[p]) s += " Other:%i" % other return "<%s:%s>" % (self.listname,s) |
print self.__elt2sum(r) | print self._elt2sum(r) | def summary(self, prn=None): for r in self.res: if prn is None: print self.__elt2sum(r) else: print prn(r) |
print "%04i %s" % (i,self.__elt2sum(self.res[i])) | print "%04i %s" % (i,self._elt2sum(self.res[i])) | def nsummary(self,prn=None): for i in range(len(self.res)): if prn is None: print "%04i %s" % (i,self.__elt2sum(self.res[i])) else: print "%04i %s" % (i,prn(self.res[i])) |
hexdump(self.__elt2pkt(p)) | hexdump(self._elt2pkt(p)) | def hexdump(self): for p in self: hexdump(self.__elt2pkt(p)) |
p = self.__elt2pkt(self.res[i]) print "%04i %s %s" % (i,p.sprintf("%.time%"),self.__elt2sum(self.res[i])) | p = self._elt2pkt(self.res[i]) print "%04i %s %s" % (i,p.sprintf("%.time%"),self._elt2sum(self.res[i])) | def hexraw(self): for i in range(len(self.res)): p = self.__elt2pkt(self.res[i]) print "%04i %s %s" % (i,p.sprintf("%.time%"),self.__elt2sum(self.res[i])) if p.haslayer(Raw): hexdump(p.getlayer(Raw).load) |
def __elt2pkt(self, elt): | def _elt2pkt(self, elt): | def __elt2pkt(self, elt): return elt[1] |
def __elt2sum(self, elt): | def _elt2sum(self, elt): | def __elt2sum(self, elt): return "%s ==> %s" % (elt[0].summary(),elt[1].summary()) |
def i2m(self, pkt, i): return str(i) def m2i(self, pkt, m): return self.cls(m) | def i2m(self, pkt, i): return str(i) | |
def answers(self, other): return 1 | def guess_payload_class(self): np = self.next_payload if np == 0: return Padding elif np < len(ISAKMP_payload_type): pt = ISAKMP_payload_type[np] return globals().get("ISAKMP_payload_%s" % pt, ISAKMP_payload) else: return ISAKMP_payload | |
ShortField("length",None), | FieldLenField("len",None,"load","H",shift=-8), | def post_build(self, p): if self.length is None: p = p[:24]+struct.pack("!I",len(p))+p[28:] return p |
ShortField("res",0), XIntField("enc",0x80010005L), XIntField("hash",0x80020002L), XIntField("auth",0x80030001L), XIntField("group",0x80040002L), XIntField("life_type",0x800b0001L), XIntField("durationh",0x000c0004L), | ShortField("res2",0), ISAKMPTransformSetField("transforms",None,"len") | def post_build(self, p): if self.length is None: p = p[:24]+struct.pack("!I",len(p))+p[28:] return p |
FieldLenField("length",None,"load","H",shift=-4), | FieldLenField("len",None,"trans","H",shift=-8), | def post_build(self, p): if self.length is None: p = p[:24]+struct.pack("!I",len(p))+p[28:] return p |
ISAKMPAttributeTypes= { "Encryption": (1, { "DES-CBS" : 1, | ISAKMPAttributeTypes= { "Encryption": (1, { "DES-CBC" : 1, | def i2m(self, pkt, x): if x is None: f = pkt.get_field(self.fld) x = f.i2len(pkt,pkt.getfieldval(self.fld)) return x |
except pcapc.EXCEPTION: | except pcap.pcapc.EXCEPTION: | def get_working_if(): try: return pcap.lookupdev() except pcapc.EXCEPTION: return 'lo' |
self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2**30) | self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 0) | def __init__(self, type = ETH_P_ALL, filter=None, promisc=None, iface=None): self.type = type self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2**30) if conf.except_filter: if filter: filter = "(%s) and not (%s)" % (filter, conf.exc... |
_ = None | def autorun_commands(cmds,verb=0): sv = conf.verb _ = None try: conf.verb = verb interp = ScapyAutorunInterpreter(globals()) cmd = "" for l in cmds.splitlines(): sys.stderr.write(str(sys.__dict__.get("ps1",ColorPrompt()))) print l cmd += "\n"+l if interp.runsource(cmd): sys.stderr.write(sys.__dict__.get("ps2","... ")) ... | |
return _ | try: return _ except NameError: return | def autorun_commands(cmds,verb=0): sv = conf.verb _ = None try: conf.verb = verb interp = ScapyAutorunInterpreter(globals()) cmd = "" for l in cmds.splitlines(): sys.stderr.write(str(sys.__dict__.get("ps1",ColorPrompt()))) print l cmd += "\n"+l if interp.runsource(cmd): sys.stderr.write(sys.__dict__.get("ps2","... ")) ... |
inet_nton = socket.inet_pton | inet_pton = socket.inet_pton | def inet_aton(x): if x == "255.255.255.255": return "\xff"*4 else: return socket.inet_aton(x) |
scapy_module = sys.argv[0] | scapy_module = sys.argv[0][sys.argv[0].rfind("/")+1:] | def usage(): print "Usage: scapy.py [-s sessionfile]" sys.exit(0) |
if session.has_key("__builtins__"): del(session["__builtins__"]) for k in session.keys(): if type(session[k]) in [types.ClassType, types.ModuleType]: print "[%s] (%s) can't be saved. Deleted." % (k, type(session[k])) del(session[k]) try: os.rename(scapy.conf.session, scapy.conf.session+".bak") except OSError: pass f=... | save_session(scapy.conf.session, session) | def attr_matches(self, text): m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text) if not m: return expr, attr = m.group(1, 3) try: object = eval(expr) except: object = eval(expr, session) if isinstance(object, scapy.Packet): words = filter(lambda x: x[0]!="_",dir(object)) words += map(str, object.fields_desc) else: words = dir... |
import pickle, types | import cPickle, types | def attr_matches(self, text): m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text) if not m: return expr, attr = m.group(1, 3) try: object = eval(expr) except: object = eval(expr, session) if isinstance(object, scapy.Packet): words = filter(lambda x: x[0]!="_",dir(object)) words += map(str, object.fields_desc) else: words = dir... |
pickle.dump(arp_cache, wrpipe) | cPickle.dump(arp_cache, wrpipe) | def sndrcv(pks, pkt, timeout = 2, inter = 0, verbose=None, chainCC=0,retry=0): if not isinstance(pkt, Gen): pkt = SetGen(pkt) if verbose is None: verbose = conf.verb debug.recv = PacketList([],"Unanswered") debug.sent = PacketList([],"Sent") debug.match = SndRcvAns([]) nbrecv=0 ans = [] # do it here to fix random fiel... |
ac = pickle.load(rdpipe) | ac = cPickle.load(rdpipe) | def sndrcv(pks, pkt, timeout = 2, inter = 0, verbose=None, chainCC=0,retry=0): if not isinstance(pkt, Gen): pkt = SetGen(pkt) if verbose is None: verbose = conf.verb debug.recv = PacketList([],"Unanswered") debug.sent = PacketList([],"Sent") debug.match = SndRcvAns([]) nbrecv=0 ans = [] # do it here to fix random fiel... |
FieldLenField("data_length", None, "data"), | FieldLenField("data_length", None, "data",fmt="I"), | def __new__(cls, name, bases, dct): f = dct["fields_desc"] f = [ ByteEnumField("next_payload",None,ISAKMP_payload_type), ByteField("res",0), ShortField("length",None), ] + f dct["fields_desc"] = f return super(ISAKMP_payload_metaclass, cls).__new__(cls, name, bases, dct) |
if self.outs: | if self.outs and self.outs.fileno() != -1: | def close(self): if self.ins != self.outs: if self.outs: self.outs.close() if self.ins: self.ins.close() |
if self.ins: | if self.ins and self.ins.fileno() != -1: | def close(self): if self.ins != self.outs: if self.outs: self.outs.close() if self.ins: self.ins.close() |
SuperSocket.close(self) | def close(self): SuperSocket.close(self) if self.promisc: for i in self.iff: set_promisc(self.ins, i, 0) | |
SuperSocket.close(self) | def close(self): SuperSocket.close(self) if self.promisc: for i in self.iff: | |
ISAKMPTransformTypes = { "Encryption": (1, { "DES-CBS" : 1, "3DES-CBC" : 5, }), | ISAKMPAttributeTypes= { "Encryption": (1, { "DES-CBS" : 1, "IDEA-CBC" : 2, "Blowfish-CBC" : 3, "RC5-R16-B64-CBC" : 4, "3DES-CBC" : 5, "CAST-CBC" : 6, "AES-CBC" : 7, "CAMELLIA-CBC" : 8, }, 0), | # def i2h(self, pkt, x): |
"SHA": 2, }), "Authentication":(3, { "PSK": 1, }), | "SHA": 2, "Tiger": 3, "SHA2-256": 4, "SHA2-384": 5, "SHA2-512": 6,}, 0), "Authentication":(3, { "PSK": 1, "DSS": 2, "RSA Sig": 3, "RSA Encryption": 4, "RSA Encryption Revised": 5, "ElGamal Encryption": 6, "ElGamal Encryption Revised": 7, "ECDSA Sig": 8, "HybridInitRSA": 64221, "HybridRespRSA": 64222, "HybridInitDSS": 6... | # def i2h(self, pkt, x): |
"1024MODPgr" : 2, }), "LifeType": (11,{ "Seconds":1, }), "LifeDuration": (12,{}), | "1024MODPgr" : 2, "EC2Ngr155" : 3, "EC2Ngr185" : 4, "1536MODPgr" : 5, "2048MODPgr" : 14, "3072MODPgr" : 15, "4096MODPgr" : 16, "6144MODPgr" : 17, "8192MODPgr" : 18, }, 0), "GroupType": (5, {"MODP": 1, "ECP": 2, "EC2N": 3}, 0), "GroupPrime": (6, {}, 1), "GroupGenerator1":(7, {}, 1), "Gro... | # def i2h(self, pkt, x): |
ISAKMPTransformNum[val[0]] = (n,tmp) | ISAKMPTransformNum[val[0]] = (n,tmp, val[2]) | # def i2h(self, pkt, x): |
def type2num(self, (typ,enc)): if ISAKMPTransformTypes.has_key(typ): val = ISAKMPTransformTypes[typ] | def type2num(self, (typ,val)): type_val,enc_dict,tlv = ISAKMPTransformTypes.get(typ, (typ,{},0)) val = enc_dict.get(val, val) if tlv: return struct.pack("!HHI",type_val, 4, val) | def type2num(self, (typ,enc)): if ISAKMPTransformTypes.has_key(typ): val = ISAKMPTransformTypes[typ] else: val = (int(typ),{}) if val[1].has_key(enc): enc = val[1][enc] else: enc = int(enc) return ((val[0] | 0x8000L) << 16) | enc |
val = (int(typ),{}) if val[1].has_key(enc): enc = val[1][enc] else: enc = int(enc) return ((val[0] | 0x8000L) << 16) | enc def num2type(self, num): typ = (num >> 16) & 0x7fff enc = num & 0xffff | type_val |= 0x8000 return struct.pack("!HH",type_val, val) def num2type(self, typ, enc): | def type2num(self, (typ,enc)): if ISAKMPTransformTypes.has_key(typ): val = ISAKMPTransformTypes[typ] else: val = (int(typ),{}) if val[1].has_key(enc): enc = val[1][enc] else: enc = int(enc) return ((val[0] | 0x8000L) << 16) | enc |
return struct.pack("!"+"I"*len(i),*i) | return "".join(i) | def i2m(self, pkt, i): if i is None: return "" i = map(self.type2num, i) return struct.pack("!"+"I"*len(i),*i) |
lst = struct.unpack("!"+"I"*(len(m)/4),m) lst = map(self.num2type, lst) return lst | lst = [] while len(m) > 4: trans_type, = struct.unpack("!H", m[:2]) is_tlv = not (trans_type & 0x8000) if is_tlv: value_len, = struct.unpack("!H", m[2:4]) if value_len+4 > len(m): warning("Bad length for ISAKMP tranform type=% value = m[4:value_len] value = reduce(lambda x,y: (x<<8)|y, struct.unpack("!%s" % ("B"*len... | def m2i(self, pkt, m): lst = struct.unpack("!"+"I"*(len(m)/4),m) lst = map(self.num2type, lst) return lst |
if l.find("Mtu"): | if l.find("Mtu") >= 0: | def read_routes(): f=os.popen("netstat -rn") # -f inet ok = 0 mtu = False routes = [] for l in f.readlines(): if not l: break l = l.strip() if l.find("Destination") >= 0: ok = 1 if l.find("Mtu"): mtu = True continue if ok == 0: continue if not l: break if mtu: dest,gw,fl,ref,use,mtu,netif = l.split()[:7] else: dest,gw,... |
FieldLenField("len",None,"load","H",shift=-8), | FieldLenField("length",None,"transforms","H",shift=-8), | def post_build(self, p): if self.length is None: p = p[:24]+struct.pack("!I",len(p))+p[28:] return p |
ISAKMPTransformSetField("transforms",None,"len") | ISAKMPTransformSetField("transforms",None,"length") | def post_build(self, p): if self.length is None: p = p[:24]+struct.pack("!I",len(p))+p[28:] return p |
FieldLenField("len",None,"trans","H",shift=-8), | FieldLenField("length",None,"trans","H",shift=-8), | def post_build(self, p): if self.length is None: p = p[:24]+struct.pack("!I",len(p))+p[28:] return p |
PacketField("trans",Raw(),ISAKMP_payload_Transform), | PacketLenField("trans",Raw(),ISAKMP_payload_Transform,"length"), | def post_build(self, p): if self.length is None: p = p[:24]+struct.pack("!I",len(p))+p[28:] return p |
FieldLenField("length",None,"load","H",shift=-4), | FieldLenField("length",None,"vendorID","H",shift=-4), | def __new__(cls, name, bases, dct): f = dct["fields_desc"] f = [ ByteEnumField("next_payload",None,ISAKMP_payload_type), ByteField("res",0), ShortField("length",None), ] + f dct["fields_desc"] = f return super(ISAKMP_payload_metaclass, cls).__new__(cls, name, bases, dct) |
FieldLenField("len",None,"prop","H",shift=-12), | FieldLenField("length",None,"prop","H",shift=-12), | def __new__(cls, name, bases, dct): f = dct["fields_desc"] f = [ ByteEnumField("next_payload",None,ISAKMP_payload_type), ByteField("res",0), ShortField("length",None), ] + f dct["fields_desc"] = f return super(ISAKMP_payload_metaclass, cls).__new__(cls, name, bases, dct) |
PacketLenField("prop",Raw(),ISAKMP_payload_Proposal,"len"), | PacketLenField("prop",Raw(),ISAKMP_payload_Proposal,"length"), | def __new__(cls, name, bases, dct): f = dct["fields_desc"] f = [ ByteEnumField("next_payload",None,ISAKMP_payload_type), ByteField("res",0), ShortField("length",None), ] + f dct["fields_desc"] = f return super(ISAKMP_payload_metaclass, cls).__new__(cls, name, bases, dct) |
s = inet_aton(s) | if s: s = inet_aton(s) | def i2m(self, pkt, s): if pkt.type == 1: s = inet_aton(s) elif pkt.type in [2,3,4,5]: s = "".join(map(lambda x: chr(len(x))+x, s.split("."))) if ord(s[-1]): s += "\x00" return s |
dnstypes = { 1:"A", 2:"NS", 3:"MD", 4:"MD", 5:"CNAME", 6:"SOA", 7: "MB", 8:"MG", | dnstypes = { 0:"ANY", 255:"ALL", 1:"A", 2:"NS", 3:"MD", 4:"MD", 5:"CNAME", 6:"SOA", 7: "MB", 8:"MG", | def mysummary(self): return Packet.mysummary(self) |
ShortEnumField("class", 1, dnsclasses), | ShortEnumField("rclass", 1, dnsclasses), | def mysummary(self): return Packet.mysummary(self) |
arpspoof(target, victim, [interval=60]) -> None | arpcachepoison(target, victim, [interval=60]) -> None | def arpcachepoison(target, victim, interval=60): """Poison target's cache with (your MAC,victim's IP) couple |
user_commands = [ sr, sr1, srp, sniff, p0f, arpcachepoison, send, sendp, traceroute, arping, ls, lsc, queso, nmap_fp, report_ports ] | user_commands = [ sr, sr1, srp, sniff, p0f, arpcachepoison, send, sendp, traceroute, arping, ls, lsc, queso, nmap_fp, report_ports, dyndns_add, dyndns_del ] | def ls(obj=None): """List available layers, or infos on a given layer""" if obj is None: for i in __builtins__: obj = __builtins__[i] if not type(obj) is types.ClassType: continue if issubclass(obj, Packet): print "%-10s : %s" %(i,obj.name) else: if type(obj) is types.ClassType and issubclass(obj, Packet): for f in ob... |
import code,sys,cPickle,types,os import scapy | import code,sys,cPickle,types,os,imp scapy_module = sys.argv[0] if not scapy_module: scapy_module = "scapy" else: if scapy_module.endswith(".py"): scapy_module = scapy_module[:-3] scapy=imp.load_module("scapy",*imp.find_module(scapy_module)) | def usage(): print "Usage: scapy.py [-s sessionfile]" sys.exit(0) |
class SndRcvList: def __init__(self, res): | class PacketList: def __init__(self, res, name="PacketList"): | def make_tex_table(self, *args, **kargs): return make_tex_table(self.res, *args, **kargs) |
return "<Unanswered:%s>" % s | return "<%s:%s>" % (self.listname,s) | def __repr__(self): stats={TCP:0,UDP:0,ICMP:0} other = 0 for r in self.res: f = 0 for p in stats: if r.haslayer(p): stats[p] += 1 f = 1 break if not f: other += 1 s = "" for p in stats: s += " %s:%i" % (p.name,stats[p]) s += " Other:%i" % other return "<Unanswered:%s>" % s |
return s+struct.pack("16s",self.i2m(pkt, val)) | return s+struct.pack("%ss"%self.length,self.i2m(pkt, val)) | def addfield(self, pkt, s, val): return s+struct.pack("16s",self.i2m(pkt, val)) |
debug.recv = SndRcvList([]) debug.sent = SndRcvList([]) | debug.recv = PacketList([],"Unanswered") debug.sent = PacketList([],"Sent") | def sndrcv(pks, pkt, timeout = 2, inter = 0, verbose=None, chainCC=0,retry=0): if not isinstance(pkt, Gen): pkt = SetGen(pkt) if verbose is None: verbose = conf.verb debug.recv = SndRcvList([]) debug.sent = SndRcvList([]) debug.match = SndRcvAns([]) nbrecv=0 ans = [] # do it here to fix random fields, so that parent a... |
debug.sent=SndRcvList(remain[:]) | debug.sent=PacketList(remain[:],"Sent") | def sndrcv(pks, pkt, timeout = 2, inter = 0, verbose=None, chainCC=0,retry=0): if not isinstance(pkt, Gen): pkt = SetGen(pkt) if verbose is None: verbose = conf.verb debug.recv = SndRcvList([]) debug.sent = SndRcvList([]) debug.match = SndRcvAns([]) nbrecv=0 ans = [] # do it here to fix random fields, so that parent a... |
return SndRcvAns(ans),SndRcvList(remain),debug.recv | return SndRcvAns(ans),PacketList(remain,"Unanswered"),debug.recv | def sndrcv(pks, pkt, timeout = 2, inter = 0, verbose=None, chainCC=0,retry=0): if not isinstance(pkt, Gen): pkt = SetGen(pkt) if verbose is None: verbose = conf.verb debug.recv = SndRcvList([]) debug.sent = SndRcvList([]) debug.match = SndRcvAns([]) nbrecv=0 ans = [] # do it here to fix random fields, so that parent a... |
return res | filename = filename[filename.rfind("/")+1:] return PacketList(res,filename) | def rdpcap(filename): res=[] f=open(filename) magic = f.read(4) if struct.unpack("<I",magic) == (0xa1b2c3d4L,): endian = "<" elif struct.unpack(">I",magic) == (0xa1b2c3d4L,): endian = ">" else: warning("Not a pcap capture file (bad magic)") return [] hdr = f.read(20) if len(hdr)<20: warning("Invalid pcap file") return ... |
return lst | return PacketList(lst,"Sniffed") | def sniff(count=0, prn = None, *arg, **karg): """Sniff packets |
filter="arp", | type=ETH_P_ARP, | def getmacbyip(ip): iff,a,gw = choose_route(ip) if iff == "lo": return "ff:ff:ff:ff:ff:ff" if gw != "0.0.0.0": ip = gw if arp_cache.has_key(ip): mac, timeout = arp_cache[ip] if timeout and (time.time()-timeout < ARPTIMEOUT): return mac res = srp1(Ether(dst=ETHER_BROADCAST)/ARP(op="who-has", pdst=ip), filter="arp", if... |
def __del__(self): self.close() | def __del__(self): self.close() | |
iff = conf.iff | iff = conf.iface | def send(self, x): if hasattr(x,"dst"): iff,a,gw = choose_route(x.dst) else: iff = conf.iff sdto = (iff, self.type) self.outs.bind(sdto) sn = self.outs.getsockname() if sn[3] == ARPHDR_PPP: sdto = (iff, ETH_P_IP) elif LLTypes.has_key(sn[3]): x = LLTypes[sn[3]]()/x self.outs.sendto(str(x), sdto) |
iface = conf.iff | iface = conf.iface | def __init__(self, iface = None, type = ETH_P_ALL, filter=None): if iface is None: iface = conf.iff self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) if conf.except_filter: if filter: filter = "(%s) and not (%s)" % (filter, conf.except_filter) else: filter = "not (%s)" % conf.except_filter... |
iff = conf.iff | iff = conf.iface | def send(self, x): if hasattr(x,"dst"): iff,a,gw = choose_route(x.dst) else: iff = conf.iff ifs = self.iflist.get(iff) if ifs is None: self.iflist[iff] = ifs = dnet.eth(iff) ifs.send(str(Ether()/x)) |
iface = conf.iff | iface = conf.iface | def __init__(self, iface = None, type = ETH_P_ALL, filter=None): if iface is None: iface = conf.iff self.ins = pcap.pcapObject() self.ins.open_live(iface, 1600, 0, 100) if conf.except_filter: if filter: filter = "(%s) and not (%s)" % (filter, conf.except_filter) else: filter = "not (%s)" % conf.except_filter if filter:... |
def sr(x,filter=None, *args,**kargs): | s.close() def sr(x,filter=None, iface=None, *args,**kargs): | def sendp(x, inter=0, *args, **kargs): """Send packets at layer 2""" if not isinstance(x, Gen): x = SetGen(x) s=conf.L2socket(*args, **kargs) for p in x: s.send(p) time.sleep(inter) |
a,b,c=sndrcv(conf.L3socket(filter=filter),x,*args,**kargs) | s = conf.L3socket(filter=filter, iface=iface) a,b,c=sndrcv(s,x,*args,**kargs) s.close() | def sr(x,filter=None, *args,**kargs): """Send and receive packets at layer 3""" if not kargs.has_key("timeout"): kargs["timeout"] = -1 a,b,c=sndrcv(conf.L3socket(filter=filter),x,*args,**kargs) return a,b |
def sr1(x,filter=None, *args,**kargs): | def sr1(x,filter=None,iface=None, *args,**kargs): | def sr1(x,filter=None, *args,**kargs): """Send packets at layer 3 and return only the first answer""" if not kargs.has_key("timeout"): kargs["timeout"] = -1 a,b,c=sndrcv(conf.L3socket(filter=filter),x,*args,**kargs) if len(a) > 0: return a[0][1] else: return None |
a,b,c=sndrcv(conf.L3socket(filter=filter),x,*args,**kargs) | s=conf.L3socket(filter=filter, iface=iface) a,b,c=sndrcv(s,x,*args,**kargs) s.close() | def sr1(x,filter=None, *args,**kargs): """Send packets at layer 3 and return only the first answer""" if not kargs.has_key("timeout"): kargs["timeout"] = -1 a,b,c=sndrcv(conf.L3socket(filter=filter),x,*args,**kargs) if len(a) > 0: return a[0][1] else: return None |
def srp(x,iface=None,filter=None, *args,**kargs): | def srp(x,iface=None,filter=None,type=None, *args,**kargs): | def srp(x,iface=None,filter=None, *args,**kargs): """Send and receive packets at layer 2""" if not kargs.has_key("timeout"): kargs["timeout"] = -1 a,b,c=sndrcv(conf.L2socket(iface=iface, filter=filter),x,*args,**kargs) return a,b |
a,b,c=sndrcv(conf.L2socket(iface=iface, filter=filter),x,*args,**kargs) | a,b,c=sndrcv(conf.L2socket(iface=iface, filter=filter, type=type),x,*args,**kargs) | def srp(x,iface=None,filter=None, *args,**kargs): """Send and receive packets at layer 2""" if not kargs.has_key("timeout"): kargs["timeout"] = -1 a,b,c=sndrcv(conf.L2socket(iface=iface, filter=filter),x,*args,**kargs) return a,b |
def srp1(x,iface=None,filter=None, *args,**kargs): | def srp1(x,iface=None,filter=None,type=None, *args,**kargs): | def srp1(x,iface=None,filter=None, *args,**kargs): """Send and receive packets at layer 2 and return only the first answer""" if not kargs.has_key("timeout"): kargs["timeout"] = -1 a,b,c=sndrcv(conf.L2socket(iface=iface, filter=filter),x,*args,**kargs) if len(a) > 0: return a[0][1] else: return None |
a,b,c=sndrcv(conf.L2socket(iface=iface, filter=filter),x,*args,**kargs) | a,b,c=sndrcv(conf.L2socket(iface=iface, filter=filter, type=type),x,*args,**kargs) | def srp1(x,iface=None,filter=None, *args,**kargs): """Send and receive packets at layer 2 and return only the first answer""" if not kargs.has_key("timeout"): kargs["timeout"] = -1 a,b,c=sndrcv(conf.L2socket(iface=iface, filter=filter),x,*args,**kargs) if len(a) > 0: return a[0][1] else: return None |
0xa1b2c3d4, | 0xa1b2c3d4L, | def wrpcap(filename, pkt): f=open(filename,"w") f.write(struct.pack("IHHIIII", 0xa1b2c3d4, 2, 4, 0, 0, MTU, 1)) # XXX Find the link type for p in pkt: s = str(p) l = len(s) sec = int(p.time) usec = int((p.time-sec)*1000000) f.write(struct.pack("IIII", sec, usec, l, l)) f.write(s) f.close() |
f = os.popen("tcpdump -i any -ddd -s 1600 '%s'" % filter) | f = os.popen("tcpdump -i s -ddd -s 1600 '%s'" % (conf.iface,filter)) | def attach_filter(s, filter): f = os.popen("tcpdump -i any -ddd -s 1600 '%s'" % filter) lines = f.readlines() if f.close(): raise Exception("Filter parse error") nb = int(lines[0]) bpf = "" for l in lines[1:]: bpf += struct.pack("HBBI",*map(long,l.split())) # XXX. Argl! We need to give the kernel a pointer on the BPF,... |
arping(net, iface=conf.iff) -> None""" | arping(net, iface=conf.iface) -> None""" | def arping(net, iface=None): """Send ARP who-has requests to determine which hosts are up |
iff = get_working_if() | iface = get_working_if() | def reset(self): self.__dict__ = {} |
warning("Can't read nmap database [%s](new nmap version ?)" % base.filename) | warning("Can't read nmap database [%s](new nmap version ?)" % self.filename) | def lazy_init(self): try: f=open(self.filename) except IOError: return |
objlst = filter(lambda (n,o): type(o) is types.TypeType and issubclass(o,Packet), __builtin__.__dict__.items()) | all = __builtin__.__dict__.copy() all.update(globals()) objlst = filter(lambda (n,o): type(o) is types.TypeType and issubclass(o,Packet), all.items()) | def ls(obj=None): """List available layers, or infos on a given layer""" if obj is None: import __builtin__ objlst = filter(lambda (n,o): type(o) is types.TypeType and issubclass(o,Packet), __builtin__.__dict__.items()) objlst.sort(lambda x,y:cmp(x[0],y[0])) for n,o in objlst: print "%-10s : %s" %(n,o.name) else: if t... |
LLNumTypes = {} for k in LLTypes: LLNumTypes[LLTypes[k]] = k | LLNumTypes = { Ether : ARPHDR_ETHER, IP : 12, IP : 101, Dot11 : 801, PrismHeader : 802, Dot11 : 105, CookedLinux : 113, } | def fragment(pkt, fragsize=1480): fragsize = (fragsize+7)/8*8 pkt = pkt.copy() pkt.flags = "MF" lst = [] for p in pkt: q = p.copy() del(q.payload) s = str(p.payload) nb = (len(s)+fragsize-1)/fragsize for i in range(nb): r = Raw(load=s[i*fragsize:(i+1)*fragsize]) r.overload_fields = p.payload.overload_fields.copy() if i... |
class ScapyPcapWriter: | class PcapWriter: | def recv(self, size): """ Emulate a socket """ return self.read_packet() |
def __init__(self, filename, linktype=1): | def __init__(self, filename, linktype=None): self.linktype = linktype self.header_done = 0 | def __init__(self, filename, linktype=1): self.f = open(filename,"w") self.f.write(struct.pack("IHHIIII", 0xa1b2c3d4L, 2, 4, 0, 0, MTU, linktype)) # XXX Find the link type |
self.f.write(struct.pack("IHHIIII", 0xa1b2c3d4L, 2, 4, 0, 0, MTU, linktype)) def write(self, packets): | def write(self, pkt): | def __init__(self, filename, linktype=1): self.f = open(filename,"w") self.f.write(struct.pack("IHHIIII", 0xa1b2c3d4L, 2, 4, 0, 0, MTU, linktype)) # XXX Find the link type |
if type(packets) == type(list): for p in packets: self.write_packet(p) else: self.write_packet(packets) | if self.header_done == 0: if self.linktype == None: if isinstance(pkt,Packet): print "x",pkt.__class__ linktype = LLNumTypes.get(pkt.__class__,1) else: print "xx",pkt[0].__class__ linktype = LLNumTypes.get(pkt[0].__class__,1) print linktype self.f.write(struct.pack("IHHIIII", 0xa1b2c3d4L, 2, 4, 0, 0, MTU, linktype)) s... | def write(self, packets): """accepts a either a single packet or a list of packets to be written to the dumpfile """ if type(packets) == type(list): for p in packets: self.write_packet(p) else: self.write_packet(packets) |
class LLPPP(Packet): | class PPP(Packet): | def mysummary(self): return Packet.mysummary(self) |
return 'DNS Ans "%s"' % self.an.rdata else: return 'DNS Query "%s"' % self.qd.qname | type = "Ans" if self.ancount > 0: name = ' "%s"' % self.an.rdata else: type = "Qry" if self.qdcount > 0: name = ' "%s"' % self.qd.qname return 'DNS %s%s ' % (type, name) | def mysummary(self): if self.qr: return 'DNS Ans "%s"' % self.an.rdata else: return 'DNS Query "%s"' % self.qd.qname |
( LLPPP, IP, { } ), | ( PPP, IP, { "proto" : 0x0021 } ), | def bind_layers(lower, upper, fval): lower.payload_guess = lower.payload_guess[:] upper.overload_fields = upper.overload_fields.copy() lower.payload_guess.append((fval, upper)) upper.overload_fields[lower] = fval |
self.outs.bind((iff, self.type)) | sdto = (iff, self.type) self.outs.bind(sdto) | def send(self, x): if hasattr(x,"dst"): iff,a,gw = choose_route(x.dst) else: iff = conf.iff self.outs.bind((iff, self.type)) sn = self.outs.getsockname() if LLTypes.has_key(sn[3]): x = LLTypes[sn[3]]()/x self.outs.sendto(str(x), (iff, self.type)) |
self.outs.sendto(str(x), (iff, self.type)) | elif sn[3] == ARPHDR_PPP: sdto = (iff, ETH_P_IP) self.outs.sendto(str(x), sdto) | def send(self, x): if hasattr(x,"dst"): iff,a,gw = choose_route(x.dst) else: iff = conf.iff self.outs.bind((iff, self.type)) sn = self.outs.getsockname() if LLTypes.has_key(sn[3]): x = LLTypes[sn[3]]()/x self.outs.sendto(str(x), (iff, self.type)) |
return s+struct.pack("%ss"%self.length,self.i2m(pkt, val)) | return s+struct.pack("%is"%self.length,self.i2m(pkt, val)) | def addfield(self, pkt, s, val): return s+struct.pack("%ss"%self.length,self.i2m(pkt, val)) |
def __init__(self, start=0, step=1, restart=0): | def __init__(self, start=0, step=1, restart=-1): | def __init__(self, start=0, step=1, restart=0): self.start = self.val = start self.step = step self.restart = restart |
stk = traceback.extract_stack(limit=1) caller = stk[0][1] | stk = traceback.extract_stack() caller=None for f,l,n,c in stk: if n == 'warning': break caller = l | def filter(self, record): wt = conf.warning_threshold if wt > 0: stk = traceback.extract_stack(limit=1) caller = stk[0][1] tm,nb = self.warning_table.get(caller, (0,0)) ltm = time.time() if ltm-tm > wt: tm = ltm nb = 0 else: if nb < 2: nb += 1 if nb == 2: record.msg = "more "+record.msg else: return 0 self.warning_tabl... |
if DNET: | if 0 and DNET: | def set_promisc(s,iff,val=1): mreq = struct.pack("IHH8s", get_if_index(iff), PACKET_MR_PROMISC, 0, "") if val: cmd = PACKET_ADD_MEMBERSHIP else: cmd = PACKET_DROP_MEMBERSHIP s.setsockopt(SOL_PACKET, cmd, mreq) |
return dnet_arp_object.get(dnet.addr(ip)).ntoa() | res = dnet_arp_object.get(dnet.addr(ip)) if res is None: return None else: return res.ntoa() | def getmacbyip(ip): iff,a,gw = choose_route(ip) if gw != "0.0.0.0": ip = gw return dnet_arp_object.get(dnet.addr(ip)).ntoa() |
user_commands = [ sr, sr1, srp, sniff, p0f, arpcachepoison, send, sendp, traceroute, ls, lsc ] | user_commands = [ sr, sr1, srp, sniff, p0f, arpcachepoison, send, sendp, traceroute, arping, ls, lsc, queso ] | def ls(obj=None): """List available layers, or infos on a given layer""" if obj is None: for i in __builtins__: obj = __builtins__[i] if not type(obj) is types.ClassType: continue if issubclass(obj, Packet): print "%-10s : %s" %(i,obj.name) else: if type(obj) is types.ClassType and issubclass(obj, Packet): for f in ob... |
def arping(net, iface=None): ans,unans = srp(Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst=net), filter="arp and arp[7] = 2", timeout=5, iface=iface) for s,r in ans: print r.payload.psrc last = ans,unans | def arping(net, iface=None): ans,unans = srp(Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst=net), filter="arp and arp[7] = 2", timeout=5, iface=iface) | |
return {"B":RandByte,"H":RandShort,"I":RandInt, "Q":RandLong}[self.fmt[-1]]() | fmtt = self.fmt[-1] if fmtt in "BHIQ": return {"B":RandByte,"H":RandShort,"I":RandInt, "Q":RandLong}[fmtt]() elif fmtt == "s": if self.fmt[0] in "0123456789": l = int(self.fmt[:-1]) else: l = int(self.fmt[1:-1]) return RandBin(l) else: warning("no random class for [%s] (fmt=%s)." % (self.name, self.fmt)) | def randval(self): return {"B":RandByte,"H":RandShort,"I":RandInt, "Q":RandLong}[self.fmt[-1]]() |
q.default_fields[f] = f.randval() | rnd = f.randval() if rnd is not None: q.default_fields[f] = rnd | def fuzz(p): p = q = p.copy() while not isinstance(q, NoPayload): for f in q.fields_desc: if f.default is not None: q.default_fields[f] = f.randval() q = q.payload return p |
bpfh = struct.pack("HI", nb, id(bpf)+36) | bpfh = struct.pack("HL", nb, id(bpf)+36) | def attach_filter(s, filter): # XXX We generate the filter on the interface conf.iface # because tcpdump open the "any" interface and ppp interfaces # in cooked mode. As we use them in raw mode, the filter will not # work... one solution could be to use "any" interface and translate # the filter from cooked mode to raw... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.