TheArchive/headscale
1
0
Fork 0
mirror of https://github.com/juanfont/headscale.git synced 2024-12-22 16:07:34 +00:00
Code Issues Packages Projects Releases Wiki Activity
headscale/api.go

633 lines
16 KiB
Go
Raw Normal View History

Initial commit
2020-06-21 12:32:08 +02:00
package headscale
import (
Template Fixes
2021-12-22 19:43:53 -07:00
"bytes"
Initial commit
2020-06-21 12:32:08 +02:00
"encoding/binary"
"encoding/json"
Update Headscale to depend on gorm v2
2021-06-24 15:44:19 +02:00
"errors"
Initial commit
2020-06-21 12:32:08 +02:00
"fmt"
Template Fixes
2021-12-22 19:43:53 -07:00
"html/template"
Initial commit
2020-06-21 12:32:08 +02:00
"io"
"net/http"
updates from code review
2021-10-08 17:43:52 +08:00
"strings"
Initial commit
2020-06-21 12:32:08 +02:00
"time"
"github.com/gin-gonic/gin"
"github.com/klauspost/compress/zstd"
golangci-lint --fix
2021-11-13 08:39:04 +00:00
"github.com/rs/zerolog/log"
Update Headscale to depend on gorm v2
2021-06-24 15:44:19 +02:00
"gorm.io/gorm"
Initial commit
2020-06-21 12:32:08 +02: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 23:30:42 +00:00
"tailscale.com/types/key"
Initial commit
2020-06-21 12:32:08 +02:00
)
Make "authKey" a constant
2021-11-18 08:49:55 +00:00
const (
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 19:32:52 +00:00
reservedResponseHeaderSize = 4
Fix excessive replace
2022-02-27 18:48:12 +01: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 19:32:52 +00:00
RegisterMethodOIDC = "oidc"
RegisterMethodCLI = "cli"
ErrRegisterMethodCLIDoesNotSupportExpire = Error(
"machines registered with CLI does not support expire",
)
Make "authKey" a constant
2021-11-18 08:49:55 +00:00
)
Remove all instances of undefined numbers (gonmd)
2021-11-14 18:31:51 +01:00
Initial multi-user support using namespaces
2021-02-28 00:58:09 +01:00
// KeyHandler provides the Headscale pub key
golangci-lint --fix
2021-11-13 08:39:04 +00:00
// Listens in /key.
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
func (h *Headscale) KeyHandler(ctx *gin.Context) {
ctx.Data(
http.StatusOK,
"text/plain; charset=utf-8",
Add back privatekey, but automatically generate it if it does not exist
2021-11-28 09:17:18 +00:00
[]byte(MachinePublicKeyStripPrefix(h.privateKey.Public())),
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
)
Initial commit
2020-06-21 12:32:08 +02:00
}
Template Fixes
2021-12-22 19:43:53 -07:00
type registerWebAPITemplateConfig struct {
Key string
}
Initial multi-user support using namespaces
2021-02-28 00:58:09 +01:00
Template Fixes
2021-12-22 19:43:53 -07:00
var registerWebAPITemplate = template.Must(
template.New("registerweb").Parse(`<html>
Initial multi-user support using namespaces
2021-02-28 00:58:09 +01:00
<body>
<h1>headscale</h1>
<p>
Remove dependency on postgres' jsonb
2021-05-15 00:05:41 +02:00
Run the command below in the headscale server to add this machine to your network:
Initial multi-user support using namespaces
2021-02-28 00:58:09 +01:00
</p>
<p>
<code>
Template Fixes
2021-12-22 19:43:53 -07:00
<b>headscale -n NAMESPACE nodes register --key {{.Key}}</b>
Initial multi-user support using namespaces
2021-02-28 00:58:09 +01:00
</code>
</p>
</body>
Template Fixes
2021-12-22 19:43:53 -07:00
</html>`),
)
// RegisterWebAPI shows a simple message in the browser to point to the CLI
// Listens in /register.
func (h *Headscale) RegisterWebAPI(ctx *gin.Context) {
machineKeyStr := ctx.Query("key")
if machineKeyStr == "" {
ctx.String(http.StatusBadRequest, "Wrong params")
return
}
var content bytes.Buffer
if err := registerWebAPITemplate.Execute(&content, registerWebAPITemplateConfig{
Key: machineKeyStr,
}); err != nil {
log.Error().
Str("func", "RegisterWebAPI").
Err(err).
Msg("Could not render register web API template")
ctx.Data(
http.StatusInternalServerError,
"text/html; charset=utf-8",
[]byte("Could not render register web API template"),
)
}
Improved tailnode start up handling
2021-05-24 21:59:03 +02:00
Template Fixes
2021-12-22 19:43:53 -07:00
ctx.Data(http.StatusOK, "text/html; charset=utf-8", content.Bytes())
Initial multi-user support using namespaces
2021-02-28 00:58:09 +01:00
}
// RegistrationHandler handles the actual registration process of a machine
golangci-lint --fix
2021-11-13 08:39:04 +00:00
// Endpoint /machine/:id.
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
func (h *Headscale) RegistrationHandler(ctx *gin.Context) {
body, _ := io.ReadAll(ctx.Request.Body)
machineKeyStr := ctx.Param("id")
Unmarshal keys in the non-deprecated way
2021-11-26 23:50:42 +00:00
var machineKey key.MachinePublic
Ensure we always have the key prefix when needed
2021-11-27 20:25:12 +00:00
err := machineKey.UnmarshalText([]byte(MachinePublicKeyEnsurePrefix(machineKeyStr)))
Initial commit
2020-06-21 12:32:08 +02:00
if err != nil {
Initial port to zerologger
2021-08-05 18:11:26 +01: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 23:30:42 +00:00
Caller().
Initial port to zerologger
2021-08-05 18:11:26 +01:00
Err(err).
Msg("Cannot parse machine key")
updates from code review
2021-10-10 17:22:42 +08:00
machineRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
ctx.String(http.StatusInternalServerError, "Sad!")
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01:00
Initial commit
2020-06-21 12:32:08 +02:00
return
}
req := tailcfg.RegisterRequest{}
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
err = decode(body, &req, &machineKey, h.privateKey)
Initial commit
2020-06-21 12:32:08 +02:00
if err != nil {
Initial port to zerologger
2021-08-05 18:11:26 +01: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 23:30:42 +00:00
Caller().
Initial port to zerologger
2021-08-05 18:11:26 +01:00
Err(err).
Msg("Cannot decode message")
updates from code review
2021-10-10 17:22:42 +08:00
machineRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
ctx.String(http.StatusInternalServerError, "Very sad!")
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01:00
Initial commit
2020-06-21 12:32:08 +02:00
return
}
Preauth keys kinda working
2021-05-06 00:59:26 +02: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 23:24:22 +01: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 23:30:42 +00:00
machine, err := h.GetMachineByMachineKey(machineKey)
updates from code review
2021-10-10 17:22:42 +08:00
if errors.Is(err, gorm.ErrRecordNotFound) {
Make log keys lowercase
2021-08-05 20:57:47 +01:00
log.Info().Str("machine", req.Hostinfo.Hostname).Msg("New 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 08:06:39 +00:00
machineKeyStr := MachinePublicKeyStripPrefix(machineKey)
// If the machine has AuthKey set, handle registration via PreAuthKeys
if req.Auth.AuthKey != "" {
h.handleAuthKey(ctx, machineKey, req)
return
}
// 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 17:22:42 +08:00
newMachine := Machine{
Expiry: &time.Time{},
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 08:06:39 +00:00
MachineKey: machineKeyStr,
updates from code review
2021-10-10 17:22:42 +08:00
Name: req.Hostinfo.Hostname,
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 08:06:39 +00:00
NodeKey: NodePublicKeyStripPrefix(req.NodeKey),
LastSeen: &now,
Handle client sending new NodeKey (fixes #32)
2021-06-05 12:13:55 +02:00
}
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01: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 08:06:39 +00:00
h.registrationCache.Set(
machineKeyStr,
newMachine,
requestedExpiryCacheExpiration,
)
h.handleMachineRegistrationNew(ctx, machineKey, req)
Implement new machine register parameter
2022-02-28 16:34:50 +00: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 08:06:39 +00:00
return
Handle client sending new NodeKey (fixes #32)
2021-06-05 12:13:55 +02: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 08:06:39 +00: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 13:59:24 +00: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
Make sure comparison of nodekey is on the same format
2021-11-28 08:23:45 +00:00
if machine.NodeKey == NodePublicKeyStripPrefix(req.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 13:59:24 +00: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
if !req.Expiry.IsZero() && req.Expiry.UTC().Before(now) {
Remove unused param
2021-11-21 14:00:48 +00:00
h.handleMachineLogOut(ctx, 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 13:59:24 +00: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() {
h.handleMachineValidRegistration(ctx, machineKey, *machine)
return
}
updates from code review
2021-10-08 17:43:52 +08: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 13:59:24 +00:00
// The NodeKey we have matches OldNodeKey, which means this is a refresh after a key expiration
Make sure comparison of nodekey is on the same format
2021-11-28 08:23:45 +00:00
if machine.NodeKey == NodePublicKeyStripPrefix(req.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 13:59:24 +00:00
!machine.isExpired() {
h.handleMachineRefreshKey(ctx, machineKey, req, *machine)
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01:00
Initial commit
2020-06-21 12:32:08 +02:00
return
}
Move handle expired machine to the end of registration
2021-11-21 21:14:13 +00:00
// The machine has expired
Add missing request arguemnt
2021-11-24 12:16:56 +00:00
h.handleMachineExpired(ctx, machineKey, req, *machine)
Move handle expired machine to the end of registration
2021-11-21 21:14:13 +00:00
return
Initial commit
2020-06-21 12:32:08 +02:00
}
}
Go format with shorter lines
2021-11-13 08:36:45 +00: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 23:30:42 +00:00
machineKey key.MachinePublic,
Go format with shorter lines
2021-11-13 08:36:45 +00:00
req tailcfg.MapRequest,
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
machine *Machine,
Go format with shorter lines
2021-11-13 08:36:45 +00:00
) ([]byte, error) {
Add more trace logging
2021-08-05 21:47:06 +01:00
log.Trace().
Str("func", "getMapResponse").
Str("machine", req.Hostinfo.Hostname).
Msg("Creating Map response")
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
node, err := machine.toNode(h.cfg.BaseDomain, h.cfg.DNSConfig, true)
Initial commit
2020-06-21 12:32:08 +02:00
if err != nil {
Initial port to zerologger
2021-08-05 18:11:26 +01: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 23:30:42 +00:00
Caller().
Make log keys lowercase
2021-08-05 20:57:47 +01:00
Str("func", "getMapResponse").
Initial port to zerologger
2021-08-05 18:11:26 +01:00
Err(err).
Msg("Cannot convert to node")
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01:00
Initial commit
2020-06-21 12:32:08 +02:00
return nil, err
}
Move DB call of pollmap to Machine inside a function
2021-10-02 21:58:28 +01: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 19:51:16 +00:00
peers, err := h.getValidPeers(machine)
Initial commit
2020-06-21 12:32:08 +02:00
if err != nil {
Initial port to zerologger
2021-08-05 18:11:26 +01: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 23:30:42 +00:00
Caller().
Make log keys lowercase
2021-08-05 20:57:47 +01:00
Str("func", "getMapResponse").
Initial port to zerologger
2021-08-05 18:11:26 +01:00
Err(err).
Msg("Cannot fetch peers")
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01:00
Initial commit
2020-06-21 12:32:08 +02:00
return nil, err
}
Send the namespace name as user to the clients
2021-07-11 16:39:19 +02:00
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
profiles := getMapResponseUserProfiles(*machine, peers)
Send the namespace name as user to the clients
2021-07-11 16:39:19 +02:00
MagicDNS changes merged back
2021-10-04 23:49:16 +02: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 22:03:34 +01: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 23:30:42 +00: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 22:03:34 +01:00
Str("func", "getMapResponse").
Err(err).
Msg("Failed to convert peers to Tailscale nodes")
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01: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 22:03:34 +01:00
return nil, err
}
Remove unused params or returns
2021-11-14 18:03:21 +01:00
dnsConfig := getMapResponseDNSConfig(
Go format with shorter lines
2021-11-13 08:36:45 +00:00
h.cfg.DNSConfig,
h.cfg.BaseDomain,
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
*machine,
Go format with shorter lines
2021-11-13 08:36:45 +00:00
peers,
)
Send search domains
2021-10-02 12:13:19 +02:00
Initial commit
2020-06-21 12:32:08 +02:00
resp := tailcfg.MapResponse{
Propagate dns config vales across Headscale
2021-10-02 11:20:42 +02:00
KeepAlive: false,
Node: node,
Merged main
2021-10-04 23:43:42 +02:00
Peers: nodePeers,
Send search domains
2021-10-02 12:13:19 +02:00
DNSConfig: dnsConfig,
Propagate dns config vales across Headscale
2021-10-02 11:20:42 +02:00
Domain: h.cfg.BaseDomain,
Use long command in example and remove pointerlist
2021-11-04 22:18:06 +00:00
PacketFilter: h.aclRules,
Use the new derp map
2021-10-22 16:56:00 +00:00
DERPMap: h.DERPMap,
Send UserProfile info for the peers' namespaces
2021-10-17 12:07:01 +02:00
UserProfiles: profiles,
Minor thing
2021-02-24 00:31:58 +01:00
}
Send UserProfile info for the peers' namespaces
2021-10-17 12:07:01 +02:00
Resolve merge conflict
2021-08-13 10:33:19 +01:00
log.Trace().
Str("func", "getMapResponse").
Str("machine", req.Hostinfo.Hostname).
Comment out aggressive logging
2021-10-05 16:51:42 +00:00
// Interface("payload", resp).
Resolve merge conflict
2021-08-13 10:33:19 +01:00
Msgf("Generated map response: %s", tailMapResponseToString(resp))
Initial commit
2020-06-21 12:32:08 +02:00
var respBody []byte
if req.Compress == "zstd" {
chore(all): update some files for linter
2022-02-14 15:26:54 +01: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 10:33:19 +01:00
Initial commit
2020-06-21 12:32:08 +02: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 23:30:42 +00:00
respBody = h.privateKey.SealTo(machineKey, srcCompressed)
Initial commit
2020-06-21 12:32:08 +02:00
} else {
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
respBody, err = encode(resp, &machineKey, h.privateKey)
Initial commit
2020-06-21 12:32:08 +02: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 17:24:24 +00:00
data := make([]byte, reservedResponseHeaderSize)
Initial commit
2020-06-21 12:32:08 +02:00
binary.LittleEndian.PutUint32(data, uint32(len(respBody)))
data = append(data, respBody...)
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01: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 17:39:01 +00:00
return data, nil
Initial commit
2020-06-21 12:32:08 +02:00
}
Go format with shorter lines
2021-11-13 08:36:45 +00: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 23:30:42 +00:00
machineKey key.MachinePublic,
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
mapRequest tailcfg.MapRequest,
Go format with shorter lines
2021-11-13 08:36:45 +00:00
) ([]byte, error) {
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
mapResponse := tailcfg.MapResponse{
Initial commit
2020-06-21 12:32:08 +02:00
KeepAlive: true,
}
var respBody []byte
var err error
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
if mapRequest.Compress == "zstd" {
chore(all): update some files for linter
2022-02-14 15:26:54 +01: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 12:32:08 +02: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 23:30:42 +00:00
respBody = h.privateKey.SealTo(machineKey, srcCompressed)
Initial commit
2020-06-21 12:32:08 +02:00
} else {
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
respBody, err = encode(mapResponse, &machineKey, h.privateKey)
Initial commit
2020-06-21 12:32:08 +02:00
if err != nil {
return nil, err
}
}
Add and fix stylecheck (golint replacement)
2021-11-15 17:24:24 +00:00
data := make([]byte, reservedResponseHeaderSize)
Initial commit
2020-06-21 12:32:08 +02:00
binary.LittleEndian.PutUint32(data, uint32(len(respBody)))
data = append(data, respBody...)
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01: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 17:39:01 +00:00
return data, nil
Initial commit
2020-06-21 12:32:08 +02:00
}
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
func (h *Headscale) handleMachineLogOut(
ctx *gin.Context,
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 23:30:42 +00:00
machineKey key.MachinePublic,
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
machine Machine,
) {
resp := tailcfg.RegisterResponse{}
log.Info().
Str("machine", machine.Name).
Msg("Client requested logout")
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 13:59:24 +00:00
h.ExpireMachine(&machine)
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
resp.AuthURL = ""
resp.MachineAuthorized = false
resp.User = *machine.Namespace.toUser()
Rename idKey to machineKey to keep consistency
2021-11-24 12:15:55 +00:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 22:39:41 +00: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 23:30:42 +00:00
Caller().
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
Err(err).
Msg("Cannot encode message")
ctx.String(http.StatusInternalServerError, "")
return
}
ctx.Data(http.StatusOK, "application/json; charset=utf-8", respBody)
}
func (h *Headscale) handleMachineValidRegistration(
ctx *gin.Context,
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 23:30:42 +00:00
machineKey key.MachinePublic,
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
machine Machine,
) {
resp := tailcfg.RegisterResponse{}
// The machine registration is valid, respond with redirect to /map
log.Debug().
Str("machine", machine.Name).
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 12:15:55 +00:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 22:39:41 +00: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 23:30:42 +00:00
Caller().
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
Err(err).
Msg("Cannot encode message")
machineRegistrations.WithLabelValues("update", "web", "error", machine.Namespace.Name).
Inc()
ctx.String(http.StatusInternalServerError, "")
return
}
machineRegistrations.WithLabelValues("update", "web", "success", machine.Namespace.Name).
Inc()
ctx.Data(http.StatusOK, "application/json; charset=utf-8", respBody)
}
func (h *Headscale) handleMachineExpired(
ctx *gin.Context,
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 23:30:42 +00:00
machineKey key.MachinePublic,
Rename idKey to machineKey to keep consistency
2021-11-24 12:15:55 +00:00
registerRequest tailcfg.RegisterRequest,
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
machine Machine,
) {
resp := tailcfg.RegisterResponse{}
// The client has registered before, but has expired
log.Debug().
Str("machine", machine.Name).
Msg("Machine registration has expired. Sending a authurl to register")
Add missing iff to handle expired preauthkey machines
2021-11-24 12:15:32 +00:00
if registerRequest.Auth.AuthKey != "" {
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 08:06:39 +00:00
h.handleAuthKey(ctx, machineKey, registerRequest)
Add missing iff to handle expired preauthkey machines
2021-11-24 12:15:32 +00:00
return
}
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
if h.cfg.OIDC.Issuer != "" {
resp.AuthURL = fmt.Sprintf("%s/oidc/register/%s",
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 23:30:42 +00:00
strings.TrimSuffix(h.cfg.ServerURL, "/"), machineKey.String())
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
} else {
resp.AuthURL = fmt.Sprintf("%s/register?key=%s",
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 23:30:42 +00:00
strings.TrimSuffix(h.cfg.ServerURL, "/"), machineKey.String())
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
}
Add missing iff to handle expired preauthkey machines
2021-11-24 12:15:32 +00:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 22:39:41 +00: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 23:30:42 +00:00
Caller().
Move registration workflow into functions
2021-11-17 22:39:41 +00: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 19:32:11 +00:00
machineRegistrations.WithLabelValues("reauth", "web", "error", machine.Namespace.Name).
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
Inc()
ctx.String(http.StatusInternalServerError, "")
return
}
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 19:32:11 +00:00
machineRegistrations.WithLabelValues("reauth", "web", "success", machine.Namespace.Name).
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
Inc()
ctx.Data(http.StatusOK, "application/json; charset=utf-8", respBody)
}
func (h *Headscale) handleMachineRefreshKey(
ctx *gin.Context,
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 23:30:42 +00:00
machineKey key.MachinePublic,
Fix typo
2021-11-22 19:35:24 +00:00
registerRequest tailcfg.RegisterRequest,
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
machine Machine,
) {
resp := tailcfg.RegisterResponse{}
log.Debug().
Str("machine", machine.Name).
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 23:30:42 +00:00
machine.NodeKey = NodePublicKeyStripPrefix(registerRequest.NodeKey)
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
h.db.Save(&machine)
resp.AuthURL = ""
resp.User = *machine.Namespace.toUser()
Rename idKey to machineKey to keep consistency
2021-11-24 12:15:55 +00:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 22:39:41 +00: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 23:30:42 +00:00
Caller().
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
Err(err).
Msg("Cannot encode message")
ctx.String(http.StatusInternalServerError, "Extremely sad!")
return
}
ctx.Data(http.StatusOK, "application/json; charset=utf-8", respBody)
}
func (h *Headscale) handleMachineRegistrationNew(
ctx *gin.Context,
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 23:30:42 +00:00
machineKey key.MachinePublic,
Fix typo
2021-11-22 19:35:24 +00:00
registerRequest tailcfg.RegisterRequest,
Move registration workflow into functions
2021-11-17 22:39:41 +00: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 08:06:39 +00:00
Str("machine", registerRequest.Hostinfo.Hostname).
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
Msg("The node is sending us a new NodeKey, sending auth url")
if h.cfg.OIDC.Issuer != "" {
resp.AuthURL = fmt.Sprintf(
"%s/oidc/register/%s",
strings.TrimSuffix(h.cfg.ServerURL, "/"),
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 23:30:42 +00:00
machineKey.String(),
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
)
} else {
resp.AuthURL = fmt.Sprintf("%s/register?key=%s",
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 23:30:42 +00:00
strings.TrimSuffix(h.cfg.ServerURL, "/"), MachinePublicKeyStripPrefix(machineKey))
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
}
Fix typo
2021-11-22 19:35:24 +00:00
if !registerRequest.Expiry.IsZero() {
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 19:32:52 +00:00
log.Trace().
Caller().
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 08:06:39 +00:00
Str("machine", registerRequest.Hostinfo.Hostname).
Fix typo
2021-11-22 19:35:24 +00:00
Time("expiry", registerRequest.Expiry).
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 19:32:52 +00:00
Msg("Non-zero expiry time requested, adding to cache")
h.requestedExpiryCache.Set(
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 23:30:42 +00:00
machineKey.String(),
Fix typo
2021-11-22 19:35:24 +00:00
registerRequest.Expiry,
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 19:32:52 +00:00
requestedExpiryCacheExpiration,
)
Remove expiry logic, this needs to be redone
2021-11-19 09:02:29 +00:00
}
Rename idKey to machineKey to keep consistency
2021-11-24 12:15:55 +00:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 22:39:41 +00: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 23:30:42 +00:00
Caller().
Move registration workflow into functions
2021-11-17 22:39:41 +00:00
Err(err).
Msg("Cannot encode message")
ctx.String(http.StatusInternalServerError, "")
return
}
ctx.Data(http.StatusOK, "application/json; charset=utf-8", respBody)
}
Add support for multiple IP prefixes
2022-01-16 14:16:59 +01:00
// TODO: check if any locks are needed around IP allocation.
Use the new derp map
2021-10-22 16:56:00 +00:00
func (h *Headscale) handleAuthKey(
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
ctx *gin.Context,
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 23:30:42 +00:00
machineKey key.MachinePublic,
Fix typo
2021-11-22 19:35:24 +00:00
registerRequest tailcfg.RegisterRequest,
Use the new derp map
2021-10-22 16:56:00 +00: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 08:06:39 +00:00
machineKeyStr := MachinePublicKeyStripPrefix(machineKey)
Initial port to zerologger
2021-08-05 18:11:26 +01:00
log.Debug().
Make log keys lowercase
2021-08-05 20:57:47 +01:00
Str("func", "handleAuthKey").
Fix typo
2021-11-22 19:35:24 +00:00
Str("machine", registerRequest.Hostinfo.Hostname).
Msgf("Processing auth key for %s", registerRequest.Hostinfo.Hostname)
Preauth keys kinda working
2021-05-06 00:59:26 +02: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 08:06:39 +00:00
Fix typo
2021-11-22 19:35:24 +00:00
pak, err := h.checkKeyValidity(registerRequest.Auth.AuthKey)
Handle client sending new NodeKey (fixes #32)
2021-06-05 12:13:55 +02:00
if err != nil {
Fixing nil issue
2021-10-04 18:03:44 +02: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 23:30:42 +00:00
Caller().
Fixing nil issue
2021-10-04 18:03:44 +02: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 08:06:39 +00:00
Str("machine", registerRequest.Hostinfo.Hostname).
Fixing nil issue
2021-10-04 18:03:44 +02:00
Err(err).
Msg("Failed authentication via AuthKey")
Handle client sending new NodeKey (fixes #32)
2021-06-05 12:13:55 +02:00
resp.MachineAuthorized = false
Rename idKey to machineKey to keep consistency
2021-11-24 12:15:55 +00:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Preauth keys kinda working
2021-05-06 00:59:26 +02:00
if err != nil {
Initial port to zerologger
2021-08-05 18:11:26 +01: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 23:30:42 +00:00
Caller().
Make log keys lowercase
2021-08-05 20:57:47 +01: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 08:06:39 +00:00
Str("machine", registerRequest.Hostinfo.Hostname).
Initial port to zerologger
2021-08-05 18:11:26 +01:00
Err(err).
Msg("Cannot encode message")
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
ctx.String(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 08:06:39 +00:00
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "error", pak.Namespace.Name).
Go format with shorter lines
2021-11-13 08:36:45 +00:00
Inc()
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01:00
Preauth keys kinda working
2021-05-06 00:59:26 +02: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 08:06:39 +00:00
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
ctx.Data(http.StatusUnauthorized, "application/json; charset=utf-8", respBody)
Initial port to zerologger
2021-08-05 18:11:26 +01: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 23:30:42 +00:00
Caller().
Make log keys lowercase
2021-08-05 20:57:47 +01: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 08:06:39 +00:00
Str("machine", registerRequest.Hostinfo.Hostname).
Initial port to zerologger
2021-08-05 18:11:26 +01:00
Msg("Failed authentication via AuthKey")
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 08:06:39 +00:00
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "error", pak.Namespace.Name).
Go format with shorter lines
2021-11-13 08:36:45 +00:00
Inc()
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01:00
Handle client sending new NodeKey (fixes #32)
2021-06-05 12:13:55 +02:00
return
}
Initial port to zerologger
2021-08-05 18:11:26 +01: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 08:06:39 +00: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 19:32:11 +00: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 08:06:39 +00:00
nodeKey := NodePublicKeyStripPrefix(registerRequest.NodeKey)
now := time.Now().UTC()
Implement new machine register parameter
2022-02-28 16:34:50 +00:00
machineToRegister := Machine{
Name: registerRequest.Hostinfo.Hostname,
NamespaceID: pak.Namespace.ID,
MachineKey: machineKeyStr,
RegisterMethod: RegisterMethodAuthKey,
Expiry: &registerRequest.Expiry,
NodeKey: nodeKey,
LastSeen: &now,
AuthKeyID: uint(pak.ID),
}
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 08:06:39 +00:00
machine, err := h.RegisterMachine(
Implement new machine register parameter
2022-02-28 16:34:50 +00:00
machineToRegister,
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 08:06:39 +00:00
)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("could not register machine")
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "error", pak.Namespace.Name).
Inc()
ctx.String(
http.StatusInternalServerError,
"could not register machine",
Generalise registration for pre auth keys
2022-02-27 18:42:15 +01:00
)
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01: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 08:06:39 +00:00
return
Initial commit
2020-06-21 12:32:08 +02:00
}
Preauth keys kinda working
2021-05-06 00:59:26 +02: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 08:06:39 +00:00
h.UsePreAuthKey(pak)
updates from code review
2021-10-10 17:22:42 +08:00
Handle client sending new NodeKey (fixes #32)
2021-06-05 12:13:55 +02:00
resp.MachineAuthorized = true
resp.User = *pak.Namespace.toUser()
Rename idKey to machineKey to keep consistency
2021-11-24 12:15:55 +00:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Initial commit
2020-06-21 12:32:08 +02:00
if err != nil {
Initial port to zerologger
2021-08-05 18:11:26 +01: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 23:30:42 +00:00
Caller().
Make log keys lowercase
2021-08-05 20:57:47 +01: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 08:06:39 +00:00
Str("machine", registerRequest.Hostinfo.Hostname).
Initial port to zerologger
2021-08-05 18:11:26 +01: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 08:06:39 +00:00
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "error", pak.Namespace.Name).
Go format with shorter lines
2021-11-13 08:36:45 +00:00
Inc()
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
ctx.String(http.StatusInternalServerError, "Extremely sad!")
Add and fix nlreturn (new line return)
2021-11-14 16:46:09 +01:00
Initial commit
2020-06-21 12:32:08 +02: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 08:06:39 +00:00
machineRegistrations.WithLabelValues("new", RegisterMethodAuthKey, "success", pak.Namespace.Name).
Go format with shorter lines
2021-11-13 08:36:45 +00:00
Inc()
Initial work eliminating one/two letter variables
2021-11-14 20:32:03 +01:00
ctx.Data(http.StatusOK, "application/json; charset=utf-8", respBody)
Initial port to zerologger
2021-08-05 18:11:26 +01:00
log.Info().
Make log keys lowercase
2021-08-05 20:57:47 +01: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 08:06:39 +00:00
Str("machine", registerRequest.Hostinfo.Hostname).
Add support for multiple IP prefixes
2022-01-16 14:16:59 +01:00
Str("ips", strings.Join(machine.IPAddresses.ToStringSlice(), ", ")).
Initial port to zerologger
2021-08-05 18:11:26 +01:00
Msg("Successfully authenticated via AuthKey")
Initial commit
2020-06-21 12:32:08 +02:00
}
Reference in New Issue Copy Permalink