def testReasonableInterval(self): # Check if the limit on maximum blocksize for processing still holds. dummy = io.BytesIO(b'') fp = fingerprint.Fingerprinter(dummy) big_finger = fingerprint.Finger(None, [fingerprint.Range(0, 1000001)], None) fp.fingers.append(big_finger) start, stop = fp._GetNextInterval() self.assertEqual(0, start) self.assertEqual(1000000, stop)
def _HashFile(self, fd):
"""Look for the required hashes in the file."""
hashes = data_store_utils.GetFileHashEntry(fd)
if hashes:
found_all = True
for fingerprint_type, hash_types in iteritems(self.HASH_TYPES):
for hash_type in hash_types:
if fingerprint_type == "pecoff":
hash_type = "pecoff_%s" % hash_type
if not hashes.HasField(hash_type):
found_all = False
break
if not found_all:
break
if found_all:
return hashes
fingerprinter = fingerprint.Fingerprinter(fd)
if "generic" in self.HASH_TYPES:
hashers = self._GetHashers(self.HASH_TYPES["generic"])
fingerprinter.EvalGeneric(hashers=hashers)
if "pecoff" in self.HASH_TYPES:
hashers = self._GetHashers(self.HASH_TYPES["pecoff"])
if hashers:
fingerprinter.EvalPecoff(hashers=hashers)
if not hashes:
hashes = fd.Schema.HASH()
for result in fingerprinter.HashIt():
fingerprint_type = result["name"]
for hash_type in self.HASH_TYPES[fingerprint_type]:
if hash_type not in result:
continue
if hash_type == "SignedData":
# There can be several certs in the same file.
for signed_data in result[hash_type]:
hashes.signed_data.Append(revision=signed_data[0],
cert_type=signed_data[1],
certificate=signed_data[2])
continue
# Set the hashes in the original object
if fingerprint_type == "generic":
hashes.Set(hash_type, result[hash_type])
elif fingerprint_type == "pecoff":
hashes.Set("pecoff_%s" % hash_type, result[hash_type])
else:
logging.error("Unknown fingerprint_type %s.",
fingerprint_type)
return hashes
def testHashBlock(self):
# Does it invoke a hash function?
dummy = b'12345'
fp = fingerprint.Fingerprinter(io.BytesIO(dummy))
big_finger = fingerprint.Finger(None, [fingerprint.Range(0, len(dummy))],
None)
hasher = self.MockHasher()
big_finger.hashers = [hasher]
fp.fingers.append(big_finger)
# Let's process the block
fp._HashBlock(dummy, 0, len(dummy))
self.assertEqual(hasher.seen, dummy)
def testSampleDataParsedCorrectly(self):
for fname, expected in self.SAMPLE_LIST.items():
path = package.ResourcePath(
'grr-response-test',
os.path.join('grr_response_test', 'test_data', 'fingerprint', fname))
with io.open(path, 'rb') as f:
fp = fingerprint.Fingerprinter(f)
fp.EvalGeneric()
fp.EvalPecoff()
result = fp.HashIt()
self.assertCountEqual(result, expected,
'Hashing results for %s do not match.' % fname)
def testAdjustments(self):
dummy = io.BytesIO(b'')
fp = fingerprint.Fingerprinter(dummy)
big_finger = fingerprint.Finger(None, [fingerprint.Range(10, 20)], None)
fp.fingers.append(big_finger)
# The remaining range should not yet be touched...
fp._AdjustIntervals(9, 10)
self.assertEqual([fingerprint.Range(10, 20)], fp.fingers[0].ranges)
# Trying to consume into the range. Blow up.
self.assertRaises(RuntimeError, fp._AdjustIntervals, 9, 11)
# We forgot a byte. Blow up.
self.assertRaises(RuntimeError, fp._AdjustIntervals, 11, 12)
# Consume a byte
fp._AdjustIntervals(10, 11)
self.assertEqual([fingerprint.Range(11, 20)], fp.fingers[0].ranges)
# Consumed too much. Blow up.
self.assertRaises(RuntimeError, fp._AdjustIntervals, 11, 21)
# Consume exactly.
fp._AdjustIntervals(11, 20)
self.assertEmpty(fp.fingers[0].ranges)
