Merge pull request #3 from wneessen/dev

v0.2.5

.gitignore

@@ -5,10 +5,10 @@
 *.so
 *.dylib
 apg
-bin/
-.go/
-build/
-.idea/
+bin
+.go
+build
+.idea
 
 # Test binary, built with `go test -c`
 *.test

README.md

@@ -1,44 +1,102 @@
-# apg.go
+# Winni's Advanced Password Generator Clone
 _apg.go_ is a simple APG-like password generator script written in Go. It tries to replicate the
 functionality of the
 "[Automated Password Generator](https://web.archive.org/web/20130313042424/http://www.adel.nursat.kz:80/apg)",
 which hasn't been maintained since 2003. Since more and more Unix distributions are abondoning the tool, I was
 looking for an alternative. FreeBSD for example recommends "security/makepasswd", which is written in Perl
-but requires a lot of dependency packages and doesn't offer the feature-set/flexibility of APG. Therefore, as a
-first attempt, I decided to write [my own implementation in Perl](https://github.com/wneessen/passwordGen), but since
-I just started learning Go, I gave it another try and reproduced apg.pl in Go as apg.go. Again, as I never used
-the "pronouncable password" functionality, I left this out in this version.
+but requires a lot of dependency packages and doesn't offer the feature-set/flexibility of APG.
 
-## Usage
-Either use the binary releases, unzip them and simply execute them:
+Therefore, as a first attempt, I decided to write 
+[my own implementation in Perl](https://github.com/wneessen/passwordGen), but since I just started learning Go, 
+I gave it another try and reproduced apg.pl in Go as apg.go.
+
+Since FIPS-181 (pronouncable passwords) has been withdrawn in 2015, I didn't see any use in replicating that
+feature. Therfore apg.go does not support pronouncable passwords.
+
+## Installation
+### Binary releases
+#### Linux/BSD/MacOS
+* Download release
+  ```sh
+  $ curl -LO https://github.com/wneessen/apg.go/releases/download/v<version>/apg-v<version>-<os>-<architecture>.tar.gz
+  $ curl -LO https://github.com/wneessen/apg.go/releases/download/v<version>/apg-v<version>-<os>-<architecture>.tar.gz.sha256
+  ```
+* Verify the checksum
+  ```sh
+  $ sha256 apg-v<version>-<os>-<architecture>.tar.gz 
+  $ cat apg-v<version>-<os>-<architecture>.tar.gz.sha256
+  ```
+  **Make sure the checksum of the downloaded file and the checksum in the .sha256 match**
+* Extract archive
+  ```sh
+  $ tar xzf apg-v<version>-<os>-<architecture>.tar.gz
+  ```
+* Execute
   ```sh
-$ unzip apg_v0.2.0_linux_amd64.zip
-$ chmod +x apg
   $ ./apg
   ```
-Or download the sources and build the binary yourselves:
+#### Windows
+* Download release
+  ```PowerShell
+  PS> Invoke-RestMethod -Uri https://github.com/wneessen/apg.go/releases/download/v<version>/apg-v<version>-windows-<architecture>.zip -OutFile apg-v<version>-windows-<architecure>.zip
+  PS> Invoke-RestMethod -Uri https://github.com/wneessen/apg.go/releases/download/v<version>/apg-v<version>-windows-<architecture>.zip.sha256 -OutFile apg-v<version>-windows-<architecure>.zip.sha256
+  ```
+* Verify the checksum
+  ```PowerShell
+  PS> Get-FileHash apg-v<version>-windows-<architecture>.zip | Format-List
+  PS> type apg-v<version>-windows-<architecture>.zip.sha256
+  ```
+  **Make sure the checksum of the downloaded file and the checksum in the .sha256 match**
+* Extract archive
+  ```PowerShell
+  PS> Expand-Archive -LiteralPath apg-v<version>-windows-<architecture>
+  ```
+* Execute
+  ```PowerShell
+  PS> cd apg-v<version>-windows-<architecture> 
+  PS> apg.exe
+  ```
+
+### Sources
+* Download sources
+  ```sh
+  $ curl -LO https://github.com/wneessen/apg.go/archive/refs/tags/v<version>.tar.gz
+  ```
+* Extract source
+  ```sh
+  $ tar xzf v<version>.tar.gz
+  ```
+* Build binary
+  ```sh
+  $ cd apg.go-<version>
+  $ go build -o apg ./...
+  ```
+* Execute the brand new binary
   ```sh
-$ go build apg.go
   $ ./apg
   ```
 
-## Systemwide installation
-To be a proper APG replacement, i suggest to install it into a directory in your PATH and symlink it to "apg":
+### Systemwide installation
+It is recommed to install apg in a directory of your ```$PATH``` environment. To do so run:
+(In this example we use ```/usr/local/bin``` as system-wide binary path. YMMV)
 ```sh
 $ sudo cp apg /usr/local/bin/apg
 ```
 
-## CLI options
+## CLI parameters
 _apg.go_ replicates some of the parameters of the original APG. Some parameters are different though:
 
-- ```-m, --minpasslen <length>```: The minimum length of the password to be generated
-- ```-x, --maxpasslen <length>```: The maximum length of the password to be generated
-- ```-n, --numofpass <number of passwords>```: The amount of passwords to be generated
-- ```-E, --exclude <list of characters>```: Do not use the specified characters in generated passwords
-- ```-U, --uppercase```: Use uppercase characters in passwords
-- ```-N, --numbers```: Use numeric characters in passwords
-- ```-S, --special```: Use special characters in passwords
-- ```-H, --human```: Avoid ambiguous characters in passwords (i. e.: 1, l, I, o, O, 0)
-- ```-c, --complex```: Generate complex passwords (implies -U -N -S and disables -H)
-- ```-h, --help```: Show a CLI help text
-- ```-v, --version```: Show the version number
+- ```-m <length>```: The minimum length of the password to be generated (Default: 20)
+- ```-x <length>```: The maximum length of the password to be generated (Default: 20)
+- ```-n <number of passwords>```: The amount of passwords to be generated (Default: 1)
+- ```-E <list of characters>```: Do not use the specified characters in generated passwords
+- ```-M <[LUNSHClunshc]>```: New style password parameters (upper-case enables, lower-case disables)
+- ```-L```: Use lower-case characters in passwords (Default: on)
+- ```-U```: Use upper-case characters in passwords (Default: on)
+- ```-N```: Use numeric characters in passwords (Default: on)
+- ```-S```: Use special characters in passwords (Default: off)
+- ```-H```: Avoid ambiguous characters in passwords (i. e.: 1, l, I, o, O, 0) (Default: off)
+- ```-C```: Generate complex passwords (implies -L -U -N -S and disables -H) (Default: off)
+- ```-l```: Spell generated passwords (Default: off)
+- ```-h```: Show a CLI help text
+- ```-v```: Show the version number

apg.go

@@ -8,7 +8,7 @@ import (
 
 // Constants
 const DefaultPwLenght int = 20
-const VersionString string = "0.2.4"
+const VersionString string = "0.2.5"
 const PwLowerCharsHuman string = "abcdefghjkmnpqrstuvwxyz"
 const PwUpperCharsHuman string = "ABCDEFGHJKMNPQRSTUVWXYZ"
 const PwLowerChars string = "abcdefghijklmnopqrstuvwxyz"
@@ -42,8 +42,8 @@ var config cliOpts
 func init() {
 	// Bool flags
 	flag.BoolVar(&config.useLowerCase, "L", true, "Use lower case characters in passwords")
-	flag.BoolVar(&config.useUpperCase, "U", false, "Use upper case characters in passwords")
-	flag.BoolVar(&config.useNumber, "N", false, "Use numbers in passwords")
+	flag.BoolVar(&config.useUpperCase, "U", true, "Use upper case characters in passwords")
+	flag.BoolVar(&config.useNumber, "N", true, "Use numbers in passwords")
 	flag.BoolVar(&config.useSpecial, "S", false, "Use special characters in passwords")
 	flag.BoolVar(&config.useComplex, "C", false, "Generate complex passwords (implies -L -U -N -S, disables -H)")
 	flag.BoolVar(&config.spellPassword, "l", false, "Spell generated password")
@@ -51,7 +51,7 @@ func init() {
 	flag.BoolVar(&config.showVersion, "v", false, "Show version")
 
 	// Int flags
-	flag.IntVar(&config.minPassLen, "m", 10, "Minimum password length")
+	flag.IntVar(&config.minPassLen, "m", DefaultPwLenght, "Minimum password length")
 	flag.IntVar(&config.maxPassLen, "x", DefaultPwLenght, "Maxiumum password length")
 	flag.IntVar(&config.numOfPass, "n", 1, "Number of passwords to generate")
 
@@ -63,6 +63,7 @@ func init() {
 	flag.Parse()
 	if config.showVersion {
 		_, _ = os.Stderr.WriteString("Winni's Advanced Password Generator Clone (apg.go) v" + VersionString + "\n")
+		_, _ = os.Stderr.WriteString("© 2021 by Winni Neessen\n")
 		os.Exit(0)
 	}
 }

apg_test.go

@@ -88,6 +88,10 @@ func TestGetCharRange(t *testing.T) {
 		allowedBytes := []int{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
 			's', 't', 'u', 'v', 'w', 'x', 'y', 'z'}
 		config.useLowerCase = true
+		config.useUpperCase = false
+		config.useNumber = false
+		config.useSpecial = false
+		config.humanReadable = false
 		charRange := getCharRange()
 		for _, curChar := range charRange {
 			searchAllowedBytes := containsByte(allowedBytes, int(curChar))
@@ -102,6 +106,10 @@ func TestGetCharRange(t *testing.T) {
 	t.Run("lower_case_only_human_readable", func(t *testing.T) {
 		allowedBytes := []int{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r',
 			's', 't', 'u', 'v', 'w', 'x', 'y', 'z'}
+		config.useLowerCase = true
+		config.useUpperCase = false
+		config.useNumber = false
+		config.useSpecial = false
 		config.humanReadable = true
 		charRange := getCharRange()
 		for _, curChar := range charRange {
@@ -117,9 +125,11 @@ func TestGetCharRange(t *testing.T) {
 	t.Run("upper_case_only", func(t *testing.T) {
 		allowedBytes := []int{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
 			'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}
-		config.humanReadable = false
 		config.useLowerCase = false
 		config.useUpperCase = true
+		config.useNumber = false
+		config.useSpecial = false
+		config.humanReadable = false
 		charRange := getCharRange()
 		for _, curChar := range charRange {
 			searchAllowedBytes := containsByte(allowedBytes, int(curChar))
@@ -134,6 +144,10 @@ func TestGetCharRange(t *testing.T) {
 	t.Run("upper_case_only_human_readable", func(t *testing.T) {
 		allowedBytes := []int{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'M', 'N', 'P', 'Q',
 			'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}
+		config.useLowerCase = false
+		config.useUpperCase = true
+		config.useNumber = false
+		config.useSpecial = false
 		config.humanReadable = true
 		charRange := getCharRange()
 		for _, curChar := range charRange {
@@ -148,9 +162,11 @@ func TestGetCharRange(t *testing.T) {
 	// Numbers only
 	t.Run("numbers_only", func(t *testing.T) {
 		allowedBytes := []int{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
-		config.humanReadable = false
+		config.useLowerCase = false
 		config.useUpperCase = false
 		config.useNumber = true
+		config.useSpecial = false
+		config.humanReadable = false
 		charRange := getCharRange()
 		for _, curChar := range charRange {
 			searchAllowedBytes := containsByte(allowedBytes, int(curChar))
@@ -164,6 +180,10 @@ func TestGetCharRange(t *testing.T) {
 	// Numbers only (human readable)
 	t.Run("numbers_only_human_readable", func(t *testing.T) {
 		allowedBytes := []int{'2', '3', '4', '5', '6', '7', '8', '9'}
+		config.useLowerCase = false
+		config.useUpperCase = false
+		config.useNumber = true
+		config.useSpecial = false
 		config.humanReadable = true
 		charRange := getCharRange()
 		for _, curChar := range charRange {
@@ -179,9 +199,11 @@ func TestGetCharRange(t *testing.T) {
 	t.Run("special_chars_only", func(t *testing.T) {
 		allowedBytes := []int{'!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', ':',
 			';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_', '`', '{', '|', '}', '~'}
-		config.humanReadable = false
+		config.useLowerCase = false
+		config.useUpperCase = false
 		config.useNumber = false
 		config.useSpecial = true
+		config.humanReadable = false
 		charRange := getCharRange()
 		for _, curChar := range charRange {
 			searchAllowedBytes := containsByte(allowedBytes, int(curChar))
@@ -195,6 +217,10 @@ func TestGetCharRange(t *testing.T) {
 	// Special characters only (human readable)
 	t.Run("special_chars_only_human_readable", func(t *testing.T) {
 		allowedBytes := []int{'"', '#', '%', '*', '+', '-', '/', ':', ';', '=', '\\', '_', '|', '~'}
+		config.useLowerCase = false
+		config.useUpperCase = false
+		config.useNumber = false
+		config.useSpecial = true
 		config.humanReadable = true
 		charRange := getCharRange()
 		for _, curChar := range charRange {

chars.go

@@ -29,7 +29,7 @@ func getCharRange() string {
 		charRange = charRange + pwSpecialChars
 	}
 	if config.excludeChars != "" {
-		regExp := regexp.MustCompile("[" + config.excludeChars + "]")
+		regExp := regexp.MustCompile("[" + regexp.QuoteMeta(config.excludeChars) + "]")
 		charRange = regExp.ReplaceAllLiteralString(charRange, "")
 	}