go.mod

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

go.sum

@@ -1,4 +1,4 @@
-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=
+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=

sign.go

@@ -7,6 +7,7 @@ import (
 	"encoding/base64"
 	"encoding/hex"
 	"errors"
+	"fmt"
 	"github.com/ugorji/go/codec"
 	"hash/crc64"
 	"strings"
@@ -16,16 +17,11 @@ const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789
 
 var b64 = base64.NewEncoding(alphabet).WithPadding(base64.NoPadding)
 
-type tokenData struct {
+type linkData 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
@@ -55,49 +51,21 @@ func (tc TokenCoder) SeedHex() string {
 	return hex.EncodeToString(tc.Seed())
 }
 
-func Format(token string) (txt string, err error) {
-	var tp tokenPrint
-	var data []byte
-	data, err = b64.DecodeString(strings.TrimFunc(token, trim))
+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
 		}
-
-	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)
 
@@ -112,16 +80,7 @@ func NewTokenCoderWithSeed(seed []byte, pubKeys ...[]byte) (tc TokenCoder, err e
 	return
 }
 
-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) {
+func NewTokenCoderHex(seed string, pubKeys ...string) (tc TokenCoder, err error) {
 	var rawSeed []byte
 	rawPubKeys := make([][]byte, len(pubKeys), len(pubKeys))
 	rawSeed, err = hex.DecodeString(seed)
@@ -134,18 +93,7 @@ func NewTokenCoderHexWithSeed(seed string, pubKeys ...string) (tc TokenCoder, er
 			return
 		}
 	}
-	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...)
+	return NewTokenCoder(rawSeed, rawPubKeys...)
 }
 
 func trim(r rune) bool {
@@ -164,11 +112,11 @@ func (tc TokenCoder) Encode(payload interface{}) (token string, err error) {
 	enc := codec.NewEncoder(buf, &handle)
 	enc.Encode(payload)
 
-	var td tokenData
-	td.Signature = ed25519.Sign(tc.privKey, buf.Bytes())
-	td.Payload = buf.Bytes()
+	var ld linkData
+	ld.Signature = ed25519.Sign(tc.privKey, buf.Bytes())
+	ld.Payload = buf.Bytes()
 	buf.Reset()
-	enc.Encode(td)
+	enc.Encode(ld)
 	token = b64.EncodeToString(buf.Bytes())
 	return
 }
@@ -191,15 +139,15 @@ func (tc TokenCoder) Decode(token string, payload interface{}) (sum string, err
 	buf.Write(data)
 	dec := codec.NewDecoder(buf, &handle)
 
-	var td tokenData
-	err = dec.Decode(&td)
+	var ld linkData
+	err = dec.Decode(&ld)
 	if err != nil {
 		return
 	}
 
 	ok := false
 	for _, key := range tc.pubKeys {
-		if ed25519.Verify(key, td.Payload, td.Signature) {
+		if ed25519.Verify(key, ld.Payload, ld.Signature) {
 			ok = true
 			break
 		}
@@ -211,10 +159,10 @@ func (tc TokenCoder) Decode(token string, payload interface{}) (sum string, err
 	}
 
 	buf.Reset()
-	buf.Write(td.Payload)
+	buf.Write(ld.Payload)
 
 	hash := crc64.New(crc64.MakeTable(crc64.ISO))
-	hash.Write(td.Payload)
+	hash.Write(ld.Payload)
 
 	sum = hex.EncodeToString(hash.Sum(nil))
 	err = dec.Decode(&payload)