added account creation, skeleton directories, and a tad of refactoring

README.md

@@ -4,7 +4,7 @@ loop
Basic Structure
===============
./users
./loop_users
-------
User name and hashed password security. Not the best but definitely simple.
@@ -40,5 +40,5 @@ Environment Variables
    - LOOP_URL      (Default: localhost:6006)
    - LOOP_SALT     (Default: whatyoutalkingaboutwillus)
    - LOOP_BASE     (Default: .)
    - LOOP_DATA     (Default: .)

account.go

@@ -0,0 +1,186 @@
package main
import (
	"encoding/json"
	"errors"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"strings"
	"time"
)
func getAccounts() ([]Account, error) {
	file := UserFile
	// Check to see if the file exists
	if _, err := os.Stat(file); os.IsNotExist(err) {
		return []Account{}, nil
	}
	// Open the file
	fi, err := os.Open(file)
	if err != nil {
		return nil, err
	}
	// Read all of its contents
	raw, err := ioutil.ReadAll(fi)
	if len(raw) == 0 {
		return []Account{}, nil
	}
	// Translate the JSON to internal structures
	var accounts []Account
	err = json.Unmarshal(raw, &accounts)
	if err != nil {
		return nil, err
	}
	fi.Close()
	return accounts, nil
}
func (a *Account) Validate() (bool, error) {
	file := UserFile
	// Determine if the "users" file exists
	// Attempt to create the file if it does not
	if _, err := os.Stat(file); os.IsNotExist(err) {
		_, err = os.Create(file)
		if err != nil {
			return false, err
		}
	}
	// Get a list of current accounts
	accounts, err := getAccounts()
	if err != nil {
		return false, err
	}
	// Search if an account and passphrase match is found
	for _, x := range accounts {
		if x.Username == a.Username && x.Passphrase == a.Passphrase {
			return true, nil
		}
	}
	return false, nil
}
func (a *Account) Create() error {
	// Ensure there are no accounts of that name already
	valid, err := a.Validate()
	if err != nil {
		return err
	}
	if valid {
		return errors.New("Account already exists")
	}
	// Create directory structure
	baseDir := os.Getenv("LOOP_DATA")
	userDir := strings.ToLower(a.Username)
	s := string(filepath.Separator)
	paths := []string{"content", "blog", "calendar"}
	for _, p := range paths {
		err = os.MkdirAll(baseDir+s+userDir+s+p, 0755)
		if err != nil {
			return err
		}
	}
	// Add the account to all of the accounts
	accounts, err := getAccounts()
	if err != nil {
		return err
	}
	accounts = append(accounts, *a)
	// Create user entry in "users" file
	// Marshal the JSON
	marshalled, err := json.Marshal(accounts)
	if err != nil {
		return err
	}
	// Write to the file
	fi, err := os.OpenFile(UserFile, os.O_TRUNC|os.O_WRONLY, 0666)
	if err != nil {
		return err
	}
	_, err = fi.Write(marshalled)
	if err != nil {
		return err
	}
	fi.Close()
	return nil
}
func (a *Account) Delete() error {
	// Ensure there are no accounts of that name already
	valid, err := a.Validate()
	if err != nil {
		return err
	}
	if !valid {
		return errors.New("Account does not exist")
	}
	// Remove user entry in "users" file
	accounts, err := getAccounts()
	if err != nil {
		return err
	}
	for i, account := range accounts {
		if account.Username == a.Username {
			accounts = append(accounts[:i], accounts[i+1:]...)
			break
		}
	}
	marshalled, err := json.Marshal(accounts)
	if err != nil {
		return err
	}
	log.Printf(string(marshalled))
	// Write to the file
	fi, err := os.OpenFile(UserFile, os.O_TRUNC|os.O_WRONLY, 0666)
	if err != nil {
		return err
	}
	_, err = fi.Write(marshalled)
	if err != nil {
		return err
	}
	fi.Close()
	// Delete directory structure
	baseDir := os.Getenv("LOOP_DATA")
	userDir := strings.ToLower(a.Username)
	s := string(filepath.Separator)
	err = os.RemoveAll(baseDir + s + userDir)
	if err != nil {
		return err
	}
	return nil
}
func (a *Account) Add(content, filename string, file []byte) (string, error) {
	// TODO: Create new content directory
	// TODO: Check if filename already exists
	// TODO: Write file to content directory
	return "", nil
}
func (a *Account) Publish(title, content string, date time.Time) (string, error) {
	// TODO: Check if symlink already exists
	// TODO: Create symbolic link in "blog" directory referencing content directory
	return "", nil
}

account_test.go

@@ -0,0 +1,83 @@
package main
import (
	"os"
	"testing"
)
func TestGetAccounts(t *testing.T) {
	a, err := getAccounts()
	if err != nil || a == nil {
		t.Error(err)
	}
}
func TestCreate(t *testing.T) {
	a := Account{
		Username:   "guest",
		Passphrase: "guest",
	}
	ConfigureEnvironment()
	err := a.Create()
	if err != nil {
		t.Error(err)
	}
	valid, err := a.Validate()
	if err != nil {
		t.Error(err)
	}
	if !valid {
		t.Error("Failed to create account")
	}
}
func TestValidate(t *testing.T) {
	a := Account{
		Username:   "fake",
		Passphrase: "fake",
	}
	valid, err := a.Validate()
	if err != nil {
		t.Error(err)
	}
	if valid {
		t.Error("Fake account should not exist")
	}
}
func TestAdd(t *testing.T) {
}
func TestPublish(t *testing.T) {
}
func TestDelete(t *testing.T) {
	a := Account{
		Username:   "guest",
		Passphrase: "guest",
	}
	ConfigureEnvironment()
	err := a.Delete()
	if err != nil {
		t.Error(err)
	}
	valid, err := a.Validate()
	if err != nil {
		t.Error(err)
	}
	if valid {
		t.Error("Failed to delete account")
	}
}
func TestCleanup(t *testing.T) {
	err := os.Remove("loop_users")
	if err != nil {
		t.Error(err)
	}
}

main.go

@@ -1,17 +1,29 @@
package main
import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"crypto/sha512"
	"encoding/base64"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"time"
	"strings"
)
const (
	UserFile = "loop_users"
)
var (
	EnvironmentVariables = map[string]string{
		"LOOP_URL":  "localhost:6006",
		"LOOP_SALT": "whatyoutalkingaboutwillus",
		"LOOP_BASE": ".",
		"LOOP_DATA": ".",
	}
)
@@ -33,21 +45,91 @@ func main() {
	log.Fatal(http.ListenAndServe(address(), nil))
}
// General stuff
type Account struct {
	Username   string `json:username`
	Passphrase string `json:passphrase`
}
func address() string {
	return os.Getenv("LOOP_URL")
}
func validateCredentials(username, password, salt string) bool {
	return false
// Security stuff
func encodeBase64(data []byte) string {
	return base64.StdEncoding.EncodeToString(data)
}
func decodeBase64(data []byte) []byte {
	b, _ := base64.StdEncoding.DecodeString(string(data))
	return b
}
func salt() string {
	return os.Getenv("LOOP_SALT")
}
func getSizedKey(key string) string {
	// Get the correct key length
	l := len(key)
	if l < 16 {
		for i := 0; i < 16-l; i++ {
			key += "."
		}
	} else if l < 24 {
		for i := 0; i < 24-l; i++ {
			key += "."
		}
	} else if l < 32 {
		for i := 0; i < 32-l; i++ {
			key += "."
		}
	} else {
		key = key[:32]
	}
	return key
}
func createUser(username string) (string, error) {
	return "", nil
func encrypt(text, passphrase string) ([]byte, error) {
	key := []byte(getSizedKey(passphrase))
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	cipherText := make([]byte, aes.BlockSize+len(text))
	iv := cipherText[:aes.BlockSize]
	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
		return nil, err
	}
	encrypter := cipher.NewCFBEncrypter(block, iv)
	encrypter.XORKeyStream(cipherText[aes.BlockSize:], []byte(text))
	return cipherText, nil
}
func createContent(username string) (string, error) {
	return "", nil
func decrypt(text []byte, passphrase string) ([]byte, error) {
	key := []byte(getSizedKey(passphrase))
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	if len(text) < aes.BlockSize {
		return nil, errors.New("Cipher text too short")
	}
	iv := text[:aes.BlockSize]
	data := text[aes.BlockSize:]
	decrypter := cipher.NewCFBDecrypter(block, iv)
	decrypter.XORKeyStream(data, data)
	return data, nil
}
func addContent(content, filename string, file []byte) (string, error) {
	return "", nil
func hash(username, passphrase, salt string) []byte {
	clearText := fmt.Sprintf(
		"%s%s-%s",
		salt,
		strings.ToLower(username),
		strings.ToLower(passphrase))
	sha := sha512.New()
	sha.Write([]byte(clearText))
	return sha.Sum(nil)
}
func publishContent(title, content string, date time.Time) (string, error) {
	return "", nil
func generatePassphrase(username, passphrase string) string {
	return encodeBase64(hash(username, passphrase, salt()))
}

main_test.go

@@ -0,0 +1,16 @@
package main
import (
	"os"
	"testing"
)
func TestAddress(t *testing.T) {
	expected := "127.0.0.1:8888"
	os.Setenv("LOOP_URL", expected)
	actual := os.Getenv("LOOP_URL")
	if actual != expected {
		t.FailNow()
	}
}