types/logid: move logtail ID types here (#6336)

Many packages reference the logtail ID types,
but unfortunately pull in the transitive dependencies of logtail.
Fix this problem by putting the log ID types in its own package
with minimal dependencies.

Signed-off-by: Joe Tsai <joetsai@digital-static.net>

types/logid/id.go

@@ -0,0 +1,183 @@
+// 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 logid
+
+import (
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+	"fmt"
+)
+
+// PrivateID represents an instance that write logs.
+// Private IDs are only shared with the server when writing logs.
+type PrivateID [32]byte
+
+// Safely generate a new PrivateId for use in Config objects.
+// You should persist this across runs of an instance of your app, so that
+// it can append to the same log file on each run.
+func NewPrivateID() (id PrivateID, err error) {
+	_, err = rand.Read(id[:])
+	if err != nil {
+		return PrivateID{}, err
+	}
+	// Clamping, for future use.
+	id[0] &= 248
+	id[31] = (id[31] & 127) | 64
+	return id, nil
+}
+
+func (id PrivateID) MarshalText() ([]byte, error) {
+	b := make([]byte, hex.EncodedLen(len(id)))
+	if i := hex.Encode(b, id[:]); i != len(b) {
+		return nil, fmt.Errorf("logtail.PrivateID.MarshalText: i=%d", i)
+	}
+	return b, nil
+}
+
+// ParsePrivateID returns a PrivateID from its hex (String) representation.
+func ParsePrivateID(s string) (PrivateID, error) {
+	if len(s) != 64 {
+		return PrivateID{}, errors.New("invalid length")
+	}
+	var p PrivateID
+	for i := range p {
+		a, ok1 := fromHexChar(s[i*2+0])
+		b, ok2 := fromHexChar(s[i*2+1])
+		if !ok1 || !ok2 {
+			return PrivateID{}, errors.New("invalid hex character")
+		}
+		p[i] = (a << 4) | b
+	}
+	return p, nil
+}
+
+// IsZero reports whether id is the zero value.
+func (id PrivateID) IsZero() bool { return id == PrivateID{} }
+
+func (id *PrivateID) UnmarshalText(s []byte) error {
+	b, err := hex.DecodeString(string(s))
+	if err != nil {
+		return fmt.Errorf("logtail.PrivateID.UnmarshalText: %v", err)
+	}
+	if len(b) != len(id) {
+		return fmt.Errorf("logtail.PrivateID.UnmarshalText: invalid hex length: %d", len(b))
+	}
+	copy(id[:], b)
+	return nil
+}
+
+func (id PrivateID) String() string {
+	b, err := id.MarshalText()
+	if err != nil {
+		panic(err)
+	}
+	return string(b)
+}
+
+func (id PrivateID) Public() (pub PublicID) {
+	h := sha256.New()
+	h.Write(id[:])
+	if n := copy(pub[:], h.Sum(pub[:0])); n != len(pub) {
+		panic(fmt.Sprintf("public id short copy: %d", n))
+	}
+	return pub
+}
+
+// PublicID represents an instance in the logs service for reading and adoption.
+// The public ID value is a SHA-256 hash of a private ID.
+type PublicID [sha256.Size]byte
+
+// ParsePublicID returns a PublicID from its hex (String) representation.
+func ParsePublicID(s string) (PublicID, error) {
+	if len(s) != sha256.Size*2 {
+		return PublicID{}, errors.New("invalid length")
+	}
+	var p PublicID
+	for i := range p {
+		a, ok1 := fromHexChar(s[i*2+0])
+		b, ok2 := fromHexChar(s[i*2+1])
+		if !ok1 || !ok2 {
+			return PublicID{}, errors.New("invalid hex character")
+		}
+		p[i] = (a << 4) | b
+	}
+	return p, nil
+}
+
+// MustParsePublicID calls ParsePublicID and panics in case of an error.
+// It is intended for use with constant strings, typically in tests.
+func MustParsePublicID(s string) PublicID {
+	id, err := ParsePublicID(s)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+func (id PublicID) MarshalText() ([]byte, error) {
+	b := make([]byte, hex.EncodedLen(len(id)))
+	if i := hex.Encode(b, id[:]); i != len(b) {
+		return nil, fmt.Errorf("logtail.PublicID.MarshalText: i=%d", i)
+	}
+	return b, nil
+}
+
+func (id *PublicID) UnmarshalText(s []byte) error {
+	if len(s) != len(id)*2 {
+		return fmt.Errorf("logtail.PublicID.UnmarshalText: invalid hex length: %d", len(s))
+	}
+	for i := range id {
+		a, ok1 := fromHexChar(s[i*2+0])
+		b, ok2 := fromHexChar(s[i*2+1])
+		if !ok1 || !ok2 {
+			return errors.New("invalid hex character")
+		}
+		id[i] = (a << 4) | b
+	}
+	return nil
+}
+
+func (id PublicID) String() string {
+	b, err := id.MarshalText()
+	if err != nil {
+		panic(err)
+	}
+	return string(b)
+}
+
+// fromHexChar converts a hex character into its value and a success flag.
+func fromHexChar(c byte) (byte, bool) {
+	switch {
+	case '0' <= c && c <= '9':
+		return c - '0', true
+	case 'a' <= c && c <= 'f':
+		return c - 'a' + 10, true
+	case 'A' <= c && c <= 'F':
+		return c - 'A' + 10, true
+	}
+
+	return 0, false
+}
+
+func (id1 PublicID) Less(id2 PublicID) bool {
+	for i, c1 := range id1[:] {
+		c2 := id2[i]
+		if c1 != c2 {
+			return c1 < c2
+		}
+	}
+	return false // equal
+}
+
+func (id PublicID) IsZero() bool {
+	return id == PublicID{}
+}
+
+func (id PublicID) Prefix64() uint64 {
+	return binary.BigEndian.Uint64(id[:8])
+}

types/logid/id_test.go

@@ -0,0 +1,67 @@
+// 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 logid
+
+import (
+	"testing"
+)
+
+func TestIDs(t *testing.T) {
+	id1, err := NewPrivateID()
+	if err != nil {
+		t.Fatal(err)
+	}
+	pub1 := id1.Public()
+
+	id2, err := NewPrivateID()
+	if err != nil {
+		t.Fatal(err)
+	}
+	pub2 := id2.Public()
+
+	if id1 == id2 {
+		t.Fatalf("subsequent private IDs match: %v", id1)
+	}
+	if pub1 == pub2 {
+		t.Fatalf("subsequent public IDs match: %v", id1)
+	}
+	if id1.String() == id2.String() {
+		t.Fatalf("id1.String()=%v equals id2.String()", id1.String())
+	}
+	if pub1.String() == pub2.String() {
+		t.Fatalf("pub1.String()=%v equals pub2.String()", pub1.String())
+	}
+
+	id1txt, err := id1.MarshalText()
+	if err != nil {
+		t.Fatal(err)
+	}
+	var id3 PrivateID
+	if err := id3.UnmarshalText(id1txt); err != nil {
+		t.Fatal(err)
+	}
+	if id1 != id3 {
+		t.Fatalf("id1 %v: marshal and unmarshal gives different key: %v", id1, id3)
+	}
+	if want, got := id1.Public(), id3.Public(); want != got {
+		t.Fatalf("id1.Public()=%v does not match id3.Public()=%v", want, got)
+	}
+	if id1.String() != id3.String() {
+		t.Fatalf("id1.String()=%v does not match id3.String()=%v", id1.String(), id3.String())
+	}
+	if id3, err := ParsePublicID(id1.Public().String()); err != nil {
+		t.Errorf("ParsePublicID: %v", err)
+	} else if id1.Public() != id3 {
+		t.Errorf("ParsePublicID mismatch")
+	}
+
+	id4, err := ParsePrivateID(id1.String())
+	if err != nil {
+		t.Fatalf("failed to ParsePrivateID(%q): %v", id1.String(), err)
+	}
+	if id1 != id4 {
+		t.Fatalf("ParsePrivateID returned different id")
+	}
+}