MyFavMirrors/headscale
1
0
Fork 0
mirror of https://github.com/juanfont/headscale.git synced 2024-12-27 14:45:52 -05:00
Code Issues Packages Projects Releases Wiki Activity
a23d82e33a
headscale/api.go

426 lines
12 KiB
Go
Raw Normal View History

Initial commit
2020-06-21 06:32:08 -04:00
package headscale
import (
"encoding/binary"
"encoding/json"
Update Headscale to depend on gorm v2
2021-06-24 09:44:19 -04:00
"errors"
Initial commit
2020-06-21 06:32:08 -04:00
"fmt"
"io"
"net/http"
"time"
Initial port to zerologger
2021-08-05 13:11:26 -04:00
"github.com/rs/zerolog/log"
Initial commit
2020-06-21 06:32:08 -04:00
"github.com/gin-gonic/gin"
"github.com/klauspost/compress/zstd"
Update Headscale to depend on gorm v2
2021-06-24 09:44:19 -04:00
"gorm.io/gorm"
Initial commit
2020-06-21 06:32:08 -04:00
"tailscale.com/tailcfg"
Update code to Tailscale 1.10
2021-06-25 12:57:08 -04:00
"tailscale.com/types/wgkey"
Initial commit
2020-06-21 06:32:08 -04:00
)
Initial multi-user support using namespaces
2021-02-27 18:58:09 -05:00
// KeyHandler provides the Headscale pub key
// Listens in /key
Initial commit
2020-06-21 06:32:08 -04:00
func (h *Headscale) KeyHandler(c *gin.Context) {
c.Data(200, "text/plain; charset=utf-8", []byte(h.publicKey.HexString()))
}
Initial multi-user support using namespaces
2021-02-27 18:58:09 -05:00
// RegisterWebAPI shows a simple message in the browser to point to the CLI
// Listens in /register
func (h *Headscale) RegisterWebAPI(c *gin.Context) {
mKeyStr := c.Query("key")
if mKeyStr == "" {
c.String(http.StatusBadRequest, "Wrong params")
return
}
c.Data(http.StatusOK, "text/html; charset=utf-8", []byte(fmt.Sprintf(`
<html>
<body>
<h1>headscale</h1>
<p>
Remove dependency on postgres' jsonb
2021-05-14 18:05:41 -04: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 18:58:09 -05:00
</p>
<p>
<code>
Fix minor typo on the register webpage
2021-07-11 09:05:32 -04:00
<b>headscale -n NAMESPACE nodes register %s</b>
Initial multi-user support using namespaces
2021-02-27 18:58:09 -05:00
</code>
</p>
</body>
</html>
Improved tailnode start up handling
2021-05-24 15:59:03 -04:00
Initial multi-user support using namespaces
2021-02-27 18:58:09 -05:00
`, mKeyStr)))
}
// RegistrationHandler handles the actual registration process of a machine
// Endpoint /machine/:id
Initial commit
2020-06-21 06:32:08 -04:00
func (h *Headscale) RegistrationHandler(c *gin.Context) {
Fixes here and there
2021-02-21 17:54:15 -05:00
body, _ := io.ReadAll(c.Request.Body)
Initial commit
2020-06-21 06:32:08 -04:00
mKeyStr := c.Param("id")
Update code to Tailscale 1.10
2021-06-25 12:57:08 -04:00
mKey, err := wgkey.ParseHex(mKeyStr)
Initial commit
2020-06-21 06:32:08 -04:00
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot parse machine key")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("unkown", "web", "error", "unknown").Inc()
Initial commit
2020-06-21 06:32:08 -04:00
c.String(http.StatusInternalServerError, "Sad!")
return
}
req := tailcfg.RegisterRequest{}
err = decode(body, &req, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot decode message")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("unkown", "web", "error", "unknown").Inc()
Initial commit
2020-06-21 06:32:08 -04:00
c.String(http.StatusInternalServerError, "Very sad!")
return
}
Preauth keys kinda working
2021-05-05 18:59:26 -04:00
Move most "poll" functionality to poll.go This function migrates more poll functions (including keepalive) to poll.go to keep it somehow in the same file. In addition it makes changes to improve the stability and ensure nodes get the appropriate updates from the headscale control and are not left in an inconsistent state. Two new additions is: omitpeers=true will now trigger an update if the clients are not already up to date keepalive has been extended with a timer that will check every 120s if all nodes are up to date.
2021-08-18 18:24:22 -04:00
now := time.Now().UTC()
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
var m Machine
Use the new derp map
2021-10-22 12:56:00 -04:00
if result := h.db.Preload("Namespace").First(&m, "machine_key = ?", mKey.HexString()); errors.Is(
result.Error,
gorm.ErrRecordNotFound,
) {
Make log keys lowercase
2021-08-05 15:57:47 -04:00
log.Info().Str("machine", req.Hostinfo.Hostname).Msg("New machine")
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
m = Machine{
Move most "poll" functionality to poll.go This function migrates more poll functions (including keepalive) to poll.go to keep it somehow in the same file. In addition it makes changes to improve the stability and ensure nodes get the appropriate updates from the headscale control and are not left in an inconsistent state. Two new additions is: omitpeers=true will now trigger an update if the clients are not already up to date keepalive has been extended with a timer that will check every 120s if all nodes are up to date.
2021-08-18 18:24:22 -04:00
Expiry: &req.Expiry,
MachineKey: mKey.HexString(),
Name: req.Hostinfo.Hostname,
NodeKey: wgkey.Key(req.NodeKey).HexString(),
LastSuccessfulUpdate: &now,
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
}
Use gorm connection pool
2021-07-04 15:40:46 -04:00
if err := h.db.Create(&m).Error; err != nil {
Convert missing from api.go
2021-08-05 13:16:21 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Convert missing from api.go
2021-08-05 13:16:21 -04:00
Err(err).
Msg("Could not create row")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("unkown", "web", "error", m.Namespace.Name).Inc()
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
return
}
}
if !m.Registered && req.Auth.AuthKey != "" {
Use gorm connection pool
2021-07-04 15:40:46 -04:00
h.handleAuthKey(c, h.db, mKey, req, m)
Initial commit
2020-06-21 06:32:08 -04:00
return
}
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
resp := tailcfg.RegisterResponse{}
// We have the updated key!
Update code to Tailscale 1.10
2021-06-25 12:57:08 -04:00
if m.NodeKey == wgkey.Key(req.NodeKey).HexString() {
Initial commit
2020-06-21 06:32:08 -04:00
if m.Registered {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Debug().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Str("machine", m.Name).
Fixed log message
2021-08-05 18:21:34 -04:00
Msg("Client is registered and we have the current NodeKey. All clear to /map")
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Initial commit
2020-06-21 06:32:08 -04:00
resp.AuthURL = ""
Update README (although do not advirtise preauth keys that much yet)
2021-05-06 17:25:40 -04:00
resp.MachineAuthorized = true
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
resp.User = *m.Namespace.toUser()
Initial commit
2020-06-21 06:32:08 -04:00
respBody, err := encode(resp, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot encode message")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("update", "web", "error", m.Namespace.Name).Inc()
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
c.String(http.StatusInternalServerError, "")
Initial commit
2020-06-21 06:32:08 -04:00
return
}
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("update", "web", "success", m.Namespace.Name).Inc()
Initial commit
2020-06-21 06:32:08 -04:00
c.Data(200, "application/json; charset=utf-8", respBody)
return
}
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Debug().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Msg("Not registered and not NodeKey rotation. Sending a authurl to register")
Initial commit
2020-06-21 06:32:08 -04:00
resp.AuthURL = fmt.Sprintf("%s/register?key=%s",
h.cfg.ServerURL, mKey.HexString())
respBody, err := encode(resp, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot encode message")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("new", "web", "error", m.Namespace.Name).Inc()
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
c.String(http.StatusInternalServerError, "")
Initial commit
2020-06-21 06:32:08 -04:00
return
}
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("new", "web", "success", m.Namespace.Name).Inc()
Initial commit
2020-06-21 06:32:08 -04:00
c.Data(200, "application/json; charset=utf-8", respBody)
return
}
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
// The NodeKey we have matches OldNodeKey, which means this is a refresh after an key expiration
Update code to Tailscale 1.10
2021-06-25 12:57:08 -04:00
if m.NodeKey == wgkey.Key(req.OldNodeKey).HexString() {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Debug().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Msg("We have the OldNodeKey in the database. This is a key refresh")
Update code to Tailscale 1.10
2021-06-25 12:57:08 -04:00
m.NodeKey = wgkey.Key(req.NodeKey).HexString()
Use gorm connection pool
2021-07-04 15:40:46 -04:00
h.db.Save(&m)
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
Initial commit
2020-06-21 06:32:08 -04:00
resp.AuthURL = ""
Initial multi-user support using namespaces
2021-02-27 18:58:09 -05:00
resp.User = *m.Namespace.toUser()
Initial commit
2020-06-21 06:32:08 -04:00
respBody, err := encode(resp, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot encode message")
Initial commit
2020-06-21 06:32:08 -04:00
c.String(http.StatusInternalServerError, "Extremely sad!")
return
}
c.Data(200, "application/json; charset=utf-8", respBody)
return
}
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
// We arrive here after a client is restarted without finalizing the authentication flow or
// when headscale is stopped in the middle of the auth process.
if m.Registered {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Debug().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Msg("The node is sending us a new NodeKey, but machine is registered. All clear for /map")
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
resp.AuthURL = ""
resp.MachineAuthorized = true
resp.User = *m.Namespace.toUser()
respBody, err := encode(resp, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot encode message")
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
c.String(http.StatusInternalServerError, "")
return
}
c.Data(200, "application/json; charset=utf-8", respBody)
return
}
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Debug().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Msg("The node is sending us a new NodeKey, sending auth url")
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
resp.AuthURL = fmt.Sprintf("%s/register?key=%s",
h.cfg.ServerURL, mKey.HexString())
respBody, err := encode(resp, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot encode message")
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
c.String(http.StatusInternalServerError, "")
return
}
c.Data(200, "application/json; charset=utf-8", respBody)
Initial commit
2020-06-21 06:32:08 -04:00
}
Clean up pointer usage consistency. This tries to make the same functions emit and consume the same type of data all over the application. If a function transform data, it should emit new data, not a pointer.
2021-10-04 13:39:01 -04:00
func (h *Headscale) getMapResponse(mKey wgkey.Key, req tailcfg.MapRequest, m *Machine) ([]byte, error) {
Add more trace logging
2021-08-05 16:47:06 -04:00
log.Trace().
Str("func", "getMapResponse").
Str("machine", req.Hostinfo.Hostname).
Msg("Creating Map response")
MagicDNS changes merged back
2021-10-04 17:49:16 -04:00
node, err := m.toNode(h.cfg.BaseDomain, h.cfg.DNSConfig, true)
Initial commit
2020-06-21 06:32:08 -04:00
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "getMapResponse").
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot convert to node")
Initial commit
2020-06-21 06:32:08 -04:00
return nil, err
}
Move DB call of pollmap to Machine inside a function
2021-10-02 16:58:28 -04:00
Initial commit
2020-06-21 06:32:08 -04:00
peers, err := h.getPeers(m)
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "getMapResponse").
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot fetch peers")
Initial commit
2020-06-21 06:32:08 -04:00
return nil, err
}
Send the namespace name as user to the clients
2021-07-11 10:39:19 -04:00
Send UserProfile info for the peers' namespaces
2021-10-17 06:07:01 -04:00
profiles := getMapResponseUserProfiles(*m, peers)
Send the namespace name as user to the clients
2021-07-11 10:39:19 -04:00
MagicDNS changes merged back
2021-10-04 17:49:16 -04:00
nodePeers, err := peers.toNodes(h.cfg.BaseDomain, h.cfg.DNSConfig, true)
Move toNode, add type helpers, split peers and shared This commit moves toNode to the bottom of the file, and adds a helper function for lists of Machines to be converted. It also adds string helpers for Machines and lists of machines. Lastly it splits getPeers into getDirectPeers, which exist in the same namespace, and getShared, which is nodes shared with the namespace. getPeers is kept as a function putting together the two lists for convenience.
2021-10-02 17:03:34 -04:00
if err != nil {
log.Error().
Str("func", "getMapResponse").
Err(err).
Msg("Failed to convert peers to Tailscale nodes")
return nil, err
}
Do not use the full application for getMapResponseDNSConfig
2021-10-17 06:10:03 -04:00
dnsConfig, err := getMapResponseDNSConfig(h.cfg.DNSConfig, h.cfg.BaseDomain, *m, peers)
Do not include BaseDomain as full route in DNSConfig + code reorg
2021-10-17 05:57:53 -04:00
if err != nil {
log.Error().
Str("func", "getMapResponse").
Err(err).
Msg("Failed generate the DNSConfig")
return nil, err
Send search domains
2021-10-02 06:13:19 -04:00
}
Initial commit
2020-06-21 06:32:08 -04:00
resp := tailcfg.MapResponse{
Propagate dns config vales across Headscale
2021-10-02 05:20:42 -04:00
KeepAlive: false,
Node: node,
Merged main
2021-10-04 17:43:42 -04:00
Peers: nodePeers,
Send search domains
2021-10-02 06:13:19 -04:00
DNSConfig: dnsConfig,
Propagate dns config vales across Headscale
2021-10-02 05:20:42 -04:00
Domain: h.cfg.BaseDomain,
Load ACL policy on headscale startup
2021-07-04 07:24:05 -04:00
PacketFilter: *h.aclRules,
Use the new derp map
2021-10-22 12:56:00 -04:00
DERPMap: h.DERPMap,
Send UserProfile info for the peers' namespaces
2021-10-17 06:07:01 -04:00
UserProfiles: profiles,
Minor thing
2021-02-23 18:31:58 -05:00
}
Send UserProfile info for the peers' namespaces
2021-10-17 06:07:01 -04:00
Resolve merge conflict
2021-08-13 05:33:19 -04:00
log.Trace().
Str("func", "getMapResponse").
Str("machine", req.Hostinfo.Hostname).
Comment out aggressive logging
2021-10-05 12:51:42 -04:00
// Interface("payload", resp).
Resolve merge conflict
2021-08-13 05:33:19 -04:00
Msgf("Generated map response: %s", tailMapResponseToString(resp))
Initial commit
2020-06-21 06:32:08 -04:00
var respBody []byte
if req.Compress == "zstd" {
src, _ := json.Marshal(resp)
Resolve merge conflict
2021-08-13 05:33:19 -04:00
Initial commit
2020-06-21 06:32:08 -04:00
encoder, _ := zstd.NewWriter(nil)
srcCompressed := encoder.EncodeAll(src, nil)
respBody, err = encodeMsg(srcCompressed, &mKey, h.privateKey)
if err != nil {
return nil, err
}
} else {
respBody, err = encode(resp, &mKey, h.privateKey)
if err != nil {
return nil, err
}
}
// declare the incoming size on the first 4 bytes
data := make([]byte, 4)
binary.LittleEndian.PutUint32(data, uint32(len(respBody)))
data = append(data, respBody...)
Clean up pointer usage consistency. This tries to make the same functions emit and consume the same type of data all over the application. If a function transform data, it should emit new data, not a pointer.
2021-10-04 13:39:01 -04:00
return data, nil
Initial commit
2020-06-21 06:32:08 -04:00
}
Clean up pointer usage consistency. This tries to make the same functions emit and consume the same type of data all over the application. If a function transform data, it should emit new data, not a pointer.
2021-10-04 13:39:01 -04:00
func (h *Headscale) getMapKeepAliveResponse(mKey wgkey.Key, req tailcfg.MapRequest, m *Machine) ([]byte, error) {
Initial commit
2020-06-21 06:32:08 -04:00
resp := tailcfg.MapResponse{
KeepAlive: true,
}
var respBody []byte
var err error
if req.Compress == "zstd" {
src, _ := json.Marshal(resp)
encoder, _ := zstd.NewWriter(nil)
srcCompressed := encoder.EncodeAll(src, nil)
respBody, err = encodeMsg(srcCompressed, &mKey, h.privateKey)
if err != nil {
return nil, err
}
} else {
respBody, err = encode(resp, &mKey, h.privateKey)
if err != nil {
return nil, err
}
}
data := make([]byte, 4)
binary.LittleEndian.PutUint32(data, uint32(len(respBody)))
data = append(data, respBody...)
Clean up pointer usage consistency. This tries to make the same functions emit and consume the same type of data all over the application. If a function transform data, it should emit new data, not a pointer.
2021-10-04 13:39:01 -04:00
return data, nil
Initial commit
2020-06-21 06:32:08 -04:00
}
Use the new derp map
2021-10-22 12:56:00 -04:00
func (h *Headscale) handleAuthKey(
c *gin.Context,
db *gorm.DB,
idKey wgkey.Key,
req tailcfg.RegisterRequest,
m Machine,
) {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Debug().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Str("machine", req.Hostinfo.Hostname).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Msgf("Processing auth key for %s", req.Hostinfo.Hostname)
Preauth keys kinda working
2021-05-05 18:59:26 -04:00
resp := tailcfg.RegisterResponse{}
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
pak, err := h.checkKeyValidity(req.Auth.AuthKey)
if err != nil {
Fixing nil issue
2021-10-04 12:03:44 -04:00
log.Error().
Str("func", "handleAuthKey").
Str("machine", m.Name).
Err(err).
Msg("Failed authentication via AuthKey")
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
resp.MachineAuthorized = false
Preauth keys kinda working
2021-05-05 18:59:26 -04:00
respBody, err := encode(resp, &idKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot encode message")
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
c.String(http.StatusInternalServerError, "")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("new", "authkey", "error", m.Namespace.Name).Inc()
Preauth keys kinda working
2021-05-05 18:59:26 -04:00
return
}
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
c.Data(401, "application/json; charset=utf-8", respBody)
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Msg("Failed authentication via AuthKey")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("new", "authkey", "error", m.Namespace.Name).Inc()
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
return
}
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Debug().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Msg("Authentication key was valid, proceeding to acquire an IP address")
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
ip, err := h.getAvailableIP()
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Msg("Failed to find an available IP")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("new", "authkey", "error", m.Namespace.Name).Inc()
Preauth keys kinda working
2021-05-05 18:59:26 -04:00
return
Initial commit
2020-06-21 06:32:08 -04:00
}
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Info().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Str("ip", ip.String()).
Move most "poll" functionality to poll.go This function migrates more poll functions (including keepalive) to poll.go to keep it somehow in the same file. In addition it makes changes to improve the stability and ensure nodes get the appropriate updates from the headscale control and are not left in an inconsistent state. Two new additions is: omitpeers=true will now trigger an update if the clients are not already up to date keepalive has been extended with a timer that will check every 120s if all nodes are up to date.
2021-08-18 18:24:22 -04:00
Msgf("Assigning %s to %s", ip, m.Name)
Initial commit
2020-06-21 06:32:08 -04:00
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
m.AuthKeyID = uint(pak.ID)
m.IPAddress = ip.String()
m.NamespaceID = pak.NamespaceID
Update code to Tailscale 1.10
2021-06-25 12:57:08 -04:00
m.NodeKey = wgkey.Key(req.NodeKey).HexString() // we update it just in case
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
m.Registered = true
m.RegisterMethod = "authKey"
db.Save(&m)
Preauth keys kinda working
2021-05-05 18:59:26 -04:00
Apply suggestions from code review Renamed AlreadyUsed to Used Co-authored-by: Kristoffer Dalby <kradalby@kradalby.no>
2021-10-13 16:51:55 -04:00
pak.Used = true
Add AlreadyUsed field to Auth Keys (fixes #157 and #158)
2021-10-13 12:13:26 -04:00
db.Save(&pak)
Handle client sending new NodeKey (fixes #32)
2021-06-05 06:13:55 -04:00
resp.MachineAuthorized = true
resp.User = *pak.Namespace.toUser()
Initial commit
2020-06-21 06:32:08 -04:00
respBody, err := encode(resp, &idKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Error().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Err(err).
Msg("Cannot encode message")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("new", "authkey", "error", m.Namespace.Name).Inc()
Initial commit
2020-06-21 06:32:08 -04:00
c.String(http.StatusInternalServerError, "Extremely sad!")
return
}
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 12:28:07 -04:00
machineRegistrations.WithLabelValues("new", "authkey", "success", m.Namespace.Name).Inc()
Initial commit
2020-06-21 06:32:08 -04:00
c.Data(200, "application/json; charset=utf-8", respBody)
Initial port to zerologger
2021-08-05 13:11:26 -04:00
log.Info().
Make log keys lowercase
2021-08-05 15:57:47 -04:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Str("ip", ip.String()).
Initial port to zerologger
2021-08-05 13:11:26 -04:00
Msg("Successfully authenticated via AuthKey")
Initial commit
2020-06-21 06:32:08 -04:00
}
Reference in New Issue Copy Permalink