def get_response(url,
message,
types,
force_str_paths=(),
xmessage_type=None):
query = blackboxprotobuf.encode_message(message, types)
query = len(query).to_bytes(5, byteorder='big') + query
query = base64.b64encode(query)
page = REQ.get(url,
post=query,
content_type='application/grpc-web-text',
headers={'accept': 'application/grpc-web-text'})
data = base64.b64decode(page)
size = int.from_bytes(data[:5], 'big')
data = data[5:5 + size]
message_type = {}
for path in force_str_paths:
d = message_type
*path, key = path
for k in path:
d = d.setdefault(k, {
'type': 'message',
'message_typedef': {}
})
d = d['message_typedef']
d[key] = {'type': 'bytes'}
message, types = blackboxprotobuf.decode_message(
data, message_type)
return message, types
def test_modify(x, modify_num):
modify_key = testMessage_typedef[modify_num]["name"]
message = Test_pb2.TestMessage()
for key,value in x.items():
setattr(message, key, value)
encoded = message.SerializeToString()
decoded, typedef = blackboxprotobuf.decode_message(encoded, testMessage_typedef)
# eliminate any cases where protobuf defaults out a field
hypothesis.assume(modify_key in decoded)
if isinstance(decoded[modify_key], str):
mod_func = lambda x: "test"
elif six.PY2 and isinstance(decoded[modify_key], unicode):
mod_func = lambda x: six.u("test")
elif isinstance(decoded[modify_key], bytes):
mod_func = lambda x: b'test'
elif isinstance(decoded[modify_key], six.integer_types):
mod_func = lambda x: 10
elif isinstance(decoded[modify_key], float):
mod_func = lambda x: 10
else:
hypothesis.note("Failed to modify key: %s (%r)" % (modify_key,type(decoded[modify_key]) ))
assert False
decoded[modify_key] = mod_func(decoded[modify_key])
x[modify_key] = mod_func(x[modify_key])
encoded = blackboxprotobuf.encode_message(decoded, testMessage_typedef)
message = Test_pb2.TestMessage()
message.ParseFromString(encoded)
for key in decoded.keys():
assert getattr(message, key) == x[key]
def test_encode(x):
encoded = blackboxprotobuf.encode_message(x, testMessage_typedef)
message = Test_pb2.TestMessage()
message.ParseFromString(encoded)
for key in x.keys():
assert getattr(message, key) == x[key]
return dict(
(convert(key), convert(value)) for key, value in input.iteritems())
elif isinstance(input, list):
return [convert(element) for element in input]
elif isinstance(input, unicode):
return input.encode('utf-8')
elif isinstance(input, int):
return long(input)
else:
return input
with open('payload.pickle', 'rb') as handle:
deserialized = pickle.load(handle)
with open('filename.pickle', 'rb') as handle:
path = pickle.load(handle)
# print(path)
#Dirty hack to have a typedef
f = open('../../%s' % (path))
message, typedef = blackboxprotobuf.decode_message(f.read())
#ready=blackboxprotobuf.encode_message(deserialized,typedef)
#toencode,typedef = convert(deserialized)
data = blackboxprotobuf.encode_message(convert(deserialized), typedef)
#print(data)
with open('final.pickle', 'wb') as handle:
pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL)
def test_anon_json_decode(x):
config = Config()
typedef, message = x
encoded = blackboxprotobuf.encode_message(message,
config=config,
message_type=typedef)
decoded_json, typedef_out = blackboxprotobuf.protobuf_to_json(
encoded, config=config)
encoded_json = blackboxprotobuf.protobuf_from_json(
decoded_json, config=config, message_type=typedef_out)
decoded, typedef_out = blackboxprotobuf.decode_message(encoded_json,
config=config)
note("Original message: %r" % message)
note("Decoded JSON: %r" % decoded_json)
note("Decoded message: %r" % decoded)
note("Original typedef: %r" % typedef)
note("Decoded typedef: %r" % typedef_out)
def check_message(orig, orig_typedef, new, new_typedef):
for field_number in set(orig.keys()) | set(new.keys()):
# verify all fields are there
assert field_number in orig
assert field_number in orig_typedef
assert field_number in new
assert field_number in new_typedef
orig_values = orig[field_number]
new_values = new[field_number]
orig_type = orig_typedef[field_number]["type"]
new_type = new_typedef[field_number]["type"]
note("Parsing field# %s" % field_number)
note("orig_values: %r" % orig_values)
note("new_values: %r" % new_values)
note("orig_type: %s" % orig_type)
note("new_type: %s" % new_type)
# Fields might be lists. Just convert everything to a list
if not isinstance(orig_values, list):
orig_values = [orig_values]
assert not isinstance(new_values, list)
new_values = [new_values]
assert isinstance(orig_values, list)
assert isinstance(new_values, list)
# if the types don't match, then try to convert them
if new_type == "message" and orig_type in ["bytes", "string"]:
# if the type is a message, we want to convert the orig type to a message
# this isn't ideal, we'll be using the unintended type, but
# best way to compare. Re-encoding a message to binary might
# not keep the field order
new_field_typedef = new_typedef[field_number][
"message_typedef"]
for i, orig_value in enumerate(orig_values):
if orig_type == "bytes":
(
orig_values[i],
orig_field_typedef,
_,
) = length_delim.decode_lendelim_message(
length_delim.encode_bytes(orig_value),
config,
new_field_typedef,
)
else:
# string value
(
orig_values[i],
orig_field_typedef,
_,
) = length_delim.decode_lendelim_message(
length_delim.encode_string(orig_value),
config,
new_field_typedef,
)
orig_typedef[field_number][
"message_typedef"] = orig_field_typedef
orig_type = "message"
if new_type == "string" and orig_type == "bytes":
# our bytes were accidently valid string
new_type = "bytes"
for i, new_value in enumerate(new_values):
new_values[i], _ = length_delim.decode_bytes(
length_delim.encode_string(new_value), 0)
note("New values: %r" % new_values)
# sort the lists with special handling for dicts
orig_values.sort(
key=lambda x: x if not isinstance(x, dict) else x.items())
new_values.sort(
key=lambda x: x if not isinstance(x, dict) else x.items())
for orig_value, new_value in zip(orig_values, new_values):
if orig_type == "message":
check_message(
orig_value,
orig_typedef[field_number]["message_typedef"],
new_value,
new_typedef[field_number]["message_typedef"],
)
else:
assert orig_value == new_value
check_message(message, typedef, decoded, typedef_out)