Signal/Android
1
0
Fork 0
mirror of https://github.com/signalapp/Signal-Android.git synced 2025-12-25 05:27:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Adopt libsignal 0.30.0 and ServiceIds for group members.

Browse Source 
Co-authored-by: Greyson Parrelli <greyson@signal.org>
This commit is contained in:
Jordan Rose
2023-07-31 10:28:18 -07:00
committed by Greyson Parrelli
parent b11d653fc0
commit a2c3b5d64e
44 changed files with 613 additions and 592 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
libsignal/service/src/main/java/org/whispersystems/signalservice/api/SignalServiceAccountManager.java
View File

@@ -740,23 +740,23 @@ public class SignalServiceAccountManager {
new ProfileCipherOutputStreamFactory(profileKey));
}
return this.pushServiceSocket.writeProfile(new SignalServiceProfileWrite(profileKey.getProfileKeyVersion(aci.getRawUuid()).serialize(),
return this.pushServiceSocket.writeProfile(new SignalServiceProfileWrite(profileKey.getProfileKeyVersion(aci.getLibSignalAci()).serialize(),
ciphertextName,
ciphertextAbout,
ciphertextEmoji,
ciphertextMobileCoinAddress,
avatar.hasAvatar,
avatar.keepTheSame,
profileKey.getCommitment(aci.getRawUuid()).serialize(),
profileKey.getCommitment(aci.getLibSignalAci()).serialize(),
visibleBadgeIds),
profileAvatarData);
}
public Optional<ExpiringProfileKeyCredential> resolveProfileKeyCredential(ServiceId serviceId, ProfileKey profileKey, Locale locale)
public Optional<ExpiringProfileKeyCredential> resolveProfileKeyCredential(ACI serviceId, ProfileKey profileKey, Locale locale)
throws NonSuccessfulResponseCodeException, PushNetworkException
{
try {
ProfileAndCredential credential = this.pushServiceSocket.retrieveVersionedProfileAndCredential(serviceId.getRawUuid(), profileKey, Optional.empty(), locale).get(10, TimeUnit.SECONDS);
ProfileAndCredential credential = this.pushServiceSocket.retrieveVersionedProfileAndCredential(serviceId, profileKey, Optional.empty(), locale).get(10, TimeUnit.SECONDS);
return credential.getExpiringProfileKeyCredential();
} catch (InterruptedException | TimeoutException e) {
throw new PushNetworkException(e);

19
libsignal/service/src/main/java/org/whispersystems/signalservice/api/SignalServiceMessageReceiver.java
View File

@@ -20,6 +20,7 @@ import org.whispersystems.signalservice.api.messages.SignalServiceStickerManifes
import org.whispersystems.signalservice.api.profiles.ProfileAndCredential;
import org.whispersystems.signalservice.api.profiles.SignalServiceProfile;
import org.whispersystems.signalservice.api.push.ServiceId;
import org.whispersystems.signalservice.api.push.ServiceId.ACI;
import org.whispersystems.signalservice.api.push.SignalServiceAddress;
import org.whispersystems.signalservice.api.push.exceptions.MissingConfigurationException;
import org.whispersystems.signalservice.api.util.CredentialsProvider;
@@ -34,6 +35,7 @@ import org.whispersystems.signalservice.internal.sticker.StickerProtos;
import org.whispersystems.signalservice.internal.util.Util;
import org.whispersystems.signalservice.internal.util.concurrent.FutureTransformers;
import org.whispersystems.signalservice.internal.util.concurrent.ListenableFuture;
import org.whispersystems.signalservice.internal.util.concurrent.SettableFuture;
import org.whispersystems.signalservice.internal.websocket.ResponseMapper;
import java.io.File;
@@ -96,13 +98,22 @@ public class SignalServiceMessageReceiver {
SignalServiceProfile.RequestType requestType,
Locale locale)
{
ServiceId serviceId = address.getServiceId();
if (profileKey.isPresent()) {
if (requestType == SignalServiceProfile.RequestType.PROFILE_AND_CREDENTIAL) {
return socket.retrieveVersionedProfileAndCredential(serviceId.getRawUuid(), profileKey.get(), unidentifiedAccess, locale);
ACI aci;
if (address.getServiceId() instanceof ACI) {
aci = (ACI) address.getServiceId();
} else {
return FutureTransformers.map(socket.retrieveVersionedProfile(serviceId.getRawUuid(), profileKey.get(), unidentifiedAccess, locale), profile -> {
// We shouldn't ever have a profile key for a non-ACI.
SettableFuture<ProfileAndCredential> result = new SettableFuture<>();
result.setException(new ClassCastException("retrieving a versioned profile requires an ACI"));
return result;
}
if (requestType == SignalServiceProfile.RequestType.PROFILE_AND_CREDENTIAL) {
return socket.retrieveVersionedProfileAndCredential(aci, profileKey.get(), unidentifiedAccess, locale);
} else {
return FutureTransformers.map(socket.retrieveVersionedProfile(aci, profileKey.get(), unidentifiedAccess, locale), profile -> {
return new ProfileAndCredential(profile,
SignalServiceProfile.RequestType.PROFILE,
Optional.empty());

135
libsignal/service/src/main/java/org/whispersystems/signalservice/api/groupsv2/DecryptedGroupUtil.java
View File

@@ -15,6 +15,7 @@ import org.signal.storageservice.protos.groups.local.DecryptedPendingMember;
import org.signal.storageservice.protos.groups.local.DecryptedPendingMemberRemoval;
import org.signal.storageservice.protos.groups.local.DecryptedRequestingMember;
import org.signal.storageservice.protos.groups.local.EnabledState;
import org.whispersystems.signalservice.api.push.ServiceId;
import org.whispersystems.signalservice.api.push.ServiceIds;
import org.whispersystems.signalservice.api.util.UuidUtil;
@@ -28,6 +29,8 @@ import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import javax.annotation.Nullable;
public final class DecryptedGroupUtil {
private static final String TAG = DecryptedGroupUtil.class.getSimpleName();
@@ -42,18 +45,18 @@ public final class DecryptedGroupUtil {
return uuidList;
}
public static ArrayList<UUID> membersToUuidList(Collection<DecryptedMember> membersList) {
ArrayList<UUID> uuidList = new ArrayList<>(membersList.size());
public static ArrayList<ServiceId> membersToServiceIdList(Collection<DecryptedMember> membersList) {
ArrayList<ServiceId> serviceIdList = new ArrayList<>(membersList.size());
for (DecryptedMember member : membersList) {
UUID uuid = toUuid(member);
ServiceId serviceId = ServiceId.parseOrNull(member.getUuid());
if (!UuidUtil.UNKNOWN_UUID.equals(uuid)) {
uuidList.add(uuid);
if (serviceId != null) {
serviceIdList.add(serviceId);
}
}
return uuidList;
return serviceIdList;
}
public static Set<ByteString> membersToUuidByteStringSet(Collection<DecryptedMember> membersList) {
@@ -67,98 +70,94 @@ public final class DecryptedGroupUtil {
}
/**
* Can return non-decryptable member UUIDs as {@link UuidUtil#UNKNOWN_UUID}.
* Can return non-decryptable member UUIDs as unknown ACIs.
*/
public static ArrayList<UUID> pendingToUuidList(Collection<DecryptedPendingMember> membersList) {
ArrayList<UUID> uuidList = new ArrayList<>(membersList.size());
public static ArrayList<ServiceId> pendingToServiceIdList(Collection<DecryptedPendingMember> membersList) {
ArrayList<ServiceId> serviceIdList = new ArrayList<>(membersList.size());
for (DecryptedPendingMember member : membersList) {
uuidList.add(toUuid(member));
ServiceId serviceId = ServiceId.parseOrNull(member.getServiceIdBinary());
if (serviceId != null) {
serviceIdList.add(serviceId);
} else {
serviceIdList.add(ServiceId.ACI.UNKNOWN);
}
}
return uuidList;
return serviceIdList;
}
/**
* Will not return any non-decryptable member UUIDs.
*/
public static ArrayList<UUID> removedMembersUuidList(DecryptedGroupChange groupChange) {
List<ByteString> deletedMembers = groupChange.getDeleteMembersList();
ArrayList<UUID> uuidList = new ArrayList<>(deletedMembers.size());
public static ArrayList<ServiceId> removedMembersServiceIdList(DecryptedGroupChange groupChange) {
List<ByteString> deletedMembers = groupChange.getDeleteMembersList();
ArrayList<ServiceId> serviceIdList = new ArrayList<>(deletedMembers.size());
for (ByteString member : deletedMembers) {
UUID uuid = toUuid(member);
ServiceId serviceId = ServiceId.parseOrNull(member);
if (!UuidUtil.UNKNOWN_UUID.equals(uuid)) {
uuidList.add(uuid);
if (serviceId != null) {
serviceIdList.add(serviceId);
}
}
return uuidList;
return serviceIdList;
}
/**
* Will not return any non-decryptable member UUIDs.
*/
public static ArrayList<UUID> removedPendingMembersUuidList(DecryptedGroupChange groupChange) {
public static ArrayList<ServiceId> removedPendingMembersServiceIdList(DecryptedGroupChange groupChange) {
List<DecryptedPendingMemberRemoval> deletedPendingMembers = groupChange.getDeletePendingMembersList();
ArrayList<UUID> uuidList = new ArrayList<>(deletedPendingMembers.size());
ArrayList<ServiceId> serviceIdList = new ArrayList<>(deletedPendingMembers.size());
for (DecryptedPendingMemberRemoval member : deletedPendingMembers) {
UUID uuid = toUuid(member.getUuid());
ServiceId serviceId = ServiceId.parseOrNull(member.getServiceIdBinary());
if(!UuidUtil.UNKNOWN_UUID.equals(uuid)) {
uuidList.add(uuid);
if(serviceId != null) {
serviceIdList.add(serviceId);
}
}
return uuidList;
return serviceIdList;
}
/**
* Will not return any non-decryptable member UUIDs.
*/
public static ArrayList<UUID> removedRequestingMembersUuidList(DecryptedGroupChange groupChange) {
List<ByteString> deleteRequestingMembers = groupChange.getDeleteRequestingMembersList();
ArrayList<UUID> uuidList = new ArrayList<>(deleteRequestingMembers.size());
public static ArrayList<ServiceId> removedRequestingMembersServiceIdList(DecryptedGroupChange groupChange) {
List<ByteString> deleteRequestingMembers = groupChange.getDeleteRequestingMembersList();
ArrayList<ServiceId> serviceIdList = new ArrayList<>(deleteRequestingMembers.size());
for (ByteString member : deleteRequestingMembers) {
UUID uuid = toUuid(member);
ServiceId serviceId = ServiceId.parseOrNull(member);
if(!UuidUtil.UNKNOWN_UUID.equals(uuid)) {
uuidList.add(uuid);
if(serviceId != null) {
serviceIdList.add(serviceId);
}
}
return uuidList;
return serviceIdList;
}
public static Set<UUID> bannedMembersToUuidSet(Collection<DecryptedBannedMember> membersList) {
Set<UUID> uuidSet = new HashSet<>(membersList.size());
public static Set<ServiceId> bannedMembersToServiceIdSet(Collection<DecryptedBannedMember> membersList) {
Set<ServiceId> serviceIdSet = new HashSet<>(membersList.size());
for (DecryptedBannedMember member : membersList) {
UUID uuid = toUuid(member);
if (!UuidUtil.UNKNOWN_UUID.equals(uuid)) {
uuidSet.add(uuid);
ServiceId serviceId = ServiceId.parseOrNull(member.getServiceIdBinary());
if (serviceId != null) {
serviceIdSet.add(serviceId);
}
}
return uuidSet;
return serviceIdSet;
}
public static UUID toUuid(DecryptedMember member) {
return toUuid(member.getUuid());
}
public static UUID toUuid(DecryptedPendingMember member) {
return toUuid(member.getUuid());
}
public static UUID toUuid(DecryptedBannedMember member) {
return toUuid(member.getUuid());
}
private static UUID toUuid(ByteString memberUuid) {
return UuidUtil.fromByteStringOrUnknown(memberUuid);
}
@@ -182,11 +181,11 @@ public final class DecryptedGroupUtil {
return Optional.empty();
}
public static Optional<DecryptedPendingMember> findPendingByUuid(Collection<DecryptedPendingMember> members, UUID uuid) {
ByteString uuidBytes = UuidUtil.toByteString(uuid);
public static Optional<DecryptedPendingMember> findPendingByServiceId(Collection<DecryptedPendingMember> members, ServiceId serviceId) {
ByteString serviceIdBinary = serviceId.toByteString();
for (DecryptedPendingMember member : members) {
if (uuidBytes.equals(member.getUuid())) {
if (serviceIdBinary.equals(member.getServiceIdBinary())) {
return Optional.of(member);
}
}
@@ -196,7 +195,7 @@ public final class DecryptedGroupUtil {
public static Optional<DecryptedPendingMember> findPendingByServiceIds(Collection<DecryptedPendingMember> members, ServiceIds serviceIds) {
for (DecryptedPendingMember member : members) {
if (serviceIds.matches(member.getUuid())) {
if (serviceIds.matches(member.getServiceIdBinary())) {
return Optional.of(member);
}
}
@@ -215,10 +214,10 @@ public final class DecryptedGroupUtil {
return -1;
}
private static int findPendingIndexByUuid(List<DecryptedPendingMember> members, ByteString uuid) {
private static int findPendingIndexByServiceId(List<DecryptedPendingMember> members, ByteString serviceIdBinary) {
for (int i = 0; i < members.size(); i++) {
DecryptedPendingMember member = members.get(i);
if (uuid.equals(member.getUuid())) {
if (serviceIdBinary.equals(member.getServiceIdBinary())) {
return i;
}
}
@@ -416,7 +415,7 @@ public final class DecryptedGroupUtil {
Set<ByteString> pendingMemberCipherTexts = getPendingMemberCipherTextSet(builder.getPendingMembersList());
for (DecryptedPendingMember pendingMember : newPendingMembersList) {
if (fullMemberSet.contains(pendingMember.getUuid())) {
if (fullMemberSet.contains(pendingMember.getServiceIdBinary())) {
throw new NotAbleToApplyGroupV2ChangeException();
}
@@ -441,7 +440,7 @@ public final class DecryptedGroupUtil {
protected static void applyPromotePendingMemberActions(DecryptedGroup.Builder builder, List<DecryptedMember> promotePendingMembersList) throws NotAbleToApplyGroupV2ChangeException {
for (DecryptedMember newMember : promotePendingMembersList) {
int index = findPendingIndexByUuid(builder.getPendingMembersList(), newMember.getUuid());
int index = findPendingIndexByServiceId(builder.getPendingMembersList(), newMember.getUuid());
if (index == -1) {
throw new NotAbleToApplyGroupV2ChangeException();
@@ -556,10 +555,10 @@ public final class DecryptedGroupUtil {
}
private static void applyAddBannedMembersActions(DecryptedGroup.Builder builder, List<DecryptedBannedMember> newBannedMembersList) {
Set<ByteString> bannedMemberUuidSet = getBannedMemberUuidSet(builder.getBannedMembersList());
Set<ByteString> bannedMemberServiceIdSet = getBannedMemberServiceIdSet(builder.getBannedMembersList());
for (DecryptedBannedMember member : newBannedMembersList) {
if (bannedMemberUuidSet.contains(member.getUuid())) {
if (bannedMemberServiceIdSet.contains(member.getServiceIdBinary())) {
Log.w(TAG, "Banned member already in banned list");
} else {
builder.addBannedMembers(member);
@@ -569,7 +568,7 @@ public final class DecryptedGroupUtil {
private static void applyDeleteBannedMembersActions(DecryptedGroup.Builder builder, List<DecryptedBannedMember> deleteMembersList) {
for (DecryptedBannedMember removedMember : deleteMembersList) {
int index = indexOfUuidInBannedMemberList(builder.getBannedMembersList(), removedMember.getUuid());
int index = indexOfServiceIdInBannedMemberList(builder.getBannedMembersList(), removedMember.getServiceIdBinary());
if (index == -1) {
Log.w(TAG, "Deleted banned member on change not found in banned list");
@@ -582,7 +581,7 @@ public final class DecryptedGroupUtil {
protected static void applyPromotePendingPniAciMemberActions(DecryptedGroup.Builder builder, List<DecryptedMember> promotePendingPniAciMembersList) throws NotAbleToApplyGroupV2ChangeException {
for (DecryptedMember newMember : promotePendingPniAciMembersList) {
int index = findPendingIndexByUuid(builder.getPendingMembersList(), newMember.getPni());
int index = findPendingIndexByServiceId(builder.getPendingMembersList(), newMember.getPni());
if (index == -1) {
throw new NotAbleToApplyGroupV2ChangeException();
@@ -619,14 +618,14 @@ public final class DecryptedGroupUtil {
return pendingMemberCipherTexts;
}
private static Set<ByteString> getBannedMemberUuidSet(List<DecryptedBannedMember> bannedMemberList) {
Set<ByteString> memberUuids = new HashSet<>(bannedMemberList.size());
private static Set<ByteString> getBannedMemberServiceIdSet(List<DecryptedBannedMember> bannedMemberList) {
Set<ByteString> memberServiceIds = new HashSet<>(bannedMemberList.size());
for (DecryptedBannedMember member : bannedMemberList) {
memberUuids.add(member.getUuid());
memberServiceIds.add(member.getServiceIdBinary());
}
return memberUuids;
return memberServiceIds;
}
private static void removePendingAndRequestingMembersNowInGroup(DecryptedGroup.Builder builder) {
@@ -634,7 +633,7 @@ public final class DecryptedGroupUtil {
for (int i = builder.getPendingMembersCount() - 1; i >= 0; i--) {
DecryptedPendingMember pendingMember = builder.getPendingMembers(i);
if (allMembers.contains(pendingMember.getUuid())) {
if (allMembers.contains(pendingMember.getServiceIdBinary())) {
builder.removePendingMembers(i);
}
}
@@ -667,19 +666,13 @@ public final class DecryptedGroupUtil {
return -1;
}
private static int indexOfUuidInBannedMemberList(List<DecryptedBannedMember> memberList, ByteString uuid) {
private static int indexOfServiceIdInBannedMemberList(List<DecryptedBannedMember> memberList, ByteString serviceIdBinary) {
for (int i = 0; i < memberList.size(); i++) {
if (uuid.equals(memberList.get(i).getUuid())) return i;
if (serviceIdBinary.equals(memberList.get(i).getServiceIdBinary())) return i;
}
return -1;
}
public static Optional<UUID> findInviter(List<DecryptedPendingMember> pendingMembersList, UUID uuid) {
return Optional.ofNullable(findPendingByUuid(pendingMembersList, uuid).map(DecryptedPendingMember::getAddedByUuid)
.map(UuidUtil::fromByteStringOrNull)
.orElse(null));
}
public static boolean changeIsEmpty(DecryptedGroupChange change) {
return change.getModifiedProfileKeysCount() == 0 && // field 6
changeIsEmptyExceptForProfileKeyChanges(change);

22
libsignal/service/src/main/java/org/whispersystems/signalservice/api/groupsv2/GroupCandidate.java
View File

@@ -1,12 +1,12 @@
package org.whispersystems.signalservice.api.groupsv2;
import org.signal.libsignal.zkgroup.profiles.ExpiringProfileKeyCredential;
import org.whispersystems.signalservice.api.push.ServiceId;
import org.whispersystems.signalservice.api.util.ExpiringProfileCredentialUtil;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
/**
* Represents a potential new member of a group.
@@ -15,20 +15,20 @@ import java.util.UUID;
* <p>
* If it does not, then this user can only be invited.
* <p>
* Equality by UUID only used to makes sure Sets only contain one copy.
* Equality by ServiceId only used to makes sure Sets only contain one copy.
*/
public final class GroupCandidate {
private final UUID uuid;
private final ServiceId serviceId;
private final Optional<ExpiringProfileKeyCredential> expiringProfileKeyCredential;
public GroupCandidate(UUID uuid, Optional<ExpiringProfileKeyCredential> expiringProfileKeyCredential) {
this.uuid = uuid;
public GroupCandidate(ServiceId serviceId, Optional<ExpiringProfileKeyCredential> expiringProfileKeyCredential) {
this.serviceId = serviceId;
this.expiringProfileKeyCredential = expiringProfileKeyCredential;
}
public UUID getUuid() {
return uuid;
public ServiceId getServiceId() {
return serviceId;
}
public Optional<ExpiringProfileKeyCredential> getExpiringProfileKeyCredential() {
@@ -57,12 +57,12 @@ public final class GroupCandidate {
}
public GroupCandidate withoutExpiringProfileKeyCredential() {
return expiringProfileKeyCredential.isPresent() ? new GroupCandidate(uuid, Optional.empty())
return expiringProfileKeyCredential.isPresent() ? new GroupCandidate(serviceId, Optional.empty())
: this;
}
public GroupCandidate withExpiringProfileKeyCredential(ExpiringProfileKeyCredential expiringProfileKeyCredential) {
return new GroupCandidate(uuid, Optional.of(expiringProfileKeyCredential));
return new GroupCandidate(serviceId, Optional.of(expiringProfileKeyCredential));
}
@Override
@@ -72,11 +72,11 @@ public final class GroupCandidate {
}
GroupCandidate other = (GroupCandidate) obj;
return other.uuid == uuid;
return other.serviceId.equals(serviceId);
}
@Override
public int hashCode() {
return uuid.hashCode();
return serviceId.hashCode();
}
}

74
libsignal/service/src/main/java/org/whispersystems/signalservice/api/groupsv2/GroupChangeReconstruct.java
View File

@@ -60,30 +60,30 @@ public final class GroupChangeReconstruct {
Set<ByteString> fromStateMemberUuids = membersToSetOfUuids(fromState.getMembersList());
Set<ByteString> toStateMemberUuids = membersToSetOfUuids(toState.getMembersList());
Set<ByteString> pendingMembersListA = pendingMembersToSetOfUuids(fromState.getPendingMembersList());
Set<ByteString> pendingMembersListB = pendingMembersToSetOfUuids(toState.getPendingMembersList());
Set<ByteString> pendingMembersListA = pendingMembersToSetOfServiceIds(fromState.getPendingMembersList());
Set<ByteString> pendingMembersListB = pendingMembersToSetOfServiceIds(toState.getPendingMembersList());
Set<ByteString> requestingMembersListA = requestingMembersToSetOfUuids(fromState.getRequestingMembersList());
Set<ByteString> requestingMembersListB = requestingMembersToSetOfUuids(toState.getRequestingMembersList());
Set<ByteString> bannedMembersListA = bannedMembersToSetOfUuids(fromState.getBannedMembersList());
Set<ByteString> bannedMembersListB = bannedMembersToSetOfUuids(toState.getBannedMembersList());
Set<ByteString> bannedMembersListA = bannedMembersToSetOfServiceIds(fromState.getBannedMembersList());
Set<ByteString> bannedMembersListB = bannedMembersToSetOfServiceIds(toState.getBannedMembersList());
Set<ByteString> removedPendingMemberUuids = subtract(pendingMembersListA, pendingMembersListB);
Set<ByteString> removedRequestingMemberUuids = subtract(requestingMembersListA, requestingMembersListB);
Set<ByteString> newPendingMemberUuids = subtract(pendingMembersListB, pendingMembersListA);
Set<ByteString> newRequestingMemberUuids = subtract(requestingMembersListB, requestingMembersListA);
Set<ByteString> removedMemberUuids = subtract(fromStateMemberUuids, toStateMemberUuids);
Set<ByteString> newMemberUuids = subtract(toStateMemberUuids, fromStateMemberUuids);
Set<ByteString> removedBannedMemberUuids = subtract(bannedMembersListA, bannedMembersListB);
Set<ByteString> newBannedMemberUuids = subtract(bannedMembersListB, bannedMembersListA);
Set<ByteString> removedPendingMemberServiceIds = subtract(pendingMembersListA, pendingMembersListB);
Set<ByteString> removedRequestingMemberUuids = subtract(requestingMembersListA, requestingMembersListB);
Set<ByteString> newPendingMemberServiceIds = subtract(pendingMembersListB, pendingMembersListA);
Set<ByteString> newRequestingMemberUuids = subtract(requestingMembersListB, requestingMembersListA);
Set<ByteString> removedMemberUuids = subtract(fromStateMemberUuids, toStateMemberUuids);
Set<ByteString> newMemberUuids = subtract(toStateMemberUuids, fromStateMemberUuids);
Set<ByteString> removedBannedMemberServiceIds = subtract(bannedMembersListA, bannedMembersListB);
Set<ByteString> newBannedMemberServiceIds = subtract(bannedMembersListB, bannedMembersListA);
Set<ByteString> addedByInvitationUuids = intersect(newMemberUuids, removedPendingMemberUuids);
Set<ByteString> addedByInvitationUuids = intersect(newMemberUuids, removedPendingMemberServiceIds);
Set<ByteString> addedByRequestApprovalUuids = intersect(newMemberUuids, removedRequestingMemberUuids);
Set<DecryptedMember> addedMembersByInvitation = intersectByUUID(toState.getMembersList(), addedByInvitationUuids);
Set<DecryptedMember> addedMembersByRequestApproval = intersectByUUID(toState.getMembersList(), addedByRequestApprovalUuids);
Set<DecryptedMember> addedMembers = intersectByUUID(toState.getMembersList(), subtract(newMemberUuids, addedByInvitationUuids, addedByRequestApprovalUuids));
Set<DecryptedPendingMember> uninvitedMembers = intersectPendingByUUID(fromState.getPendingMembersList(), subtract(removedPendingMemberUuids, addedByInvitationUuids));
Set<DecryptedPendingMember> uninvitedMembers = intersectPendingByServiceId(fromState.getPendingMembersList(), subtract(removedPendingMemberServiceIds, addedByInvitationUuids));
Set<DecryptedRequestingMember> rejectedRequestMembers = intersectRequestingByUUID(fromState.getRequestingMembersList(), subtract(removedRequestingMemberUuids, addedByRequestApprovalUuids));
for (DecryptedMember member : intersectByUUID(fromState.getMembersList(), removedMemberUuids)) {
@@ -100,18 +100,18 @@ public final class GroupChangeReconstruct {
for (DecryptedPendingMember uninvitedMember : uninvitedMembers) {
builder.addDeletePendingMembers(DecryptedPendingMemberRemoval.newBuilder()
.setUuid(uninvitedMember.getUuid())
.setServiceIdBinary(uninvitedMember.getServiceIdBinary())
.setUuidCipherText(uninvitedMember.getUuidCipherText()));
}
for (DecryptedPendingMember invitedMember : intersectPendingByUUID(toState.getPendingMembersList(), newPendingMemberUuids)) {
for (DecryptedPendingMember invitedMember : intersectPendingByServiceId(toState.getPendingMembersList(), newPendingMemberServiceIds)) {
builder.addNewPendingMembers(invitedMember);
}
Set<ByteString> consistentMemberUuids = intersect(fromStateMemberUuids, toStateMemberUuids);
Set<DecryptedMember> changedMembers = intersectByUUID(subtract(toState.getMembersList(), fromState.getMembersList()), consistentMemberUuids);
Map<ByteString, DecryptedMember> membersUuidMap = uuidMap(fromState.getMembersList());
Map<ByteString, DecryptedBannedMember> bannedMembersUuidMap = bannedUuidMap(toState.getBannedMembersList());
Set<ByteString> consistentMemberUuids = intersect(fromStateMemberUuids, toStateMemberUuids);
Set<DecryptedMember> changedMembers = intersectByUUID(subtract(toState.getMembersList(), fromState.getMembersList()), consistentMemberUuids);
Map<ByteString, DecryptedMember> membersUuidMap = uuidMap(fromState.getMembersList());
Map<ByteString, DecryptedBannedMember> bannedMembersServiceIdMap = bannedServiceIdMap(toState.getBannedMembersList());
for (DecryptedMember newState : changedMembers) {
DecryptedMember oldState = membersUuidMap.get(newState.getUuid());
@@ -148,13 +148,13 @@ public final class GroupChangeReconstruct {
builder.setNewInviteLinkPassword(toState.getInviteLinkPassword());
}
for (ByteString uuid : removedBannedMemberUuids) {
builder.addDeleteBannedMembers(DecryptedBannedMember.newBuilder().setUuid(uuid).build());
for (ByteString serviceIdBinary : removedBannedMemberServiceIds) {
builder.addDeleteBannedMembers(DecryptedBannedMember.newBuilder().setServiceIdBinary(serviceIdBinary).build());
}
for (ByteString uuid : newBannedMemberUuids) {
DecryptedBannedMember.Builder newBannedBuilder = DecryptedBannedMember.newBuilder().setUuid(uuid);
DecryptedBannedMember bannedMember = bannedMembersUuidMap.get(uuid);
for (ByteString serviceIdBinary : newBannedMemberServiceIds) {
DecryptedBannedMember.Builder newBannedBuilder = DecryptedBannedMember.newBuilder().setServiceIdBinary(serviceIdBinary);
DecryptedBannedMember bannedMember = bannedMembersServiceIdMap.get(serviceIdBinary);
if (bannedMember != null) {
newBannedBuilder.setTimestamp(bannedMember.getTimestamp());
}
@@ -173,10 +173,10 @@ public final class GroupChangeReconstruct {
return map;
}
private static Map<ByteString, DecryptedBannedMember> bannedUuidMap(List<DecryptedBannedMember> membersList) {
private static Map<ByteString, DecryptedBannedMember> bannedServiceIdMap(List<DecryptedBannedMember> membersList) {
Map<ByteString, DecryptedBannedMember> map = new LinkedHashMap<>(membersList.size());
for (DecryptedBannedMember member : membersList) {
map.put(member.getUuid(), member);
map.put(member.getServiceIdBinary(), member);
}
return map;
}
@@ -190,10 +190,10 @@ public final class GroupChangeReconstruct {
return result;
}
private static Set<DecryptedPendingMember> intersectPendingByUUID(Collection<DecryptedPendingMember> members, Set<ByteString> uuids) {
private static Set<DecryptedPendingMember> intersectPendingByServiceId(Collection<DecryptedPendingMember> members, Set<ByteString> serviceIds) {
Set<DecryptedPendingMember> result = new LinkedHashSet<>(members.size());
for (DecryptedPendingMember member : members) {
if (uuids.contains(member.getUuid()))
if (serviceIds.contains(member.getServiceIdBinary()))
result.add(member);
}
return result;
@@ -208,12 +208,12 @@ public final class GroupChangeReconstruct {
return result;
}
private static Set<ByteString> pendingMembersToSetOfUuids(Collection<DecryptedPendingMember> pendingMembers) {
Set<ByteString> uuids = new LinkedHashSet<>(pendingMembers.size());
private static Set<ByteString> pendingMembersToSetOfServiceIds(Collection<DecryptedPendingMember> pendingMembers) {
Set<ByteString> serviceIds = new LinkedHashSet<>(pendingMembers.size());
for (DecryptedPendingMember pendingMember : pendingMembers) {
uuids.add(pendingMember.getUuid());
serviceIds.add(pendingMember.getServiceIdBinary());
}
return uuids;
return serviceIds;
}
private static Set<ByteString> requestingMembersToSetOfUuids(Collection<DecryptedRequestingMember> requestingMembers) {
@@ -232,12 +232,12 @@ public final class GroupChangeReconstruct {
return uuids;
}
private static Set<ByteString> bannedMembersToSetOfUuids(Collection<DecryptedBannedMember> bannedMembers) {
Set<ByteString> uuids = new LinkedHashSet<>(bannedMembers.size());
private static Set<ByteString> bannedMembersToSetOfServiceIds(Collection<DecryptedBannedMember> bannedMembers) {
Set<ByteString> serviceIds = new LinkedHashSet<>(bannedMembers.size());
for (DecryptedBannedMember bannedMember : bannedMembers) {
uuids.add(bannedMember.getUuid());
serviceIds.add(bannedMember.getServiceIdBinary());
}
return uuids;
return serviceIds;
}
private static <T> Set<T> subtract(Collection<T> a, Collection<T> b) {

56
libsignal/service/src/main/java/org/whispersystems/signalservice/api/groupsv2/GroupChangeUtil.java
View File

@@ -107,17 +107,17 @@ public final class GroupChangeUtil {
DecryptedGroupChange conflictingChange,
ChangeSetModifier changeSetModifier)
{
HashMap<ByteString, DecryptedMember> fullMembersByUuid = new HashMap<>(groupState.getMembersCount());
HashMap<ByteString, DecryptedPendingMember> pendingMembersByUuid = new HashMap<>(groupState.getPendingMembersCount());
HashMap<ByteString, DecryptedRequestingMember> requestingMembersByUuid = new HashMap<>(groupState.getMembersCount());
HashMap<ByteString, DecryptedBannedMember> bannedMembersByUuid = new HashMap<>(groupState.getBannedMembersCount());
HashMap<ByteString, DecryptedMember> fullMembersByUuid = new HashMap<>(groupState.getMembersCount());
HashMap<ByteString, DecryptedPendingMember> pendingMembersByServiceId = new HashMap<>(groupState.getPendingMembersCount());
HashMap<ByteString, DecryptedRequestingMember> requestingMembersByUuid = new HashMap<>(groupState.getMembersCount());
HashMap<ByteString, DecryptedBannedMember> bannedMembersByServiceId = new HashMap<>(groupState.getBannedMembersCount());
for (DecryptedMember member : groupState.getMembersList()) {
fullMembersByUuid.put(member.getUuid(), member);
}
for (DecryptedPendingMember member : groupState.getPendingMembersList()) {
pendingMembersByUuid.put(member.getUuid(), member);
pendingMembersByServiceId.put(member.getServiceIdBinary(), member);
}
for (DecryptedRequestingMember member : groupState.getRequestingMembersList()) {
@@ -125,33 +125,33 @@ public final class GroupChangeUtil {
}
for (DecryptedBannedMember member : groupState.getBannedMembersList()) {
bannedMembersByUuid.put(member.getUuid(), member);
bannedMembersByServiceId.put(member.getServiceIdBinary(), member);
}
resolveField3AddMembers (conflictingChange, changeSetModifier, fullMembersByUuid, pendingMembersByUuid);
resolveField3AddMembers (conflictingChange, changeSetModifier, fullMembersByUuid, pendingMembersByServiceId);
resolveField4DeleteMembers (conflictingChange, changeSetModifier, fullMembersByUuid);
resolveField5ModifyMemberRoles (conflictingChange, changeSetModifier, fullMembersByUuid);
resolveField6ModifyProfileKeys (conflictingChange, changeSetModifier, fullMembersByUuid);
resolveField7AddPendingMembers (conflictingChange, changeSetModifier, fullMembersByUuid, pendingMembersByUuid);
resolveField8DeletePendingMembers (conflictingChange, changeSetModifier, pendingMembersByUuid);
resolveField9PromotePendingMembers (conflictingChange, changeSetModifier, pendingMembersByUuid);
resolveField7AddPendingMembers (conflictingChange, changeSetModifier, fullMembersByUuid, pendingMembersByServiceId);
resolveField8DeletePendingMembers (conflictingChange, changeSetModifier, pendingMembersByServiceId);
resolveField9PromotePendingMembers (conflictingChange, changeSetModifier, pendingMembersByServiceId);
resolveField10ModifyTitle (groupState, conflictingChange, changeSetModifier);
resolveField11ModifyAvatar (groupState, conflictingChange, changeSetModifier);
resolveField12modifyDisappearingMessagesTimer(groupState, conflictingChange, changeSetModifier);
resolveField13modifyAttributesAccess (groupState, conflictingChange, changeSetModifier);
resolveField14modifyAttributesAccess (groupState, conflictingChange, changeSetModifier);
resolveField15modifyAddFromInviteLinkAccess (groupState, conflictingChange, changeSetModifier);
resolveField16AddRequestingMembers (conflictingChange, changeSetModifier, fullMembersByUuid, pendingMembersByUuid);
resolveField16AddRequestingMembers (conflictingChange, changeSetModifier, fullMembersByUuid, pendingMembersByServiceId);
resolveField17DeleteMembers (conflictingChange, changeSetModifier, requestingMembersByUuid);
resolveField18PromoteRequestingMembers (conflictingChange, changeSetModifier, requestingMembersByUuid);
resolveField20ModifyDescription (groupState, conflictingChange, changeSetModifier);
resolveField21ModifyAnnouncementsOnly (groupState, conflictingChange, changeSetModifier);
resolveField22AddBannedMembers (conflictingChange, changeSetModifier, bannedMembersByUuid);
resolveField23DeleteBannedMembers (conflictingChange, changeSetModifier, bannedMembersByUuid);
resolveField22AddBannedMembers (conflictingChange, changeSetModifier, bannedMembersByServiceId);
resolveField23DeleteBannedMembers (conflictingChange, changeSetModifier, bannedMembersByServiceId);
resolveField24PromotePendingPniAciMembers (conflictingChange, changeSetModifier, fullMembersByUuid);
}
private static void resolveField3AddMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedMember> fullMembersByUuid, HashMap<ByteString, DecryptedPendingMember> pendingMembersByUuid) {
private static void resolveField3AddMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedMember> fullMembersByUuid, HashMap<ByteString, DecryptedPendingMember> pendingMembersByServiceId) {
List<DecryptedMember> newMembersList = conflictingChange.getNewMembersList();
for (int i = newMembersList.size() - 1; i >= 0; i--) {
@@ -159,7 +159,7 @@ public final class GroupChangeUtil {
if (fullMembersByUuid.containsKey(member.getUuid())) {
result.removeAddMembers(i);
} else if (pendingMembersByUuid.containsKey(member.getUuid())) {
} else if (pendingMembersByServiceId.containsKey(member.getUuid())) {
result.moveAddToPromote(i);
}
}
@@ -203,37 +203,37 @@ public final class GroupChangeUtil {
}
}
private static void resolveField7AddPendingMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedMember> fullMembersByUuid, HashMap<ByteString, DecryptedPendingMember> pendingMembersByUuid) {
private static void resolveField7AddPendingMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedMember> fullMembersByUuid, HashMap<ByteString, DecryptedPendingMember> pendingMembersByServiceId) {
List<DecryptedPendingMember> newPendingMembersList = conflictingChange.getNewPendingMembersList();
for (int i = newPendingMembersList.size() - 1; i >= 0; i--) {
DecryptedPendingMember member = newPendingMembersList.get(i);
if (fullMembersByUuid.containsKey(member.getUuid()) || pendingMembersByUuid.containsKey(member.getUuid())) {
if (fullMembersByUuid.containsKey(member.getServiceIdBinary()) || pendingMembersByServiceId.containsKey(member.getServiceIdBinary())) {
result.removeAddPendingMembers(i);
}
}
}
private static void resolveField8DeletePendingMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedPendingMember> pendingMembersByUuid) {
private static void resolveField8DeletePendingMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedPendingMember> pendingMembersByServiceId) {
List<DecryptedPendingMemberRemoval> deletePendingMembersList = conflictingChange.getDeletePendingMembersList();
for (int i = deletePendingMembersList.size() - 1; i >= 0; i--) {
DecryptedPendingMemberRemoval member = deletePendingMembersList.get(i);
if (!pendingMembersByUuid.containsKey(member.getUuid())) {
if (!pendingMembersByServiceId.containsKey(member.getServiceIdBinary())) {
result.removeDeletePendingMembers(i);
}
}
}
private static void resolveField9PromotePendingMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedPendingMember> pendingMembersByUuid) {
private static void resolveField9PromotePendingMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedPendingMember> pendingMembersByServiceId) {
List<DecryptedMember> promotePendingMembersList = conflictingChange.getPromotePendingMembersList();
for (int i = promotePendingMembersList.size() - 1; i >= 0; i--) {
DecryptedMember member = promotePendingMembersList.get(i);
if (!pendingMembersByUuid.containsKey(member.getUuid())) {
if (!pendingMembersByServiceId.containsKey(member.getUuid())) {
result.removePromotePendingMembers(i);
}
}
@@ -275,7 +275,7 @@ public final class GroupChangeUtil {
}
}
private static void resolveField16AddRequestingMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedMember> fullMembersByUuid, HashMap<ByteString, DecryptedPendingMember> pendingMembersByUuid) {
private static void resolveField16AddRequestingMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedMember> fullMembersByUuid, HashMap<ByteString, DecryptedPendingMember> pendingMembersByServiceId) {
List<DecryptedRequestingMember> newMembersList = conflictingChange.getNewRequestingMembersList();
for (int i = newMembersList.size() - 1; i >= 0; i--) {
@@ -283,8 +283,8 @@ public final class GroupChangeUtil {
if (fullMembersByUuid.containsKey(member.getUuid())) {
result.removeAddRequestingMembers(i);
} else if (pendingMembersByUuid.containsKey(member.getUuid())) {
result.moveAddRequestingMembersToPromote(i);
} else if (pendingMembersByServiceId.containsKey(member.getUuid())) {
result.moveAddRequestingMembersToPromote(i);
}
}
}
@@ -331,25 +331,25 @@ public final class GroupChangeUtil {
}
}
private static void resolveField22AddBannedMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedBannedMember> bannedMembersByUuid) {
private static void resolveField22AddBannedMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedBannedMember> bannedMembersByServiceId) {
List<DecryptedBannedMember> newBannedMembersList = conflictingChange.getNewBannedMembersList();
for (int i = newBannedMembersList.size() - 1; i >= 0; i--) {
DecryptedBannedMember member = newBannedMembersList.get(i);
if (bannedMembersByUuid.containsKey(member.getUuid())) {
if (bannedMembersByServiceId.containsKey(member.getServiceIdBinary())) {
result.removeAddBannedMembers(i);
}
}
}
private static void resolveField23DeleteBannedMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedBannedMember> bannedMembersByUuid) {
private static void resolveField23DeleteBannedMembers(DecryptedGroupChange conflictingChange, ChangeSetModifier result, HashMap<ByteString, DecryptedBannedMember> bannedMembersByServiceId) {
List<DecryptedBannedMember> deleteBannedMembersList = conflictingChange.getDeleteBannedMembersList();
for (int i = deleteBannedMembersList.size() - 1; i >= 0; i--) {
DecryptedBannedMember member = deleteBannedMembersList.get(i);
if (!bannedMembersByUuid.containsKey(member.getUuid())) {
if (!bannedMembersByServiceId.containsKey(member.getServiceIdBinary())) {
result.removeDeleteBannedMembers(i);
}
}

9
libsignal/service/src/main/java/org/whispersystems/signalservice/api/groupsv2/GroupsV2Api.java
View File

@@ -21,7 +21,8 @@ import org.signal.storageservice.protos.groups.GroupJoinInfo;
import org.signal.storageservice.protos.groups.local.DecryptedGroup;
import org.signal.storageservice.protos.groups.local.DecryptedGroupChange;
import org.signal.storageservice.protos.groups.local.DecryptedGroupJoinInfo;
import org.whispersystems.signalservice.api.push.ServiceId;
import org.whispersystems.signalservice.api.push.ServiceId.ACI;
import org.whispersystems.signalservice.api.push.ServiceId.PNI;
import org.whispersystems.signalservice.internal.push.PushServiceSocket;
import org.whispersystems.signalservice.internal.push.exceptions.ForbiddenException;
@@ -55,15 +56,15 @@ public class GroupsV2Api {
/**
* Create an auth token from a credential response.
*/
public GroupsV2AuthorizationString getGroupsV2AuthorizationString(ServiceId aci,
ServiceId pni,
public GroupsV2AuthorizationString getGroupsV2AuthorizationString(ACI aci,
PNI pni,
long redemptionTimeSeconds,
GroupSecretParams groupSecretParams,
AuthCredentialWithPniResponse authCredentialWithPniResponse)
throws VerificationFailedException
{
ClientZkAuthOperations authOperations = groupsOperations.getAuthOperations();
AuthCredentialWithPni authCredentialWithPni = authOperations.receiveAuthCredentialWithPni(aci.getRawUuid(), pni.getRawUuid(), redemptionTimeSeconds, authCredentialWithPniResponse);
AuthCredentialWithPni authCredentialWithPni = authOperations.receiveAuthCredentialWithPniAsServiceId(aci.getLibSignalAci(), pni.getLibSignalPni(), redemptionTimeSeconds, authCredentialWithPniResponse);
AuthCredentialPresentation authCredentialPresentation = authOperations.createAuthCredentialPresentation(new SecureRandom(), groupSecretParams, authCredentialWithPni);
return new GroupsV2AuthorizationString(groupSecretParams, authCredentialPresentation);

203
libsignal/service/src/main/java/org/whispersystems/signalservice/api/groupsv2/GroupsV2Operations.java
View File

@@ -40,6 +40,7 @@ import org.signal.storageservice.protos.groups.local.DecryptedString;
import org.signal.storageservice.protos.groups.local.DecryptedTimer;
import org.signal.storageservice.protos.groups.local.EnabledState;
import org.whispersystems.signalservice.api.push.ServiceId.ACI;
import org.whispersystems.signalservice.api.push.ServiceId.PNI;
import org.whispersystems.signalservice.api.push.ServiceId;
import org.whispersystems.signalservice.api.util.UuidUtil;
@@ -119,7 +120,7 @@ public final class GroupsV2Operations {
if (expiringProfileKeyCredential != null) {
group.addMembers(groupOperations.member(expiringProfileKeyCredential, memberRole));
} else {
group.addPendingMembers(groupOperations.invitee(credential.getUuid(), memberRole));
group.addPendingMembers(groupOperations.invitee(credential.getServiceId(), memberRole));
}
}
@@ -165,13 +166,13 @@ public final class GroupsV2Operations {
return GroupChange.Actions.newBuilder().setModifyDescription(createModifyGroupDescriptionAction(description));
}
public GroupChange.Actions.Builder createModifyGroupMembershipChange(Set<GroupCandidate> membersToAdd, Set<UUID> bannedMembers, UUID selfUuid) {
public GroupChange.Actions.Builder createModifyGroupMembershipChange(Set<GroupCandidate> membersToAdd, Set<ServiceId> bannedMembers, ACI selfAci) {
final GroupOperations groupOperations = forGroup(groupSecretParams);
Set<UUID> membersToUnban = membersToAdd.stream().map(GroupCandidate::getUuid).filter(bannedMembers::contains).collect(Collectors.toSet());
Set<ServiceId> membersToUnban = membersToAdd.stream().map(GroupCandidate::getServiceId).filter(bannedMembers::contains).collect(Collectors.toSet());
GroupChange.Actions.Builder actions = membersToUnban.isEmpty() ? GroupChange.Actions.newBuilder()
: createUnbanUuidsChange(membersToUnban);
: createUnbanServiceIdsChange(membersToUnban);
for (GroupCandidate credential : membersToAdd) {
Member.Role newMemberRole = Member.Role.DEFAULT;
@@ -184,8 +185,8 @@ public final class GroupsV2Operations {
} else {
actions.addAddPendingMembers(GroupChange.Actions.AddPendingMemberAction
.newBuilder()
.setAdded(groupOperations.invitee(credential.getUuid(), newMemberRole)
.setAddedByUserId(encryptUuid(selfUuid))));
.setAdded(groupOperations.invitee(credential.getServiceId(), newMemberRole)
.setAddedByUserId(encryptServiceId(selfAci))));
}
}
@@ -221,7 +222,7 @@ public final class GroupsV2Operations {
for (UUID uuid : requestsToRemove) {
actions.addDeleteRequestingMembers(GroupChange.Actions.DeleteRequestingMemberAction
.newBuilder()
.setDeletedUserId(encryptUuid(uuid)));
.setDeletedUserId(encryptServiceId(ACI.from(uuid))));
}
return actions;
@@ -234,7 +235,7 @@ public final class GroupsV2Operations {
actions.addPromoteRequestingMembers(GroupChange.Actions.PromoteRequestingMemberAction
.newBuilder()
.setRole(Member.Role.DEFAULT)
.setUserId(encryptUuid(uuid)));
.setUserId(encryptServiceId(ACI.from(uuid))));
}
return actions;
@@ -247,7 +248,7 @@ public final class GroupsV2Operations {
for (UUID remove: membersToRemove) {
actions.addDeleteMembers(GroupChange.Actions.DeleteMemberAction
.newBuilder()
.setDeletedUserId(encryptUuid(remove)));
.setDeletedUserId(encryptServiceId(ACI.from(remove))));
}
return actions;
@@ -259,7 +260,7 @@ public final class GroupsV2Operations {
for (UUID member : membersToMakeAdmin) {
actions.addModifyMemberRoles(GroupChange.Actions.ModifyMemberRoleAction
.newBuilder()
.setUserId(encryptUuid(member))
.setUserId(encryptServiceId(ACI.from(member)))
.setRole(Member.Role.ADMINISTRATOR));
}
@@ -361,6 +362,7 @@ public final class GroupsV2Operations {
.setAnnouncementsOnly(isAnnouncementGroup));
}
/** Note that this can only ban ACIs. */
public GroupChange.Actions.Builder createBanUuidsChange(Set<UUID> banUuids, boolean rejectJoinRequest, List<DecryptedBannedMember> bannedMembersList) {
GroupChange.Actions.Builder builder = rejectJoinRequest ? createRefuseGroupJoinRequest(banUuids, false, Collections.emptyList())
: GroupChange.Actions.newBuilder();
@@ -370,26 +372,26 @@ public final class GroupsV2Operations {
List<ByteString> unban = bannedMembersList.stream()
.sorted(Comparator.comparingLong(DecryptedBannedMember::getTimestamp))
.limit(spacesToFree)
.map(DecryptedBannedMember::getUuid)
.map(DecryptedBannedMember::getServiceIdBinary)
.collect(Collectors.toList());
for (ByteString uuid : unban) {
builder.addDeleteBannedMembers(GroupChange.Actions.DeleteBannedMemberAction.newBuilder().setDeletedUserId(encryptUuid(UuidUtil.fromByteString(uuid))));
for (ByteString serviceIdBinary : unban) {
builder.addDeleteBannedMembers(GroupChange.Actions.DeleteBannedMemberAction.newBuilder().setDeletedUserId(encryptServiceId(ServiceId.parseOrThrow(serviceIdBinary.toByteArray()))));
}
}
for (UUID uuid : banUuids) {
builder.addAddBannedMembers(GroupChange.Actions.AddBannedMemberAction.newBuilder().setAdded(BannedMember.newBuilder().setUserId(encryptUuid(uuid)).build()));
builder.addAddBannedMembers(GroupChange.Actions.AddBannedMemberAction.newBuilder().setAdded(BannedMember.newBuilder().setUserId(encryptServiceId(ACI.from(uuid))).build()));
}
return builder;
}
public GroupChange.Actions.Builder createUnbanUuidsChange(Set<UUID> banUuids) {
public GroupChange.Actions.Builder createUnbanServiceIdsChange(Set<ServiceId> serviceIds) {
GroupChange.Actions.Builder builder = GroupChange.Actions.newBuilder();
for (UUID uuid : banUuids) {
builder.addDeleteBannedMembers(GroupChange.Actions.DeleteBannedMemberAction.newBuilder().setDeletedUserId(encryptUuid(uuid)).build());
for (ServiceId serviceId : serviceIds) {
builder.addDeleteBannedMembers(GroupChange.Actions.DeleteBannedMemberAction.newBuilder().setDeletedUserId(encryptServiceId(serviceId)).build());
}
return builder;
@@ -433,8 +435,8 @@ public final class GroupsV2Operations {
.setPresentation(ByteString.copyFrom(presentation.serialize()));
}
public PendingMember.Builder invitee(UUID uuid, Member.Role role) {
UuidCiphertext uuidCiphertext = clientZkGroupCipher.encryptUuid(uuid);
public PendingMember.Builder invitee(ServiceId serviceId, Member.Role role) {
UuidCiphertext uuidCiphertext = clientZkGroupCipher.encrypt(serviceId.getLibSignalServiceId());
Member member = Member.newBuilder()
.setRole(role)
@@ -454,17 +456,17 @@ public final class GroupsV2Operations {
List<DecryptedPendingMember> decryptedPendingMembers = new ArrayList<>(pendingMembersList.size());
for (Member member : membersList) {
UUID memberUuid = decryptUuid(member.getUserId());
ACI memberAci = decryptAci(member.getUserId());
decryptedMembers.add(DecryptedMember.newBuilder()
.setUuid(UuidUtil.toByteString(memberUuid))
.setUuid(memberAci.toByteString())
.setJoinedAtRevision(member.getJoinedAtRevision())
.build());
}
for (PendingMember member : pendingMembersList) {
UUID pendingMemberUuid = decryptUuidOrUnknown(member.getMember().getUserId());
ServiceId pendingMemberServiceId = decryptServiceIdOrUnknown(member.getMember().getUserId());
decryptedPendingMembers.add(DecryptedPendingMember.newBuilder()
.setUuid(UuidUtil.toByteString(pendingMemberUuid))
.setServiceIdBinary(pendingMemberServiceId.toByteString())
.build());
}
@@ -505,7 +507,7 @@ public final class GroupsV2Operations {
}
for (BannedMember member : group.getBannedMembersList()) {
decryptedBannedMembers.add(DecryptedBannedMember.newBuilder().setUuid(decryptUuidToByteString(member.getUserId())).setTimestamp(member.getTimestamp()).build());
decryptedBannedMembers.add(DecryptedBannedMember.newBuilder().setServiceIdBinary(decryptServiceIdToBinary(member.getUserId())).setTimestamp(member.getTimestamp()).build());
}
return DecryptedGroup.newBuilder()
@@ -551,16 +553,16 @@ public final class GroupsV2Operations {
return decryptChange(actions, null);
}
public DecryptedGroupChange decryptChange(GroupChange.Actions actions, UUID source)
public DecryptedGroupChange decryptChange(GroupChange.Actions actions, ServiceId source)
throws VerificationFailedException, InvalidGroupStateException
{
DecryptedGroupChange.Builder builder = DecryptedGroupChange.newBuilder();
// Field 1
if (source != null) {
builder.setEditor(UuidUtil.toByteString(source));
builder.setEditor(source.toByteString());
} else {
builder.setEditor(decryptUuidToByteString(actions.getSourceUuid()));
builder.setEditor(decryptServiceIdToBinary(actions.getSourceUuid()));
}
// Field 2
@@ -577,35 +579,35 @@ public final class GroupsV2Operations {
// Field 4
for (GroupChange.Actions.DeleteMemberAction deleteMemberAction : actions.getDeleteMembersList()) {
builder.addDeleteMembers(decryptUuidToByteString(deleteMemberAction.getDeletedUserId()));
builder.addDeleteMembers(decryptServiceIdToBinary(deleteMemberAction.getDeletedUserId()));
}
// Field 5
for (GroupChange.Actions.ModifyMemberRoleAction modifyMemberRoleAction : actions.getModifyMemberRolesList()) {
builder.addModifyMemberRoles(DecryptedModifyMemberRole.newBuilder()
.setRole(modifyMemberRoleAction.getRole())
.setUuid(decryptUuidToByteString(modifyMemberRoleAction.getUserId())));
.setUuid(decryptServiceIdToBinary(modifyMemberRoleAction.getUserId())));
}
// Field 6
for (GroupChange.Actions.ModifyMemberProfileKeyAction modifyMemberProfileKeyAction : actions.getModifyMemberProfileKeysList()) {
try {
UUID uuid;
ACI aci;
ProfileKey profileKey;
if (modifyMemberProfileKeyAction.getUserId().isEmpty() || modifyMemberProfileKeyAction.getProfileKey().isEmpty()) {
ProfileKeyCredentialPresentation presentation = new ProfileKeyCredentialPresentation(modifyMemberProfileKeyAction.getPresentation().toByteArray());
uuid = decryptUuid(ByteString.copyFrom(presentation.getUuidCiphertext().serialize()));
profileKey = decryptProfileKey(ByteString.copyFrom(presentation.getProfileKeyCiphertext().serialize()), uuid);
aci = decryptAci(ByteString.copyFrom(presentation.getUuidCiphertext().serialize()));
profileKey = decryptProfileKey(ByteString.copyFrom(presentation.getProfileKeyCiphertext().serialize()), aci);
} else {
uuid = decryptUuid(modifyMemberProfileKeyAction.getUserId());
profileKey = decryptProfileKey(modifyMemberProfileKeyAction.getProfileKey(), uuid);
aci = decryptAci(modifyMemberProfileKeyAction.getUserId());
profileKey = decryptProfileKey(modifyMemberProfileKeyAction.getProfileKey(), aci);
}
builder.addModifiedProfileKeys(DecryptedMember.newBuilder()
.setRole(Member.Role.UNKNOWN)
.setJoinedAtRevision(-1)
.setUuid(UuidUtil.toByteString(uuid))
.setUuid(aci.toByteString())
.setProfileKey(ByteString.copyFrom(profileKey.serialize())));
} catch (InvalidInputException e) {
throw new InvalidGroupStateException(e);
@@ -617,45 +619,45 @@ public final class GroupsV2Operations {
PendingMember added = addPendingMemberAction.getAdded();
Member member = added.getMember();
ByteString uuidCipherText = member.getUserId();
UUID uuid = decryptUuidOrUnknown(uuidCipherText);
ServiceId serviceId = decryptServiceIdOrUnknown(uuidCipherText);
builder.addNewPendingMembers(DecryptedPendingMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setServiceIdBinary(serviceId.toByteString())
.setUuidCipherText(uuidCipherText)
.setRole(member.getRole())
.setAddedByUuid(decryptUuidToByteString(added.getAddedByUserId()))
.setAddedByUuid(decryptServiceIdToBinary(added.getAddedByUserId()))
.setTimestamp(added.getTimestamp()));
}
// Field 8
for (GroupChange.Actions.DeletePendingMemberAction deletePendingMemberAction : actions.getDeletePendingMembersList()) {
ByteString uuidCipherText = deletePendingMemberAction.getDeletedUserId();
UUID uuid = decryptUuidOrUnknown(uuidCipherText);
ServiceId serviceId = decryptServiceIdOrUnknown(uuidCipherText);
builder.addDeletePendingMembers(DecryptedPendingMemberRemoval.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setServiceIdBinary(serviceId.toByteString())
.setUuidCipherText(uuidCipherText));
}
// Field 9
for (GroupChange.Actions.PromotePendingMemberAction promotePendingMemberAction : actions.getPromotePendingMembersList()) {
try {
UUID uuid;
ACI aci;
ProfileKey profileKey;
if (promotePendingMemberAction.getUserId().isEmpty() || promotePendingMemberAction.getProfileKey().isEmpty()) {
ProfileKeyCredentialPresentation presentation = new ProfileKeyCredentialPresentation(promotePendingMemberAction.getPresentation().toByteArray());
uuid = decryptUuid(ByteString.copyFrom(presentation.getUuidCiphertext().serialize()));
profileKey = decryptProfileKey(ByteString.copyFrom(presentation.getProfileKeyCiphertext().serialize()), uuid);
aci = decryptAci(ByteString.copyFrom(presentation.getUuidCiphertext().serialize()));
profileKey = decryptProfileKey(ByteString.copyFrom(presentation.getProfileKeyCiphertext().serialize()), aci);
} else {
uuid = decryptUuid(promotePendingMemberAction.getUserId());
profileKey = decryptProfileKey(promotePendingMemberAction.getProfileKey(), uuid);
aci = decryptAci(promotePendingMemberAction.getUserId());
profileKey = decryptProfileKey(promotePendingMemberAction.getProfileKey(), aci);
}
builder.addPromotePendingMembers(DecryptedMember.newBuilder()
.setJoinedAtRevision(-1)
.setRole(Member.Role.DEFAULT)
.setUuid(UuidUtil.toByteString(uuid))
.setUuid(aci.toByteString())
.setProfileKey(ByteString.copyFrom(profileKey.serialize())));
} catch (InvalidInputException e) {
throw new InvalidGroupStateException(e);
@@ -700,12 +702,12 @@ public final class GroupsV2Operations {
// Field 17
for (GroupChange.Actions.DeleteRequestingMemberAction delete : actions.getDeleteRequestingMembersList()) {
builder.addDeleteRequestingMembers(decryptUuidToByteString(delete.getDeletedUserId()));
builder.addDeleteRequestingMembers(decryptServiceIdToBinary(delete.getDeletedUserId()));
}
// Field 18
for (GroupChange.Actions.PromoteRequestingMemberAction promote : actions.getPromoteRequestingMembersList()) {
builder.addPromoteRequestingMembers(DecryptedApproveMember.newBuilder().setRole(promote.getRole()).setUuid(decryptUuidToByteString(promote.getUserId())));
builder.addPromoteRequestingMembers(DecryptedApproveMember.newBuilder().setRole(promote.getRole()).setUuid(decryptServiceIdToBinary(promote.getUserId())));
}
// Field 19
@@ -725,27 +727,31 @@ public final class GroupsV2Operations {
// Field 22
for (GroupChange.Actions.AddBannedMemberAction action : actions.getAddBannedMembersList()) {
builder.addNewBannedMembers(DecryptedBannedMember.newBuilder().setUuid(decryptUuidToByteString(action.getAdded().getUserId())).setTimestamp(action.getAdded().getTimestamp()).build());
builder.addNewBannedMembers(DecryptedBannedMember.newBuilder().setServiceIdBinary(decryptServiceIdToBinary(action.getAdded().getUserId())).setTimestamp(action.getAdded().getTimestamp()).build());
}
// Field 23
for (GroupChange.Actions.DeleteBannedMemberAction action : actions.getDeleteBannedMembersList()) {
builder.addDeleteBannedMembers(DecryptedBannedMember.newBuilder().setUuid(decryptUuidToByteString(action.getDeletedUserId())).build());
builder.addDeleteBannedMembers(DecryptedBannedMember.newBuilder().setServiceIdBinary(decryptServiceIdToBinary(action.getDeletedUserId())).build());
}
// Field 24
for (GroupChange.Actions.PromotePendingPniAciMemberProfileKeyAction promotePendingPniAciMemberAction : actions.getPromotePendingPniAciMembersList()) {
UUID uuid = decryptUuid(promotePendingPniAciMemberAction.getUserId());
UUID pni = decryptUuid(promotePendingPniAciMemberAction.getPni());
ProfileKey profileKey = decryptProfileKey(promotePendingPniAciMemberAction.getProfileKey(), uuid);
ACI aci = decryptAci(promotePendingPniAciMemberAction.getUserId());
ServiceId pni = decryptServiceId(promotePendingPniAciMemberAction.getPni());
ProfileKey profileKey = decryptProfileKey(promotePendingPniAciMemberAction.getProfileKey(), aci);
builder.setEditor(UuidUtil.toByteString(uuid))
if (!(pni instanceof PNI)) {
throw new InvalidGroupStateException();
}
builder.setEditor(aci.toByteString())
.addPromotePendingPniAciMembers(DecryptedMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setUuid(aci.toByteString())
.setRole(Member.Role.DEFAULT)
.setProfileKey(ByteString.copyFrom(profileKey.serialize()))
.setJoinedAtRevision(actions.getRevision())
.setPni(UuidUtil.toByteString(pni)));
.setPni(pni.toByteString()));
}
return builder.build();
@@ -767,20 +773,26 @@ public final class GroupsV2Operations {
throws InvalidGroupStateException, VerificationFailedException, InvalidInputException
{
if (member.getPresentation().isEmpty()) {
UUID uuid = decryptUuid(member.getUserId());
ACI aci = decryptAci(member.getUserId());
return DecryptedMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setUuid(aci.toByteString())
.setJoinedAtRevision(member.getJoinedAtRevision())
.setProfileKey(decryptProfileKeyToByteString(member.getProfileKey(), uuid))
.setProfileKey(decryptProfileKeyToByteString(member.getProfileKey(), aci))
.setRole(member.getRole());
} else {
ProfileKeyCredentialPresentation profileKeyCredentialPresentation = new ProfileKeyCredentialPresentation(member.getPresentation().toByteArray());
UUID uuid = clientZkGroupCipher.decryptUuid(profileKeyCredentialPresentation.getUuidCiphertext());
ProfileKey profileKey = clientZkGroupCipher.decryptProfileKey(profileKeyCredentialPresentation.getProfileKeyCiphertext(), uuid);
ServiceId serviceId = ServiceId.fromLibSignal(clientZkGroupCipher.decrypt(profileKeyCredentialPresentation.getUuidCiphertext()));
if (!(serviceId instanceof ACI)) {
throw new InvalidGroupStateException();
}
ACI serviceIdAsAci = (ACI)serviceId;
ProfileKey profileKey = clientZkGroupCipher.decryptProfileKey(profileKeyCredentialPresentation.getProfileKeyCiphertext(), serviceIdAsAci.getLibSignalAci());
return DecryptedMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setUuid(serviceIdAsAci.toByteString())
.setJoinedAtRevision(member.getJoinedAtRevision())
.setProfileKey(ByteString.copyFrom(profileKey.serialize()))
.setRole(member.getRole());
@@ -791,8 +803,8 @@ public final class GroupsV2Operations {
throws InvalidGroupStateException, VerificationFailedException
{
ByteString userIdCipherText = member.getMember().getUserId();
UUID uuid = decryptUuidOrUnknown(userIdCipherText);
UUID addedBy = decryptUuid(member.getAddedByUserId());
ServiceId serviceId = decryptServiceIdOrUnknown(userIdCipherText);
ACI addedBy = decryptAci(member.getAddedByUserId());
Member.Role role = member.getMember().getRole();
@@ -801,9 +813,9 @@ public final class GroupsV2Operations {
}
return DecryptedPendingMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setServiceIdBinary(serviceId.toByteString())
.setUuidCipherText(userIdCipherText)
.setAddedByUuid(UuidUtil.toByteString(addedBy))
.setAddedByUuid(addedBy.toByteString())
.setRole(role)
.setTimestamp(member.getTimestamp())
.build();
@@ -813,11 +825,11 @@ public final class GroupsV2Operations {
throws InvalidGroupStateException, VerificationFailedException
{
if (member.getPresentation().isEmpty()) {
UUID uuid = decryptUuid(member.getUserId());
ACI aci = decryptAci(member.getUserId());
return DecryptedRequestingMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setProfileKey(decryptProfileKeyToByteString(member.getProfileKey(), uuid))
.setUuid(aci.toByteString())
.setProfileKey(decryptProfileKeyToByteString(member.getProfileKey(), aci))
.setTimestamp(member.getTimestamp())
.build();
} else {
@@ -828,54 +840,67 @@ public final class GroupsV2Operations {
throw new InvalidGroupStateException(e);
}
UUID uuid = clientZkGroupCipher.decryptUuid(profileKeyCredentialPresentation.getUuidCiphertext());
ProfileKey profileKey = clientZkGroupCipher.decryptProfileKey(profileKeyCredentialPresentation.getProfileKeyCiphertext(), uuid);
ServiceId serviceId = ServiceId.fromLibSignal(clientZkGroupCipher.decrypt(profileKeyCredentialPresentation.getUuidCiphertext()));
if (!(serviceId instanceof ACI)) {
throw new InvalidGroupStateException();
}
ACI serviceIdAsAci = (ACI)serviceId;
ProfileKey profileKey = clientZkGroupCipher.decryptProfileKey(profileKeyCredentialPresentation.getProfileKeyCiphertext(), serviceIdAsAci.getLibSignalAci());
return DecryptedRequestingMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setUuid(serviceIdAsAci.toByteString())
.setProfileKey(ByteString.copyFrom(profileKey.serialize()))
.build();
}
}
private ProfileKey decryptProfileKey(ByteString profileKey, UUID uuid) throws VerificationFailedException, InvalidGroupStateException {
private ProfileKey decryptProfileKey(ByteString profileKey, ACI aci) throws VerificationFailedException, InvalidGroupStateException {
try {
ProfileKeyCiphertext profileKeyCiphertext = new ProfileKeyCiphertext(profileKey.toByteArray());
return clientZkGroupCipher.decryptProfileKey(profileKeyCiphertext, uuid);
return clientZkGroupCipher.decryptProfileKey(profileKeyCiphertext, aci.getLibSignalAci());
} catch (InvalidInputException e) {
throw new InvalidGroupStateException(e);
}
}
private ByteString decryptProfileKeyToByteString(ByteString profileKey, UUID uuid) throws VerificationFailedException, InvalidGroupStateException {
return ByteString.copyFrom(decryptProfileKey(profileKey, uuid).serialize());
private ByteString decryptProfileKeyToByteString(ByteString profileKey, ACI aci) throws VerificationFailedException, InvalidGroupStateException {
return ByteString.copyFrom(decryptProfileKey(profileKey, aci).serialize());
}
private ByteString decryptUuidToByteString(ByteString userId) throws InvalidGroupStateException, VerificationFailedException {
return UuidUtil.toByteString(decryptUuid(userId));
private ByteString decryptServiceIdToBinary(ByteString userId) throws InvalidGroupStateException, VerificationFailedException {
return decryptServiceId(userId).toByteString();
}
// Visible for Testing
public ByteString encryptUuid(UUID uuid) {
return ByteString.copyFrom(clientZkGroupCipher.encryptUuid(uuid).serialize());
public ByteString encryptServiceId(ServiceId serviceId) {
return ByteString.copyFrom(clientZkGroupCipher.encrypt(serviceId.getLibSignalServiceId()).serialize());
}
private UUID decryptUuid(ByteString userId) throws InvalidGroupStateException, VerificationFailedException {
private ServiceId decryptServiceId(ByteString userId) throws InvalidGroupStateException, VerificationFailedException {
try {
return clientZkGroupCipher.decryptUuid(new UuidCiphertext(userId.toByteArray()));
return ServiceId.fromLibSignal(clientZkGroupCipher.decrypt(new UuidCiphertext(userId.toByteArray())));
} catch (InvalidInputException e) {
throw new InvalidGroupStateException(e);
}
}
private ACI decryptAci(ByteString userId) throws InvalidGroupStateException, VerificationFailedException {
ServiceId result = decryptServiceId(userId);
if (result instanceof ACI) {
return (ACI)result;
}
throw new InvalidGroupStateException();
}
/**
* Attempts to decrypt a UUID, but will return {@link #UNKNOWN_UUID} if it cannot.
* Attempts to decrypt a UUID, but will return an ACI of {@link #UNKNOWN_UUID} if it cannot.
*/
private UUID decryptUuidOrUnknown(ByteString userId) {
private ServiceId decryptServiceIdOrUnknown(ByteString userId) {
try {
return clientZkGroupCipher.decryptUuid(new UuidCiphertext(userId.toByteArray()));
return ServiceId.fromLibSignal(clientZkGroupCipher.decrypt(new UuidCiphertext(userId.toByteArray())));
} catch (InvalidInputException | VerificationFailedException e) {
return UNKNOWN_UUID;
return ACI.UNKNOWN;
}
}
@@ -977,10 +1002,10 @@ public final class GroupsV2Operations {
return GroupChange.Actions.parseFrom(groupChange.getActions());
}
public GroupChange.Actions.Builder createChangeMemberRole(UUID uuid, Member.Role role) {
public GroupChange.Actions.Builder createChangeMemberRole(ACI memberAci, Member.Role role) {
return GroupChange.Actions.newBuilder()
.addModifyMemberRoles(GroupChange.Actions.ModifyMemberRoleAction.newBuilder()
.setUserId(encryptUuid(uuid))
.setUserId(encryptServiceId(memberAci))
.setRole(role));
}
@@ -990,7 +1015,7 @@ public final class GroupsV2Operations {
GroupChange.Actions.AddMemberAction addMember = addMembers.get(i);
ProfileKeyCredentialPresentation profileKeyCredentialPresentation = new ProfileKeyCredentialPresentation(addMember.getAdded().getPresentation().toByteArray());
ids.add(ACI.from(clientZkGroupCipher.decryptUuid(profileKeyCredentialPresentation.getUuidCiphertext())));
ids.add(ServiceId.fromLibSignal(clientZkGroupCipher.decrypt(profileKeyCredentialPresentation.getUuidCiphertext())));
}
return ids;
}

43
libsignal/service/src/main/java/org/whispersystems/signalservice/api/push/ServiceId.kt
View File

@@ -19,8 +19,17 @@ import org.signal.libsignal.protocol.ServiceId.Pni as LibSignalPni
* The only times you truly know, and the only times you should actually care, is during CDS refreshes or specific inbound messages
* that link them together.
*/
sealed class ServiceId(@JvmField protected val libsignalServiceId: LibSignalServiceId) {
sealed class ServiceId(val libSignalServiceId: LibSignalServiceId) {
companion object {
@JvmStatic
fun fromLibSignal(serviceId: LibSignalServiceId): ServiceId {
return when (serviceId) {
is LibSignalAci -> ACI(serviceId)
is LibSignalPni -> PNI(serviceId)
else -> throw IllegalArgumentException("Unknown libsignal ServiceId type!")
}
}
/** Parses a ServiceId serialized as a string. Returns null if the ServiceId is invalid. */
@JvmStatic
fun parseOrNull(raw: String?): ServiceId? {
@@ -29,11 +38,7 @@ sealed class ServiceId(@JvmField protected val libsignalServiceId: LibSignalServ
}
return try {
when (val serviceId = LibSignalServiceId.parseFromString(raw)) {
is LibSignalAci -> ACI(serviceId)
is LibSignalPni -> PNI(serviceId)
else -> null
}
fromLibSignal(LibSignalServiceId.parseFromString(raw))
} catch (e: IllegalArgumentException) {
null
} catch (e: InvalidServiceIdException) {
@@ -49,11 +54,7 @@ sealed class ServiceId(@JvmField protected val libsignalServiceId: LibSignalServ
}
return try {
return when (val serviceId = LibSignalServiceId.parseFromBinary(raw)) {
is LibSignalAci -> ACI.from(serviceId.rawUUID)
is LibSignalPni -> PNI.from(serviceId.rawUUID)
else -> null
}
fromLibSignal(LibSignalServiceId.parseFromBinary(raw))
} catch (e: IllegalArgumentException) {
null
} catch (e: InvalidServiceIdException) {
@@ -61,6 +62,10 @@ sealed class ServiceId(@JvmField protected val libsignalServiceId: LibSignalServ
}
}
/** Parses a ServiceId serialized as a ByteString. Returns null if the ServiceId is invalid. */
@JvmStatic
fun parseOrNull(bytes: ByteString): ServiceId? = parseOrNull(bytes.toByteArray())
/** Parses a ServiceId serialized as a string. Crashes if the ServiceId is invalid. */
@JvmStatic
@Throws(IllegalArgumentException::class)
@@ -77,27 +82,27 @@ sealed class ServiceId(@JvmField protected val libsignalServiceId: LibSignalServ
fun parseOrThrow(bytes: ByteString): ServiceId = parseOrThrow(bytes.toByteArray())
}
val rawUuid: UUID = libsignalServiceId.rawUUID
val rawUuid: UUID = libSignalServiceId.rawUUID
val isUnknown: Boolean = rawUuid == UuidUtil.UNKNOWN_UUID
val isValid: Boolean = !isUnknown
fun toProtocolAddress(deviceId: Int): SignalProtocolAddress = SignalProtocolAddress(libsignalServiceId.toServiceIdString(), deviceId)
fun toProtocolAddress(deviceId: Int): SignalProtocolAddress = SignalProtocolAddress(libSignalServiceId.toServiceIdString(), deviceId)
fun toByteString(): ByteString = ByteString.copyFrom(libsignalServiceId.toServiceIdBinary())
fun toByteString(): ByteString = ByteString.copyFrom(libSignalServiceId.toServiceIdBinary())
fun toByteArray(): ByteArray = libsignalServiceId.toServiceIdBinary()
fun toByteArray(): ByteArray = libSignalServiceId.toServiceIdBinary()
fun logString(): String = libsignalServiceId.toLogString()
fun logString(): String = libSignalServiceId.toLogString()
/**
* A serialized string that can be parsed via [parseOrThrow], for instance.
* Basically ACI's are just normal UUIDs, and PNI's are UUIDs with a `PNI:` prefix.
*/
override fun toString(): String = libsignalServiceId.toServiceIdString()
override fun toString(): String = libSignalServiceId.toServiceIdString()
data class ACI(val libsignalAci: LibSignalAci) : ServiceId(libsignalAci) {
data class ACI(val libSignalAci: LibSignalAci) : ServiceId(libSignalAci) {
companion object {
@JvmField
val UNKNOWN = from(UuidUtil.UNKNOWN_UUID)
@@ -133,7 +138,7 @@ sealed class ServiceId(@JvmField protected val libsignalServiceId: LibSignalServ
override fun toString(): String = super.toString()
}
data class PNI(private val libsignalPni: LibSignalPni) : ServiceId(libsignalPni) {
data class PNI(val libSignalPni: LibSignalPni) : ServiceId(libSignalPni) {
companion object {
@JvmField
var UNKNOWN = from(UuidUtil.UNKNOWN_UUID)

12
libsignal/service/src/main/java/org/whispersystems/signalservice/api/services/ProfileService.java
View File

@@ -1,6 +1,7 @@
package org.whispersystems.signalservice.api.services;
import org.signal.libsignal.protocol.IdentityKey;
import org.signal.libsignal.protocol.logging.Log;
import org.signal.libsignal.protocol.util.Pair;
import org.signal.libsignal.zkgroup.VerificationFailedException;
import org.signal.libsignal.zkgroup.profiles.ClientZkProfileOperations;
@@ -15,6 +16,7 @@ import org.whispersystems.signalservice.api.crypto.UnidentifiedAccess;
import org.whispersystems.signalservice.api.profiles.ProfileAndCredential;
import org.whispersystems.signalservice.api.profiles.SignalServiceProfile;
import org.whispersystems.signalservice.api.push.ServiceId;
import org.whispersystems.signalservice.api.push.ServiceId.ACI;
import org.whispersystems.signalservice.api.push.SignalServiceAddress;
import org.whispersystems.signalservice.api.push.exceptions.MalformedResponseException;
import org.whispersystems.signalservice.internal.ServiceResponse;
@@ -81,11 +83,17 @@ public final class ProfileService {
.setVerb("GET");
if (profileKey.isPresent()) {
ProfileKeyVersion profileKeyIdentifier = profileKey.get().getProfileKeyVersion(serviceId.getRawUuid());
if (!(serviceId instanceof ACI)) {
Log.w(TAG, "ServiceId must be an ACI if a profile key is available!");
return Single.just(ServiceResponse.forUnknownError(new IllegalArgumentException("ServiceId must be an ACI if a profile key is available!")));
}
ACI aci = (ACI) serviceId;
ProfileKeyVersion profileKeyIdentifier = profileKey.get().getProfileKeyVersion(aci.getLibSignalAci());
String version = profileKeyIdentifier.serialize();
if (requestType == SignalServiceProfile.RequestType.PROFILE_AND_CREDENTIAL) {
requestContext = clientZkProfileOperations.createProfileKeyCredentialRequestContext(random, serviceId.getRawUuid(), profileKey.get());
requestContext = clientZkProfileOperations.createProfileKeyCredentialRequestContext(random, aci.getLibSignalAci(), profileKey.get());
ProfileKeyCredentialRequest request = requestContext.getRequest();
String credentialRequest = Hex.toStringCondensed(request.serialize());

12
libsignal/service/src/main/java/org/whispersystems/signalservice/internal/push/PushServiceSocket.java
View File

@@ -258,7 +258,7 @@ public class PushServiceSocket {
private static final String STICKER_MANIFEST_PATH = "stickers/%s/manifest.proto";
private static final String STICKER_PATH = "stickers/%s/full/%d";
private static final String GROUPSV2_CREDENTIAL = "/v1/certificate/auth/group?redemptionStartSeconds=%d&redemptionEndSeconds=%d";
private static final String GROUPSV2_CREDENTIAL = "/v1/certificate/auth/group?redemptionStartSeconds=%d&redemptionEndSeconds=%d&pniAsServiceId=true";
private static final String GROUPSV2_GROUP = "/v1/groups/";
private static final String GROUPSV2_GROUP_PASSWORD = "/v1/groups/?inviteLinkPassword=%s";
private static final String GROUPSV2_GROUP_CHANGES = "/v1/groups/logs/%s?maxSupportedChangeEpoch=%d&includeFirstState=%s&includeLastState=false";
@@ -853,9 +853,9 @@ public class PushServiceSocket {
});
}
public ListenableFuture<ProfileAndCredential> retrieveVersionedProfileAndCredential(UUID target, ProfileKey profileKey, Optional<UnidentifiedAccess> unidentifiedAccess, Locale locale) {
ProfileKeyVersion profileKeyIdentifier = profileKey.getProfileKeyVersion(target);
ProfileKeyCredentialRequestContext requestContext = clientZkProfileOperations.createProfileKeyCredentialRequestContext(random, target, profileKey);
public ListenableFuture<ProfileAndCredential> retrieveVersionedProfileAndCredential(ACI target, ProfileKey profileKey, Optional<UnidentifiedAccess> unidentifiedAccess, Locale locale) {
ProfileKeyVersion profileKeyIdentifier = profileKey.getProfileKeyVersion(target.getLibSignalAci());
ProfileKeyCredentialRequestContext requestContext = clientZkProfileOperations.createProfileKeyCredentialRequestContext(random, target.getLibSignalAci(), profileKey);
ProfileKeyCredentialRequest request = requestContext.getRequest();
String version = profileKeyIdentifier.serialize();
@@ -889,8 +889,8 @@ public class PushServiceSocket {
}
}
public ListenableFuture<SignalServiceProfile> retrieveVersionedProfile(UUID target, ProfileKey profileKey, Optional<UnidentifiedAccess> unidentifiedAccess, Locale locale) {
ProfileKeyVersion profileKeyIdentifier = profileKey.getProfileKeyVersion(target);
public ListenableFuture<SignalServiceProfile> retrieveVersionedProfile(ACI target, ProfileKey profileKey, Optional<UnidentifiedAccess> unidentifiedAccess, Locale locale) {
ProfileKeyVersion profileKeyIdentifier = profileKey.getProfileKeyVersion(target.getLibSignalAci());
String version = profileKeyIdentifier.serialize();
String subPath = String.format("%s/%s", target, version);

18
libsignal/service/src/main/proto/DecryptedGroups.proto
View File

@@ -21,11 +21,11 @@ message DecryptedMember {
}
message DecryptedPendingMember {
bytes uuid = 1;
Member.Role role = 2;
bytes addedByUuid = 3;
uint64 timestamp = 4;
bytes uuidCipherText = 5;
bytes serviceIdBinary = 1;
Member.Role role = 2;
bytes addedByUuid = 3;
uint64 timestamp = 4;
bytes uuidCipherText = 5;
}
message DecryptedRequestingMember {
@@ -35,13 +35,13 @@ message DecryptedRequestingMember {
}
message DecryptedBannedMember {
bytes uuid = 1;
uint64 timestamp = 2;
bytes serviceIdBinary = 1;
uint64 timestamp = 2;
}
message DecryptedPendingMemberRemoval {
bytes uuid = 1;
bytes uuidCipherText = 2;
bytes serviceIdBinary = 1;
bytes uuidCipherText = 2;
}
message DecryptedApproveMember {

59
libsignal/service/src/test/java/org/whispersystems/signalservice/api/groupsv2/DecryptedGroupUtilTest.java
View File

@@ -7,6 +7,8 @@ import org.signal.storageservice.protos.groups.local.DecryptedGroupChange;
import org.signal.storageservice.protos.groups.local.DecryptedMember;
import org.signal.storageservice.protos.groups.local.DecryptedPendingMember;
import org.signal.storageservice.protos.groups.local.DecryptedPendingMemberRemoval;
import org.whispersystems.signalservice.api.push.ServiceId;
import org.whispersystems.signalservice.api.push.ServiceId.ACI;
import org.whispersystems.signalservice.api.util.UuidUtil;
import org.whispersystems.signalservice.internal.util.Util;
@@ -15,6 +17,7 @@ import java.util.UUID;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static java.util.Arrays.asList;
@@ -58,39 +61,39 @@ public final class DecryptedGroupUtilTest {
@Test
public void can_extract_uuid_from_decrypted_pending_member() {
UUID uuid = UUID.randomUUID();
ACI aci = ACI.from(UUID.randomUUID());
DecryptedPendingMember decryptedMember = DecryptedPendingMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setServiceIdBinary(aci.toByteString())
.build();
UUID parsed = DecryptedGroupUtil.toUuid(decryptedMember);
ServiceId parsed = ServiceId.parseOrNull(decryptedMember.getServiceIdBinary());
assertEquals(uuid, parsed);
assertEquals(aci, parsed);
}
@Test
public void can_extract_uuid_from_bad_decrypted_pending_member() {
DecryptedPendingMember decryptedMember = DecryptedPendingMember.newBuilder()
.setUuid(ByteString.copyFrom(Util.getSecretBytes(17)))
.setServiceIdBinary(ByteString.copyFrom(Util.getSecretBytes(18)))
.build();
UUID parsed = DecryptedGroupUtil.toUuid(decryptedMember);
ServiceId parsed = ServiceId.parseOrNull(decryptedMember.getServiceIdBinary());
assertEquals(UuidUtil.UNKNOWN_UUID, parsed);
assertNull(parsed);
}
@Test
public void can_extract_uuids_for_all_pending_including_bad_entries() {
UUID uuid1 = UUID.randomUUID();
UUID uuid2 = UUID.randomUUID();
ACI aci1 = ACI.from(UUID.randomUUID());
ACI aci2 = ACI.from(UUID.randomUUID());
DecryptedPendingMember decryptedMember1 = DecryptedPendingMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid1))
.setServiceIdBinary(aci1.toByteString())
.build();
DecryptedPendingMember decryptedMember2 = DecryptedPendingMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid2))
.setServiceIdBinary(aci2.toByteString())
.build();
DecryptedPendingMember decryptedMember3 = DecryptedPendingMember.newBuilder()
.setUuid(ByteString.copyFrom(Util.getSecretBytes(17)))
.setServiceIdBinary(ByteString.copyFrom(Util.getSecretBytes(18)))
.build();
DecryptedGroupChange groupChange = DecryptedGroupChange.newBuilder()
@@ -99,23 +102,23 @@ public final class DecryptedGroupUtilTest {
.addNewPendingMembers(decryptedMember3)
.build();
List<UUID> pendingUuids = DecryptedGroupUtil.pendingToUuidList(groupChange.getNewPendingMembersList());
List<ServiceId> pendingUuids = DecryptedGroupUtil.pendingToServiceIdList(groupChange.getNewPendingMembersList());
assertThat(pendingUuids, is(asList(uuid1, uuid2, UuidUtil.UNKNOWN_UUID)));
assertThat(pendingUuids, is(asList(aci1, aci2, ACI.UNKNOWN)));
}
@Test
public void can_extract_uuids_for_all_deleted_pending_excluding_bad_entries() {
UUID uuid1 = UUID.randomUUID();
UUID uuid2 = UUID.randomUUID();
ACI aci1 = ACI.from(UUID.randomUUID());
ACI aci2 = ACI.from(UUID.randomUUID());
DecryptedPendingMemberRemoval decryptedMember1 = DecryptedPendingMemberRemoval.newBuilder()
.setUuid(UuidUtil.toByteString(uuid1))
.setServiceIdBinary(aci1.toByteString())
.build();
DecryptedPendingMemberRemoval decryptedMember2 = DecryptedPendingMemberRemoval.newBuilder()
.setUuid(UuidUtil.toByteString(uuid2))
.setServiceIdBinary(aci2.toByteString())
.build();
DecryptedPendingMemberRemoval decryptedMember3 = DecryptedPendingMemberRemoval.newBuilder()
.setUuid(ByteString.copyFrom(Util.getSecretBytes(17)))
.setServiceIdBinary(ByteString.copyFrom(Util.getSecretBytes(18)))
.build();
DecryptedGroupChange groupChange = DecryptedGroupChange.newBuilder()
@@ -124,23 +127,23 @@ public final class DecryptedGroupUtilTest {
.addDeletePendingMembers(decryptedMember3)
.build();
List<UUID> removedUuids = DecryptedGroupUtil.removedPendingMembersUuidList(groupChange);
List<ServiceId> removedUuids = DecryptedGroupUtil.removedPendingMembersServiceIdList(groupChange);
assertThat(removedUuids, is(asList(uuid1, uuid2)));
assertThat(removedUuids, is(asList(aci1, aci2)));
}
@Test
public void can_extract_uuids_for_all_deleted_members_excluding_bad_entries() {
UUID uuid1 = UUID.randomUUID();
UUID uuid2 = UUID.randomUUID();
ACI aci1 = ACI.from(UUID.randomUUID());
ACI aci2 = ACI.from(UUID.randomUUID());
DecryptedGroupChange groupChange = DecryptedGroupChange.newBuilder()
.addDeleteMembers(UuidUtil.toByteString(uuid1))
.addDeleteMembers(UuidUtil.toByteString(uuid2))
.addDeleteMembers(ByteString.copyFrom(Util.getSecretBytes(17)))
.addDeleteMembers(aci1.toByteString())
.addDeleteMembers(aci2.toByteString())
.addDeleteMembers(ByteString.copyFrom(Util.getSecretBytes(18)))
.build();
List<UUID> removedUuids = DecryptedGroupUtil.removedMembersUuidList(groupChange);
List<ServiceId> removedServiceIds = DecryptedGroupUtil.removedMembersServiceIdList(groupChange);
assertThat(removedUuids, is(asList(uuid1, uuid2)));
assertThat(removedServiceIds, is(asList(aci1, aci2)));
}
}

2
libsignal/service/src/test/java/org/whispersystems/signalservice/api/groupsv2/DecryptedGroupUtil_apply_Test.java
View File

@@ -949,7 +949,7 @@ public final class DecryptedGroupUtil_apply_Test {
DecryptedGroupChange.newBuilder()
.setRevision(11)
.addDeleteBannedMembers(DecryptedBannedMember.newBuilder()
.setUuid(UuidUtil.toByteString(bannedUuid))
.setServiceIdBinary(UuidUtil.toByteString(bannedUuid))
.build())
.build());

17
libsignal/service/src/test/java/org/whispersystems/signalservice/api/groupsv2/GroupsV2Operations_ban_Test.java
View File

@@ -12,6 +12,8 @@ import org.signal.storageservice.protos.groups.GroupChange;
import org.signal.storageservice.protos.groups.GroupChange.Actions.AddBannedMemberAction;
import org.signal.storageservice.protos.groups.GroupChange.Actions.DeleteBannedMemberAction;
import org.signal.storageservice.protos.groups.local.DecryptedBannedMember;
import org.whispersystems.signalservice.api.push.ServiceId;
import org.whispersystems.signalservice.api.push.ServiceId.ACI;
import org.whispersystems.signalservice.api.util.UuidUtil;
import org.whispersystems.signalservice.internal.util.Util;
import org.whispersystems.signalservice.testutil.LibSignalLibraryUtil;
@@ -52,7 +54,7 @@ public final class GroupsV2Operations_ban_Test {
Collections.emptyList());
assertThat(banUuidsChange.getAddBannedMembersCount(), is(1));
assertThat(banUuidsChange.getAddBannedMembers(0).getAdded().getUserId(), is(groupOperations.encryptUuid(ban)));
assertThat(banUuidsChange.getAddBannedMembers(0).getAdded().getUserId(), is(groupOperations.encryptServiceId(ACI.from(ban))));
}
@Test
@@ -69,7 +71,7 @@ public final class GroupsV2Operations_ban_Test {
alreadyBanned);
assertThat(banUuidsChange.getAddBannedMembersCount(), is(1));
assertThat(banUuidsChange.getAddBannedMembers(0).getAdded().getUserId(), is(groupOperations.encryptUuid(toBan)));
assertThat(banUuidsChange.getAddBannedMembers(0).getAdded().getUserId(), is(groupOperations.encryptServiceId(ACI.from(toBan))));
}
@Test
@@ -93,11 +95,11 @@ public final class GroupsV2Operations_ban_Test {
alreadyBanned);
assertThat(banUuidsChange.getDeleteBannedMembersCount(), is(1));
assertThat(banUuidsChange.getDeleteBannedMembers(0).getDeletedUserId(), is(groupOperations.encryptUuid(UuidUtil.fromByteString(oldest.getUuid()))));
assertThat(banUuidsChange.getDeleteBannedMembers(0).getDeletedUserId(), is(groupOperations.encryptServiceId(ServiceId.parseOrThrow(oldest.getServiceIdBinary()))));
assertThat(banUuidsChange.getAddBannedMembersCount(), is(1));
assertThat(banUuidsChange.getAddBannedMembers(0).getAdded().getUserId(), is(groupOperations.encryptUuid(toBan)));
assertThat(banUuidsChange.getAddBannedMembers(0).getAdded().getUserId(), is(groupOperations.encryptServiceId(ACI.from(toBan))));
}
@Test
@@ -112,8 +114,8 @@ public final class GroupsV2Operations_ban_Test {
}
List<ByteString> oldest = new ArrayList<>(2);
oldest.add(groupOperations.encryptUuid(UuidUtil.fromByteString(alreadyBanned.get(0).getUuid())));
oldest.add(groupOperations.encryptUuid(UuidUtil.fromByteString(alreadyBanned.get(1).getUuid())));
oldest.add(groupOperations.encryptServiceId(ServiceId.parseOrThrow(alreadyBanned.get(0).getServiceIdBinary())));
oldest.add(groupOperations.encryptServiceId(ServiceId.parseOrThrow(alreadyBanned.get(1).getServiceIdBinary())));
Collections.shuffle(alreadyBanned);
@@ -135,6 +137,7 @@ public final class GroupsV2Operations_ban_Test {
.map(AddBannedMemberAction::getAdded)
.map(BannedMember::getUserId)
.collect(Collectors.toList()),
hasItems(groupOperations.encryptUuid(toBan.get(0)), groupOperations.encryptUuid(toBan.get(1))));
hasItems(groupOperations.encryptServiceId(ACI.from(toBan.get(0))),
groupOperations.encryptServiceId(ACI.from(toBan.get(1)))));
}
}

106
libsignal/service/src/test/java/org/whispersystems/signalservice/api/groupsv2/GroupsV2Operations_decrypt_change_Test.java
View File

@@ -33,6 +33,8 @@ import org.signal.storageservice.protos.groups.local.DecryptedRequestingMember;
import org.signal.storageservice.protos.groups.local.DecryptedString;
import org.signal.storageservice.protos.groups.local.DecryptedTimer;
import org.signal.storageservice.protos.groups.local.EnabledState;
import org.whispersystems.signalservice.api.push.ServiceId.ACI;
import org.whispersystems.signalservice.api.push.ServiceId.PNI;
import org.whispersystems.signalservice.api.util.UuidUtil;
import org.whispersystems.signalservice.internal.util.Util;
import org.whispersystems.signalservice.testutil.LibSignalLibraryUtil;
@@ -94,8 +96,8 @@ public final class GroupsV2Operations_decrypt_change_Test {
@Test
public void can_decrypt_member_additions_field3() {
UUID self = UUID.randomUUID();
UUID newMember = UUID.randomUUID();
ACI self = ACI.from(UUID.randomUUID());
ACI newMember = ACI.from(UUID.randomUUID());
ProfileKey profileKey = newProfileKey();
GroupCandidate groupCandidate = groupCandidate(newMember, profileKey);
@@ -107,12 +109,12 @@ public final class GroupsV2Operations_decrypt_change_Test {
.setRole(Member.Role.DEFAULT)
.setProfileKey(ByteString.copyFrom(profileKey.serialize()))
.setJoinedAtRevision(10)
.setUuid(UuidUtil.toByteString(newMember))));
.setUuid(newMember.toByteString())));
}
@Test
public void can_decrypt_member_direct_join_field3() {
UUID newMember = UUID.randomUUID();
ACI newMember = ACI.from(UUID.randomUUID());
ProfileKey profileKey = newProfileKey();
GroupCandidate groupCandidate = groupCandidate(newMember, profileKey);
@@ -124,13 +126,13 @@ public final class GroupsV2Operations_decrypt_change_Test {
.setRole(Member.Role.DEFAULT)
.setProfileKey(ByteString.copyFrom(profileKey.serialize()))
.setJoinedAtRevision(10)
.setUuid(UuidUtil.toByteString(newMember))));
.setUuid(newMember.toByteString())));
}
@Test
public void can_decrypt_member_additions_direct_to_admin_field3() {
UUID self = UUID.randomUUID();
UUID newMember = UUID.randomUUID();
ACI self = ACI.from(UUID.randomUUID());
ACI newMember = ACI.from(UUID.randomUUID());
ProfileKey profileKey = newProfileKey();
GroupCandidate groupCandidate = groupCandidate(newMember, profileKey);
@@ -142,7 +144,7 @@ public final class GroupsV2Operations_decrypt_change_Test {
.setRole(Member.Role.DEFAULT)
.setProfileKey(ByteString.copyFrom(profileKey.serialize()))
.setJoinedAtRevision(10)
.setUuid(UuidUtil.toByteString(newMember))));
.setUuid(newMember.toByteString())));
}
@Test(expected = InvalidGroupStateException.class)
@@ -181,29 +183,29 @@ public final class GroupsV2Operations_decrypt_change_Test {
@Test
public void can_decrypt_modify_member_action_role_to_admin_field5() {
UUID member = UUID.randomUUID();
ACI member = ACI.from(UUID.randomUUID());
assertDecryption(groupOperations.createChangeMemberRole(member, Member.Role.ADMINISTRATOR),
DecryptedGroupChange.newBuilder()
.addModifyMemberRoles(DecryptedModifyMemberRole.newBuilder()
.setUuid(UuidUtil.toByteString(member))
.setUuid(member.toByteString())
.setRole(Member.Role.ADMINISTRATOR)));
}
@Test
public void can_decrypt_modify_member_action_role_to_member_field5() {
UUID member = UUID.randomUUID();
ACI member = ACI.from(UUID.randomUUID());
assertDecryption(groupOperations.createChangeMemberRole(member, Member.Role.DEFAULT),
DecryptedGroupChange.newBuilder()
.addModifyMemberRoles(DecryptedModifyMemberRole.newBuilder()
.setUuid(UuidUtil.toByteString(member))
.setUuid(member.toByteString())
.setRole(Member.Role.DEFAULT)));
}
@Test
public void can_decrypt_modify_member_profile_key_action_field6() {
UUID self = UUID.randomUUID();
ACI self = ACI.from(UUID.randomUUID());
ProfileKey profileKey = newProfileKey();
GroupCandidate groupCandidate = groupCandidate(self, profileKey);
@@ -215,35 +217,35 @@ public final class GroupsV2Operations_decrypt_change_Test {
.setRole(Member.Role.UNKNOWN)
.setJoinedAtRevision(-1)
.setProfileKey(ByteString.copyFrom(profileKey.serialize()))
.setUuid(UuidUtil.toByteString(self))));
.setUuid(self.toByteString())));
}
@Test
public void can_decrypt_member_invitations_field7() {
UUID self = UUID.randomUUID();
UUID newMember = UUID.randomUUID();
GroupCandidate groupCandidate = groupCandidate(newMember);
ACI self = ACI.from(UUID.randomUUID());
ACI newMember = ACI.from(UUID.randomUUID());
GroupCandidate groupCandidate = new GroupCandidate(newMember, Optional.empty());
assertDecryption(groupOperations.createModifyGroupMembershipChange(Collections.singleton(groupCandidate), Collections.emptySet(), self)
.setRevision(13),
DecryptedGroupChange.newBuilder()
.setRevision(13)
.addNewPendingMembers(DecryptedPendingMember.newBuilder()
.setAddedByUuid(UuidUtil.toByteString(self))
.setUuidCipherText(groupOperations.encryptUuid(newMember))
.setAddedByUuid(self.toByteString())
.setUuidCipherText(groupOperations.encryptServiceId(newMember))
.setRole(Member.Role.DEFAULT)
.setUuid(UuidUtil.toByteString(newMember))));
.setServiceIdBinary(newMember.toByteString())));
}
@Test
public void can_decrypt_pending_member_removals_field8() throws InvalidInputException {
UUID oldMember = UUID.randomUUID();
UuidCiphertext uuidCiphertext = new UuidCiphertext(groupOperations.encryptUuid(oldMember).toByteArray());
ACI oldMember = ACI.from(UUID.randomUUID());
UuidCiphertext uuidCiphertext = new UuidCiphertext(groupOperations.encryptServiceId(oldMember).toByteArray());
assertDecryption(groupOperations.createRemoveInvitationChange(Collections.singleton(uuidCiphertext)),
DecryptedGroupChange.newBuilder()
.addDeletePendingMembers(DecryptedPendingMemberRemoval.newBuilder()
.setUuid(UuidUtil.toByteString(oldMember))
.setServiceIdBinary(oldMember.toByteString())
.setUuidCipherText(ByteString.copyFrom(uuidCiphertext.serialize()))));
}
@@ -257,20 +259,20 @@ public final class GroupsV2Operations_decrypt_change_Test {
.setDeletedUserId(ByteString.copyFrom(uuidCiphertext))),
DecryptedGroupChange.newBuilder()
.addDeletePendingMembers(DecryptedPendingMemberRemoval.newBuilder()
.setUuid(UuidUtil.toByteString(UuidUtil.UNKNOWN_UUID))
.setServiceIdBinary(UuidUtil.toByteString(UuidUtil.UNKNOWN_UUID))
.setUuidCipherText(ByteString.copyFrom(uuidCiphertext))));
}
@Test
public void can_decrypt_promote_pending_member_field9() {
UUID newMember = UUID.randomUUID();
ACI newMember = ACI.from(UUID.randomUUID());
ProfileKey profileKey = newProfileKey();
GroupCandidate groupCandidate = groupCandidate(newMember, profileKey);
assertDecryption(groupOperations.createAcceptInviteChange(groupCandidate.getExpiringProfileKeyCredential().get()),
DecryptedGroupChange.newBuilder()
.addPromotePendingMembers(DecryptedMember.newBuilder()
.setUuid(UuidUtil.toByteString(newMember))
.setUuid(newMember.toByteString())
.setRole(Member.Role.DEFAULT)
.setProfileKey(ByteString.copyFrom(profileKey.serialize()))
.setJoinedAtRevision(-1)));
@@ -328,7 +330,7 @@ public final class GroupsV2Operations_decrypt_change_Test {
@Test
public void can_decrypt_member_requests_field16() {
UUID newRequestingMember = UUID.randomUUID();
ACI newRequestingMember = ACI.from(UUID.randomUUID());
ProfileKey profileKey = newProfileKey();
GroupCandidate groupCandidate = groupCandidate(newRequestingMember, profileKey);
@@ -337,7 +339,7 @@ public final class GroupsV2Operations_decrypt_change_Test {
DecryptedGroupChange.newBuilder()
.setRevision(10)
.addNewRequestingMembers(DecryptedRequestingMember.newBuilder()
.setUuid(UuidUtil.toByteString(newRequestingMember))
.setUuid(newRequestingMember.toByteString())
.setProfileKey(ByteString.copyFrom(profileKey.serialize()))));
}
@@ -350,7 +352,7 @@ public final class GroupsV2Operations_decrypt_change_Test {
DecryptedGroupChange.newBuilder()
.setRevision(10)
.addDeleteRequestingMembers(UuidUtil.toByteString(newRequestingMember))
.addNewBannedMembers(DecryptedBannedMember.newBuilder().setUuid(UuidUtil.toByteString(newRequestingMember)).build()));
.addNewBannedMembers(DecryptedBannedMember.newBuilder().setServiceIdBinary(UuidUtil.toByteString(newRequestingMember)).build()));
}
@Test
@@ -402,42 +404,42 @@ public final class GroupsV2Operations_decrypt_change_Test {
DecryptedGroupChange.newBuilder()
.setRevision(13)
.addNewBannedMembers(DecryptedBannedMember.newBuilder()
.setUuid(UuidUtil.toByteString(ban))));
.setServiceIdBinary(UuidUtil.toByteString(ban))));
}
@Test
public void can_decrypt_banned_member_removals_field23() {
UUID ban = UUID.randomUUID();
ACI ban = ACI.from(UUID.randomUUID());
assertDecryption(groupOperations.createUnbanUuidsChange(Collections.singleton(ban))
assertDecryption(groupOperations.createUnbanServiceIdsChange(Collections.singleton(ban))
.setRevision(13),
DecryptedGroupChange.newBuilder()
.setRevision(13)
.addDeleteBannedMembers(DecryptedBannedMember.newBuilder()
.setUuid(UuidUtil.toByteString(ban))));
.setServiceIdBinary(ban.toByteString())));
}
@Test
public void can_decrypt_promote_pending_pni_aci_member_field24() {
UUID memberUuid = UUID.randomUUID();
UUID memberPni = UUID.randomUUID();
ACI memberAci = ACI.from(UUID.randomUUID());
PNI memberPni = PNI.from(UUID.randomUUID());
ProfileKey profileKey = newProfileKey();
GroupChange.Actions.Builder builder = GroupChange.Actions.newBuilder()
.setSourceUuid(groupOperations.encryptUuid(memberPni))
.setSourceUuid(groupOperations.encryptServiceId(memberPni))
.setRevision(5)
.addPromotePendingPniAciMembers(GroupChange.Actions.PromotePendingPniAciMemberProfileKeyAction.newBuilder()
.setUserId(groupOperations.encryptUuid(memberUuid))
.setPni(groupOperations.encryptUuid(memberPni))
.setProfileKey(encryptProfileKey(memberUuid, profileKey)));
.setUserId(groupOperations.encryptServiceId(memberAci))
.setPni(groupOperations.encryptServiceId(memberPni))
.setProfileKey(encryptProfileKey(memberAci, profileKey)));
assertDecryptionWithEditorSet(builder,
DecryptedGroupChange.newBuilder()
.setEditor(UuidUtil.toByteString(memberUuid))
.setEditor(memberAci.toByteString())
.setRevision(5)
.addPromotePendingPniAciMembers(DecryptedMember.newBuilder()
.setUuid(UuidUtil.toByteString(memberUuid))
.setPni(UuidUtil.toByteString(memberPni))
.setUuid(memberAci.toByteString())
.setPni(memberPni.toByteString())
.setRole(Member.Role.DEFAULT)
.setProfileKey(ByteString.copyFrom(profileKey.serialize()))
.setJoinedAtRevision(5)));
@@ -451,23 +453,23 @@ public final class GroupsV2Operations_decrypt_change_Test {
}
}
private ByteString encryptProfileKey(UUID uuid, ProfileKey profileKey) {
return ByteString.copyFrom(new ClientZkGroupCipher(groupSecretParams).encryptProfileKey(profileKey, uuid).serialize());
private ByteString encryptProfileKey(ACI aci, ProfileKey profileKey) {
return ByteString.copyFrom(new ClientZkGroupCipher(groupSecretParams).encryptProfileKey(profileKey, aci.getLibSignalAci()).serialize());
}
static GroupCandidate groupCandidate(UUID uuid) {
return new GroupCandidate(uuid, Optional.empty());
return new GroupCandidate(ACI.from(uuid), Optional.empty());
}
GroupCandidate groupCandidate(UUID uuid, ProfileKey profileKey) {
GroupCandidate groupCandidate(ACI aci, ProfileKey profileKey) {
try {
ClientZkProfileOperations profileOperations = clientZkOperations.getProfileOperations();
ProfileKeyCommitment commitment = profileKey.getCommitment(uuid);
ProfileKeyCredentialRequestContext requestContext = profileOperations.createProfileKeyCredentialRequestContext(uuid, profileKey);
ProfileKeyCommitment commitment = profileKey.getCommitment(aci.getLibSignalAci());
ProfileKeyCredentialRequestContext requestContext = profileOperations.createProfileKeyCredentialRequestContext(aci.getLibSignalAci(), profileKey);
ProfileKeyCredentialRequest request = requestContext.getRequest();
ExpiringProfileKeyCredentialResponse expiringProfileKeyCredentialResponse = server.getExpiringProfileKeyCredentialResponse(request, uuid, commitment, Instant.now().plus(7, ChronoUnit.DAYS).truncatedTo(ChronoUnit.DAYS));
ExpiringProfileKeyCredentialResponse expiringProfileKeyCredentialResponse = server.getExpiringProfileKeyCredentialResponse(request, aci, commitment, Instant.now().plus(7, ChronoUnit.DAYS).truncatedTo(ChronoUnit.DAYS));
ExpiringProfileKeyCredential profileKeyCredential = profileOperations.receiveExpiringProfileKeyCredential(requestContext, expiringProfileKeyCredentialResponse);
GroupCandidate groupCandidate = new GroupCandidate(uuid, Optional.of(profileKeyCredential));
GroupCandidate groupCandidate = new GroupCandidate(aci, Optional.of(profileKeyCredential));
ProfileKeyCredentialPresentation presentation = profileOperations.createProfileKeyCredentialPresentation(groupSecretParams, profileKeyCredential);
server.assertProfileKeyCredentialPresentation(groupSecretParams.getPublicParams(), presentation, Instant.now());
@@ -481,8 +483,8 @@ public final class GroupsV2Operations_decrypt_change_Test {
void assertDecryption(GroupChange.Actions.Builder inputChange,
DecryptedGroupChange.Builder expectedDecrypted)
{
UUID editor = UUID.randomUUID();
assertDecryptionWithEditorSet(inputChange.setSourceUuid(groupOperations.encryptUuid(editor)), expectedDecrypted.setEditor(UuidUtil.toByteString(editor)));
ACI editor = ACI.from(UUID.randomUUID());
assertDecryptionWithEditorSet(inputChange.setSourceUuid(groupOperations.encryptServiceId(editor)), expectedDecrypted.setEditor(editor.toByteString()));
}
void assertDecryptionWithEditorSet(GroupChange.Actions.Builder inputChange,

76
libsignal/service/src/test/java/org/whispersystems/signalservice/api/groupsv2/GroupsV2Operations_decrypt_group_Test.java
View File

@@ -22,7 +22,7 @@ import org.signal.storageservice.protos.groups.local.DecryptedMember;
import org.signal.storageservice.protos.groups.local.DecryptedPendingMember;
import org.signal.storageservice.protos.groups.local.DecryptedRequestingMember;
import org.signal.storageservice.protos.groups.local.EnabledState;
import org.whispersystems.signalservice.api.util.UuidUtil;
import org.whispersystems.signalservice.api.push.ServiceId.ACI;
import org.whispersystems.signalservice.internal.util.Util;
import org.whispersystems.signalservice.testutil.LibSignalLibraryUtil;
@@ -122,20 +122,20 @@ public final class GroupsV2Operations_decrypt_group_Test {
@Test
public void decrypt_full_members_field_7() throws VerificationFailedException, InvalidGroupStateException {
UUID admin1 = UUID.randomUUID();
UUID member1 = UUID.randomUUID();
ACI admin1 = ACI.from(UUID.randomUUID());
ACI member1 = ACI.from(UUID.randomUUID());
ProfileKey adminProfileKey = newProfileKey();
ProfileKey memberProfileKey = newProfileKey();
Group group = Group.newBuilder()
.addMembers(Member.newBuilder()
.setRole(Member.Role.ADMINISTRATOR)
.setUserId(groupOperations.encryptUuid(admin1))
.setUserId(groupOperations.encryptServiceId(admin1))
.setJoinedAtRevision(4)
.setProfileKey(encryptProfileKey(admin1, adminProfileKey)))
.addMembers(Member.newBuilder()
.setRole(Member.Role.DEFAULT)
.setUserId(groupOperations.encryptUuid(member1))
.setUserId(groupOperations.encryptServiceId(member1))
.setJoinedAtRevision(7)
.setProfileKey(encryptProfileKey(member1, memberProfileKey)))
.build();
@@ -145,13 +145,13 @@ public final class GroupsV2Operations_decrypt_group_Test {
assertEquals(DecryptedGroup.newBuilder()
.addMembers(DecryptedMember.newBuilder()
.setJoinedAtRevision(4)
.setUuid(UuidUtil.toByteString(admin1))
.setUuid(admin1.toByteString())
.setRole(Member.Role.ADMINISTRATOR)
.setProfileKey(ByteString.copyFrom(adminProfileKey.serialize())))
.addMembers(DecryptedMember.newBuilder()
.setJoinedAtRevision(7)
.setRole(Member.Role.DEFAULT)
.setUuid(UuidUtil.toByteString(member1))
.setUuid(member1.toByteString())
.setProfileKey(ByteString.copyFrom(memberProfileKey.serialize())))
.build().getMembersList(),
decryptedGroup.getMembersList());
@@ -159,52 +159,52 @@ public final class GroupsV2Operations_decrypt_group_Test {
@Test
public void decrypt_pending_members_field_8() throws VerificationFailedException, InvalidGroupStateException {
UUID admin1 = UUID.randomUUID();
UUID member1 = UUID.randomUUID();
UUID member2 = UUID.randomUUID();
UUID inviter1 = UUID.randomUUID();
UUID inviter2 = UUID.randomUUID();
ACI admin1 = ACI.from(UUID.randomUUID());
ACI member1 = ACI.from(UUID.randomUUID());
ACI member2 = ACI.from(UUID.randomUUID());
ACI inviter1 = ACI.from(UUID.randomUUID());
ACI inviter2 = ACI.from(UUID.randomUUID());
Group group = Group.newBuilder()
.addPendingMembers(PendingMember.newBuilder()
.setAddedByUserId(groupOperations.encryptUuid(inviter1))
.setAddedByUserId(groupOperations.encryptServiceId(inviter1))
.setTimestamp(100)
.setMember(Member.newBuilder()
.setRole(Member.Role.ADMINISTRATOR)
.setUserId(groupOperations.encryptUuid(admin1))))
.setUserId(groupOperations.encryptServiceId(admin1))))
.addPendingMembers(PendingMember.newBuilder()
.setAddedByUserId(groupOperations.encryptUuid(inviter1))
.setAddedByUserId(groupOperations.encryptServiceId(inviter1))
.setTimestamp(200)
.setMember(Member.newBuilder()
.setRole(Member.Role.DEFAULT)
.setUserId(groupOperations.encryptUuid(member1))))
.setUserId(groupOperations.encryptServiceId(member1))))
.addPendingMembers(PendingMember.newBuilder()
.setAddedByUserId(groupOperations.encryptUuid(inviter2))
.setAddedByUserId(groupOperations.encryptServiceId(inviter2))
.setTimestamp(1500)
.setMember(Member.newBuilder()
.setUserId(groupOperations.encryptUuid(member2))))
.setUserId(groupOperations.encryptServiceId(member2))))
.build();
DecryptedGroup decryptedGroup = groupOperations.decryptGroup(group);
assertEquals(DecryptedGroup.newBuilder()
.addPendingMembers(DecryptedPendingMember.newBuilder()
.setUuid(UuidUtil.toByteString(admin1))
.setUuidCipherText(groupOperations.encryptUuid(admin1))
.setServiceIdBinary(admin1.toByteString())
.setUuidCipherText(groupOperations.encryptServiceId(admin1))
.setTimestamp(100)
.setAddedByUuid(UuidUtil.toByteString(inviter1))
.setAddedByUuid(inviter1.toByteString())
.setRole(Member.Role.ADMINISTRATOR))
.addPendingMembers(DecryptedPendingMember.newBuilder()
.setUuid(UuidUtil.toByteString(member1))
.setUuidCipherText(groupOperations.encryptUuid(member1))
.setServiceIdBinary(member1.toByteString())
.setUuidCipherText(groupOperations.encryptServiceId(member1))
.setTimestamp(200)
.setAddedByUuid(UuidUtil.toByteString(inviter1))
.setAddedByUuid(inviter1.toByteString())
.setRole(Member.Role.DEFAULT))
.addPendingMembers(DecryptedPendingMember.newBuilder()
.setUuid(UuidUtil.toByteString(member2))
.setUuidCipherText(groupOperations.encryptUuid(member2))
.setServiceIdBinary(member2.toByteString())
.setUuidCipherText(groupOperations.encryptServiceId(member2))
.setTimestamp(1500)
.setAddedByUuid(UuidUtil.toByteString(inviter2))
.setAddedByUuid(inviter2.toByteString())
.setRole(Member.Role.DEFAULT))
.build().getPendingMembersList(),
decryptedGroup.getPendingMembersList());
@@ -212,18 +212,18 @@ public final class GroupsV2Operations_decrypt_group_Test {
@Test
public void decrypt_requesting_members_field_9() throws VerificationFailedException, InvalidGroupStateException {
UUID admin1 = UUID.randomUUID();
UUID member1 = UUID.randomUUID();
ACI admin1 = ACI.from(UUID.randomUUID());
ACI member1 = ACI.from(UUID.randomUUID());
ProfileKey adminProfileKey = newProfileKey();
ProfileKey memberProfileKey = newProfileKey();
Group group = Group.newBuilder()
.addRequestingMembers(RequestingMember.newBuilder()
.setUserId(groupOperations.encryptUuid(admin1))
.setUserId(groupOperations.encryptServiceId(admin1))
.setProfileKey(encryptProfileKey(admin1, adminProfileKey))
.setTimestamp(5000))
.addRequestingMembers(RequestingMember.newBuilder()
.setUserId(groupOperations.encryptUuid(member1))
.setUserId(groupOperations.encryptServiceId(member1))
.setProfileKey(encryptProfileKey(member1, memberProfileKey))
.setTimestamp(15000))
.build();
@@ -232,11 +232,11 @@ public final class GroupsV2Operations_decrypt_group_Test {
assertEquals(DecryptedGroup.newBuilder()
.addRequestingMembers(DecryptedRequestingMember.newBuilder()
.setUuid(UuidUtil.toByteString(admin1))
.setUuid(admin1.toByteString())
.setProfileKey(ByteString.copyFrom(adminProfileKey.serialize()))
.setTimestamp(5000))
.addRequestingMembers(DecryptedRequestingMember.newBuilder()
.setUuid(UuidUtil.toByteString(member1))
.setUuid(member1.toByteString())
.setProfileKey(ByteString.copyFrom(memberProfileKey.serialize()))
.setTimestamp(15000))
.build().getRequestingMembersList(),
@@ -279,20 +279,20 @@ public final class GroupsV2Operations_decrypt_group_Test {
@Test
public void decrypt_banned_members_field_13() throws VerificationFailedException, InvalidGroupStateException {
UUID member1 = UUID.randomUUID();
ACI member1 = ACI.from(UUID.randomUUID());
Group group = Group.newBuilder()
.addBannedMembers(BannedMember.newBuilder().setUserId(groupOperations.encryptUuid(member1)))
.addBannedMembers(BannedMember.newBuilder().setUserId(groupOperations.encryptServiceId(member1)))
.build();
DecryptedGroup decryptedGroup = groupOperations.decryptGroup(group);
assertEquals(1, decryptedGroup.getBannedMembersCount());
assertEquals(DecryptedBannedMember.newBuilder().setUuid(UuidUtil.toByteString(member1)).build(), decryptedGroup.getBannedMembers(0));
assertEquals(DecryptedBannedMember.newBuilder().setServiceIdBinary(member1.toByteString()).build(), decryptedGroup.getBannedMembers(0));
}
private ByteString encryptProfileKey(UUID uuid, ProfileKey profileKey) {
return ByteString.copyFrom(new ClientZkGroupCipher(groupSecretParams).encryptProfileKey(profileKey, uuid).serialize());
private ByteString encryptProfileKey(ACI aci, ProfileKey profileKey) {
return ByteString.copyFrom(new ClientZkGroupCipher(groupSecretParams).encryptProfileKey(profileKey, aci.getLibSignalAci()).serialize());
}
private static ProfileKey newProfileKey() {

6
libsignal/service/src/test/java/org/whispersystems/signalservice/api/groupsv2/ProtoTestUtils.java
View File

@@ -107,14 +107,14 @@ final class ProtoTestUtils {
static DecryptedPendingMemberRemoval pendingMemberRemoval(UUID uuid) {
return DecryptedPendingMemberRemoval.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setServiceIdBinary(UuidUtil.toByteString(uuid))
.setUuidCipherText(encrypt(uuid))
.build();
}
static DecryptedPendingMember pendingMember(UUID uuid) {
return DecryptedPendingMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setServiceIdBinary(UuidUtil.toByteString(uuid))
.setUuidCipherText(encrypt(uuid))
.setRole(Member.Role.DEFAULT)
.build();
@@ -133,7 +133,7 @@ final class ProtoTestUtils {
static DecryptedBannedMember bannedMember(UUID uuid) {
return DecryptedBannedMember.newBuilder()
.setUuid(UuidUtil.toByteString(uuid))
.setServiceIdBinary(UuidUtil.toByteString(uuid))
.build();
}

6
libsignal/service/src/test/java/org/whispersystems/signalservice/api/groupsv2/TestZkGroupServer.java
View File

@@ -9,10 +9,10 @@ import org.signal.libsignal.zkgroup.profiles.ProfileKeyCommitment;
import org.signal.libsignal.zkgroup.profiles.ProfileKeyCredentialPresentation;
import org.signal.libsignal.zkgroup.profiles.ProfileKeyCredentialRequest;
import org.signal.libsignal.zkgroup.profiles.ServerZkProfileOperations;
import org.whispersystems.signalservice.api.push.ServiceId.ACI;
import org.whispersystems.signalservice.testutil.LibSignalLibraryUtil;
import java.time.Instant;
import java.util.UUID;
/**
* Provides Zk group operations that the server would provide.
@@ -35,8 +35,8 @@ final class TestZkGroupServer {
return serverPublicParams;
}
public ExpiringProfileKeyCredentialResponse getExpiringProfileKeyCredentialResponse(ProfileKeyCredentialRequest request, UUID uuid, ProfileKeyCommitment commitment, Instant expiration) throws VerificationFailedException {
return serverZkProfileOperations.issueExpiringProfileKeyCredential(request, uuid, commitment, expiration);
public ExpiringProfileKeyCredentialResponse getExpiringProfileKeyCredentialResponse(ProfileKeyCredentialRequest request, ACI aci, ProfileKeyCommitment commitment, Instant expiration) throws VerificationFailedException {
return serverZkProfileOperations.issueExpiringProfileKeyCredential(request, aci.getLibSignalAci(), commitment, expiration);
}
public void assertProfileKeyCredentialPresentation(GroupPublicParams publicParams, ProfileKeyCredentialPresentation profileKeyCredentialPresentation, Instant now) {