mirror of
https://github.com/gmemstr/sliproad.git
synced 2024-09-19 16:11:11 +01:00
49dba732d3
Implemented a much-needed Setup() function for providers to implement, which (as demonstrated in the backblaze provider) allows for authentication in advance of needing to make calls to remote locations. This could also be used to create a directory or perform some other sanity check required for the provider to work. So far, haven't noticed any performance impacts from this approach, besides not needing to auth each time we make a request.
100 lines
2.3 KiB
Go
100 lines
2.3 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"database/sql"
|
|
"encoding/base64"
|
|
"fmt"
|
|
"github.com/gmemstr/nas/files"
|
|
"github.com/go-yaml/yaml"
|
|
"golang.org/x/crypto/bcrypt"
|
|
"io/ioutil"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
|
|
"github.com/gmemstr/nas/router"
|
|
)
|
|
|
|
// Main function that defines routes
|
|
func main() {
|
|
if _, err := os.Stat(".lock"); os.IsNotExist(err) {
|
|
createDatabase()
|
|
createLockFile()
|
|
}
|
|
|
|
// Initialize file providers.
|
|
file, err := ioutil.ReadFile("providers.yml")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
err = yaml.Unmarshal(file, &files.ProviderConfig)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
files.SetupProviders()
|
|
|
|
r := router.Init()
|
|
fmt.Println("Your NAS instance is live on port :3000")
|
|
log.Fatal(http.ListenAndServe(":3000", r))
|
|
}
|
|
|
|
func createDatabase() {
|
|
fmt.Println("Initializing the database")
|
|
os.Create("assets/config/users.db")
|
|
|
|
db, err := sql.Open("sqlite3", "assets/config/users.db")
|
|
if err != nil {
|
|
fmt.Println("Problem opening database file! %v", err)
|
|
}
|
|
|
|
_, err = db.Exec("CREATE TABLE IF NOT EXISTS `users` ( `id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT UNIQUE, `username` TEXT UNIQUE, `hash` TEXT, `token` TEXT, `permissions` INTEGER )")
|
|
if err != nil {
|
|
fmt.Println("Problem creating database! %v", err)
|
|
}
|
|
|
|
text, err := GenerateRandomString(12)
|
|
if err != nil {
|
|
fmt.Println("Error randomly generating password", err)
|
|
}
|
|
fmt.Println("Admin password: ", text)
|
|
hash, err := bcrypt.GenerateFromPassword([]byte(text), 4)
|
|
if err != nil {
|
|
fmt.Println("Error generating hash", err)
|
|
}
|
|
if bcrypt.CompareHashAndPassword(hash, []byte(text)) == nil {
|
|
fmt.Println("Password hashed")
|
|
}
|
|
_, err = db.Exec("INSERT INTO users(id,username,hash,permissions) VALUES (0,'admin','" + string(hash) + "',2)")
|
|
if err != nil {
|
|
fmt.Println("Problem creating database! %v", err)
|
|
}
|
|
defer db.Close()
|
|
}
|
|
|
|
func createLockFile() {
|
|
lock, err := os.Create(".lock")
|
|
if err != nil {
|
|
fmt.Println("Error: %v", err)
|
|
}
|
|
lock.Write([]byte("This file left intentionally empty"))
|
|
defer lock.Close()
|
|
}
|
|
|
|
func GenerateRandomBytes(n int) ([]byte, error) {
|
|
b := make([]byte, n)
|
|
_, err := rand.Read(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return b, nil
|
|
}
|
|
|
|
|
|
// GenerateRandomString returns a URL-safe, base64 encoded
|
|
// securely generated random string.
|
|
func GenerateRandomString(s int) (string, error) {
|
|
b, err := GenerateRandomBytes(s)
|
|
return base64.URLEncoding.EncodeToString(b), err
|
|
} |