486 lines
14 KiB
Go
486 lines
14 KiB
Go
package scsusers
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rand"
|
|
"database/sql"
|
|
"encoding/base32"
|
|
"encoding/json"
|
|
"fmt"
|
|
"html/template"
|
|
"log"
|
|
"net/smtp"
|
|
"strings"
|
|
|
|
"github.com/jmoiron/sqlx"
|
|
"golang.org/x/crypto/bcrypt"
|
|
)
|
|
|
|
type templates struct {
|
|
Registration *template.Template
|
|
Alert *template.Template
|
|
Recovery *template.Template
|
|
}
|
|
|
|
type config struct {
|
|
SiteName string
|
|
FromEmail string
|
|
Templates templates
|
|
SMTPServer string
|
|
db *sqlx.DB
|
|
TablePrefix string
|
|
}
|
|
|
|
type UserData struct {
|
|
Username string `json:"username"`
|
|
UserPerms map[string]string `json:"perms"`
|
|
UserSettings map[string]string `json:"settings"`
|
|
}
|
|
|
|
var c config
|
|
|
|
func Init(dbin *sqlx.DB, tp, sitename, fromaddr, smtpserver string) {
|
|
c.db = dbin
|
|
c.TablePrefix = tp
|
|
c.SiteName = sitename
|
|
c.FromEmail = fromaddr
|
|
c.SMTPServer = smtpserver
|
|
|
|
SetRegistrationTemplate("")
|
|
SetAlertTemplate("")
|
|
SetRecoveryTemplate("")
|
|
}
|
|
|
|
func UsernameAvailable(username string) bool {
|
|
if len(username) == 0 {
|
|
return false
|
|
}
|
|
var tmp string
|
|
u := strings.ToLower(username)
|
|
|
|
q := fmt.Sprintf("select username from %s_auth where username = $1", c.TablePrefix)
|
|
err := c.db.Get(&tmp, q, u)
|
|
if err == sql.ErrNoRows {
|
|
return true
|
|
}
|
|
if err != nil {
|
|
log.Printf("UsernameAvailable returned error: " + err.Error() + " Query was " + q)
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
|
|
/* Check for username availability, add to database, send email */
|
|
|
|
func Register(username, email, ip string) bool {
|
|
if !UsernameAvailable(username) {
|
|
return false
|
|
}
|
|
u := strings.ToLower(username)
|
|
|
|
pass := randBytes(16)
|
|
crypt, err := bcrypt.GenerateFromPassword(pass, 10)
|
|
if err != nil {
|
|
log.Printf("scsusers.Register: Bcrypt GenerateFromPassword failed? Pass is %s and error is %s\n", pass, err.Error())
|
|
return false
|
|
}
|
|
q := fmt.Sprintf("insert into %s_auth (username, , displayname, email, password, registration_date, registration_ip) values ($1, $2, $3, CURRENT_TIMESTAMP, $4)", c.TablePrefix)
|
|
_, err = c.db.Exec(q, u, username, email, crypt, ip)
|
|
if err != nil {
|
|
log.Printf("scsusers.Register: insert failed: %s\n", err.Error())
|
|
return false
|
|
}
|
|
if sendRegistrationEmail(email, username, string(pass)) {
|
|
log.Printf("scsusers.Register: New user registration: %s from %s\n", username, ip)
|
|
return true
|
|
}
|
|
log.Printf("scsusers.Register: Failed to send registration email, deleting user %s\n", username)
|
|
q = fmt.Sprintf("delete from %s_auth where username = $1 AND password=$2", c.TablePrefix)
|
|
_, err = c.db.Exec(q, u, string(crypt))
|
|
if err != nil {
|
|
log.Printf("scsusers.Register: Failed to delete new user %s: %s\n", username, err.Error())
|
|
}
|
|
return false
|
|
}
|
|
|
|
func Login(username, password string) bool {
|
|
u := strings.ToLower(username)
|
|
|
|
q := fmt.Sprintf("select password from %s_auth where username = $1 AND status='active'", c.TablePrefix)
|
|
var crypt string
|
|
err := c.db.Get(&crypt, q, u)
|
|
if err != nil {
|
|
log.Printf("scsusers.Login: Failed login attempt for unknown username: %s\n", username)
|
|
return false
|
|
}
|
|
if bcrypt.CompareHashAndPassword([]byte(crypt), []byte(password)) != nil {
|
|
log.Printf("scsusers.Login: Failed password for " + username)
|
|
return false
|
|
}
|
|
log.Printf("User %s logged in\n", username)
|
|
return true
|
|
}
|
|
|
|
func ChangePassword(username, oldpass, newpass string) bool {
|
|
u := strings.ToLower(username)
|
|
|
|
q := fmt.Sprintf("select password from %s_auth where username = $1 AND status='active'", c.TablePrefix)
|
|
var crypt string
|
|
err := c.db.Get(&crypt, q, u)
|
|
if err != nil {
|
|
log.Println("scsusers.ChangePassword: Failed change attempt for unknown username: " + username)
|
|
return false
|
|
}
|
|
if bcrypt.CompareHashAndPassword([]byte(crypt), []byte(oldpass)) != nil {
|
|
log.Printf("scsusers.ChangePassword: Failed password for %s\n", username)
|
|
return false
|
|
}
|
|
newcrypt, err := bcrypt.GenerateFromPassword([]byte(newpass), 10)
|
|
q = fmt.Sprintf("update %s_auth set password=$2 where username = $1", c.TablePrefix)
|
|
_, err = c.db.Exec(q, u, newcrypt)
|
|
if err != nil {
|
|
log.Printf("scsusers.ChangePassword: update failed for %s: %s\n", username, err.Error())
|
|
return false
|
|
}
|
|
return true
|
|
|
|
}
|
|
|
|
func GetUserid(username string) int64 {
|
|
var i int64
|
|
u := strings.ToLower(username)
|
|
|
|
q := fmt.Sprintf("select userid from %s_auth where username = $1", c.TablePrefix)
|
|
err := c.db.Get(&i, q, u)
|
|
if err != nil {
|
|
log.Printf("scsusers.getUserId: Error loading user: %s : %s\n", username, err.Error())
|
|
return 0
|
|
}
|
|
return i
|
|
}
|
|
func LoadUser(username string) (UserData, error) {
|
|
var tmp UserData
|
|
u := strings.ToLower(username)
|
|
|
|
q := fmt.Sprintf("select data from %s_userdata where username = $1", c.TablePrefix)
|
|
var d string
|
|
err := c.db.Get(d, q, u)
|
|
if err != nil {
|
|
log.Printf("scsusers.LoadUser: Error loading user: %s : %s\n", username, err.Error())
|
|
return tmp, err
|
|
}
|
|
err = json.Unmarshal([]byte(d), &tmp)
|
|
if err != nil {
|
|
log.Printf("scsusers.LoadUser: Error decoding json on user %s. Unmarshal returned %s\n", username, err.Error())
|
|
}
|
|
return tmp, err
|
|
}
|
|
|
|
func SaveUser(username string, d UserData) bool {
|
|
u := strings.ToLower(username)
|
|
q := fmt.Sprintf("update %s_userdata set data=$1 where username = $2", c.TablePrefix)
|
|
j, err := json.Marshal(d)
|
|
if err != nil {
|
|
log.Printf("scsusers.SaveUser: json.Marshal failed for username %s : %s\n", username, err.Error())
|
|
return false
|
|
}
|
|
_, err = c.db.Exec(q, u, j)
|
|
if err != nil {
|
|
log.Printf("scsusers.SaveUser: db.Exec failed for username %s : %s\n", username, err.Error())
|
|
return false
|
|
}
|
|
return true
|
|
|
|
}
|
|
|
|
func Bump(username string, ip string) {
|
|
u := strings.ToLower(username)
|
|
q := fmt.Sprintf("update %s_auth set lastseen=CURRENT_TIMESTAMP, lastseenip=$2 where username = $1", c.TablePrefix)
|
|
_, err := c.db.Exec(q, u, ip)
|
|
if err != nil {
|
|
log.Printf("scsusers.Bump: Error on user bump: %s : %s\n", username, err.Error())
|
|
}
|
|
}
|
|
|
|
type Metadata struct {
|
|
MetaKey string `db:"meta_key"`
|
|
MetaValue string `db:"meta_value"`
|
|
}
|
|
|
|
func GetAllMeta(username string) map[string]string {
|
|
meta := make(map[string]string)
|
|
u := strings.ToLower(username)
|
|
|
|
q := fmt.Sprintf(`select meta_key, meta_value
|
|
from %s_user_metadata where
|
|
user_id=(select userid from %s_auth where username = $1)`,
|
|
c.TablePrefix, c.TablePrefix)
|
|
rows, err := c.db.Queryx(q, u)
|
|
if err != nil && err != sql.ErrNoRows {
|
|
log.Printf("scsusers.GetAllMeta: %s: %s\n", username, err.Error())
|
|
return meta
|
|
}
|
|
var m Metadata
|
|
for rows.Next() {
|
|
err = rows.StructScan(&m)
|
|
if err != nil {
|
|
log.Printf("scsusers.GetAllMeta: StructScan: %s: %s\n", username, err.Error())
|
|
return meta
|
|
}
|
|
meta[m.MetaKey] = m.MetaValue
|
|
}
|
|
return meta
|
|
}
|
|
|
|
func GetMeta(username string, metakey string) string {
|
|
var v string
|
|
u := strings.ToLower(username)
|
|
|
|
q := fmt.Sprintf(`select meta_value from %s_user_metadata where
|
|
user_id=(select userid from %s_auth where username = $1) AND meta_key=$2`, c.TablePrefix, c.TablePrefix)
|
|
err := c.db.Get(&v, q, u, metakey)
|
|
if err != nil && err != sql.ErrNoRows {
|
|
log.Printf("scsusers.GetMeta: %s - %s - %s\n", username, metakey, err.Error())
|
|
}
|
|
if v == "" {
|
|
// get default user
|
|
err := c.db.Get(&v, q, "//default//", metakey)
|
|
if err != nil && err != sql.ErrNoRows {
|
|
log.Printf("scsusers.GetMeta: %s - %s - %s\n", username, metakey, err.Error())
|
|
}
|
|
|
|
}
|
|
return v
|
|
}
|
|
|
|
func SetMeta(username string, metakey string, metavalue string) {
|
|
var err error
|
|
u := strings.ToLower(username)
|
|
|
|
if metavalue == "" {
|
|
q := fmt.Sprintf(`delete from %s_user_metadata where user_id=(select userid from %s_auth where username = $1) AND meta_key=$2`,
|
|
c.TablePrefix, c.TablePrefix)
|
|
_, err = c.db.Exec(q, u, metakey)
|
|
} else {
|
|
q := fmt.Sprintf(`insert into %s_user_metadata (user_id, meta_key, meta_value) VALUES
|
|
((select userid from %s_auth where username = $1), $2, $3)`, c.TablePrefix, c.TablePrefix)
|
|
_, err = c.db.Exec(q, u, metakey, metavalue)
|
|
}
|
|
if err != nil {
|
|
log.Printf("scsusers.SetMeta: %s %s %s %s\n", username, metakey, metavalue, err.Error())
|
|
}
|
|
}
|
|
|
|
func RecoverByUsername(username string) {
|
|
var email string
|
|
u := strings.ToLower(username)
|
|
|
|
q := fmt.Sprintf("select email from %s_auth where username = $1", c.TablePrefix)
|
|
err := c.db.Get(&email, q, u)
|
|
if err != sql.ErrNoRows {
|
|
recoverycode := randBytes(16)
|
|
qq := fmt.Sprintf("update %s_auth set recoverycode=$1, recoverytime=NOW() where username = $2", c.TablePrefix)
|
|
_, err := c.db.Exec(qq, recoverycode, u)
|
|
if err == nil {
|
|
sendRecoveryEmail(email, username, string(recoverycode))
|
|
}
|
|
}
|
|
}
|
|
|
|
func RecoverByEmail(e string) {
|
|
var username, email string
|
|
q := fmt.Sprintf("select username from %s_auth where email ILIKE $1", c.TablePrefix)
|
|
err := c.db.Get(&username, q, e)
|
|
if err != sql.ErrNoRows {
|
|
recoverycode := randBytes(16)
|
|
qq := fmt.Sprintf("update %s_auth set recoverycode=$1, recoverytime=NOW() where username = $2", c.TablePrefix)
|
|
_, err := c.db.Exec(qq, recoverycode, username)
|
|
if err == nil {
|
|
sendRecoveryEmail(email, username, string(recoverycode))
|
|
}
|
|
}
|
|
}
|
|
|
|
func randBytes(n int) []byte {
|
|
randomBytes := make([]byte, 32)
|
|
_, err := rand.Read(randomBytes)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return []byte(base32.StdEncoding.EncodeToString(randomBytes)[:n])
|
|
}
|
|
|
|
func sendRegistrationEmail(recipient, username, password string) bool {
|
|
data := struct {
|
|
SiteName string
|
|
FromEmail string
|
|
UserName string
|
|
Pass string
|
|
}{
|
|
SiteName: c.SiteName,
|
|
FromEmail: c.FromEmail,
|
|
UserName: username,
|
|
Pass: password,
|
|
}
|
|
var body bytes.Buffer
|
|
err := c.Templates.Registration.Execute(&body, data)
|
|
if err != nil {
|
|
log.Printf("scsusers.sendRegistrationEmail: Registration template failed to execute: %v returned %s\n", data, err.Error())
|
|
return false
|
|
}
|
|
subject := fmt.Sprintf("Welcome to %s", c.SiteName)
|
|
err = SendMail(c.SMTPServer, c.FromEmail, subject, body.String(), recipient)
|
|
if err != nil {
|
|
log.Printf("scsusers.SendRegistrationEmail: Error sending mail to %s: %s\n", recipient, err.Error())
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func sendAlertEmail(username, recipient, message string) bool {
|
|
data := struct {
|
|
SiteName string
|
|
FromEmail string
|
|
UserName string
|
|
Activity string
|
|
}{
|
|
SiteName: c.SiteName,
|
|
FromEmail: c.FromEmail,
|
|
UserName: username,
|
|
Activity: message,
|
|
}
|
|
var body bytes.Buffer
|
|
err := c.Templates.Registration.Execute(&body, data)
|
|
if err != nil {
|
|
log.Printf("scsusers.sendAlertEmail: Alert template failed to execute: %v returned %s\n", data, err.Error())
|
|
return false
|
|
}
|
|
|
|
subject := fmt.Sprintf("new Activity Notification on %s", c.SiteName)
|
|
err = SendMail(c.SMTPServer, c.FromEmail, subject, body.String(), recipient)
|
|
if err != nil {
|
|
log.Printf("scsusers.sendAlertEmail: Error sending mail to %s: %s\n", recipient, err.Error())
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func sendRecoveryEmail(recipient, username, code string) bool {
|
|
data := struct {
|
|
SiteName string
|
|
FromEmail string
|
|
UserName string
|
|
RecoveryCode string
|
|
}{
|
|
SiteName: c.SiteName,
|
|
FromEmail: c.FromEmail,
|
|
UserName: username,
|
|
RecoveryCode: code,
|
|
}
|
|
var body bytes.Buffer
|
|
err := c.Templates.Registration.Execute(&body, data)
|
|
if err != nil {
|
|
log.Printf("scsusers.sendRecoveryEmail: Recovery template failed to execute: %v returned %s\n", data, err.Error())
|
|
return false
|
|
}
|
|
subject := fmt.Sprintf("Account recovery at %s", c.SiteName)
|
|
err = SendMail(c.SMTPServer, c.FromEmail, subject, body.String(), recipient)
|
|
if err != nil {
|
|
log.Printf("scsusers.sendRecoveryEmail: Error sending mail to %s: %s\n", recipient, err.Error())
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func SetRegistrationTemplate(t string) bool {
|
|
if len(t) != 0 {
|
|
r, err := template.New("reg").Parse(t)
|
|
if err != nil {
|
|
c.Templates.Registration = r
|
|
return true
|
|
}
|
|
}
|
|
df := `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html></head><body><p>Hello {{.UserName}}! Welcome to {{.SiteName}}! We've created your account with the username you selected and the following password: {{.Pass}}<br>You can change your password to whatever you want once you log in.</p></body></html>`
|
|
|
|
r, err := template.New("reg").Parse(df)
|
|
if err != nil {
|
|
log.Fatal("scsusers.SetRegistrationTemplate: Default registration template MUST compile. Error: " + err.Error())
|
|
}
|
|
c.Templates.Registration = r
|
|
|
|
return false
|
|
}
|
|
|
|
func SetAlertTemplate(t string) bool {
|
|
if len(t) != 0 {
|
|
r, err := template.New("alert").Parse(t)
|
|
if err != nil {
|
|
c.Templates.Alert = r
|
|
return true
|
|
}
|
|
}
|
|
df := `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html></head><body><p> Hey {{.UserName}}! Just letting you know that {{.Activity}}.<br> You can disable future notifications in your user settings.</p></body></html>`
|
|
r, err := template.New("alert").Parse(df)
|
|
if err != nil {
|
|
log.Fatal("scsusers.SetAlertTemplate: Default alert template MUST compile. Error: " + err.Error())
|
|
}
|
|
c.Templates.Alert = r
|
|
return false
|
|
}
|
|
|
|
func SetRecoveryTemplate(t string) bool {
|
|
if len(t) != 0 {
|
|
r, err := template.New("recovery").Parse(t)
|
|
if err != nil {
|
|
c.Templates.Recovery = r
|
|
return true
|
|
}
|
|
}
|
|
df := `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html></head><body><p>Hello {{.UserName}}! Someone (hopefully you) has attempted an account recovery agt {{.SiteName}}. If this was you, enter the following code to regain access: {{.RecoveryCode}}<br> If this was not you, you can ignore this email.</p></body></html>`
|
|
r, err := template.New("recovery").Parse(df)
|
|
if err != nil {
|
|
log.Fatal("scsusers.SetRecoveryTemplate: Default recovery template MUST compile. Error: " + err.Error())
|
|
}
|
|
c.Templates.Recovery = r
|
|
|
|
return false
|
|
}
|
|
|
|
func SendMail(addr, from, subject, body string, to string) error {
|
|
r := strings.NewReplacer("\r\n", "", "\r", "", "\n", "", "%0a", "", "%0d", "")
|
|
|
|
c, err := smtp.Dial(addr)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer c.Close()
|
|
if err = c.Mail(r.Replace(from)); err != nil {
|
|
return err
|
|
}
|
|
to = r.Replace(to)
|
|
if err = c.Rcpt(to); err != nil {
|
|
return err
|
|
}
|
|
|
|
w, err := c.Data()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
msg := "To: " + to + "\r\n" +
|
|
"From: " + from + "\r\n" +
|
|
"Subject: " + subject + "\r\n" +
|
|
"Content-Type: text/html; charset=\"UTF-8\"\r\n" +
|
|
"\r\n" + body
|
|
|
|
_, err = w.Write([]byte(msg))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = w.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return c.Quit()
|
|
}
|