headscale/hscontrol/api.go

package hscontrol

import (
	"bytes"
	"encoding/json"
	"errors"
	"html/template"
	"net/http"
	"time"

	"github.com/gorilla/mux"
	"github.com/juanfont/headscale/hscontrol/util"
	"github.com/rs/zerolog/log"
	"tailscale.com/types/key"
)

const (
	// TODO(juan): remove this once https://github.com/juanfont/headscale/issues/727 is fixed.
	registrationHoldoff        = time.Second * 5
	reservedResponseHeaderSize = 4
)

var ErrRegisterMethodCLIDoesNotSupportExpire = errors.New(
	"machines registered with CLI does not support expire",
)

func (h *Headscale) HealthHandler(
	writer http.ResponseWriter,
	req *http.Request,
) {
	respond := func(err error) {
		writer.Header().Set("Content-Type", "application/health+json; charset=utf-8")

		res := struct {
			Status string `json:"status"`
		}{
			Status: "pass",
		}

		if err != nil {
			writer.WriteHeader(http.StatusInternalServerError)
			log.Error().Caller().Err(err).Msg("health check failed")
			res.Status = "fail"
		}

		buf, err := json.Marshal(res)
		if err != nil {
			log.Error().Caller().Err(err).Msg("marshal failed")
		}
		_, err = writer.Write(buf)
		if err != nil {
			log.Error().Caller().Err(err).Msg("write failed")
		}
	}

	if err := h.db.PingDB(req.Context()); err != nil {
		respond(err)

		return
	}

	respond(nil)
}

type registerWebAPITemplateConfig struct {
	Key string
}

var registerWebAPITemplate = template.Must(
	template.New("registerweb").Parse(`
<html>
	<head>
		<title>Registration - Headscale</title>
	</head>
	<body>
		<h1>headscale</h1>
		<h2>Machine registration</h2>
		<p>
			Run the command below in the headscale server to add this machine to your network:
		</p>
		<pre><code>headscale nodes register --user USERNAME --key {{.Key}}</code></pre>
	</body>
</html>
`))

// RegisterWebAPI shows a simple message in the browser to point to the CLI
// Listens in /register/:nkey.
//
// This is not part of the Tailscale control API, as we could send whatever URL
// in the RegisterResponse.AuthURL field.
func (h *Headscale) RegisterWebAPI(
	writer http.ResponseWriter,
	req *http.Request,
) {
	vars := mux.Vars(req)
	nodeKeyStr, ok := vars["nkey"]

	if !util.NodePublicKeyRegex.Match([]byte(nodeKeyStr)) {
		log.Warn().Str("node_key", nodeKeyStr).Msg("Invalid node key passed to registration url")

		writer.Header().Set("Content-Type", "text/plain; charset=utf-8")
		writer.WriteHeader(http.StatusUnauthorized)
		_, err := writer.Write([]byte("Unauthorized"))
		if err != nil {
			log.Error().
				Caller().
				Err(err).
				Msg("Failed to write response")
		}

		return
	}

	// We need to make sure we dont open for XSS style injections, if the parameter that
	// is passed as a key is not parsable/validated as a NodePublic key, then fail to render
	// the template and log an error.
	var nodeKey key.NodePublic
	err := nodeKey.UnmarshalText(
		[]byte(util.NodePublicKeyEnsurePrefix(nodeKeyStr)),
	)

	if !ok || nodeKeyStr == "" || err != nil {
		log.Warn().Err(err).Msg("Failed to parse incoming nodekey")

		writer.Header().Set("Content-Type", "text/plain; charset=utf-8")
		writer.WriteHeader(http.StatusBadRequest)
		_, err := writer.Write([]byte("Wrong params"))
		if err != nil {
			log.Error().
				Caller().
				Err(err).
				Msg("Failed to write response")
		}

		return
	}

	var content bytes.Buffer
	if err := registerWebAPITemplate.Execute(&content, registerWebAPITemplateConfig{
		Key: nodeKeyStr,
	}); err != nil {
		log.Error().
			Str("func", "RegisterWebAPI").
			Err(err).
			Msg("Could not render register web API template")
		writer.Header().Set("Content-Type", "text/plain; charset=utf-8")
		writer.WriteHeader(http.StatusInternalServerError)
		_, err = writer.Write([]byte("Could not render register web API template"))
		if err != nil {
			log.Error().
				Caller().
				Err(err).
				Msg("Failed to write response")
		}

		return
	}

	writer.Header().Set("Content-Type", "text/html; charset=utf-8")
	writer.WriteHeader(http.StatusOK)
	_, err = writer.Write(content.Bytes())
	if err != nil {
		log.Error().
			Caller().
			Err(err).
			Msg("Failed to write response")
	}
}
rename package name to hscontrol Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2023-05-10 01:24:05 -06:00			`package hscontrol`
Initial commit 2020-06-21 04:32:08 -06:00
			`import (`
Template Fixes 2021-12-22 19:43:53 -07:00			`"bytes"`
Initial commit 2020-06-21 04:32:08 -06:00			`"encoding/json"`
create DB struct This is step one in detaching the Database layer from Headscale (h). The ultimate goal is to have all function that does database operations in its own package, and keep the business logic and writing separate. Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2023-05-11 01:09:18 -06:00			`"errors"`
Template Fixes 2021-12-22 19:43:53 -07:00			`"html/template"`
Initial commit 2020-06-21 04:32:08 -06:00			`"net/http"`
			`"time"`

Remove Gin from the Registration handler 2022-06-20 04:30:41 -06:00			`"github.com/gorilla/mux"`
create DB struct This is step one in detaching the Database layer from Headscale (h). The ultimate goal is to have all function that does database operations in its own package, and keep the business logic and writing separate. Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2023-05-11 01:09:18 -06:00			`"github.com/juanfont/headscale/hscontrol/util"`
golangci-lint --fix 2021-11-13 01:39:04 -07:00			`"github.com/rs/zerolog/log"`
Protect against user injection for registration CLI page This commit addresses a potential issue where we allowed unsanitised content to be passed through a go template without validation. We now try to unmarshall the incoming node key and fails to render the template if it is not a valid node key. Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2022-09-23 02:39:42 -06:00			`"tailscale.com/types/key"`
Initial commit 2020-06-21 04:32:08 -06:00			`)`

Make "authKey" a constant 2021-11-18 01:49:55 -07:00			`const (`
Added missing dot in comment 2022-08-12 01:36:17 -06:00			`// TODO(juan): remove this once https://github.com/juanfont/headscale/issues/727 is fixed.`
create DB struct This is step one in detaching the Database layer from Headscale (h). The ultimate goal is to have all function that does database operations in its own package, and keep the business logic and writing separate. Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2023-05-11 01:09:18 -06:00			`registrationHoldoff = time.Second * 5`
			`reservedResponseHeaderSize = 4`
			`)`

			`var ErrRegisterMethodCLIDoesNotSupportExpire = errors.New(`
			`"machines registered with CLI does not support expire",`
Make "authKey" a constant 2021-11-18 01:49:55 -07:00			`)`
Remove all instances of undefined numbers (gonmd) 2021-11-14 10:31:51 -07:00
ping db in health check 2022-07-06 05:39:10 -06:00			`func (h *Headscale) HealthHandler(`
			`writer http.ResponseWriter,`
			`req *http.Request,`
			`) {`
			`respond := func(err error) {`
			`writer.Header().Set("Content-Type", "application/health+json; charset=utf-8")`

			`res := struct {`
			Status string `json:"status"`
			`}{`
			`Status: "pass",`
			`}`

			`if err != nil {`
			`writer.WriteHeader(http.StatusInternalServerError)`
			`log.Error().Caller().Err(err).Msg("health check failed")`
			`res.Status = "fail"`
			`}`

			`buf, err := json.Marshal(res)`
			`if err != nil {`
			`log.Error().Caller().Err(err).Msg("marshal failed")`
			`}`
			`_, err = writer.Write(buf)`
			`if err != nil {`
			`log.Error().Caller().Err(err).Msg("write failed")`
			`}`
			`}`

Split code into modules This is a massive commit that restructures the code into modules: db/ All functions related to modifying the Database types/ All type definitions and methods that can be exclusivly used on these types without dependencies policy/ All Policy related code, now without dependencies on the Database. policy/matcher/ Dedicated code to match machines in a list of FilterRules Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2023-05-21 10:37:59 -06:00			`if err := h.db.PingDB(req.Context()); err != nil {`
ping db in health check 2022-07-06 05:39:10 -06:00			`respond(err)`

			`return`
			`}`

			`respond(nil)`
			`}`

Template Fixes 2021-12-22 19:43:53 -07:00			`type registerWebAPITemplateConfig struct {`
			`Key string`
			`}`
Initial multi-user support using namespaces 2021-02-27 16:58:09 -07:00
Template Fixes 2021-12-22 19:43:53 -07:00			`var registerWebAPITemplate = template.Must(`
fix: make register html/template consistent with other html - makes the html/template for /register follow the same formatting as /apple and /windows - adds a <title> element - minor change for consistency's sake 2022-03-08 01:34:46 -07:00			template.New("registerweb").Parse(`
			`<html>`
			`<head>`
			`<title>Registration - Headscale</title>`
			`</head>`
Initial multi-user support using namespaces 2021-02-27 16:58:09 -07:00			`<body>`
fix: make register html/template consistent with other html - makes the html/template for /register follow the same formatting as /apple and /windows - adds a <title> element - minor change for consistency's sake 2022-03-08 01:34:46 -07:00			`<h1>headscale</h1>`
			`<h2>Machine registration</h2>`
			`<p>`
			`Run the command below in the headscale server to add this machine to your network:`
			`</p>`
Update the node join instruction to reference "username" related to https://github.com/juanfont/headscale/pull/1144 Signed-off-by: Christian Heusel <christian@heusel.eu> 2023-01-19 17:37:37 -07:00			`<pre><code>headscale nodes register --user USERNAME --key {{.Key}}</code></pre>`
Initial multi-user support using namespaces 2021-02-27 16:58:09 -07:00			`</body>`
fix: make register html/template consistent with other html - makes the html/template for /register follow the same formatting as /apple and /windows - adds a <title> element - minor change for consistency's sake 2022-03-08 01:34:46 -07:00			`</html>`
			`))
Template Fixes 2021-12-22 19:43:53 -07:00
			`// RegisterWebAPI shows a simple message in the browser to point to the CLI`
Improve protocol implementation for client registration (fixes #706) 2022-08-11 04:11:02 -06:00			`// Listens in /register/:nkey.`
Added comment clarifying registration API 2022-08-11 04:16:50 -06:00			`//`
			`// This is not part of the Tailscale control API, as we could send whatever URL`
			`// in the RegisterResponse.AuthURL field.`
Remove Gin from simple endpoints for TS2019 2022-06-17 08:48:04 -06:00			`func (h *Headscale) RegisterWebAPI(`
Lint fixes 2/n 2022-06-26 03:55:37 -06:00			`writer http.ResponseWriter,`
			`req *http.Request,`
Remove Gin from simple endpoints for TS2019 2022-06-17 08:48:04 -06:00			`) {`
Improve protocol implementation for client registration (fixes #706) 2022-08-11 04:11:02 -06:00			`vars := mux.Vars(req)`
			`nodeKeyStr, ok := vars["nkey"]`
Protect against user injection for registration CLI page This commit addresses a potential issue where we allowed unsanitised content to be passed through a go template without validation. We now try to unmarshall the incoming node key and fails to render the template if it is not a valid node key. Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2022-09-23 02:39:42 -06:00
create DB struct This is step one in detaching the Database layer from Headscale (h). The ultimate goal is to have all function that does database operations in its own package, and keep the business logic and writing separate. Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2023-05-11 01:09:18 -06:00			`if !util.NodePublicKeyRegex.Match([]byte(nodeKeyStr)) {`
Validate the incoming nodekey with regex before attempting to parse Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2022-09-23 03:51:38 -06:00			`log.Warn().Str("node_key", nodeKeyStr).Msg("Invalid node key passed to registration url")`

			`writer.Header().Set("Content-Type", "text/plain; charset=utf-8")`
			`writer.WriteHeader(http.StatusUnauthorized)`
			`_, err := writer.Write([]byte("Unauthorized"))`
			`if err != nil {`
			`log.Error().`
			`Caller().`
			`Err(err).`
			`Msg("Failed to write response")`
			`}`

			`return`
			`}`

Protect against user injection for registration CLI page This commit addresses a potential issue where we allowed unsanitised content to be passed through a go template without validation. We now try to unmarshall the incoming node key and fails to render the template if it is not a valid node key. Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2022-09-23 02:39:42 -06:00			`// We need to make sure we dont open for XSS style injections, if the parameter that`
			`// is passed as a key is not parsable/validated as a NodePublic key, then fail to render`
			`// the template and log an error.`
			`var nodeKey key.NodePublic`
			`err := nodeKey.UnmarshalText(`
create DB struct This is step one in detaching the Database layer from Headscale (h). The ultimate goal is to have all function that does database operations in its own package, and keep the business logic and writing separate. Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2023-05-11 01:09:18 -06:00			`[]byte(util.NodePublicKeyEnsurePrefix(nodeKeyStr)),`
Protect against user injection for registration CLI page This commit addresses a potential issue where we allowed unsanitised content to be passed through a go template without validation. We now try to unmarshall the incoming node key and fails to render the template if it is not a valid node key. Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2022-09-23 02:39:42 -06:00			`)`

			`if !ok \|\| nodeKeyStr == "" \|\| err != nil {`
			`log.Warn().Err(err).Msg("Failed to parse incoming nodekey")`

Lint fixes 2/n 2022-06-26 03:55:37 -06:00			`writer.Header().Set("Content-Type", "text/plain; charset=utf-8")`
			`writer.WriteHeader(http.StatusBadRequest)`
Lint fixes 5/n 2022-06-26 04:21:35 -06:00			`_, err := writer.Write([]byte("Wrong params"))`
			`if err != nil {`
			`log.Error().`
			`Caller().`
			`Err(err).`
			`Msg("Failed to write response")`
			`}`
Template Fixes 2021-12-22 19:43:53 -07:00
			`return`
			`}`

			`var content bytes.Buffer`
			`if err := registerWebAPITemplate.Execute(&content, registerWebAPITemplateConfig{`
Replace machine key with node key in preparation for Noise in auth related stuff 2022-08-10 07:35:26 -06:00			`Key: nodeKeyStr,`
Template Fixes 2021-12-22 19:43:53 -07:00			`}); err != nil {`
			`log.Error().`
			`Str("func", "RegisterWebAPI").`
			`Err(err).`
			`Msg("Could not render register web API template")`
Lint fixes 2/n 2022-06-26 03:55:37 -06:00			`writer.Header().Set("Content-Type", "text/plain; charset=utf-8")`
			`writer.WriteHeader(http.StatusInternalServerError)`
Lint fixes 5/n 2022-06-26 04:21:35 -06:00			`_, err = writer.Write([]byte("Could not render register web API template"))`
			`if err != nil {`
			`log.Error().`
			`Caller().`
			`Err(err).`
			`Msg("Failed to write response")`
			`}`
Lint fixes 2/n 2022-06-26 03:55:37 -06:00
			`return`
Template Fixes 2021-12-22 19:43:53 -07:00			`}`
Improved tailnode start up handling 2021-05-24 13:59:03 -06:00
Lint fixes 2/n 2022-06-26 03:55:37 -06:00			`writer.Header().Set("Content-Type", "text/html; charset=utf-8")`
			`writer.WriteHeader(http.StatusOK)`
Protect against user injection for registration CLI page This commit addresses a potential issue where we allowed unsanitised content to be passed through a go template without validation. We now try to unmarshall the incoming node key and fails to render the template if it is not a valid node key. Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> 2022-09-23 02:39:42 -06:00			`_, err = writer.Write(content.Bytes())`
Lint fixes 5/n 2022-06-26 04:21:35 -06:00			`if err != nil {`
			`log.Error().`
			`Caller().`
			`Err(err).`
			`Msg("Failed to write response")`
			`}`
Initial multi-user support using namespaces 2021-02-27 16:58:09 -07:00			`}`