Implement password generator

Signed-off-by: Tamal Saha <[email protected]>

Author: tamalsaha

.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Go 1.x
+        uses: actions/setup-go@v2
+        with:
+          go-version: ^1.15
+        id: go
+
+      - uses: actions/checkout@v2
+
+      - name: Build
+        run: go build -v ./...
+
+      - name: Test
+        run: go test -v ./...

.gitignore

@@ -12,4 +12,6 @@
 *.out
 
 # Dependency directories (remove the comment below to include it)
-# vendor/
+vendor/
+
+.idea/

README.md

@@ -1,2 +1,6 @@
+[![PkgGoDev](https://pkg.go.dev/badge/gomodules.xyz/password-generator)](https://pkg.go.dev/gomodules.xyz/password-generator)
+
 # password-generator
-Generate Strong Password
+
+Generates strong random password using algorithm described here:
+https://en.wikipedia.org/wiki/Random_password_generator#JavaScript

go.mod

@@ -0,0 +1,3 @@
+module gomodules.xyz/password-generator
+
+go 1.15

password.go

@@ -0,0 +1,91 @@
+package password
+
+import (
+	"crypto/rand"
+	"math/big"
+)
+
+type Charset int
+
+const (
+	Uppercase Charset = 1 << iota // 1 << 0 which is 00000001
+	Lowercase                     // 1 << 1 which is 00000010
+	Numbers                       // 1 << 2 which is 00000100
+	Symbols                       // 1 << 3 which is 00001000
+)
+
+var (
+	uppercase     = []byte(`ABCDEFGHIJKLMNOPQRSTUVWXYZ`)
+	len_uppercase = len(uppercase)
+	lowercase     = []byte(`abcdefghijklmnopqrstuvwxyz`)
+	len_lowercase = len(lowercase)
+	numbers       = []byte(`0123456789`)
+	len_numbers   = len(numbers)
+	symbols       = []byte(`!"#$%&'()*+,-./:;<=>?@^[\]^_{|}~` + "`")
+	len_symbols   = len(symbols)
+)
+
+func Generate(n int) string {
+	return GenerateForCharset(n, Uppercase|Lowercase|Numbers|Symbols)
+}
+
+func GenerateForCharset(n int, chset Charset) string {
+	buf := make([]byte, n)
+
+	count := 0
+	if chset&Uppercase != 0 {
+		count += len_uppercase
+	}
+	if chset&Lowercase != 0 {
+		count += len_lowercase
+	}
+	if chset&Numbers != 0 {
+		count += len_numbers
+	}
+	if chset&Symbols != 0 {
+		count += len_symbols
+	}
+	max := big.NewInt(int64(count))
+
+	for i := 0; i < n; i++ {
+		r, err := rand.Int(rand.Reader, max)
+		if err != nil {
+			panic(err)
+		}
+		idx := int(r.Int64())
+
+		if chset&Uppercase != 0 {
+			if idx < len_uppercase {
+				buf[i] = uppercase[idx]
+				continue
+			} else {
+				idx -= len_uppercase
+			}
+		}
+		if chset&Lowercase != 0 {
+			if idx < len_lowercase {
+				buf[i] = lowercase[idx]
+				continue
+			} else {
+				idx -= len_lowercase
+			}
+		}
+		if chset&Numbers != 0 {
+			if idx < len_numbers {
+				buf[i] = numbers[idx]
+				continue
+			} else {
+				idx -= len_numbers
+			}
+		}
+		if chset&Symbols != 0 {
+			if idx < len_symbols {
+				buf[i] = symbols[idx]
+				continue
+			} else {
+				idx -= len_symbols
+			}
+		}
+	}
+	return string(buf)
+}

password_test.go

@@ -0,0 +1,111 @@
+package password
+
+import "testing"
+
+func TestGenerateForCharset2(t *testing.T) {
+	type args struct {
+		n     int
+		chset Charset
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "Uppercase",
+			args: args{
+				n:     8,
+				chset: Uppercase,
+			},
+		},
+		{
+			name: "Lowercase",
+			args: args{
+				n:     8,
+				chset: Lowercase,
+			},
+		},
+		{
+			name: "Numbers",
+			args: args{
+				n:     8,
+				chset: Numbers,
+			},
+		},
+		{
+			name: "Symbols",
+			args: args{
+				n:     8,
+				chset: Symbols,
+			},
+		},
+		{
+			name: "Uppercase | Lowercase",
+			args: args{
+				n:     8,
+				chset: Uppercase | Lowercase,
+			},
+		},
+		{
+			name: "Uppercase | Lowercase | Numbers",
+			args: args{
+				n:     8,
+				chset: Uppercase | Lowercase | Numbers,
+			},
+		},
+		{
+			name: "Uppercase | Lowercase | Symbols",
+			args: args{
+				n:     8,
+				chset: Uppercase | Lowercase | Symbols,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := GenerateForCharset(tt.args.n, tt.args.chset)
+			if len(got) != tt.args.n {
+				t.Errorf("GenerateForCharset(%v, %v) returned password with length %v", tt.args.n, tt.args.chset, len(got))
+			} else if !uses_charset(got, tt.args.chset) {
+				t.Errorf("GenerateForCharset(%v, %v) uses unexpected charset", tt.args.n, tt.args.chset)
+			}
+		})
+	}
+}
+
+func uses_charset(str string, chset Charset) bool {
+	data := []byte(str)
+	for i := 0; i < len(data); i++ {
+		if chset&Uppercase != 0 {
+			if contains(uppercase, data[i]) {
+				continue
+			}
+		}
+		if chset&Lowercase != 0 {
+			if contains(lowercase, data[i]) {
+				continue
+			}
+		}
+		if chset&Numbers != 0 {
+			if contains(numbers, data[i]) {
+				continue
+			}
+		}
+		if chset&Symbols != 0 {
+			if contains(symbols, data[i]) {
+				continue
+			}
+		}
+		return false
+	}
+	return true
+}
+
+func contains(a []byte, ch byte) bool {
+	for i := 0; i < len(a); i++ {
+		if a[i] == ch {
+			return true
+		}
+	}
+	return false
+}