CRC guesser

crc_brute.go

package main

import (
	"bytes"
	"encoding/csv"
	"errors"
	"flag"
	"fmt"
	"hash/crc32"
	"io"
	"io/ioutil"
	"log"
	"os"
	"runtime"
	"strconv"
	"strings"
	"sync"
)

func main() {
	unknowns := map[uint32]struct{}{}
	var limit int
	var parts []string

	source := flag.String("source", "list.csv", "CSV containing Hash, Name as a starting point")
	partsName := flag.String("parts", "", "line-separated list of parts")
	limitV := flag.Int("limit", 100000, "max permutation")
	flag.Parse()
	limit = *limitV

	srcFi, err := os.Open(*source)
	if err != nil {
		panic(err)
	}
	rd := csv.NewReader(srcFi)
	head, err := rd.Read()
	if len(head) < 2 || strings.ToLower(strings.TrimSpace(head[0])) != "hash" || strings.ToLower(strings.TrimSpace(head[1])) != "name" {
		panic(errors.New("source csv is invalid format"))
	}

	for {
		rec, err := rd.Read()
		if err != nil {
			if err == io.EOF {
				break
			}
			panic(err)
		}
		if len(rec) == 0 {
			continue
		}
		h64, _ := strconv.ParseUint(strings.TrimSpace(rec[0]), 16, 32)
		hash := uint32(h64)
		name := strings.TrimSpace(rec[1])
		if hash != hashName(name) {
			unknowns[hash] = struct{}{}
		}
	}
	srcFi.Close()

	partsFi, err := os.Open(*partsName)
	if err != nil {
		panic(err)
	}
	partsBuf, err := ioutil.ReadAll(partsFi)
	if err != nil {
		panic(err)
	}
	partsFi.Close()
	partsUntrimmed := strings.Split(string(partsBuf), "\n")
	for _, p := range partsUntrimmed {
		p := strings.TrimSpace(p)
		if p != "" {
			parts = append(parts, p)
		}
	}
	log.Println("parts:", parts)

	numCPU := runtime.NumCPU()
	l := len(parts) + 1
	var om sync.Mutex
	var w sync.WaitGroup
	for n := 0; n < numCPU; n++ {
		tid := n
		w.Add(1)
		go func(i int) {
			for ; i < limit; i += numCPU {
				z := i
				s := ""
				idem := false
				for z > 0 {
					zi := z % l
					if zi > 0 {
						s = parts[zi-1] + s
					} else {
						idem = true
						break
					}
					z /= l
				}
				if idem {
					continue
				}
				hash := hashName(s)
				if _, ok := unknowns[hash]; ok {
					om.Lock()
					fmt.Printf("%X, %s\n", hash, s)
					om.Unlock()
				}
			}
			w.Done()
		}(tid)
	}
	w.Wait()
}

func hashName(s string) uint32 {
	return crc32.ChecksumIEEE(bytes.ToLower([]byte(s)))
}