Merge branch 'feature/improvements' into develop

Author: axllent

.github/dependabot.yml

@@ -8,8 +8,8 @@ updates:
   - package-ecosystem: "gomod"
     directory: "/" # Location of package manifests
     schedule:
-      interval: "monthly"
+      interval: "semiannually"
   - package-ecosystem: "github-actions"
     directory: "/" # Location of package manifests
     schedule:
-      interval: "monthly"
+      interval: "semiannually"

README.md

@@ -6,7 +6,6 @@ A command-line vanity (public) key generator for [WireGuard](https://www.wiregua
 and not whether the search matches anywhere in the public key. The concept is based on
 [wireguard-vanity-address](https://github.com/warner/wireguard-vanity-address), however I wanted something a little more streamlined.
 
-
 ## Features
 
 - Generates compliant [curve25519](https://cr.yp.to/ecdh.html) private and public keys
@@ -17,7 +16,6 @@ and not whether the search matches anywhere in the public key. The concept is ba
 - Exit after results limit reached (defaults to 1)
 - Displays probability and estimated runtime based on quick benchmark
 
-
 ## Usage options
 
 ```
@@ -29,7 +27,6 @@ Options:
   -l, --limit int        limit results to n (exists after) (default 1)
 ```
 
-
 ## Example
 
 ```
@@ -42,28 +39,27 @@ Cannot calculate probability for the regular expression "^pc7[/+]"
 
 Press Ctrl-c to cancel
 
-private OFVUjUoTNQp94fNPB9GCLzxiJPTbN03rcDPrVd12uFc=   public tEstMXL/3ZzAd2TnVlr1BNs/+eOnKzSHpGUnjspk3kc=
-private gInIEDmENYbyuaWR1W/KLfximExwbcCg45W2WOmEc0I=   public TestKmA/XVagDW/JsHBXk5mhYJ6E1N1lAWeIeCttgRs=
-private yDQLNiQlfnMGhUBsbLQjoBbuNezyHug31Qa1Ht6cgkw=   public PC1/3oUId241TLYImJLUObR8NNxz4HXzG4z+EazfWxY=
-private QIbJgxy83+F/1kdogcF+T04trs+1N9gAr1t5th2tLXM=   public Pc7+h172sx0TfIMikjgszM/B8i8/ghi7qJVOwWQtx0w=
-private +CUqn4jcKoL8pw53pD4IzfMKW/IMceDWKcM2W5Dxtn4=   public teStmGXZwiJl9HmfnTSmk83girtiIH8oZEa6PFJ8F1Y=
-private EMaUfQvAEABpQV/21ALJP5YtyGerRXAn8u67j2AQzVs=   public pC1/t2x5V99Y1SBqNgPZDPsa6r+L5y3BJ4XUCJMar3g=
-private wNuHOKCfoH1emfvijXNBoc/7KjrEXUeof7tSdGWvRFo=   public PC1/jXQosaBad2HePOm/w1KjCZ82eT3qNbfzNDZiwTs=
-private gJtn0woDChGvyN2eSdc7mTpAFA/nA6jykJeK5bYYfFA=   public Pc7+UEJSHiWsQ9zkO2q+guqDK4sc3VMDMgJu+h/bOFI=
-private IMyPmYm/v0SPmB62hC8l6kfxT3/Lfp7dMioo+SM6T2c=   public Pc7/uVfD/ZftxWBHwYbaudEywUS61biBcpj5Tw830Q4=
+private: OFVUjUoTNQp94fNPB9GCLzxiJPTbN03rcDPrVd12uFc=   public: tEstMXL/3ZzAd2TnVlr1BNs/+eOnKzSHpGUnjspk3kc=
+private: gInIEDmENYbyuaWR1W/KLfximExwbcCg45W2WOmEc0I=   public: TestKmA/XVagDW/JsHBXk5mhYJ6E1N1lAWeIeCttgRs=
+private: yDQLNiQlfnMGhUBsbLQjoBbuNezyHug31Qa1Ht6cgkw=   public: PC1/3oUId241TLYImJLUObR8NNxz4HXzG4z+EazfWxY=
+private: QIbJgxy83+F/1kdogcF+T04trs+1N9gAr1t5th2tLXM=   public: Pc7+h172sx0TfIMikjgszM/B8i8/ghi7qJVOwWQtx0w=
+private: +CUqn4jcKoL8pw53pD4IzfMKW/IMceDWKcM2W5Dxtn4=   public: teStmGXZwiJl9HmfnTSmk83girtiIH8oZEa6PFJ8F1Y=
+private: EMaUfQvAEABpQV/21ALJP5YtyGerRXAn8u67j2AQzVs=   public: pC1/t2x5V99Y1SBqNgPZDPsa6r+L5y3BJ4XUCJMar3g=
+private: wNuHOKCfoH1emfvijXNBoc/7KjrEXUeof7tSdGWvRFo=   public: PC1/jXQosaBad2HePOm/w1KjCZ82eT3qNbfzNDZiwTs=
+private: gJtn0woDChGvyN2eSdc7mTpAFA/nA6jykJeK5bYYfFA=   public: Pc7+UEJSHiWsQ9zkO2q+guqDK4sc3VMDMgJu+h/bOFI=
+private: IMyPmYm/v0SPmB62hC8l6kfxT3/Lfp7dMioo+SM6T2c=   public: Pc7/uVfD/ZftxWBHwYbaudEywUS61biBcpj5Tw830Q4=
 ```
 
-
 ## Installing
 
 Download the [latest binary release](https://github.com/axllent/wireguard-vanity-keygen/releases/latest) for your system,
 or build from source `go install github.com/axllent/wireguard-vanity-keygen@latest`.
 
-
 ## Timings
 
 To give you a rough idea of how long it will take to generate keys, the following table lists
-estimated timings to find a matching key on a system that reported  "`Calculating speed: 230,000 calculations per second using 19 CPU cores`" when it started:
+estimated timings to find a matching key on a system that reported
+"`Calculating speed: 230,000 calculations per second using 19 CPU cores`" when it started:
 
 | Length  | Case-insensitive | Case-sensitive |
 | :------ | :--------------- | :------------- |
@@ -84,7 +80,6 @@ If any search term contains numbers, the timings would fall somewhere between th
 
 Of course, your mileage will differ, depending on the number, and speed, of your CPU cores.
 
-
 ## Regular Expressions
 
 Since each additional letter in a search term increases the search time exponentially, searching using a regular expression may
@@ -105,8 +100,7 @@ On Windows, you must use double quotes. For example: `"^(a|b)"`.
 
 NOTE: Complex regular expressions, such as those using escape sequences, flags, or character classes, may never match a key.
 To avoid that, consider testing your regex using a tool such as [this one](https://go.dev/play/p/6LJy51Wd08O) on The Go Playground,
- or the same tool on [goplay.tools](https://goplay.tools/snippet/6LJy51Wd08O).
-
+or the same tool on [goplay.tools](https://goplay.tools/snippet/6LJy51Wd08O).
 
 ## FAQ
 
@@ -116,19 +110,16 @@ Valid characters include `A-Z`, `a-z`, `0-9`, `/` and `+`. There are no other ch
 
 You can also use regex expressions to search.
 
-
 ### Why does `test` & `tes1` show different probabilities despite having 4 characters each?
 
 With case-insensitive searches (default), a-z have the chance of matching both uppercase and lowercase. A search for "cat" can match `Cat`, `cAT` etc.
 
-
 ### How accurate are the estimated times?
 
 They are not (and cannot be) accurate. Keys are completely randomly generated, and the estimate is based on a law of averages.
 For instance, you could find a match for a one in a billion chance on the very first hit, or it could take you 5 billion attempts.
 It will however give you an indication based on your CPU speed, word count, case sensitivity, and use of numbers or characters.
 
-
 ### Why do I need this?
 
 You don't. I wrote it because I run a WireGuard server, which does not provide any reference as to who the key belongs to (`wg` on the server).

go.mod

@@ -3,6 +3,8 @@ module github.com/axllent/wireguard-vanity-keygen
 go 1.24.0
 
 require (
+	github.com/oasisprotocol/curve25519-voi v0.0.0-20251114093237-2ab5a27a1729
 	github.com/spf13/pflag v1.0.10
-	golang.org/x/crypto v0.46.0
 )
+
+require golang.org/x/sys v0.40.0 // indirect

go.sum

@@ -1,4 +1,6 @@
+github.com/oasisprotocol/curve25519-voi v0.0.0-20251114093237-2ab5a27a1729 h1:yfQ2sO9WJXUAIUR+g7NUkxJSKCAFJcR5sUDu+ZmjTZI=
+github.com/oasisprotocol/curve25519-voi v0.0.0-20251114093237-2ab5a27a1729/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s=
 github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
 github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU=
-golang.org/x/crypto v0.46.0/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0=
+golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=

keygen/crypto.go

@@ -5,7 +5,8 @@ import (
 	"crypto/rand"
 	"encoding/base64"
 
-	"golang.org/x/crypto/curve25519"
+	curve25519voi "github.com/oasisprotocol/curve25519-voi/curve"
+	scalar "github.com/oasisprotocol/curve25519-voi/curve/scalar"
 )
 
 // KeySize defines the size of the key
@@ -19,33 +20,29 @@ type Key [KeySize]byte
 // It is used by WireGuard to represent private keys.
 type PrivateKey [KeySize]byte
 
-// NewPrivateKey generates a new curve25519 secret key.
-// It conforms to the format described on https://cr.yp.to/ecdh.html.
+// NewPrivateKey generates a new curve25519 secret key (clamped).
 func newPrivateKey() (PrivateKey, error) {
-	k, err := newPreSharedKey()
+	var priv [KeySize]byte
+	_, err := rand.Read(priv[:])
 	if err != nil {
 		return PrivateKey{}, err
 	}
-	k[0] &= 248
-	k[31] = (k[31] & 127) | 64
-	return (PrivateKey)(*k), nil
+	// Clamp as per RFC 7748
+	priv[0] &= 248
+	priv[31] = (priv[31] & 127) | 64
+	return PrivateKey(priv), nil
 }
 
-// NewPreSharedKey generates a new key
-func newPreSharedKey() (*Key, error) {
-	var k [KeySize]byte
-	_, err := rand.Read(k[:])
-	if err != nil {
-		return nil, err
-	}
-	return (*Key)(&k), nil
-}
-
-// Public computes the public key matching this curve25519 secret key.
+// Public computes the public key matching this curve25519 secret key using curve25519-voi.
 func (k *PrivateKey) Public() Key {
-	var p [KeySize]byte
-	curve25519.ScalarBaseMult(&p, (*[KeySize]byte)(k))
-	return (Key)(p)
+	var pub curve25519voi.MontgomeryPoint
+	base := *curve25519voi.X25519_BASEPOINT
+	s, err := scalar.NewFromBytesModOrder(k[:])
+	if err != nil || s == nil {
+		panic("invalid private key for scalar.NewFromBytesModOrder: " + err.Error())
+	}
+	pub.Mul(&base, s)
+	return Key(pub)
 }
 
 // String returns a private key as a string

keygen/utils.go

@@ -9,7 +9,7 @@ import (
 	"time"
 )
 
-// regexChars contains the list of the metacharacters used in regular expressions,
+// regexChars contains the list of the meta characters used in regular expressions,
 // but not including the + character, which is valid in a key
 const regexChars = `^$.|?*-[]{}()\`
 
@@ -31,7 +31,7 @@ func InvalidSearchMsg(s string) string {
 func HumanizeDuration(duration time.Duration) string {
 	// more than duration can handle
 	if duration.Hours() < 0.0 {
-		return fmt.Sprintf("hundreds of years")
+		return "hundreds of years"
 	}
 	if duration.Hours() > 8760.0 {
 		y := int64(duration.Hours() / 8760)
@@ -101,22 +101,22 @@ func NumberFormat(n int64) string {
 	}
 }
 
-// IsRegex returns true if any regex metacharacters (except +) are in the search term
+// IsRegex returns true if any regex meta characters (except +) are in the search term
 func IsRegex(s string) bool {
 	return strings.ContainsAny(s, regexChars)
 }
 
 // invalidRegexMsg returns an error message how the regex is invalid
-func invalidRegexMsg(s string, errmsg string) string {
-	return fmt.Sprintf("\n\"%s\" is an invalid regular expression\n%s", s, errmsg)
+func invalidRegexMsg(s string, errMsg string) string {
+	return fmt.Sprintf("\n\"%s\" is an invalid regular expression\n%s", s, errMsg)
 }
 
 // IsValidRegex checks the regex has any chance of matching a key
 func IsValidRegex(s string) string {
 	// A concise guide on golang's regex syntax is at
 	// https://pkg.go.dev/regexp/syntax
 
-	stripped := removeMetacharacters(s)
+	stripped := removeMetaCharacters(s)
 	if !IsValidSearch(stripped) {
 		return InvalidSearchMsg(s)
 	}
@@ -188,8 +188,8 @@ func IsValidRegex(s string) string {
 	return ""
 }
 
-// removeMetacharacters removes regex metacharacters (except +) from the string
-func removeMetacharacters(s string) string {
+// RemoveMetaCharacters removes regex meta characters (except +) from the string
+func removeMetaCharacters(s string) string {
 	// This logic isn't needed anymore, as we don't attempt to calculate the probability of regular expressions
 	// // remove (?i) from beginning of string
 	// re := regexp.MustCompile(`^\([^)]*\)`)
@@ -204,7 +204,7 @@ func removeMetacharacters(s string) string {
 	// re = regexp.MustCompile(`=`)
 	// s = re.ReplaceAllLiteralString(s, "x")
 
-	// strip out remaining regexp metacharacters
+	// strip out remaining regexp meta characters
 	for _, rune1 := range regexChars {
 		s = strings.ReplaceAll(s, string(rune1), "")
 	}

keygen/worker.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"regexp"
 	"strings"
-	"sync"
+	"sync/atomic"
 	"time"
 )
 
@@ -17,16 +17,32 @@ type Options struct {
 	Timeout       string
 }
 
+// Cruncher struct
+
+// AtomicCounter struct
+type AtomicCounter struct {
+	Value int64
+}
+
+// Dec decrements the counter and returns the new value
+func (a *AtomicCounter) Dec() int64 {
+	return atomic.AddInt64(&a.Value, -1)
+}
+
+// Get returns the current value of the counter
+func (a *AtomicCounter) Get() int64 {
+	return atomic.LoadInt64(&a.Value)
+}
+
 // Cruncher struct
 type Cruncher struct {
 	Options
-	WordMap   map[string]int
-	mapMutex  sync.RWMutex
-	RegexpMap map[*regexp.Regexp]int
+	WordMap   map[string]*AtomicCounter
+	RegexpMap map[*regexp.Regexp]*AtomicCounter
 	thread    chan int
 	Abort     bool // set to true to abort processing
 	timeout   time.Duration
-	timedout  bool
+	timedOut  bool
 }
 
 // Pair struct
@@ -39,8 +55,8 @@ type Pair struct {
 func New(options Options, timeout time.Duration) *Cruncher {
 	return &Cruncher{
 		Options:   options,
-		WordMap:   make(map[string]int),
-		RegexpMap: make(map[*regexp.Regexp]int),
+		WordMap:   make(map[string]*AtomicCounter),
+		RegexpMap: make(map[*regexp.Regexp]*AtomicCounter),
 		thread:    make(chan int, options.Cores),
 		timeout:   timeout,
 	}
@@ -60,33 +76,29 @@ func (c *Cruncher) crunch(cb func(match Pair)) bool {
 		matchKey = strings.ToLower(pub)
 	}
 
-	// Assume the task is completed, once all searched have been found
-	// and limits have been reached, it sends an exit signal
 	completed := true
 
-	// Allow only one routine at a time to avoid
-	// "concurrent map iteration and map write"
-	c.mapMutex.Lock()
-	defer c.mapMutex.Unlock()
-	for w, count := range c.WordMap {
-		if count == 0 {
+	for w, counter := range c.WordMap {
+		if counter.Get() <= 0 {
 			continue
 		}
 		completed = false
 		if strings.HasPrefix(matchKey, w) {
-			c.WordMap[w] = count - 1
-			cb(Pair{Private: k.String(), Public: pub})
+			if counter.Dec() >= 0 {
+				cb(Pair{Private: k.String(), Public: pub})
+			}
 		}
 	}
 
-	for w, count := range c.RegexpMap {
-		if count == 0 {
+	for w, counter := range c.RegexpMap {
+		if counter.Get() <= 0 {
 			continue
 		}
 		completed = false
 		if w.MatchString(matchKey) {
-			c.RegexpMap[w] = count - 1
-			cb(Pair{Private: k.String(), Public: pub})
+			if counter.Dec() >= 0 {
+				cb(Pair{Private: k.String(), Public: pub})
+			}
 		}
 	}
 
@@ -121,8 +133,6 @@ func (c *Cruncher) CalculateSpeed() (int64, time.Duration) {
 
 			// Allow only one routine at a time to avoid
 			// "concurrent map iteration and map write"
-			c.mapMutex.Lock()
-			defer c.mapMutex.Unlock()
 			for w := range c.WordMap {
 				_ = strings.HasPrefix(t, w)
 			}
@@ -209,13 +219,13 @@ func (c *Cruncher) Find(cb func(match Pair)) {
 			}
 			select {
 			case <-t.C:
-				c.timedout = true
+				c.timedOut = true
 				c.Abort = true
 			default:
 			}
 		}(t)
 		if c.Abort {
-			if c.timedout {
+			if c.timedOut {
 				fmt.Printf("Timed out after %v\n", c.timeout)
 			} else {
 				if !t.Stop() {