Examples with VerifiedMessage org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage used on opensource projects

Example 1 with VerifiedMessage

use of org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage in project libsignal-service-java by signalapp.

the class SignalServiceCipher method createSynchronizeMessage.

private SignalServiceSyncMessage createSynchronizeMessage(SignalServiceEnvelope envelope, SyncMessage content) throws InvalidMessageException {
    if (content.hasSent()) {
        SyncMessage.Sent sentContent = content.getSent();
        return SignalServiceSyncMessage.forSentTranscript(new SentTranscriptMessage(sentContent.getDestination(), sentContent.getTimestamp(), createSignalServiceMessage(envelope, sentContent.getMessage()), sentContent.getExpirationStartTimestamp()));
    }
    if (content.hasRequest()) {
        return SignalServiceSyncMessage.forRequest(new RequestMessage(content.getRequest()));
    }
    if (content.getReadList().size() > 0) {
        List<ReadMessage> readMessages = new LinkedList<>();
        for (SyncMessage.Read read : content.getReadList()) {
            readMessages.add(new ReadMessage(read.getSender(), read.getTimestamp()));
        }
        return SignalServiceSyncMessage.forRead(readMessages);
    }
    if (content.hasVerified()) {
        try {
            Verified verified = content.getVerified();
            String destination = verified.getDestination();
            IdentityKey identityKey = new IdentityKey(verified.getIdentityKey().toByteArray(), 0);
            VerifiedState verifiedState;
            if (verified.getState() == Verified.State.DEFAULT) {
                verifiedState = VerifiedState.DEFAULT;
            } else if (verified.getState() == Verified.State.VERIFIED) {
                verifiedState = VerifiedState.VERIFIED;
            } else if (verified.getState() == Verified.State.UNVERIFIED) {
                verifiedState = VerifiedState.UNVERIFIED;
            } else {
                throw new InvalidMessageException("Unknown state: " + verified.getState().getNumber());
            }
            return SignalServiceSyncMessage.forVerified(new VerifiedMessage(destination, identityKey, verifiedState, System.currentTimeMillis()));
        } catch (InvalidKeyException e) {
            throw new InvalidMessageException(e);
        }
    }
    return SignalServiceSyncMessage.empty();
}

Example 2 with VerifiedMessage

use of org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage in project Signal-Android by signalapp.

the class MultiDeviceContactUpdateJob method generateSingleContactUpdate.

private void generateSingleContactUpdate(@NonNull Address address) throws IOException, UntrustedIdentityException, NetworkException {
    File contactDataFile = createTempFile("multidevice-contact-update");
    try {
        DeviceContactsOutputStream out = new DeviceContactsOutputStream(new FileOutputStream(contactDataFile));
        Recipient recipient = Recipient.from(context, address, false);
        Optional<IdentityDatabase.IdentityRecord> identityRecord = DatabaseFactory.getIdentityDatabase(context).getIdentity(address);
        Optional<VerifiedMessage> verifiedMessage = getVerifiedMessage(recipient, identityRecord);
        out.write(new DeviceContact(address.toPhoneString(), Optional.fromNullable(recipient.getName()), getAvatar(recipient.getContactUri()), Optional.fromNullable(recipient.getColor().serialize()), verifiedMessage, Optional.fromNullable(recipient.getProfileKey()), recipient.isBlocked(), recipient.getExpireMessages() > 0 ? Optional.of(recipient.getExpireMessages()) : Optional.absent()));
        out.close();
        sendUpdate(messageSender, contactDataFile, false);
    } catch (InvalidNumberException e) {
        Log.w(TAG, e);
    } finally {
        if (contactDataFile != null)
            contactDataFile.delete();
    }
}

Example 3 with VerifiedMessage

use of org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage in project Signal-Android by signalapp.

the class MultiDeviceContactUpdateJob method getVerifiedMessage.

private Optional<VerifiedMessage> getVerifiedMessage(Recipient recipient, Optional<IdentityDatabase.IdentityRecord> identity) throws InvalidNumberException {
    if (!identity.isPresent())
        return Optional.absent();
    String destination = recipient.getAddress().toPhoneString();
    IdentityKey identityKey = identity.get().getIdentityKey();
    VerifiedMessage.VerifiedState state;
    switch(identity.get().getVerifiedStatus()) {
        case VERIFIED:
            state = VerifiedMessage.VerifiedState.VERIFIED;
            break;
        case UNVERIFIED:
            state = VerifiedMessage.VerifiedState.UNVERIFIED;
            break;
        case DEFAULT:
            state = VerifiedMessage.VerifiedState.DEFAULT;
            break;
        default:
            throw new AssertionError("Unknown state: " + identity.get().getVerifiedStatus());
    }
    return Optional.of(new VerifiedMessage(destination, identityKey, state, System.currentTimeMillis()));
}

Example 4 with VerifiedMessage

use of org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage in project Signal-Android by WhisperSystems.

the class MultiDeviceContactUpdateJob method generateFullContactUpdate.

private void generateFullContactUpdate() throws IOException, UntrustedIdentityException, NetworkException {
    boolean isAppVisible = ApplicationDependencies.getAppForegroundObserver().isForegrounded();
    long timeSinceLastSync = System.currentTimeMillis() - TextSecurePreferences.getLastFullContactSyncTime(context);
    Log.d(TAG, "Requesting a full contact sync. forced = " + forceSync + ", appVisible = " + isAppVisible + ", timeSinceLastSync = " + timeSinceLastSync + " ms");
    if (!forceSync && !isAppVisible && timeSinceLastSync < FULL_SYNC_TIME) {
        Log.i(TAG, "App is backgrounded and the last contact sync was too soon (" + timeSinceLastSync + " ms ago). Marking that we need a sync. Skipping multi-device contact update...");
        TextSecurePreferences.setNeedsFullContactSync(context, true);
        return;
    }
    TextSecurePreferences.setLastFullContactSyncTime(context, System.currentTimeMillis());
    TextSecurePreferences.setNeedsFullContactSync(context, false);
    WriteDetails writeDetails = createTempFile();
    try {
        DeviceContactsOutputStream out = new DeviceContactsOutputStream(writeDetails.outputStream);
        List<Recipient> recipients = SignalDatabase.recipients().getRecipientsForMultiDeviceSync();
        Map<RecipientId, Integer> inboxPositions = SignalDatabase.threads().getInboxPositions();
        Set<RecipientId> archived = SignalDatabase.threads().getArchivedRecipients();
        for (Recipient recipient : recipients) {
            Optional<IdentityRecord> identity = ApplicationDependencies.getProtocolStore().aci().identities().getIdentityRecord(recipient.getId());
            Optional<VerifiedMessage> verified = getVerifiedMessage(recipient, identity);
            Optional<String> name = Optional.fromNullable(recipient.isSystemContact() ? recipient.getDisplayName(context) : recipient.getGroupName(context));
            Optional<ProfileKey> profileKey = ProfileKeyUtil.profileKeyOptional(recipient.getProfileKey());
            boolean blocked = recipient.isBlocked();
            Optional<Integer> expireTimer = recipient.getExpiresInSeconds() > 0 ? Optional.of(recipient.getExpiresInSeconds()) : Optional.absent();
            Optional<Integer> inboxPosition = Optional.fromNullable(inboxPositions.get(recipient.getId()));
            out.write(new DeviceContact(RecipientUtil.toSignalServiceAddress(context, recipient), name, getAvatar(recipient.getId(), recipient.getContactUri()), Optional.of(ChatColorsMapper.getMaterialColor(recipient.getChatColors()).serialize()), verified, profileKey, blocked, expireTimer, inboxPosition, archived.contains(recipient.getId())));
        }
        Recipient self = Recipient.self();
        byte[] profileKey = self.getProfileKey();
        if (profileKey != null) {
            out.write(new DeviceContact(RecipientUtil.toSignalServiceAddress(context, self), Optional.absent(), Optional.absent(), Optional.of(ChatColorsMapper.getMaterialColor(self.getChatColors()).serialize()), Optional.absent(), ProfileKeyUtil.profileKeyOptionalOrThrow(self.getProfileKey()), false, self.getExpiresInSeconds() > 0 ? Optional.of(self.getExpiresInSeconds()) : Optional.absent(), Optional.fromNullable(inboxPositions.get(self.getId())), archived.contains(self.getId())));
        }
        out.close();
        long length = BlobProvider.getInstance().calculateFileSize(context, writeDetails.uri);
        sendUpdate(ApplicationDependencies.getSignalServiceMessageSender(), BlobProvider.getInstance().getStream(context, writeDetails.uri), length, true);
    } catch (InvalidNumberException e) {
        Log.w(TAG, e);
    } finally {
        BlobProvider.getInstance().delete(context, writeDetails.uri);
    }
}

Example 5 with VerifiedMessage

use of org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage in project Signal-Android by WhisperSystems.

the class SignalServiceContent method createSynchronizeMessage.

private static SignalServiceSyncMessage createSynchronizeMessage(SignalServiceMetadata metadata, SignalServiceProtos.SyncMessage content) throws ProtocolInvalidKeyException, UnsupportedDataMessageException, InvalidMessageStructureException {
    if (content.hasSent()) {
        Map<SignalServiceAddress, Boolean> unidentifiedStatuses = new HashMap<>();
        SignalServiceProtos.SyncMessage.Sent sentContent = content.getSent();
        SignalServiceDataMessage dataMessage = createSignalServiceMessage(metadata, sentContent.getMessage());
        Optional<SignalServiceAddress> address = SignalServiceAddress.isValidAddress(sentContent.getDestinationUuid(), sentContent.getDestinationE164()) ? Optional.of(new SignalServiceAddress(ACI.parseOrThrow(sentContent.getDestinationUuid()), sentContent.getDestinationE164())) : Optional.<SignalServiceAddress>absent();
        if (!address.isPresent() && !dataMessage.getGroupContext().isPresent()) {
            throw new InvalidMessageStructureException("SyncMessage missing both destination and group ID!");
        }
        for (SignalServiceProtos.SyncMessage.Sent.UnidentifiedDeliveryStatus status : sentContent.getUnidentifiedStatusList()) {
            if (SignalServiceAddress.isValidAddress(status.getDestinationUuid(), status.getDestinationE164())) {
                SignalServiceAddress recipient = new SignalServiceAddress(ACI.parseOrThrow(status.getDestinationUuid()), status.getDestinationE164());
                unidentifiedStatuses.put(recipient, status.getUnidentified());
            } else {
                Log.w(TAG, "Encountered an invalid UnidentifiedDeliveryStatus in a SentTranscript! Ignoring.");
            }
        }
        return SignalServiceSyncMessage.forSentTranscript(new SentTranscriptMessage(address, sentContent.getTimestamp(), dataMessage, sentContent.getExpirationStartTimestamp(), unidentifiedStatuses, sentContent.getIsRecipientUpdate()));
    }
    if (content.hasRequest()) {
        return SignalServiceSyncMessage.forRequest(new RequestMessage(content.getRequest()));
    }
    if (content.getReadList().size() > 0) {
        List<ReadMessage> readMessages = new LinkedList<>();
        for (SignalServiceProtos.SyncMessage.Read read : content.getReadList()) {
            if (SignalServiceAddress.isValidAddress(read.getSenderUuid(), read.getSenderE164())) {
                SignalServiceAddress address = new SignalServiceAddress(ACI.parseOrThrow(read.getSenderUuid()), read.getSenderE164());
                readMessages.add(new ReadMessage(address, read.getTimestamp()));
            } else {
                Log.w(TAG, "Encountered an invalid ReadMessage! Ignoring.");
            }
        }
        return SignalServiceSyncMessage.forRead(readMessages);
    }
    if (content.getViewedList().size() > 0) {
        List<ViewedMessage> viewedMessages = new LinkedList<>();
        for (SignalServiceProtos.SyncMessage.Viewed viewed : content.getViewedList()) {
            if (SignalServiceAddress.isValidAddress(viewed.getSenderUuid(), viewed.getSenderE164())) {
                SignalServiceAddress address = new SignalServiceAddress(ACI.parseOrThrow(viewed.getSenderUuid()), viewed.getSenderE164());
                viewedMessages.add(new ViewedMessage(address, viewed.getTimestamp()));
            } else {
                Log.w(TAG, "Encountered an invalid ReadMessage! Ignoring.");
            }
        }
        return SignalServiceSyncMessage.forViewed(viewedMessages);
    }
    if (content.hasViewOnceOpen()) {
        if (SignalServiceAddress.isValidAddress(content.getViewOnceOpen().getSenderUuid(), content.getViewOnceOpen().getSenderE164())) {
            SignalServiceAddress address = new SignalServiceAddress(ACI.parseOrThrow(content.getViewOnceOpen().getSenderUuid()), content.getViewOnceOpen().getSenderE164());
            ViewOnceOpenMessage timerRead = new ViewOnceOpenMessage(address, content.getViewOnceOpen().getTimestamp());
            return SignalServiceSyncMessage.forViewOnceOpen(timerRead);
        } else {
            throw new InvalidMessageStructureException("ViewOnceOpen message has no sender!");
        }
    }
    if (content.hasVerified()) {
        if (SignalServiceAddress.isValidAddress(content.getVerified().getDestinationUuid(), content.getVerified().getDestinationE164())) {
            try {
                SignalServiceProtos.Verified verified = content.getVerified();
                SignalServiceAddress destination = new SignalServiceAddress(ACI.parseOrThrow(verified.getDestinationUuid()), verified.getDestinationE164());
                IdentityKey identityKey = new IdentityKey(verified.getIdentityKey().toByteArray(), 0);
                VerifiedMessage.VerifiedState verifiedState;
                if (verified.getState() == SignalServiceProtos.Verified.State.DEFAULT) {
                    verifiedState = VerifiedMessage.VerifiedState.DEFAULT;
                } else if (verified.getState() == SignalServiceProtos.Verified.State.VERIFIED) {
                    verifiedState = VerifiedMessage.VerifiedState.VERIFIED;
                } else if (verified.getState() == SignalServiceProtos.Verified.State.UNVERIFIED) {
                    verifiedState = VerifiedMessage.VerifiedState.UNVERIFIED;
                } else {
                    throw new InvalidMessageStructureException("Unknown state: " + verified.getState().getNumber(), metadata.getSender().getIdentifier(), metadata.getSenderDevice());
                }
                return SignalServiceSyncMessage.forVerified(new VerifiedMessage(destination, identityKey, verifiedState, System.currentTimeMillis()));
            } catch (InvalidKeyException e) {
                throw new ProtocolInvalidKeyException(e, metadata.getSender().getIdentifier(), metadata.getSenderDevice());
            }
        } else {
            throw new InvalidMessageStructureException("Verified message has no sender!");
        }
    }
    if (content.getStickerPackOperationList().size() > 0) {
        List<StickerPackOperationMessage> operations = new LinkedList<>();
        for (SignalServiceProtos.SyncMessage.StickerPackOperation operation : content.getStickerPackOperationList()) {
            byte[] packId = operation.hasPackId() ? operation.getPackId().toByteArray() : null;
            byte[] packKey = operation.hasPackKey() ? operation.getPackKey().toByteArray() : null;
            StickerPackOperationMessage.Type type = null;
            if (operation.hasType()) {
                switch(operation.getType()) {
                    case INSTALL:
                        type = StickerPackOperationMessage.Type.INSTALL;
                        break;
                    case REMOVE:
                        type = StickerPackOperationMessage.Type.REMOVE;
                        break;
                }
            }
            operations.add(new StickerPackOperationMessage(packId, packKey, type));
        }
        return SignalServiceSyncMessage.forStickerPackOperations(operations);
    }
    if (content.hasBlocked()) {
        List<String> numbers = content.getBlocked().getNumbersList();
        List<String> uuids = content.getBlocked().getUuidsList();
        List<SignalServiceAddress> addresses = new ArrayList<>(numbers.size() + uuids.size());
        List<byte[]> groupIds = new ArrayList<>(content.getBlocked().getGroupIdsList().size());
        for (String uuid : uuids) {
            Optional<SignalServiceAddress> address = SignalServiceAddress.fromRaw(uuid, null);
            if (address.isPresent()) {
                addresses.add(address.get());
            }
        }
        for (ByteString groupId : content.getBlocked().getGroupIdsList()) {
            groupIds.add(groupId.toByteArray());
        }
        return SignalServiceSyncMessage.forBlocked(new BlockedListMessage(addresses, groupIds));
    }
    if (content.hasConfiguration()) {
        Boolean readReceipts = content.getConfiguration().hasReadReceipts() ? content.getConfiguration().getReadReceipts() : null;
        Boolean unidentifiedDeliveryIndicators = content.getConfiguration().hasUnidentifiedDeliveryIndicators() ? content.getConfiguration().getUnidentifiedDeliveryIndicators() : null;
        Boolean typingIndicators = content.getConfiguration().hasTypingIndicators() ? content.getConfiguration().getTypingIndicators() : null;
        Boolean linkPreviews = content.getConfiguration().hasLinkPreviews() ? content.getConfiguration().getLinkPreviews() : null;
        return SignalServiceSyncMessage.forConfiguration(new ConfigurationMessage(Optional.fromNullable(readReceipts), Optional.fromNullable(unidentifiedDeliveryIndicators), Optional.fromNullable(typingIndicators), Optional.fromNullable(linkPreviews)));
    }
    if (content.hasFetchLatest() && content.getFetchLatest().hasType()) {
        switch(content.getFetchLatest().getType()) {
            case LOCAL_PROFILE:
                return SignalServiceSyncMessage.forFetchLatest(SignalServiceSyncMessage.FetchType.LOCAL_PROFILE);
            case STORAGE_MANIFEST:
                return SignalServiceSyncMessage.forFetchLatest(SignalServiceSyncMessage.FetchType.STORAGE_MANIFEST);
            case SUBSCRIPTION_STATUS:
                return SignalServiceSyncMessage.forFetchLatest(SignalServiceSyncMessage.FetchType.SUBSCRIPTION_STATUS);
        }
    }
    if (content.hasMessageRequestResponse()) {
        MessageRequestResponseMessage.Type type;
        switch(content.getMessageRequestResponse().getType()) {
            case ACCEPT:
                type = MessageRequestResponseMessage.Type.ACCEPT;
                break;
            case DELETE:
                type = MessageRequestResponseMessage.Type.DELETE;
                break;
            case BLOCK:
                type = MessageRequestResponseMessage.Type.BLOCK;
                break;
            case BLOCK_AND_DELETE:
                type = MessageRequestResponseMessage.Type.BLOCK_AND_DELETE;
                break;
            default:
                type = MessageRequestResponseMessage.Type.UNKNOWN;
                break;
        }
        MessageRequestResponseMessage responseMessage;
        if (content.getMessageRequestResponse().hasGroupId()) {
            responseMessage = MessageRequestResponseMessage.forGroup(content.getMessageRequestResponse().getGroupId().toByteArray(), type);
        } else {
            Optional<SignalServiceAddress> address = SignalServiceAddress.fromRaw(content.getMessageRequestResponse().getThreadUuid(), content.getMessageRequestResponse().getThreadE164());
            if (address.isPresent()) {
                responseMessage = MessageRequestResponseMessage.forIndividual(address.get(), type);
            } else {
                throw new InvalidMessageStructureException("Message request response has an invalid thread identifier!");
            }
        }
        return SignalServiceSyncMessage.forMessageRequestResponse(responseMessage);
    }
    if (content.hasOutgoingPayment()) {
        SignalServiceProtos.SyncMessage.OutgoingPayment outgoingPayment = content.getOutgoingPayment();
        switch(outgoingPayment.getPaymentDetailCase()) {
            case MOBILECOIN:
                {
                    SignalServiceProtos.SyncMessage.OutgoingPayment.MobileCoin mobileCoin = outgoingPayment.getMobileCoin();
                    Money.MobileCoin amount = Money.picoMobileCoin(mobileCoin.getAmountPicoMob());
                    Money.MobileCoin fee = Money.picoMobileCoin(mobileCoin.getFeePicoMob());
                    ByteString address = mobileCoin.getRecipientAddress();
                    Optional<SignalServiceAddress> recipient = SignalServiceAddress.fromRaw(outgoingPayment.getRecipientUuid(), null);
                    return SignalServiceSyncMessage.forOutgoingPayment(new OutgoingPaymentMessage(recipient, amount, fee, mobileCoin.getReceipt(), mobileCoin.getLedgerBlockIndex(), mobileCoin.getLedgerBlockTimestamp(), address.isEmpty() ? Optional.absent() : Optional.of(address.toByteArray()), Optional.of(outgoingPayment.getNote()), mobileCoin.getOutputPublicKeysList(), mobileCoin.getSpentKeyImagesList()));
                }
            default:
                return SignalServiceSyncMessage.empty();
        }
    }
    if (content.hasKeys() && content.getKeys().hasStorageService()) {
        byte[] storageKey = content.getKeys().getStorageService().toByteArray();
        return SignalServiceSyncMessage.forKeys(new KeysMessage(Optional.of(new StorageKey(storageKey))));
    }
    if (content.hasContacts()) {
        return SignalServiceSyncMessage.forContacts(new ContactsMessage(createAttachmentPointer(content.getContacts().getBlob()), content.getContacts().getComplete()));
    }
    return SignalServiceSyncMessage.empty();
}