whatcanGOwrong

go/pkg/mod/golang.org/x/tools@v0.17.0/cmd/auth/authtest/authtest.go

@@ -0,0 +1,231 @@
+// Copyright 2019 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.
+
+// authtest is a diagnostic tool for implementations of the GOAUTH protocol
+// described in https://golang.org/issue/26232.
+//
+// It accepts a single URL as an argument, and executes the GOAUTH protocol to
+// fetch and display the headers for that URL.
+//
+// CAUTION: authtest logs the GOAUTH responses, which may include user
+// credentials, to stderr. Do not post its output unless you are certain that
+// all of the credentials involved are fake!
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/textproto"
+	"net/url"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+var v = flag.Bool("v", false, "if true, log GOAUTH responses to stderr")
+
+func main() {
+	log.SetFlags(log.LstdFlags | log.Lshortfile)
+	flag.Parse()
+	args := flag.Args()
+	if len(args) != 1 {
+		log.Fatalf("usage: [GOAUTH=CMD...] %s URL", filepath.Base(os.Args[0]))
+	}
+
+	resp := try(args[0], nil)
+	if resp.StatusCode == http.StatusOK {
+		return
+	}
+
+	resp = try(args[0], resp)
+	if resp.StatusCode != http.StatusOK {
+		os.Exit(1)
+	}
+}
+
+func try(url string, prev *http.Response) *http.Response {
+	req := new(http.Request)
+	if prev != nil {
+		*req = *prev.Request
+	} else {
+		var err error
+		req, err = http.NewRequest("HEAD", os.Args[1], nil)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+goauth:
+	for _, argList := range strings.Split(os.Getenv("GOAUTH"), ";") {
+		// TODO(golang.org/issue/26849): If we escape quoted strings in GOFLAGS, use
+		// the same quoting here.
+		args := strings.Split(argList, " ")
+		if len(args) == 0 || args[0] == "" {
+			log.Fatalf("invalid or empty command in GOAUTH")
+		}
+
+		creds, err := getCreds(args, prev)
+		if err != nil {
+			log.Fatal(err)
+		}
+		for _, c := range creds {
+			if c.Apply(req) {
+				fmt.Fprintf(os.Stderr, "# request to %s\n", req.URL)
+				fmt.Fprintf(os.Stderr, "%s %s %s\n", req.Method, req.URL, req.Proto)
+				req.Header.Write(os.Stderr)
+				fmt.Fprintln(os.Stderr)
+				break goauth
+			}
+		}
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK && resp.StatusCode < 400 || resp.StatusCode > 500 {
+		log.Fatalf("unexpected status: %v", resp.Status)
+	}
+
+	fmt.Fprintf(os.Stderr, "# response from %s\n", resp.Request.URL)
+	formatHead(os.Stderr, resp)
+	return resp
+}
+
+func formatHead(out io.Writer, resp *http.Response) {
+	fmt.Fprintf(out, "%s %s\n", resp.Proto, resp.Status)
+	if err := resp.Header.Write(out); err != nil {
+		log.Fatal(err)
+	}
+	fmt.Fprintln(out)
+}
+
+type Cred struct {
+	URLPrefixes []*url.URL
+	Header      http.Header
+}
+
+func (c Cred) Apply(req *http.Request) bool {
+	if req.URL == nil {
+		return false
+	}
+	ok := false
+	for _, prefix := range c.URLPrefixes {
+		if prefix.Host == req.URL.Host &&
+			(req.URL.Path == prefix.Path ||
+				(strings.HasPrefix(req.URL.Path, prefix.Path) &&
+					(strings.HasSuffix(prefix.Path, "/") ||
+						req.URL.Path[len(prefix.Path)] == '/'))) {
+			ok = true
+			break
+		}
+	}
+	if !ok {
+		return false
+	}
+
+	for k, vs := range c.Header {
+		req.Header.Del(k)
+		for _, v := range vs {
+			req.Header.Add(k, v)
+		}
+	}
+	return true
+}
+
+func (c Cred) String() string {
+	var buf strings.Builder
+	for _, u := range c.URLPrefixes {
+		fmt.Fprintln(&buf, u)
+	}
+	buf.WriteString("\n")
+	c.Header.Write(&buf)
+	buf.WriteString("\n")
+	return buf.String()
+}
+
+func getCreds(args []string, resp *http.Response) ([]Cred, error) {
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Stderr = os.Stderr
+
+	if resp != nil {
+		u := *resp.Request.URL
+		u.RawQuery = ""
+		cmd.Args = append(cmd.Args, u.String())
+	}
+
+	var head strings.Builder
+	if resp != nil {
+		formatHead(&head, resp)
+	}
+	cmd.Stdin = strings.NewReader(head.String())
+
+	fmt.Fprintf(os.Stderr, "# %s\n", strings.Join(cmd.Args, " "))
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("%s: %v", strings.Join(cmd.Args, " "), err)
+	}
+	os.Stderr.Write(out)
+	os.Stderr.WriteString("\n")
+
+	var creds []Cred
+	r := textproto.NewReader(bufio.NewReader(bytes.NewReader(out)))
+	line := 0
+readLoop:
+	for {
+		var prefixes []*url.URL
+		for {
+			prefix, err := r.ReadLine()
+			if err == io.EOF {
+				if len(prefixes) > 0 {
+					return nil, fmt.Errorf("line %d: %v", line, io.ErrUnexpectedEOF)
+				}
+				break readLoop
+			}
+			line++
+
+			if prefix == "" {
+				if len(prefixes) == 0 {
+					return nil, fmt.Errorf("line %d: unexpected newline", line)
+				}
+				break
+			}
+			u, err := url.Parse(prefix)
+			if err != nil {
+				return nil, fmt.Errorf("line %d: malformed URL: %v", line, err)
+			}
+			if u.Scheme != "https" {
+				return nil, fmt.Errorf("line %d: non-HTTPS URL %q", line, prefix)
+			}
+			if len(u.RawQuery) > 0 {
+				return nil, fmt.Errorf("line %d: unexpected query string in URL %q", line, prefix)
+			}
+			if len(u.Fragment) > 0 {
+				return nil, fmt.Errorf("line %d: unexpected fragment in URL %q", line, prefix)
+			}
+			prefixes = append(prefixes, u)
+		}
+
+		header, err := r.ReadMIMEHeader()
+		if err != nil {
+			return nil, fmt.Errorf("headers at line %d: %v", line, err)
+		}
+		if len(header) > 0 {
+			creds = append(creds, Cred{
+				URLPrefixes: prefixes,
+				Header:      http.Header(header),
+			})
+		}
+	}
+
+	return creds, nil
+}

go/pkg/mod/golang.org/x/tools@v0.17.0/cmd/auth/cookieauth/cookieauth.go

@@ -0,0 +1,166 @@
+// Copyright 2019 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.
+
+// cookieauth uses a “Netscape cookie file” to implement the GOAUTH protocol
+// described in https://golang.org/issue/26232.
+// It expects the location of the file as the first command-line argument.
+//
+// Example GOAUTH usage:
+//
+//	export GOAUTH="cookieauth $(git config --get http.cookieFile)"
+//
+// See http://www.cookiecentral.com/faq/#3.5 for a description of the Netscape
+// cookie file format.
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+)
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintf(os.Stderr, "usage: %s COOKIEFILE [URL]\n", os.Args[0])
+		os.Exit(2)
+	}
+
+	log.SetPrefix("cookieauth: ")
+
+	f, err := os.Open(os.Args[1])
+	if err != nil {
+		log.Fatalf("failed to read cookie file: %v\n", os.Args[1])
+	}
+	defer f.Close()
+
+	var (
+		targetURL  *url.URL
+		targetURLs = map[string]*url.URL{}
+	)
+	if len(os.Args) == 3 {
+		targetURL, err = url.ParseRequestURI(os.Args[2])
+		if err != nil {
+			log.Fatalf("invalid request URI (%v): %q\n", err, os.Args[2])
+		}
+		targetURLs[targetURL.String()] = targetURL
+	} else if len(os.Args) > 3 {
+		// Extra arguments were passed: maybe the protocol was expanded?
+		// We don't know how to interpret the request, so ignore it.
+		return
+	}
+
+	entries, err := parseCookieFile(f.Name(), f)
+	if err != nil {
+		log.Fatalf("error reading cookie file: %v\n", f.Name())
+	}
+
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		log.Fatalf("failed to initialize cookie jar: %v\n", err)
+	}
+
+	for _, e := range entries {
+		u := &url.URL{
+			Scheme: "https",
+			Host:   e.Host,
+			Path:   e.Cookie.Path,
+		}
+
+		if targetURL == nil {
+			targetURLs[u.String()] = u
+		}
+
+		jar.SetCookies(u, []*http.Cookie{&e.Cookie})
+	}
+
+	for _, u := range targetURLs {
+		req := &http.Request{URL: u, Header: make(http.Header)}
+		for _, c := range jar.Cookies(req.URL) {
+			req.AddCookie(c)
+		}
+		fmt.Printf("%s\n\n", u)
+		req.Header.Write(os.Stdout)
+		fmt.Println()
+	}
+}
+
+type Entry struct {
+	Host   string
+	Cookie http.Cookie
+}
+
+// parseCookieFile parses a Netscape cookie file as described in
+// http://www.cookiecentral.com/faq/#3.5.
+func parseCookieFile(name string, r io.Reader) ([]*Entry, error) {
+	var entries []*Entry
+	s := bufio.NewScanner(r)
+	line := 0
+	for s.Scan() {
+		line++
+		text := strings.TrimSpace(s.Text())
+		if len(text) < 2 || (text[0] == '#' && unicode.IsSpace(rune(text[1]))) {
+			continue
+		}
+
+		e, err := parseCookieLine(text)
+		if err != nil {
+			log.Printf("%s:%d: %v\n", name, line, err)
+			continue
+		}
+		entries = append(entries, e)
+	}
+	return entries, s.Err()
+}
+
+func parseCookieLine(line string) (*Entry, error) {
+	f := strings.Fields(line)
+	if len(f) < 7 {
+		return nil, fmt.Errorf("found %d columns; want 7", len(f))
+	}
+
+	e := new(Entry)
+	c := &e.Cookie
+
+	if domain := f[0]; strings.HasPrefix(domain, "#HttpOnly_") {
+		c.HttpOnly = true
+		e.Host = strings.TrimPrefix(domain[10:], ".")
+	} else {
+		e.Host = strings.TrimPrefix(domain, ".")
+	}
+
+	isDomain, err := strconv.ParseBool(f[1])
+	if err != nil {
+		return nil, fmt.Errorf("non-boolean domain flag: %v", err)
+	}
+	if isDomain {
+		c.Domain = e.Host
+	}
+
+	c.Path = f[2]
+
+	c.Secure, err = strconv.ParseBool(f[3])
+	if err != nil {
+		return nil, fmt.Errorf("non-boolean secure flag: %v", err)
+	}
+
+	expiration, err := strconv.ParseInt(f[4], 10, 64)
+	if err != nil {
+		return nil, fmt.Errorf("malformed expiration: %v", err)
+	}
+	c.Expires = time.Unix(expiration, 0)
+
+	c.Name = f[5]
+	c.Value = f[6]
+
+	return e, nil
+}

go/pkg/mod/golang.org/x/tools@v0.17.0/cmd/auth/gitauth/gitauth.go

@@ -0,0 +1,150 @@
+// Copyright 2019 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.
+
+// gitauth uses 'git credential' to implement the GOAUTH protocol described in
+// https://golang.org/issue/26232. It expects an absolute path to the working
+// directory for the 'git' command as the first command-line argument.
+//
+// Example GOAUTH usage:
+//
+//	export GOAUTH="gitauth $HOME"
+//
+// See https://git-scm.com/docs/gitcredentials or run 'man gitcredentials' for
+// information on how to configure 'git credential'.
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+func main() {
+	if len(os.Args) < 2 || !filepath.IsAbs(os.Args[1]) {
+		fmt.Fprintf(os.Stderr, "usage: %s WORKDIR [URL]", os.Args[0])
+		os.Exit(2)
+	}
+
+	log.SetPrefix("gitauth: ")
+
+	if len(os.Args) != 3 {
+		// No explicit URL was passed on the command line, but 'git credential'
+		// provides no way to enumerate existing credentials.
+		// Wait for a request for a specific URL.
+		return
+	}
+
+	u, err := url.ParseRequestURI(os.Args[2])
+	if err != nil {
+		log.Fatalf("invalid request URI (%v): %q\n", err, os.Args[1])
+	}
+
+	var (
+		prefix     *url.URL
+		lastHeader http.Header
+		lastStatus = http.StatusUnauthorized
+	)
+	for lastStatus == http.StatusUnauthorized {
+		cmd := exec.Command("git", "credential", "fill")
+
+		// We don't want to execute a 'git' command in an arbitrary directory, since
+		// that opens up a number of config-injection attacks (for example,
+		// https://golang.org/issue/29230). Instead, we have the user configure a
+		// directory explicitly on the command line.
+		cmd.Dir = os.Args[1]
+
+		cmd.Stdin = strings.NewReader(fmt.Sprintf("url=%s\n", u))
+		cmd.Stderr = os.Stderr
+		out, err := cmd.Output()
+		if err != nil {
+			log.Fatalf("'git credential fill' failed: %v\n", err)
+		}
+
+		prefix = new(url.URL)
+		var username, password string
+		lines := strings.Split(string(out), "\n")
+		for _, line := range lines {
+			frags := strings.SplitN(line, "=", 2)
+			if len(frags) != 2 {
+				continue // Ignore unrecognized response lines.
+			}
+			switch strings.TrimSpace(frags[0]) {
+			case "protocol":
+				prefix.Scheme = frags[1]
+			case "host":
+				prefix.Host = frags[1]
+			case "path":
+				prefix.Path = frags[1]
+			case "username":
+				username = frags[1]
+			case "password":
+				password = frags[1]
+			case "url":
+				// Write to a local variable instead of updating prefix directly:
+				// if the url field is malformed, we don't want to invalidate
+				// information parsed from the protocol, host, and path fields.
+				u, err := url.ParseRequestURI(frags[1])
+				if err == nil {
+					prefix = u
+				} else {
+					log.Printf("malformed URL from 'git credential fill' (%v): %q\n", err, frags[1])
+					// Proceed anyway: we might be able to parse the prefix from other fields of the response.
+				}
+			}
+		}
+
+		// Double-check that the URL Git gave us is a prefix of the one we requested.
+		if !strings.HasPrefix(u.String(), prefix.String()) {
+			log.Fatalf("requested a credential for %q, but 'git credential fill' provided one for %q\n", u, prefix)
+		}
+
+		// Send a HEAD request to try to detect whether the credential is valid.
+		// If the user just typed in a correct password and has caching enabled,
+		// we don't want to nag them for it again the next time they run a 'go' command.
+		req, err := http.NewRequest("HEAD", u.String(), nil)
+		if err != nil {
+			log.Fatalf("internal error constructing HTTP HEAD request: %v\n", err)
+		}
+		req.SetBasicAuth(username, password)
+		lastHeader = req.Header
+		resp, err := http.DefaultClient.Do(req)
+		if err != nil {
+			log.Printf("HTTPS HEAD request failed to connect: %v\n", err)
+			// Couldn't verify the credential, but we have no evidence that it is invalid either.
+			// Proceed, but don't update git's credential cache.
+			break
+		}
+		lastStatus = resp.StatusCode
+
+		if resp.StatusCode != http.StatusOK {
+			log.Printf("%s: %v %s\n", u, resp.StatusCode, http.StatusText(resp.StatusCode))
+		}
+
+		if resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusUnauthorized {
+			// We learned something about the credential: it either worked or it was invalid.
+			// Approve or reject the credential (on a best-effort basis)
+			// so that the git credential helper can update its cache as appropriate.
+			action := "approve"
+			if resp.StatusCode != http.StatusOK {
+				action = "reject"
+			}
+			cmd = exec.Command("git", "credential", action)
+			cmd.Stderr = os.Stderr
+			cmd.Stdout = os.Stderr
+			cmd.Stdin = bytes.NewReader(out)
+			_ = cmd.Run()
+		}
+	}
+
+	// Write out the credential in the format expected by the 'go' command.
+	fmt.Printf("%s\n\n", prefix)
+	lastHeader.Write(os.Stdout)
+	fmt.Println()
+}

go/pkg/mod/golang.org/x/tools@v0.17.0/cmd/auth/netrcauth/netrcauth.go

@@ -0,0 +1,123 @@
+// Copyright 2018 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.
+
+// netrcauth uses a .netrc file (or _netrc file on Windows) to implement the
+// GOAUTH protocol described in https://golang.org/issue/26232.
+// It expects the location of the file as the first command-line argument.
+//
+// Example GOAUTH usage:
+//
+//	export GOAUTH="netrcauth $HOME/.netrc"
+//
+// See https://www.gnu.org/software/inetutils/manual/html_node/The-_002enetrc-file.html
+// or run 'man 5 netrc' for a description of the .netrc file format.
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+)
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintf(os.Stderr, "usage: %s NETRCFILE [URL]", os.Args[0])
+		os.Exit(2)
+	}
+
+	log.SetPrefix("netrcauth: ")
+
+	if len(os.Args) != 2 {
+		// An explicit URL was passed on the command line, but netrcauth does not
+		// have any URL-specific output: it dumps the entire .netrc file at the
+		// first call.
+		return
+	}
+
+	path := os.Args[1]
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return
+		}
+		log.Fatalf("failed to read %s: %v\n", path, err)
+	}
+
+	u := &url.URL{Scheme: "https"}
+	lines := parseNetrc(string(data))
+	for _, l := range lines {
+		u.Host = l.machine
+		fmt.Printf("%s\n\n", u)
+
+		req := &http.Request{Header: make(http.Header)}
+		req.SetBasicAuth(l.login, l.password)
+		req.Header.Write(os.Stdout)
+		fmt.Println()
+	}
+}
+
+// The following functions were extracted from src/cmd/go/internal/web2/web.go
+// as of https://golang.org/cl/161698.
+
+type netrcLine struct {
+	machine  string
+	login    string
+	password string
+}
+
+func parseNetrc(data string) []netrcLine {
+	// See https://www.gnu.org/software/inetutils/manual/html_node/The-_002enetrc-file.html
+	// for documentation on the .netrc format.
+	var nrc []netrcLine
+	var l netrcLine
+	inMacro := false
+	for _, line := range strings.Split(data, "\n") {
+		if inMacro {
+			if line == "" {
+				inMacro = false
+			}
+			continue
+		}
+
+		f := strings.Fields(line)
+		i := 0
+		for ; i < len(f)-1; i += 2 {
+			// Reset at each "machine" token.
+			// “The auto-login process searches the .netrc file for a machine token
+			// that matches […]. Once a match is made, the subsequent .netrc tokens
+			// are processed, stopping when the end of file is reached or another
+			// machine or a default token is encountered.”
+			switch f[i] {
+			case "machine":
+				l = netrcLine{machine: f[i+1]}
+			case "default":
+				break
+			case "login":
+				l.login = f[i+1]
+			case "password":
+				l.password = f[i+1]
+			case "macdef":
+				// “A macro is defined with the specified name; its contents begin with
+				// the next .netrc line and continue until a null line (consecutive
+				// new-line characters) is encountered.”
+				inMacro = true
+			}
+			if l.machine != "" && l.login != "" && l.password != "" {
+				nrc = append(nrc, l)
+				l = netrcLine{}
+			}
+		}
+
+		if i < len(f) && f[i] == "default" {
+			// “There can be only one default token, and it must be after all machine tokens.”
+			break
+		}
+	}
+
+	return nrc
+}