Implement manual fuzzy search, enabled by default (#213, fixes #32)

Author: sophacles

Gopkg.lock

@@ -27,11 +27,22 @@ type Login struct {
 
 var endianness = binary.LittleEndian
 
+// Settings info for the browserpass program.
+//
+// The browser extension will look up settings in its localstorage and find
+// which options have been selected by the user, and put them in a JSON object
+// which is then passed along with the command over the native messaging api.
+type Config struct {
+	// Manual searches use FuzzySearch if true, GlobSearch otherwise
+	UseFuzzy bool `json:"use_fuzzy_search"`
+}
+
 // msg defines a message sent from a browser extension.
 type msg struct {
-	Action string `json:"action"`
-	Domain string `json:"domain"`
-	Entry  string `json:"entry"`
+	Settings Config `json:"settings"`
+	Action   string `json:"action"`
+	Domain   string `json:"domain"`
+	Entry    string `json:"entry"`
 }
 
 // Run starts browserpass.
@@ -53,6 +64,10 @@ func Run(stdin io.Reader, stdout io.Writer, s pass.Store) error {
 			return err
 		}
 
+		// Since the pass.Store object is created by the wrapper prior to
+		// settings from the browser being made available, we set them here
+		s.SetConfig(&data.Settings.UseFuzzy)
+
 		var resp interface{}
 		switch data.Action {
 		case "search":
@@ -61,6 +76,12 @@ func Run(stdin io.Reader, stdout io.Writer, s pass.Store) error {
 				return err
 			}
 			resp = list
+		case "match_domain":
+			list, err := s.GlobSearch(data.Domain)
+			if err != nil {
+				return err
+			}
+			resp = list
 		case "get":
 			rc, err := s.Open(data.Entry)
 			if err != nil {

browserpass.go

@@ -85,6 +85,14 @@ function onMessage(request, sender, sendResponse) {
   if (request.action == "dismissOTP" && sender.tab.id in tabInfos) {
     delete tabInfos[sender.tab.id];
   }
+
+  // allows the local communication to request settings. Returns an
+  // object that has current settings. Update this as new settings
+  // are added (or old ones removed)
+  if (request.action == "getSettings") {
+    const use_fuzzy_search = localStorage.getItem("use_fuzzy_search") != "false";
+    sendResponse({ use_fuzzy_search: use_fuzzy_search})
+  }
 }
 
 function onTabUpdated(tabId, changeInfo, tab) {

chrome/background.js

@@ -13,6 +13,11 @@
   Auto-Submit login forms
 </label>
 <br/>
+<label>
+  <input type="checkbox" id="use-fuzzy">
+  Use fuzzy search
+</label>
+<br/>
 <br/>
 <button id="save">Save</button>
 

chrome/options.html

@@ -1,12 +1,23 @@
 function save_options() {
   var autoSubmit = document.getElementById("auto-submit").checked;
   localStorage.setItem("autoSubmit", autoSubmit);
+
+  // Options related to fuzzy finding.
+  //  use_fuzzy_search indicates if fuzzy finding or glob searching should
+  //  be used in manual searches
+  var use_fuzzy = document.getElementById("use-fuzzy").checked;
+  localStorage.setItem("use_fuzzy_search", use_fuzzy);
+
   window.close();
 }
 
 function restore_options() {
   var autoSubmit = localStorage.getItem("autoSubmit") == "true";
   document.getElementById("auto-submit").checked = autoSubmit;
+
+  // Restore the view to show the settings described above
+  var use_fuzzy = localStorage.getItem("use_fuzzy_search") != "false";
+  document.getElementById("use-fuzzy").checked = use_fuzzy;
 }
 
 document.addEventListener("DOMContentLoaded", restore_options);

chrome/options.js

@@ -105,30 +105,38 @@ function init(tab) {
 
   activeTab = tab;
   var activeDomain = parseDomainFromUrl(tab.url);
-  searchPassword(activeDomain);
+  searchPassword(activeDomain, "match_domain");
 }
 
-function searchPassword(_domain) {
+function searchPassword(_domain, action="search") {
   searching = true;
   logins = null;
   domain = _domain;
   urlDuringSearch = activeTab.url;
   m.redraw();
 
-  chrome.runtime.sendNativeMessage(
-    app,
-    { action: "search", domain: _domain },
+  // First get the settings needed by the browserpass native client
+  // by requesting them from the background script (which has localStorage access
+  // to the settings). Then construct the message to send to browserpass and
+  // send that via sendNativeMessage.
+  chrome.runtime.sendMessage(
+    { action: "getSettings" },
     function(response) {
-      if (chrome.runtime.lastError) {
-        error = chrome.runtime.lastError.message;
-        console.error(error);
-      }
+      chrome.runtime.sendNativeMessage(
+        app,
+        { action: action, domain: _domain, settings: response},
+        function(response) {
+          if (chrome.runtime.lastError) {
+            error = chrome.runtime.lastError.message;
+            console.error(error);
+          }
 
-      searching = false;
-      logins = response;
-      m.redraw();
-    }
-  );
+          searching = false;
+          logins = response;
+          m.redraw();
+        }
+      );
+    });
 }
 
 function parseDomainFromUrl(url) {

chrome/script.browserify.js

@@ -11,10 +11,12 @@ import (
 	"os/user"
 
 	"github.com/mattn/go-zglob"
+	sfuzzy "github.com/sahilm/fuzzy"
 )
 
 type diskStore struct {
-	path string
+	path     string
+	useFuzzy bool // Setting for FuzzySearch or GlobSearch in manual searches
 }
 
 func NewDefaultStore() (Store, error) {
@@ -23,7 +25,7 @@ func NewDefaultStore() (Store, error) {
 		return nil, err
 	}
 
-	return &diskStore{path}, nil
+	return &diskStore{path, false}, nil
 }
 
 func defaultStorePath() (string, error) {
@@ -42,7 +44,47 @@ func defaultStorePath() (string, error) {
 	return filepath.EvalSymlinks(path)
 }
 
+// Set the configuration options for password matching.
+func (s *diskStore) SetConfig(use_fuzzy *bool) error {
+	if use_fuzzy != nil {
+		s.useFuzzy = *use_fuzzy
+	}
+	return nil
+}
+
+// Do a search. Will call into the correct algoritm (glob or fuzzy)
+// based on the settings present in the diskStore struct
 func (s *diskStore) Search(query string) ([]string, error) {
+	// default glob search
+	if !s.useFuzzy {
+		return s.GlobSearch(query)
+	} else {
+		return s.FuzzySearch(query)
+	}
+}
+
+// Fuzzy searches first get a list of all pass entries by doing a glob search
+// for the empty string, then apply appropriate logic to convert results to
+// a slice of strings, finally returning all of the unique entries.
+func (s *diskStore) FuzzySearch(query string) ([]string, error) {
+	var items []string
+	file_list, err := s.GlobSearch("")
+	if err != nil {
+		return nil, err
+	}
+
+	// The resulting match struct does not copy the strings, but rather
+	// provides the index to the original array. Copy those strings
+	// into the result slice
+	matches := sfuzzy.Find(query, file_list)
+	for _, match := range matches {
+		items = append(items, file_list[match.Index])
+	}
+
+	return items, nil
+}
+
+func (s *diskStore) GlobSearch(query string) ([]string, error) {
 	// Search:
 	// 	1. DOMAIN/USERNAME.gpg
 	//	2. DOMAIN.gpg
@@ -69,7 +111,7 @@ func (s *diskStore) Search(query string) ([]string, error) {
 	if strings.Count(query, ".") >= 2 {
 		// try finding additional items by removing subparts of the query
 		queryParts := strings.SplitN(query, ".", 2)[1:]
-		newItems, err := s.Search(strings.Join(queryParts, "."))
+		newItems, err := s.GlobSearch(strings.Join(queryParts, "."))
 		if err != nil {
 			return nil, err
 		}

pass/disk.go

@@ -24,7 +24,7 @@ func TestDefaultStorePath(t *testing.T) {
 	expected = filepath.Join(home, ".password-store")
 	actual, _ = defaultStorePath()
 	if expected != actual {
-		t.Errorf("%s does not match %s", expected, actual)
+		t.Errorf("1: '%s' does not match '%s'", expected, actual)
 	}
 
 	// custom directory from $PASSWORD_STORE_DIR
@@ -36,9 +36,12 @@ func TestDefaultStorePath(t *testing.T) {
 	fmt.Println(expected)
 	os.Mkdir(expected, os.ModePerm)
 	os.Setenv("PASSWORD_STORE_DIR", expected)
-	actual, _ = defaultStorePath()
+	actual, err = defaultStorePath()
+	if err != nil {
+		t.Error(err)
+	}
 	if expected != actual {
-		t.Errorf("%s does not match %s", expected, actual)
+		t.Errorf("2: '%s' does not match '%s'", expected, actual)
 	}
 
 	// clean-up
@@ -63,7 +66,7 @@ func TestDiskStore_Search_nomatch(t *testing.T) {
 }
 
 func TestDiskStoreSearch(t *testing.T) {
-	store := diskStore{"test_store"}
+	store := diskStore{"test_store", false}
 	targetDomain := "abc.com"
 	testDomains := []string{"abc.com", "test.abc.com", "testing.test.abc.com"}
 	for _, domain := range testDomains {
@@ -86,7 +89,7 @@ func TestDiskStoreSearch(t *testing.T) {
 }
 
 func TestDiskStoreSearchNoDuplicatesWhenPatternMatchesDomainAndUsername(t *testing.T) {
-	store := diskStore{"test_store"}
+	store := diskStore{"test_store", false}
 	searchResult, err := store.Search("xyz")
 	if err != nil {
 		t.Fatal(err)
@@ -101,7 +104,7 @@ func TestDiskStoreSearchNoDuplicatesWhenPatternMatchesDomainAndUsername(t *testi
 }
 
 func TestDiskStoreSearchFollowsSymlinkFiles(t *testing.T) {
-	store := diskStore{"test_store"}
+	store := diskStore{"test_store", false}
 	searchResult, err := store.Search("def.com")
 	if err != nil {
 		t.Fatal(err)
@@ -116,7 +119,7 @@ func TestDiskStoreSearchFollowsSymlinkFiles(t *testing.T) {
 }
 
 func TestDiskStoreSearchFollowsSymlinkDirectories(t *testing.T) {
-	store := diskStore{"test_store"}
+	store := diskStore{"test_store", false}
 	searchResult, err := store.Search("amazon.co.uk")
 	if err != nil {
 		t.Fatal(err)
@@ -131,7 +134,7 @@ func TestDiskStoreSearchFollowsSymlinkDirectories(t *testing.T) {
 }
 
 func TestDiskStoreSearchSubDirectories(t *testing.T) {
-	store := diskStore{"test_store"}
+	store := diskStore{"test_store", false}
 	searchTermsMatches := map[string][]string{
 		"abc.org": []string{"abc.org/user3", "abc.org/wiki/user4", "abc.org/wiki/work/user5"},
 		"wiki":    []string{"abc.org/wiki/user4", "abc.org/wiki/work/user5"},
@@ -155,7 +158,7 @@ func TestDiskStoreSearchSubDirectories(t *testing.T) {
 }
 
 func TestDiskStorePartSearch(t *testing.T) {
-	store := diskStore{"test_store"}
+	store := diskStore{"test_store", false}
 	searchResult, err := store.Search("ab")
 	if err != nil {
 		t.Fatal(err)
@@ -170,3 +173,60 @@ func TestDiskStorePartSearch(t *testing.T) {
 		}
 	}
 }
+
+func TestFuzzySearch(t *testing.T) {
+	store := diskStore{"test_store", true}
+	searchResult, err := store.Search("amaz2")
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(searchResult) != 2 {
+		t.Fatalf("Result size was: %s expected 2", len(searchResult))
+	}
+
+	expectedResult := map[string]bool{
+		"amazon.co.uk/user2": true,
+		"amazon.com/user2":   true,
+	}
+
+	for _, res := range searchResult {
+		if !expectedResult[res] {
+			t.Fatalf("Result %s not expected!", res)
+		}
+	}
+}
+
+func TestFuzzySearchNoResult(t *testing.T) {
+	store := diskStore{"test_store", true}
+	searchResult, err := store.Search("vvv")
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(searchResult) != 0 {
+		t.Fatalf("Result size was: %s expected 0", len(searchResult))
+	}
+}
+
+func TestFuzzySearchTopLevelEntries(t *testing.T) {
+	store := diskStore{"test_store", true}
+	searchResult, err := store.Search("def")
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(searchResult) != 1 {
+		t.Fatalf("Result size was: %s expected 1", len(searchResult))
+	}
+
+	expectedResult := map[string]bool{
+		"def.com": true,
+	}
+
+	for _, res := range searchResult {
+		if !expectedResult[res] {
+			t.Fatalf("Result %s not expected!", res)
+		}
+	}
+}