Ability to skip UTC→TAI conversion during encoding

diff --git a/go/cmd/test-vector-anys/main.go b/go/cmd/test-vector-anys/main.go
index a5d232a6b2977b0d9e76db3c6d104cd464b4d5494543ba92fb4d69d9cc4b3097..650eee1017268fa56b78cb67515b98c0a777f36d668f69c59d03343ea3da8cbf 100644 (file)
--- a/go/cmd/test-vector-anys/main.go
+++ b/go/cmd/test-vector-anys/main.go
@@ -104,7 +104,7 @@ func main() {
                "uuid": uuid.MustParse("0e875e3f-d385-49eb-87b4-be42d641c367"),
        }
        var buf bytes.Buffer
-       _, err := keks.Encode(&buf, data)
+       _, err := keks.Encode(&buf, data, nil)
        if err != nil {
                log.Fatal(err)
        }

diff --git a/go/encode.go b/go/encode.go
index 6dcbc2951a9293af4b147b756a10494d2cac24594d4e0abd91b409a2c6c7ba8a..cd478f1e2732ea42ab1b9ecc823f38e7f3bb97339e34ef5086ade37d5e3b786c 100644 (file)
--- a/go/encode.go
+++ b/go/encode.go
@@ -33,7 +33,12 @@ import (
 
 var bigIntZero = big.NewInt(0)
 
-func Encode(w io.Writer, v any) (written int64, err error) {
+type EncodeOpts struct {
+       // Do not convert time.Time to TAI, assume no conversion is needed.
+       LeaveTAI bool
+}
+
+func Encode(w io.Writer, v any, opts *EncodeOpts) (written int64, err error) {
        if v == nil {
                return ByteEncode(w, byte(AtomNIL))
        }
@@ -49,7 +54,9 @@ func Encode(w io.Writer, v any) (written int64, err error) {
        case BlobReader:
                return BlobEncode(w, v.ChunkLen, v.R)
        case time.Time:
-               v = tai64n.Leapsecs.Add(v)
+               if opts == nil || !opts.LeaveTAI {
+                       v = tai64n.Leapsecs.Add(v)
+               }
                if v.Nanosecond() > 0 {
                        var tai tai64n.TAI64N
                        tai.FromTime(v)
@@ -108,7 +115,7 @@ func Encode(w io.Writer, v any) (written int64, err error) {
                if vv.IsNil() {
                        return ByteEncode(w, byte(AtomNIL))
                }
-               return Encode(w, vv.Elem().Interface())
+               return Encode(w, vv.Elem().Interface(), opts)
        case reflect.Slice:
                _, err = ByteEncode(w, byte(AtomList))
                if err != nil {
@@ -118,7 +125,7 @@ func Encode(w io.Writer, v any) (written int64, err error) {
                var n64 int64
                if anys, ok := v.([]any); ok {
                        for _, v := range anys {
-                               n64, err = Encode(w, v)
+                               n64, err = Encode(w, v, opts)
                                written += n64
                                if err != nil {
                                        return
@@ -126,7 +133,7 @@ func Encode(w io.Writer, v any) (written int64, err error) {
                        }
                } else {
                        for i := 0; i < vv.Len(); i++ {
-                               n64, err = Encode(w, vv.Index(i).Interface())
+                               n64, err = Encode(w, vv.Index(i).Interface(), opts)
                                written += n64
                                if err != nil {
                                        return
@@ -154,7 +161,7 @@ func Encode(w io.Writer, v any) (written int64, err error) {
                        if err != nil {
                                return
                        }
-                       n64, err = Encode(w, vv.MapIndex(k).Interface())
+                       n64, err = Encode(w, vv.MapIndex(k).Interface(), opts)
                        written += n64
                        if err != nil {
                                return
@@ -217,7 +224,7 @@ func Encode(w io.Writer, v any) (written int64, err error) {
                        if err != nil {
                                return
                        }
-                       n64, err = Encode(w, fv.Interface())
+                       n64, err = Encode(w, fv.Interface(), opts)
                        written += n64
                        if err != nil {
                                return
@@ -234,8 +241,8 @@ func Encode(w io.Writer, v any) (written int64, err error) {
        return
 }
 
-func EncodeBuf(v any) ([]byte, error) {
+func EncodeBuf(v any, opts *EncodeOpts) ([]byte, error) {
        var b bytes.Buffer
-       _, err := Encode(&b, v)
+       _, err := Encode(&b, v, opts)
        return b.Bytes(), err
 }

diff --git a/go/fuzz_test.go b/go/fuzz_test.go
index b7f4c4a34a4c2f3653c44dcf32b8f27f2e4ad7ffdb8f71219818d554d7082bcc..2fbe92b32e54a1b5c4b26e29ce6ccc799c96e190e5009ce46761b6b9c38b7277 100644 (file)
--- a/go/fuzz_test.go
+++ b/go/fuzz_test.go
@@ -23,7 +23,7 @@ func FuzzDecode(f *testing.F) {
                                t.Fatal(err)
                        }
                        buf.Reset()
-                       _, err = Encode(&buf, v)
+                       _, err = Encode(&buf, v, nil)
                        if err != nil {
                                t.Fatal(err)
                        }

diff --git a/go/pki/av.go b/go/pki/av.go
index f8bf2e01752ed15f3730713809ee1dc236f25386c8197030a83cf0a00a35a679..289bac3ba89e70569a52de1ee9c480586b17f1b5154b8f1c03f6bebb1f79858f 100644 (file)
--- a/go/pki/av.go
+++ b/go/pki/av.go
@@ -45,7 +45,7 @@ func (av *AV) Id() (id uuid.UUID) {
                id = uuid.Nil
                return
        }
-       _, err := keks.Encode(hasher, av)
+       _, err := keks.Encode(hasher, av, nil)
        if err != nil {
                panic(err)
        }

diff --git a/go/pki/cer.go b/go/pki/cer.go
index cdb5ac87746bab8d6d892cf9ec8800b434b77b089bdfbc75d7542b98bf0d61d7..02a9120aef943323d64037027138bdfbadf350796c0151935c75212818338c6a 100644 (file)
--- a/go/pki/cer.go
+++ b/go/pki/cer.go
@@ -190,7 +190,7 @@ func (sd *SignedData) CerCheckSignatureFrom(parent *CerLoad) (err error) {
                return
        }
        tbs := SignedDataTBS{T: sd.Load.T, V: sd.Load.V, TBS: sig.TBS}
-       buf, err := keks.EncodeBuf(tbs)
+       buf, err := keks.EncodeBuf(tbs, nil)
        if err != nil {
                return
        }

diff --git a/go/pki/cmd/kekscertool/main.go b/go/pki/cmd/kekscertool/main.go
index d09e97b21e5fc9ef33b7e98215ee5079717082d2edbf96d8f8d8a4eeaa31b3cc..2658f41ebb27d7dca1cb292ad08ae56ae70281c9d9b5a46aab1d522f39f45785 100644 (file)
--- a/go/pki/cmd/kekscertool/main.go
+++ b/go/pki/cmd/kekscertool/main.go
@@ -157,7 +157,7 @@ func main() {
                        log.Fatal(err)
                }
                var data []byte
-               data, err = keks.EncodeBuf(pki.AV{A: *algo, V: prvRaw})
+               data, err = keks.EncodeBuf(pki.AV{A: *algo, V: prvRaw}, nil)
                if err != nil {
                        log.Fatal(err)
                }
@@ -190,7 +190,7 @@ func main() {
        }
 
        var data []byte
-       data, err = keks.EncodeBuf(sd)
+       data, err = keks.EncodeBuf(sd, nil)
        if err != nil {
                log.Fatal(err)
        }

diff --git a/go/pki/cmd/kekssdtool/main.go b/go/pki/cmd/kekssdtool/main.go
index 9ff790e2bdaa7c2936ae7826a435285d1233b1b76c6da430877fd2a9bcdf2f15..3e6e40a8175f86f559fb8c291e292fa0db099ae2c359265aa4e47c6719a75796 100644 (file)
--- a/go/pki/cmd/kekssdtool/main.go
+++ b/go/pki/cmd/kekssdtool/main.go
@@ -114,7 +114,7 @@ func main() {
                        log.Fatal(err)
                }
                var data []byte
-               data, err = keks.EncodeBuf(sd)
+               data, err = keks.EncodeBuf(sd, nil)
                if err != nil {
                        log.Fatal(err)
                }

diff --git a/go/pki/signed-data.go b/go/pki/signed-data.go
index e95c30b3a040e538f1d5cc8069334f736e2ad97d476ddc71c9dbddfa32c12eed..5d2bb87a4732ed2f37f198af93c68ab2206bcdf8a7050c1529506d4d37e81270 100644 (file)
--- a/go/pki/signed-data.go
+++ b/go/pki/signed-data.go
@@ -147,7 +147,7 @@ func (sd *SignedData) SignWith(
        sig := Sig{TBS: sigTBS}
        sig.Sign.A = parent.Pub[0].A
        var buf []byte
-       buf, err = keks.EncodeBuf(sdTBS)
+       buf, err = keks.EncodeBuf(sdTBS, nil)
        if err != nil {
                return
        }