forgejo-federation/models/login.go

361 lines
8 KiB
Go
Raw Normal View History

// Copyright 2014 The Gogs Authors. All rights reserved.
2014-05-05 15:02:47 +05:30
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
2014-04-26 11:51:04 +05:30
package models
2014-05-03 08:18:14 +05:30
import (
2014-05-16 00:16:04 +05:30
"crypto/tls"
2014-05-03 08:18:14 +05:30
"encoding/json"
2014-05-05 14:10:25 +05:30
"errors"
2014-05-11 13:19:36 +05:30
"fmt"
"net/smtp"
2014-05-11 11:42:45 +05:30
"strings"
2014-05-03 08:18:14 +05:30
"time"
2014-04-26 11:51:04 +05:30
2014-05-03 08:18:14 +05:30
"github.com/go-xorm/core"
2014-05-05 14:10:25 +05:30
"github.com/go-xorm/xorm"
2014-05-05 15:02:47 +05:30
2014-05-03 08:18:14 +05:30
"github.com/gogits/gogs/modules/auth/ldap"
2014-05-15 20:04:36 +05:30
"github.com/gogits/gogs/modules/log"
2014-05-03 08:18:14 +05:30
)
2014-04-26 11:51:04 +05:30
type LoginType int
2014-05-05 14:10:25 +05:30
const (
NOTYPE LoginType = iota
PLAIN
LDAP
SMTP
2014-05-05 14:10:25 +05:30
)
var (
ErrAuthenticationAlreadyExist = errors.New("Authentication already exist")
2014-05-05 15:02:47 +05:30
ErrAuthenticationNotExist = errors.New("Authentication does not exist")
2014-05-05 14:10:25 +05:30
ErrAuthenticationUserUsed = errors.New("Authentication has been used by some users")
)
var LoginTypes = map[LoginType]string{
LDAP: "LDAP",
SMTP: "SMTP",
2014-05-05 14:10:25 +05:30
}
2014-04-26 11:51:04 +05:30
2014-05-12 20:32:36 +05:30
// Ensure structs implmented interface.
var (
_ core.Conversion = &LDAPConfig{}
_ core.Conversion = &SMTPConfig{}
)
2014-04-26 11:51:04 +05:30
type LDAPConfig struct {
2014-05-03 08:18:14 +05:30
ldap.Ldapsource
2014-04-26 11:51:04 +05:30
}
func (cfg *LDAPConfig) FromDB(bs []byte) error {
2014-05-03 08:18:14 +05:30
return json.Unmarshal(bs, &cfg.Ldapsource)
2014-04-26 11:51:04 +05:30
}
func (cfg *LDAPConfig) ToDB() ([]byte, error) {
2014-05-03 08:18:14 +05:30
return json.Marshal(cfg.Ldapsource)
2014-04-26 11:51:04 +05:30
}
2014-05-11 13:19:36 +05:30
type SMTPConfig struct {
Auth string
Host string
2014-05-11 15:40:37 +05:30
Port int
2014-05-11 13:19:36 +05:30
TLS bool
}
func (cfg *SMTPConfig) FromDB(bs []byte) error {
return json.Unmarshal(bs, cfg)
}
func (cfg *SMTPConfig) ToDB() ([]byte, error) {
return json.Marshal(cfg)
}
2014-04-26 11:51:04 +05:30
type LoginSource struct {
2014-05-11 11:42:45 +05:30
Id int64
Type LoginType
Name string `xorm:"UNIQUE"`
IsActived bool `xorm:"NOT NULL DEFAULT false"`
2014-05-11 11:42:45 +05:30
Cfg core.Conversion `xorm:"TEXT"`
AllowAutoRegister bool `xorm:"NOT NULL DEFAULT false"`
Created time.Time `xorm:"CREATED"`
Updated time.Time `xorm:"UPDATED"`
2014-05-03 08:18:14 +05:30
}
2014-05-05 14:10:25 +05:30
func (source *LoginSource) TypeString() string {
return LoginTypes[source.Type]
}
func (source *LoginSource) LDAP() *LDAPConfig {
return source.Cfg.(*LDAPConfig)
}
2014-05-11 13:19:36 +05:30
func (source *LoginSource) SMTP() *SMTPConfig {
return source.Cfg.(*SMTPConfig)
}
2014-05-05 14:10:25 +05:30
func (source *LoginSource) BeforeSet(colName string, val xorm.Cell) {
if colName == "type" {
ty := (*val).(int64)
switch LoginType(ty) {
case LDAP:
2014-05-05 14:10:25 +05:30
source.Cfg = new(LDAPConfig)
case SMTP:
2014-05-11 13:19:36 +05:30
source.Cfg = new(SMTPConfig)
2014-05-05 14:10:25 +05:30
}
}
}
func CreateSource(source *LoginSource) error {
2014-06-21 10:21:41 +05:30
_, err := x.Insert(source)
return err
}
2014-05-03 08:18:14 +05:30
func GetAuths() ([]*LoginSource, error) {
var auths = make([]*LoginSource, 0, 5)
2014-06-21 10:21:41 +05:30
err := x.Find(&auths)
2014-05-03 08:18:14 +05:30
return auths, err
}
2014-05-05 14:10:25 +05:30
func GetLoginSourceById(id int64) (*LoginSource, error) {
source := new(LoginSource)
2014-06-21 10:21:41 +05:30
has, err := x.Id(id).Get(source)
2014-05-05 14:10:25 +05:30
if err != nil {
return nil, err
} else if !has {
2014-05-05 14:10:25 +05:30
return nil, ErrAuthenticationNotExist
}
return source, nil
}
2014-05-11 15:40:37 +05:30
func UpdateSource(source *LoginSource) error {
2014-06-21 10:21:41 +05:30
_, err := x.Id(source.Id).AllCols().Update(source)
2014-05-03 08:18:14 +05:30
return err
}
2014-05-05 14:10:25 +05:30
func DelLoginSource(source *LoginSource) error {
2014-06-21 10:21:41 +05:30
cnt, err := x.Count(&User{LoginSource: source.Id})
2014-05-05 14:10:25 +05:30
if err != nil {
return err
}
if cnt > 0 {
return ErrAuthenticationUserUsed
}
2014-06-21 10:21:41 +05:30
_, err = x.Id(source.Id).Delete(&LoginSource{})
2014-05-03 08:18:14 +05:30
return err
2014-04-26 11:51:04 +05:30
}
2014-05-11 11:42:45 +05:30
2014-06-06 07:37:35 +05:30
// UserSignIn validates user name and password.
func UserSignIn(uname, passwd string) (*User, error) {
2014-10-25 04:13:17 +05:30
u := new(User)
2014-05-11 11:42:45 +05:30
if strings.Contains(uname, "@") {
u = &User{Email: uname}
} else {
u = &User{LowerName: strings.ToLower(uname)}
}
2014-06-21 10:21:41 +05:30
has, err := x.Get(u)
2014-05-11 11:42:45 +05:30
if err != nil {
return nil, err
}
2014-10-03 22:42:54 +05:30
if u.LoginType == NOTYPE && has {
u.LoginType = PLAIN
2014-05-11 11:42:45 +05:30
}
2014-07-26 09:54:27 +05:30
// For plain login, user must exist to reach this line.
// Now verify password.
if u.LoginType == PLAIN {
2014-05-11 11:42:45 +05:30
newUser := &User{Passwd: passwd, Salt: u.Salt}
newUser.EncodePasswd()
if u.Passwd != newUser.Passwd {
return nil, ErrUserNotExist
}
return u, nil
} else {
if !has {
var sources []LoginSource
2014-06-21 10:21:41 +05:30
if err = x.UseBool().Find(&sources,
2014-05-19 03:37:04 +05:30
&LoginSource{IsActived: true, AllowAutoRegister: true}); err != nil {
2014-05-11 11:42:45 +05:30
return nil, err
}
for _, source := range sources {
if source.Type == LDAP {
2014-05-11 17:34:28 +05:30
u, err := LoginUserLdapSource(nil, uname, passwd,
2014-05-11 13:19:36 +05:30
source.Id, source.Cfg.(*LDAPConfig), true)
if err == nil {
2014-05-15 20:04:36 +05:30
return u, nil
2014-05-11 13:19:36 +05:30
}
log.Warn("Fail to login(%s) by LDAP(%s): %v", uname, source.Name, err)
} else if source.Type == SMTP {
2014-05-11 17:34:28 +05:30
u, err := LoginUserSMTPSource(nil, uname, passwd,
2014-05-11 13:19:36 +05:30
source.Id, source.Cfg.(*SMTPConfig), true)
if err == nil {
2014-05-15 20:04:36 +05:30
return u, nil
2014-05-11 13:19:36 +05:30
}
log.Warn("Fail to login(%s) by SMTP(%s): %v", uname, source.Name, err)
2014-05-11 11:42:45 +05:30
}
}
return nil, ErrUserNotExist
}
var source LoginSource
2014-06-21 10:21:41 +05:30
hasSource, err := x.Id(u.LoginSource).Get(&source)
2014-05-11 11:42:45 +05:30
if err != nil {
return nil, err
2014-05-16 00:16:04 +05:30
} else if !hasSource {
2014-05-11 11:42:45 +05:30
return nil, ErrLoginSourceNotExist
2014-05-16 00:16:04 +05:30
} else if !source.IsActived {
2014-05-11 11:42:45 +05:30
return nil, ErrLoginSourceNotActived
}
switch u.LoginType {
case LDAP:
2014-05-11 11:42:45 +05:30
return LoginUserLdapSource(u, u.LoginName, passwd,
source.Id, source.Cfg.(*LDAPConfig), false)
case SMTP:
2014-05-11 13:19:36 +05:30
return LoginUserSMTPSource(u, u.LoginName, passwd,
source.Id, source.Cfg.(*SMTPConfig), false)
2014-05-11 11:42:45 +05:30
}
return nil, ErrUnsupportedLoginType
}
}
// Query if name/passwd can login against the LDAP direcotry pool
// Create a local user if success
// Return the same LoginUserPlain semantic
2014-07-26 09:54:27 +05:30
func LoginUserLdapSource(u *User, name, passwd string, sourceId int64, cfg *LDAPConfig, autoRegister bool) (*User, error) {
2014-05-11 11:42:45 +05:30
mail, logged := cfg.Ldapsource.SearchEntry(name, passwd)
if !logged {
// user not in LDAP, do nothing
return nil, ErrUserNotExist
}
if !autoRegister {
2014-07-26 09:54:27 +05:30
return u, nil
2014-05-11 11:42:45 +05:30
}
// fake a local user creation
2014-07-26 09:54:27 +05:30
u = &User{
2014-05-11 11:42:45 +05:30
LowerName: strings.ToLower(name),
Name: strings.ToLower(name),
LoginType: LDAP,
2014-05-11 11:42:45 +05:30
LoginSource: sourceId,
LoginName: name,
IsActive: true,
Passwd: passwd,
Email: mail,
}
2014-07-26 09:54:27 +05:30
err := CreateUser(u)
return u, err
2014-05-11 11:42:45 +05:30
}
2014-05-11 13:19:36 +05:30
type loginAuth struct {
username, password string
}
func LoginAuth(username, password string) smtp.Auth {
return &loginAuth{username, password}
}
func (a *loginAuth) Start(server *smtp.ServerInfo) (string, []byte, error) {
return "LOGIN", []byte(a.username), nil
}
func (a *loginAuth) Next(fromServer []byte, more bool) ([]byte, error) {
if more {
switch string(fromServer) {
case "Username:":
return []byte(a.username), nil
case "Password:":
return []byte(a.password), nil
}
}
return nil, nil
}
var (
2014-05-11 15:40:37 +05:30
SMTP_PLAIN = "PLAIN"
SMTP_LOGIN = "LOGIN"
SMTPAuths = []string{SMTP_PLAIN, SMTP_LOGIN}
2014-05-11 13:19:36 +05:30
)
2014-05-16 00:16:04 +05:30
func SmtpAuth(host string, port int, a smtp.Auth, useTls bool) error {
c, err := smtp.Dial(fmt.Sprintf("%s:%d", host, port))
2014-05-11 13:19:36 +05:30
if err != nil {
return err
}
defer c.Close()
2014-05-16 00:16:04 +05:30
if err = c.Hello("gogs"); err != nil {
return err
}
if useTls {
2014-05-11 17:34:28 +05:30
if ok, _ := c.Extension("STARTTLS"); ok {
2014-05-16 00:16:04 +05:30
config := &tls.Config{ServerName: host}
if err = c.StartTLS(config); err != nil {
2014-05-11 17:34:28 +05:30
return err
}
} else {
2014-05-16 08:33:26 +05:30
return errors.New("SMTP server unsupports TLS")
2014-05-11 13:19:36 +05:30
}
}
if ok, _ := c.Extension("AUTH"); ok {
if err = c.Auth(a); err != nil {
return err
}
return nil
}
return ErrUnsupportedLoginType
2014-05-11 13:19:36 +05:30
}
// Query if name/passwd can login against the LDAP direcotry pool
// Create a local user if success
// Return the same LoginUserPlain semantic
2014-07-26 09:54:27 +05:30
func LoginUserSMTPSource(u *User, name, passwd string, sourceId int64, cfg *SMTPConfig, autoRegister bool) (*User, error) {
2014-05-11 13:19:36 +05:30
var auth smtp.Auth
2014-05-11 15:40:37 +05:30
if cfg.Auth == SMTP_PLAIN {
2014-05-11 13:19:36 +05:30
auth = smtp.PlainAuth("", name, passwd, cfg.Host)
2014-05-11 15:40:37 +05:30
} else if cfg.Auth == SMTP_LOGIN {
2014-05-11 13:19:36 +05:30
auth = LoginAuth(name, passwd)
2014-05-11 17:34:28 +05:30
} else {
2014-05-16 00:16:04 +05:30
return nil, errors.New("Unsupported SMTP auth type")
2014-05-11 13:19:36 +05:30
}
2014-05-16 00:16:04 +05:30
if err := SmtpAuth(cfg.Host, cfg.Port, auth, cfg.TLS); err != nil {
if strings.Contains(err.Error(), "Username and Password not accepted") {
return nil, ErrUserNotExist
}
2014-05-11 13:19:36 +05:30
return nil, err
}
if !autoRegister {
2014-07-26 09:54:27 +05:30
return u, nil
2014-05-11 13:19:36 +05:30
}
2014-05-11 17:34:28 +05:30
var loginName = name
idx := strings.Index(name, "@")
if idx > -1 {
loginName = name[:idx]
}
2014-05-11 13:19:36 +05:30
// fake a local user creation
2014-07-26 09:54:27 +05:30
u = &User{
2014-05-11 17:34:28 +05:30
LowerName: strings.ToLower(loginName),
Name: strings.ToLower(loginName),
LoginType: SMTP,
2014-05-11 13:19:36 +05:30
LoginSource: sourceId,
LoginName: name,
IsActive: true,
Passwd: passwd,
Email: name,
}
2014-07-26 09:54:27 +05:30
err := CreateUser(u)
return u, err
2014-05-11 13:19:36 +05:30
}