示例#1
0
        private bool ProcessMessageDeleteSecret(DeviceToDeviceMessages.IMessage message)
        {
            var messageContent = (DeviceToDeviceMessages.DeleteSecret) message;

            var secret =
                _model.EntriesSharedSecrets.Query()
                    .FirstOrDefault(r => r.SecretIdentifier == messageContent.SecretIdentifier);

            if (secret == null)
                return false;

            // Mark the secret as deleted. The sync process will handle it.
            _model.EntriesSharedSecrets.Update(secret.Id, new EntrySharedSecret {ToBeDeleted = true});
            _controller.SetEntrySecretAsModified(_appServerAccountId, secret.Id);

            return true;
        }
示例#2
0
        private bool ProcessMessageNewSecretShare(DeviceToDeviceMessages.IMessage message)
        {
            var messageContents = (DeviceToDeviceMessages.NewSecret) message;

            var link = _model.Links.Query().FirstOrDefault(r => r.Identifier == messageContents.LinkIdentifier);
            if (link == null)
                return false;

            var entry =
                _model.Entries.Query()
                    .FirstOrDefault(r => r.LinkId == link.Id && r.Identifier == messageContents.EntryIdentifier);

            if (entry == null)
            {
                var entryId =
                    _model.Entries.Create(new Entry { Identifier = messageContents.EntryIdentifier, LinkId = link.Id });
                entry = _model.Entries.Query().First(r => r.Id == entryId);
            }
            
            var secretKey = messageContents.SecretIdentifier;
            var secret = messageContents.Secret;

            var existingEntryShares = 
                _model.EntriesSharedSecrets.Query()
                .Where(r => r.EntryId == entry.Id && r.SecretIdentifier == secretKey).ToList();

            foreach (var existingEntryShare in existingEntryShares)
            {
                _model.EntriesSharedSecrets.Delete(existingEntryShare.Id);
            }

            var newSecretDataId = _model.EntriesSharedSecretsData.Create(new EntrySharedSecretData
            {
                ShareType = "EncDataKey",
                Secret = secret
            });

            var newSecretId = _model.EntriesSharedSecrets.Create(new EntrySharedSecret
            {
                EntryId = entry.Id,
                SecretIdentifier = secretKey,
                EntrySecretDataId = newSecretDataId
            });

            _controller.SetEntrySecretAsModified(_appServerAccountId, newSecretId);

            return true;
        }
示例#3
0
        private bool ProcessMessageRequestEntrySecrets(
            GetMessages.ResponseParamsMessage messageItem, DeviceToDeviceMessages.IMessage message)
        {
            var messageContents = (DeviceToDeviceMessages.RequestEntrySecrets)message;
            
            var accountSettings = _model.ServerAccountSettings.Query().First();

            var entry = _model.Entries.Query().FirstOrDefault(r => r.Identifier == messageContents.EntryIdentifier);
            if (entry == null)
                return false;
            
            var linkedDeviceCryptoKeyId = accountSettings.LinkedDeviceCryptoKeyId;
            var linkedDeviceCryptoKey = _model.CryptoKeys.Query().First(r => r.Id == linkedDeviceCryptoKeyId);

            var entrySecrets = new Dictionary<string, string>();
            foreach (var secretIdentifier in messageContents.SecretIdentifiers)
            {
                var entrySecretsResult = _model.EntriesSharedSecrets.Query()
                    .FirstOrDefault(r => r.EntryId == entry.Id && r.SecretIdentifier == secretIdentifier);

                if (entrySecretsResult == null)
                    continue;

                var entrySecretData = _model.EntriesSharedSecretsData.Query().First(r => r.Id == entrySecretsResult.EntrySecretDataId);
                entrySecrets.Add(entrySecretsResult.SecretIdentifier, entrySecretData.Secret);
            }

            if (entrySecrets.Count != messageContents.SecretIdentifiers.Count)
            {
                // We don't appear to have all the requested secrets.
                return false;
            }

            var requestConfirmed = _controller.PromptSecretShareRequestSafe();

            var apiRequest = new SendLinkedDeviceMessage
            {
                //LinkIdentifier = link.Identifier,
                SecondsValidFor = 30
            };
            if (!requestConfirmed)
            {
                var deniedMessage = new DeviceToDeviceMessages.SendEntrySecrets
                {
                    OriginalMessageIdentifier = messageItem.Identifier,
                    RequestAccepted = false
                };
                apiRequest.SetMessage(deniedMessage, linkedDeviceCryptoKey.PublicKeyPem);
                apiRequest.GetResponse(GetApiClient());
                return true;
            }

            var acceptedMessage = new DeviceToDeviceMessages.SendEntrySecrets
            {
                OriginalMessageIdentifier = messageItem.Identifier,
                RequestAccepted = true,
                Secrets = entrySecrets
            };
            apiRequest.SetMessage(acceptedMessage, linkedDeviceCryptoKey.PublicKeyPem);
            apiRequest.GetResponse(GetApiClient());

            return true;
        }
示例#4
0
        private bool ProcessMessageFromDevice(
            GetMessages.ResponseParamsMessage messageItem, DeviceToDeviceMessages.Envelope deviceMessage)
        {
            switch (deviceMessage.Type)
            {
                case DeviceToDeviceMessages.Types.NewSecret:
                    return ProcessMessageNewSecretShare(deviceMessage.Message);

                case DeviceToDeviceMessages.Types.RequestEntrySecrets:
                    return ProcessMessageRequestEntrySecrets(messageItem, deviceMessage.Message);

                case DeviceToDeviceMessages.Types.DeleteSecret:
                    return ProcessMessageDeleteSecret(deviceMessage.Message);

                default:
                    return false;
            }
        }