You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
248 lines
9.6 KiB
248 lines
9.6 KiB
package datekey_test
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"errors"
|
|
"math/rand/v2"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
datekeys "g.activething.com/go/DateKeys"
|
|
"g.activething.com/go/DateKeys/datekey"
|
|
"g.activething.com/go/DateKeys/internal/testkit"
|
|
"g.activething.com/go/DateKeys/profile"
|
|
)
|
|
|
|
func TestNormativeRoundVector(t *testing.T) {
|
|
// Spec §16, stated literally.
|
|
p := profile.Quicknet()
|
|
d, err := datekey.Resolve(p, time.Date(2030, 1, 1, 0, 0, 0, 0, time.UTC))
|
|
if err != nil || d.Round != 66884212 {
|
|
t.Fatalf("2030-01-01 resolved to %+v, %v", d, err)
|
|
}
|
|
if got := d.UnlockAt(p).Format(time.RFC3339); got != "2030-01-01T00:00:00Z" {
|
|
t.Fatalf("round time %s", got)
|
|
}
|
|
rt, err := datekey.RoundTime(p, 66432123)
|
|
if err != nil || rt.Format(time.RFC3339) != "2029-12-16T07:15:33Z" {
|
|
t.Fatalf("round 66432123 at %s, %v", rt, err)
|
|
}
|
|
if got := d.Compact(); got != "dk1_eyJ2ZXJzaW9uIjoxLCJuZXR3b3JrIjoiZGF0ZWtleXM6cXVpY2tuZXQ6djEiLCJyb3VuZCI6NjY4ODQyMTJ9" {
|
|
t.Fatalf("dk1_ %s", got)
|
|
}
|
|
if got := string(d.CanonicalJSON()); got != `{"version":1,"network":"datekeys:quicknet:v1","round":66884212}` {
|
|
t.Fatalf("canonical JSON %s", got)
|
|
}
|
|
}
|
|
|
|
func TestGoldenRoundVectors(t *testing.T) {
|
|
var golden testkit.RoundVectorFile
|
|
if err := testkit.ReadJSON("../testdata/vectors/quicknet_rounds.json", &golden); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := testkit.RoundVectors(); !reflect.DeepEqual(got, golden) {
|
|
t.Fatalf("round vectors changed:\n got %+v\nwant %+v", got, golden)
|
|
}
|
|
p := profile.Quicknet()
|
|
for _, v := range golden.Vectors {
|
|
at, err := time.Parse(time.RFC3339Nano, v.Requested)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
d, err := datekey.Resolve(p, at)
|
|
if v.Error != "" {
|
|
if datekeys.Code(err) != v.Error {
|
|
t.Errorf("%s: got %v, want %s", v.Name, err, v.Error)
|
|
}
|
|
continue
|
|
}
|
|
if err != nil || d.Round != v.Round || d.UnlockAt(p).Format(time.RFC3339Nano) != v.Effective {
|
|
t.Errorf("%s: got %+v %v", v.Name, d, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGoldenDK1Vectors(t *testing.T) {
|
|
var golden testkit.DK1VectorFile
|
|
if err := testkit.ReadJSON("../testdata/vectors/dk1.json", &golden); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := testkit.DK1Vectors(); !reflect.DeepEqual(got, golden) {
|
|
t.Fatalf("dk1_ vectors changed")
|
|
}
|
|
for _, v := range golden.Vectors {
|
|
if v.DK1 != "" {
|
|
d, err := datekey.Parse(v.DK1)
|
|
if err != nil || d.ProfileID != v.Network || d.Round != v.Round {
|
|
t.Errorf("%s: %+v %v", v.Name, d, err)
|
|
}
|
|
if string(d.CanonicalJSON()) != v.CanonicalJSON || base64.RawURLEncoding.EncodeToString(d.CanonicalJSON()) != v.Base64URL {
|
|
t.Errorf("%s: intermediate encodings differ", v.Name)
|
|
}
|
|
continue
|
|
}
|
|
if v.Error == "accepted" {
|
|
t.Errorf("%s: a rejected-encoding vector is accepted", v.Name)
|
|
}
|
|
if _, err := datekey.Parse(v.Input); datekeys.Code(err) != v.Error {
|
|
t.Errorf("%s: got %v, want %s", v.Name, err, v.Error)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Kept from the prototype: resolution never picks a round that opens early.
|
|
func TestRoundNeverOpensEarly(t *testing.T) {
|
|
p := profile.Quicknet()
|
|
g := time.Unix(p.GenesisTime, 0).UTC()
|
|
for _, tc := range []struct {
|
|
offset time.Duration
|
|
want uint64
|
|
}{
|
|
{0, 1}, {time.Nanosecond, 2}, {time.Second, 2}, {3 * time.Second, 2}, {3*time.Second + time.Nanosecond, 3}, {2997 * time.Second, 1000},
|
|
} {
|
|
requested := g.Add(tc.offset)
|
|
d, err := datekey.Resolve(p, requested)
|
|
if err != nil || d.Round != tc.want {
|
|
t.Fatalf("offset %s: %+v, %v", tc.offset, d, err)
|
|
}
|
|
if u := d.UnlockAt(p); u.Before(requested) || u.Sub(requested) >= p.Period {
|
|
t.Fatal("unsafe rounding")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestResolveProperty(t *testing.T) {
|
|
p := profile.Quicknet()
|
|
r := rand.New(rand.NewPCG(3, 4))
|
|
for range 20000 {
|
|
secs := p.GenesisTime + r.Int64N(profile.MaxUnixTime-p.GenesisTime-3)
|
|
at := time.Unix(secs, r.Int64N(int64(time.Second)))
|
|
d, err := datekey.Resolve(p, at)
|
|
if err != nil {
|
|
t.Fatalf("%s: %v", at, err)
|
|
}
|
|
u := d.UnlockAt(p)
|
|
// The first round whose time is >= at: never earlier, and the previous
|
|
// round is strictly earlier.
|
|
if u.Before(at) {
|
|
t.Fatalf("%s resolves to round %d at %s, before the request", at, d.Round, u)
|
|
}
|
|
if d.Round > 1 {
|
|
prev, _ := datekey.RoundTime(p, d.Round-1)
|
|
if !prev.Before(at) {
|
|
t.Fatalf("%s: round %d at %s would already satisfy the request", at, d.Round-1, prev)
|
|
}
|
|
}
|
|
parsed, err := datekey.Parse(d.Compact())
|
|
if err != nil || parsed != d {
|
|
t.Fatalf("Parse(Compact(d)) != d for %+v: %v", d, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTimezoneIndependence(t *testing.T) {
|
|
p := profile.Quicknet()
|
|
a, _ := time.Parse(time.RFC3339Nano, "2026-10-22T19:00:00.001+02:00")
|
|
b, _ := time.Parse(time.RFC3339Nano, "2026-10-22T17:00:00.001Z")
|
|
da, _ := datekey.Resolve(p, a)
|
|
db, _ := datekey.Resolve(p, b)
|
|
if da != db {
|
|
t.Fatal("timezone changed the DateKey")
|
|
}
|
|
}
|
|
|
|
func TestValidate(t *testing.T) {
|
|
p := profile.Quicknet()
|
|
if err := (datekey.DateKey{ProfileID: "datekeys:evmnet:v1", Round: 5}).Validate(p); !errors.Is(err, datekeys.ErrProfileMismatch) {
|
|
t.Fatalf("other profile: %v", err)
|
|
}
|
|
for _, r := range []uint64{0, p.MaxRound() + 1} {
|
|
if err := (datekey.DateKey{ProfileID: p.ID, Round: r}).Validate(p); !errors.Is(err, datekeys.ErrDateKeyInvalid) {
|
|
t.Fatalf("round %d: %v", r, err)
|
|
}
|
|
}
|
|
if !(datekey.DateKey{ProfileID: p.ID, Round: 0}).UnlockAt(p).IsZero() {
|
|
t.Fatal("invalid DateKey has an unlock time")
|
|
}
|
|
if (datekey.DateKey{ProfileID: `bad"id`, Round: 1}).Compact() != "" {
|
|
t.Fatal("invalid DateKey has a dk1_ form")
|
|
}
|
|
if _, err := datekey.Resolve(p, time.Time{}); !errors.Is(err, datekeys.ErrDateKeyInvalid) {
|
|
t.Fatalf("zero time: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNumberSpellings(t *testing.T) {
|
|
enc := func(round string) string {
|
|
return datekey.Prefix + base64.RawURLEncoding.EncodeToString([]byte(`{"version":1,"network":"datekeys:quicknet:v1","round":`+round+`}`))
|
|
}
|
|
for _, s := range []string{"1000.0", "1e3", "1E3", "10e2", "1000e0", "100000e-2", "0.1e4"} {
|
|
if _, err := datekey.Parse(enc(s)); !errors.Is(err, datekeys.ErrDateKeyNonCanonical) {
|
|
t.Errorf("%s: %v, want non-canonical", s, err)
|
|
}
|
|
}
|
|
for _, s := range []string{"1.5", "-1000", "1e-3", "1e400", "18446744073709551616", "0", "-0", "0e5"} {
|
|
if _, err := datekey.Parse(enc(s)); !errors.Is(err, datekeys.ErrDateKeyInvalid) {
|
|
t.Errorf("%s: %v, want invalid", s, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Spec §19, the reading rules of steps 1 to 3: step 1 accepts only the two
|
|
// Base64 alphabets, so CR and LF, which the Go decoders would skip, fail
|
|
// there; step 2 accepts one RFC 8259 JSON text holding an object, with JSON
|
|
// white space around it but no byte order mark; step 3 reads the exact
|
|
// decimal value of each number, never its IEEE 754 double.
|
|
func TestReadingRules(t *testing.T) {
|
|
canon := datekey.DateKey{ProfileID: profile.QuicknetID, Round: 66884212}.Compact()
|
|
payload := canon[len(datekey.Prefix):]
|
|
enc := func(json string) string {
|
|
return datekey.Prefix + base64.RawURLEncoding.EncodeToString([]byte(json))
|
|
}
|
|
for _, tc := range []struct {
|
|
name, in string
|
|
want error
|
|
}{
|
|
{"LF inside the Base64", datekey.Prefix + payload[:8] + "\n" + payload[8:], datekeys.ErrDateKeyInvalid},
|
|
{"CR inside the Base64", datekey.Prefix + payload[:8] + "\r" + payload[8:], datekeys.ErrDateKeyInvalid},
|
|
{"CR LF after the Base64", canon + "\r\n", datekeys.ErrDateKeyInvalid},
|
|
{"LF before the Base64", datekey.Prefix + "\n" + payload, datekeys.ErrDateKeyInvalid},
|
|
{"space inside the Base64", datekey.Prefix + payload[:8] + " " + payload[8:], datekeys.ErrDateKeyInvalid},
|
|
{"both alphabets mixed", datekey.Prefix + "-+" + payload[2:], datekeys.ErrDateKeyInvalid},
|
|
{"byte order mark", enc("\ufeff" + `{"version":1,"network":"datekeys:quicknet:v1","round":66884212}`), datekeys.ErrDateKeyInvalid},
|
|
{"JSON white space before the object", enc(" \t\r\n" + `{"version":1,"network":"datekeys:quicknet:v1","round":66884212}`), datekeys.ErrDateKeyNonCanonical},
|
|
{"invalid UTF-8 in a member a repeated name overwrites", enc(`{"version":1,"network":"` + "\xff" + `","network":"datekeys:quicknet:v1","round":66884212}`), datekeys.ErrDateKeyInvalid},
|
|
{"invalid UTF-8 in a member name", enc(`{"version":1,"netw` + "\xff" + `ork":"x","network":"datekeys:quicknet:v1","round":66884212}`), datekeys.ErrDateKeyInvalid},
|
|
{"a JSON array", enc(`[{"version":1,"network":"datekeys:quicknet:v1","round":66884212}]`), datekeys.ErrDateKeyInvalid},
|
|
{"version 1.0000000000000001, 1 as a double", enc(`{"version":1.0000000000000001,"network":"datekeys:quicknet:v1","round":66884212}`), datekeys.ErrDateKeyInvalid},
|
|
{"round 66884212.00000000000001", enc(`{"version":1,"network":"datekeys:quicknet:v1","round":66884212.00000000000001}`), datekeys.ErrDateKeyInvalid},
|
|
{"round 2^53+1, 2^53 as a double", enc(`{"version":1,"network":"datekeys:quicknet:v1","round":9007199254740993}`), datekeys.ErrDateKeyInvalid},
|
|
{"version 1.0", enc(`{"version":1.0,"network":"datekeys:quicknet:v1","round":66884212}`), datekeys.ErrDateKeyNonCanonical},
|
|
{"version 100e-2", enc(`{"version":100e-2,"network":"datekeys:quicknet:v1","round":66884212}`), datekeys.ErrDateKeyNonCanonical},
|
|
} {
|
|
if _, err := datekey.Parse(tc.in); !errors.Is(err, tc.want) {
|
|
t.Errorf("%s: %v, want %s", tc.name, err, datekeys.Code(tc.want))
|
|
}
|
|
}
|
|
}
|
|
|
|
func FuzzParse(f *testing.F) {
|
|
d := datekey.DateKey{ProfileID: profile.QuicknetID, Round: 1000}
|
|
f.Add(d.Compact())
|
|
f.Add("dk1_invalid")
|
|
f.Add(datekey.Prefix + base64.RawURLEncoding.EncodeToString([]byte(`{"version":1,"network":"a","round":1e3}`)))
|
|
f.Fuzz(func(t *testing.T, s string) {
|
|
d, err := datekey.Parse(s)
|
|
if err != nil {
|
|
if c := datekeys.Code(err); c != "ERR_DATEKEY_INVALID" && c != "ERR_DATEKEY_NON_CANONICAL" {
|
|
t.Fatalf("unexpected error %v", err)
|
|
}
|
|
return
|
|
}
|
|
if d.Compact() != s {
|
|
t.Fatal("accepted a non-canonical DateKey")
|
|
}
|
|
})
|
|
}
|