woodpecker/server/api/login.go

203 lines
5.8 KiB
Go
Raw Normal View History

2018-02-19 22:24:10 +00:00
// Copyright 2018 Drone.IO Inc.
2018-03-21 13:02:17 +00:00
//
2018-02-19 22:24:10 +00:00
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
2018-03-21 13:02:17 +00:00
//
2018-02-19 22:24:10 +00:00
// http://www.apache.org/licenses/LICENSE-2.0
2018-03-21 13:02:17 +00:00
//
2018-02-19 22:24:10 +00:00
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package api
2016-05-02 00:33:22 +00:00
import (
"encoding/base32"
"errors"
2016-05-02 00:33:22 +00:00
"net/http"
"time"
"github.com/gin-gonic/gin"
2019-06-01 07:45:20 +00:00
"github.com/gorilla/securecookie"
"github.com/rs/zerolog/log"
"github.com/woodpecker-ci/woodpecker/server"
"github.com/woodpecker-ci/woodpecker/server/model"
"github.com/woodpecker-ci/woodpecker/server/store"
"github.com/woodpecker-ci/woodpecker/server/store/types"
"github.com/woodpecker-ci/woodpecker/shared/httputil"
"github.com/woodpecker-ci/woodpecker/shared/token"
2016-05-02 00:33:22 +00:00
)
2017-07-31 19:15:05 +00:00
func HandleLogin(c *gin.Context) {
var (
w = c.Writer
r = c.Request
)
if err := r.FormValue("error"); err != "" {
http.Redirect(w, r, "/login/error?code="+err, 303)
} else {
http.Redirect(w, r, "/authorize", 303)
2017-07-31 19:15:05 +00:00
}
}
func HandleAuth(c *gin.Context) {
_store := store.FromContext(c)
2016-05-02 00:33:22 +00:00
// when dealing with redirects we may need to adjust the content type. I
// cannot, however, remember why, so need to revisit this line.
c.Writer.Header().Del("Content-Type")
tmpuser, err := server.Config.Services.Forge.Login(c, c.Writer, c.Request)
2016-05-02 00:33:22 +00:00
if err != nil {
log.Error().Msgf("cannot authenticate user. %s", err)
c.Redirect(http.StatusSeeOther, "/login?error=oauth_error")
2016-05-02 00:33:22 +00:00
return
}
// this will happen when the user is redirected by the forge as
2016-05-02 00:33:22 +00:00
// part of the authorization workflow.
if tmpuser == nil {
return
}
config := ToConfig(c)
// get the user from the database
u, err := _store.GetUserLogin(tmpuser.Login)
2016-05-02 00:33:22 +00:00
if err != nil {
if !errors.Is(err, types.RecordNotExist) {
_ = c.AbortWithError(http.StatusInternalServerError, err)
return
}
2016-05-02 00:33:22 +00:00
// if self-registration is disabled we should return a not authorized error
if !config.Open && !config.IsAdmin(tmpuser) {
log.Error().Msgf("cannot register %s. registration closed", tmpuser.Login)
c.Redirect(http.StatusSeeOther, "/login?error=access_denied")
2016-05-02 00:33:22 +00:00
return
}
// if self-registration is enabled for whitelisted organizations we need to
// check the user's organization membership.
if len(config.Orgs) != 0 {
teams, terr := server.Config.Services.Forge.Teams(c, tmpuser)
if terr != nil || !config.IsMember(teams) {
log.Error().Msgf("cannot verify team membership for %s.", u.Login)
c.Redirect(303, "/login?error=access_denied")
return
}
}
2016-05-02 00:33:22 +00:00
// create the user account
u = &model.User{
Login: tmpuser.Login,
Token: tmpuser.Token,
Secret: tmpuser.Secret,
Email: tmpuser.Email,
Avatar: tmpuser.Avatar,
Hash: base32.StdEncoding.EncodeToString(
securecookie.GenerateRandomKey(32),
),
2016-05-02 00:33:22 +00:00
}
// insert the user into the database
if err := _store.CreateUser(u); err != nil {
log.Error().Msgf("cannot insert %s. %s", u.Login, err)
c.Redirect(http.StatusSeeOther, "/login?error=internal_error")
2016-05-02 00:33:22 +00:00
return
}
}
// update the user meta data and authorization data.
u.Token = tmpuser.Token
u.Secret = tmpuser.Secret
u.Email = tmpuser.Email
u.Avatar = tmpuser.Avatar
u.Admin = u.Admin || config.IsAdmin(tmpuser)
2016-05-02 00:33:22 +00:00
// if self-registration is enabled for whitelisted organizations we need to
// check the user's organization membership.
2016-05-02 00:33:22 +00:00
if len(config.Orgs) != 0 {
teams, terr := server.Config.Services.Forge.Teams(c, u)
if terr != nil || !config.IsMember(teams) {
log.Error().Msgf("cannot verify team membership for %s.", u.Login)
c.Redirect(http.StatusSeeOther, "/login?error=access_denied")
2016-05-02 00:33:22 +00:00
return
}
}
if err := _store.UpdateUser(u); err != nil {
log.Error().Msgf("cannot update %s. %s", u.Login, err)
c.Redirect(http.StatusSeeOther, "/login?error=internal_error")
return
}
exp := time.Now().Add(server.Config.Server.SessionExpires).Unix()
tokenString, err := token.New(token.SessToken, u.Login).SignExpires(u.Hash, exp)
2016-05-02 00:33:22 +00:00
if err != nil {
log.Error().Msgf("cannot create token for %s. %s", u.Login, err)
c.Redirect(http.StatusSeeOther, "/login?error=internal_error")
2016-05-02 00:33:22 +00:00
return
}
httputil.SetCookie(c.Writer, c.Request, "user_sess", tokenString)
2016-05-02 00:33:22 +00:00
c.Redirect(http.StatusSeeOther, "/")
2016-05-02 00:33:22 +00:00
}
func GetLogout(c *gin.Context) {
httputil.DelCookie(c.Writer, c.Request, "user_sess")
httputil.DelCookie(c.Writer, c.Request, "user_last")
c.Redirect(http.StatusSeeOther, "/")
2016-05-02 00:33:22 +00:00
}
func GetLoginToken(c *gin.Context) {
_store := store.FromContext(c)
2016-05-02 00:33:22 +00:00
in := &tokenPayload{}
err := c.Bind(in)
if err != nil {
_ = c.AbortWithError(http.StatusBadRequest, err)
2016-05-02 00:33:22 +00:00
return
}
login, err := server.Config.Services.Forge.Auth(c, in.Access, in.Refresh)
2016-05-02 00:33:22 +00:00
if err != nil {
_ = c.AbortWithError(http.StatusUnauthorized, err)
2016-05-02 00:33:22 +00:00
return
}
user, err := _store.GetUserLogin(login)
2016-05-02 00:33:22 +00:00
if err != nil {
_ = c.AbortWithError(http.StatusNotFound, err)
2016-05-02 00:33:22 +00:00
return
}
exp := time.Now().Add(server.Config.Server.SessionExpires).Unix()
newToken := token.New(token.SessToken, user.Login)
tokenStr, err := newToken.SignExpires(user.Hash, exp)
2016-05-02 00:33:22 +00:00
if err != nil {
_ = c.AbortWithError(http.StatusInternalServerError, err)
2016-05-02 00:33:22 +00:00
return
}
2016-06-14 21:01:20 +00:00
c.JSON(http.StatusOK, &tokenPayload{
Access: tokenStr,
2016-05-02 00:33:22 +00:00
Expires: exp - time.Now().Unix(),
})
}
type tokenPayload struct {
Access string `json:"access_token,omitempty"`
Refresh string `json:"refresh_token,omitempty"`
Expires int64 `json:"expires_in,omitempty"`
}
2016-05-02 19:21:25 +00:00
// ToConfig returns the config from the Context
2017-05-05 16:59:37 +00:00
func ToConfig(c *gin.Context) *model.Settings {
2016-05-02 19:21:25 +00:00
v := c.MustGet("config")
2017-05-05 16:59:37 +00:00
return v.(*model.Settings)
2016-05-02 19:21:25 +00:00
}