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)