TheArchive/tailscale
1
0
Fork 0
mirror of https://github.com/tailscale/tailscale.git synced 2024-12-01 14:05:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

types/key: delete legacy NodeKey type.

Browse Source 
Fixes #3206

Signed-off-by: David Anderson <danderson@tailscale.com>
This commit is contained in:
David Anderson 2021-11-02 14:14:32 -07:00
parent 7e6a1ef4f1
commit 17b5782b3a
4 changed files with 0 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
tailcfg/tailcfg.go
View File

@ -79,12 +79,6 @@ func (u StableNodeID) IsZero() bool {
return u == ""
}
// NodeKey is the WireGuard public key for a node.
//
// Deprecated: prefer to use key.NodePublic instead. If you must have
// a NodeKey, use NodePublic.AsNodeKey.
type NodeKey = key.NodeKey
// DiscoKey is the curve25519 public key for path discovery key.
// It's never written to disk or reused between network start-ups.
type DiscoKey [32]byte

7
types/key/node.go
View File

@ -305,10 +305,3 @@ func (k NodePublic) WireGuardGoString() string {
b[second+3] = b64((k.k[31] << 2) & 63)
return string(b)
}
// AsNodeKey returns k converted to a NodeKey.
//
// Cross-compatibility shim as part of #3206.
func (k NodePublic) AsNodeKey() NodeKey {
return k.Raw32()
}

28
types/key/node_legacy.go
View File

@ -1,28 +0,0 @@
// Copyright (c) 2021 Tailscale Inc & AUTHORS All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package key
import (
"go4.org/mem"
)
// NodeKey is the legacy form of NodePublic.
// See #3206 for removal effort.
type NodeKey [32]byte
func (k NodeKey) ShortString() string { return k.AsNodePublic().ShortString() }
func (k NodeKey) String() string { return k.AsNodePublic().String() }
func (k NodeKey) MarshalText() ([]byte, error) { return k.AsNodePublic().MarshalText() }
func (k NodeKey) AsNodePublic() NodePublic { return NodePublicFromRaw32(mem.B(k[:])) }
func (k NodeKey) IsZero() bool { return k == NodeKey{} }
func (k *NodeKey) UnmarshalText(text []byte) error {
var nk NodePublic
if err := nk.UnmarshalText(text); err != nil {
return err
}
*k = nk.AsNodeKey()
return nil
}

75
types/key/node_legacy_test.go
View File

@ -1,75 +0,0 @@
// Copyright (c) 2021 Tailscale Inc & AUTHORS All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package key
import (
"bytes"
"encoding/json"
"strings"
"testing"
)
func TestNodeKeyMarshal(t *testing.T) {
var k1, k2 NodeKey
for i := range k1 {
k1[i] = byte(i)
}
const prefix = "nodekey:"
got, err := k1.MarshalText()
if err != nil {
t.Fatal(err)
}
if err := k2.UnmarshalText(got); err != nil {
t.Fatal(err)
}
if s := k1.String(); string(got) != s {
t.Errorf("MarshalText = %q != String %q", got, s)
}
if !strings.HasPrefix(string(got), prefix) {
t.Errorf("%q didn't start with prefix %q", got, prefix)
}
if k2 != k1 {
t.Errorf("mismatch after unmarshal")
}
}
func TestNodeKeyRoundTrip(t *testing.T) {
serialized := `{
"Pub":"nodekey:50d20b455ecf12bc453f83c2cfdb2a24925d06cf2598dcaa54e91af82ce9f765"
}`
// Carefully check that the expected serialized data decodes and
// re-encodes to the expected keys. These types are serialized to
// disk all over the place and need to be stable.
pub := NodeKey{
0x50, 0xd2, 0xb, 0x45, 0x5e, 0xcf, 0x12, 0xbc, 0x45, 0x3f, 0x83,
0xc2, 0xcf, 0xdb, 0x2a, 0x24, 0x92, 0x5d, 0x6, 0xcf, 0x25, 0x98,
0xdc, 0xaa, 0x54, 0xe9, 0x1a, 0xf8, 0x2c, 0xe9, 0xf7, 0x65,
}
type key struct {
Pub NodeKey
}
var a key
if err := json.Unmarshal([]byte(serialized), &a); err != nil {
t.Fatal(err)
}
if a.Pub != pub {
t.Errorf("wrong deserialization of public key, got %#v want %#v", a.Pub, pub)
}
bs, err := json.MarshalIndent(a, "", " ")
if err != nil {
t.Fatal(err)
}
var b bytes.Buffer
json.Indent(&b, []byte(serialized), "", " ")
if got, want := string(bs), b.String(); got != want {
t.Error("json serialization doesn't roundtrip")
}
}