Golang program to check a string list of patterns in another string list - password cracking

Community, I need suggestions on improving the following code:

To give the problem, the program does the following:

• It reads a file containing sha2 hashes into a string array.
• It accepts a starting number and computes the hash values consecutively.
• It checks for the computed hash with the hashes from the file (list) and prints the matches.

//FILENAME: passcracker.go
package main
import (
"fmt"
"crypto/sha256"
"os"
"io/ioutil"
"strings"
"math/big"	
)
func isValueInList(value1 string, list []string) bool {
for _, v := range list {
if v == value1 {
return true
}
}
return false
}
func main() {
if len(os.Args) <= 2 {
fmt.Printf("USAGE : %s <PATTERNFILE> <STARTING_NUMBER>\n", os.Args[0])
os.Exit(0)
}
fileName := os.Args[1]
fileBytes, err := ioutil.ReadFile(fileName)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
strHashArr := strings.Split(string(fileBytes), "\r\n")
startNum := new(big.Int)
startNum.SetString(os.Args[2], 10)
one := big.NewInt(1)
//list := []string{ }
var i int64
for i = 0; i < 262144; i++ {
h := sha256.New()
h.Write([]byte(startNum.Bytes()))
s := fmt.Sprintf("%x", h.Sum(nil))
// Hash values are computed and added to a string list - A probable approach
//list.append(s)
if isValueInList(s, strHashArr) {
fmt.Printf("Matched Hash %s for number %s\n",s,startNum)
}
startNum = startNum.Add(startNum,one)
}
// Probable approach to reduce the time
// Computed hash string list is checked with the file hashes list
// Function takes to string arrays 
// Can it also use map or any other method for list in list comparison?
//if isValueInList(list, strHashArr) {
// get all the matched items and print the index value using the startNum value in a loop
//}
}

The password hash file is at: https://pastebin.com/TWPxrb4R

To run the program, use

passcracker hashes.txt 1000

The program prints the matching hashes along with the identified number.

Since the program only computes a limited 262144 hashes, it will print faster.

Now to improve the program to output the matches faster, is it possible to compute the hashes into a string array and call a function to match the hashes from the file and return the matched indexes in a single call?

Since the problem is very similar to password cracking approach, but here the difference is to print the sequentially computed and matched hash value. It is something like a running user id which is consecutive.

Since the input hash file could get really big (in the tune of a couple of thousand hashes) and consecutive numbers could also be a large one, the program struggles even if the computation is just for 32K loop for a hash file containing a 10K hashes.

Currently for the sake of brevity, the number of hashes in the above file is 50 and loop checks for 256K numbers which executes faster.

Some help would be really appreciated. Thank you.

I was able to triple the speed:

package main
import (
"bufio"
"crypto/sha256"
"encoding/binary"
"encoding/hex"
"math/bits"
"os"
"testing"
)
func BenchmarkFast(b *testing.B) {
f, err := os.Open("hashes.txt")
if err != nil {
b.Fatal(err)
}
defer f.Close()
s := bufio.NewScanner(f)
hash := make(map[[32]byte]struct{})
for s.Scan() {
var dst [32]byte
hex.Decode(dst[:], s.Bytes())
hash[dst] = struct{}{}
}
var num uint64
for n := 0; n < b.N; n++ {
buf := make([]byte, 8)
binary.BigEndian.PutUint64(buf, num)
buf = buf[bits.LeadingZeros64(num)>>3:]
sum := sha256.Sum256(buf)
if _, ok := hash[sum]; ok {
}
num++
}
}

Result:

BenchmarkFast-12         5983708               198.2 ns/op
BenchmarkSlow-12         1946358               614.7 ns/op