improve print

go.mod

@@ -1,5 +1,5 @@
 module git.purser.it/roypur/stoken
 
-go 1.17
+go 1.18
 
-require github.com/ugorji/go/codec v1.2.6
+require github.com/ugorji/go/codec v1.2.7 // indirect

go.sum

@@ -1,4 +1,4 @@
-github.com/ugorji/go v1.2.6 h1:tGiWC9HENWE2tqYycIqFTNorMmFRVhNwCpDOpWqnk8E=
-github.com/ugorji/go v1.2.6/go.mod h1:anCg0y61KIhDlPZmnH+so+RQbysYVyDko0IMgJv0Nn0=
-github.com/ugorji/go/codec v1.2.6 h1:7kbGefxLoDBuYXOms4yD7223OpNMMPNPZxXk5TvFcyQ=
-github.com/ugorji/go/codec v1.2.6/go.mod h1:V6TCNZ4PHqoHGFZuSG1W8nrCzzdgA2DozYxWFFpvxTw=
+github.com/ugorji/go v1.2.7 h1:qYhyWUUd6WbiM+C6JZAUkIJt/1WrjzNHY9+KCIjVqTo=
+github.com/ugorji/go v1.2.7/go.mod h1:nF9osbDWLy6bDVv/Rtoh6QgnvNDpmCalQV5urGCCS6M=
+github.com/ugorji/go/codec v1.2.7 h1:YPXUKf7fYbp/y8xloBqZOw2qaVggbfwMlI8WM3wZUJ0=
+github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY=

sign.go

@@ -7,7 +7,6 @@ import (
 	"encoding/base64"
 	"encoding/hex"
 	"errors"
-	"fmt"
 	"github.com/ugorji/go/codec"
 	"hash/crc64"
 	"strings"
@@ -17,11 +16,16 @@ const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789
 
 var b64 = base64.NewEncoding(alphabet).WithPadding(base64.NoPadding)
 
-type linkData struct {
+type tokenData struct {
 	Signature []byte `codec:"s"`
 	Payload   []byte `codec:"p"`
 }
 
+type tokenPrint struct {
+	Signature string      `codec:"signature"`
+	Payload   interface{} `codec:"payload"`
+}
+
 type TokenCoder struct {
 	valid   bool
 	privKey ed25519.PrivateKey
@@ -51,21 +55,49 @@ func (tc TokenCoder) SeedHex() string {
 	return hex.EncodeToString(tc.Seed())
 }
 
-func NewTokenCoder(seed []byte, pubKeys ...[]byte) (tc TokenCoder, err error) {
-	tc.pubKeys = make([]ed25519.PublicKey, len(pubKeys)+1, len(pubKeys)+1)
-	if len(seed) == 0 {
-		seed = make([]byte, ed25519.SeedSize, ed25519.SeedSize)
-		_, err = rand.Read(seed)
-		if err != nil {
-			return
-		}
+func Format(token string) (txt string, err error) {
+	var tp tokenPrint
+	var data []byte
+	data, err = b64.DecodeString(strings.TrimFunc(token, trim))
+	if err != nil {
+		return
 	}
 
+	buf := bytes.NewBuffer(nil)
+	var cHandle codec.CborHandle
+	var jHandle codec.JsonHandle
+	jHandle.HTMLCharsAsIs = true
+	jHandle.MapKeyAsString = true
+	jHandle.Indent = 4
+
+	buf.Write(data)
+	dec := codec.NewDecoder(buf, &cHandle)
+
+	var td tokenData
+	err = dec.Decode(&td)
+	if err != nil {
+		return
+	}
+
+	tp.Signature = hex.EncodeToString(td.Signature)
+	buf.Reset()
+	buf.Write(td.Payload)
+
+	err = dec.Decode(&tp.Payload)
+	buf.Reset()
+	enc := codec.NewEncoder(buf, &jHandle)
+	err = enc.Encode(tp)
+	txt = buf.String()
+	return
+}
+
+func NewTokenCoderWithSeed(seed []byte, pubKeys ...[]byte) (tc TokenCoder, err error) {
 	if len(seed) != ed25519.SeedSize {
 		err = errors.New("Incorrect seed size")
 		return
 	}
 
+	tc.pubKeys = make([]ed25519.PublicKey, len(pubKeys)+1, len(pubKeys)+1)
 	tc.privKey = ed25519.NewKeyFromSeed(seed)
 	tc.pubKeys[len(pubKeys)] = tc.privKey.Public().(ed25519.PublicKey)
 
@@ -80,7 +112,16 @@ func NewTokenCoder(seed []byte, pubKeys ...[]byte) (tc TokenCoder, err error) {
 	return
 }
 
-func NewTokenCoderHex(seed string, pubKeys ...string) (tc TokenCoder, err error) {
+func NewTokenCoder(pubKeys ...[]byte) (tc TokenCoder, err error) {
+	seed := make([]byte, ed25519.SeedSize, ed25519.SeedSize)
+	_, err = rand.Read(seed)
+	if err != nil {
+		return
+	}
+	return NewTokenCoderWithSeed(seed, pubKeys...)
+}
+
+func NewTokenCoderHexWithSeed(seed string, pubKeys ...string) (tc TokenCoder, err error) {
 	var rawSeed []byte
 	rawPubKeys := make([][]byte, len(pubKeys), len(pubKeys))
 	rawSeed, err = hex.DecodeString(seed)
@@ -93,7 +134,18 @@ func NewTokenCoderHex(seed string, pubKeys ...string) (tc TokenCoder, err error)
 			return
 		}
 	}
-	return NewTokenCoder(rawSeed, rawPubKeys...)
+	return NewTokenCoderWithSeed(rawSeed, rawPubKeys...)
+}
+
+func NewTokenCoderHex(pubKeys ...string) (tc TokenCoder, err error) {
+	rawPubKeys := make([][]byte, len(pubKeys), len(pubKeys))
+	for pos, pubKey := range pubKeys {
+		rawPubKeys[pos], err = hex.DecodeString(pubKey)
+		if err != nil {
+			return
+		}
+	}
+	return NewTokenCoder(rawPubKeys...)
 }
 
 func trim(r rune) bool {
@@ -112,11 +164,11 @@ func (tc TokenCoder) Encode(payload interface{}) (token string, err error) {
 	enc := codec.NewEncoder(buf, &handle)
 	enc.Encode(payload)
 
-	var ld linkData
-	ld.Signature = ed25519.Sign(tc.privKey, buf.Bytes())
-	ld.Payload = buf.Bytes()
+	var td tokenData
+	td.Signature = ed25519.Sign(tc.privKey, buf.Bytes())
+	td.Payload = buf.Bytes()
 	buf.Reset()
-	enc.Encode(ld)
+	enc.Encode(td)
 	token = b64.EncodeToString(buf.Bytes())
 	return
 }
@@ -139,15 +191,15 @@ func (tc TokenCoder) Decode(token string, payload interface{}) (sum string, err
 	buf.Write(data)
 	dec := codec.NewDecoder(buf, &handle)
 
-	var ld linkData
-	err = dec.Decode(&ld)
+	var td tokenData
+	err = dec.Decode(&td)
 	if err != nil {
 		return
 	}
 
 	ok := false
 	for _, key := range tc.pubKeys {
-		if ed25519.Verify(key, ld.Payload, ld.Signature) {
+		if ed25519.Verify(key, td.Payload, td.Signature) {
 			ok = true
 			break
 		}
@@ -159,10 +211,10 @@ func (tc TokenCoder) Decode(token string, payload interface{}) (sum string, err
 	}
 
 	buf.Reset()
-	buf.Write(ld.Payload)
+	buf.Write(td.Payload)
 
 	hash := crc64.New(crc64.MakeTable(crc64.ISO))
-	hash.Write(ld.Payload)
+	hash.Write(td.Payload)
 
 	sum = hex.EncodeToString(hash.Sum(nil))
 	err = dec.Decode(&payload)