reg-dump

main.go (8026B)

---

 package main
 
 import (
 	"flag"
 	"fmt"
 	"hash/maphash"
 	"io"
 	"log/slog"
 	"os"
 	"path/filepath"
 	"regexp"
 	"slices"
 	"strconv"
 	"strings"
 	"sync"
 
 	"github.com/carlmjohnson/flowmatic"
 	"golang.org/x/sys/windows/registry"
 
 	_ "net/http/pprof"
 )
 
 func main() {
 	args := os.Args[1:]
 
 	cmd := "search"
 
 	if v, ok := take(&args); ok {
 		cmd = v
 	}
 
 	switch cmd {
 	case "search":
 		Search(args)
 	case "show":
 		Show(args)
 	case "purge":
 		Purge(args)
 	}
 }
 
 // take returns the first element.
 func take[S ~[]E, E any](s *S) (e E, ok bool) {
 	if len(*s) == 0 {
 		return e, false
 	}
 	defer func() { *s = (*s)[1:] }()
 	return (*s)[0], true
 }
 
 // Show outputs the given registry key values.
 func Show(args []string) {
 	var path string
 
 	flags := flag.NewFlagSet("show", flag.ExitOnError)
 	flags.StringVar(&path, "path", "", "path to show values for")
 	flags.Parse(args)
 
 	positional := flags.Args()
 
 	if path == "" && len(positional) > 0 {
 		path, _ = take(&positional)
 	}
 
 	show(path)
 }
 
 // Search the registry outputting each entry that contains the given pattern.
 // If the pattern is empty search will output all entries.
 func Search(args []string) {
 	var (
 		log     string
 		pattern string
 		root    string
 	)
 
 	flags := flag.NewFlagSet("search", flag.ExitOnError)
 	flags.StringVar(&log, "log", "", "log file")
 	flags.StringVar(&pattern, "pattern", "", "regex pattern to match against")
 	flags.StringVar(&root, "path", "", "root search path")
 	flags.Parse(args)
 
 	var exp *regexp.Regexp
 
 	if pattern != "" {
 		exp = regexp.MustCompile(pattern)
 	}
 
 	var output io.Writer
 
 	if log != "" {
 		f, err := os.OpenFile(log, os.O_CREATE|os.O_WRONLY, 0o644)
 		if err != nil {
 			panic(fmt.Errorf("opening log file: %w", err))
 		}
 		defer f.Close()
 		output = f
 	} else {
 		output = os.Stderr
 	}
 
 	manager := Manager{
 		Logger:  slog.New(slog.NewTextHandler(output, nil)),
 		Pattern: exp,
 	}
 
 	flowmatic.ManageTasks(-1, walk, manager.Search, root)
 }
 
 // Purge the registry of all entries that match the pattern.
 func Purge(args []string) {
 	var (
 		log     string
 		pattern string
 		root    string
 	)
 
 	flags := flag.NewFlagSet("search", flag.ExitOnError)
 	flags.StringVar(&log, "log", "", "log file")
 	flags.StringVar(&pattern, "pattern", "", "regex pattern to match against")
 	flags.StringVar(&root, "path", "", "root search path")
 	flags.Parse(args)
 
 	if pattern == "" {
 		fmt.Println("-pattern is required")
 		os.Exit(1)
 	}
 
 	var exp *regexp.Regexp
 
 	if pattern != "" {
 		exp = regexp.MustCompile(pattern)
 	}
 
 	var output io.Writer
 
 	if log != "" {
 		f, err := os.OpenFile(log, os.O_CREATE|os.O_WRONLY, 0o644)
 		if err != nil {
 			panic(fmt.Errorf("opening log file: %w", err))
 		}
 		defer f.Close()
 		output = f
 	} else {
 		output = os.Stderr
 	}
 
 	manager := Manager{
 		Logger:  slog.New(slog.NewTextHandler(output, nil)),
 		Pattern: exp,
 	}
 
 	flowmatic.ManageTasks(-1, walk, manager.Purge, root)
 }
 
 type Manager struct {
 	*slog.Logger
 	Pattern *regexp.Regexp
 
 	seedInit sync.Once
 	seed     maphash.Seed
 
 	seen []uint64
 }
 
 // Search outputs matched registry entries.
 func (m *Manager) Search(path string, subkeys []string, err error) ([]string, bool) {
 	if err != nil {
 		m.Error("task", path, err)
 	}
 
 	if m.redundant(path) {
 		m.Warn("skipping", "path", path)
 		return nil, true
 	}
 
 	if m.match(path) {
 		if err == nil {
 			fmt.Println(path)
 		} else {
 			fmt.Printf("%s (%s)", path, err.Error())
 		}
 	}
 
 	for ii, subkey := range subkeys {
 		subkeys[ii] = filepath.Join(path, subkey)
 	}
 
 	return subkeys, true
 }
 
 // Purge deletes matched registry entries.
 func (m *Manager) Purge(path string, subkeys []string, err error) ([]string, bool) {
 	if err != nil {
 		m.Error("task", path, err)
 	}
 
 	if m.redundant(path) {
 		m.Warn("skipping", "path", path)
 		return nil, true
 	}
 
 	if m.match(path) && err == nil {
 		if err := m.purge(path); err != nil {
 			m.Error("purge", path, err)
 		}
 		return nil, true
 	}
 
 	for ii, subkey := range subkeys {
 		subkeys[ii] = filepath.Join(path, subkey)
 	}
 
 	return subkeys, true
 }
 
 // purge the given path.
 // If the path contains the pattern, delete the key.
 // Else if the key's values contain the pattern in name or value, delete them.
 func (m *Manager) purge(path string) error {
 	if m.Pattern.MatchString(path) {
 		if err := registry.DeleteKey(registry.CURRENT_USER, path); err != nil {
 			return fmt.Errorf("deleting key: %w", err)
 		}
 		return nil
 	}
 
 	key, err := registry.OpenKey(registry.CURRENT_USER, path, registry.ALL_ACCESS)
 	if err != nil {
 		return fmt.Errorf("opening key with write permissions: %w", err)
 	}
 
 	defer key.Close()
 
 	forEachValue(key, func(name, value string, err error) bool {
 		if err != nil {
 			m.Error("iterating", fmt.Sprintf("%s.%s", path, name), err)
 		}
 		if m.Pattern.MatchString(name) || m.Pattern.MatchString(value) {
 			if err := key.DeleteValue(name); err != nil {
 				m.Error("deleting", fmt.Sprintf("%s.%s", path, name), err)
 			}
 		}
 		return true
 	})
 
 	return nil
 }
 
 // redundant is true if the path has already been seen.
 //
 // The check is done using a binary search over sorted hashes to avoid retaining
 // many heap allocated strings. The registry has a lot of entries and can easily
 // consume gigabytes of memory if we heap allocate each path.
 func (m *Manager) redundant(path string) bool {
 	m.seedInit.Do(func() {
 		m.seed = maphash.MakeSeed()
 	})
 
 	hash := maphash.String(m.seed, path)
 
 	if _, ok := slices.BinarySearch(m.seen, hash); ok {
 		return true
 	}
 
 	m.seen = append(m.seen, hash)
 	slices.Sort(m.seen)
 
 	return false
 }
 
 // match the path and its values against the pattern.
 func (m *Manager) match(path string) bool {
 	if m.Pattern == nil {
 		return true
 	}
 
 	if m.Pattern.MatchString(path) {
 		return true
 	}
 
 	key, err := registry.OpenKey(registry.CURRENT_USER, path, registry.READ|registry.ENUMERATE_SUB_KEYS|registry.QUERY_VALUE)
 	if err != nil {
 		return false
 	}
 
 	defer key.Close()
 
 	return !forEachValue(key, func(name, value string, err error) bool {
 		if err != nil {
 			m.Error("matching", fmt.Sprintf("%s.%s", path, name), err)
 			return true
 		}
 		if m.Pattern.MatchString(name) || m.Pattern.MatchString(value) {
 			return false
 		}
 		return true
 	})
 }
 
 func walk(path string) ([]string, error) {
 	key, err := registry.OpenKey(registry.CURRENT_USER, path, registry.READ|registry.ENUMERATE_SUB_KEYS|registry.QUERY_VALUE)
 	if err != nil {
 		return nil, fmt.Errorf("opening key: %w", err)
 	}
 
 	defer key.Close()
 
 	subkeys, err := key.ReadSubKeyNames(-1)
 	if err != nil {
 		return nil, fmt.Errorf("reading subkeys: %w", err)
 	}
 
 	return subkeys, nil
 }
 
 func show(path string) {
 	key, err := registry.OpenKey(registry.CURRENT_USER, path, registry.READ|registry.ENUMERATE_SUB_KEYS|registry.QUERY_VALUE)
 	if err != nil {
 		panic(err)
 	}
 
 	defer key.Close()
 
 	forEachValue(key, func(name, value string, err error) bool {
 		if name == "" {
 			name = "Default"
 		}
 		if err != nil {
 			fmt.Fprintf(os.Stdout, "%v: %q (%v)\n", name, value, err.Error())
 		} else {
 			fmt.Fprintf(os.Stdout, "%v: %q\n", name, value)
 		}
 		return true
 	})
 }
 
 // forEachValue invokes [fn] on each value [key], returning true if all values were processed.
 func forEachValue(key registry.Key, fn func(name string, value string, err error) bool) bool {
 	names, err := key.ReadValueNames(-1)
 	if err != nil {
 		panic(fmt.Errorf("reading value names: %w", err))
 	}
 
 	for _, name := range names {
 		_, t, err := key.GetValue(name, nil)
 		if err != nil {
 			panic(err)
 		}
 
 		var value string
 
 		switch t {
 		case registry.SZ, registry.EXPAND_SZ:
 			value, _, err = key.GetStringValue(name)
 			if err != nil {
 				fn(name, value, err)
 			}
 
 		case registry.DWORD, registry.QWORD:
 			n, _, err := key.GetIntegerValue(name)
 			if err != nil {
 				fn(name, value, err)
 			}
 			value = strconv.Itoa(int(n))
 
 		case registry.MULTI_SZ:
 			values, _, err := key.GetStringsValue(name)
 			if err != nil {
 				fn(name, value, err)
 			}
 			value = strings.Join(values, " | ")
 		}
 
 		if value != "" {
 			if !fn(name, value, err) {
 				return false
 			}
 		}
 	}
 
 	return true
 }