MM-10516: Added support for PostActions in ephemeral posts (#10258)

* Added support for PostActions in ephemeral posts The general approach is that we take all the metadata that DoPostAction needs to process client DoPostActionRequests, and store it in a serialized, encrypted Cookie field, in the PostAction struct. The client then must send it back, and it is then used to process PostActions as a fallback top the metadata in the database. This PR adds a new config setting, `ServiceSettings.ActionCookieSecret`. In a cluster environment it must be the same for all instances. - Added type PostActionCookie, and a Cookie string to PostAction. - Added App.AddActionCookiesToPost. - Use App.AddActionCookiesToPost in api4.createEphemeralPost, App.SendEphemeralPost, App.UpdateEphemeralPost. - Added App.DoPostActionWithCookie to process incoming requests with cookies. For backward compatibility, it prefers the metadata in the database; falls back to cookie. - Added plugin.API.UpdateEphemeralPost and plugin.API.DeleteEphemeralPost. - Added App.encryptActionCookie/App.decryptActionCookie. * Style * Fixed an unfortunate typo, tested with matterpoll * minor PR feedback * Fixed uninitialized Context * Fixed another test failure * Fixed permission check * Added api test for DoPostActionWithCookie * Replaced config.ActionCookieSecret with Server.PostActionCookieSecret Modeled after AsymetricSigningKey * style * Set DeleteAt in DeleteEphemeralPost * PR feedback * Removed deadwood comment * Added EXPERIMENTAL comment to the 2 APIs in question
2019-03-01 10:15:31 -08:00
--- a/model/client4.go
+++ b/model/client4.go
@@ -2333,6 +2333,23 @@ func (c *Client4) DoPostAction(postId, actionId string) (bool, *Response) {
 	return CheckStatusOK(r), BuildResponse(r)
 }

+// DoPostActionWithCookie performs a post action with extra arguments
+func (c *Client4) DoPostActionWithCookie(postId, actionId, selected, cookieStr string) (bool, *Response) {
+	var body []byte
+	if selected != "" || cookieStr != "" {
+		body, _ = json.Marshal(DoPostActionRequest{
+			SelectedOption: selected,
+			Cookie:         cookieStr,
+		})
+	}
+	r, err := c.DoApiPost(c.GetPostRoute(postId)+"/actions/"+actionId, string(body))
+	if err != nil {
+		return false, BuildErrorResponse(r, err)
+	}
+	defer closeBody(r)
+	return CheckStatusOK(r), BuildResponse(r)
+}
+
 // OpenInteractiveDialog sends a WebSocket event to a user's clients to
 // open interactive dialogs, based on the provided trigger ID and other
 // provided data. Used with interactive message buttons, menus and
--- a/model/integration_action.go
+++ b/model/integration_action.go
@@ -5,11 +5,14 @@ package model

 import (
 	"crypto"
+	"crypto/aes"
+	"crypto/cipher"
 	"crypto/ecdsa"
 	"crypto/rand"
 	"encoding/asn1"
 	"encoding/base64"
 	"encoding/json"
+	"fmt"
 	"io"
 	"math/big"
 	"net/http"
@@ -24,16 +27,49 @@ const (
 )

 type DoPostActionRequest struct {
-	SelectedOption string `json:"selected_option"`
+	SelectedOption string `json:"selected_option,omitempty"`
+	Cookie         string `json:"cookie,omitempty"`
 }

 type PostAction struct {
-	Id          string                 `json:"id"`
-	Name        string                 `json:"name"`
-	Type        string                 `json:"type"`
-	DataSource  string                 `json:"data_source"`
-	Options     []*PostActionOptions   `json:"options"`
+	// A unique Action ID. If not set, generated automatically.
+	Id string `json:"id,omitempty"`
+
+	// The type of the interactive element. Currently supported are
+	// "select" and "button".
+	Type string `json:"type,omitempty"`
+
+	// The text on the button, or in the select placeholder.
+	Name string `json:"name,omitempty"`
+
+	// DataSource indicates the data source for the select action. If left
+	// empty, the select is populated from Options. Other supported values
+	// are "users" and "channels".
+	DataSource string               `json:"data_source,omitempty"`
+	Options    []*PostActionOptions `json:"options,omitempty"`
+
+	// Defines the interaction with the backend upon a user action.
+	// Integration contains Context, which is private plugin data;
+	// Integrations are stripped from Posts when they are sent to the
+	// client, or are encrypted in a Cookie.
 	Integration *PostActionIntegration `json:"integration,omitempty"`
+	Cookie      string                 `json:"cookie,omitempty" db:"-"`
+}
+
+// PostActionCookie is set by the server, serialized and encrypted into
+// PostAction.Cookie. The clients should hold on to it, and include it with
+// subsequent DoPostAction requests.  This allows the server to access the
+// action metadata even when it's not available in the database, for ephemeral
+// posts.
+type PostActionCookie struct {
+	Type        string                 `json:"type,omitempty"`
+	PostId      string                 `json:"post_id,omitempty"`
+	RootPostId  string                 `json:"root_post_id,omitempty"`
+	ChannelId   string                 `json:"channel_id,omitempty"`
+	DataSource  string                 `json:"data_source,omitempty"`
+	Integration *PostActionIntegration `json:"integration,omitempty"`
+	RetainProps map[string]interface{} `json:"retain_props,omitempty"`
+	RemoveProps []string               `json:"remove_props,omitempty"`
 }

 type PostActionOptions struct {
@@ -287,6 +323,115 @@ func (o *Post) GenerateActionIds() {
 	}
 }

+func AddPostActionCookies(o *Post, secret []byte) *Post {
+	p := o.Clone()
+
+	// retainedProps carry over their value from the old post, including no value
+	retainPropKeys := []string{"override_username", "override_icon_url"}
+	retainProps := map[string]interface{}{}
+	removeProps := []string{}
+	for _, key := range retainPropKeys {
+		value, ok := p.Props[key]
+		if ok {
+			retainProps[key] = value
+		} else {
+			removeProps = append(removeProps, key)
+		}
+	}
+
+	attachments := p.Attachments()
+	for _, attachment := range attachments {
+		for _, action := range attachment.Actions {
+			c := &PostActionCookie{
+				Type:        action.Type,
+				ChannelId:   p.ChannelId,
+				DataSource:  action.DataSource,
+				Integration: action.Integration,
+				RetainProps: retainProps,
+				RemoveProps: removeProps,
+			}
+
+			c.PostId = p.Id
+			if p.RootId == "" {
+				c.RootPostId = p.Id
+			} else {
+				c.RootPostId = p.RootId
+			}
+
+			b, _ := json.Marshal(c)
+			action.Cookie, _ = encryptPostActionCookie(string(b), secret)
+		}
+	}
+
+	return p
+}
+
+func encryptPostActionCookie(plain string, secret []byte) (string, error) {
+	if len(secret) == 0 {
+		return plain, nil
+	}
+
+	block, err := aes.NewCipher(secret)
+	if err != nil {
+		return "", err
+	}
+
+	aesgcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", err
+	}
+
+	nonce := make([]byte, aesgcm.NonceSize())
+	_, err = io.ReadFull(rand.Reader, nonce)
+	if err != nil {
+		return "", err
+	}
+
+	sealed := aesgcm.Seal(nil, nonce, []byte(plain), nil)
+
+	combined := append(nonce, sealed...)
+	encoded := make([]byte, base64.StdEncoding.EncodedLen(len(combined)))
+	base64.StdEncoding.Encode(encoded, combined)
+
+	return string(encoded), nil
+}
+
+func DecryptPostActionCookie(encoded string, secret []byte) (string, error) {
+	if len(secret) == 0 {
+		return encoded, nil
+	}
+
+	block, err := aes.NewCipher(secret)
+	if err != nil {
+		return "", err
+	}
+
+	aesgcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", err
+	}
+
+	decoded := make([]byte, base64.StdEncoding.DecodedLen(len(encoded)))
+	n, err := base64.StdEncoding.Decode(decoded, []byte(encoded))
+	if err != nil {
+		return "", err
+	}
+	decoded = decoded[:n]
+
+	nonceSize := aesgcm.NonceSize()
+	if len(decoded) < nonceSize {
+		return "", fmt.Errorf("cookie too short")
+	}
+
+	nonce, decoded := decoded[:nonceSize], decoded[nonceSize:]
+	plain, err := aesgcm.Open(nil, nonce, decoded, nil)
+	if err != nil {
+		return "", err
+	}
+
+	return string(plain), nil
+}
+
 func DoPostActionRequestFromJson(data io.Reader) *DoPostActionRequest {
 	var o *DoPostActionRequest
 	json.NewDecoder(data).Decode(&o)
--- a/model/system.go
+++ b/model/system.go
@@ -10,13 +10,14 @@ import (
 )

 const (
-	SYSTEM_DIAGNOSTIC_ID          = "DiagnosticId"
-	SYSTEM_RAN_UNIT_TESTS         = "RanUnitTests"
-	SYSTEM_LAST_SECURITY_TIME     = "LastSecurityTime"
-	SYSTEM_ACTIVE_LICENSE_ID      = "ActiveLicenseId"
-	SYSTEM_LAST_COMPLIANCE_TIME   = "LastComplianceTime"
-	SYSTEM_ASYMMETRIC_SIGNING_KEY = "AsymmetricSigningKey"
-	SYSTEM_INSTALLATION_DATE_KEY  = "InstallationDate"
+	SYSTEM_DIAGNOSTIC_ID             = "DiagnosticId"
+	SYSTEM_RAN_UNIT_TESTS            = "RanUnitTests"
+	SYSTEM_LAST_SECURITY_TIME        = "LastSecurityTime"
+	SYSTEM_ACTIVE_LICENSE_ID         = "ActiveLicenseId"
+	SYSTEM_LAST_COMPLIANCE_TIME      = "LastComplianceTime"
+	SYSTEM_ASYMMETRIC_SIGNING_KEY    = "AsymmetricSigningKey"
+	SYSTEM_POST_ACTION_COOKIE_SECRET = "PostActionCookieSecret"
+	SYSTEM_INSTALLATION_DATE_KEY     = "InstallationDate"
 )

 type System struct {
@@ -35,6 +36,10 @@ func SystemFromJson(data io.Reader) *System {
 	return o
 }

+type SystemPostActionCookieSecret struct {
+	Secret []byte `json:"key,omitempty"`
+}
+
 type SystemAsymmetricSigningKey struct {
 	ECDSAKey *SystemECDSAKey `json:"ecdsa_key,omitempty"`
 }