import org.signal.libsignal.metadata.ProtocolNoSessionException;
import org.signal.libsignal.metadata.ProtocolUntrustedIdentityException;
import org.signal.libsignal.metadata.SelfSendException;
+import org.signal.libsignal.metadata.certificate.InvalidCertificateException;
+import org.signal.zkgroup.InvalidInputException;
+import org.signal.zkgroup.VerificationFailedException;
+import org.signal.zkgroup.profiles.ProfileKey;
import org.whispersystems.libsignal.IdentityKey;
import org.whispersystems.libsignal.IdentityKeyPair;
import org.whispersystems.libsignal.InvalidKeyException;
import org.whispersystems.signalservice.api.SignalServiceMessagePipe;
import org.whispersystems.signalservice.api.SignalServiceMessageReceiver;
import org.whispersystems.signalservice.api.SignalServiceMessageSender;
+import org.whispersystems.signalservice.api.crypto.InvalidCiphertextException;
+import org.whispersystems.signalservice.api.crypto.ProfileCipher;
import org.whispersystems.signalservice.api.crypto.SignalServiceCipher;
import org.whispersystems.signalservice.api.crypto.UnidentifiedAccess;
import org.whispersystems.signalservice.api.crypto.UnidentifiedAccessPair;
import org.whispersystems.signalservice.api.messages.multidevice.SentTranscriptMessage;
import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage;
import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage;
+import org.whispersystems.signalservice.api.profiles.SignalServiceProfile;
import org.whispersystems.signalservice.api.push.ContactTokenDetails;
import org.whispersystems.signalservice.api.push.SignalServiceAddress;
import org.whispersystems.signalservice.api.push.exceptions.AuthorizationFailedException;
public class Manager implements Signal {
+ private static final SignalServiceProfile.Capabilities capabilities = new SignalServiceProfile.Capabilities(false, false);
+
private final String settingsPath;
private final String dataPath;
private final String attachmentsPath;
if (username == null) {
account = SignalAccount.createTemporaryAccount(identityKey, registrationId);
} else {
- byte[] profileKey = KeyUtils.createProfileKey();
+ ProfileKey profileKey = KeyUtils.createProfileKey();
account = SignalAccount.create(dataPath, username, identityKey, registrationId, profileKey);
account.save();
}
accountManager = getSignalServiceAccountManager();
if (voiceVerification) {
- accountManager.requestVoiceVerificationCode(Locale.getDefault(), Optional.<String>absent(), Optional.<String>absent());
+ accountManager.requestVoiceVerificationCode(Locale.getDefault(), Optional.absent(), Optional.absent());
} else {
- accountManager.requestSmsVerificationCode(false, Optional.<String>absent(), Optional.<String>absent());
+ accountManager.requestSmsVerificationCode(false, Optional.absent(), Optional.absent());
}
account.setRegistered(false);
}
public void updateAccountAttributes() throws IOException {
- accountManager.setAccountAttributes(account.getSignalingKey(), account.getSignalProtocolStore().getLocalRegistrationId(), true, account.getRegistrationLockPin(), getSelfUnidentifiedAccessKey(), false);
+ accountManager.setAccountAttributes(account.getSignalingKey(), account.getSignalProtocolStore().getLocalRegistrationId(), true, account.getRegistrationLockPin(), account.getRegistrationLock(), getSelfUnidentifiedAccessKey(), false, capabilities);
}
public void setProfileName(String name) throws IOException {
// When setting an empty GCM id, the Signal-Server also sets the fetchesMessages property to false.
// If this is the master device, other users can't send messages to this number anymore.
// If this is a linked device, other users can still send messages, but this device doesn't receive them anymore.
- accountManager.setGcmId(Optional.<String>absent());
+ accountManager.setGcmId(Optional.absent());
account.setRegistered(false);
account.save();
}
// Create new account with the synced identity
- byte[] profileKey = ret.getProfileKey();
- if (profileKey == null) {
+ byte[] profileKeyBytes = ret.getProfileKey();
+ ProfileKey profileKey;
+ if (profileKeyBytes == null) {
profileKey = KeyUtils.createProfileKey();
+ } else {
+ try {
+ profileKey = new ProfileKey(profileKeyBytes);
+ } catch (InvalidInputException e) {
+ throw new IOException("Received invalid profileKey", e);
+ }
}
account = SignalAccount.createLinkedAccount(dataPath, username, account.getPassword(), ret.getDeviceId(), ret.getIdentity(), account.getSignalProtocolStore().getLocalRegistrationId(), account.getSignalingKey(), profileKey);
IdentityKeyPair identityKeyPair = account.getSignalProtocolStore().getIdentityKeyPair();
String verificationCode = accountManager.getNewDeviceVerificationCode();
- accountManager.addDevice(deviceIdentifier, deviceKey, identityKeyPair, Optional.of(account.getProfileKey()), verificationCode);
+ accountManager.addDevice(deviceIdentifier, deviceKey, identityKeyPair, Optional.of(account.getProfileKey().serialize()), verificationCode);
account.setMultiDevice(true);
account.save();
}
verificationCode = verificationCode.replace("-", "");
account.setSignalingKey(KeyUtils.createSignalingKey());
// TODO make unrestricted unidentified access configurable
- accountManager.verifyAccountWithCode(verificationCode, account.getSignalingKey(), account.getSignalProtocolStore().getLocalRegistrationId(), true, pin, getSelfUnidentifiedAccessKey(), false);
+ accountManager.verifyAccountWithCode(verificationCode, account.getSignalingKey(), account.getSignalProtocolStore().getLocalRegistrationId(), true, pin, null, getSelfUnidentifiedAccessKey(), false, capabilities);
//accountManager.setGcmId(Optional.of(GoogleCloudMessaging.getInstance(this).register(REGISTRATION_ID)));
account.setRegistered(true);
}
public void setRegistrationLockPin(Optional<String> pin) throws IOException {
- accountManager.setPin(pin);
if (pin.isPresent()) {
account.setRegistrationLockPin(pin.get());
+ throw new RuntimeException("Not implemented anymore, will be replaced with KBS");
} else {
account.setRegistrationLockPin(null);
+ accountManager.removeV1Pin();
}
account.save();
}
private SignalServiceMessageSender getMessageSender() {
return new SignalServiceMessageSender(BaseConfig.serviceConfiguration, null, username, account.getPassword(),
- account.getDeviceId(), account.getSignalProtocolStore(), BaseConfig.USER_AGENT, account.isMultiDevice(), Optional.fromNullable(messagePipe), Optional.fromNullable(unidentifiedMessagePipe), Optional.<SignalServiceMessageSender.EventListener>absent());
+ account.getDeviceId(), account.getSignalProtocolStore(), BaseConfig.USER_AGENT, account.isMultiDevice(), Optional.fromNullable(messagePipe), Optional.fromNullable(unidentifiedMessagePipe), Optional.absent());
+ }
+
+ private SignalServiceProfile getRecipientProfile(SignalServiceAddress address, Optional<UnidentifiedAccess> unidentifiedAccess) throws IOException {
+ SignalServiceMessagePipe pipe = unidentifiedMessagePipe != null && unidentifiedAccess.isPresent() ? unidentifiedMessagePipe
+ : messagePipe;
+
+ if (pipe != null) {
+ try {
+ return pipe.getProfile(address, Optional.absent(), unidentifiedAccess, SignalServiceProfile.RequestType.PROFILE).getProfile();
+ } catch (IOException ignored) {
+ }
+ }
+
+ SignalServiceMessageReceiver receiver = getMessageReceiver();
+ try {
+ return receiver.retrieveProfile(address, Optional.absent(), unidentifiedAccess, SignalServiceProfile.RequestType.PROFILE).getProfile();
+ } catch (VerificationFailedException e) {
+ throw new AssertionError(e);
+ }
}
private Optional<SignalServiceAttachmentStream> createGroupAvatarAttachment(byte[] groupId) throws IOException {
sendMessageLegacy(messageBuilder, membersSend);
}
+ public void sendGroupMessageReaction(String emoji, boolean remove, SignalServiceAddress targetAuthor,
+ long targetSentTimestamp, byte[] groupId)
+ throws IOException, EncapsulatedExceptions, AttachmentInvalidException {
+ SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, targetAuthor, targetSentTimestamp);
+ final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
+ .withReaction(reaction)
+ .withProfileKey(account.getProfileKey().serialize());
+ if (groupId != null) {
+ SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.DELIVER)
+ .withId(groupId)
+ .build();
+ messageBuilder.asGroupMessage(group);
+ }
+ final GroupInfo g = getGroupForSending(groupId);
+ // Don't send group message to ourself
+ final List<String> membersSend = new ArrayList<>(g.members);
+ membersSend.remove(this.username);
+ sendMessageLegacy(messageBuilder, membersSend);
+ }
+
public void sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, EncapsulatedExceptions {
SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT)
.withId(groupId)
messageBuilder.withAttachments(attachmentPointers);
}
- messageBuilder.withProfileKey(account.getProfileKey());
+ messageBuilder.withProfileKey(account.getProfileKey().serialize());
+ sendMessageLegacy(messageBuilder, recipients);
+ }
+
+ public void sendMessageReaction(String emoji, boolean remove, SignalServiceAddress targetAuthor,
+ long targetSentTimestamp, List<String> recipients)
+ throws IOException, EncapsulatedExceptions, AttachmentInvalidException {
+ SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, targetAuthor, targetSentTimestamp);
+ final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
+ .withReaction(reaction)
+ .withProfileKey(account.getProfileKey().serialize());
sendMessageLegacy(messageBuilder, recipients);
}
}
}
+ private byte[] getSenderCertificate() throws IOException {
+ byte[] certificate = accountManager.getSenderCertificate();
+ // TODO cache for a day
+ return certificate;
+ }
+
private byte[] getSelfUnidentifiedAccessKey() {
return UnidentifiedAccess.deriveAccessKeyFrom(account.getProfileKey());
}
- private byte[] getTargetUnidentifiedAccessKey(SignalServiceAddress recipient) {
- // TODO implement
- return null;
+ private static SignalProfile decryptProfile(SignalServiceProfile encryptedProfile, ProfileKey profileKey) throws IOException {
+ ProfileCipher profileCipher = new ProfileCipher(profileKey);
+ try {
+ return new SignalProfile(
+ encryptedProfile.getIdentityKey(),
+ encryptedProfile.getName() == null ? null : new String(profileCipher.decryptName(Base64.decode(encryptedProfile.getName()))),
+ encryptedProfile.getAvatar(),
+ encryptedProfile.getUnidentifiedAccess() == null || !profileCipher.verifyUnidentifiedAccess(Base64.decode(encryptedProfile.getUnidentifiedAccess())) ? null : encryptedProfile.getUnidentifiedAccess(),
+ encryptedProfile.isUnrestrictedUnidentifiedAccess()
+ );
+ } catch (InvalidCiphertextException e) {
+ return null;
+ }
+ }
+
+ private byte[] getTargetUnidentifiedAccessKey(SignalServiceAddress recipient) throws IOException {
+ ContactInfo contact = account.getContactStore().getContact(recipient.getNumber().get());
+ if (contact == null || contact.profileKey == null) {
+ return null;
+ }
+ ProfileKey theirProfileKey;
+ try {
+ theirProfileKey = new ProfileKey(Base64.decode(contact.profileKey));
+ } catch (InvalidInputException e) {
+ throw new AssertionError(e);
+ }
+ SignalProfile targetProfile = decryptProfile(getRecipientProfile(recipient, Optional.absent()), theirProfileKey);
+
+ if (targetProfile == null || targetProfile.getUnidentifiedAccess() == null) {
+ return null;
+ }
+
+ if (targetProfile.isUnrestrictedUnidentifiedAccess()) {
+ return KeyUtils.createUnrestrictedUnidentifiedAccess();
+ }
+
+ return UnidentifiedAccess.deriveAccessKeyFrom(theirProfileKey);
}
- private Optional<UnidentifiedAccessPair> getAccessForSync() {
- // TODO implement
- return Optional.absent();
+ private Optional<UnidentifiedAccessPair> getAccessForSync() throws IOException {
+ byte[] selfUnidentifiedAccessKey = getSelfUnidentifiedAccessKey();
+ byte[] selfUnidentifiedAccessCertificate = getSenderCertificate();
+
+ if (selfUnidentifiedAccessKey == null || selfUnidentifiedAccessCertificate == null) {
+ return Optional.absent();
+ }
+
+ try {
+ return Optional.of(new UnidentifiedAccessPair(
+ new UnidentifiedAccess(selfUnidentifiedAccessKey, selfUnidentifiedAccessCertificate),
+ new UnidentifiedAccess(selfUnidentifiedAccessKey, selfUnidentifiedAccessCertificate)
+ ));
+ } catch (InvalidCertificateException e) {
+ return Optional.absent();
+ }
}
- private List<Optional<UnidentifiedAccessPair>> getAccessFor(Collection<SignalServiceAddress> recipients) {
+ private List<Optional<UnidentifiedAccessPair>> getAccessFor(Collection<SignalServiceAddress> recipients) throws IOException {
List<Optional<UnidentifiedAccessPair>> result = new ArrayList<>(recipients.size());
for (SignalServiceAddress recipient : recipients) {
- result.add(Optional.<UnidentifiedAccessPair>absent());
+ result.add(getAccessFor(recipient));
}
return result;
}
- private Optional<UnidentifiedAccessPair> getAccessFor(SignalServiceAddress recipient) {
- // TODO implement
- return Optional.absent();
+ private Optional<UnidentifiedAccessPair> getAccessFor(SignalServiceAddress recipient) throws IOException {
+ byte[] recipientUnidentifiedAccessKey = getTargetUnidentifiedAccessKey(recipient);
+ byte[] selfUnidentifiedAccessKey = getSelfUnidentifiedAccessKey();
+ byte[] selfUnidentifiedAccessCertificate = getSenderCertificate();
+
+ if (recipientUnidentifiedAccessKey == null || selfUnidentifiedAccessKey == null || selfUnidentifiedAccessCertificate == null) {
+ return Optional.absent();
+ }
+
+ try {
+ return Optional.of(new UnidentifiedAccessPair(
+ new UnidentifiedAccess(recipientUnidentifiedAccessKey, selfUnidentifiedAccessCertificate),
+ new UnidentifiedAccess(selfUnidentifiedAccessKey, selfUnidentifiedAccessCertificate)
+ ));
+ } catch (InvalidCertificateException e) {
+ return Optional.absent();
+ }
}
private void sendSyncMessage(SignalServiceSyncMessage message)
return Collections.emptyList();
}
+ if (messagePipe == null) {
+ messagePipe = getMessageReceiver().createMessagePipe();
+ }
+ if (unidentifiedMessagePipe == null) {
+ unidentifiedMessagePipe = getMessageReceiver().createUnidentifiedMessagePipe();
+ }
SignalServiceDataMessage message = null;
try {
SignalServiceMessageSender messageSender = getMessageSender();
}
if (message.getProfileKey().isPresent() && message.getProfileKey().get().length == 32) {
if (source.equals(username)) {
- this.account.setProfileKey(message.getProfileKey().get());
+ try {
+ this.account.setProfileKey(new ProfileKey(message.getProfileKey().get()));
+ } catch (InvalidInputException ignored) {
+ }
}
ContactInfo contact = account.getContactStore().getContact(source);
if (contact == null) {
contact.number = source;
}
contact.profileKey = Base64.encodeBytes(message.getProfileKey().get());
+ account.getContactStore().updateContact(contact);
}
if (message.getPreviews().isPresent()) {
final List<SignalServiceDataMessage.Preview> previews = message.getPreviews().get();
Exception exception = null;
final long now = new Date().getTime();
try {
- envelope = messagePipe.read(timeout, unit, new SignalServiceMessagePipe.MessagePipeCallback() {
- @Override
- public void onMessage(SignalServiceEnvelope envelope) {
- // store message on disk, before acknowledging receipt to the server
- try {
- File cacheFile = getMessageCacheFile(envelope.getSourceE164().get(), now, envelope.getTimestamp());
- Utils.storeEnvelope(envelope, cacheFile);
- } catch (IOException e) {
- System.err.println("Failed to store encrypted message in disk cache, ignoring: " + e.getMessage());
- }
+ envelope = messagePipe.read(timeout, unit, envelope1 -> {
+ // store message on disk, before acknowledging receipt to the server
+ try {
+ File cacheFile = getMessageCacheFile(envelope1.getSourceE164().get(), now, envelope1.getTimestamp());
+ Utils.storeEnvelope(envelope1, cacheFile);
+ } catch (IOException e) {
+ System.err.println("Failed to store encrypted message in disk cache, ignoring: " + e.getMessage());
}
});
} catch (TimeoutException e) {
syncGroup.name = g.getName().get();
}
syncGroup.addMembers(g.getMembers());
- syncGroup.active = g.isActive();
+ if (!g.isActive()) {
+ syncGroup.members.remove(username);
+ }
syncGroup.blocked = g.isBlocked();
if (g.getColor().isPresent()) {
syncGroup.color = g.getColor().get();
if (g.getAvatar().isPresent()) {
retrieveGroupAvatarAttachment(g.getAvatar().get(), syncGroup.groupId);
}
+ syncGroup.inboxPosition = g.getInboxPosition().orNull();
+ syncGroup.archived = g.isArchived();
account.getGroupStore().updateGroup(syncGroup);
}
}
contact.color = c.getColor().get();
}
if (c.getProfileKey().isPresent()) {
- contact.profileKey = Base64.encodeBytes(c.getProfileKey().get());
+ contact.profileKey = Base64.encodeBytes(c.getProfileKey().get().serialize());
}
if (c.getVerified().isPresent()) {
final VerifiedMessage verifiedMessage = c.getVerified().get();
account.getThreadStore().updateThread(thread);
}
contact.blocked = c.isBlocked();
+ contact.inboxPosition = c.getInboxPosition().orNull();
+ contact.archived = c.isArchived();
account.getContactStore().updateContact(contact);
if (c.getAvatar().isPresent()) {
ThreadInfo info = account.getThreadStore().getThread(Base64.encodeBytes(record.groupId));
out.write(new DeviceGroup(record.groupId, Optional.fromNullable(record.name),
new ArrayList<>(record.getMembers()), createGroupAvatarAttachment(record.groupId),
- record.active, Optional.fromNullable(info != null ? info.messageExpirationTime : null),
- Optional.fromNullable(record.color), record.blocked));
+ record.members.contains(username), Optional.fromNullable(info != null ? info.messageExpirationTime : null),
+ Optional.fromNullable(record.color), record.blocked, Optional.fromNullable(record.inboxPosition), record.archived));
}
}
}
}
- byte[] profileKey = record.profileKey == null ? null : Base64.decode(record.profileKey);
+ ProfileKey profileKey = null;
+ try {
+ profileKey = record.profileKey == null ? null : new ProfileKey(Base64.decode(record.profileKey));
+ } catch (InvalidInputException ignored) {
+ }
out.write(new DeviceContact(record.getAddress(), Optional.fromNullable(record.name),
createContactAvatarAttachment(record.number), Optional.fromNullable(record.color),
Optional.fromNullable(verifiedMessage), Optional.fromNullable(profileKey), record.blocked,
- Optional.fromNullable(info != null ? info.messageExpirationTime : null)));
+ Optional.fromNullable(info != null ? info.messageExpirationTime : null),
+ Optional.fromNullable(record.inboxPosition), record.archived));
}
if (account.getProfileKey() != null) {
// Send our own profile key as well
out.write(new DeviceContact(account.getSelfAddress(),
- Optional.<String>absent(), Optional.<SignalServiceAttachmentStream>absent(),
- Optional.<String>absent(), Optional.<VerifiedMessage>absent(),
+ Optional.absent(), Optional.absent(),
+ Optional.absent(), Optional.absent(),
Optional.of(account.getProfileKey()),
- false, Optional.<Integer>absent()));
+ false, Optional.absent(), Optional.absent(), false));
}
}
git.nmode.ca / signal-cli / blobdiff
