2020-06-30 08:30:58 +00:00
package push_notification_client
2020-06-30 07:50:59 +00:00
import (
2020-07-07 13:55:24 +00:00
"context"
2020-06-30 07:50:59 +00:00
"crypto/aes"
"crypto/cipher"
2020-07-10 13:26:06 +00:00
"sort"
2020-07-09 16:52:26 +00:00
"bytes"
2020-06-30 07:50:59 +00:00
"crypto/ecdsa"
"crypto/rand"
2020-07-09 16:52:26 +00:00
"encoding/hex"
2020-07-06 08:54:22 +00:00
"errors"
2020-06-30 07:50:59 +00:00
"io"
2020-07-07 13:55:24 +00:00
"time"
2020-06-30 07:50:59 +00:00
2020-07-07 13:55:24 +00:00
"github.com/golang/protobuf/proto"
2020-06-30 07:50:59 +00:00
"github.com/google/uuid"
2020-07-10 13:26:06 +00:00
"github.com/status-im/status-go/eth-node/crypto"
2020-06-30 07:50:59 +00:00
"github.com/status-im/status-go/eth-node/crypto/ecies"
2020-07-06 08:54:22 +00:00
"github.com/status-im/status-go/protocol/common"
2020-06-30 07:50:59 +00:00
"github.com/status-im/status-go/protocol/protobuf"
2020-07-07 13:55:24 +00:00
"go.uber.org/zap"
2020-06-30 07:50:59 +00:00
)
2020-07-07 13:55:24 +00:00
const encryptedPayloadKeyLength = 16
2020-06-30 07:50:59 +00:00
const accessTokenKeyLength = 16
2020-07-10 13:26:06 +00:00
const staleQueryTimeInSeconds = 86400
2020-06-30 07:50:59 +00:00
type PushNotificationServer struct {
2020-07-10 07:45:40 +00:00
PublicKey * ecdsa . PublicKey
Registered bool
RegisteredAt int64
AccessToken string
2020-07-07 09:00:04 +00:00
}
type PushNotificationInfo struct {
2020-07-10 13:26:06 +00:00
AccessToken string
InstallationID string
PublicKey * ecdsa . PublicKey
ServerPublicKey * ecdsa . PublicKey
RetrievedAt int64
2020-06-30 07:50:59 +00:00
}
2020-06-30 08:30:58 +00:00
type Config struct {
2020-06-30 07:50:59 +00:00
// Identity is our identity key
Identity * ecdsa . PrivateKey
// SendEnabled indicates whether we should be sending push notifications
SendEnabled bool
// RemoteNotificationsEnabled is whether we should register with a remote server for push notifications
RemoteNotificationsEnabled bool
// AllowOnlyFromContacts indicates whether we should be receiving push notifications
// only from contacts
AllowOnlyFromContacts bool
// PushNotificationServers is an array of push notification servers we want to register with
PushNotificationServers [ ] * PushNotificationServer
// InstallationID is the installation-id for this device
InstallationID string
2020-07-07 13:55:24 +00:00
Logger * zap . Logger
// TokenType is the type of token
TokenType protobuf . PushNotificationRegistration_TokenType
2020-06-30 07:50:59 +00:00
}
2020-06-30 08:30:58 +00:00
type Client struct {
persistence * Persistence
2020-07-06 08:54:22 +00:00
quit chan struct { }
2020-06-30 08:30:58 +00:00
config * Config
2020-06-30 07:50:59 +00:00
2020-07-01 08:37:54 +00:00
// lastPushNotificationVersion is the latest known push notification version
lastPushNotificationVersion uint64
2020-06-30 07:50:59 +00:00
// AccessToken is the access token that is currently being used
AccessToken string
// DeviceToken is the device token for this device
DeviceToken string
// randomReader only used for testing so we have deterministic encryption
reader io . Reader
2020-07-06 08:54:22 +00:00
//messageProcessor is a message processor used to send and being notified of messages
messageProcessor * common . MessageProcessor
}
2020-07-07 13:55:24 +00:00
func New ( persistence * Persistence , config * Config , processor * common . MessageProcessor ) * Client {
2020-07-06 08:54:22 +00:00
return & Client {
2020-07-10 13:26:06 +00:00
quit : make ( chan struct { } ) ,
config : config ,
messageProcessor : processor ,
persistence : persistence ,
reader : rand . Reader }
2020-07-06 08:54:22 +00:00
}
func ( c * Client ) Start ( ) error {
if c . messageProcessor == nil {
return errors . New ( "can't start, missing message processor" )
}
go func ( ) {
subscription := c . messageProcessor . Subscribe ( )
for {
select {
case m := <- subscription :
if err := c . HandleMessageSent ( m ) ; err != nil {
2020-07-10 13:26:06 +00:00
c . config . Logger . Error ( "failed to handle message" , zap . Error ( err ) )
2020-07-06 08:54:22 +00:00
}
case <- c . quit :
return
}
}
} ( )
return nil
2020-06-30 07:50:59 +00:00
}
2020-07-06 08:54:22 +00:00
func ( c * Client ) Stop ( ) error {
close ( c . quit )
return nil
2020-06-30 07:50:59 +00:00
}
2020-07-10 13:26:06 +00:00
type notificationSendingSpec struct {
serverPublicKey * ecdsa . PublicKey
installationID string
messageID [ ] byte
2020-06-30 07:50:59 +00:00
}
2020-07-10 13:26:06 +00:00
// The message has been sent
// We should:
// 1) Check whether we should notify on anything
// 2) Refresh info if necessaary
// 3) Sent push notifications
func ( c * Client ) HandleMessageSent ( sentMessage * common . SentMessage ) error {
if ! c . config . SendEnabled {
return nil
}
publicKey := sentMessage . PublicKey
var installationIDs [ ] string
var notificationSpecs [ ] * notificationSendingSpec
//Find if there's any actionable message
for _ , messageID := range sentMessage . MessageIDs {
for _ , installation := range sentMessage . Spec . Installations {
installationID := installation . ID
shouldNotify , err := c . shouldNotifyOn ( publicKey , installationID , messageID )
if err != nil {
return err
}
if shouldNotify {
notificationSpecs = append ( notificationSpecs , & notificationSendingSpec {
installationID : installationID ,
messageID : messageID ,
} )
installationIDs = append ( installationIDs , installation . ID )
}
}
}
// Is there anything we should be notifying on?
if len ( installationIDs ) == 0 {
return nil
}
// Check if we queried recently
queriedAt , err := c . persistence . GetQueriedAt ( publicKey )
if err != nil {
return err
}
// Naively query again if too much time has passed.
// Here it might not be necessary
if time . Now ( ) . Unix ( ) - queriedAt > staleQueryTimeInSeconds {
err := c . QueryPushNotificationInfo ( publicKey )
if err != nil {
return err
}
// This is just horrible, but for now will do,
// the issue is that we don't really know how long it will
// take to reply, as there might be multiple servers
// replying to us.
// The only time we are 100% certain that we can proceed is
// when we have non-stale info for each device, but
// most devices are not going to be registered, so we'd still
// have to wait teh maximum amount of time allowed.
time . Sleep ( 3 * time . Second )
}
// Retrieve infos
info , err := c . GetPushNotificationInfo ( publicKey , installationIDs )
if err != nil {
return err
}
// Naively dispatch to the first server for now
// This wait for an acknowledgement and try a different server after a timeout
// Also we sent a single notification for multiple message ids, need to check with UI what's the desired behavior
// Sort by server so we tend to hit the same one
sort . Slice ( info , func ( i , j int ) bool {
return info [ i ] . ServerPublicKey . X . Cmp ( info [ j ] . ServerPublicKey . X ) <= 0
} )
installationIDsMap := make ( map [ string ] bool )
// One info per installation id, grouped by server
actionableInfos := make ( map [ string ] [ ] * PushNotificationInfo )
for _ , i := range info {
if ! installationIDsMap [ i . InstallationID ] {
serverKey := hex . EncodeToString ( crypto . CompressPubkey ( i . ServerPublicKey ) )
actionableInfos [ serverKey ] = append ( actionableInfos [ serverKey ] , i )
installationIDsMap [ i . InstallationID ] = true
}
}
for _ , infos := range actionableInfos {
var pushNotifications [ ] * protobuf . PushNotification
for _ , i := range infos {
// TODO: Add ChatID, message, public_key
pushNotifications = append ( pushNotifications , & protobuf . PushNotification {
AccessToken : i . AccessToken ,
PublicKey : common . HashPublicKey ( publicKey ) ,
InstallationId : i . InstallationID ,
} )
}
request := & protobuf . PushNotificationRequest {
MessageId : sentMessage . MessageIDs [ 0 ] ,
Requests : pushNotifications ,
}
serverPublicKey := infos [ 0 ] . ServerPublicKey
payload , err := proto . Marshal ( request )
if err != nil {
return err
}
rawMessage := & common . RawMessage {
Payload : payload ,
MessageType : protobuf . ApplicationMetadataMessage_PUSH_NOTIFICATION_REQUEST ,
}
// TODO: We should use the messageID for the response
_ , err = c . messageProcessor . SendPrivate ( context . Background ( ) , serverPublicKey , rawMessage )
if err != nil {
return err
}
}
2020-06-30 07:50:59 +00:00
return nil
}
2020-07-10 13:26:06 +00:00
// NotifyOnMessageID keeps track of the message to make sure we notify on it
func ( c * Client ) NotifyOnMessageID ( chatID string , messageID [ ] byte ) error {
return c . persistence . TrackPushNotification ( chatID , messageID )
}
func ( c * Client ) shouldNotifyOn ( publicKey * ecdsa . PublicKey , installationID string , messageID [ ] byte ) ( bool , error ) {
return c . persistence . ShouldSentNotificationFor ( publicKey , installationID , messageID )
2020-06-30 07:50:59 +00:00
}
2020-07-10 13:26:06 +00:00
func ( c * Client ) notifiedOn ( publicKey * ecdsa . PublicKey , installationID string , messageID [ ] byte ) error {
return c . persistence . NotifiedOn ( publicKey , installationID , messageID )
}
2020-07-07 09:00:04 +00:00
func ( p * Client ) mutedChatIDsHashes ( chatIDs [ ] string ) [ ] [ ] byte {
2020-06-30 07:50:59 +00:00
var mutedChatListHashes [ ] [ ] byte
2020-07-07 09:00:04 +00:00
for _ , chatID := range chatIDs {
2020-07-07 13:55:24 +00:00
mutedChatListHashes = append ( mutedChatListHashes , common . Shake256 ( [ ] byte ( chatID ) ) )
2020-06-30 07:50:59 +00:00
}
return mutedChatListHashes
}
2020-07-01 08:37:54 +00:00
func ( p * Client ) encryptToken ( publicKey * ecdsa . PublicKey , token [ ] byte ) ( [ ] byte , error ) {
2020-06-30 07:50:59 +00:00
sharedKey , err := ecies . ImportECDSA ( p . config . Identity ) . GenerateShared (
ecies . ImportECDSAPublic ( publicKey ) ,
accessTokenKeyLength ,
accessTokenKeyLength ,
)
if err != nil {
return nil , err
}
encryptedToken , err := encryptAccessToken ( token , sharedKey , p . reader )
if err != nil {
return nil , err
}
2020-07-01 08:37:54 +00:00
return encryptedToken , nil
2020-06-30 07:50:59 +00:00
}
2020-07-07 09:00:04 +00:00
func ( p * Client ) allowedUserList ( token [ ] byte , contactIDs [ ] * ecdsa . PublicKey ) ( [ ] [ ] byte , error ) {
2020-07-01 08:37:54 +00:00
var encryptedTokens [ ] [ ] byte
2020-07-07 09:00:04 +00:00
for _ , publicKey := range contactIDs {
2020-07-01 08:37:54 +00:00
encryptedToken , err := p . encryptToken ( publicKey , token )
2020-06-30 07:50:59 +00:00
if err != nil {
return nil , err
}
2020-07-01 08:37:54 +00:00
encryptedTokens = append ( encryptedTokens , encryptedToken )
2020-06-30 07:50:59 +00:00
}
2020-07-01 08:37:54 +00:00
return encryptedTokens , nil
2020-06-30 07:50:59 +00:00
}
2020-07-07 09:00:04 +00:00
func ( p * Client ) buildPushNotificationRegistrationMessage ( contactIDs [ ] * ecdsa . PublicKey , mutedChatIDs [ ] string ) ( * protobuf . PushNotificationRegistration , error ) {
2020-07-01 08:37:54 +00:00
token := uuid . New ( ) . String ( )
2020-07-07 09:00:04 +00:00
allowedUserList , err := p . allowedUserList ( [ ] byte ( token ) , contactIDs )
2020-06-30 07:50:59 +00:00
if err != nil {
return nil , err
}
2020-07-02 08:08:19 +00:00
options := & protobuf . PushNotificationRegistration {
2020-07-01 08:37:54 +00:00
AccessToken : token ,
2020-07-07 13:55:24 +00:00
TokenType : p . config . TokenType ,
2020-07-01 08:37:54 +00:00
Version : p . lastPushNotificationVersion + 1 ,
2020-06-30 07:50:59 +00:00
InstallationId : p . config . InstallationID ,
Token : p . DeviceToken ,
Enabled : p . config . RemoteNotificationsEnabled ,
2020-07-07 09:00:04 +00:00
BlockedChatList : p . mutedChatIDsHashes ( mutedChatIDs ) ,
2020-06-30 07:50:59 +00:00
AllowedUserList : allowedUserList ,
}
return options , nil
}
2020-07-10 07:45:40 +00:00
func ( c * Client ) Register ( deviceToken string , contactIDs [ ] * ecdsa . PublicKey , mutedChatIDs [ ] string ) ( [ ] * PushNotificationServer , error ) {
2020-07-07 13:55:24 +00:00
c . DeviceToken = deviceToken
servers , err := c . persistence . GetServers ( )
2020-07-07 09:00:04 +00:00
if err != nil {
2020-07-09 16:52:26 +00:00
return nil , err
2020-07-07 09:00:04 +00:00
}
2020-07-07 13:55:24 +00:00
2020-07-07 09:00:04 +00:00
if len ( servers ) == 0 {
2020-07-09 16:52:26 +00:00
return nil , errors . New ( "no servers to register with" )
2020-07-07 09:00:04 +00:00
}
2020-07-07 13:55:24 +00:00
registration , err := c . buildPushNotificationRegistrationMessage ( contactIDs , mutedChatIDs )
if err != nil {
2020-07-09 16:52:26 +00:00
return nil , err
2020-07-07 13:55:24 +00:00
}
2020-07-10 07:45:40 +00:00
var serverPublicKeys [ ] * ecdsa . PublicKey
2020-07-07 13:55:24 +00:00
for _ , server := range servers {
2020-07-10 07:45:40 +00:00
// Reset server registration data
server . Registered = false
server . RegisteredAt = 0
server . AccessToken = registration . AccessToken
serverPublicKeys = append ( serverPublicKeys , server . PublicKey )
if err := c . persistence . UpsertServer ( server ) ; err != nil {
return nil , err
}
2020-07-13 08:53:13 +00:00
grant , err := c . buildGrantSignature ( server . PublicKey , registration . AccessToken )
if err != nil {
c . config . Logger . Error ( "failed to build grant" , zap . Error ( err ) )
return nil , err
}
c . config . Logger . Info ( "GRANT2" , zap . Binary ( "GRANT" , grant ) )
registration . Grant = grant
marshaledRegistration , err := proto . Marshal ( registration )
if err != nil {
return nil , err
}
2020-07-10 07:45:40 +00:00
// Dispatch message
encryptedRegistration , err := c . encryptRegistration ( server . PublicKey , marshaledRegistration )
2020-07-07 13:55:24 +00:00
if err != nil {
2020-07-09 16:52:26 +00:00
return nil , err
2020-07-07 13:55:24 +00:00
}
rawMessage := & common . RawMessage {
Payload : encryptedRegistration ,
MessageType : protobuf . ApplicationMetadataMessage_PUSH_NOTIFICATION_REGISTRATION ,
}
2020-07-10 07:45:40 +00:00
_ , err = c . messageProcessor . SendPrivate ( context . Background ( ) , server . PublicKey , rawMessage )
2020-07-07 13:55:24 +00:00
2020-07-10 07:45:40 +00:00
if err != nil {
return nil , err
}
2020-07-07 13:55:24 +00:00
}
2020-07-10 07:45:40 +00:00
ctx , cancel := context . WithTimeout ( context . Background ( ) , 5 * time . Second )
// This code polls the database for server registrations, giving up
// after 5 seconds
2020-07-07 13:55:24 +00:00
for {
select {
case <- c . quit :
2020-07-10 07:45:40 +00:00
return servers , nil
case <- ctx . Done ( ) :
c . config . Logger . Debug ( "Context done" )
return servers , nil
case <- time . After ( 200 * time . Millisecond ) :
servers , err = c . persistence . GetServersByPublicKey ( serverPublicKeys )
if err != nil {
return nil , err
}
allRegistered := true
for _ , server := range servers {
allRegistered = allRegistered && server . Registered
}
// If any of the servers we haven't registered yet, continue
if ! allRegistered {
continue
}
// all have registered,cancel context and return
cancel ( )
return servers , nil
2020-07-07 13:55:24 +00:00
}
}
2020-06-30 07:50:59 +00:00
}
// HandlePushNotificationRegistrationResponse should check whether the response was successful or not, retry if necessary otherwise store the result in the database
2020-07-10 07:45:40 +00:00
func ( c * Client ) HandlePushNotificationRegistrationResponse ( publicKey * ecdsa . PublicKey , response protobuf . PushNotificationRegistrationResponse ) error {
2020-07-09 16:52:26 +00:00
c . config . Logger . Debug ( "received push notification registration response" , zap . Any ( "response" , response ) )
2020-07-10 07:45:40 +00:00
// TODO: handle non successful response and match request id
// Not successful ignore for now
if ! response . Success {
return errors . New ( "response was not successful" )
2020-07-09 16:52:26 +00:00
}
2020-07-10 07:45:40 +00:00
servers , err := c . persistence . GetServersByPublicKey ( [ ] * ecdsa . PublicKey { publicKey } )
if err != nil {
return err
}
// We haven't registered with this server
if len ( servers ) != 1 {
return errors . New ( "not registered with this server, ignoring" )
}
server := servers [ 0 ]
server . Registered = true
server . RegisteredAt = time . Now ( ) . Unix ( )
return c . persistence . UpsertServer ( server )
2020-06-30 07:50:59 +00:00
}
// HandlePushNotificationAdvertisement should store any info related to push notifications
2020-06-30 08:30:58 +00:00
func ( p * Client ) HandlePushNotificationAdvertisement ( info * protobuf . PushNotificationAdvertisementInfo ) error {
2020-06-30 07:50:59 +00:00
return nil
}
2020-07-13 08:53:13 +00:00
// buildGrantSignatureMaterial builds a grant for a specific server.
// We use 3 components:
// 1) The client public key. Not sure this applies to our signature scheme, but best to be conservative. https://crypto.stackexchange.com/questions/15538/given-a-message-and-signature-find-a-public-key-that-makes-the-signature-valid
// 2) The server public key
// 3) The access token
// By verifying this signature, a client can trust the server was instructed to store this access token.
func ( c * Client ) buildGrantSignatureMaterial ( clientPublicKey * ecdsa . PublicKey , serverPublicKey * ecdsa . PublicKey , accessToken string ) [ ] byte {
var signatureMaterial [ ] byte
signatureMaterial = append ( signatureMaterial , crypto . CompressPubkey ( clientPublicKey ) ... )
signatureMaterial = append ( signatureMaterial , crypto . CompressPubkey ( serverPublicKey ) ... )
signatureMaterial = append ( signatureMaterial , [ ] byte ( accessToken ) ... )
return crypto . Keccak256 ( signatureMaterial )
}
func ( c * Client ) buildGrantSignature ( serverPublicKey * ecdsa . PublicKey , accessToken string ) ( [ ] byte , error ) {
signatureMaterial := c . buildGrantSignatureMaterial ( & c . config . Identity . PublicKey , serverPublicKey , accessToken )
return crypto . Sign ( signatureMaterial , c . config . Identity )
}
func ( c * Client ) handleGrant ( clientPublicKey * ecdsa . PublicKey , serverPublicKey * ecdsa . PublicKey , grant [ ] byte , accessToken string ) error {
signatureMaterial := c . buildGrantSignatureMaterial ( clientPublicKey , serverPublicKey , accessToken )
c . config . Logger . Info ( "GRANT" , zap . Binary ( "GRANT" , grant ) )
extractedPublicKey , err := crypto . SigToPub ( signatureMaterial , grant )
if err != nil {
return err
}
if ! common . IsPubKeyEqual ( clientPublicKey , extractedPublicKey ) {
return errors . New ( "invalid grant" )
}
return nil
}
2020-06-30 07:50:59 +00:00
// HandlePushNotificationQueryResponse should update the data in the database for a given user
2020-07-10 13:26:06 +00:00
func ( c * Client ) HandlePushNotificationQueryResponse ( serverPublicKey * ecdsa . PublicKey , response protobuf . PushNotificationQueryResponse ) error {
2020-07-07 13:55:24 +00:00
c . config . Logger . Debug ( "received push notification query response" , zap . Any ( "response" , response ) )
2020-07-10 13:26:06 +00:00
if len ( response . Info ) == 0 {
return errors . New ( "empty response from the server" )
}
publicKey , err := c . persistence . GetQueryPublicKey ( response . MessageId )
if err != nil {
return err
}
if publicKey == nil {
c . config . Logger . Debug ( "query not found" )
return nil
}
var pushNotificationInfo [ ] * PushNotificationInfo
for _ , info := range response . Info {
if bytes . Compare ( info . PublicKey , common . HashPublicKey ( publicKey ) ) != 0 {
c . config . Logger . Warn ( "reply for different key, ignoring" )
continue
}
2020-07-13 08:53:13 +00:00
// We check the user has allowed this server to store this particular
// access token, otherwise anyone could reply with a fake token
// and receive notifications for a user
if err := c . handleGrant ( publicKey , serverPublicKey , info . Grant , info . AccessToken ) ; err != nil {
c . config . Logger . Warn ( "grant verification failed, ignoring" , zap . Error ( err ) )
continue
}
2020-07-10 13:26:06 +00:00
pushNotificationInfo = append ( pushNotificationInfo , & PushNotificationInfo {
PublicKey : publicKey ,
ServerPublicKey : serverPublicKey ,
AccessToken : info . AccessToken ,
InstallationID : info . InstallationId ,
RetrievedAt : time . Now ( ) . Unix ( ) ,
} )
}
err = c . persistence . SavePushNotificationInfo ( pushNotificationInfo )
if err != nil {
c . config . Logger . Error ( "failed to save push notifications" , zap . Error ( err ) )
return err
2020-07-07 13:55:24 +00:00
}
2020-07-10 13:26:06 +00:00
2020-06-30 07:50:59 +00:00
return nil
}
2020-07-03 08:26:35 +00:00
// HandlePushNotificationResponse should set the request as processed
func ( p * Client ) HandlePushNotificationResponse ( ack * protobuf . PushNotificationResponse ) error {
2020-06-30 07:50:59 +00:00
return nil
}
2020-07-07 09:00:04 +00:00
func ( c * Client ) AddPushNotificationServer ( publicKey * ecdsa . PublicKey ) error {
2020-07-07 13:55:24 +00:00
c . config . Logger . Debug ( "adding push notification server" , zap . Any ( "public-key" , publicKey ) )
2020-07-07 09:00:04 +00:00
currentServers , err := c . persistence . GetServers ( )
if err != nil {
return err
}
for _ , server := range currentServers {
2020-07-10 07:45:40 +00:00
if common . IsPubKeyEqual ( server . PublicKey , publicKey ) {
2020-07-07 09:00:04 +00:00
return errors . New ( "push notification server already added" )
}
}
return c . persistence . UpsertServer ( & PushNotificationServer {
2020-07-10 07:45:40 +00:00
PublicKey : publicKey ,
2020-07-07 09:00:04 +00:00
} )
2020-06-30 07:50:59 +00:00
}
2020-07-10 13:26:06 +00:00
func ( c * Client ) QueryPushNotificationInfo ( publicKey * ecdsa . PublicKey ) error {
2020-07-09 16:52:26 +00:00
hashedPublicKey := common . HashPublicKey ( publicKey )
query := & protobuf . PushNotificationQuery {
PublicKeys : [ ] [ ] byte { hashedPublicKey } ,
}
encodedMessage , err := proto . Marshal ( query )
if err != nil {
2020-07-10 13:26:06 +00:00
return err
2020-07-09 16:52:26 +00:00
}
rawMessage := & common . RawMessage {
Payload : encodedMessage ,
MessageType : protobuf . ApplicationMetadataMessage_PUSH_NOTIFICATION_QUERY ,
}
encodedPublicKey := hex . EncodeToString ( hashedPublicKey )
c . config . Logger . Debug ( "sending query" )
messageID , err := c . messageProcessor . SendPublic ( context . Background ( ) , encodedPublicKey , rawMessage )
2020-07-10 13:26:06 +00:00
if err != nil {
return err
}
2020-07-09 16:52:26 +00:00
2020-07-10 13:26:06 +00:00
return c . persistence . SavePushNotificationQuery ( publicKey , messageID )
}
2020-07-09 16:52:26 +00:00
2020-07-10 13:26:06 +00:00
func ( c * Client ) GetPushNotificationInfo ( publicKey * ecdsa . PublicKey , installationIDs [ ] string ) ( [ ] * PushNotificationInfo , error ) {
return c . persistence . GetPushNotificationInfo ( publicKey , installationIDs )
2020-07-09 16:52:26 +00:00
}
2020-07-07 09:00:04 +00:00
2020-07-10 13:26:06 +00:00
func ( c * Client ) listenToPublicKeyQueryTopic ( hashedPublicKey [ ] byte ) error {
2020-07-09 16:52:26 +00:00
encodedPublicKey := hex . EncodeToString ( hashedPublicKey )
2020-07-10 13:26:06 +00:00
return c . messageProcessor . JoinPublic ( encodedPublicKey )
2020-06-30 07:50:59 +00:00
}
func encryptAccessToken ( plaintext [ ] byte , key [ ] byte , reader io . Reader ) ( [ ] byte , error ) {
c , err := aes . NewCipher ( key )
if err != nil {
return nil , err
}
gcm , err := cipher . NewGCM ( c )
if err != nil {
return nil , err
}
nonce := make ( [ ] byte , gcm . NonceSize ( ) )
if _ , err = io . ReadFull ( reader , nonce ) ; err != nil {
return nil , err
}
return gcm . Seal ( nonce , nonce , plaintext , nil ) , nil
}
2020-07-07 13:55:24 +00:00
func ( c * Client ) encryptRegistration ( publicKey * ecdsa . PublicKey , payload [ ] byte ) ( [ ] byte , error ) {
sharedKey , err := c . generateSharedKey ( publicKey )
if err != nil {
return nil , err
}
return common . Encrypt ( payload , sharedKey , c . reader )
}
func ( c * Client ) generateSharedKey ( publicKey * ecdsa . PublicKey ) ( [ ] byte , error ) {
return ecies . ImportECDSA ( c . config . Identity ) . GenerateShared (
ecies . ImportECDSAPublic ( publicKey ) ,
encryptedPayloadKeyLength ,
encryptedPayloadKeyLength ,
)
2020-06-30 07:50:59 +00:00
}