Feature Request: Optimize the logic of obtaining browser data. about hackbrowserdata

[rowingdude]

Hello, I would like to take a stab at this.

I'd like to propose using a single map and a key of the folder.

First, we modify the original "walk" function to get rid of the if statements which cause obscurity. This eliminates one map and established a directory of composite keys, which are much faster to look up than re-traversing.

func chromiumWalkFunc(items []item.Item, itemPaths map[string]map[item.Item]string) filepath.WalkFunc {
	return func(path string, info fs.FileInfo, err error) error {
		if !isValidItem(path, info, items) {
			return nil
		}
		
		profileFolder := fileutil.ParentBaseDir(path)
		if strings.Contains(filepath.ToSlash(path), "/Network/Cookies") {
			profileFolder = fileutil.BaseDir(strings.ReplaceAll(filepath.ToSlash(path), "/Network/Cookies", ""))
		}
	
		for _, v := range items {
			if info.Name() == v.Filename() {
				itemPaths[composeKey(profileFolder, v)] = path
				break 
			}
		}
		
		return nil
	}
}

func composeKey(profileFolder string, item item.Item) string {
	return fmt.Sprintf("%s|%s", profileFolder, item.Filename())
}

We then write up a function to test if the item is what we're looking for:

func isValidItem(path string, info fs.FileInfo, items []item.Item) bool {
	if info.IsDir() || strings.Contains(path, "System Profile") {
		return false
	}
	for _, v := range items {
		if info.Name() == v.Filename() {
			return true
		}
	}
	return false
}

I have not bench marked this yet but present it here as a possible alternative to your original idea.

[moonD4rk]

Thanks for your suggestion @rowingdude, The following structure is defined in the new version. Use the KeyFile of Chromium to determine the location of RootPath .

There are still some bugs that need to be fixed. I will submit the code in the next few days and look forward to your review at that time.

type BrowserProfile struct {
	// Name name like 'Default', 'BrowserProfile 1', etc.
	Name string
	// Path to the master key file (e.g., 'Local State', 'key4.db',
	KeyPath string
	// MasterKey is the key used to decrypt the browser data.
	MasterKey []byte
	// Map of data types to file paths
	DataFiles map[types.DataType][]string
}

func (bd *BrowserData) findChromiumProfiles(rootPath string, dataTypes []types.DataType) (map[string]*BrowserProfile, error) {
	profiles := make(map[string]*BrowserProfile)
	var sharedKeyPath string
	err := filepath.WalkDir(rootPath, func(path string, entry fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		normalizedPath := filepath.ToSlash(path)
		// Skip directories that should not be included
		if entry.IsDir() && skipDirs(normalizedPath, defaultExcludeDirs) {
			return fs.SkipDir
		}
		for _, dataType := range dataTypes {
			if entry.Name() != dataType.Filename() {
				continue
			}
			// Calculate relative path from Chrome baseDir path
			profileName := extractProfileNameFromPath(rootPath, path)
			// handle shard key
			if profileName == "" && dataType == types.ChromiumKey {
				sharedKeyPath = path
			}
			if profileName == "" {
				continue
			}
			if _, exists := profiles[profileName]; !exists {
				profiles[profileName] = newProfile(profileName)
				profiles[profileName].DataFiles[dataType] = []string{path}
			} else {
				profiles[profileName].DataFiles[dataType] = append(profiles[profileName].DataFiles[dataType], path)
			}
		}
		return nil
	})
	// Assign the shared key path to all profileNames
	for _, profile := range profiles {
		profile.KeyPath = sharedKeyPath
	}
	return profiles, err
}