MyFavMirrors/headscale
1
0
Fork 0
mirror of https://github.com/juanfont/headscale.git synced 2024-12-26 22:25:52 -05:00
Code Issues Packages Projects Releases Wiki Activity
19455399f4
headscale/api.go

918 lines
24 KiB
Go
Raw Normal View History

Initial commit
2020-06-21 06:32:08 -04:00
package headscale
import (
Template Fixes
2021-12-22 21:43:53 -05:00
"bytes"
Initial commit
2020-06-21 06:32:08 -04:00
"encoding/binary"
"encoding/json"
Update Headscale to depend on gorm v2
2021-06-24 09:44:19 -04:00
"errors"
Initial commit
2020-06-21 06:32:08 -04:00
"fmt"
Template Fixes
2021-12-22 21:43:53 -05:00
"html/template"
Initial commit
2020-06-21 06:32:08 -04:00
"io"
"net/http"
updates from code review
2021-10-08 05:43:52 -04:00
"strings"
Initial commit
2020-06-21 06:32:08 -04:00
"time"
Remove Gin from the Registration handler
2022-06-20 06:30:41 -04:00
"github.com/gorilla/mux"
Initial commit
2020-06-21 06:32:08 -04:00
"github.com/klauspost/compress/zstd"
golangci-lint --fix
2021-11-13 03:39:04 -05:00
"github.com/rs/zerolog/log"
Update Headscale to depend on gorm v2
2021-06-24 09:44:19 -04:00
"gorm.io/gorm"
Initial commit
2020-06-21 06:32:08 -04:00
"tailscale.com/tailcfg"
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
"tailscale.com/types/key"
Initial commit
2020-06-21 06:32:08 -04:00
)
Make "authKey" a constant
2021-11-18 03:49:55 -05:00
const (
Added missing dot in comment
2022-08-12 03:36:17 -04:00
// TODO(juan): remove this once https://github.com/juanfont/headscale/issues/727 is fixed.
Update api.go Co-authored-by: Kristoffer Dalby <kradalby@kradalby.no>
2022-08-12 03:02:58 -04:00
registrationHoldoff = time.Second * 5
Add cache for requested expiry times This commit adds a sentral cache to keep track of clients whom has requested an expiry time, but were we need to keep hold of it until the second request comes in.
2021-11-22 14:32:52 -05:00
reservedResponseHeaderSize = 4
Fix excessive replace
2022-02-27 12:48:12 -05:00
RegisterMethodAuthKey = "authkey"
Add cache for requested expiry times This commit adds a sentral cache to keep track of clients whom has requested an expiry time, but were we need to keep hold of it until the second request comes in.
2021-11-22 14:32:52 -05:00
RegisterMethodOIDC = "oidc"
RegisterMethodCLI = "cli"
ErrRegisterMethodCLIDoesNotSupportExpire = Error(
"machines registered with CLI does not support expire",
)
Make "authKey" a constant
2021-11-18 03:49:55 -05:00
)
Remove all instances of undefined numbers (gonmd)
2021-11-14 12:31:51 -05:00
ping db in health check
2022-07-06 07:39:10 -04: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")
}
}
if err := h.pingDB(); err != nil {
respond(err)
return
}
respond(nil)
}
Initial multi-user support using namespaces
2021-02-27 18:58:09 -05:00
// KeyHandler provides the Headscale pub key
golangci-lint --fix
2021-11-13 03:39:04 -05:00
// Listens in /key.
Remove Gin from simple endpoints for TS2019
2022-06-17 10:48:04 -04:00
func (h *Headscale) KeyHandler(
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer http.ResponseWriter,
req *http.Request,
Remove Gin from simple endpoints for TS2019
2022-06-17 10:48:04 -04:00
) {
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer.Header().Set("Content-Type", "text/plain; charset=utf-8")
writer.WriteHeader(http.StatusOK)
Lint fixes 5/n
2022-06-26 06:21:35 -04:00
_, err := writer.Write([]byte(MachinePublicKeyStripPrefix(h.privateKey.Public())))
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Failed to write response")
}
Initial commit
2020-06-21 06:32:08 -04:00
}
Template Fixes
2021-12-22 21:43:53 -05:00
type registerWebAPITemplateConfig struct {
Key string
}
Initial multi-user support using namespaces
2021-02-27 18:58:09 -05:00
Template Fixes
2021-12-22 21:43:53 -05: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 03:34:46 -05:00
template.New("registerweb").Parse(`
<html>
<head>
<title>Registration - Headscale</title>
</head>
Initial multi-user support using namespaces
2021-02-27 18:58:09 -05: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 03:34:46 -05: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>
<pre><code>headscale -n NAMESPACE nodes register --key {{.Key}}</code></pre>
Initial multi-user support using namespaces
2021-02-27 18:58:09 -05: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 03:34:46 -05:00
</html>
`))
Template Fixes
2021-12-22 21:43:53 -05: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 06:11:02 -04:00
// Listens in /register/:nkey.
Added comment clarifying registration API
2022-08-11 06:16:50 -04: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 10:48:04 -04:00
func (h *Headscale) RegisterWebAPI(
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer http.ResponseWriter,
req *http.Request,
Remove Gin from simple endpoints for TS2019
2022-06-17 10:48:04 -04:00
) {
Improve protocol implementation for client registration (fixes #706)
2022-08-11 06:11:02 -04:00
vars := mux.Vars(req)
nodeKeyStr, ok := vars["nkey"]
if !ok || nodeKeyStr == "" {
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer.Header().Set("Content-Type", "text/plain; charset=utf-8")
writer.WriteHeader(http.StatusBadRequest)
Lint fixes 5/n
2022-06-26 06:21:35 -04: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 21:43:53 -05: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 09:35:26 -04:00
Key: nodeKeyStr,
Template Fixes
2021-12-22 21:43:53 -05: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 05:55:37 -04:00
writer.Header().Set("Content-Type", "text/plain; charset=utf-8")
writer.WriteHeader(http.StatusInternalServerError)
Lint fixes 5/n
2022-06-26 06:21:35 -04: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 05:55:37 -04:00
return
Template Fixes
2021-12-22 21:43:53 -05:00
}
Improved tailnode start up handling
2021-05-24 15:59:03 -04:00
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer.Header().Set("Content-Type", "text/html; charset=utf-8")
writer.WriteHeader(http.StatusOK)
Lint fixes 5/n
2022-06-26 06:21:35 -04:00
_, err := writer.Write(content.Bytes())
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Failed to write response")
}
Initial multi-user support using namespaces
2021-02-27 18:58:09 -05:00
}
// RegistrationHandler handles the actual registration process of a machine
Remove Gin from the Registration handler
2022-06-20 06:30:41 -04:00
// Endpoint /machine/:mkey.
func (h *Headscale) RegistrationHandler(
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer http.ResponseWriter,
req *http.Request,
Remove Gin from the Registration handler
2022-06-20 06:30:41 -04:00
) {
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
vars := mux.Vars(req)
Remove Gin from the Registration handler
2022-06-20 06:30:41 -04:00
machineKeyStr, ok := vars["mkey"]
if !ok || machineKeyStr == "" {
log.Error().
Str("handler", "RegistrationHandler").
Msg("No machine ID in request")
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "No machine ID in request", http.StatusBadRequest)
Remove Gin from the Registration handler
2022-06-20 06:30:41 -04:00
return
}
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
body, _ := io.ReadAll(req.Body)
Unmarshal keys in the non-deprecated way
2021-11-26 18:50:42 -05:00
var machineKey key.MachinePublic
Ensure we always have the key prefix when needed
2021-11-27 15:25:12 -05:00
err := machineKey.UnmarshalText([]byte(MachinePublicKeyEnsurePrefix(machineKeyStr)))
Initial commit
2020-06-21 06:32:08 -04:00
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot parse machine key")
updates from code review
2021-10-10 05:22:42 -04:00
machineRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "Cannot parse machine key", http.StatusBadRequest)
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Initial commit
2020-06-21 06:32:08 -04:00
return
}
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
registerRequest := tailcfg.RegisterRequest{}
err = decode(body, &registerRequest, &machineKey, h.privateKey)
Initial commit
2020-06-21 06:32:08 -04:00
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot decode message")
updates from code review
2021-10-10 05:22:42 -04:00
machineRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "Cannot decode message", http.StatusBadRequest)
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Initial commit
2020-06-21 06:32:08 -04:00
return
}
Preauth keys kinda working
2021-05-05 18:59:26 -04:00
Move most "poll" functionality to poll.go This function migrates more poll functions (including keepalive) to poll.go to keep it somehow in the same file. In addition it makes changes to improve the stability and ensure nodes get the appropriate updates from the headscale control and are not left in an inconsistent state. Two new additions is: omitpeers=true will now trigger an update if the clients are not already up to date keepalive has been extended with a timer that will check every 120s if all nodes are up to date.
2021-08-18 18:24:22 -04:00
now := time.Now().UTC()
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
machine, err := h.GetMachineByMachineKey(machineKey)
updates from code review
2021-10-10 05:22:42 -04:00
if errors.Is(err, gorm.ErrRecordNotFound) {
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
machineKeyStr := MachinePublicKeyStripPrefix(machineKey)
// If the machine has AuthKey set, handle registration via PreAuthKeys
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
if registerRequest.Auth.AuthKey != "" {
h.handleAuthKey(writer, req, machineKey, registerRequest)
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
return
}
Move todo to correct file
2022-04-24 16:12:45 -04:00
Added missing dot in comment
2022-08-12 03:36:17 -04:00
// Check if the node is waiting for interactive login.
Improve protocol implementation for client registration (fixes #706)
2022-08-11 06:11:02 -04:00
//
// TODO(juan): We could use this field to improve our protocol implementation,
// and hold the request until the client closes it, or the interactive
// login is completed (i.e., the user registers the machine).
// This is not implemented yet, as it is no strictly required. The only side-effect
// is that the client will hammer headscale with requests until it gets a
// successful RegisterResponse.
if registerRequest.Followup != "" {
if _, ok := h.registrationCache.Get(NodePublicKeyStripPrefix(registerRequest.NodeKey)); ok {
log.Debug().
Caller().
Str("machine", registerRequest.Hostinfo.Hostname).
Update api.go Co-authored-by: Kristoffer Dalby <kradalby@kradalby.no>
2022-08-12 03:03:32 -04:00
Str("node_key", registerRequest.NodeKey.ShortString()).
Str("node_key_old", registerRequest.OldNodeKey.ShortString()).
Str("follow_up", registerRequest.Followup).
Improve protocol implementation for client registration (fixes #706)
2022-08-11 06:11:02 -04:00
Msg("Machine is waiting for interactive login")
Add a sleep to reduce the impact of #727
2022-08-11 07:37:25 -04:00
ticker := time.NewTicker(registrationHoldoff)
select {
case <-req.Context().Done():
return
case <-ticker.C:
h.handleMachineRegistrationNew(writer, req, machineKey, registerRequest)
Improve protocol implementation for client registration (fixes #706)
2022-08-11 06:11:02 -04:00
Add a sleep to reduce the impact of #727
2022-08-11 07:37:25 -04:00
return
}
Improve protocol implementation for client registration (fixes #706)
2022-08-11 06:11:02 -04:00
}
}
log.Info().
Caller().
Str("machine", registerRequest.Hostinfo.Hostname).
Update api.go Co-authored-by: Kristoffer Dalby <kradalby@kradalby.no>
2022-08-12 03:03:11 -04:00
Str("node_key", registerRequest.NodeKey.ShortString()).
Str("node_key_old", registerRequest.OldNodeKey.ShortString()).
Str("follow_up", registerRequest.Followup).
Improve protocol implementation for client registration (fixes #706)
2022-08-11 06:11:02 -04:00
Msg("New machine not yet in the database")
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
givenName, err := h.GenerateGivenName(registerRequest.Hostinfo.Hostname)
feat(api): add normalisation at machine register step
2022-03-07 16:46:29 -05:00
if err != nil {
log.Error().
Caller().
Str("func", "RegistrationHandler").
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
Str("hostinfo.name", registerRequest.Hostinfo.Hostname).
feat(api): add normalisation at machine register step
2022-03-07 16:46:29 -05:00
Err(err)
fix: apply fmt and fix missing name changes
2022-03-07 17:20:30 -05:00
feat(api): add normalisation at machine register step
2022-03-07 16:46:29 -05:00
return
}
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
// The machine did not have a key to authenticate, which means
// that we rely on a method that calls back some how (OpenID or CLI)
// We create the machine and then keep it around until a callback
// happens
updates from code review
2021-10-10 05:22:42 -04:00
newMachine := Machine{
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
MachineKey: machineKeyStr,
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
Hostname: registerRequest.Hostinfo.Hostname,
Generate unique givennames for hosts joining (and debug added)
2022-05-16 14:32:37 -04:00
GivenName: givenName,
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
NodeKey: NodePublicKeyStripPrefix(registerRequest.NodeKey),
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
LastSeen: &now,
Protect against expiry nil
2022-03-02 02:15:20 -05:00
Expiry: &time.Time{},
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
}
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
if !registerRequest.Expiry.IsZero() {
Remove redundant caches This commit removes the two extra caches (oidc, requested time) and uses the new central registration cache instead. The requested time is unified into the main machine object and the oidc key is just added to the same cache, as a string with the state as a key instead of machine key.
2022-02-28 17:42:30 -05:00
log.Trace().
Caller().
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
Str("machine", registerRequest.Hostinfo.Hostname).
Time("expiry", registerRequest.Expiry).
Remove redundant caches This commit removes the two extra caches (oidc, requested time) and uses the new central registration cache instead. The requested time is unified into the main machine object and the oidc key is just added to the same cache, as a string with the state as a key instead of machine key.
2022-02-28 17:42:30 -05:00
Msg("Non-zero expiry time requested")
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
newMachine.Expiry = &registerRequest.Expiry
Remove redundant caches This commit removes the two extra caches (oidc, requested time) and uses the new central registration cache instead. The requested time is unified into the main machine object and the oidc key is just added to the same cache, as a string with the state as a key instead of machine key.
2022-02-28 17:42:30 -05:00
}
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
h.registrationCache.Set(
Replace machine key with node key in preparation for Noise in auth related stuff
2022-08-10 09:35:26 -04:00
newMachine.NodeKey,
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
newMachine,
Remove redundant caches This commit removes the two extra caches (oidc, requested time) and uses the new central registration cache instead. The requested time is unified into the main machine object and the oidc key is just added to the same cache, as a string with the state as a key instead of machine key.
2022-02-28 17:42:30 -05:00
registerCacheExpiration,
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
)
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
h.handleMachineRegistrationNew(writer, req, machineKey, registerRequest)
Implement new machine register parameter
2022-02-28 11:34:50 -05:00
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
return
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
}
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
// The machine is already registered, so we need to pass through reauth or key update.
if machine != nil {
Simplify control flow in RegistrationHandler This commits tries to dismantle the complicated "if and or" in the RegistrationHandler by factoring out the "is Registrated" into a root if. This, together with some new comments, should hopefully make it a bit easier to follow what is happening in all the different cases that needs to be handled when a Node contacts the registration endpoint.
2021-11-21 08:59:24 -05:00
// If the NodeKey stored in headscale is the same as the key presented in a registration
// request, then we have a node that is either:
// - Trying to log out (sending a expiry in the past)
// - A valid, registered machine, looking for the node map
// - Expired machine wanting to reauthenticate
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
if machine.NodeKey == NodePublicKeyStripPrefix(registerRequest.NodeKey) {
Simplify control flow in RegistrationHandler This commits tries to dismantle the complicated "if and or" in the RegistrationHandler by factoring out the "is Registrated" into a root if. This, together with some new comments, should hopefully make it a bit easier to follow what is happening in all the different cases that needs to be handled when a Node contacts the registration endpoint.
2021-11-21 08:59:24 -05:00
// The client sends an Expiry in the past if the client is requesting to expire the key (aka logout)
// https://github.com/tailscale/tailscale/blob/main/tailcfg/tailcfg.go#L648
chore(all): apply formater
2022-08-04 04:47:00 -04:00
if !registerRequest.Expiry.IsZero() &&
registerRequest.Expiry.UTC().Before(now) {
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
h.handleMachineLogOut(writer, req, machineKey, *machine)
Simplify control flow in RegistrationHandler This commits tries to dismantle the complicated "if and or" in the RegistrationHandler by factoring out the "is Registrated" into a root if. This, together with some new comments, should hopefully make it a bit easier to follow what is happening in all the different cases that needs to be handled when a Node contacts the registration endpoint.
2021-11-21 08:59:24 -05:00
return
}
// If machine is not expired, and is register, we have a already accepted this machine,
// let it proceed with a valid registration
if !machine.isExpired() {
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
h.handleMachineValidRegistration(writer, req, machineKey, *machine)
Simplify control flow in RegistrationHandler This commits tries to dismantle the complicated "if and or" in the RegistrationHandler by factoring out the "is Registrated" into a root if. This, together with some new comments, should hopefully make it a bit easier to follow what is happening in all the different cases that needs to be handled when a Node contacts the registration endpoint.
2021-11-21 08:59:24 -05:00
return
}
updates from code review
2021-10-08 05:43:52 -04:00
}
Simplify control flow in RegistrationHandler This commits tries to dismantle the complicated "if and or" in the RegistrationHandler by factoring out the "is Registrated" into a root if. This, together with some new comments, should hopefully make it a bit easier to follow what is happening in all the different cases that needs to be handled when a Node contacts the registration endpoint.
2021-11-21 08:59:24 -05:00
// The NodeKey we have matches OldNodeKey, which means this is a refresh after a key expiration
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
if machine.NodeKey == NodePublicKeyStripPrefix(registerRequest.OldNodeKey) &&
Simplify control flow in RegistrationHandler This commits tries to dismantle the complicated "if and or" in the RegistrationHandler by factoring out the "is Registrated" into a root if. This, together with some new comments, should hopefully make it a bit easier to follow what is happening in all the different cases that needs to be handled when a Node contacts the registration endpoint.
2021-11-21 08:59:24 -05:00
!machine.isExpired() {
chore(all): apply formater
2022-08-04 04:47:00 -04:00
h.handleMachineRefreshKey(
writer,
req,
machineKey,
registerRequest,
*machine,
)
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Initial commit
2020-06-21 06:32:08 -04:00
return
}
Move handle expired machine to the end of registration
2021-11-21 16:14:13 -05:00
// The machine has expired
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
h.handleMachineExpired(writer, req, machineKey, registerRequest, *machine)
Move handle expired machine to the end of registration
2021-11-21 16:14:13 -05:00
return
Initial commit
2020-06-21 06:32:08 -04:00
}
}
Go format with shorter lines
2021-11-13 03:36:45 -05:00
func (h *Headscale) getMapResponse(
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
machineKey key.MachinePublic,
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
mapRequest tailcfg.MapRequest,
Initial work eliminating one/two letter variables
2021-11-14 14:32:03 -05:00
machine *Machine,
Go format with shorter lines
2021-11-13 03:36:45 -05:00
) ([]byte, error) {
Add more trace logging
2021-08-05 16:47:06 -04:00
log.Trace().
Str("func", "getMapResponse").
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
Str("machine", mapRequest.Hostinfo.Hostname).
Add more trace logging
2021-08-05 16:47:06 -04:00
Msg("Creating Map response")
Initial work eliminating one/two letter variables
2021-11-14 14:32:03 -05:00
node, err := machine.toNode(h.cfg.BaseDomain, h.cfg.DNSConfig, true)
Initial commit
2020-06-21 06:32:08 -04:00
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "getMapResponse").
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot convert to node")
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Initial commit
2020-06-21 06:32:08 -04:00
return nil, err
}
Move DB call of pollmap to Machine inside a function
2021-10-02 16:58:28 -04:00
Update neighbours if node is expired or refreshed In addition, only pass the map of registered and not expired nodes to clients.
2021-11-22 14:51:16 -05:00
peers, err := h.getValidPeers(machine)
Initial commit
2020-06-21 06:32:08 -04:00
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "getMapResponse").
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot fetch peers")
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Initial commit
2020-06-21 06:32:08 -04:00
return nil, err
}
Send the namespace name as user to the clients
2021-07-11 10:39:19 -04:00
Initial work eliminating one/two letter variables
2021-11-14 14:32:03 -05:00
profiles := getMapResponseUserProfiles(*machine, peers)
Send the namespace name as user to the clients
2021-07-11 10:39:19 -04:00
MagicDNS changes merged back
2021-10-04 17:49:16 -04:00
nodePeers, err := peers.toNodes(h.cfg.BaseDomain, h.cfg.DNSConfig, true)
Move toNode, add type helpers, split peers and shared This commit moves toNode to the bottom of the file, and adds a helper function for lists of Machines to be converted. It also adds string helpers for Machines and lists of machines. Lastly it splits getPeers into getDirectPeers, which exist in the same namespace, and getShared, which is nodes shared with the namespace. getPeers is kept as a function putting together the two lists for convenience.
2021-10-02 17:03:34 -04:00
if err != nil {
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Move toNode, add type helpers, split peers and shared This commit moves toNode to the bottom of the file, and adds a helper function for lists of Machines to be converted. It also adds string helpers for Machines and lists of machines. Lastly it splits getPeers into getDirectPeers, which exist in the same namespace, and getShared, which is nodes shared with the namespace. getPeers is kept as a function putting together the two lists for convenience.
2021-10-02 17:03:34 -04:00
Str("func", "getMapResponse").
Err(err).
Msg("Failed to convert peers to Tailscale nodes")
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Move toNode, add type helpers, split peers and shared This commit moves toNode to the bottom of the file, and adds a helper function for lists of Machines to be converted. It also adds string helpers for Machines and lists of machines. Lastly it splits getPeers into getDirectPeers, which exist in the same namespace, and getShared, which is nodes shared with the namespace. getPeers is kept as a function putting together the two lists for convenience.
2021-10-02 17:03:34 -04:00
return nil, err
}
Remove unused params or returns
2021-11-14 12:03:21 -05:00
dnsConfig := getMapResponseDNSConfig(
Go format with shorter lines
2021-11-13 03:36:45 -05:00
h.cfg.DNSConfig,
h.cfg.BaseDomain,
Initial work eliminating one/two letter variables
2021-11-14 14:32:03 -05:00
*machine,
Go format with shorter lines
2021-11-13 03:36:45 -05:00
peers,
)
Send search domains
2021-10-02 06:13:19 -04:00
Initial commit
2020-06-21 06:32:08 -04:00
resp := tailcfg.MapResponse{
Propagate dns config vales across Headscale
2021-10-02 05:20:42 -04:00
KeepAlive: false,
Node: node,
Merged main
2021-10-04 17:43:42 -04:00
Peers: nodePeers,
Send search domains
2021-10-02 06:13:19 -04:00
DNSConfig: dnsConfig,
Propagate dns config vales across Headscale
2021-10-02 05:20:42 -04:00
Domain: h.cfg.BaseDomain,
Use long command in example and remove pointerlist
2021-11-04 18:18:06 -04:00
PacketFilter: h.aclRules,
Use the new derp map
2021-10-22 12:56:00 -04:00
DERPMap: h.DERPMap,
Send UserProfile info for the peers' namespaces
2021-10-17 06:07:01 -04:00
UserProfiles: profiles,
Disable logtail for clients
2022-05-30 08:52:50 -04:00
Debug: &tailcfg.Debug{
add ability to set randomizeClientPort
2022-06-09 15:20:11 -04:00
DisableLogTail: !h.cfg.LogTail.Enabled,
RandomizeClientPort: h.cfg.RandomizeClientPort,
Disable logtail for clients
2022-05-30 08:52:50 -04:00
},
Minor thing
2021-02-23 18:31:58 -05:00
}
Send UserProfile info for the peers' namespaces
2021-10-17 06:07:01 -04:00
Resolve merge conflict
2021-08-13 05:33:19 -04:00
log.Trace().
Str("func", "getMapResponse").
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
Str("machine", mapRequest.Hostinfo.Hostname).
Comment out aggressive logging
2021-10-05 12:51:42 -04:00
// Interface("payload", resp).
Resolve merge conflict
2021-08-13 05:33:19 -04:00
Msgf("Generated map response: %s", tailMapResponseToString(resp))
Initial commit
2020-06-21 06:32:08 -04:00
var respBody []byte
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
if mapRequest.Compress == "zstd" {
chore(all): update some files for linter
2022-02-14 09:26:54 -05:00
src, err := json.Marshal(resp)
if err != nil {
log.Error().
Caller().
Str("func", "getMapResponse").
Err(err).
Msg("Failed to marshal response for the client")
return nil, err
}
Resolve merge conflict
2021-08-13 05:33:19 -04:00
Initial commit
2020-06-21 06:32:08 -04:00
encoder, _ := zstd.NewWriter(nil)
srcCompressed := encoder.EncodeAll(src, nil)
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
respBody = h.privateKey.SealTo(machineKey, srcCompressed)
Initial commit
2020-06-21 06:32:08 -04:00
} else {
Initial work eliminating one/two letter variables
2021-11-14 14:32:03 -05:00
respBody, err = encode(resp, &machineKey, h.privateKey)
Initial commit
2020-06-21 06:32:08 -04:00
if err != nil {
return nil, err
}
}
// declare the incoming size on the first 4 bytes
Add and fix stylecheck (golint replacement)
2021-11-15 12:24:24 -05:00
data := make([]byte, reservedResponseHeaderSize)
Initial commit
2020-06-21 06:32:08 -04:00
binary.LittleEndian.PutUint32(data, uint32(len(respBody)))
data = append(data, respBody...)
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Clean up pointer usage consistency. This tries to make the same functions emit and consume the same type of data all over the application. If a function transform data, it should emit new data, not a pointer.
2021-10-04 13:39:01 -04:00
return data, nil
Initial commit
2020-06-21 06:32:08 -04:00
}
Go format with shorter lines
2021-11-13 03:36:45 -05:00
func (h *Headscale) getMapKeepAliveResponse(
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
machineKey key.MachinePublic,
Initial work eliminating one/two letter variables
2021-11-14 14:32:03 -05:00
mapRequest tailcfg.MapRequest,
Go format with shorter lines
2021-11-13 03:36:45 -05:00
) ([]byte, error) {
Initial work eliminating one/two letter variables
2021-11-14 14:32:03 -05:00
mapResponse := tailcfg.MapResponse{
Initial commit
2020-06-21 06:32:08 -04:00
KeepAlive: true,
}
var respBody []byte
var err error
Initial work eliminating one/two letter variables
2021-11-14 14:32:03 -05:00
if mapRequest.Compress == "zstd" {
chore(all): update some files for linter
2022-02-14 09:26:54 -05:00
src, err := json.Marshal(mapResponse)
if err != nil {
log.Error().
Caller().
Str("func", "getMapKeepAliveResponse").
Err(err).
Msg("Failed to marshal keepalive response for the client")
return nil, err
}
Initial commit
2020-06-21 06:32:08 -04:00
encoder, _ := zstd.NewWriter(nil)
srcCompressed := encoder.EncodeAll(src, nil)
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
respBody = h.privateKey.SealTo(machineKey, srcCompressed)
Initial commit
2020-06-21 06:32:08 -04:00
} else {
Initial work eliminating one/two letter variables
2021-11-14 14:32:03 -05:00
respBody, err = encode(mapResponse, &machineKey, h.privateKey)
Initial commit
2020-06-21 06:32:08 -04:00
if err != nil {
return nil, err
}
}
Add and fix stylecheck (golint replacement)
2021-11-15 12:24:24 -05:00
data := make([]byte, reservedResponseHeaderSize)
Initial commit
2020-06-21 06:32:08 -04:00
binary.LittleEndian.PutUint32(data, uint32(len(respBody)))
data = append(data, respBody...)
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Clean up pointer usage consistency. This tries to make the same functions emit and consume the same type of data all over the application. If a function transform data, it should emit new data, not a pointer.
2021-10-04 13:39:01 -04:00
return data, nil
Initial commit
2020-06-21 06:32:08 -04:00
}
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
func (h *Headscale) handleMachineLogOut(
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer http.ResponseWriter,
req *http.Request,
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
machineKey key.MachinePublic,
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
machine Machine,
) {
resp := tailcfg.RegisterResponse{}
log.Info().
Rename name -> hostname, nickname -> givenname
2022-04-24 15:54:38 -04:00
Str("machine", machine.Hostname).
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
Msg("Client requested logout")
Lint fixes 7/n
2022-06-26 06:30:52 -04:00
err := h.ExpireMachine(&machine)
if err != nil {
log.Error().
Caller().
Str("func", "handleMachineLogOut").
Err(err).
Msg("Failed to expire machine")
http.Error(writer, "Internal server error", http.StatusInternalServerError)
return
}
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
resp.AuthURL = ""
resp.MachineAuthorized = false
resp.User = *machine.Namespace.toUser()
Rename idKey to machineKey to keep consistency
2021-11-24 07:15:55 -05:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
if err != nil {
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
Err(err).
Msg("Cannot encode message")
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "Internal server error", http.StatusInternalServerError)
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
return
}
Remove Gin from the Registration handler
2022-06-20 06:30:41 -04:00
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
writer.WriteHeader(http.StatusOK)
Lint fixes 5/n
2022-06-26 06:21:35 -04:00
_, err = writer.Write(respBody)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Failed to write response")
}
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
}
func (h *Headscale) handleMachineValidRegistration(
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer http.ResponseWriter,
req *http.Request,
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
machineKey key.MachinePublic,
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
machine Machine,
) {
resp := tailcfg.RegisterResponse{}
// The machine registration is valid, respond with redirect to /map
log.Debug().
Rename name -> hostname, nickname -> givenname
2022-04-24 15:54:38 -04:00
Str("machine", machine.Hostname).
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
Msg("Client is registered and we have the current NodeKey. All clear to /map")
resp.AuthURL = ""
resp.MachineAuthorized = true
resp.User = *machine.Namespace.toUser()
resp.Login = *machine.Namespace.toLogin()
Rename idKey to machineKey to keep consistency
2021-11-24 07:15:55 -05:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
if err != nil {
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
Err(err).
Msg("Cannot encode message")
machineRegistrations.WithLabelValues("update", "web", "error", machine.Namespace.Name).
Inc()
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "Internal server error", http.StatusInternalServerError)
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
return
}
machineRegistrations.WithLabelValues("update", "web", "success", machine.Namespace.Name).
Inc()
Remove Gin from the Registration handler
2022-06-20 06:30:41 -04:00
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
writer.WriteHeader(http.StatusOK)
Lint fixes 5/n
2022-06-26 06:21:35 -04:00
_, err = writer.Write(respBody)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Failed to write response")
}
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
}
func (h *Headscale) handleMachineExpired(
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer http.ResponseWriter,
req *http.Request,
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
machineKey key.MachinePublic,
Rename idKey to machineKey to keep consistency
2021-11-24 07:15:55 -05:00
registerRequest tailcfg.RegisterRequest,
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
machine Machine,
) {
resp := tailcfg.RegisterResponse{}
// The client has registered before, but has expired
log.Debug().
Rename name -> hostname, nickname -> givenname
2022-04-24 15:54:38 -04:00
Str("machine", machine.Hostname).
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
Msg("Machine registration has expired. Sending a authurl to register")
Add missing iff to handle expired preauthkey machines
2021-11-24 07:15:32 -05:00
if registerRequest.Auth.AuthKey != "" {
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
h.handleAuthKey(writer, req, machineKey, registerRequest)
Add missing iff to handle expired preauthkey machines
2021-11-24 07:15:32 -05:00
return
}
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
if h.cfg.OIDC.Issuer != "" {
resp.AuthURL = fmt.Sprintf("%s/oidc/register/%s",
Minor formatting changes
2022-08-14 06:10:20 -04:00
strings.TrimSuffix(h.cfg.ServerURL, "/"),
NodePublicKeyStripPrefix(registerRequest.NodeKey))
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
} else {
Fix expired node registration URL
2022-08-13 15:17:05 -04:00
resp.AuthURL = fmt.Sprintf("%s/register/%s",
Minor formatting changes
2022-08-14 06:10:20 -04:00
strings.TrimSuffix(h.cfg.ServerURL, "/"),
NodePublicKeyStripPrefix(registerRequest.NodeKey))
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
}
Add missing iff to handle expired preauthkey machines
2021-11-24 07:15:32 -05:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
if err != nil {
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
Err(err).
Msg("Cannot encode message")
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 14:32:11 -05:00
machineRegistrations.WithLabelValues("reauth", "web", "error", machine.Namespace.Name).
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
Inc()
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "Internal server error", http.StatusInternalServerError)
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
return
}
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 14:32:11 -05:00
machineRegistrations.WithLabelValues("reauth", "web", "success", machine.Namespace.Name).
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
Inc()
Remove Gin from the Registration handler
2022-06-20 06:30:41 -04:00
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
writer.WriteHeader(http.StatusOK)
Lint fixes 5/n
2022-06-26 06:21:35 -04:00
_, err = writer.Write(respBody)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Failed to write response")
}
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
}
func (h *Headscale) handleMachineRefreshKey(
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer http.ResponseWriter,
req *http.Request,
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
machineKey key.MachinePublic,
Fix typo
2021-11-22 14:35:24 -05:00
registerRequest tailcfg.RegisterRequest,
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
machine Machine,
) {
resp := tailcfg.RegisterResponse{}
log.Debug().
Rename name -> hostname, nickname -> givenname
2022-04-24 15:54:38 -04:00
Str("machine", machine.Hostname).
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
Msg("We have the OldNodeKey in the database. This is a key refresh")
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
machine.NodeKey = NodePublicKeyStripPrefix(registerRequest.NodeKey)
Check errors of more database calls
2022-05-30 09:39:24 -04:00
if err := h.db.Save(&machine).Error; err != nil {
log.Error().
Caller().
Err(err).
Msg("Failed to update machine key in the database")
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "Internal server error", http.StatusInternalServerError)
Check errors of more database calls
2022-05-30 09:39:24 -04:00
return
}
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
resp.AuthURL = ""
resp.User = *machine.Namespace.toUser()
Rename idKey to machineKey to keep consistency
2021-11-24 07:15:55 -05:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
if err != nil {
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
Err(err).
Msg("Cannot encode message")
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "Internal server error", http.StatusInternalServerError)
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
return
}
Remove Gin from the Registration handler
2022-06-20 06:30:41 -04:00
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
writer.WriteHeader(http.StatusOK)
Lint fixes 5/n
2022-06-26 06:21:35 -04:00
_, err = writer.Write(respBody)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Failed to write response")
}
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
}
func (h *Headscale) handleMachineRegistrationNew(
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer http.ResponseWriter,
req *http.Request,
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
machineKey key.MachinePublic,
Fix typo
2021-11-22 14:35:24 -05:00
registerRequest tailcfg.RegisterRequest,
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
) {
resp := tailcfg.RegisterResponse{}
// The machine registration is new, redirect the client to the registration URL
log.Debug().
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
Str("machine", registerRequest.Hostinfo.Hostname).
Improve protocol implementation for client registration (fixes #706)
2022-08-11 06:11:02 -04:00
Msg("The node seems to be new, sending auth url")
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
if h.cfg.OIDC.Issuer != "" {
resp.AuthURL = fmt.Sprintf(
"%s/oidc/register/%s",
strings.TrimSuffix(h.cfg.ServerURL, "/"),
Fixed another recurrence of MachineKey
2022-08-14 06:04:31 -04:00
NodePublicKeyStripPrefix(registerRequest.NodeKey),
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
)
} else {
Improve protocol implementation for client registration (fixes #706)
2022-08-11 06:11:02 -04:00
resp.AuthURL = fmt.Sprintf("%s/register/%s",
Minor formatting changes
2022-08-14 06:10:20 -04:00
strings.TrimSuffix(h.cfg.ServerURL, "/"),
NodePublicKeyStripPrefix(registerRequest.NodeKey))
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
}
Rename idKey to machineKey to keep consistency
2021-11-24 07:15:55 -05:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
if err != nil {
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
Err(err).
Msg("Cannot encode message")
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "Internal server error", http.StatusInternalServerError)
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
return
}
Remove Gin from the Registration handler
2022-06-20 06:30:41 -04:00
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
writer.WriteHeader(http.StatusOK)
Lint fixes 5/n
2022-06-26 06:21:35 -04:00
_, err = writer.Write(respBody)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Failed to write response")
}
Move registration workflow into functions
2021-11-17 17:39:41 -05:00
}
Add support for multiple IP prefixes
2022-01-16 08:16:59 -05:00
// TODO: check if any locks are needed around IP allocation.
Use the new derp map
2021-10-22 12:56:00 -04:00
func (h *Headscale) handleAuthKey(
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer http.ResponseWriter,
req *http.Request,
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
machineKey key.MachinePublic,
Fix typo
2021-11-22 14:35:24 -05:00
registerRequest tailcfg.RegisterRequest,
Use the new derp map
2021-10-22 12:56:00 -04:00
) {
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
machineKeyStr := MachinePublicKeyStripPrefix(machineKey)
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Debug().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Fix typo
2021-11-22 14:35:24 -05:00
Str("machine", registerRequest.Hostinfo.Hostname).
Msgf("Processing auth key for %s", registerRequest.Hostinfo.Hostname)
Preauth keys kinda working
2021-05-05 18:59:26 -04:00
resp := tailcfg.RegisterResponse{}
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
Fix typo
2021-11-22 14:35:24 -05:00
pak, err := h.checkKeyValidity(registerRequest.Auth.AuthKey)
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
if err != nil {
Fixing nil issue
2021-10-04 12:03:44 -04:00
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Fixing nil issue
2021-10-04 12:03:44 -04:00
Str("func", "handleAuthKey").
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
Str("machine", registerRequest.Hostinfo.Hostname).
Fixing nil issue
2021-10-04 12:03:44 -04:00
Err(err).
Msg("Failed authentication via AuthKey")
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
resp.MachineAuthorized = false
Rename idKey to machineKey to keep consistency
2021-11-24 07:15:55 -05:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Preauth keys kinda working
2021-05-05 18:59:26 -04:00
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
Str("machine", registerRequest.Hostinfo.Hostname).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot encode message")
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "Internal server error", http.StatusInternalServerError)
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "error", pak.Namespace.Name).
Go format with shorter lines
2021-11-13 03:36:45 -05:00
Inc()
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Preauth keys kinda working
2021-05-05 18:59:26 -04:00
return
}
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
writer.WriteHeader(http.StatusUnauthorized)
Lint fixes 5/n
2022-06-26 06:21:35 -04:00
_, err = writer.Write(respBody)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Failed to write response")
}
Remove Gin from the Registration handler
2022-06-20 06:30:41 -04:00
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
Str("machine", registerRequest.Hostinfo.Hostname).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Msg("Failed authentication via AuthKey")
Refresh expired machine on re-auth - closes #489
2022-03-10 08:59:28 -05:00
if pak != nil {
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "error", pak.Namespace.Name).
Inc()
} else {
Fix labels cardinality error when registering unknown pre-auth key
2022-03-21 04:49:14 -04:00
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "error", "unknown").Inc()
Refresh expired machine on re-auth - closes #489
2022-03-10 08:59:28 -05:00
}
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
return
}
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
log.Debug().
Str("func", "handleAuthKey").
Str("machine", registerRequest.Hostinfo.Hostname).
Msg("Authentication key was valid, proceeding to acquire IP addresses")
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 14:32:11 -05:00
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
nodeKey := NodePublicKeyStripPrefix(registerRequest.NodeKey)
Implement new machine register parameter
2022-02-28 11:34:50 -05:00
Refresh expired machine on re-auth - closes #489
2022-03-10 08:59:28 -05:00
// retrieve machine information if it exist
// The error is not important, because if it does not
// exist, then this is a new machine and we will move
// on to registration.
machine, _ := h.GetMachineByMachineKey(machineKey)
if machine != nil {
log.Trace().
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
Caller().
Rename name -> hostname, nickname -> givenname
2022-04-24 15:54:38 -04:00
Str("machine", machine.Hostname).
Refresh expired machine on re-auth - closes #489
2022-03-10 08:59:28 -05:00
Msg("machine already registered, refreshing with new auth key")
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Refresh expired machine on re-auth - closes #489
2022-03-10 08:59:28 -05:00
machine.NodeKey = nodeKey
machine.AuthKeyID = uint(pak.ID)
Lint fixes 7/n
2022-06-26 06:30:52 -04:00
err := h.RefreshMachine(machine, registerRequest.Expiry)
if err != nil {
log.Error().
Caller().
Str("machine", machine.Hostname).
Err(err).
Msg("Failed to refresh machine")
return
}
Refresh expired machine on re-auth - closes #489
2022-03-10 08:59:28 -05:00
} else {
now := time.Now().UTC()
Make sure givenname is set for preauthkeys
2022-05-17 16:02:18 -04:00
givenName, err := h.GenerateGivenName(registerRequest.Hostinfo.Hostname)
if err != nil {
log.Error().
Caller().
Str("func", "RegistrationHandler").
Str("hostinfo.name", registerRequest.Hostinfo.Hostname).
Err(err)
return
}
Refresh expired machine on re-auth - closes #489
2022-03-10 08:59:28 -05:00
machineToRegister := Machine{
Rename name -> hostname, nickname -> givenname
2022-04-24 15:54:38 -04:00
Hostname: registerRequest.Hostinfo.Hostname,
Make sure givenname is set for preauthkeys
2022-05-17 16:02:18 -04:00
GivenName: givenName,
Refresh expired machine on re-auth - closes #489
2022-03-10 08:59:28 -05:00
NamespaceID: pak.Namespace.ID,
MachineKey: machineKeyStr,
RegisterMethod: RegisterMethodAuthKey,
Expiry: &registerRequest.Expiry,
NodeKey: nodeKey,
LastSeen: &now,
AuthKeyID: uint(pak.ID),
}
fixed lint errors
2022-03-10 10:22:21 -05:00
Refresh expired machine on re-auth - closes #489
2022-03-10 08:59:28 -05:00
machine, err = h.RegisterMachine(
machineToRegister,
)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("could not register machine")
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "error", pak.Namespace.Name).
Inc()
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "Internal server error", http.StatusInternalServerError)
fixed lint errors
2022-03-10 10:22:21 -05:00
Refresh expired machine on re-auth - closes #489
2022-03-10 08:59:28 -05:00
return
fixed lint errors
2022-03-10 10:22:21 -05:00
}
Initial commit
2020-06-21 06:32:08 -04:00
}
Preauth keys kinda working
2021-05-05 18:59:26 -04:00
Lint fixes 7/n
2022-06-26 06:30:52 -04:00
err = h.UsePreAuthKey(pak)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Failed to use pre-auth key")
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "error", pak.Namespace.Name).
Inc()
http.Error(writer, "Internal server error", http.StatusInternalServerError)
return
}
updates from code review
2021-10-10 05:22:42 -04:00
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
resp.MachineAuthorized = true
resp.User = *pak.Namespace.toUser()
Rename idKey to machineKey to keep consistency
2021-11-24 07:15:55 -05:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Initial commit
2020-06-21 06:32:08 -04:00
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Factor wgkey to types/key This commit converts all the uses of wgkey to the new key interfaces. It now has specific machine, node and discovery keys and we now should use them correctly. Please note the new logic which strips a key prefix (in utils.go) that is now standard inside tailscale. In theory we could put it in the database, but to preserve backwards compatibility and not spend a lot of resources on accounting for both, we just strip them.
2021-11-26 18:30:42 -05:00
Caller().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
Str("machine", registerRequest.Hostinfo.Hostname).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot encode message")
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "error", pak.Namespace.Name).
Go format with shorter lines
2021-11-13 03:36:45 -05:00
Inc()
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
http.Error(writer, "Internal server error", http.StatusInternalServerError)
Add and fix nlreturn (new line return)
2021-11-14 10:46:09 -05:00
Initial commit
2020-06-21 06:32:08 -04:00
return
}
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "success", pak.Namespace.Name).
Go format with shorter lines
2021-11-13 03:36:45 -05:00
Inc()
Lint fixes 2/n
2022-06-26 05:55:37 -04:00
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
writer.WriteHeader(http.StatusOK)
Lint fixes 5/n
2022-06-26 06:21:35 -04:00
_, err = writer.Write(respBody)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Failed to write response")
}
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Info().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Register new machines needing callback in memory This commit stores temporary registration data in cache, instead of memory allowing us to only have actually registered machines in the database.
2022-02-28 03:06:39 -05:00
Str("machine", registerRequest.Hostinfo.Hostname).
Add support for multiple IP prefixes
2022-01-16 08:16:59 -05:00
Str("ips", strings.Join(machine.IPAddresses.ToStringSlice(), ", ")).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Msg("Successfully authenticated via AuthKey")
Initial commit
2020-06-21 06:32:08 -04:00
}
Reference in New Issue Copy Permalink