Updating Makefile, making in-memory default, adding disk option

Makefile

@@ -18,4 +18,5 @@ build-all:
 	env GOOS="linux" GOARCH="amd64" go build -o "build/gitleaks-linux-amd64"
 	env GOOS="linux" GOARCH="arm" go build -o "build/gitleaks-linux-arm"
 	env GOOS="linux" GOARCH="mips" go build -o "build/gitleaks-linux-mips"
-	env GOOS="linux" GOARCH="mips" go build -o "build/gitleaks-linux-mips"
+	env GOOS="linux" GOARCH="mips" go build -o "build/gitleaks-linux-mips"
+	env GOOS="darwin" GOARCH="amd64" go build -o "build/gitleaks-darwin-amd64"

README.md

@@ -30,7 +30,7 @@ Application Options:
       --repo-path=     Path to repo
       --owner-path=    Path to owner directory (repos discovered)
       --max-go=        Maximum number of concurrent go-routines gitleaks spawns
-  -m, --in-memory      Run gitleaks in memory
+      --disk           Clones repo(s) to disk
       --all-refs       run audit on all refs
       --single-search= single regular expression to search for
       --config=        path to gitleaks config

gitleaks_test.go

@@ -85,10 +85,10 @@ func TestGetRepo(t *testing.T) {
 		},
 		{
 			testOpts: Options{
-				Repo:  "https://github.com/gitleakstest/gronit",
-				InMem: true,
+				Repo: "https://github.com/gitleakstest/gronit",
+				Disk: true,
 			},
-			description:    "test inmem clone remote repo",
+			description:    "test on disk clone remote repo",
 			expectedErrMsg: "",
 		},
 		{
@@ -117,7 +117,7 @@ func TestGetRepo(t *testing.T) {
 			testOpts: Options{
 				Repo:           "https://github.com/gitleakstest/private",
 				IncludePrivate: true,
-				InMem:          true,
+				Disk:           true,
 			},
 			description:    "test private repo",
 			expectedErrMsg: "invalid auth method",
@@ -167,9 +167,9 @@ func TestGetOwnerRepo(t *testing.T) {
 		{
 			testOpts: Options{
 				GithubUser: "gitleakstest",
-				InMem:      true,
+				Disk:       true,
 			},
-			description:    "test github user in mem",
+			description:    "test github user on disk ",
 			numRepos:       2,
 			expectedErrMsg: "",
 		},
@@ -201,9 +201,9 @@ func TestGetOwnerRepo(t *testing.T) {
 		{
 			testOpts: Options{
 				GithubOrg: "gitleakstestorg",
-				InMem:     true,
+				Disk:      true,
 			},
-			description:    "test org in mem",
+			description:    "test org on disk",
 			numRepos:       2,
 			expectedErrMsg: "",
 		},
@@ -211,9 +211,9 @@ func TestGetOwnerRepo(t *testing.T) {
 			testOpts: Options{
 				GithubOrg:      "gitleakstestorg",
 				IncludePrivate: true,
-				InMem:          true,
+				Disk:           true,
 			},
-			description:    "test private org in mem no ssh",
+			description:    "test private org on disk no ssh",
 			numRepos:       0,
 			expectedErrMsg: "no ssh auth available",
 		},

main.go

@@ -79,7 +79,7 @@ type Options struct {
 
 	// Process options
 	MaxGoRoutines int    `long:"max-go" description:"Maximum number of concurrent go-routines gitleaks spawns"`
-	InMem         bool   `short:"m" long:"in-memory" description:"Run gitleaks in memory"`
+	Disk          bool   `long:"disk" description:"Clones repo(s) to disk"`
 	AuditAllRefs  bool   `long:"all-refs" description:"run audit on all refs"`
 	SingleSearch  string `long:"single-search" description:"single regular expression to search for"`
 	ConfigPath    string `long:"config" description:"path to gitleaks config"`
@@ -200,7 +200,7 @@ func main() {
 		}
 	}
 
-	if !opts.InMem {
+	if opts.Disk {
 		// temporary directory where all the gitleaks plain clones will reside
 		dir, err = ioutil.TempDir("", "gitleaks")
 		defer os.RemoveAll(dir)
@@ -254,15 +254,16 @@ func getRepo() (Repo, error) {
 		r   *git.Repository
 	)
 
-	if opts.InMem {
+	if opts.Disk {
+		cloneTarget := fmt.Sprintf("%s/%x", dir, md5.Sum([]byte(fmt.Sprintf("%s%s", opts.GithubUser, opts.Repo))))
 		if opts.IncludePrivate {
-			r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
+			r, err = git.PlainClone(cloneTarget, false, &git.CloneOptions{
 				URL:      opts.Repo,
 				Progress: os.Stdout,
 				Auth:     sshAuth,
 			})
 		} else {
-			r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
+			r, err = git.PlainClone(cloneTarget, false, &git.CloneOptions{
 				URL:      opts.Repo,
 				Progress: os.Stdout,
 			})
@@ -271,15 +272,14 @@ func getRepo() (Repo, error) {
 		// use existing repo
 		r, err = git.PlainOpen(opts.RepoPath)
 	} else {
-		cloneTarget := fmt.Sprintf("%s/%x", dir, md5.Sum([]byte(fmt.Sprintf("%s%s", opts.GithubUser, opts.Repo))))
 		if opts.IncludePrivate {
-			r, err = git.PlainClone(cloneTarget, false, &git.CloneOptions{
+			r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
 				URL:      opts.Repo,
 				Progress: os.Stdout,
 				Auth:     sshAuth,
 			})
 		} else {
-			r, err = git.PlainClone(cloneTarget, false, &git.CloneOptions{
+			r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
 				URL:      opts.Repo,
 				Progress: os.Stdout,
 			})
@@ -535,32 +535,32 @@ func getUserGithubRepos(ctx context.Context, listOpts *github.RepositoryListOpti
 
 		for _, rDesc := range rs {
 			log.Debugf("Cloning: %s from %s", *rDesc.Name, *rDesc.SSHURL)
-			if opts.InMem {
+			if opts.Disk {
+				ownerDir, err := ioutil.TempDir(dir, opts.GithubUser)
+				if err != nil {
+					return repos, fmt.Errorf("unable to generater owner temp dir: %v", err)
+				}
 				if opts.IncludePrivate {
-					r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
+					r, err = git.PlainClone(fmt.Sprintf("%s/%s", ownerDir, *rDesc.Name), false, &git.CloneOptions{
 						URL:  *rDesc.SSHURL,
 						Auth: sshAuth,
 					})
 				} else {
-					r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
+					r, err = git.PlainClone(fmt.Sprintf("%s/%s", ownerDir, *rDesc.Name), false, &git.CloneOptions{
 						URL: *rDesc.CloneURL,
 					})
+
 				}
 			} else {
-				ownerDir, err := ioutil.TempDir(dir, opts.GithubUser)
-				if err != nil {
-					return repos, fmt.Errorf("unable to generater owner temp dir: %v", err)
-				}
 				if opts.IncludePrivate {
-					r, err = git.PlainClone(fmt.Sprintf("%s/%s", ownerDir, *rDesc.Name), false, &git.CloneOptions{
+					r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
 						URL:  *rDesc.SSHURL,
 						Auth: sshAuth,
 					})
 				} else {
-					r, err = git.PlainClone(fmt.Sprintf("%s/%s", ownerDir, *rDesc.Name), false, &git.CloneOptions{
+					r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
 						URL: *rDesc.CloneURL,
 					})
-
 				}
 			}
 			if err != nil {
@@ -593,38 +593,38 @@ func getOrgGithubRepos(ctx context.Context, listOpts *github.RepositoryListByOrg
 		rs, resp, err := client.Repositories.ListByOrg(ctx, opts.GithubOrg, listOpts)
 		for _, rDesc := range rs {
 			log.Debugf("Cloning: %s from %s", *rDesc.Name, *rDesc.SSHURL)
-			if opts.InMem {
+			if opts.Disk {
+				ownerDir, err = ioutil.TempDir(dir, opts.GithubUser)
+				if err != nil {
+					return repos, fmt.Errorf("unable to generater owner temp dir: %v", err)
+				}
 				if opts.IncludePrivate {
 					if sshAuth == nil {
 						return nil, fmt.Errorf("no ssh auth available")
 					}
-					r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
+					r, err = git.PlainClone(fmt.Sprintf("%s/%s", ownerDir, *rDesc.Name), false, &git.CloneOptions{
 						URL:  *rDesc.SSHURL,
 						Auth: sshAuth,
 					})
 				} else {
-					r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
+					r, err = git.PlainClone(fmt.Sprintf("%s/%s", ownerDir, *rDesc.Name), false, &git.CloneOptions{
 						URL: *rDesc.CloneURL,
 					})
+
 				}
 			} else {
-				ownerDir, err = ioutil.TempDir(dir, opts.GithubUser)
-				if err != nil {
-					return repos, fmt.Errorf("unable to generater owner temp dir: %v", err)
-				}
 				if opts.IncludePrivate {
 					if sshAuth == nil {
 						return nil, fmt.Errorf("no ssh auth available")
 					}
-					r, err = git.PlainClone(fmt.Sprintf("%s/%s", ownerDir, *rDesc.Name), false, &git.CloneOptions{
+					r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
 						URL:  *rDesc.SSHURL,
 						Auth: sshAuth,
 					})
 				} else {
-					r, err = git.PlainClone(fmt.Sprintf("%s/%s", ownerDir, *rDesc.Name), false, &git.CloneOptions{
+					r, err = git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
 						URL: *rDesc.CloneURL,
 					})
-
 				}
 			}
 			if err != nil {