shorter handle representation.

drbg/seed.go

@@ -46,14 +46,13 @@ func (s *Seed) MarshalBinary() ([]byte, error) {
 	return s.value[:], nil
 }
 
-// MarshalJSON serializes the seed to JSON
-// Implements the json.Marshaller interface
-func (s *Seed) MarshalJSON() ([]byte, error) {
+// MarshalText serializes the seed to textual representation
+func (s *Seed) MarshalText() ([]byte, error) {
 	return json.Marshal(s.value)
 }
 
-// UnmarshalJSON restores the seed from a JSON representation.
-func (s *Seed) UnmarshalJSON(data []byte) error {
+// UnmarshalText restores the seed from a Text representation.
+func (s *Seed) UnmarshalText(data []byte) error {
 	if err := json.Unmarshal(data, &s.value); err != nil {
 		return err
 	}

libtalek/handle.go

@@ -3,6 +3,7 @@ package libtalek
 import (
 	"encoding/binary"
 	"errors"
+	"fmt"
 	"io"
 
 	"github.com/agl/ed25519"
@@ -184,3 +185,41 @@ func (h *Handle) retrieveResponse(args *common.ReadArgs, reply *common.ReadReply
 	}
 	return nil
 }
+
+// MarshalText is a compact textual representation of a handle
+func (h *Handle) MarshalText() ([]byte, error) {
+	s1, err := h.Seed1.MarshalBinary()
+	if err != nil {
+		return nil, err
+	}
+	s2, err := h.Seed2.MarshalBinary()
+	if err != nil {
+		return nil, err
+	}
+	txt := fmt.Sprintf("%x.%x.%x.%x.%d", s1, s2, *h.SharedSecret, *h.SigningPublicKey, h.Seqno)
+	return []byte(txt), nil
+}
+
+// UnmarshalText restores a handle from its compact textual representation
+func (h *Handle) UnmarshalText(text []byte) error {
+	var s1, s2, ss, pk []byte
+	if n, err := fmt.Sscanf(string(text), "%x.%x.%x.%x.%d", &s1, &s2, &ss, &pk, &h.Seqno); n < 4 || err != nil {
+		if err != nil {
+			return err
+		}
+		return errors.New("invalid handle")
+	}
+	h.SharedSecret = new([32]byte)
+	copy(h.SharedSecret[:], ss)
+	h.SigningPublicKey = new([32]byte)
+	copy(h.SigningPublicKey[:], pk)
+	h.Seed1 = &drbg.Seed{}
+	h.Seed2 = &drbg.Seed{}
+	if err := h.Seed1.UnmarshalBinary(s1); err != nil {
+		return err
+	}
+	if err := h.Seed2.UnmarshalBinary(s2); err != nil {
+		return err
+	}
+	return nil
+}

libtalek/handle_test.go

@@ -1,6 +1,7 @@
 package libtalek
 
 import (
+	"bytes"
 	"crypto/rand"
 	"fmt"
 	"testing"
@@ -39,6 +40,26 @@ func TestGeneratePoll(t *testing.T) {
 	fmt.Printf("... done \n")
 }
 
+func TestSerialization(t *testing.T) {
+	topic, _ := NewTopic()
+	h := topic.Handle
+
+	txt, err := h.MarshalText()
+	if err != nil {
+		t.Fatalf("Error serializing: %v\n", err)
+	}
+	fmt.Printf("Serialized handle looks like %s\n", txt)
+
+	h2, _ := NewHandle()
+	err = h2.UnmarshalText(txt)
+	if err != nil {
+		t.Fatalf("Could not deserialize: %v\n", err)
+	}
+	if !bytes.Equal(h.SharedSecret[:], h2.SharedSecret[:]) {
+		t.Fatalf("serialization log info!")
+	}
+}
+
 func BenchmarkGeneratePollN10K(b *testing.B) {
 	HelperBenchmarkGeneratePoll(b, 10000/4)
 }

libtalek/topic.go

@@ -1,8 +1,10 @@
 package libtalek
 
 import (
+	"bytes"
 	"crypto/rand"
 	"encoding/binary"
+	"fmt"
 
 	"github.com/agl/ed25519"
 	"github.com/privacylab/talek/common"
@@ -111,3 +113,21 @@ func (t *Topic) encrypt(plaintext []byte, nonce *[24]byte) ([]byte, error) {
 	digest := ed25519.Sign(t.SigningPrivateKey, buf)
 	return append(buf, digest[:]...), nil
 }
+
+// MarshalText is a compact textual representation of a topic
+func (t *Topic) MarshalText() ([]byte, error) {
+	handle, err := t.Handle.MarshalText()
+	if err != nil {
+		return nil, err
+	}
+	txt := fmt.Sprintf("%x.", *t.SigningPrivateKey)
+	return append([]byte(txt), handle...), nil
+}
+
+// UnmarshalText restores a topic from its compact textual representation
+func (t *Topic) UnmarshalText(text []byte) error {
+	parts := bytes.SplitN(text, []byte("."), 1)
+	t.SigningPrivateKey = new([64]byte)
+	copy(t.SigningPrivateKey[:], parts[0])
+	return t.Handle.UnmarshalText(parts[1])
+}