headscale/preauth_keys_test.go

193 lines
5.1 KiB
Go
Raw Normal View History

package headscale
import (
2021-05-05 15:00:04 -06:00
"time"
"gopkg.in/check.v1"
)
func (*Suite) TestCreatePreAuthKey(c *check.C) {
2022-08-25 04:12:41 -06:00
_, err := app.CreatePreAuthKey("bogus", true, false, nil, nil)
2021-05-05 15:00:04 -06:00
c.Assert(err, check.NotNil)
2021-11-15 09:16:04 -07:00
namespace, err := app.CreateNamespace("test")
c.Assert(err, check.IsNil)
2022-08-25 04:12:41 -06:00
key, err := app.CreatePreAuthKey(namespace.Name, true, false, nil, nil)
c.Assert(err, check.IsNil)
// Did we get a valid key?
2021-11-15 09:16:04 -07:00
c.Assert(key.Key, check.NotNil)
c.Assert(len(key.Key), check.Equals, 48)
// Make sure the Namespace association is populated
2021-11-15 09:16:04 -07:00
c.Assert(key.Namespace.Name, check.Equals, namespace.Name)
2021-11-15 09:16:04 -07:00
_, err = app.ListPreAuthKeys("bogus")
c.Assert(err, check.NotNil)
2021-11-15 09:16:04 -07:00
keys, err := app.ListPreAuthKeys(namespace.Name)
c.Assert(err, check.IsNil)
c.Assert(len(keys), check.Equals, 1)
// Make sure the Namespace association is populated
2021-11-15 09:16:04 -07:00
c.Assert((keys)[0].Namespace.Name, check.Equals, namespace.Name)
}
2021-05-05 15:00:04 -06:00
func (*Suite) TestExpiredPreAuthKey(c *check.C) {
2021-11-15 09:16:04 -07:00
namespace, err := app.CreateNamespace("test2")
2021-05-05 15:00:04 -06:00
c.Assert(err, check.IsNil)
now := time.Now()
2022-08-25 04:12:41 -06:00
pak, err := app.CreatePreAuthKey(namespace.Name, true, false, &now, nil)
2021-05-05 15:00:04 -06:00
c.Assert(err, check.IsNil)
2021-11-15 09:16:04 -07:00
key, err := app.checkKeyValidity(pak.Key)
2022-07-29 09:35:21 -06:00
c.Assert(err, check.Equals, ErrPreAuthKeyExpired)
2021-11-15 09:16:04 -07:00
c.Assert(key, check.IsNil)
2021-05-05 15:00:04 -06:00
}
func (*Suite) TestPreAuthKeyDoesNotExist(c *check.C) {
2021-11-15 09:16:04 -07:00
key, err := app.checkKeyValidity("potatoKey")
2022-07-29 09:35:21 -06:00
c.Assert(err, check.Equals, ErrPreAuthKeyNotFound)
2021-11-15 09:16:04 -07:00
c.Assert(key, check.IsNil)
2021-05-05 15:00:04 -06:00
}
func (*Suite) TestValidateKeyOk(c *check.C) {
2021-11-15 09:16:04 -07:00
namespace, err := app.CreateNamespace("test3")
c.Assert(err, check.IsNil)
2022-08-25 04:12:41 -06:00
pak, err := app.CreatePreAuthKey(namespace.Name, true, false, nil, nil)
c.Assert(err, check.IsNil)
2021-11-15 09:16:04 -07:00
key, err := app.checkKeyValidity(pak.Key)
c.Assert(err, check.IsNil)
2021-11-15 09:16:04 -07:00
c.Assert(key.ID, check.Equals, pak.ID)
}
func (*Suite) TestAlreadyUsedKey(c *check.C) {
2021-11-15 09:16:04 -07:00
namespace, err := app.CreateNamespace("test4")
c.Assert(err, check.IsNil)
2022-08-25 04:12:41 -06:00
pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil, nil)
c.Assert(err, check.IsNil)
2021-11-15 09:16:04 -07:00
machine := Machine{
ID: 0,
MachineKey: "foo",
NodeKey: "bar",
DiscoKey: "faa",
Hostname: "testest",
2021-11-15 09:16:04 -07:00
NamespaceID: namespace.ID,
2021-11-18 01:49:55 -07:00
RegisterMethod: RegisterMethodAuthKey,
AuthKeyID: uint(pak.ID),
}
2021-11-15 09:16:04 -07:00
app.db.Save(&machine)
2021-11-15 09:16:04 -07:00
key, err := app.checkKeyValidity(pak.Key)
2022-07-29 09:35:21 -06:00
c.Assert(err, check.Equals, ErrSingleUseAuthKeyHasBeenUsed)
2021-11-15 09:16:04 -07:00
c.Assert(key, check.IsNil)
}
func (*Suite) TestReusableBeingUsedKey(c *check.C) {
2021-11-15 09:16:04 -07:00
namespace, err := app.CreateNamespace("test5")
c.Assert(err, check.IsNil)
2022-08-25 04:12:41 -06:00
pak, err := app.CreatePreAuthKey(namespace.Name, true, false, nil, nil)
c.Assert(err, check.IsNil)
2021-11-15 09:16:04 -07:00
machine := Machine{
ID: 1,
MachineKey: "foo",
NodeKey: "bar",
DiscoKey: "faa",
Hostname: "testest",
2021-11-15 09:16:04 -07:00
NamespaceID: namespace.ID,
2021-11-18 01:49:55 -07:00
RegisterMethod: RegisterMethodAuthKey,
AuthKeyID: uint(pak.ID),
}
2021-11-15 09:16:04 -07:00
app.db.Save(&machine)
2021-11-15 09:16:04 -07:00
key, err := app.checkKeyValidity(pak.Key)
c.Assert(err, check.IsNil)
2021-11-15 09:16:04 -07:00
c.Assert(key.ID, check.Equals, pak.ID)
}
func (*Suite) TestNotReusableNotBeingUsedKey(c *check.C) {
2021-11-15 09:16:04 -07:00
namespace, err := app.CreateNamespace("test6")
c.Assert(err, check.IsNil)
2022-08-25 04:12:41 -06:00
pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil, nil)
c.Assert(err, check.IsNil)
2021-11-15 09:16:04 -07:00
key, err := app.checkKeyValidity(pak.Key)
c.Assert(err, check.IsNil)
2021-11-15 09:16:04 -07:00
c.Assert(key.ID, check.Equals, pak.ID)
}
func (*Suite) TestEphemeralKey(c *check.C) {
2021-11-15 09:16:04 -07:00
namespace, err := app.CreateNamespace("test7")
c.Assert(err, check.IsNil)
2022-08-25 04:12:41 -06:00
pak, err := app.CreatePreAuthKey(namespace.Name, false, true, nil, nil)
c.Assert(err, check.IsNil)
now := time.Now()
2021-11-15 09:16:04 -07:00
machine := Machine{
ID: 0,
MachineKey: "foo",
NodeKey: "bar",
DiscoKey: "faa",
Hostname: "testest",
2021-11-15 09:16:04 -07:00
NamespaceID: namespace.ID,
2021-11-18 01:49:55 -07:00
RegisterMethod: RegisterMethodAuthKey,
LastSeen: &now,
AuthKeyID: uint(pak.ID),
}
2021-11-15 09:16:04 -07:00
app.db.Save(&machine)
2021-11-15 09:16:04 -07:00
_, err = app.checkKeyValidity(pak.Key)
// Ephemeral keys are by definition reusable
c.Assert(err, check.IsNil)
2021-11-15 09:16:04 -07:00
_, err = app.GetMachine("test7", "testest")
c.Assert(err, check.IsNil)
2021-11-15 09:16:04 -07:00
app.expireEphemeralNodesWorker()
// The machine record should have been deleted
2021-11-15 09:16:04 -07:00
_, err = app.GetMachine("test7", "testest")
c.Assert(err, check.NotNil)
}
2021-08-07 15:57:52 -06:00
func (*Suite) TestExpirePreauthKey(c *check.C) {
2021-11-15 09:16:04 -07:00
namespace, err := app.CreateNamespace("test3")
2021-08-07 15:57:52 -06:00
c.Assert(err, check.IsNil)
2022-08-25 04:12:41 -06:00
pak, err := app.CreatePreAuthKey(namespace.Name, true, false, nil, nil)
2021-08-07 15:57:52 -06:00
c.Assert(err, check.IsNil)
c.Assert(pak.Expiration, check.IsNil)
2021-11-15 09:16:04 -07:00
err = app.ExpirePreAuthKey(pak)
2021-08-07 15:57:52 -06:00
c.Assert(err, check.IsNil)
c.Assert(pak.Expiration, check.NotNil)
2021-11-15 09:16:04 -07:00
key, err := app.checkKeyValidity(pak.Key)
2022-07-29 09:35:21 -06:00
c.Assert(err, check.Equals, ErrPreAuthKeyExpired)
2021-11-15 09:16:04 -07:00
c.Assert(key, check.IsNil)
2021-08-07 15:57:52 -06:00
}
func (*Suite) TestNotReusableMarkedAsUsed(c *check.C) {
2021-11-15 09:16:04 -07:00
namespace, err := app.CreateNamespace("test6")
c.Assert(err, check.IsNil)
2022-08-25 04:12:41 -06:00
pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil, nil)
c.Assert(err, check.IsNil)
pak.Used = true
2021-11-15 09:16:04 -07:00
app.db.Save(&pak)
2021-11-15 09:16:04 -07:00
_, err = app.checkKeyValidity(pak.Key)
2022-07-29 09:35:21 -06:00
c.Assert(err, check.Equals, ErrSingleUseAuthKeyHasBeenUsed)
}