go-mockid/mockid/mockid.go

package mockid

import (
	"crypto/ecdsa"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"crypto/sha512"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"math/big"
	"net/http"
	"net/url"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"git.rootprojects.org/root/keypairs"
	"git.rootprojects.org/root/keypairs/keyfetch"
	//jwt "github.com/dgrijalva/jwt-go"
)

type PublicJWK struct {
	Crv   string `json:"crv"`
	KeyID string `json:"kid,omitempty"`
	Kty   string `json:"kty,omitempty"`
	X     string `json:"x"`
	Y     string `json:"y"`
}

type InspectableToken struct {
	Public    keypairs.PublicKey     `json:"public"`
	Protected map[string]interface{} `json:"protected"`
	Payload   map[string]interface{} `json:"payload"`
	Signature string                 `json:"signature"`
	Verified  bool                   `json:"verified"`
	Errors    []string               `json:"errors"`
}

func (t *InspectableToken) MarshalJSON() ([]byte, error) {
	pub := keypairs.MarshalJWKPublicKey(t.Public)
	header, _ := json.Marshal(t.Protected)
	payload, _ := json.Marshal(t.Payload)
	errs, _ := json.Marshal(t.Errors)
	return []byte(fmt.Sprintf(
		`{"public":%s,"protected":%s,"payload":%s,"signature":%q,"verified":%t,"errors":%s}`,
		pub, header, payload, t.Signature, t.Verified, errs,
	)), nil
}

var nonces map[string]int64

func init() {
	nonces = make(map[string]int64)
}

func Route(jwksPrefix string, privkey keypairs.PrivateKey) {
	pubkey := keypairs.NewPublicKey(privkey.Public())

	http.HandleFunc("/api/new-nonce", func(w http.ResponseWriter, r *http.Request) {
		baseURL := getBaseURL(r)
		/*
			res.statusCode = 200;
			res.setHeader("Cache-Control", "max-age=0, no-cache, no-store");
			// TODO
			//res.setHeader("Date", "Sun, 10 Mar 2019 08:04:45 GMT");
			// is this the expiration of the nonce itself? methinks maybe so
			//res.setHeader("Expires", "Sun, 10 Mar 2019 08:04:45 GMT");
			// TODO use one of the registered domains
			//var indexUrl = "https://acme-staging-v02.api.letsencrypt.org/index"
		*/
		//var port = (state.config.ipc && state.config.ipc.port || state._ipc.port || undefined);
		//var indexUrl = "http://localhost:" + port + "/index";
		indexUrl := baseURL + "/index"
		w.Header().Set("Link", "<"+indexUrl+">;rel=\"index\"")
		w.Header().Set("Cache-Control", "max-age=0, no-cache, no-store")
		w.Header().Set("Pragma", "no-cache")
		//res.setHeader("Strict-Transport-Security", "max-age=604800");

		w.Header().Set("X-Frame-Options", "DENY")
		issueNonce(w, r)
	})

	http.HandleFunc("/api/new-account", requireNonce(func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, "Not Implemented", http.StatusNotImplemented)
	}))

	http.HandleFunc("/api/jwks", func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s %s", r.Method, r.Host, r.URL.Path)
		if "POST" != r.Method {
			http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
			return
		}

		tok := make(map[string]interface{})
		decoder := json.NewDecoder(r.Body)
		err := decoder.Decode(&tok)
		if nil != err {
			http.Error(w, "Bad Request: invalid json", http.StatusBadRequest)
			return
		}
		defer r.Body.Close()

		// TODO better, JSON error messages
		if _, ok := tok["d"]; ok {
			http.Error(w, "Bad Request: private key", http.StatusBadRequest)
			return
		}

		kty, _ := tok["kty"].(string)
		switch kty {
		case "EC":
			postEC(jwksPrefix, tok, w, r)
		case "RSA":
			postRSA(jwksPrefix, tok, w, r)
		default:
			http.Error(w, "Bad Request: only EC and RSA keys are supported", http.StatusBadRequest)
			return
		}
	})

	http.HandleFunc("/access_token", func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s\n", r.Method, r.URL.Path)
		_, _, token := GenToken(getBaseURL(r), privkey, r.URL.Query())
		fmt.Fprintf(w, token)
	})

	http.HandleFunc("/inspect_token", func(w http.ResponseWriter, r *http.Request) {
		token := r.Header.Get("Authorization")
		log.Printf("%s %s %s\n", r.Method, r.URL.Path, token)

		if "" == token {
			token = r.URL.Query().Get("access_token")
			if "" == token {
				http.Error(w, "Bad Format: missing Authorization header and 'access_token' query", http.StatusBadRequest)
				return
			}
		} else {
			parts := strings.Split(token, " ")
			if 2 != len(parts) {
				http.Error(w, "Bad Format: expected Authorization header to be in the format of 'Bearer <Token>'", http.StatusBadRequest)
				return
			}
			token = parts[1]
		}

		parts := strings.Split(token, ".")
		if 3 != len(parts) {
			http.Error(w, "Bad Format: token should be in the format of <protected-header>.<payload>.<signature>", http.StatusBadRequest)
			return
		}
		protected64 := parts[0]
		data64 := parts[1]
		signature64 := parts[2]

		protectedB, err := base64.RawURLEncoding.DecodeString(protected64)
		if nil != err {
			http.Error(w, "Bad Format: token's header should be URL-safe base64 encoded", http.StatusBadRequest)
			return
		}
		dataB, err := base64.RawURLEncoding.DecodeString(data64)
		if nil != err {
			http.Error(w, "Bad Format: token's payload should be URL-safe base64 encoded", http.StatusBadRequest)
			return
		}
		// TODO verify signature
		_, err = base64.RawURLEncoding.DecodeString(signature64)
		if nil != err {
			http.Error(w, "Bad Format: token's signature should be URL-safe base64 encoded", http.StatusBadRequest)
			return
		}

		errors := []string{}

		protected := map[string]interface{}{}
		err = json.Unmarshal(protectedB, &protected)
		if nil != err {
			http.Error(w, "Bad Format: token's header should be URL-safe base64-encoded JSON", http.StatusBadRequest)
			return
		}
		kid, kidOK := protected["kid"].(string)
		// TODO parse jwkM
		_, jwkOK := protected["jwk"]
		if !kidOK && !jwkOK {
			errors = append(errors, "must have either header.kid or header.jwk")
		}

		data := map[string]interface{}{}
		err = json.Unmarshal(dataB, &data)
		if nil != err {
			http.Error(w, "Bad Format: token's payload should be URL-safe base64-encoded JSON", http.StatusBadRequest)
			return
		}
		iss, issOK := data["iss"].(string)
		if !jwkOK && !issOK {
			errors = append(errors, "payload.iss must exist to complement header.kid")
		}

		pub, err := keyfetch.OIDCJWK(kid, iss)
		if nil != err {
			fmt.Println("couldn't fetch pub key:")
			fmt.Println(err)
		}
		fmt.Println("fetched pub key:")
		fmt.Println(pub)

		inspected := &InspectableToken{
			Public:    pub,
			Protected: protected,
			Payload:   data,
			Signature: signature64,
			Verified:  false,
			Errors:    errors,
		}

		tokenB, err := json.MarshalIndent(inspected, "", "    ")
		if nil != err {
			fmt.Println("couldn't serialize inpsected token:")
			fmt.Println(err)
		}
		fmt.Println("serialized inpsected token")
		fmt.Println(inspected)
		fmt.Println(string(tokenB))
		fmt.Fprintf(w, string(tokenB))
	})

	http.HandleFunc("/authorization_header", func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s\n", r.Method, r.URL.Path)

		var header string
		headers, _ := r.URL.Query()["header"]
		if 0 == len(headers) {
			header = "Authorization"
		} else {
			header = headers[0]
		}

		var prefix string
		prefixes, _ := r.URL.Query()["prefix"]
		if 0 == len(prefixes) {
			prefix = "Bearer "
		} else {
			prefix = prefixes[0]
		}

		_, _, token := GenToken(getBaseURL(r), privkey, r.URL.Query())
		fmt.Fprintf(w, "%s: %s%s", header, prefix, token)
	})

	http.HandleFunc("/key.jwk.json", func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s", r.Method, r.URL.Path)
		jwk := string(MarshalJWKPrivateKey(privkey))
		jwk = strings.Replace(jwk, `{"`, `{ "`, 1)
		jwk = strings.Replace(jwk, `",`, `", `, -1)
		jwk = jwk[0 : len(jwk)-1]
		jwk = jwk + `, "ext": true , "key_ops": ["sign"] }`
		// `{ "kty": "EC" , "crv": %q , "d": %q , "x": %q , "y": %q }`, jwk.Crv, jwk.D, jwk.X, jwk.Y
		fmt.Fprintf(w, jwk)
	})

	http.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
		baseURL := getBaseURL(r)
		log.Printf("%s %s\n", r.Method, r.URL.Path)
		fmt.Fprintf(w, `{ "issuer": "%s", "jwks_uri": "%s/.well-known/jwks.json" }`, baseURL, baseURL)
	})

	http.HandleFunc("/.well-known/jwks.json", func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s %s", r.Method, r.Host, r.URL.Path)
		parts := strings.Split(r.Host, ".")
		kid := parts[0]

		b, err := ioutil.ReadFile(filepath.Join(jwksPrefix, strings.ToLower(kid)+".jwk.json"))
		if nil != err {
			//http.Error(w, "Not Found", http.StatusNotFound)
			exp := strconv.FormatInt(time.Now().Add(15*time.Minute).Unix(), 10)
			jwk := string(keypairs.MarshalJWKPublicKey(pubkey))
			jwk = strings.Replace(jwk, `{"`, `{ "`, 1)
			jwk = strings.Replace(jwk, `",`, `" ,`, -1)
			jwk = jwk[0 : len(jwk)-1]
			jwk = jwk + fmt.Sprintf(`, "ext": true , "key_ops": ["verify"], "exp": %s }`, exp)
			// { "kty": "EC" , "crv": %q , "x": %q , "y": %q , "kid": %q , "ext": true , "key_ops": ["verify"] , "exp": %s }
			jwkstr := fmt.Sprintf(`{ "keys": [ %s ] }`, jwk)
			fmt.Println(jwkstr)
			fmt.Fprintf(w, jwkstr)
			return
		}

		tok := &PublicJWK{}
		err = json.Unmarshal(b, tok)
		if nil != err {
			// TODO delete the bad file?
			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
			return
		}

		jwkstr := fmt.Sprintf(
			`{ "keys": [ { "kty": "EC", "crv": %q, "x": %q, "y": %q, "kid": %q,`+
				` "ext": true, "key_ops": ["verify"], "exp": %s } ] }`,
			tok.Crv, tok.X, tok.Y, tok.KeyID, strconv.FormatInt(time.Now().Add(15*time.Minute).Unix(), 10),
		)
		fmt.Println(jwkstr)
		fmt.Fprintf(w, jwkstr)
	})
}

func parseExp(exp string) (int, error) {
	if "" == exp {
		exp = "15m"
	}
	mult := 1
	switch exp[len(exp)-1] {
	case 'w':
		mult *= 7
		fallthrough
	case 'd':
		mult *= 24
		fallthrough
	case 'h':
		mult *= 60
		fallthrough
	case 'm':
		mult *= 60
		fallthrough
	case 's':
		// no fallthrough
	default:
		// could be 'k' or 'z', but we assume its empty
		exp += "s"
	}

	num, err := strconv.Atoi(exp[:len(exp)-1])
	if nil != err {
		return 0, err
	}
	return num * mult, nil
}

func postEC(jwksPrefix string, tok map[string]interface{}, w http.ResponseWriter, r *http.Request) {
	crv, ok := tok["crv"].(string)
	if 5 != len(crv) || "P-" != crv[:2] {
		http.Error(w, "Bad Request: bad curve", http.StatusBadRequest)
		return
	}
	x, ok := tok["x"].(string)
	if !ok {
		http.Error(w, "Bad Request: missing 'x'", http.StatusBadRequest)
		return
	}
	y, ok := tok["y"].(string)
	if !ok {
		http.Error(w, "Bad Request: missing 'y'", http.StatusBadRequest)
		return
	}

	thumbprintable := []byte(
		fmt.Sprintf(`{"crv":%q,"kty":"EC","x":%q,"y":%q}`, crv, x, y),
	)
	alg := crv[2:]

	var thumb []byte
	switch alg {
	case "256":
		hash := sha256.Sum256(thumbprintable)
		thumb = hash[:]
	case "384":
		hash := sha512.Sum384(thumbprintable)
		thumb = hash[:]
	case "521":
		fallthrough
	case "512":
		hash := sha512.Sum512(thumbprintable)
		thumb = hash[:]
	default:
		http.Error(w, "Bad Request: bad key length or curve", http.StatusBadRequest)
		return
	}

	kid := base64.RawURLEncoding.EncodeToString(thumb)
	if kid2, _ := tok["kid"].(string); "" != kid2 && kid != kid2 {
		http.Error(w, "Bad Request: kid should be "+kid, http.StatusBadRequest)
		return
	}

	pub := []byte(fmt.Sprintf(
		`{"crv":%q,"kid":%q,"kty":"EC","x":%q,"y":%q}`, crv, kid, x, y,
	))

	// TODO allow posting at the top-level?
	// TODO support a group of keys by PPID
	// (right now it's only by KID)
	if !strings.HasPrefix(r.Host, strings.ToLower(kid)+".") {
		http.Error(w, "Bad Request: prefix should be "+kid, http.StatusBadRequest)
		return
	}

	if err := ioutil.WriteFile(
		filepath.Join(jwksPrefix, strings.ToLower(kid)+".jwk.json"),
		pub,
		0644,
	); nil != err {
		fmt.Println("can't write file")
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}

	baseURL := getBaseURL(r)
	w.Write([]byte(fmt.Sprintf(
		`{ "iss":%q, "jwks_url":%q }`, baseURL+"/", baseURL+"/.well-known/jwks.json",
	)))
}

func postRSA(jwksPrefix string, tok map[string]interface{}, w http.ResponseWriter, r *http.Request) {
	e, ok := tok["e"].(string)
	if !ok {
		http.Error(w, "Bad Request: missing 'e'", http.StatusBadRequest)
		return
	}
	n, ok := tok["n"].(string)
	if !ok {
		http.Error(w, "Bad Request: missing 'n'", http.StatusBadRequest)
		return
	}

	thumbprintable := []byte(
		fmt.Sprintf(`{"e":%q,"kty":"RSA","n":%q}`, e, n),
	)

	var thumb []byte
	// TODO handle bit lengths well
	switch 3 * (len(n) / 4.0) {
	case 256:
		hash := sha256.Sum256(thumbprintable)
		thumb = hash[:]
	case 384:
		hash := sha512.Sum384(thumbprintable)
		thumb = hash[:]
	case 512:
		hash := sha512.Sum512(thumbprintable)
		thumb = hash[:]
	default:
		http.Error(w, "Bad Request: only standard RSA key lengths (2048, 3072, 4096) are supported", http.StatusBadRequest)
		return
	}

	kid := base64.RawURLEncoding.EncodeToString(thumb)
	if kid2, _ := tok["kid"].(string); "" != kid2 && kid != kid2 {
		http.Error(w, "Bad Request: kid should be "+kid, http.StatusBadRequest)
		return
	}

	pub := []byte(fmt.Sprintf(
		`{"e":%q,"kid":%q,"kty":"EC","n":%q}`, e, kid, n,
	))

	// TODO allow posting at the top-level?
	// TODO support a group of keys by PPID
	// (right now it's only by KID)
	if !strings.HasPrefix(r.Host, strings.ToLower(kid)+".") {
		http.Error(w, "Bad Request: prefix should be "+kid, http.StatusBadRequest)
		return
	}

	if err := ioutil.WriteFile(
		filepath.Join(jwksPrefix, strings.ToLower(kid)+".jwk.json"),
		pub,
		0644,
	); nil != err {
		fmt.Println("can't write file")
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}

	baseURL := getBaseURL(r)
	w.Write([]byte(fmt.Sprintf(
		`{ "iss":%q, "jwks_url":%q }`, baseURL+"/", baseURL+"/.well-known/jwks.json",
	)))
}

func GenToken(host string, privkey keypairs.PrivateKey, query url.Values) (string, string, string) {
	thumbprint := keypairs.ThumbprintPublicKey(keypairs.NewPublicKey(privkey.Public()))
	// TODO keypairs.Alg(key)
	alg := "ES256"
	switch privkey.(type) {
	case *rsa.PrivateKey:
		alg = "RS256"
	}
	protected := fmt.Sprintf(`{"typ":"JWT","alg":%q,"kid":"%s"}`, alg, thumbprint)
	protected64 := base64.RawURLEncoding.EncodeToString([]byte(protected))

	exp, err := parseExp(query.Get("exp"))
	if nil != err {
		// cryptic error code
		// TODO propagate error
		exp = 422
	}

	payload := fmt.Sprintf(
		`{"iss":"%s/","sub":"dummy","exp":%s}`,
		host, strconv.FormatInt(time.Now().Add(time.Duration(exp)*time.Second).Unix(), 10),
	)
	payload64 := base64.RawURLEncoding.EncodeToString([]byte(payload))

	hash := sha256.Sum256([]byte(fmt.Sprintf(`%s.%s`, protected64, payload64)))
	sig := JOSESign(privkey, hash[:])
	sig64 := base64.RawURLEncoding.EncodeToString(sig)
	token := fmt.Sprintf("%s.%s.%s\n", protected64, payload64, sig64)
	return protected, payload, token
}

// TODO: move to keypairs

func JOSESign(privkey keypairs.PrivateKey, hash []byte) []byte {
	var sig []byte

	switch k := privkey.(type) {
	case *rsa.PrivateKey:
		panic("TODO: implement rsa sign")
	case *ecdsa.PrivateKey:
		r, s, _ := ecdsa.Sign(rand.Reader, k, hash[:])
		rb := r.Bytes()
		for len(rb) < 32 {
			rb = append([]byte{0}, rb...)
		}
		sb := s.Bytes()
		for len(rb) < 32 {
			sb = append([]byte{0}, sb...)
		}
		sig = append(rb, sb...)
	}
	return sig
}

func issueNonce(w http.ResponseWriter, r *http.Request) {
	b := make([]byte, 16)
	_, _ = rand.Read(b)
	nonce := base64.RawURLEncoding.EncodeToString(b)
	nonces[nonce] = time.Now().Unix()

	w.Header().Set("Replay-Nonce", nonce)
}

func requireNonce(next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		nonce := r.Header.Get("Replay-Nonce")
		// TODO expire nonces every so often
		t := nonces[nonce]
		if 0 == t {
			http.Error(
				w,
				`{ "error": "invalid or expired nonce", "error_code": "ENONCE" }`,
				http.StatusBadRequest,
			)
			return
		}

		delete(nonces, nonce)
		issueNonce(w, r)

		next(w, r)
	}
}

func getBaseURL(r *http.Request) string {
	var scheme string
	if nil != r.TLS || "https" == r.Header.Get("X-Forwarded-Proto") {
		scheme = "https:"
	} else {
		scheme = "http:"
	}
	return fmt.Sprintf(
		"%s//%s",
		scheme,
		r.Host,
	)
}

// MarshalJWKPrivateKey outputs the given private key as JWK
func MarshalJWKPrivateKey(privkey keypairs.PrivateKey) []byte {
	// thumbprint keys are alphabetically sorted and only include the necessary public parts
	switch k := privkey.(type) {
	case *rsa.PrivateKey:
		return MarshalRSAPrivateKey(k)
	case *ecdsa.PrivateKey:
		return MarshalECPrivateKey(k)
	default:
		// this is unreachable because we know the types that we pass in
		log.Printf("keytype: %t, %+v\n", privkey, privkey)
		panic(keypairs.ErrInvalidPublicKey)
	}
}

// MarshalECPrivateKey will output the given private key as JWK
func MarshalECPrivateKey(k *ecdsa.PrivateKey) []byte {
	crv := k.Curve.Params().Name
	d := base64.RawURLEncoding.EncodeToString(k.D.Bytes())
	x := base64.RawURLEncoding.EncodeToString(k.X.Bytes())
	y := base64.RawURLEncoding.EncodeToString(k.Y.Bytes())
	return []byte(fmt.Sprintf(
		`{"crv":%q,"d":%q,"kty":"EC","x":%q,"y":%q}`,
		crv, d, x, y,
	))
}

// MarshalRSAPrivateKey will output the given private key as JWK
func MarshalRSAPrivateKey(pk *rsa.PrivateKey) []byte {
	e := base64.RawURLEncoding.EncodeToString(big.NewInt(int64(pk.E)).Bytes())
	n := base64.RawURLEncoding.EncodeToString(pk.N.Bytes())
	d := base64.RawURLEncoding.EncodeToString(pk.D.Bytes())
	p := base64.RawURLEncoding.EncodeToString(pk.Primes[0].Bytes())
	q := base64.RawURLEncoding.EncodeToString(pk.Primes[1].Bytes())
	dp := base64.RawURLEncoding.EncodeToString(pk.Precomputed.Dp.Bytes())
	dq := base64.RawURLEncoding.EncodeToString(pk.Precomputed.Dq.Bytes())
	qi := base64.RawURLEncoding.EncodeToString(pk.Precomputed.Qinv.Bytes())
	return []byte(fmt.Sprintf(
		`{"d":%q,"dp":%q,"dq":%q,"e":%q,"kty":"RSA","n":%q,"p":%q,"q":%q,"qi":%q}`,
		d, dp, dq, e, n, p, q, qi,
	))
}