def buf_hashes(buf, algo='sha256'):
  if not buf:
    return None

  if algo == 'crc32':
    return "%X" % (zlib.crc32(buf) & 0xffffffff)
  elif algo == 'adler32':
    return "%X" % (zlib.adler32(buf) & 0xffffffff)
  elif algo == 'md5':
    hasher = hashlib.md5()
  elif algo == 'sha1':
    hasher = hashlib.sha1()
  elif algo == 'sha224':
    hasher = hashlib.sha224()
  elif algo == 'sha256':
    hasher = hashlib.sha256()
  elif algo == 'sha384':
    hasher = hashlib.sha384()
  elif algo == 'sha512':
    hasher = hashlib.sha512()
  elif algo == 'ssdeep':
    return pydeep.hash_file(filename)
  else:
    return None

  hasher.update(buf)
  return hasher.hexdigest()

def file_hashes(filename, algo='sha256', blocksize=65536):
  file_handle = open(filename, 'rb')
  buf = file_handle.read(blocksize)

  if algo == 'crc32':
    return "%X" % (zlib.crc32(open(filename,"rb").read()) & 0xffffffff)
  elif algo == 'adler32':
    return "%X" % (zlib.adler32(open(filename,"rb").read()) & 0xffffffff)
  elif algo == 'md5':
    hasher = hashlib.md5()
  elif algo == 'sha1':
    hasher = hashlib.sha1()
  elif algo == 'sha224':
    hasher = hashlib.sha224()
  elif algo == 'sha256':
    hasher = hashlib.sha256()
  elif algo == 'sha384':
    hasher = hashlib.sha384()
  elif algo == 'sha512':
    hasher = hashlib.sha512()
  elif algo == 'ssdeep':
    return pydeep.hash_file(filename)
  else:
    return None

  while len(buf) > 0:
    hasher.update(buf)
    buf = file_handle.read(blocksize)
  return hasher.hexdigest()

def hashfile(path, targetfile):
    '''This function returns a hash from a given file.'''
    md5 = hashlib.md5()
    sha1 = hashlib.sha1()
    sha256 = hashlib.sha256()
    sha512 = hashlib.sha512()
    fullfile = path + "/" + targetfile
    with open(fullfile, 'rb') as f:
        while True:
            data = f.read(BUF_SIZE)
            if not data:
                break
            md5.update(data)
            sha1.update(data)
            sha256.update(data)
            sha512.update(data)
            hdict = {
                'fileformat': magic.from_file(fullfile, mime=True),
                'filename': str(targetfile),
                'filesize': os.path.getsize(fullfile),
                'md5': md5.hexdigest(),
                'sha1': sha1.hexdigest(),
                'sha256': sha256.hexdigest(),
                'sha512': sha512.hexdigest(),
                'ssdeep': pydeep.hash_file(fullfile)
            }
            return hdict

    def get_ssdeep(self):
        if not HAVE_SSDEEP:
            return ''

        try:
            return pydeep.hash_file(self.path)
        except Exception:
            return ''

def test_pydeep():
    for test in testL:
        filename, filelen, filehash = test
        data = io.open(filename, 'rb').read()
        hash_buf = pydeep.hash_buf(data)
        hash_file = pydeep.hash_file(filename)
        assert len(data) == filelen, "File length error"
        assert hash_buf == filehash, "Error hashing %s using hash_buf"%filename
        assert hash_file == filehash, "Error hashing %s using hash_file"%filename

 def get_ssdeep(self):
     """ Obtem o hash SSDEEP do arquivo """
     if not HAVE_SSDEEP:
         return ''
     if self.file_data is None:
         return ''
     try:
         return pydeep.hash_file(self.file_path)
     except Exception:
         return ''

    def get_ssdeep(self):
        """Get SSDEEP.
        @return: SSDEEP.
        """
        if not HAVE_SSDEEP:
            return None

        try:
            return pydeep.hash_file(self.file_path)
        except Exception:
            return None

    def get_ssdeep(self):
        if not HAVE_SSDEEP:
            return None

        try:
            if Config().api.use_aws:
                return pydeep.hash_buffer(self.data)
            else:
                return pydeep.hash_file(self.path)
        except Exception:
            return None

    def get_ssdeep(self):
        """Get SSDEEP.
        @return: SSDEEP.
        """
        if not HAVE_PYDEEP:
            if not File.notified_pydeep:
                File.notified_pydeep = True
                log.warning("Unable to import pydeep (install with `pip install pydeep`)")
            return None

        try:
            return pydeep.hash_file(self.file_path)
        except Exception:
            return None

    def analyze(self, config, filename):
        """Analyze the file."""

        # sanity check to make sure we can run
        if self.is_activated == False:
            return False
        log = logging.getLogger('Mastiff.Plugins.' + self.name)
        log.info('Starting execution.')
        log.info('Generating fuzzy hash.')

        try:
            my_fuzzy = pydeep.hash_file(filename)
        except pydeep.error, err:
            log.error('Could not generate fuzzy hash: %s', err)
            return False

	def ssdeepMe(path):
		if path is not None:
			return pydeep.hash_file(path)
		else:
			print("Ssdeep: provide a file path")
			return ""

def get_ssdeep(malware_path):
  return pydeep.hash_file(malware_path)

#!/usr/bin/env python
#ssdeep insto hashin'! - since ssdeep is natively an unwieldy PITA.
#https://pypi.python.org/pypi/pydeep
#PhG

import sys, pydeep
pd1 = pydeep.hash_file(sys.argv[1])
pd2 = pydeep.hash_file(sys.argv[2])
percent = str(pydeep.compare(pd1, pd2))
print "SSDeep has determined that these files are " + percent +"% alike."

#pd0 = pydeep.hash_file("VirusShare_ab208f0b517ba9850f1551c9555b5313")
#pd1 = pydeep.hash_file("VirusShare_6570163cd34454b3d1476c134d44b9d9")

def ssdeep(filename):
	return pydeep.hash_file(filename)

#!/usr/bin/env python
#ssdeep massive comparision engine (fancy way of saying... shitty script)
#there's no reason to do this... idk wtf I was doing. This makes no sense. Broken.

import sys
import pydeep
pd0 = pydeep.hash_file(sys.argv[1])
pd1 = sys.argv[2]
#Import our ssdeep file.
def deepImp(pd1) :
                deepDict = []
                with open(pd1, 'r') as deepFiles:
                    for row in deepFiles:
                        deepDict.append(row[1])
                return ssdeepDir
deepImpList = deepImp(pd1)
x = str(pydeep.compare(pd0, pd1))
print "SSDeep has determined that the DeepImportHash between" + (sys.argv[1]) + " and " + deepImpList + " are " + x +"% alike."

def get_ssdeep(path):
    try:
        return pydeep.hash_file(path)
    except Exception:
        return ''

import pydeep
file1 = 'calc.exe'
file2 = 'notepad.exe'
file3 = 'bc'
file1hash = '1536:JEl14rQcWAkN7GAlqbkfAGQGV8aMbrNyrf1w+noPvLV6eBsCXKc:JYmZWXyaiedMbrN6pnoXL1BsC'
file2hash = '1536:0awOnbNQKLjWDyy1o5RefYMJUEbooPRrKKRl1P3:0YNQKPWDyDRefVJltZrpRl1P3'
file3hash = '1536:MsjYdR3Bul8hcURWhEcg4/btZzDcQflbCUPEBEh8wkcGDioxMYeo7:TYf8l8htRWA4ztZsGlWUPEBEh8wmxMYe'
data1 = open(file1).read()
data2 = open(file2).read()
data3 = open(file3).read()
assert len(data1) == 114688, "File length error"
assert len(data2) ==  69120, "File length error"
assert len(data3) ==  77168, "File length error"
hash01 = pydeep.hash_buf(data1)
hash02 = pydeep.hash_buf(data2)
hash03 = pydeep.hash_buf(data3)
assert hash01 == file1hash, "Error hashing file1"
assert hash02 == file2hash, "Error hashing file2"
assert hash03 == file3hash, "Error hashing file2"
hash1 = pydeep.hash_file(file1)
hash2 = pydeep.hash_file(file2)
hash3 = pydeep.hash_file(file3)
assert hash1 == file1hash, "Error hashing file1"
assert hash2 == file2hash, "Error hashing file2"
assert hash3 == file3hash, "Error hashing file3"
assert pydeep.compare(hash1,hash2) == 0, "Error fuzzy compare value"
print 'Stuff looks fine..'