"x/lib": Marshal IBE master

This CL adds methods to marshal and unmarshal the private
component of an IBE Master. These methods will be used by
a service that hosts an IBE master object for issuing
IBE private keys.

Change-Id: Iaee881fe24c5b01d6205b2b12be628e81641af88

Author: ankurtaly

ibe/.api

@@ -1,7 +1,9 @@
+pkg ibe, func MarshalMasterKey(Master) ([]byte, error)
 pkg ibe, func MarshalParams(Params) ([]byte, error)
 pkg ibe, func MarshalPrivateKey(PrivateKey) ([]byte, error)
 pkg ibe, func SetupBB1() (Master, error)
 pkg ibe, func SetupBB2() (Master, error)
+pkg ibe, func UnmarshalMasterKey(Params, []byte) (Master, error)
 pkg ibe, func UnmarshalParams([]byte) (Params, error)
 pkg ibe, func UnmarshalPrivateKey(Params, []byte) (PrivateKey, error)
 pkg ibe, type Master interface { Extract, Params }

ibe/bb_test.go

@@ -153,6 +153,10 @@ func testMarshaling(t *testing.T, setup SetupFunc) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	mkbytes, err := MarshalMasterKey(master)
+	if err != nil {
+		t.Fatal(err)
+	}
 	m := []byte("01234567899876543210123456789012")
 	overhead := bbParams.CiphertextOverhead()
 	var (
@@ -161,6 +165,19 @@ func testMarshaling(t *testing.T, setup SetupFunc) {
 		m1 = make([]byte, len(m))
 		m2 = make([]byte, len(m))
 	)
+	// Encrypt with the original params, decrypt with key extracted from unmarshaled
+	// master key.
+	if err := bbParams.Encrypt("alice", m, C1); err != nil {
+		t.Error(err)
+	} else if mk, err := UnmarshalMasterKey(bbParams, mkbytes); err != nil {
+		t.Error(err)
+	} else if bbSK, err := mk.Extract("alice"); err != nil {
+		t.Error(err)
+	} else if err := bbSK.Decrypt(C1, m2); err != nil {
+		t.Error(err)
+	} else if !bytes.Equal(m, m2) {
+		t.Errorf("Got %q, want %q", m, m2)
+	}
 	// Encrypt with the original params, decrypt with the unmarshaled key.
 	if err := bbParams.Encrypt("alice", m, C1); err != nil {
 		t.Error(err)
@@ -189,13 +206,19 @@ func testMarshaling(t *testing.T, setup SetupFunc) {
 	if _, err := UnmarshalPrivateKey(bbParams, skbytes[:len(skbytes)-1]); err == nil {
 		t.Errorf("UnmarshalPrivateKey succeeded on truncated input")
 	}
+	if _, err := UnmarshalMasterKey(bbParams, mkbytes[:len(mkbytes)-1]); err == nil {
+		t.Errorf("UnmarshalMasterKey succeeded on truncated input")
+	}
 	// Extension errors
 	if _, err := UnmarshalParams(append(pbytes, 0)); err == nil {
 		t.Errorf("UnmarshalParams succeeded on extended input")
 	}
 	if _, err := UnmarshalPrivateKey(bbParams, append(skbytes, 0)); err == nil {
 		t.Errorf("UnmarshalPrivateKey succeeded on extended input")
 	}
+	if _, err := UnmarshalMasterKey(bbParams, append(mkbytes, 0)); err == nil {
+		t.Errorf("UnmarshalMasterKey succeeded on extended input")
+	}
 	// Zero length (no valid header either)
 	if _, err := UnmarshalParams(nil); err == nil {
 		t.Errorf("UnmarshalParams succeeded on nil input")
@@ -209,6 +232,12 @@ func testMarshaling(t *testing.T, setup SetupFunc) {
 	if _, err := UnmarshalPrivateKey(bbParams, []byte{}); err == nil {
 		t.Errorf("UnmarshalPrivateKey succeeded on zero length input")
 	}
+	if _, err := UnmarshalMasterKey(bbParams, nil); err == nil {
+		t.Errorf("UnmarshalMasterKey succeeded on nil input")
+	}
+	if _, err := UnmarshalMasterKey(bbParams, []byte{}); err == nil {
+		t.Errorf("UnmarshalMasterKey succeeded on zero length input")
+	}
 }
 
 func TestBB1Marshaling(t *testing.T) { testMarshaling(t, SetupBB1) }

ibe/marshal.go

@@ -23,15 +23,19 @@ const (
 	// types of encoded bytes, 1 byte
 	typeBB1Params     marshaledType = 0
 	typeBB1PrivateKey               = 1
-	typeBB2Params                   = 2
-	typeBB2PrivateKey               = 3
+	typeBB1MasterKey                = 2
+	typeBB2Params                   = 3
+	typeBB2PrivateKey               = 4
+	typeBB2MasterKey                = 5
 
 	// Sizes excluding the magic number and type header.
 	headerSize                 = 3
 	marshaledBB1ParamsSize     = 2*marshaledG1Size + 2*marshaledG2Size + marshaledGTSize
 	marshaledBB1PrivateKeySize = 2 * marshaledG2Size
+	marshaledBB1MasterKeySize  = marshaledG2Size
 	marshaledBB2ParamsSize     = 2*marshaledG1Size + marshaledGTSize
 	marshaledBB2PrivateKeySize = fieldElemSize + marshaledG2Size
+	marshaledBB2MasterKeySize  = 2*fieldElemSize + marshaledG2Size
 )
 
 func writeFieldElement(elem *big.Int) []byte {
@@ -174,7 +178,7 @@ func MarshalPrivateKey(k PrivateKey) ([]byte, error) {
 		}
 		return ret, nil
 	default:
-		return nil, fmt.Errorf("MarshalPrivateKey for %T for implemented yet", k)
+		return nil, fmt.Errorf("MarshalPrivateKey for %T not implemented yet", k)
 	}
 }
 
@@ -235,3 +239,87 @@ func UnmarshalPrivateKey(params Params, data []byte) (PrivateKey, error) {
 		return nil, fmt.Errorf("unrecognized private key type (%d)", typ)
 	}
 }
+
+// MarshalMasterKey encodes the private component of m into a byte slice.
+func MarshalMasterKey(m Master) ([]byte, error) {
+	switch m := m.(type) {
+	case *bb1master:
+		ret := make([]byte, 0, headerSize+marshaledBB1MasterKeySize)
+		for _, field := range [][]byte{
+			writeHeader(typeBB1MasterKey),
+			m.g0Hat.Marshal(),
+		} {
+			ret = append(ret, field...)
+		}
+		return ret, nil
+	case *bb2master:
+		ret := make([]byte, 0, headerSize+marshaledBB2MasterKeySize)
+		for _, field := range [][]byte{
+			writeHeader(typeBB2MasterKey),
+			writeFieldElement(m.x),
+			writeFieldElement(m.y),
+			m.hHat.Marshal(),
+		} {
+			ret = append(ret, field...)
+		}
+		return ret, nil
+	default:
+		return nil, fmt.Errorf("MarshalMasterKey for %T not implemented yet", m)
+	}
+}
+
+// UnmarshalMasterKey parses an encoded Master object.
+func UnmarshalMasterKey(params Params, data []byte) (Master, error) {
+	var typ marshaledType
+	var err error
+	if typ, data, err = readHeader(data); err != nil {
+		return nil, err
+	}
+	advance := func(n int) []byte {
+		ret := data[0:n]
+		data = data[n:]
+		return ret
+	}
+	switch typ {
+	case typeBB1MasterKey:
+		if len(data) != marshaledBB1MasterKeySize {
+			return nil, fmt.Errorf("invalid size")
+		}
+		m := &bb1master{
+			g0Hat: new(bn256.G2),
+		}
+		if _, ok := m.g0Hat.Unmarshal(advance(marshaledG2Size)); !ok {
+			return nil, fmt.Errorf("failed to unmarshal g0Hat")
+		}
+		p, ok := params.(*bb1params)
+		if !ok {
+			return nil, fmt.Errorf("params type %T incompatible with %T", params, m)
+		}
+		m.params = new(bb1params)
+		*(m.params) = *p
+		return m, nil
+	case typeBB2MasterKey:
+		if len(data) != marshaledBB2MasterKeySize {
+			return nil, fmt.Errorf("invalid size")
+		}
+		m := &bb2master{
+			x:    new(big.Int),
+			y:    new(big.Int),
+			hHat: new(bn256.G2),
+		}
+		m.x.SetBytes(advance(fieldElemSize))
+		m.y.SetBytes(advance(fieldElemSize))
+		if _, ok := m.hHat.Unmarshal(advance(marshaledG2Size)); !ok {
+			return nil, fmt.Errorf("failed to unmarshal hHat")
+		}
+		p, ok := params.(*bb2params)
+		if !ok {
+			return nil, fmt.Errorf("params type %T incompatible with %T", params, m)
+		}
+		m.params = new(bb2params)
+		*(m.params) = *p
+		return m, nil
+	default:
+		return nil, fmt.Errorf("unrecognized master key type (%d)", typ)
+	}
+}