refactoring and basic usability reached

file.go

@@ -0,0 +1,88 @@
package main
import (
	"bytes"
	"compress/gzip"
	"crypto/md5"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"os"
)
func save(file, passphrase string, sites []Site) error {
	// If the file doesn't exist then create it
	if _, err := os.Stat(file); os.IsNotExist(err) {
		_, err = os.Create(file)
		if err != nil {
			return err
		}
	}
	// Marshal the JSON
	b, err := json.Marshal(sites)
	if err != nil {
		return err
	}
	// Compress the contents
	var buffer bytes.Buffer
	gzip := gzip.NewWriter(&buffer)
	if err != nil {
		return err
	}
	gzip.Write(b)
	gzip.Close()
	// Write to the file
	fi, err := os.OpenFile(file, os.O_WRONLY, 0666)
	if err != nil {
		return err
	}
	_, err = fi.Write(buffer.Bytes())
	if err != nil {
		return err
	}
	fi.Close()
	return nil
}
// Read the password book
func read(file, passphrase string) ([]Site, error) {
	// If the file doesn't exist yet no worries
	if _, err := os.Stat(file); os.IsNotExist(err) {
		return []Site{}, nil
	}
	// Bring in the compressed data
	fi, err := os.Open(file)
	if err != nil {
		return nil, err
	}
	// Decompress the file contents
	gzip, err := gzip.NewReader(fi)
	if err != nil {
		return nil, err
	}
	decompressed, err := ioutil.ReadAll(gzip)
	gzip.Close()
	// Unmarshal the JSON information
	var sites []Site
	err = json.Unmarshal(decompressed, &sites)
	if err != nil {
		return nil, err
	}
	fi.Close()
	return sites, nil
}
// Get the book name
func getBookname(profile string) string {
	hash := md5.New()
	hash.Write([]byte(profile))
	return fmt.Sprintf("%x", string(hash.Sum(nil)))
}

handlers.go

@@ -0,0 +1,260 @@
package main
import (
	"fmt"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"text/template"
)
type Page struct {
	Profile    string
	Passphrase string
	Sites      []Site
}
func GenerateHandler(w http.ResponseWriter, r *http.Request) {
	profile := r.FormValue("profile")
	passphrase := r.FormValue("p")
	host := r.FormValue("host")
	minimumLength, _ := strconv.Atoi(r.FormValue("minimumLength"))
	maximumLength, _ := strconv.Atoi(r.FormValue("maximumLength"))
	minimumDigits, _ := strconv.Atoi(r.FormValue("minimumDigits"))
	minimumUppercase, _ := strconv.Atoi(r.FormValue("minimumUppercase"))
	minimumSpecialCharacters, _ := strconv.Atoi(r.FormValue("minimumSpecialCharacters"))
	specialCharacters := r.FormValue("specialCharacters")
	if profile == "" || passphrase == "" || host == "" {
		http.Error(w, "Missing credentials", http.StatusUnauthorized)
		return
	}
	url, err := url.Parse(host)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	site := Site{
		Host:                      url.Host,
		MinimumLength:             minimumLength,
		MaximumLength:             maximumLength,
		SpecialCharacters:         specialCharacters,
		NumberOfSpecialCharacters: minimumSpecialCharacters,
		NumberOfDigits:            minimumDigits,
		NumberOfUpperCase:         minimumUppercase,
		Revision:                  0,
	}
	book := getBookname(profile)
	sites, err := read(book, passphrase)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	sites = append(sites, site)
	err = save(book, passphrase, sites)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	http.Redirect(w, r, "/book", http.StatusSeeOther)
}
func ProfileHandler(w http.ResponseWriter, r *http.Request) {
	profile := r.FormValue("profile")
	passphrase := r.FormValue("p")
	newPassphrase := r.FormValue("newPassphrase")
	confirmPassphrase := r.FormValue("confirmPassphrase")
	cmd := r.FormValue("cmd")
	if profile == "" || passphrase == "" || newPassphrase == "" || confirmPassphrase == "" || cmd == "" {
		http.Error(w, "Missing credentials", http.StatusUnauthorized)
		return
	}
	book := getBookname(profile)
	if cmd == "delete" {
		err := os.Remove(book)
		if err != nil {
			// Return an error
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	} else if cmd == "update" {
		if newPassphrase != confirmPassphrase {
		}
		sites, err := read(book, passphrase)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		err = save(book, newPassphrase, sites)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
	http.Redirect(w, r, "/book", http.StatusSeeOther)
}
func RefreshHandler(w http.ResponseWriter, r *http.Request) {
	profile := r.FormValue("profile")
	passphrase := r.FormValue("p")
	host := r.FormValue("host")
	if profile == "" || passphrase == "" || host == "" {
		http.Error(w, "Missing credentials", http.StatusUnauthorized)
		return
	}
	// Update the revision number and generate a new password
	book := getBookname(profile)
	sites, err := read(book, passphrase)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	for i, s := range sites {
		if s.Host == host {
			sites[i].Revision++
			break
		}
	}
	err = save(book, passphrase, sites)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	http.Redirect(w, r, "/book", http.StatusSeeOther)
}
func RemoveHandler(w http.ResponseWriter, r *http.Request) {
	profile := r.FormValue("profile")
	passphrase := r.FormValue("p")
	host := r.FormValue("host")
	if profile == "" || passphrase == "" || host == "host" {
		http.Error(w, "Missing credentials", http.StatusUnauthorized)
		return
	}
	// Remove the site from our book and save it
	book := getBookname(profile)
	sites, err := read(book, passphrase)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	for i, site := range sites {
		if site.Host == host {
			sites = append(sites[:i], sites[i+1:]...)
			break
		}
	}
	err = save(book, passphrase, sites)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	http.Redirect(w, r, "/book", http.StatusSeeOther)
}
func SignOffHandler(w http.ResponseWriter, r *http.Request) {
	cookieProfile := &http.Cookie{
		Name:   "profile",
		MaxAge: -1,
	}
	cookiePassphrase := &http.Cookie{
		Name:   "passphrase",
		MaxAge: -1,
	}
	http.SetCookie(w, cookieProfile)
	http.SetCookie(w, cookiePassphrase)
	http.Redirect(w, r, "/", http.StatusSeeOther)
}
func BookHandler(w http.ResponseWriter, r *http.Request) {
	profile := r.FormValue("profile")
	passphrase := r.FormValue("p")
	if profile == "" || passphrase == "" {
		c, err := r.Cookie("profile")
		if err == nil {
			profile = c.Value
		}
		c, err = r.Cookie("passphrase")
		if err == nil {
			passphrase = c.Value
		}
	}
	if profile == "" || passphrase == "" {
		http.Redirect(w, r, "/book", http.StatusSeeOther)
		return
	}
	// Set cookies
	//expire := time.Now().AddDate(0, 0, 1)
	cookieProfile := &http.Cookie{
		Name:  "profile",
		Value: profile,
		//Path:       "/",
		//Domain:     "localhost",
		//Expires:    expire,
		//RawExpires: expire.Format(time.UnixDate),
		//MaxAge:     0,
		//Secure:     false,
		//HttpOnly:   true,
	}
	http.SetCookie(w, cookieProfile)
	cookiePassphrase := &http.Cookie{
		Name:  "passphrase",
		Value: passphrase,
		//Path:       "/",
		//Domain:     "localhost",
		//Expires:    expire,
		//RawExpires: expire.Format(time.UnixDate),
		//MaxAge:     0,
		//Secure:     false,
		//HttpOnly:   true,
	}
	http.SetCookie(w, cookiePassphrase)
	book := getBookname(profile)
	sites, err := read(book, passphrase)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	for i, s := range sites {
		p := s.generatePassphrase(profile, passphrase)
		sites[i].Password = fmt.Sprintf("%s", string(p))
	}
	page := Page{
		Profile:    profile,
		Passphrase: passphrase,
		Sites:      sites,
	}
	t := template.Must(template.New("book").Parse(templateBook))
	err = t.Execute(w, page)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}
func DefaultHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, templateIndex)
}

main.go

@@ -1,440 +1,17 @@
package main
import (
	"bytes"
	"compress/gzip"
	"crypto/md5"
	"crypto/sha512"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"regexp"
	"strconv"
	"strings"
	"text/template"
)
type Site struct {
	Host                      string `json:host`
	MinimumLength             int    `json:minimumLength`
	MaximumLength             int    `json:maximumLength`
	SpecialCharacters         string `json:specialCharacters`
	NumberOfSpecialCharacters int    `json:numberOfSpecialCharacters`
	NumberOfUpperCase         int    `json:numberOfUpperCase`
	NumberOfDigits            int    `json:numberOfDigits`
	Revision                  int    `json:revision`
	Password                  string `json:",omitempty"`
}
type Page struct {
	Profile    string
	Passphrase string
	Sites      []Site
}
func main() {
	http.HandleFunc("/api/generate", func(w http.ResponseWriter, r *http.Request) {
		profile := r.FormValue("profile")
		passphrase := r.FormValue("p")
		host := r.FormValue("host")
		minimumLength, _ := strconv.Atoi(r.FormValue("minimumLength"))
		maximumLength, _ := strconv.Atoi(r.FormValue("maximumLength"))
		minimumDigits, _ := strconv.Atoi(r.FormValue("minimumDigits"))
		minimumUppercase, _ := strconv.Atoi(r.FormValue("minimumUppercase"))
		minimumSpecialCharacters, _ := strconv.Atoi(r.FormValue("minimumSpecialCharacters"))
		specialCharacters := r.FormValue("specialCharacters")
		if profile == "" || passphrase == "" || host == "" {
			http.Error(w, "Missing credentials", http.StatusUnauthorized)
			return
		}
		site := Site{
			Host:                      host,
			MinimumLength:             minimumLength,
			MaximumLength:             maximumLength,
			SpecialCharacters:         specialCharacters,
			NumberOfSpecialCharacters: minimumSpecialCharacters,
			NumberOfDigits:            minimumDigits,
			NumberOfUpperCase:         minimumUppercase,
			Revision:                  0,
		}
		book := getBookname(profile)
		sites, err := read(book, passphrase)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		sites = append(sites, site)
		err = save(book, passphrase, sites)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		http.Redirect(w, r, "/", 200)
	})
	http.HandleFunc("/api/update", func(w http.ResponseWriter, r *http.Request) {
		profile := r.FormValue("profile")
		passphrase := r.FormValue("p")
		newPassphrase := r.FormValue("newPassphrase")
		confirmPassphrase := r.FormValue("confirmPassphrase")
		cmd := r.FormValue("cmd")
		if profile == "" || passphrase == "" || newPassphrase == "" || confirmPassphrase == "" || cmd == "" {
			http.Error(w, "Missing credentials", http.StatusUnauthorized)
			return
		}
		book := getBookname(profile)
		if cmd == "delete" {
			err := os.Remove(book)
			if err != nil {
				// Return an error
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
		} else if cmd == "update" {
			if newPassphrase != confirmPassphrase {
			}
			sites, err := read(book, passphrase)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			err = save(book, newPassphrase, sites)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
		}
		http.Redirect(w, r, "/", 200)
	})
	http.HandleFunc("/api/refresh", func(w http.ResponseWriter, r *http.Request) {
		profile := r.FormValue("profile")
		passphrase := r.FormValue("p")
		host := r.FormValue("host")
		if profile == "" || passphrase == "" || host == "" {
			http.Error(w, "Missing credentials", http.StatusUnauthorized)
			return
		}
		// Update the revision number and generate a new password
		book := getBookname(profile)
		sites, err := read(book, passphrase)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		for _, site := range sites {
			if site.Host == host {
				site.Revision++
				break
			}
		}
		err = save(book, passphrase, sites)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		http.Redirect(w, r, "/", 200)
	})
	http.HandleFunc("/api/remove", func(w http.ResponseWriter, r *http.Request) {
		profile := r.FormValue("profile")
		passphrase := r.FormValue("p")
		host := r.FormValue("host")
		if profile == "" || passphrase == "" || host == "host" {
			http.Error(w, "Missing credentials", http.StatusUnauthorized)
			return
		}
		// Remove the site from our book and save it
		book := getBookname(profile)
		sites, err := read(book, passphrase)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		for i, site := range sites {
			if site.Host == host {
				sites = append(sites[:i], sites[i+1:]...)
				break
			}
		}
		err = save(book, passphrase, sites)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		http.Redirect(w, r, "/", 200)
	})
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		profile := r.FormValue("profile")
		passphrase := r.FormValue("p")
		if profile == "" || passphrase == "" {
			fmt.Fprintf(w, templateIndex)
		} else {
			book := getBookname(profile)
			sites, err := read(book, passphrase)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			for _, s := range sites {
				p, err := generatePassphrase(profile, passphrase, s)
				if err != nil {
				}
				s.Password = fmt.Sprintf("%s", string(p))
			}
			page := Page{
				Profile:    profile,
				Passphrase: passphrase,
				Sites:      sites,
			}
			t := template.Must(template.New("book").Parse(templateBook))
			err = t.Execute(w, page)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
		}
	})
	http.HandleFunc("/api/generate", GenerateHandler)
	http.HandleFunc("/api/update", ProfileHandler)
	http.HandleFunc("/api/refresh", RefreshHandler)
	http.HandleFunc("/api/remove", RemoveHandler)
	http.HandleFunc("/book", BookHandler)
	http.HandleFunc("/", DefaultHandler)
	log.Fatal(http.ListenAndServe("localhost:8080", nil))
}
func save(file, passphrase string, sites []Site) error {
	// If the file doesn't exist then create it
	if _, err := os.Stat(file); os.IsNotExist(err) {
		_, err = os.Create(file)
		if err != nil {
			return err
		}
	}
	// Marshal the JSON
	b, err := json.Marshal(sites)
	if err != nil {
		return err
	}
	// Compress the contents
	var buffer bytes.Buffer
	gzip := gzip.NewWriter(&buffer)
	if err != nil {
		return err
	}
	gzip.Write(b)
	gzip.Close()
	// Write to the file
	fi, err := os.OpenFile(file, os.O_WRONLY, 0666)
	if err != nil {
		return err
	}
	_, err = fi.Write(buffer.Bytes())
	if err != nil {
		return err
	}
	fi.Close()
	return nil
}
// Read the password book
func read(file, passphrase string) ([]Site, error) {
	// If the file doesn't exist yet no worries
	if _, err := os.Stat(file); os.IsNotExist(err) {
		return []Site{}, nil
	}
	// Bring in the compressed data
	fi, err := os.Open(file)
	if err != nil {
		return nil, err
	}
	// Decompress the file contents
	gzip, err := gzip.NewReader(fi)
	if err != nil {
		return nil, err
	}
	decompressed, err := ioutil.ReadAll(gzip)
	gzip.Close()
	// Unmarshal the JSON information
	var sites []Site
	err = json.Unmarshal(decompressed, &sites)
	if err != nil {
		return nil, err
	}
	fi.Close()
	return sites, nil
}
// Get the book name
func getBookname(profile string) string {
	hash := md5.New()
	hash.Write([]byte(profile))
	return fmt.Sprintf("%x", string(hash.Sum(nil)))
}
// Encrypt the password book
func encrypt(clearText, profile, passphrase string) ([]byte, error) {
	return nil, nil
}
// Decrypt the password book
func decrypt(encryptedText, profile, passphrase string) ([]byte, error) {
	return nil, nil
}
// Generate the passphrase
func generatePassphrase(profile, passphrase string, settings Site) ([]byte, error) {
	clearText := fmt.Sprintf(
		"%s-%s-%s-%s",
		strings.ToLower(profile),
		strings.ToLower(passphrase),
		strings.ToLower(settings.Host),
		settings.Revision)
	sha := sha512.New()
	sha.Write([]byte(clearText))
	hash := sha.Sum(nil)
	hash = []byte(fmt.Sprintf("%x", hash))
	// Apply site criteria
	applySiteSettings(hash, settings)
	// If there is a maximum length truncate the hash
	if settings.MaximumLength > -1 {
		hash = hash[:settings.MaximumLength]
	}
	// Ensure the length is adequate
	if !validateLength(hash, settings.MinimumLength, settings.MaximumLength) {
		log.Println("Does not meed the length requirements")
	}
	return hash, nil
}
// Apply site settings to the hashed value
func applySiteSettings(source []byte, settings Site) []byte {
	if !containsUppercase(source, settings.NumberOfUpperCase) {
		i := 0
		r := regexp.MustCompile(`[a-z]+`)
		var matches [][]int
		if matches = r.FindAllIndex(source, -1); matches != nil {
			for _, v := range matches {
				if i < settings.NumberOfUpperCase {
					c := strings.ToUpper(string(source[v[0]]))
					source[v[0]] = []byte(c)[0]
					i += 1
				}
			}
		}
	}
	if !containsDigits(source, settings.NumberOfDigits) {
		i := 0
		r := regexp.MustCompile(`[a-z]+`)
		var matches [][]int
		if matches = r.FindAllIndex(source, -1); matches != nil {
			for _, v := range matches {
				if i < settings.NumberOfDigits {
					source[v[0]] = byte(i)
					i += 1
				}
			}
		}
	}
	if !containsSpecialCharacters(source, settings.SpecialCharacters, settings.NumberOfSpecialCharacters) {
		i := 0
		r := regexp.MustCompile(`[a-z]+`)
		var matches [][]int
		if matches = r.FindAllIndex(source, -1); matches != nil {
			for _, v := range matches {
				if i < settings.NumberOfSpecialCharacters {
					i += 1
					source[v[0]] = []byte(settings.SpecialCharacters)[len(settings.SpecialCharacters)-i]
				}
			}
		}
	}
	return source
}
// Determine if the hash currently contains the appropriate amount of digits
func containsDigits(source []byte, minOccurrences int) bool {
	r := regexp.MustCompile(`\d`)
	var matches [][]byte
	if matches = r.FindAll(source, -1); matches == nil {
		return false
	}
	return len(matches) >= minOccurrences
}
// Determine if the hash currently contains the appropriate amount of uppercase characters
func containsUppercase(source []byte, minOccurrences int) bool {
	r := regexp.MustCompile(`[A-Z]+`)
	var matches [][]byte
	if matches = r.FindAll(source, -1); matches == nil {
		return false
	}
	return len(matches) >= minOccurrences
}
// Determine if the hash currently contains the appropriate amount of special characters from the allowed
// character set
func containsSpecialCharacters(source []byte, specialCharacters string, minOccurrences int) bool {
	s := specialCharacters
	s = strings.Replace(s, "\\", "\\\\", -1)
	s = strings.Replace(s, ".", "\\.", -1)
	s = strings.Replace(s, " ", "\\s", -1)
	s = strings.Replace(s, "-", "\\-", -1)
	s = strings.Replace(s, "[", "\\[", -1)
	s = strings.Replace(s, "]", "\\]", -1)
	r := regexp.MustCompile(`[` + s + `]+`)
	var matches [][]byte
	if matches = r.FindAll(source, -1); matches == nil {
		return false
	}
	return len(matches) >= minOccurrences
}
// Determine if the hash currently abides by the length restrictions
func validateLength(source []byte, minimum, maximum int) bool {
	if minimum > -1 && len(source) < minimum {
		return false
	}
	if maximum > -1 && len(source) > maximum {
		return false
	}
	return true
}

resources.go

@@ -64,17 +64,12 @@ const (
</head>
<body>
    <div class="container">
        <form action="/" method="post" class="form-signin">
        <form action="/book" method="post" class="form-signin">
            <h2 class="form-signin-heading">Please sign in</h2>
            <label for="profile" class="sr-only">Email address</label>
            <input type="text" id="profile" name="profile" class="form-control" placeholder="Username" required autofocus>
            <label for="p" class="sr-only">Password</label>
            <input type="password" id="p" name="p" class="form-control" placeholder="Password" required>
            <div class="checkbox">
                <label>
                    <input type="checkbox" value="remember-me"> Remember me
                </label>
            </div>
            <button class="btn btn-lg btn-primary btn-block" type="submit">Sign in</button>
        </form>
    </div>
@@ -191,7 +186,7 @@ const (
                                    <option>3</option>
                                    <option>4</option>
                                    <option>5</option>
                                    <option>6</option>
                                    <option selected="selected">6</option>
                                    <option>7</option>
                                    <option>8</option>
                                    <option>9</option>
@@ -212,7 +207,7 @@ const (
                                    <option>9</option>
                                    <option>10</option>
                                    <option>11</option>
                                    <option>12</option>
                                    <option selected="selected">12</option>
                                    <option>13</option>
                                    <option>14</option>
                                    <option>15</option>
@@ -231,7 +226,7 @@ const (
                                    <option>0</option>
                                    <option>1</option>
                                    <option>2</option>
                                    <option>3</option>
                                    <option selected="selected">3</option>
                                    <option>4</option>
                                    <option>5</option>
                                    <option>6</option>
@@ -248,7 +243,7 @@ const (
                                <select id="minimumUppercase" name="minimumUppercase" class="form-control">
                                    <option>0</option>
                                    <option>1</option>
                                    <option>2</option>
                                    <option selected="selected">2</option>
                                    <option>3</option>
                                    <option>4</option>
                                    <option>5</option>
@@ -266,7 +261,7 @@ const (
                                <select id="minimumSpecialCharacters" name="minimumSpecialCharacters" class="form-control">
                                    <option>0</option>
                                    <option>1</option>
                                    <option>2</option>
                                    <option selected="selected">2</option>
                                    <option>3</option>
                                    <option>4</option>
                                    <option>5</option>
@@ -281,7 +276,7 @@ const (
                        <div class="form-group">
                            <label for="specialCharacters" class="col-xs-3 control-label">Special Characters</label>
                            <div class="col-xs-9">
                                <input id="specialCharacters" name="specialCharacters" type="text" class="form-control" value=" !@#$%^&*()_+-=<>,." />
                                <input id="specialCharacters" name="specialCharacters" type="text" class="form-control" value=" !@#$%^&*_+-=,." />
                            </div>
                        </div>
                        <div class="form-group">

security.go

@@ -0,0 +1,11 @@
package main
// Encrypt the password book
func encrypt(clearText, profile, passphrase string) ([]byte, error) {
	return nil, nil
}
// Decrypt the password book
func decrypt(encryptedText, profile, passphrase string) ([]byte, error) {
	return nil, nil
}

site.go

@@ -0,0 +1,156 @@
package main
import (
	"crypto/sha512"
	"fmt"
	"log"
	"regexp"
	"strings"
)
type Site struct {
	Host                      string `json:host`
	MinimumLength             int    `json:minimumLength`
	MaximumLength             int    `json:maximumLength`
	SpecialCharacters         string `json:specialCharacters`
	NumberOfSpecialCharacters int    `json:numberOfSpecialCharacters`
	NumberOfUpperCase         int    `json:numberOfUpperCase`
	NumberOfDigits            int    `json:numberOfDigits`
	Revision                  int    `json:revision`
	Password                  string `json:",omitempty"`
}
// Generate the passphrase
func (s *Site) generatePassphrase(profile, passphrase string) []byte {
	clearText := fmt.Sprintf(
		"%s-%s-%s-%s",
		strings.ToLower(profile),
		strings.ToLower(passphrase),
		strings.ToLower(s.Host),
		s.Revision)
	sha := sha512.New()
	sha.Write([]byte(clearText))
	return s.applyCriteria(sha.Sum(nil))
}
func (s *Site) applyCriteria(sha []byte) []byte {
	hash := []byte(fmt.Sprintf("%x", sha))
	if !containsUppercase(hash, s.NumberOfUpperCase) {
		i := 0
		r := regexp.MustCompile(`[a-z]+`)
		var matches [][]int
		if matches = r.FindAllIndex(hash, -1); matches != nil {
			for _, v := range matches {
				if i < s.NumberOfUpperCase {
					c := strings.ToUpper(string(hash[v[0]]))
					hash[v[0]] = []byte(c)[0]
					i += 1
				}
			}
		}
	}
	if !containsDigits(hash, s.NumberOfDigits) {
		i := 0
		r := regexp.MustCompile(`[a-z]+`)
		var matches [][]int
		if matches = r.FindAllIndex(hash, -1); matches != nil {
			for _, v := range matches {
				if i < s.NumberOfDigits {
					hash[v[0]] = byte(i)
					i += 1
				}
			}
		}
	}
	if !containsSpecialCharacters(hash, s.SpecialCharacters, s.NumberOfSpecialCharacters) {
		i := 0
		r := regexp.MustCompile(`[a-z]+`)
		var matches [][]int
		if matches = r.FindAllIndex(hash, -1); matches != nil {
			for _, v := range matches {
				if i < s.NumberOfSpecialCharacters {
					i += 1
					hash[v[0]] = []byte(s.SpecialCharacters)[len(s.SpecialCharacters)-i]
				}
			}
		}
	}
	// If there is a maximum length truncate the hash
	if s.MaximumLength > -1 {
		hash = hash[:s.MaximumLength]
	}
	// Ensure the length is adequate
	if !validateLength(hash, s.MinimumLength, s.MaximumLength) {
		log.Println("Does not meed the length requirements")
	}
	return hash
}
// Determine if the hash currently contains the appropriate amount of digits
func containsDigits(source []byte, minOccurrences int) bool {
	r := regexp.MustCompile(`\d`)
	var matches [][]byte
	if matches = r.FindAll(source, -1); matches == nil {
		return false
	}
	return len(matches) >= minOccurrences
}
// Determine if the hash currently contains the appropriate amount of uppercase characters
func containsUppercase(source []byte, minOccurrences int) bool {
	r := regexp.MustCompile(`[A-Z]+`)
	var matches [][]byte
	if matches = r.FindAll(source, -1); matches == nil {
		return false
	}
	return len(matches) >= minOccurrences
}
// Determine if the hash currently contains the appropriate amount of special characters from the allowed
// character set
func containsSpecialCharacters(source []byte, specialCharacters string, minOccurrences int) bool {
	s := specialCharacters
	s = strings.Replace(s, "\\", "\\\\", -1)
	s = strings.Replace(s, ".", "\\.", -1)
	s = strings.Replace(s, " ", "\\s", -1)
	s = strings.Replace(s, "-", "\\-", -1)
	s = strings.Replace(s, "[", "\\[", -1)
	s = strings.Replace(s, "]", "\\]", -1)
	r := regexp.MustCompile(`[` + s + `]+`)
	var matches [][]byte
	if matches = r.FindAll(source, -1); matches == nil {
		return false
	}
	return len(matches) >= minOccurrences
}
// Determine if the hash currently abides by the length restrictions
func validateLength(source []byte, minimum, maximum int) bool {
	if minimum > -1 && len(source) < minimum {
		return false
	}
	if maximum > -1 && len(source) > maximum {
		return false
	}
	return true
}