def InitFromKeyValue(self, key, value):
self.key = key
# Convert primitive types to rdf values so they can be serialized.
if isinstance(value, float) and not value.is_integer():
# TODO(user): Do not convert float values here and mark them invalid
# later. ATM, we do not have means to properly represent floats. Change
# this part once we have a RDFFloat implementation.
pass
elif rdfvalue.RDFInteger.IsNumeric(value):
value = rdfvalue.RDFInteger(value)
elif isinstance(value, unicode):
value = rdfvalue.RDFString(value)
elif isinstance(value, bytes):
value = rdfvalue.RDFBytes(value)
elif isinstance(value, bool):
value = rdfvalue.RDFBool(value)
if isinstance(value, rdfvalue.RDFValue):
self.type = value.__class__.__name__
self.value = value
else:
self.invalid = True
return self
def StoreMBR(self, responses):
"""This method stores the MBR."""
if not responses.success:
msg = "Could not retrieve MBR: %s" % responses.status
self.Log(msg)
raise flow.FlowError(msg)
response = responses.First()
self.state.buffers.append(response.data)
self.state.bytes_downloaded += len(response.data)
if self.state.bytes_downloaded >= self.args.length:
mbr_data = "".join(self.state.buffers)
self.state.buffers = None
mbr = aff4.FACTORY.Create(self.client_urn.Add("mbr"),
aff4_grr.VFSFile,
mode="w",
token=self.token)
mbr.write(mbr_data)
mbr.Close()
self.Log("Successfully stored the MBR (%d bytes)." % len(mbr_data))
self.SendReply(rdfvalue.RDFBytes(mbr_data))
def ParseFile(
self,
knowledge_base: rdf_client.KnowledgeBase,
pathspec: rdf_paths.PathSpec,
filedesc: file_store.BlobStream,
) -> Iterable[rdfvalue.RDFBytes]:
del knowledge_base, pathspec # Unused.
return [rdfvalue.RDFBytes(filedesc.Read())]
def Done(self, responses):
response = responses.First()
if not responses.success:
raise flow.FlowError("Execute Python hack failed: %s" % responses.status)
if response:
result = utils.SmartStr(response.return_val)
# Send reply with full data, but only log the first 200 bytes.
str_result = result[0:200]
if len(result) >= 200:
str_result += "...[truncated]"
self.Log("Result: %s" % str_result)
self.SendReply(rdfvalue.RDFBytes(utils.SmartStr(response.return_val)))
def testAnyValueWithoutTypeCallback(self):
test_pb = AnyValueWithoutTypeFunctionTest()
for value_to_assign in [
rdfvalue.RDFString("test"),
rdfvalue.RDFInteger(1234),
rdfvalue.RDFBytes(b"abc"),
rdf_flows.GrrStatus(status="WORKER_STUCK", error_message="stuck")
]:
test_pb.dynamic = value_to_assign
serialized = test_pb.SerializeToString()
self.assertEqual(
AnyValueWithoutTypeFunctionTest.FromSerializedString(serialized),
test_pb)
def testRDFBytesConverter(self):
data = rdfvalue.RDFBytes(b"foobar")
converter = rdf_primitives.RDFBytesToExportedBytesConverter()
results = list(converter.Convert(self.metadata, data))
self.assertNotEmpty(results)
exported_bytes = [
r for r in results if r.__class__.__name__ == "ExportedBytes"
]
self.assertLen(exported_bytes, 1)
self.assertEqual(exported_bytes[0].data, data)
self.assertEqual(exported_bytes[0].length, 6)
def StoreMBR(self, responses):
"""This method stores the MBR."""
if not responses.success:
msg = "Could not retrieve MBR: %s" % responses.status
self.Log(msg)
raise flow_base.FlowError(msg)
response = responses.First()
self.state.buffers.append(response.data)
self.state.bytes_downloaded += len(response.data)
if self.state.bytes_downloaded >= self.args.length:
mbr_data = b"".join(self.state.buffers)
self.state.buffers = None
self.Log("Successfully collected the MBR (%d bytes)." % len(mbr_data))
self.SendReply(rdfvalue.RDFBytes(mbr_data))
def GenerateSample(self, number=0):
return rdfvalue.RDFBytes(b"\x00hello%s\x01" %
str(number).encode("ascii"))
def testFromRDFBytes(self): foo = rdf_objects.BlobID(rdfvalue.RDFBytes(b"12345678" * 4)) self.assertEqual(foo, b"12345678" * 4)
def GenerateSample(self, number=0):
return rdfvalue.RDFBytes(b"\x00hello%s\x01" % number)