def ping(test_params, show_result=False):
"""Check CoAP service availability by sending ping packet and waiting for response."""
if not test_params:
return None
coap_ping_packets = [COAP_PING_1_RAW, COAP_PING_2_RAW]
for coap_ping_raw in coap_ping_packets:
packet_raw = dehex(coap_ping_raw)
response = udp_sr1(test_params, packet_raw, test_params.wrap_secure_layer)
if response:
for response_packet in response:
response_packet.show()
if (
response_packet.haslayer(CoAP)
and response_packet[CoAP].ver == 1
):
return True
coap_response = coap_scrap_response(response_packet)
print_verbose(test_params, coap_response)
if (
"ver = 1" in coap_response
and coap_convert_type(coap_response) != "Empty"
):
print_verbose(test_params, "Found CoAP response")
return True
print_verbose(test_params, "NOT found CoAP response")
return False
def search_string():
string = input("Search String : ")
for i in cap_raw:
try:
id_to_name = {'6': 'TCP', '17': 'UDP'}
proto = id_to_name[i['ip'].proto]
if bytes(string,
'utf-8') in hexdump.dehex(i[proto].payload_raw[0]):
for j in hexdump.dehex(i[proto].payload_raw[0]):
if chr(j).isprintable():
print(chr(j), end='')
else:
print('.', end='')
print()
except:
pass
input("press <enter> to continue ...")
def ping(test_params, show_result=False):
"""Checks MQTT service availability by sending ping packet and waiting for response."""
# MQTT ping is using Connect message
for packet_hex in [MQTT_CONN_MQTT, MQTT_CONN_MQISDP]:
packet_data = dehex(packet_hex)
out_packet = MQTT(packet_data)
if mqtt_request(test_params, out_packet):
return True
return False
def write_block(ctx, input, hexdata, seek, length, address):
"""Write data to radio memory.
This command will by default read data from stdin. Use the --input (-i)
option to read data from a file instead, or --hexdata (-d) to provide
hexadecimal data on the command line.
Examples:
1. Write four bytes to address 0x1700
tmv71 memory write-block 0x1700 -d 'F0 15 AB 08'
2. Open 'backup.dat', seek to position 0x1700, read 16 bytes, and
write them to address 0x1700:
tmv71 memory write-block 0x1700 -i backup.dat -s 0x1700 -l 16
"""
LOG.debug("seek %d length %d address %d", seek, length, address)
if input:
LOG.debug("reading data from %s", input.name)
with input:
input.seek(seek)
data = input.read(length)
elif hexdata:
LOG.debug("reading data from hexdata option")
data = hexdump.dehex(hexdata)
if seek:
data = data[seek:]
if length:
data = data[:length]
elif sys.stdin.buffer.seekable():
LOG.debug("reading data from stdin (seekable)")
sys.stdin.buffer.seek(seek)
data = sys.stdin.buffer.read(length)
else:
LOG.debug("reading data from stdin (not seekable)")
data = sys.stdin.buffer.read()[seek:]
if length:
data = data[:length]
with ctx.api.programming_mode():
addr = address
for chunk in hexdump.chunks(data, 256):
chunklen = len(chunk)
LOG.info(
"writing %d bytes of data to address 0x%04X",
256 if chunklen == 0 else chunklen,
addr,
)
addr += 256
ctx.api.write_block(address, chunk)
def ping(test_params, show_result=False):
"""Check MQTT-SN service availability by sending ping packet and waiting for response."""
if not test_params:
return None
# MQTT-SN ping is using Search Gateway message
for packet_hex in [MQTTSN_SEARCH_GATEWAY]:
packet_data = dehex(packet_hex)
out_packet = MQTT(packet_data)
if mqttsn_request(test_params, out_packet):
return True
return False
def ping(test_params, show_result=False):
"""Checks CoAP service availability by sending ping packet and waiting for response."""
coap_ping_packets = [COAP_PING_1_RAW, COAP_PING_2_RAW]
for coap_ping_raw in coap_ping_packets:
packet_raw = dehex(coap_ping_raw)
response = udp_sr1(test_params, packet_raw,
test_params.wrap_secure_layer)
if response is not None:
for response_packet in response:
coap_response = coap_scrap_response(response_packet)
print_verbose(test_params, coap_response)
if ("ver = 1" in coap_response
and coap_convert_type(coap_response) != "Empty"):
return True
return False
def _wrapper_info(self):
memory = self._info['memory']
self._out_dict['type'] = memory['operation']
self._out_dict['data target address'] = memory['address']
symbol = self._info["symbol"]
pc_str = symbol['address'] + " "
# 如果能解析出来符号则解析
if symbol["moduleName"]:
pc_str = pc_str + symbol["moduleName"] + "!" + symbol["name"]
self._out_dict['PC'] = pc_str
self._out_dict['ins str'] = self._info["ins"]
operands = self._info["operands"]
self._out_dict['Register'] = self._handle_operands(operands)
data = self._info['data']
self._out_dict['data'] = hexdump.hexdump(hexdump.dehex(data),
result="return")
def mqtt_ping(test_params):
"""Checks MQTT service availability by sending ping packet and waiting for response."""
# MQTT ping is using Connect message
packet_data = dehex(MQTT_CONN)
out_packet = MQTT(packet_data)
try:
for i in range(1 + test_params.nr_retries):
in_data = tcp_sr1(test_params, out_packet)
in_packet = MQTT(in_data)
show_verbose(test_params, in_packet)
if (
in_packet[MQTT].type in CONTROL_PACKET_TYPE
and CONTROL_PACKET_TYPE[in_packet[MQTT].type] == "CONNACK"
):
print_verbose(
test_params,
"MQTT ping {}: in_packet[MQTTConnack].retcode: {}".format(
i + 1, RETURN_CODE[in_packet[MQTTConnack].retcode]
),
)
return True
except (socket.timeout, socket.error) as error:
print_verbose(test_params, error)
return False
import socket
import telnetlib
# 88.87.208.163:6969
# 11111111111111111
def xor_encrypt(data, key):
decode_string = ''
for i in range(len(data)):
decode_string += chr((ord(data[i])
^ ord(key[len(key) - i % len(key) - 1])) & 0xFF)
return decode_string
data = '55 75 44 B6 0B 33 06 03 E9 02 60 71 47 B2 44 33'
data1 = hexdump.dehex(data)
print data.encode('hex')
key = '65 87 33 45 12'
key1 = hexdump.dehex(key)
flag = xor_encrypt(data1, key1)
print flag.encode('hex')
print flag
print hashlib.sha1(flag).hexdigest()
a = '01101111080101100801101010110101'.decode('hex')
print hashlib.sha1(a).hexdigest()
s = socket.create_connection(('88.87.208.163', 6969))
t = telnetlib.Telnet()
t.sock = s
t.interact()
def true_sendall(self, data, *args, **kwargs):
req = decode_from_bytes(data)
# make request unique again
req_signature = hashlib.md5(encode_to_bytes(''.join(sorted(req.split('\r\n'))))).hexdigest()
# port should be always a string
port = text_type(self._port)
# prepare responses dictionary
responses = dict()
if Mocket.get_truesocket_recording_dir():
path = os.path.join(
Mocket.get_truesocket_recording_dir(),
Mocket.get_namespace() + '.json',
)
# check if there's already a recorded session dumped to a JSON file
try:
with io.open(path) as f:
responses = json.load(f)
# if not, create a new dictionary
except (FileNotFoundError, JSONDecodeError):
pass
try:
response_dict = responses[self._host][port][req_signature]
except KeyError:
# preventing next KeyError exceptions
responses.setdefault(self._host, dict())
responses[self._host].setdefault(port, dict())
responses[self._host][port].setdefault(req_signature, dict())
response_dict = responses[self._host][port][req_signature]
# try to get the response from the dictionary
try:
try:
encoded_response = hexdump.dehex(response_dict['response'])
except TypeError: # pragma: no cover
# Python 2
encoded_response = hexdump.restore(encode_to_bytes(response_dict['response']))
# if not available, call the real sendall
except KeyError:
self._connect()
self.true_socket.sendall(data, *args, **kwargs)
encoded_response = b''
# https://github.com/kennethreitz/requests/blob/master/tests/testserver/server.py#L13
while select.select([self.true_socket], [], [], 0.5)[0]:
recv = self.true_socket.recv(self._buflen)
if recv:
encoded_response += recv
else:
break
# dump the resulting dictionary to a JSON file
if Mocket.get_truesocket_recording_dir():
# update the dictionary with request and response lines
response_dict['request'] = req
response_dict['response'] = hexdump.dump(encoded_response)
with io.open(path, mode='w') as f:
f.write(decode_from_bytes(json.dumps(responses, indent=4, sort_keys=True)))
# response back to .sendall() which writes it to the mocket socket and flush the BytesIO
return encoded_response
def read_hex(data):
return hexdump.dehex(data)
def read_hex(data):
return hexdump.dehex(data)
R: 11:56:30.129 .....>.. BD 8F FE 04 D3 3E 2E BD
""".split('\n')
x = "T: 11:56:28.622 ..........#..... "
msg = " ".join([z[len(x):] for z in msg])
import logging
logging.basicConfig(level=logging.INFO)
import hexdump
import io
from PyCampbellCR1000.pycampbellcr1000.pakdecode import PakBusDecode
class pbByteIo(io.BytesIO):
# pakbus assumes there is a timeout member...
timeout = 1
link = pbByteIo(hexdump.dehex(msg))
pb = PakBusDecode(link)
packet = pb.read()
while packet:
logging.debug("packet is {}: {}".format(hexdump.dump(packet), packet))
hdr, msg = pb.decode_packet(bytes(packet))
logging.info('HEAD: {}'.format(hdr))
logging.info(' MSG: {}'.format(msg))
packet = pb.read()
import hashlib
import base64
import hexdump
import socket
import telnetlib
# 88.87.208.163:6969
# 11111111111111111
def xor_encrypt(data, key):
decode_string = ''
for i in range(len(data)):
decode_string += chr((ord(data[i])^ord(key[len(key)-i%len(key)-1]))&0xFF)
return decode_string
data='55 75 44 B6 0B 33 06 03 E9 02 60 71 47 B2 44 33'
data1=hexdump.dehex(data)
print data.encode('hex')
key='65 87 33 45 12'
key1=hexdump.dehex(key)
flag=xor_encrypt(data1,key1)
print flag.encode('hex')
print flag
print hashlib.sha1(flag).hexdigest()
a='01101111080101100801101010110101'.decode('hex')
print hashlib.sha1(a).hexdigest()
s = socket.create_connection(('88.87.208.163', 6969))
t = telnetlib.Telnet()
t.sock = s
def true_sendall(self, data, *args, **kwargs):
req = decode_from_bytes(data)
# make request unique again
req_signature = _hash_request(hasher, req)
# port should be always a string
port = text_type(self._port)
# prepare responses dictionary
responses = dict()
if Mocket.get_truesocket_recording_dir():
path = os.path.join(Mocket.get_truesocket_recording_dir(),
Mocket.get_namespace() + ".json")
# check if there's already a recorded session dumped to a JSON file
try:
with io.open(path) as f:
responses = json.load(f)
# if not, create a new dictionary
except (FileNotFoundError, JSONDecodeError):
pass
try:
try:
response_dict = responses[self._host][port][req_signature]
except KeyError:
if hasher is not hashlib.md5:
# Fallback for backwards compatibility
req_signature = _hash_request(hashlib.md5, req)
response_dict = responses[self._host][port][req_signature]
else:
raise
except KeyError:
# preventing next KeyError exceptions
responses.setdefault(self._host, dict())
responses[self._host].setdefault(port, dict())
responses[self._host][port].setdefault(req_signature, dict())
response_dict = responses[self._host][port][req_signature]
# try to get the response from the dictionary
try:
try:
encoded_response = hexdump.dehex(response_dict["response"])
except TypeError: # pragma: no cover
# Python 2
encoded_response = hexdump.restore(
encode_to_bytes(response_dict["response"]))
# if not available, call the real sendall
except KeyError:
host, port = Mocket._address
host = true_gethostbyname(host)
if isinstance(self.true_socket,
true_socket) and self._secure_socket:
try:
self = MocketSocket(sock=self)
except TypeError:
ssl_context = self.kwargs.get("ssl_context")
server_hostname = self.kwargs.get("server_hostname")
self.true_socket = true_ssl_context.wrap_socket(
self=ssl_context,
sock=self.true_socket,
server_hostname=server_hostname,
)
try:
self.true_socket.connect((host, port))
except (OSError, socket.error, ValueError):
# already connected
pass
self.true_socket.sendall(data, *args, **kwargs)
encoded_response = b""
# https://github.com/kennethreitz/requests/blob/master/tests/testserver/server.py#L13
while True:
if not select.select([self.true_socket], [], [],
0.1)[0] and encoded_response:
break
recv = self.true_socket.recv(self._buflen)
if not recv and encoded_response:
break
encoded_response += recv
# dump the resulting dictionary to a JSON file
if Mocket.get_truesocket_recording_dir():
# update the dictionary with request and response lines
response_dict["request"] = req
response_dict["response"] = hexdump.dump(encoded_response)
with io.open(path, mode="w") as f:
f.write(
decode_from_bytes(
json.dumps(responses, indent=4, sort_keys=True)))
# response back to .sendall() which writes it to the Mocket socket and flush the BytesIO
return encoded_response
def true_sendall(self, data, *args, **kwargs):
req = decode_from_bytes(data)
# make request unique again
req_signature = _hash_request(hasher, req)
# port should be always a string
port = text_type(self._port)
# prepare responses dictionary
responses = dict()
if Mocket.get_truesocket_recording_dir():
path = os.path.join(
Mocket.get_truesocket_recording_dir(), Mocket.get_namespace() + ".json"
)
# check if there's already a recorded session dumped to a JSON file
try:
with io.open(path) as f:
responses = json.load(f)
# if not, create a new dictionary
except (FileNotFoundError, JSONDecodeError):
pass
try:
try:
response_dict = responses[self._host][port][req_signature]
except KeyError:
if hasher is not hashlib.md5:
# Fallback for backwards compatibility
req_signature = _hash_request(hashlib.md5, req)
response_dict = responses[self._host][port][req_signature]
else:
raise
except KeyError:
# preventing next KeyError exceptions
responses.setdefault(self._host, dict())
responses[self._host].setdefault(port, dict())
responses[self._host][port].setdefault(req_signature, dict())
response_dict = responses[self._host][port][req_signature]
# try to get the response from the dictionary
try:
try:
encoded_response = hexdump.dehex(response_dict["response"])
except TypeError: # pragma: no cover
# Python 2
encoded_response = hexdump.restore(
encode_to_bytes(response_dict["response"])
)
# if not available, call the real sendall
except KeyError:
host, port = Mocket._address
host = true_gethostbyname(host)
try:
self.true_socket.connect((host, port))
except (OSError, socket.error, ValueError):
# already connected
pass
self.true_socket.sendall(data, *args, **kwargs)
encoded_response = b""
# https://github.com/kennethreitz/requests/blob/master/tests/testserver/server.py#L13
while True:
if not select.select(
[self.true_socket], [], [], 0.1
)[0] and encoded_response:
break
recv = self.true_socket.recv(self._buflen)
if not recv and encoded_response:
break
encoded_response += recv
# dump the resulting dictionary to a JSON file
if Mocket.get_truesocket_recording_dir():
# update the dictionary with request and response lines
response_dict["request"] = req
response_dict["response"] = hexdump.dump(encoded_response)
with io.open(path, mode="w") as f:
f.write(
decode_from_bytes(
json.dumps(responses, indent=4, sort_keys=True)
)
)
# response back to .sendall() which writes it to the mocket socket and flush the BytesIO
return encoded_response
T: 11:56:30.129 ...?........ BD B4 D3 3F FE 04 D3 0F FE DA BB BD
R: 11:56:30.129 .....>.. BD 8F FE 04 D3 3E 2E BD
""".split('\n')
x = "T: 11:56:28.622 ..........#..... "
msg = " ".join([z[len(x):] for z in msg])
import logging
logging.basicConfig(level=logging.INFO)
import hexdump
import io
from PyCampbellCR1000.pycampbellcr1000.pakdecode import PakBusDecode
class pbByteIo(io.BytesIO):
# pakbus assumes there is a timeout member...
timeout = 1
link = pbByteIo(hexdump.dehex(msg))
pb = PakBusDecode(link)
packet = pb.read()
while packet:
logging.debug ("packet is {}: {}".format(hexdump.dump(packet), packet))
hdr, msg = pb.decode_packet(bytes(packet))
logging.info ('HEAD: {}'.format(hdr))
logging.info (' MSG: {}'.format(msg))
packet = pb.read()
import hexdump
from pytun import TunTapDevice, IFF_TAP
tun = TunTapDevice(name='rfc6214')
with open("captured_in.hex", "r") as the_file:
hex = the_file.readline()
buf = hexdump.dehex(hex)
tun.write(buf)
buf = tun.read(tun.mtu)
hex = hexdump.dump(buf, 2, '')
print(hex)
with open('captured_out.hex', 'w') as the_file:
the_file.write(hex)
pref = """78 9f 3e 22 01 00 01 06 90 08 00 04 00 00 00 00 00 01 00 01 00 01 07 90 06 00 08 00 00 00 e4 04 00 00 00 00 00 00
e8 00 01 08 80 07 00 20 00 00 00 49 50 4d 2e 4d 69 63 72 6f 73 6f 66 74 20 53 63 68 65 64 75 6c 65 2e 4d 74 67 52 65 73
70 4e 00 55 0b 01 0d 80 04 00 02 00 00 00 02 00 02 00 01 05 80 03 00 0e 00 00 00 d8 07 01 00 10 00 17 00 1c 00 08 00 03
00 2e 01 01 20 80 03 00 0e 00 00 00 d8 07 01 00 10 00 17 00 1c 00 08 00 03 00 2e 01 01 03 90 06 00 88 00 00 00 02 00 00
00 02 01 7f 00 01 00 00 00 0c 00 00 00"""
ckey = "38 71 6b 6a 30 30 73 67 6d 34 66 00"
mid = "02 01 09 10 01 00 00 00 5d 00 00 00"
rtf = """59 00 00 00 b3 00 00 00 4c 5a 46 75 a9 be bb ed 87 00 0a 01 0d 03 43 74 65 78 74 01 f7 ff 02 a4 03 e4 05 eb 02
83 00 50 02 f3 06 b4 02 83 26 32 03 c5 02 00 63 68 0a c0 73 65 d8 74 30 20 07 13 02 80 7d 0a 80 08 cf 3f 09 d9 02 80
0a 84 0b 37 12 c2 01 d0 20 46 10 59 49 00 7d 18 20"""
postf = "00 00 00 f7 21"
dt = datetime(2008, 1, 16, 23, 28, 8)
prop = MapiProps()
prop.add(MapiEnum.PR_TNEF_CORRELATION_KEY, hexdump.dehex(ckey))
prop.add(MapiEnum.PR_RTF_COMPRESSED, hexdump.dehex(rtf))
obj = TNEF()
data = obj.std().messageClass(TNEF.CLASS_MRESPN).priority().dateSent(
dt).dateModified(dt).msgProps(prop).dump()
res = hexdump.dehex(pref + ' ' + ckey + ' ' + mid + ' ' + rtf + ' ' + postf)
print "test2:", "OK" if checkBuffers(res, data, True) else "FAILED"
# TEST3
# test p7s builder
pubkey = """00 30 82 01 0A 02 82 01 01 00 BE 93 B1 7E E5 7E 12 AE 4A C8 3F 56 AA 2D F1 EE F8 99 50 61 8A F2 3B 43 3A
11 31 57 D7 B9 FE 71 56 CB C0 A3 57 10 FC 79 1A 34 26 0D A4 67 3C 53 64 18 8B 70 AA A9 12 52 13 16 98 5E 65 2D 98 B5
66 8E 70 07 55 D4 C3 56 B1 8D 1A 87 94 9A 96 33 57 16 3E BF DC A2 D1 EB 96 6D CD 46 13 40 2C 1C 1D AF 54 B5 55 49 47
