mirror of https://github.com/tailscale/tailscale/
types/key: delete legacy undifferentiated key types.
Updates #3206 Signed-off-by: David Anderson <danderson@tailscale.com>danderson/nodekey-delete-old
David Anderson
3 years ago
parent
eeb97fd89f
commit
b43362852c
@ -1,119 +0,0 @@
|
|||||||
// Copyright (c) 2020 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 defines some types for the various keys Tailscale uses.
|
|
||||||
package key
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/base64"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
|
|
||||||
"go4.org/mem"
|
|
||||||
"golang.org/x/crypto/curve25519"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Private represents a curve25519 private key of unspecified purpose.
|
|
||||||
//
|
|
||||||
// Deprecated: this key type has been used for several different
|
|
||||||
// keypairs, which are used in different protocols. This makes it easy
|
|
||||||
// to accidentally use the wrong key for a particular purpose, because
|
|
||||||
// the type system doesn't protect you. Please define dedicated key
|
|
||||||
// types for each purpose (e.g. communication with control, disco,
|
|
||||||
// wireguard...) instead, even if they are a Curve25519 value under
|
|
||||||
// the hood.
|
|
||||||
type Private [32]byte
|
|
||||||
|
|
||||||
// Private reports whether p is the zero value.
|
|
||||||
func (p Private) IsZero() bool { return p == Private{} }
|
|
||||||
|
|
||||||
// NewPrivate returns a new private key.
|
|
||||||
func NewPrivate() Private {
|
|
||||||
var p Private
|
|
||||||
rand(p[:])
|
|
||||||
clamp25519Private(p[:])
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
// B32 returns k as the *[32]byte type that's used by the
|
|
||||||
// golang.org/x/crypto packages. This allocates; it might
|
|
||||||
// not be appropriate for performance-sensitive paths.
|
|
||||||
func (k Private) B32() *[32]byte { return (*[32]byte)(&k) }
|
|
||||||
|
|
||||||
// Public represents a curve25519 public key.
|
|
||||||
//
|
|
||||||
// Deprecated: this key type has been used for several different
|
|
||||||
// keypairs, which are used in different protocols. This makes it easy
|
|
||||||
// to accidentally use the wrong key for a particular purpose, because
|
|
||||||
// the type system doesn't protect you. Please define dedicated key
|
|
||||||
// types for each purpose (e.g. communication with control, disco,
|
|
||||||
// wireguard...) instead, even if they are a Curve25519 value under
|
|
||||||
// the hood.
|
|
||||||
type Public [32]byte
|
|
||||||
|
|
||||||
// Public reports whether p is the zero value.
|
|
||||||
func (p Public) IsZero() bool { return p == Public{} }
|
|
||||||
|
|
||||||
// ShortString returns the Tailscale conventional debug representation
|
|
||||||
// of a public key: the first five base64 digits of the key, in square
|
|
||||||
// brackets.
|
|
||||||
func (p Public) ShortString() string {
|
|
||||||
return "[" + base64.StdEncoding.EncodeToString(p[:])[:5] + "]"
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p Public) MarshalText() ([]byte, error) {
|
|
||||||
buf := make([]byte, base64.StdEncoding.EncodedLen(len(p)))
|
|
||||||
base64.StdEncoding.Encode(buf, p[:])
|
|
||||||
return buf, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *Public) UnmarshalText(txt []byte) error {
|
|
||||||
if *p != (Public{}) {
|
|
||||||
return errors.New("refusing to unmarshal into non-zero key.Public")
|
|
||||||
}
|
|
||||||
n, err := base64.StdEncoding.Decode(p[:], txt)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if n != 32 {
|
|
||||||
return fmt.Errorf("short decode of %d; want 32", n)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// B32 returns k as the *[32]byte type that's used by the
|
|
||||||
// golang.org/x/crypto packages. This allocates; it might
|
|
||||||
// not be appropriate for performance-sensitive paths.
|
|
||||||
func (k Public) B32() *[32]byte { return (*[32]byte)(&k) }
|
|
||||||
|
|
||||||
func (k Private) Public() Public {
|
|
||||||
var pub [32]byte
|
|
||||||
curve25519.ScalarBaseMult(&pub, (*[32]byte)(&k))
|
|
||||||
return Public(pub)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (k Private) SharedSecret(pub Public) (ss [32]byte) {
|
|
||||||
apk := (*[32]byte)(&pub)
|
|
||||||
ask := (*[32]byte)(&k)
|
|
||||||
curve25519.ScalarMult(&ss, ask, apk)
|
|
||||||
return ss
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewPublicFromHexMem parses a public key in its hex form, given in m.
|
|
||||||
// The provided m must be exactly 64 bytes in length.
|
|
||||||
func NewPublicFromHexMem(m mem.RO) (Public, error) {
|
|
||||||
if m.Len() != 64 {
|
|
||||||
return Public{}, errors.New("invalid length")
|
|
||||||
}
|
|
||||||
var p Public
|
|
||||||
for i := range p {
|
|
||||||
a, ok1 := fromHexChar(m.At(i*2 + 0))
|
|
||||||
b, ok2 := fromHexChar(m.At(i*2 + 1))
|
|
||||||
if !ok1 || !ok2 {
|
|
||||||
return Public{}, errors.New("invalid hex character")
|
|
||||||
}
|
|
||||||
p[i] = (a << 4) | b
|
|
||||||
}
|
|
||||||
return p, nil
|
|
||||||
}
|
|
||||||
@ -1,74 +0,0 @@
|
|||||||
// Copyright (c) 2020 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"
|
|
||||||
"reflect"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
type tmu interface {
|
|
||||||
encoding.TextMarshaler
|
|
||||||
encoding.TextUnmarshaler
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTextMarshal(t *testing.T) {
|
|
||||||
// Check that keys roundtrip correctly through marshaling, and
|
|
||||||
// cannot be unmarshaled as other key types.
|
|
||||||
type keyMaker func() (random, zero tmu)
|
|
||||||
keys := []keyMaker{
|
|
||||||
func() (tmu, tmu) { k := NewMachine(); return &k, &MachinePrivate{} },
|
|
||||||
func() (tmu, tmu) { k := NewMachine().Public(); return &k, &MachinePublic{} },
|
|
||||||
func() (tmu, tmu) { k := NewPrivate().Public(); return &k, &Public{} },
|
|
||||||
}
|
|
||||||
for i, kf := range keys {
|
|
||||||
k1, k2 := kf()
|
|
||||||
// Sanity check: both k's should have the same type, k2 should
|
|
||||||
// be the zero value.
|
|
||||||
if t1, t2 := reflect.ValueOf(k1).Elem().Type(), reflect.ValueOf(k2).Elem().Type(); t1 != t2 {
|
|
||||||
t.Fatalf("got two keys of different types %T and %T", t1, t2)
|
|
||||||
}
|
|
||||||
if !reflect.ValueOf(k2).Elem().IsZero() {
|
|
||||||
t.Fatal("k2 is not the zero value")
|
|
||||||
}
|
|
||||||
|
|
||||||
// All keys should marshal successfully.
|
|
||||||
t1, err := k1.MarshalText()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("MarshalText(%#v): %v", k1, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Marshalling should round-trip.
|
|
||||||
if err := k2.UnmarshalText(t1); err != nil {
|
|
||||||
t.Fatalf("UnmarshalText(MarshalText(%#v)): %v", k1, err)
|
|
||||||
}
|
|
||||||
if !reflect.DeepEqual(k1, k2) {
|
|
||||||
t.Fatalf("UnmarshalText(MarshalText(k1)) changed\n old: %#v\n new: %#v", k1, k2)
|
|
||||||
}
|
|
||||||
|
|
||||||
// And the text representation should also roundtrip.
|
|
||||||
t2, err := k2.MarshalText()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("MarshalText(%#v): %v", k2, err)
|
|
||||||
}
|
|
||||||
if !bytes.Equal(t1, t2) {
|
|
||||||
t.Fatal("MarshalText(k1) != MarshalText(k2)")
|
|
||||||
}
|
|
||||||
|
|
||||||
// No other key type should be able to unmarshal the text of a
|
|
||||||
// different key.
|
|
||||||
for j, otherkf := range keys {
|
|
||||||
if i == j {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
_, otherk := otherkf()
|
|
||||||
if err := otherk.UnmarshalText(t1); err == nil {
|
|
||||||
t.Fatalf("key %#v can unmarshal as %#v (marshaled form %q)", k1, otherk, t1)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue