bench-forgejo/modules/oauth2/oauth2.go

237 lines
5.8 KiB
Go
Raw Normal View History

2014-04-02 19:57:54 +05:30
// Copyright 2014 Google Inc. All Rights Reserved.
//
// 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
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 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 oauth2 contains Martini handlers to provide
// user login via an OAuth 2.0 backend.
package oauth2
import (
"encoding/json"
"fmt"
"net/http"
"net/url"
"strings"
"time"
"code.google.com/p/goauth2/oauth"
"github.com/go-martini/martini"
2014-04-05 20:52:14 +05:30
"github.com/gogits/session"
"github.com/gogits/gogs/modules/middleware"
2014-04-02 19:57:54 +05:30
)
const (
codeRedirect = 302
keyToken = "oauth2_token"
keyNextPage = "next"
)
var (
// Path to handle OAuth 2.0 logins.
PathLogin = "/login"
// Path to handle OAuth 2.0 logouts.
PathLogout = "/logout"
// Path to handle callback from OAuth 2.0 backend
// to exchange credentials.
PathCallback = "/oauth2callback"
// Path to handle error cases.
PathError = "/oauth2error"
)
// Represents OAuth2 backend options.
type Options struct {
ClientId string
ClientSecret string
RedirectURL string
Scopes []string
AuthUrl string
TokenUrl string
}
// Represents a container that contains
// user's OAuth 2.0 access and refresh tokens.
type Tokens interface {
Access() string
Refresh() string
IsExpired() bool
ExpiryTime() time.Time
ExtraData() map[string]string
}
type token struct {
oauth.Token
}
func (t *token) ExtraData() map[string]string {
return t.Extra
}
// Returns the access token.
func (t *token) Access() string {
return t.AccessToken
}
// Returns the refresh token.
func (t *token) Refresh() string {
return t.RefreshToken
}
// Returns whether the access token is
// expired or not.
func (t *token) IsExpired() bool {
if t == nil {
return true
}
return t.Expired()
}
// Returns the expiry time of the user's
// access token.
func (t *token) ExpiryTime() time.Time {
return t.Expiry
}
// Formats tokens into string.
func (t *token) String() string {
return fmt.Sprintf("tokens: %v", t)
}
// Returns a new Google OAuth 2.0 backend endpoint.
func Google(opts *Options) martini.Handler {
opts.AuthUrl = "https://accounts.google.com/o/oauth2/auth"
opts.TokenUrl = "https://accounts.google.com/o/oauth2/token"
return NewOAuth2Provider(opts)
}
// Returns a new Github OAuth 2.0 backend endpoint.
func Github(opts *Options) martini.Handler {
opts.AuthUrl = "https://github.com/login/oauth/authorize"
opts.TokenUrl = "https://github.com/login/oauth/access_token"
return NewOAuth2Provider(opts)
}
func Facebook(opts *Options) martini.Handler {
opts.AuthUrl = "https://www.facebook.com/dialog/oauth"
opts.TokenUrl = "https://graph.facebook.com/oauth/access_token"
return NewOAuth2Provider(opts)
}
// Returns a generic OAuth 2.0 backend endpoint.
func NewOAuth2Provider(opts *Options) martini.Handler {
config := &oauth.Config{
ClientId: opts.ClientId,
ClientSecret: opts.ClientSecret,
RedirectURL: opts.RedirectURL,
Scope: strings.Join(opts.Scopes, " "),
AuthURL: opts.AuthUrl,
TokenURL: opts.TokenUrl,
}
transport := &oauth.Transport{
Config: config,
Transport: http.DefaultTransport,
}
2014-04-05 20:52:14 +05:30
return func(c martini.Context, ctx *middleware.Context) {
if ctx.Req.Method == "GET" {
switch ctx.Req.URL.Path {
2014-04-02 19:57:54 +05:30
case PathLogin:
2014-04-05 20:52:14 +05:30
login(transport, ctx)
2014-04-02 19:57:54 +05:30
case PathLogout:
2014-04-05 20:52:14 +05:30
logout(transport, ctx)
2014-04-02 19:57:54 +05:30
case PathCallback:
2014-04-05 20:52:14 +05:30
handleOAuth2Callback(transport, ctx)
2014-04-02 19:57:54 +05:30
}
}
2014-04-05 20:52:14 +05:30
tk := unmarshallToken(ctx.Session)
2014-04-02 19:57:54 +05:30
if tk != nil {
// check if the access token is expired
if tk.IsExpired() && tk.Refresh() == "" {
2014-04-05 20:52:14 +05:30
ctx.Session.Delete(keyToken)
2014-04-02 19:57:54 +05:30
tk = nil
}
}
// Inject tokens.
c.MapTo(tk, (*Tokens)(nil))
}
}
// Handler that redirects user to the login page
// if user is not logged in.
// Sample usage:
// m.Get("/login-required", oauth2.LoginRequired, func() ... {})
var LoginRequired martini.Handler = func() martini.Handler {
2014-04-05 20:52:14 +05:30
return func(c martini.Context, ctx *middleware.Context) {
token := unmarshallToken(ctx.Session)
2014-04-02 19:57:54 +05:30
if token == nil || token.IsExpired() {
2014-04-05 20:52:14 +05:30
next := url.QueryEscape(ctx.Req.URL.RequestURI())
ctx.Redirect(PathLogin+"?next="+next, codeRedirect)
2014-04-02 19:57:54 +05:30
}
}
}()
2014-04-05 20:52:14 +05:30
func login(t *oauth.Transport, ctx *middleware.Context) {
next := extractPath(ctx.Req.URL.Query().Get(keyNextPage))
if ctx.Session.Get(keyToken) == nil {
2014-04-02 19:57:54 +05:30
// User is not logged in.
2014-04-05 20:52:14 +05:30
ctx.Redirect(t.Config.AuthCodeURL(next), codeRedirect)
2014-04-02 19:57:54 +05:30
return
}
// No need to login, redirect to the next page.
2014-04-05 20:52:14 +05:30
ctx.Redirect(next, codeRedirect)
2014-04-02 19:57:54 +05:30
}
2014-04-05 20:52:14 +05:30
func logout(t *oauth.Transport, ctx *middleware.Context) {
next := extractPath(ctx.Req.URL.Query().Get(keyNextPage))
ctx.Session.Delete(keyToken)
ctx.Redirect(next, codeRedirect)
2014-04-02 19:57:54 +05:30
}
2014-04-05 20:52:14 +05:30
func handleOAuth2Callback(t *oauth.Transport, ctx *middleware.Context) {
next := extractPath(ctx.Req.URL.Query().Get("state"))
code := ctx.Req.URL.Query().Get("code")
2014-04-02 19:57:54 +05:30
tk, err := t.Exchange(code)
if err != nil {
// Pass the error message, or allow dev to provide its own
// error handler.
2014-04-05 20:52:14 +05:30
ctx.Redirect(PathError, codeRedirect)
2014-04-02 19:57:54 +05:30
return
}
// Store the credentials in the session.
val, _ := json.Marshal(tk)
2014-04-05 20:52:14 +05:30
ctx.Session.Set(keyToken, val)
ctx.Redirect(next, codeRedirect)
2014-04-02 19:57:54 +05:30
}
2014-04-05 20:52:14 +05:30
func unmarshallToken(s session.SessionStore) (t *token) {
2014-04-02 19:57:54 +05:30
if s.Get(keyToken) == nil {
return
}
data := s.Get(keyToken).([]byte)
var tk oauth.Token
json.Unmarshal(data, &tk)
return &token{tk}
}
func extractPath(next string) string {
n, err := url.Parse(next)
if err != nil {
return "/"
}
return n.Path
}