myriation/headscale
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity
headscale/api.go

594 lines
15 KiB
Go
Raw Normal View History

Initial commit
2020-06-21 04:32:08 -06:00
package headscale
import (
"encoding/binary"
"encoding/json"
Update Headscale to depend on gorm v2
2021-06-24 07:44:19 -06:00
"errors"
Initial commit
2020-06-21 04:32:08 -06:00
"fmt"
"io"
"net/http"
updates from code review
2021-10-08 03:43:52 -06:00
"strings"
Initial commit
2020-06-21 04:32:08 -06:00
"time"
"github.com/gin-gonic/gin"
"github.com/klauspost/compress/zstd"
golangci-lint --fix
2021-11-13 01:39:04 -07:00
"github.com/rs/zerolog/log"
Update Headscale to depend on gorm v2
2021-06-24 07:44:19 -06:00
"gorm.io/gorm"
Initial commit
2020-06-21 04:32:08 -06: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 16:30:42 -07:00
"tailscale.com/types/key"
Initial commit
2020-06-21 04:32:08 -06:00
)
Make "authKey" a constant
2021-11-18 01:49:55 -07:00
const (
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 12:32:52 -07:00
reservedResponseHeaderSize = 4
RegisterMethodAuthKey = "authKey"
RegisterMethodOIDC = "oidc"
RegisterMethodCLI = "cli"
ErrRegisterMethodCLIDoesNotSupportExpire = Error(
"machines registered with CLI does not support expire",
)
Make "authKey" a constant
2021-11-18 01:49:55 -07:00
)
Remove all instances of undefined numbers (gonmd)
2021-11-14 10:31:51 -07:00
Initial multi-user support using namespaces
2021-02-27 16:58:09 -07:00
// KeyHandler provides the Headscale pub key
golangci-lint --fix
2021-11-13 01:39:04 -07:00
// Listens in /key.
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
func (h *Headscale) KeyHandler(ctx *gin.Context) {
ctx.Data(
http.StatusOK,
"text/plain; charset=utf-8",
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 16:30:42 -07:00
[]byte(MachinePublicKeyStripPrefix(*h.publicKey)),
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
)
Initial commit
2020-06-21 04:32:08 -06:00
}
Initial multi-user support using namespaces
2021-02-27 16:58:09 -07:00
// RegisterWebAPI shows a simple message in the browser to point to the CLI
golangci-lint --fix
2021-11-13 01:39:04 -07:00
// Listens in /register.
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
func (h *Headscale) RegisterWebAPI(ctx *gin.Context) {
machineKeyStr := ctx.Query("key")
if machineKeyStr == "" {
ctx.String(http.StatusBadRequest, "Wrong params")
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Initial multi-user support using namespaces
2021-02-27 16:58:09 -07:00
return
}
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
ctx.Data(http.StatusOK, "text/html; charset=utf-8", []byte(fmt.Sprintf(`
Initial multi-user support using namespaces
2021-02-27 16:58:09 -07:00
<html>
<body>
<h1>headscale</h1>
<p>
Remove dependency on postgres' jsonb
2021-05-14 16:05:41 -06:00
Run the command below in the headscale server to add this machine to your network:
Initial multi-user support using namespaces
2021-02-27 16:58:09 -07:00
</p>
<p>
<code>
Use long command in example and remove pointerlist
2021-11-04 16:18:06 -06:00
<b>headscale -n NAMESPACE nodes register --key %s</b>
Initial multi-user support using namespaces
2021-02-27 16:58:09 -07:00
</code>
</p>
</body>
</html>
Improved tailnode start up handling
2021-05-24 13:59:03 -06:00
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
`, machineKeyStr)))
Initial multi-user support using namespaces
2021-02-27 16:58:09 -07:00
}
// RegistrationHandler handles the actual registration process of a machine
golangci-lint --fix
2021-11-13 01:39:04 -07:00
// Endpoint /machine/:id.
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07: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 16:50:42 -07:00
var machineKey key.MachinePublic
Ensure we always have the key prefix when needed
2021-11-27 13:25:12 -07:00
err := machineKey.UnmarshalText([]byte(MachinePublicKeyEnsurePrefix(machineKeyStr)))
Initial commit
2020-06-21 04:32:08 -06:00
if err != nil {
Initial port to zerologger
2021-08-05 11:11:26 -06: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 16:30:42 -07:00
Caller().
Initial port to zerologger
2021-08-05 11:11:26 -06:00
Err(err).
Msg("Cannot parse machine key")
updates from code review
2021-10-10 03:22:42 -06:00
machineRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
ctx.String(http.StatusInternalServerError, "Sad!")
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Initial commit
2020-06-21 04:32:08 -06:00
return
}
req := tailcfg.RegisterRequest{}
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
err = decode(body, &req, &machineKey, h.privateKey)
Initial commit
2020-06-21 04:32:08 -06:00
if err != nil {
Initial port to zerologger
2021-08-05 11:11:26 -06: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 16:30:42 -07:00
Caller().
Initial port to zerologger
2021-08-05 11:11:26 -06:00
Err(err).
Msg("Cannot decode message")
updates from code review
2021-10-10 03:22:42 -06:00
machineRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
ctx.String(http.StatusInternalServerError, "Very sad!")
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Initial commit
2020-06-21 04:32:08 -06:00
return
}
Preauth keys kinda working
2021-05-05 16:59:26 -06: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 16:24:22 -06: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 16:30:42 -07:00
machine, err := h.GetMachineByMachineKey(machineKey)
updates from code review
2021-10-10 03:22:42 -06:00
if errors.Is(err, gorm.ErrRecordNotFound) {
Make log keys lowercase
2021-08-05 13:57:47 -06:00
log.Info().Str("machine", req.Hostinfo.Hostname).Msg("New machine")
updates from code review
2021-10-10 03:22:42 -06:00
newMachine := Machine{
Expiry: &time.Time{},
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 16:30:42 -07:00
MachineKey: MachinePublicKeyStripPrefix(machineKey),
updates from code review
2021-10-10 03:22:42 -06:00
Name: req.Hostinfo.Hostname,
Handle client sending new NodeKey (fixes #32)
2021-06-05 04:13:55 -06:00
}
updates from code review
2021-10-10 03:22:42 -06:00
if err := h.db.Create(&newMachine).Error; err != nil {
Convert missing from api.go
2021-08-05 11:16:21 -06: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 16:30:42 -07:00
Caller().
Convert missing from api.go
2021-08-05 11:16:21 -06:00
Err(err).
Msg("Could not create row")
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
machineRegistrations.WithLabelValues("unknown", "web", "error", machine.Namespace.Name).
Go format with shorter lines
2021-11-13 01:36:45 -07:00
Inc()
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Handle client sending new NodeKey (fixes #32)
2021-06-05 04:13:55 -06:00
return
}
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
machine = &newMachine
Handle client sending new NodeKey (fixes #32)
2021-06-05 04:13:55 -06: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 06:59:24 -07:00
if machine.Registered {
// 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 01:23:45 -07: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 06:59:24 -07: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 07:00:48 -07: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 06:59:24 -07: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 03:43:52 -06: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 06:59:24 -07: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 01:23:45 -07: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 06:59:24 -07:00
!machine.isExpired() {
h.handleMachineRefreshKey(ctx, machineKey, req, *machine)
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Initial commit
2020-06-21 04:32:08 -06:00
return
}
Move handle expired machine to the end of registration
2021-11-21 14:14:13 -07:00
// The machine has expired
Add missing request arguemnt
2021-11-24 05:16:56 -07:00
h.handleMachineExpired(ctx, machineKey, req, *machine)
Move handle expired machine to the end of registration
2021-11-21 14:14:13 -07:00
return
Initial commit
2020-06-21 04:32:08 -06: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 06:59:24 -07:00
// If the machine has AuthKey set, handle registration via PreAuthKeys
if req.Auth.AuthKey != "" {
h.handleAuthKey(ctx, machineKey, req, *machine)
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Initial commit
2020-06-21 04:32:08 -06:00
return
}
Move registration workflow into functions
2021-11-17 15:39:41 -07:00
h.handleMachineRegistrationNew(ctx, machineKey, req, *machine)
Initial commit
2020-06-21 04:32:08 -06:00
}
Go format with shorter lines
2021-11-13 01:36:45 -07: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 16:30:42 -07:00
machineKey key.MachinePublic,
Go format with shorter lines
2021-11-13 01:36:45 -07:00
req tailcfg.MapRequest,
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
machine *Machine,
Go format with shorter lines
2021-11-13 01:36:45 -07:00
) ([]byte, error) {
Add more trace logging
2021-08-05 14:47:06 -06: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 12:32:03 -07:00
node, err := machine.toNode(h.cfg.BaseDomain, h.cfg.DNSConfig, true)
Initial commit
2020-06-21 04:32:08 -06:00
if err != nil {
Initial port to zerologger
2021-08-05 11:11:26 -06: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 16:30:42 -07:00
Caller().
Make log keys lowercase
2021-08-05 13:57:47 -06:00
Str("func", "getMapResponse").
Initial port to zerologger
2021-08-05 11:11:26 -06:00
Err(err).
Msg("Cannot convert to node")
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Initial commit
2020-06-21 04:32:08 -06:00
return nil, err
}
Move DB call of pollmap to Machine inside a function
2021-10-02 14:58:28 -06: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 12:51:16 -07:00
peers, err := h.getValidPeers(machine)
Initial commit
2020-06-21 04:32:08 -06:00
if err != nil {
Initial port to zerologger
2021-08-05 11:11:26 -06: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 16:30:42 -07:00
Caller().
Make log keys lowercase
2021-08-05 13:57:47 -06:00
Str("func", "getMapResponse").
Initial port to zerologger
2021-08-05 11:11:26 -06:00
Err(err).
Msg("Cannot fetch peers")
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Initial commit
2020-06-21 04:32:08 -06:00
return nil, err
}
Send the namespace name as user to the clients
2021-07-11 08:39:19 -06:00
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
profiles := getMapResponseUserProfiles(*machine, peers)
Send the namespace name as user to the clients
2021-07-11 08:39:19 -06:00
MagicDNS changes merged back
2021-10-04 15:49:16 -06: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 15:03:34 -06: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 16:30:42 -07: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 15:03:34 -06:00
Str("func", "getMapResponse").
Err(err).
Msg("Failed to convert peers to Tailscale nodes")
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07: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 15:03:34 -06:00
return nil, err
}
Remove unused params or returns
2021-11-14 10:03:21 -07:00
dnsConfig := getMapResponseDNSConfig(
Go format with shorter lines
2021-11-13 01:36:45 -07:00
h.cfg.DNSConfig,
h.cfg.BaseDomain,
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
*machine,
Go format with shorter lines
2021-11-13 01:36:45 -07:00
peers,
)
Send search domains
2021-10-02 04:13:19 -06:00
Initial commit
2020-06-21 04:32:08 -06:00
resp := tailcfg.MapResponse{
Propagate dns config vales across Headscale
2021-10-02 03:20:42 -06:00
KeepAlive: false,
Node: node,
Merged main
2021-10-04 15:43:42 -06:00
Peers: nodePeers,
Send search domains
2021-10-02 04:13:19 -06:00
DNSConfig: dnsConfig,
Propagate dns config vales across Headscale
2021-10-02 03:20:42 -06:00
Domain: h.cfg.BaseDomain,
Use long command in example and remove pointerlist
2021-11-04 16:18:06 -06:00
PacketFilter: h.aclRules,
Use the new derp map
2021-10-22 10:56:00 -06:00
DERPMap: h.DERPMap,
Send UserProfile info for the peers' namespaces
2021-10-17 04:07:01 -06:00
UserProfiles: profiles,
Minor thing
2021-02-23 16:31:58 -07:00
}
Send UserProfile info for the peers' namespaces
2021-10-17 04:07:01 -06:00
Resolve merge conflict
2021-08-13 03:33:19 -06:00
log.Trace().
Str("func", "getMapResponse").
Str("machine", req.Hostinfo.Hostname).
Comment out aggressive logging
2021-10-05 10:51:42 -06:00
// Interface("payload", resp).
Resolve merge conflict
2021-08-13 03:33:19 -06:00
Msgf("Generated map response: %s", tailMapResponseToString(resp))
Initial commit
2020-06-21 04:32:08 -06:00
var respBody []byte
if req.Compress == "zstd" {
src, _ := json.Marshal(resp)
Resolve merge conflict
2021-08-13 03:33:19 -06:00
Initial commit
2020-06-21 04:32:08 -06: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 16:30:42 -07:00
respBody = h.privateKey.SealTo(machineKey, srcCompressed)
Initial commit
2020-06-21 04:32:08 -06:00
} else {
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
respBody, err = encode(resp, &machineKey, h.privateKey)
Initial commit
2020-06-21 04:32:08 -06: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 10:24:24 -07:00
data := make([]byte, reservedResponseHeaderSize)
Initial commit
2020-06-21 04:32:08 -06:00
binary.LittleEndian.PutUint32(data, uint32(len(respBody)))
data = append(data, respBody...)
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07: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 11:39:01 -06:00
return data, nil
Initial commit
2020-06-21 04:32:08 -06:00
}
Go format with shorter lines
2021-11-13 01:36:45 -07: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 16:30:42 -07:00
machineKey key.MachinePublic,
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
mapRequest tailcfg.MapRequest,
Go format with shorter lines
2021-11-13 01:36:45 -07:00
) ([]byte, error) {
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
mapResponse := tailcfg.MapResponse{
Initial commit
2020-06-21 04:32:08 -06:00
KeepAlive: true,
}
var respBody []byte
var err error
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
if mapRequest.Compress == "zstd" {
src, _ := json.Marshal(mapResponse)
Initial commit
2020-06-21 04:32:08 -06: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 16:30:42 -07:00
respBody = h.privateKey.SealTo(machineKey, srcCompressed)
Initial commit
2020-06-21 04:32:08 -06:00
} else {
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
respBody, err = encode(mapResponse, &machineKey, h.privateKey)
Initial commit
2020-06-21 04:32:08 -06:00
if err != nil {
return nil, err
}
}
Add and fix stylecheck (golint replacement)
2021-11-15 10:24:24 -07:00
data := make([]byte, reservedResponseHeaderSize)
Initial commit
2020-06-21 04:32:08 -06:00
binary.LittleEndian.PutUint32(data, uint32(len(respBody)))
data = append(data, respBody...)
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07: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 11:39:01 -06:00
return data, nil
Initial commit
2020-06-21 04:32:08 -06:00
}
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
machineKey key.MachinePublic,
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 06:59:24 -07:00
h.ExpireMachine(&machine)
Move registration workflow into functions
2021-11-17 15:39:41 -07:00
resp.AuthURL = ""
resp.MachineAuthorized = false
resp.User = *machine.Namespace.toUser()
Rename idKey to machineKey to keep consistency
2021-11-24 05:15:55 -07:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
Caller().
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
machineKey key.MachinePublic,
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 05:15:55 -07:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
Caller().
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
machineKey key.MachinePublic,
Rename idKey to machineKey to keep consistency
2021-11-24 05:15:55 -07:00
registerRequest tailcfg.RegisterRequest,
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 05:15:32 -07:00
if registerRequest.Auth.AuthKey != "" {
h.handleAuthKey(ctx, machineKey, registerRequest, machine)
return
}
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
strings.TrimSuffix(h.cfg.ServerURL, "/"), machineKey.String())
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
strings.TrimSuffix(h.cfg.ServerURL, "/"), machineKey.String())
Move registration workflow into functions
2021-11-17 15:39:41 -07:00
}
Add missing iff to handle expired preauthkey machines
2021-11-24 05:15:32 -07:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
Caller().
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 12:32:11 -07:00
machineRegistrations.WithLabelValues("reauth", "web", "error", machine.Namespace.Name).
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 12:32:11 -07:00
machineRegistrations.WithLabelValues("reauth", "web", "success", machine.Namespace.Name).
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
machineKey key.MachinePublic,
Fix typo
2021-11-22 12:35:24 -07:00
registerRequest tailcfg.RegisterRequest,
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
machine.NodeKey = NodePublicKeyStripPrefix(registerRequest.NodeKey)
Move registration workflow into functions
2021-11-17 15:39:41 -07:00
h.db.Save(&machine)
resp.AuthURL = ""
resp.User = *machine.Namespace.toUser()
Rename idKey to machineKey to keep consistency
2021-11-24 05:15:55 -07:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
Caller().
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
machineKey key.MachinePublic,
Fix typo
2021-11-22 12:35:24 -07:00
registerRequest tailcfg.RegisterRequest,
Move registration workflow into functions
2021-11-17 15:39:41 -07:00
machine Machine,
) {
resp := tailcfg.RegisterResponse{}
// The machine registration is new, redirect the client to the registration URL
log.Debug().
Str("machine", machine.Name).
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 16:30:42 -07:00
machineKey.String(),
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
strings.TrimSuffix(h.cfg.ServerURL, "/"), MachinePublicKeyStripPrefix(machineKey))
Move registration workflow into functions
2021-11-17 15:39:41 -07:00
}
Fix typo
2021-11-22 12:35:24 -07: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 12:32:52 -07:00
log.Trace().
Caller().
Str("machine", machine.Name).
Fix typo
2021-11-22 12:35:24 -07: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 12:32:52 -07: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 16:30:42 -07:00
machineKey.String(),
Fix typo
2021-11-22 12:35:24 -07: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 12:32:52 -07:00
requestedExpiryCacheExpiration,
)
Remove expiry logic, this needs to be redone
2021-11-19 02:02:29 -07:00
}
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 16:30:42 -07:00
machine.NodeKey = NodePublicKeyStripPrefix(registerRequest.NodeKey)
// save the NodeKey
Move registration workflow into functions
2021-11-17 15:39:41 -07:00
h.db.Save(&machine)
Rename idKey to machineKey to keep consistency
2021-11-24 05:15:55 -07:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Move registration workflow into functions
2021-11-17 15:39:41 -07: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 16:30:42 -07:00
Caller().
Move registration workflow into functions
2021-11-17 15:39:41 -07:00
Err(err).
Msg("Cannot encode message")
ctx.String(http.StatusInternalServerError, "")
return
}
ctx.Data(http.StatusOK, "application/json; charset=utf-8", respBody)
}
Use the new derp map
2021-10-22 10:56:00 -06:00
func (h *Headscale) handleAuthKey(
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07: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 16:30:42 -07:00
machineKey key.MachinePublic,
Fix typo
2021-11-22 12:35:24 -07:00
registerRequest tailcfg.RegisterRequest,
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
machine Machine,
Use the new derp map
2021-10-22 10:56:00 -06:00
) {
Initial port to zerologger
2021-08-05 11:11:26 -06:00
log.Debug().
Make log keys lowercase
2021-08-05 13:57:47 -06:00
Str("func", "handleAuthKey").
Fix typo
2021-11-22 12:35:24 -07:00
Str("machine", registerRequest.Hostinfo.Hostname).
Msgf("Processing auth key for %s", registerRequest.Hostinfo.Hostname)
Preauth keys kinda working
2021-05-05 16:59:26 -06:00
resp := tailcfg.RegisterResponse{}
Fix typo
2021-11-22 12:35:24 -07:00
pak, err := h.checkKeyValidity(registerRequest.Auth.AuthKey)
Handle client sending new NodeKey (fixes #32)
2021-06-05 04:13:55 -06:00
if err != nil {
Fixing nil issue
2021-10-04 10:03:44 -06: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 16:30:42 -07:00
Caller().
Fixing nil issue
2021-10-04 10:03:44 -06:00
Str("func", "handleAuthKey").
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
Str("machine", machine.Name).
Fixing nil issue
2021-10-04 10:03:44 -06:00
Err(err).
Msg("Failed authentication via AuthKey")
Handle client sending new NodeKey (fixes #32)
2021-06-05 04:13:55 -06:00
resp.MachineAuthorized = false
Rename idKey to machineKey to keep consistency
2021-11-24 05:15:55 -07:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Preauth keys kinda working
2021-05-05 16:59:26 -06:00
if err != nil {
Initial port to zerologger
2021-08-05 11:11:26 -06: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 16:30:42 -07:00
Caller().
Make log keys lowercase
2021-08-05 13:57:47 -06:00
Str("func", "handleAuthKey").
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
Str("machine", machine.Name).
Initial port to zerologger
2021-08-05 11:11:26 -06:00
Err(err).
Msg("Cannot encode message")
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
ctx.String(http.StatusInternalServerError, "")
machineRegistrations.WithLabelValues("new", "authkey", "error", machine.Namespace.Name).
Go format with shorter lines
2021-11-13 01:36:45 -07:00
Inc()
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Preauth keys kinda working
2021-05-05 16:59:26 -06:00
return
}
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
ctx.Data(http.StatusUnauthorized, "application/json; charset=utf-8", respBody)
Initial port to zerologger
2021-08-05 11:11:26 -06: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 16:30:42 -07:00
Caller().
Make log keys lowercase
2021-08-05 13:57:47 -06:00
Str("func", "handleAuthKey").
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
Str("machine", machine.Name).
Initial port to zerologger
2021-08-05 11:11:26 -06:00
Msg("Failed authentication via AuthKey")
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
machineRegistrations.WithLabelValues("new", "authkey", "error", machine.Namespace.Name).
Go format with shorter lines
2021-11-13 01:36:45 -07:00
Inc()
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Handle client sending new NodeKey (fixes #32)
2021-06-05 04:13:55 -06:00
return
}
Initial port to zerologger
2021-08-05 11:11:26 -06:00
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 12:32:11 -07:00
if machine.isRegistered() {
log.Trace().
Caller().
Str("machine", machine.Name).
Msg("machine already registered, reauthenticating")
Fix typo
2021-11-22 12:35:24 -07:00
h.RefreshMachine(&machine, registerRequest.Expiry)
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 12:32:11 -07:00
} else {
log.Debug().
Make log keys lowercase
2021-08-05 13:57:47 -06:00
Str("func", "handleAuthKey").
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
Str("machine", machine.Name).
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 12:32:11 -07:00
Msg("Authentication key was valid, proceeding to acquire an IP address")
ip, err := h.getAvailableIP()
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 16:30:42 -07:00
Caller().
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 12:32:11 -07:00
Str("func", "handleAuthKey").
Str("machine", machine.Name).
Msg("Failed to find an available IP")
machineRegistrations.WithLabelValues("new", "authkey", "error", machine.Namespace.Name).
Inc()
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 12:32:11 -07:00
return
}
log.Info().
Str("func", "handleAuthKey").
Str("machine", machine.Name).
Str("ip", ip.String()).
Msgf("Assigning %s to %s", ip, machine.Name)
Fix typo
2021-11-22 12:35:24 -07:00
machine.Expiry = &registerRequest.Expiry
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 12:32:11 -07:00
machine.AuthKeyID = uint(pak.ID)
machine.IPAddress = ip.String()
machine.NamespaceID = pak.NamespaceID
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 16:30:42 -07:00
machine.NodeKey = NodePublicKeyStripPrefix(registerRequest.NodeKey)
// we update it just in case
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 12:32:11 -07:00
machine.Registered = true
machine.RegisterMethod = RegisterMethodAuthKey
h.db.Save(&machine)
Initial commit
2020-06-21 04:32:08 -06:00
}
Preauth keys kinda working
2021-05-05 16:59:26 -06:00
Apply suggestions from code review Renamed AlreadyUsed to Used Co-authored-by: Kristoffer Dalby <kradalby@kradalby.no>
2021-10-13 14:51:55 -06:00
pak.Used = true
Move registration workflow into functions
2021-11-17 15:39:41 -07:00
h.db.Save(&pak)
updates from code review
2021-10-10 03:22:42 -06:00
Handle client sending new NodeKey (fixes #32)
2021-06-05 04:13:55 -06:00
resp.MachineAuthorized = true
resp.User = *pak.Namespace.toUser()
Rename idKey to machineKey to keep consistency
2021-11-24 05:15:55 -07:00
respBody, err := encode(resp, &machineKey, h.privateKey)
Initial commit
2020-06-21 04:32:08 -06:00
if err != nil {
Initial port to zerologger
2021-08-05 11:11:26 -06: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 16:30:42 -07:00
Caller().
Make log keys lowercase
2021-08-05 13:57:47 -06:00
Str("func", "handleAuthKey").
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
Str("machine", machine.Name).
Initial port to zerologger
2021-08-05 11:11:26 -06:00
Err(err).
Msg("Cannot encode message")
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
machineRegistrations.WithLabelValues("new", "authkey", "error", machine.Namespace.Name).
Go format with shorter lines
2021-11-13 01:36:45 -07:00
Inc()
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
ctx.String(http.StatusInternalServerError, "Extremely sad!")
Add and fix nlreturn (new line return)
2021-11-14 08:46:09 -07:00
Initial commit
2020-06-21 04:32:08 -06:00
return
}
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
machineRegistrations.WithLabelValues("new", "authkey", "success", machine.Namespace.Name).
Go format with shorter lines
2021-11-13 01:36:45 -07:00
Inc()
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
ctx.Data(http.StatusOK, "application/json; charset=utf-8", respBody)
Initial port to zerologger
2021-08-05 11:11:26 -06:00
log.Info().
Make log keys lowercase
2021-08-05 13:57:47 -06:00
Str("func", "handleAuthKey").
Initial work eliminating one/two letter variables
2021-11-14 12:32:03 -07:00
Str("machine", machine.Name).
Make sure nodes can reauthenticate This commit fixes an issue where nodes were not able to reauthenticate.
2021-11-22 12:32:11 -07:00
Str("ip", machine.IPAddress).
Initial port to zerologger
2021-08-05 11:11:26 -06:00
Msg("Successfully authenticated via AuthKey")
Initial commit
2020-06-21 04:32:08 -06:00
}
Copy permalink