session+rpcserver: add feature config to session type

Author: ellemouton

session/interface.go

@@ -40,6 +40,10 @@ type MacaroonRecipe struct {
 	Caveats     []macaroon.Caveat
 }
 
+// FeaturesConfig is a map from feature name to a raw byte array which stores
+// any config feature config options.
+type FeaturesConfig map[string][]byte
+
 // Session is a struct representing a long-term Terminal Connect session.
 type Session struct {
 	ID              ID
@@ -57,6 +61,7 @@ type Session struct {
 	LocalPrivateKey *btcec.PrivateKey
 	LocalPublicKey  *btcec.PublicKey
 	RemotePublicKey *btcec.PublicKey
+	FeatureConfig   *FeaturesConfig
 }
 
 // MacaroonBaker is a function type for baking a super macaroon.
@@ -65,8 +70,8 @@ type MacaroonBaker func(ctx context.Context, rootKeyID uint64,
 
 // NewSession creates a new session with the given user-defined parameters.
 func NewSession(label string, typ Type, expiry time.Time, serverAddr string,
-	devServer bool, perms []bakery.Op, caveats []macaroon.Caveat) (*Session,
-	error) {
+	devServer bool, perms []bakery.Op, caveats []macaroon.Caveat,
+	featureConfig FeaturesConfig) (*Session, error) {
 
 	_, pairingSecret, err := mailbox.NewPassphraseEntropy()
 	if err != nil {
@@ -106,6 +111,10 @@ func NewSession(label string, typ Type, expiry time.Time, serverAddr string,
 		}
 	}
 
+	if len(featureConfig) != 0 {
+		sess.FeatureConfig = &featureConfig
+	}
+
 	return sess, nil
 }
 

session/tlv.go

@@ -25,7 +25,7 @@ const (
 	typeRemotePublicKey tlv.Type = 11
 	typeMacaroonRecipe  tlv.Type = 12
 	typeCreatedAt       tlv.Type = 13
-	typeReservedNum1    tlv.Type = 14
+	typeFeaturesConfig  tlv.Type = 14
 	typeReservedNum2    tlv.Type = 15
 	typeRevokedAt       tlv.Type = 16
 
@@ -42,6 +42,9 @@ const (
 
 	typePermEntity tlv.Type = 1
 	typePermAction tlv.Type = 2
+
+	typeFeatureName   tlv.Type = 1
+	typeFeatureConfig tlv.Type = 2
 )
 
 // SerializeSession binary serializes the given session to the writer using the
@@ -111,7 +114,23 @@ func SerializeSession(w io.Writer, session *Session) error {
 
 	tlvRecords = append(
 		tlvRecords, tlv.MakePrimitiveRecord(typeCreatedAt, &createdAt),
-		tlv.MakePrimitiveRecord(typeRevokedAt, &revokedAt),
+	)
+
+	if session.FeatureConfig != nil && len(*session.FeatureConfig) != 0 {
+		tlvRecords = append(tlvRecords, tlv.MakeDynamicRecord(
+			typeFeaturesConfig, session.FeatureConfig,
+			func() uint64 {
+				return recordSize(
+					featureConfigEncoder,
+					session.FeatureConfig,
+				)
+			},
+			featureConfigEncoder, featureConfigDecoder,
+		))
+	}
+
+	tlvRecords = append(
+		tlvRecords, tlv.MakePrimitiveRecord(typeRevokedAt, &revokedAt),
 	)
 
 	tlvStream, err := tlv.NewStream(tlvRecords...)
@@ -132,6 +151,7 @@ func DeserializeSession(r io.Reader) (*Session, error) {
 		state, typ, devServer        uint8
 		expiry, createdAt, revokedAt uint64
 		macRecipe                    MacaroonRecipe
+		featureConfig                FeaturesConfig
 	)
 	tlvStream, err := tlv.NewStream(
 		tlv.MakePrimitiveRecord(typeLabel, &label),
@@ -153,6 +173,10 @@ func DeserializeSession(r io.Reader) (*Session, error) {
 			macaroonRecipeEncoder, macaroonRecipeDecoder,
 		),
 		tlv.MakePrimitiveRecord(typeCreatedAt, &createdAt),
+		tlv.MakeDynamicRecord(
+			typeFeaturesConfig, &featureConfig, nil,
+			featureConfigEncoder, featureConfigDecoder,
+		),
 		tlv.MakePrimitiveRecord(typeRevokedAt, &revokedAt),
 	)
 	if err != nil {
@@ -191,9 +215,115 @@ func DeserializeSession(r io.Reader) (*Session, error) {
 		)
 	}
 
+	if t, ok := parsedTypes[typeFeaturesConfig]; ok && t == nil {
+		session.FeatureConfig = &featureConfig
+	}
+
 	return session, nil
 }
 
+func featureConfigEncoder(w io.Writer, val interface{}, buf *[8]byte) error {
+	if v, ok := val.(*FeaturesConfig); ok {
+		for n, config := range *v {
+			name := []byte(n)
+			config := config
+
+			var permsTLVBytes bytes.Buffer
+			tlvStream, err := tlv.NewStream(
+				tlv.MakePrimitiveRecord(typeFeatureName, &name),
+				tlv.MakePrimitiveRecord(
+					typeFeatureConfig, &config,
+				),
+			)
+			if err != nil {
+				return err
+			}
+
+			err = tlvStream.Encode(&permsTLVBytes)
+			if err != nil {
+				return err
+			}
+
+			// We encode the record with a varint length followed by
+			// the _raw_ TLV bytes.
+			tlvLen := uint64(len(permsTLVBytes.Bytes()))
+			if err := tlv.WriteVarInt(w, tlvLen, buf); err != nil {
+				return err
+			}
+
+			_, err = w.Write(permsTLVBytes.Bytes())
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}
+
+	return tlv.NewTypeForEncodingErr(val, "FeaturesConfig")
+}
+
+func featureConfigDecoder(r io.Reader, val interface{}, buf *[8]byte,
+	l uint64) error {
+
+	if v, ok := val.(*FeaturesConfig); ok {
+		featureConfig := make(map[string][]byte)
+
+		// Using this information, we'll create a new limited
+		// reader that'll return an EOF once the end has been
+		// reached so the stream stops consuming bytes.
+		innerTlvReader := io.LimitedReader{
+			R: r,
+			N: int64(l),
+		}
+
+		for {
+			// Read out the varint that encodes the size of this
+			// inner TLV record.
+			blobSize, err := tlv.ReadVarInt(&innerTlvReader, buf)
+			if err == io.EOF {
+				break
+			} else if err != nil {
+				return err
+			}
+
+			innerInnerTlvReader := io.LimitedReader{
+				R: &innerTlvReader,
+				N: int64(blobSize),
+			}
+
+			var (
+				name   []byte
+				config []byte
+			)
+			tlvStream, err := tlv.NewStream(
+				tlv.MakePrimitiveRecord(
+					typeFeatureName, &name,
+				),
+				tlv.MakePrimitiveRecord(
+					typeFeatureConfig, &config,
+				),
+			)
+			if err != nil {
+				return err
+			}
+
+			err = tlvStream.Decode(&innerInnerTlvReader)
+			if err != nil {
+				return err
+			}
+
+			featureConfig[string(name)] = config
+		}
+
+		*v = featureConfig
+
+		return nil
+	}
+
+	return tlv.NewTypeForEncodingErr(val, "FeaturesConfig")
+}
+
 // macaroonRecipeEncoder is a custom TLV encoder for a MacaroonRecipe record.
 func macaroonRecipeEncoder(w io.Writer, val interface{}, buf *[8]byte) error {
 	if v, ok := val.(*MacaroonRecipe); ok {

session/tlv_test.go

@@ -51,11 +51,12 @@ var (
 // and deserialized from and to the tlv binary format successfully.
 func TestSerializeDeserializeSession(t *testing.T) {
 	tests := []struct {
-		name      string
-		sessType  Type
-		revokedAt time.Time
-		perms     []bakery.Op
-		caveats   []macaroon.Caveat
+		name          string
+		sessType      Type
+		revokedAt     time.Time
+		perms         []bakery.Op
+		caveats       []macaroon.Caveat
+		featureConfig map[string][]byte
 	}{
 		{
 			name:     "session 1",
@@ -70,6 +71,14 @@ func TestSerializeDeserializeSession(t *testing.T) {
 			perms:    perms,
 			caveats:  caveats,
 		},
+		{
+			name:     "session 3",
+			sessType: TypeMacaroonCustom,
+			featureConfig: map[string][]byte{
+				"AutoFees":      {1, 2, 3, 4},
+				"AutoSomething": {4, 3, 4, 5, 6, 6},
+			},
+		},
 	}
 
 	for _, test := range tests {
@@ -78,7 +87,7 @@ func TestSerializeDeserializeSession(t *testing.T) {
 				test.name, test.sessType,
 				time.Date(99999, 1, 1, 0, 0, 0, 0, time.UTC),
 				"foo.bar.baz:1234", true, test.perms,
-				test.caveats,
+				test.caveats, test.featureConfig,
 			)
 			require.NoError(t, err)
 

session_rpcserver.go

@@ -249,7 +249,7 @@ func (s *sessionRpcServer) AddSession(_ context.Context,
 
 	sess, err := session.NewSession(
 		req.Label, typ, expiry, req.MailboxServerAddr, req.DevServer,
-		uniquePermissions, caveats,
+		uniquePermissions, caveats, nil,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("error creating new session: %v", err)