from __future__ import absolute_import

import shutil

import sys

import math

import datetime

import argparse

import uuid

import hashlib

import tempfile

import os

import re

import json

import stat

from git import Repo

from git import NULL_TREE

from truffleHogRegexes.regexChecks import regexes

def main():

def str2bool(v):

BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="

HEX_CHARS = "1234567890abcdefABCDEF"

def del_rw(action, name, exc):

def shannon_entropy(data, iterator):

    if not data:

    entropy = 0

    for x in iterator:

        p_x = float(data.count(x))/len(data)

        if p_x > 0:

            entropy += - p_x*math.log(p_x, 2)

    return entropy

def get_strings_of_set(word, char_set, threshold=20):

    count = 0

    letters = ""

    strings = []

    for char in word:

        if char in char_set:

            letters += char

            count += 1

            if count > threshold:

                strings.append(letters)

            letters = ""

            count = 0

    if count > threshold:

        strings.append(letters)

    return strings

class bcolors:

    HEADER = '\033[95m'

    OKBLUE = '\033[94m'

    OKGREEN = '\033[92m'

    WARNING = '\033[93m'

    FAIL = '\033[91m'

    ENDC = '\033[0m'

    BOLD = '\033[1m'

    UNDERLINE = '\033[4m'

def clone_git_repo(git_url):

    project_path = tempfile.mkdtemp()

    Repo.clone_from(git_url, project_path)

    return project_path

def print_results(printJson, issue):

    commit_time = issue['date']

    branch_name = issue['branch']

    prev_commit = issue['commit']

    printableDiff = issue['printDiff']

    commitHash = issue['commitHash']

    reason = issue['reason']

    path = issue['path']

    if printJson:

        print(json.dumps(issue, sort_keys=True))

def find_entropy(printableDiff, commit_time, branch_name, prev_commit, blob, commitHash):

    stringsFound = []

    lines = printableDiff.split("\n")

    for line in lines:

        for word in line.split():

            base64_strings = get_strings_of_set(word, BASE64_CHARS)

            hex_strings = get_strings_of_set(word, HEX_CHARS)

            for string in base64_strings:

                b64Entropy = shannon_entropy(string, BASE64_CHARS)

                if b64Entropy > 4.5:

                    stringsFound.append(string)

                    printableDiff = printableDiff.replace(string, bcolors.WARNING + string + bcolors.ENDC)

            for string in hex_strings:

                hexEntropy = shannon_entropy(string, HEX_CHARS)

                if hexEntropy > 3:

                    stringsFound.append(string)

                    printableDiff = printableDiff.replace(string, bcolors.WARNING + string + bcolors.ENDC)

    entropicDiff = None

    if len(stringsFound) > 0:

        entropicDiff = {}

        entropicDiff['date'] = commit_time

        entropicDiff['path'] = blob.b_path if blob.b_path else blob.a_path

        entropicDiff['branch'] = branch_name

        entropicDiff['commit'] = prev_commit.message

        entropicDiff['diff'] = blob.diff.decode('utf-8', errors='replace')

        entropicDiff['stringsFound'] = stringsFound

        entropicDiff['printDiff'] = printableDiff

        entropicDiff['commitHash'] = prev_commit.hexsha

        entropicDiff['reason'] = "High Entropy"

    return entropicDiff

def regex_check(printableDiff, commit_time, branch_name, prev_commit, blob, commitHash, custom_regexes={}):

def diff_worker(diff, curr_commit, prev_commit, branch_name, commitHash, custom_regexes, do_entropy, do_regex, printJson, surpress_output, path_inclusions, path_exclusions):

    issues = []

    for blob in diff:

        printableDiff = blob.diff.decode('utf-8', errors='replace')

        if printableDiff.startswith("Binary files"):

        if not path_included(blob, path_inclusions, path_exclusions):

        commit_time =  datetime.datetime.fromtimestamp(prev_commit.committed_date).strftime('%Y-%m-%d %H:%M:%S')

        foundIssues = []

        if do_entropy:

            entropicDiff = find_entropy(printableDiff, commit_time, branch_name, prev_commit, blob, commitHash)

            if entropicDiff:

                foundIssues.append(entropicDiff)

        if do_regex:

        if not surpress_output:

            for foundIssue in foundIssues:

                print_results(printJson, foundIssue)

        issues += foundIssues

    return issues

def handle_results(output, output_dir, foundIssues):

    for foundIssue in foundIssues:

        result_path = os.path.join(output_dir, str(uuid.uuid4()))

        with open(result_path, "w+") as result_file:

            result_file.write(json.dumps(foundIssue))

        output["foundIssues"].append(result_path)

    return output

def path_included(blob, include_patterns=None, exclude_patterns=None):

    path = blob.b_path if blob.b_path else blob.a_path

    if include_patterns and not any(p.match(path) for p in include_patterns):

        return False

    if exclude_patterns and any(p.match(path) for p in exclude_patterns):

        return False

    return True

def find_strings(git_url, since_commit=None, max_depth=1000000, printJson=False, do_regex=False, do_entropy=True, surpress_output=True,

    output = {"foundIssues": []}

    if repo_path:

        project_path = repo_path

        project_path = clone_git_repo(git_url)

    repo = Repo(project_path)

    already_searched = set()

    output_dir = tempfile.mkdtemp()

    if branch:

        branches = repo.remotes.origin.fetch(branch)

        branches = repo.remotes.origin.fetch()

    for remote_branch in branches:

        since_commit_reached = False

        branch_name = remote_branch.name

        prev_commit = None

        for curr_commit in repo.iter_commits(branch_name, max_count=max_depth):

            commitHash = curr_commit.hexsha

            if commitHash == since_commit:

                since_commit_reached = True

            if since_commit and since_commit_reached:

                prev_commit = curr_commit

                continue

            diff_hash = hashlib.md5((str(prev_commit) + str(curr_commit)).encode('utf-8')).digest()

            if not prev_commit:

                prev_commit = curr_commit

                continue

            elif diff_hash in already_searched:

                prev_commit = curr_commit

                continue

                diff = prev_commit.diff(curr_commit, create_patch=True)

            already_searched.add(diff_hash)

            foundIssues = diff_worker(diff, curr_commit, prev_commit, branch_name, commitHash, custom_regexes, do_entropy, do_regex, printJson, surpress_output, path_inclusions, path_exclusions)

            output = handle_results(output, output_dir, foundIssues)

            prev_commit = curr_commit

        diff = curr_commit.diff(NULL_TREE, create_patch=True)

        foundIssues = diff_worker(diff, curr_commit, prev_commit, branch_name, commitHash, custom_regexes, do_entropy, do_regex, printJson, surpress_output, path_inclusions, path_exclusions)

        output = handle_results(output, output_dir, foundIssues)

    output["project_path"] = project_path

    output["clone_uri"] = git_url

    output["issues_path"] = output_dir

    if not repo_path:

        shutil.rmtree(project_path, onerror=del_rw)

    return output

def clean_up(output):

if __name__ == "__main__":