blob: 7afad05c4eb67e73cdab9a9dee2c88615ba4016d [file] [log] [blame]
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package gerrit
import (
"bytes"
"crypto/md5"
"encoding/hex"
"fmt"
"io/ioutil"
"net/http"
"net/http/cookiejar"
"net/url"
"os"
"os/exec"
"path/filepath"
"runtime"
"strconv"
"strings"
"sync"
"time"
"golang.org/x/oauth2"
)
// Auth is a Gerrit authentication mode.
// The most common ones are NoAuth or BasicAuth.
type Auth interface {
setAuth(*Client, *http.Request) error
}
// BasicAuth sends a username and password.
func BasicAuth(username, password string) Auth {
return basicAuth{username, password}
}
type basicAuth struct {
username, password string
}
func (ba basicAuth) setAuth(c *Client, r *http.Request) error {
r.SetBasicAuth(ba.username, ba.password)
return nil
}
// GitCookiesAuth derives the Gerrit authentication token from
// gitcookies based on the URL of the Gerrit request.
// The cookie file used is determined by running "git config
// http.cookiefile" in the current directory.
// To use a specific file, see GitCookieFileAuth.
func GitCookiesAuth() Auth {
return gitCookiesAuth{}
}
// GitCookieFileAuth derives the Gerrit authentication token from the
// provided gitcookies file. It is equivalent to GitCookiesAuth,
// except that "git config http.cookiefile" is not used to find which
// cookie file to use.
func GitCookieFileAuth(file string) Auth {
return &gitCookieFileAuth{file: file}
}
func netrcPath() string {
if runtime.GOOS == "windows" {
return filepath.Join(os.Getenv("USERPROFILE"), "_netrc")
}
return filepath.Join(os.Getenv("HOME"), ".netrc")
}
type gitCookiesAuth struct{}
func (gitCookiesAuth) setAuth(c *Client, r *http.Request) error {
// First look in Git's http.cookiefile, which is where Gerrit
// now tells users to store this information.
git := exec.Command("git", "config", "http.cookiefile")
git.Stderr = os.Stderr
// Ignore a failure here, git will exit(1) if no cookies are
// present and prevent the netrc from being read below.
gitOut, _ := git.Output()
cookieFile := strings.TrimSpace(string(gitOut))
if len(cookieFile) != 0 {
auth := &gitCookieFileAuth{file: cookieFile}
if err := auth.setAuth(c, r); err != nil {
return err
}
if len(r.Header["Cookie"]) > 0 {
return nil
}
}
url, err := url.Parse(c.url)
if err != nil {
return err
}
// If not there, then look in $HOME/.netrc, which is where Gerrit
// used to tell users to store the information, until the passwords
// got so long that old versions of curl couldn't handle them.
host := url.Host
netrc := netrcPath()
data, _ := ioutil.ReadFile(netrc)
for _, line := range strings.Split(string(data), "\n") {
if i := strings.Index(line, "#"); i >= 0 {
line = line[:i]
}
f := strings.Fields(line)
if len(f) >= 6 && f[0] == "machine" && f[1] == host && f[2] == "login" && f[4] == "password" {
r.SetBasicAuth(f[3], f[5])
return nil
}
}
return fmt.Errorf("no authentication configured for Gerrit; tried both git config http.cookiefile and %s", netrc)
}
type gitCookieFileAuth struct {
file string
once sync.Once
jar *cookiejar.Jar
err error
}
func (a *gitCookieFileAuth) loadCookieFileOnce() {
data, err := ioutil.ReadFile(a.file)
if err != nil {
a.err = fmt.Errorf("Error loading cookie file: %v", err)
return
}
a.jar = parseGitCookies(string(data))
}
func (a *gitCookieFileAuth) setAuth(c *Client, r *http.Request) error {
a.once.Do(a.loadCookieFileOnce)
if a.err != nil {
return a.err
}
url, err := url.Parse(c.url)
if err != nil {
return err
}
for _, cookie := range a.jar.Cookies(url) {
r.AddCookie(cookie)
}
return nil
}
func parseGitCookies(data string) *cookiejar.Jar {
jar, _ := cookiejar.New(nil)
for _, line := range strings.Split(data, "\n") {
f := strings.Split(line, "\t")
if len(f) < 7 {
continue
}
expires, err := strconv.ParseInt(f[4], 10, 64)
if err != nil {
continue
}
c := http.Cookie{
Domain: f[0],
Path: f[2],
Secure: f[3] == "TRUE",
Expires: time.Unix(expires, 0),
Name: f[5],
Value: f[6],
}
// Construct a fake URL to add c to the jar.
url := url.URL{
Scheme: "http",
Host: c.Domain,
Path: c.Path,
}
jar.SetCookies(&url, []*http.Cookie{&c})
}
return jar
}
// Scopes to use when creating a TokenSource.
var OAuth2Scopes = []string{
"https://www.googleapis.com/auth/cloud-platform",
"https://www.googleapis.com/auth/gerritcodereview",
"https://www.googleapis.com/auth/source.full_control",
"https://www.googleapis.com/auth/source.read_write",
"https://www.googleapis.com/auth/source.read_only",
}
// OAuth2Auth uses the given TokenSource to authenticate requests.
func OAuth2Auth(src oauth2.TokenSource) Auth {
return oauth2Auth{src}
}
type oauth2Auth struct {
src oauth2.TokenSource
}
func (a oauth2Auth) setAuth(c *Client, r *http.Request) error {
token, err := a.src.Token()
if err != nil {
return err
}
token.SetAuthHeader(r)
return nil
}
// NoAuth makes requests unauthenticated.
var NoAuth = noAuth{}
type noAuth struct{}
func (noAuth) setAuth(c *Client, r *http.Request) error {
return nil
}
type digestAuth struct {
Username, Password, Realm, NONCE, QOP, Opaque, Algorithm string
}
func getDigestAuth(username, password string, resp *http.Response) *digestAuth {
header := resp.Header.Get("www-authenticate")
parts := strings.SplitN(header, " ", 2)
parts = strings.Split(parts[1], ", ")
opts := make(map[string]string)
for _, part := range parts {
vals := strings.SplitN(part, "=", 2)
key := vals[0]
val := strings.Trim(vals[1], "\",")
opts[key] = val
}
auth := digestAuth{
username, password,
opts["realm"], opts["nonce"], opts["qop"], opts["opaque"], opts["algorithm"],
}
return &auth
}
func setDigestAuth(r *http.Request, username, password string, resp *http.Response, nc int) {
auth := getDigestAuth(username, password, resp)
authStr := getDigestAuthString(auth, r.URL, r.Method, nc)
r.Header.Add("Authorization", authStr)
}
func getDigestAuthString(auth *digestAuth, url *url.URL, method string, nc int) string {
var buf bytes.Buffer
h := md5.New()
fmt.Fprintf(&buf, "%s:%s:%s", auth.Username, auth.Realm, auth.Password)
buf.WriteTo(h)
ha1 := hex.EncodeToString(h.Sum(nil))
h = md5.New()
fmt.Fprintf(&buf, "%s:%s", method, url.Path)
buf.WriteTo(h)
ha2 := hex.EncodeToString(h.Sum(nil))
ncStr := fmt.Sprintf("%08x", nc)
hnc := "MTM3MDgw"
h = md5.New()
fmt.Fprintf(&buf, "%s:%s:%s:%s:%s:%s", ha1, auth.NONCE, ncStr, hnc, auth.QOP, ha2)
buf.WriteTo(h)
respdig := hex.EncodeToString(h.Sum(nil))
buf.Write([]byte("Digest "))
fmt.Fprintf(&buf,
`username="%s", realm="%s", nonce="%s", uri="%s", response="%s"`,
auth.Username, auth.Realm, auth.NONCE, url.Path, respdig,
)
if auth.Opaque != "" {
fmt.Fprintf(&buf, `, opaque="%s"`, auth.Opaque)
}
if auth.QOP != "" {
fmt.Fprintf(&buf, `, qop="%s", nc=%s, cnonce="%s"`, auth.QOP, ncStr, hnc)
}
if auth.Algorithm != "" {
fmt.Fprintf(&buf, `, algorithm="%s"`, auth.Algorithm)
}
return buf.String()
}
func (a digestAuth) setAuth(c *Client, r *http.Request) error {
resp, err := http.Get(r.URL.String())
if err != nil {
return err
}
setDigestAuth(r, a.Username, a.Password, resp, 1)
return nil
}
// DigestAuth returns an Auth implementation which sends
// the provided username and password using HTTP Digest Authentication
// (RFC 2617)
func DigestAuth(username, password string) Auth {
return digestAuth{
Username: username,
Password: password,
}
}