private async Task <GroupContext> CreateGroupContent(CancellationToken token, SignalServiceGroup group)
{
GroupContext groupContext = new GroupContext {
};
groupContext.Id = ByteString.CopyFrom(group.GroupId);
if (group.Type != SignalServiceGroup.GroupType.DELIVER)
{
if (group.Type == SignalServiceGroup.GroupType.UPDATE)
{
groupContext.Type = GroupContext.Types.Type.Update;
}
else if (group.Type == SignalServiceGroup.GroupType.QUIT)
{
groupContext.Type = GroupContext.Types.Type.Quit;
}
else if (group.Type == SignalServiceGroup.GroupType.REQUEST_INFO)
{
groupContext.Type = GroupContext.Types.Type.RequestInfo;
}
else
{
throw new Exception("Unknown type: " + group.Type);
}
if (group.Name != null)
{
groupContext.Name = group.Name;
}
if (group.Members != null)
{
groupContext.Members.AddRange(group.Members);
}
if (group.Avatar != null && group.Avatar.IsStream())
{
AttachmentPointer pointer = await CreateAttachmentPointer(token, group.Avatar.AsStream());
groupContext.Avatar = pointer;
}
}
else
{
groupContext.Type = GroupContext.Types.Type.Deliver;
}
return(groupContext);
}
private async Task <AttachmentPointer> CreateAttachmentPointer(CancellationToken token, SignalServiceAttachmentStream attachment)
{
byte[] attachmentKey = Util.GetSecretBytes(64);
long paddedLength = PaddingInputStream.GetPaddedSize(attachment.Length);
long ciphertextLength = AttachmentCipherInputStream.GetCiphertextLength(paddedLength);
PushAttachmentData attachmentData = new PushAttachmentData(attachment.ContentType,
new PaddingInputStream(attachment.InputStream, attachment.Length),
ciphertextLength,
new AttachmentCipherOutputStreamFactory(attachmentKey),
attachment.Listener);
(ulong id, byte[] digest) = await socket.SendAttachment(token, attachmentData);
var attachmentPointer = new AttachmentPointer
{
ContentType = attachment.ContentType,
Id = id,
Key = ByteString.CopyFrom(attachmentKey),
Digest = ByteString.CopyFrom(digest),
Size = (uint)attachment.Length
};
if (attachment.FileName != null)
{
attachmentPointer.FileName = attachment.FileName;
}
if (attachment.Preview != null)
{
attachmentPointer.Thumbnail = ByteString.CopyFrom(attachment.Preview);
}
if (attachment.Width > 0)
{
attachmentPointer.Width = (uint)attachment.Width;
}
if (attachment.Height > 0)
{
attachmentPointer.Height = (uint)attachment.Height;
}
if (attachment.VoiceNote)
{
attachmentPointer.Flags = (uint)AttachmentPointer.Types.Flags.VoiceMessage;
}
return(attachmentPointer);
}
public static SignalServiceAttachmentRemoteId?From(AttachmentPointer attachmentPointer)
{
switch (attachmentPointer.AttachmentIdentifierCase)
{
case AttachmentPointer.AttachmentIdentifierOneofCase.CdnId:
return(new SignalServiceAttachmentRemoteId((long)attachmentPointer.CdnId));
case AttachmentPointer.AttachmentIdentifierOneofCase.CdnKey:
return(new SignalServiceAttachmentRemoteId(attachmentPointer.CdnKey));
case AttachmentPointer.AttachmentIdentifierOneofCase.None:
throw new ProtocolInvalidMessageException(new InvalidMessageException("AttachmentPointer CDN location not set"), null !, 0);
}
return(null);
}
private async Task <GroupContext> createGroupContent(SignalServiceGroup group)
{
GroupContext.Builder builder = GroupContext.CreateBuilder();
builder.SetId(ByteString.CopyFrom(group.getGroupId()));
if (group.getType() != SignalServiceGroup.Type.DELIVER)
{
if (group.getType() == SignalServiceGroup.Type.UPDATE)
{
builder.SetType(GroupContext.Types.Type.UPDATE);
}
else if (group.getType() == SignalServiceGroup.Type.QUIT)
{
builder.SetType(GroupContext.Types.Type.QUIT);
}
else if (group.getType() == SignalServiceGroup.Type.REQUEST_INFO)
{
builder.SetType(GroupContext.Types.Type.REQUEST_INFO);
}
else
{
throw new Exception("Unknown type: " + group.getType());
}
if (group.getName().HasValue)
{
builder.SetName(group.getName().ForceGetValue());
}
if (group.getMembers().HasValue)
{
builder.AddRangeMembers(group.getMembers().ForceGetValue());
}
if (group.getAvatar().HasValue&& group.getAvatar().ForceGetValue().isStream())
{
AttachmentPointer pointer = await createAttachmentPointer(group.getAvatar().ForceGetValue().asStream());
builder.SetAvatar(pointer);
}
}
else
{
builder.SetType(GroupContext.Types.Type.DELIVER);
}
return(builder.Build());
}
private static SignalServiceAttachmentPointer CreateAttachmentPointer(AttachmentPointer pointer)
{
return(new SignalServiceAttachmentPointer((int)pointer.CdnNumber,
SignalServiceAttachmentRemoteId.From(pointer) !,
pointer.ContentType,
pointer.Key.ToByteArray(),
pointer.HasSize ? pointer.Size : (uint?)null,
pointer.HasThumbnail ? pointer.Thumbnail.ToByteArray() : null,
(int)pointer.Width,
(int)pointer.Height,
pointer.HasDigest ? pointer.Digest.ToByteArray() : null,
pointer.HasFileName ? pointer.FileName : null,
(pointer.Flags & (uint)AttachmentPointer.Types.Flags.VoiceMessage) != 0,
pointer.HasCaption ? pointer.Caption : null,
pointer.HasBlurHash ? pointer.BlurHash : null,
pointer.HasUploadTimestamp ? (long)pointer.UploadTimestamp : 0));
}
private SignalServiceAttachmentPointer CreateAttachmentPointer(AttachmentPointer pointer)
{
uint?size = null;
if (pointer.SizeOneofCase == AttachmentPointer.SizeOneofOneofCase.Size)
{
size = pointer.Size;
}
return(new SignalServiceAttachmentPointer(pointer.Id,
pointer.ContentType,
pointer.Key.ToByteArray(),
size,
pointer.ThumbnailOneofCase == AttachmentPointer.ThumbnailOneofOneofCase.Thumbnail ? pointer.Thumbnail.ToByteArray() : null,
(int)pointer.Width,
(int)pointer.Height,
pointer.DigestOneofCase == AttachmentPointer.DigestOneofOneofCase.Digest ? pointer.Digest.ToByteArray() : null,
pointer.FileNameOneofCase == AttachmentPointer.FileNameOneofOneofCase.FileName ? pointer.FileName : null,
(pointer.Flags & (uint)AttachmentPointer.Types.Flags.VoiceMessage) != 0));
}
private AttachmentPointer CreateAttachmentPointerFromPointer(SignalServiceAttachmentPointer attachment)
{
var attachmentPointer = new AttachmentPointer()
{
ContentType = attachment.ContentType,
Id = attachment.Id,
Key = ByteString.CopyFrom(attachment.Key),
Digest = ByteString.CopyFrom(attachment.Digest),
Size = (uint)attachment.Size
};
if (attachment.FileName != null)
{
attachmentPointer.FileName = attachment.FileName;
}
if (attachment.VoiceNote)
{
attachmentPointer.Flags = (uint)AttachmentPointer.Types.Flags.VoiceMessage;
}
return(attachmentPointer);
}
private async Task <AttachmentPointer> createAttachmentPointer(SignalServiceAttachmentStream attachment)
{
byte[] attachmentKey = Util.getSecretBytes(64);
PushAttachmentData attachmentData = new PushAttachmentData(attachment.getContentType(),
attachment.getInputStream().AsInputStream(),
(ulong)attachment.getLength(),
attachmentKey);
ulong attachmentId = await socket.sendAttachment(attachmentData);
var builder = AttachmentPointer.CreateBuilder()
.SetContentType(attachment.getContentType())
.SetId(attachmentId)
.SetKey(ByteString.CopyFrom(attachmentKey))
.SetSize((uint)attachment.getLength());
if (attachment.getPreview().HasValue)
{
builder.SetThumbnail(ByteString.CopyFrom(attachment.getPreview().ForceGetValue()));
}
return(builder.Build());
}
private AttachmentPointer createAttachmentPointer(SignalServiceAttachmentStream attachment)
{
byte[] attachmentKey = Util.getSecretBytes(64);
PushAttachmentData attachmentData = new PushAttachmentData(attachment.getContentType(),
attachment.getInputStream(),
(ulong)attachment.getLength(),
attachmentKey);
Tuple <ulong, byte[]> attachmentIdAndDigest = socket.SendAttachment(attachmentData);
var attachmentPointer = new AttachmentPointer
{
ContentType = attachment.getContentType(),
Id = attachmentIdAndDigest.Item1,
Key = ByteString.CopyFrom(attachmentKey),
Digest = ByteString.CopyFrom(attachmentIdAndDigest.Item2),
Size = (uint)attachment.getLength()
};
if (attachment.FileName != null)
{
attachmentPointer.FileName = attachment.FileName;
}
if (attachment.getPreview().HasValue)
{
attachmentPointer.Thumbnail = ByteString.CopyFrom(attachment.getPreview().ForceGetValue());
}
if (attachment.VoiceNote)
{
attachmentPointer.Flags = (uint)AttachmentPointer.Types.Flags.VoiceMessage;
}
return(attachmentPointer);
}
private static SignalServiceGroup?CreateGroupV1Info(DataMessage content)
{
if (content.Group == null)
{
return(null);
}
var type = content.Group.Type switch
{
GroupContext.Types.Type.Deliver => SignalServiceGroup.GroupType.DELIVER,
GroupContext.Types.Type.Update => SignalServiceGroup.GroupType.UPDATE,
GroupContext.Types.Type.Quit => SignalServiceGroup.GroupType.QUIT,
GroupContext.Types.Type.RequestInfo => SignalServiceGroup.GroupType.REQUEST_INFO,
_ => SignalServiceGroup.GroupType.UNKNOWN,
};
if (content.Group.Type != GroupContext.Types.Type.Deliver)
{
string?name = null;
List <SignalServiceAddress>? members = null;
SignalServiceAttachmentPointer?avatar = null;
if (content.Group.HasName)
{
name = content.Group.Name;
}
if (content.Group.MembersE164.Count > 0)
{
members = new List <SignalServiceAddress>(content.Group.MembersE164.Count);
foreach (string member in content.Group.MembersE164)
{
members.Add(new SignalServiceAddress(null, member));
}
}
if (content.Group.Avatar != null)
{
AttachmentPointer pointer = content.Group.Avatar;
avatar = new SignalServiceAttachmentPointer((int)pointer.CdnNumber,
SignalServiceAttachmentRemoteId.From(pointer) !,
pointer.ContentType,
pointer.Key.ToByteArray(),
pointer.HasSize ? pointer.Size : 0,
null,
0, 0,
pointer.HasDigest ? pointer.Digest.ToByteArray() : null,
null,
false,
null,
null,
pointer.HasUploadTimestamp ? (long)pointer.UploadTimestamp : 0);
}
return(new SignalServiceGroup(type, content.Group.Id.ToByteArray(), name, members, avatar));
}
return(new SignalServiceGroup(content.Group.Id.ToByteArray()));
}
/// <summary>
///
/// </summary>
/// <param name="metadata"></param>
/// <param name="content"></param>
/// <returns></returns>
/// <exception cref="ProtocolInvalidMessageException"></exception>
/// <exception cref="ProtocolInvalidKeyException"></exception>
private static SignalServiceSyncMessage CreateSynchronizeMessage(SignalServiceMetadata metadata, SyncMessage content)
{
if (content.Sent != null)
{
var unidentifiedStatuses = new Dictionary <SignalServiceAddress, bool>();
SyncMessage.Types.Sent sentContent = content.Sent;
SignalServiceDataMessage dataMessage = CreateSignalServiceMessage(metadata, sentContent.Message);
SignalServiceAddress? address = SignalServiceAddress.IsValidAddress(sentContent.DestinationUuid, sentContent.Destination) ?
new SignalServiceAddress(UuidUtil.ParseOrNull(sentContent.DestinationUuid), sentContent.Destination) :
null;
if (address == null && dataMessage.Group == null)
{
throw new ProtocolInvalidMessageException(new InvalidMessageException("SyncMessage missing both destination and group ID!"), null, 0);
}
foreach (var status in sentContent.UnidentifiedStatus)
{
if (SignalServiceAddress.IsValidAddress(status.DestinationUuid, status.Destination))
{
SignalServiceAddress recipient = new SignalServiceAddress(UuidUtil.ParseOrNull(status.DestinationUuid), status.Destination);
unidentifiedStatuses.Add(recipient, status.Unidentified);
}
else
{
logger.LogWarning("Encountered an invalid UnidentifiedDeliveryStatus in a SentTranscript! Ignoring.");
}
}
return(SignalServiceSyncMessage.ForSentTranscript(new SentTranscriptMessage(address !,
(long)sentContent.Timestamp,
CreateSignalServiceMessage(metadata, sentContent.Message),
(long)sentContent.ExpirationStartTimestamp,
unidentifiedStatuses,
sentContent.IsRecipientUpdate)));
}
if (content.Request != null)
{
return(SignalServiceSyncMessage.ForRequest(new RequestMessage(content.Request)));
}
if (content.Read.Count > 0)
{
List <ReadMessage> readMessages = new List <ReadMessage>();
foreach (SyncMessage.Types.Read read in content.Read)
{
if (SignalServiceAddress.IsValidAddress(read.SenderUuid, read.Sender))
{
SignalServiceAddress address = new SignalServiceAddress(UuidUtil.ParseOrNull(read.SenderUuid), read.Sender);
readMessages.Add(new ReadMessage(address, (long)read.Timestamp));
}
else
{
logger.LogWarning("Encountered an invalid ReadMessage! Ignoring.");
}
}
return(SignalServiceSyncMessage.ForRead(readMessages));
}
if (content.ViewOnceOpen != null)
{
if (SignalServiceAddress.IsValidAddress(content.ViewOnceOpen.SenderUuid, content.ViewOnceOpen.Sender))
{
SignalServiceAddress address = new SignalServiceAddress(UuidUtil.ParseOrNull(content.ViewOnceOpen.SenderUuid), content.ViewOnceOpen.Sender);
ViewOnceOpenMessage timerRead = new ViewOnceOpenMessage(address, (long)content.ViewOnceOpen.Timestamp);
return(SignalServiceSyncMessage.ForViewOnceOpen(timerRead));
}
else
{
throw new ProtocolInvalidMessageException(new InvalidMessageException("ViewOnceOpen message has no sender!"), null, 0);
}
}
if (content.Contacts != null)
{
AttachmentPointer pointer = content.Contacts.Blob;
return(SignalServiceSyncMessage.ForContacts(new ContactsMessage(CreateAttachmentPointer(pointer), content.Contacts.Complete)));
}
if (content.Groups != null)
{
AttachmentPointer pointer = content.Groups.Blob;
return(SignalServiceSyncMessage.ForGroups(CreateAttachmentPointer(pointer)));
}
if (content.Verified != null)
{
if (SignalServiceAddress.IsValidAddress(content.Verified.DestinationUuid, content.Verified.Destination))
{
try
{
Verified verified = content.Verified;
SignalServiceAddress destination = new SignalServiceAddress(UuidUtil.ParseOrNull(verified.DestinationUuid), verified.Destination);
IdentityKey identityKey = new IdentityKey(verified.IdentityKey.ToByteArray(), 0);
VerifiedMessage.VerifiedState verifiedState;
if (verified.State == Verified.Types.State.Default)
{
verifiedState = VerifiedMessage.VerifiedState.Default;
}
else if (verified.State == Verified.Types.State.Verified)
{
verifiedState = VerifiedMessage.VerifiedState.Verified;
}
else if (verified.State == Verified.Types.State.Unverified)
{
verifiedState = VerifiedMessage.VerifiedState.Unverified;
}
else
{
throw new ProtocolInvalidMessageException(new InvalidMessageException($"Unknown state: {(int)verified.State}"),
metadata.Sender.GetIdentifier(), metadata.SenderDevice);
}
return(SignalServiceSyncMessage.ForVerified(new VerifiedMessage(destination, identityKey, verifiedState, Util.CurrentTimeMillis())));
}
catch (InvalidKeyException ex)
{
throw new ProtocolInvalidKeyException(ex, metadata.Sender.GetIdentifier(), metadata.SenderDevice);
}
}
else
{
throw new ProtocolInvalidMessageException(new InvalidMessageException("Verified message has no sender!"), null, 0);
}
}
if (content.StickerPackOperation.Count > 0)
{
List <StickerPackOperationMessage> operations = new List <StickerPackOperationMessage>();
foreach (var operation in content.StickerPackOperation)
{
byte[]? packId = operation.HasPackId ? operation.PackId.ToByteArray() : null;
byte[]? packKey = operation.HasPackKey ? operation.PackKey.ToByteArray() : null;
StickerPackOperationMessage.OperationType?type = null;
if (operation.HasType)
{
switch (operation.Type)
{
case SyncMessage.Types.StickerPackOperation.Types.Type.Install: type = StickerPackOperationMessage.OperationType.Install; break;
case SyncMessage.Types.StickerPackOperation.Types.Type.Remove: type = StickerPackOperationMessage.OperationType.Remove; break;
}
}
operations.Add(new StickerPackOperationMessage(packId, packKey, type));
}
return(SignalServiceSyncMessage.ForStickerPackOperations(operations));
}
if (content.Blocked != null)
{
List <string> numbers = content.Blocked.Numbers.ToList();
List <string> uuids = content.Blocked.Uuids.ToList();
List <SignalServiceAddress> addresses = new List <SignalServiceAddress>(numbers.Count + uuids.Count);
List <byte[]> groupIds = new List <byte[]>(content.Blocked.GroupIds.Count);
foreach (string e164 in numbers)
{
SignalServiceAddress?address = SignalServiceAddress.FromRaw(null, e164);
if (address != null)
{
addresses.Add(address);
}
}
foreach (string uuid in uuids)
{
SignalServiceAddress?address = SignalServiceAddress.FromRaw(uuid, null);
if (address != null)
{
addresses.Add(address);
}
}
foreach (ByteString groupId in content.Blocked.GroupIds)
{
groupIds.Add(groupId.ToByteArray());
}
return(SignalServiceSyncMessage.ForBlocked(new BlockedListMessage(addresses, groupIds)));
}
if (content.Configuration != null)
{
bool?readReceipts = content.Configuration.HasReadReceipts ? content.Configuration.ReadReceipts : (bool?)null;
bool?unidentifiedDeliveryIndicators = content.Configuration.HasUnidentifiedDeliveryIndicators ? content.Configuration.UnidentifiedDeliveryIndicators : (bool?)null;
bool?typingIndicators = content.Configuration.HasTypingIndicators ? content.Configuration.TypingIndicators : (bool?)null;
bool?linkPreviews = content.Configuration.HasLinkPreviews ? content.Configuration.LinkPreviews : (bool?)null;
return(SignalServiceSyncMessage.ForConfiguration(new ConfigurationMessage(readReceipts, unidentifiedDeliveryIndicators, typingIndicators, linkPreviews)));
}
return(SignalServiceSyncMessage.Empty());
}
private SignalServiceGroup createGroupInfo(SignalServiceEnvelope envelope, DataMessage content)
{
if (content.GroupOneofCase == DataMessage.GroupOneofOneofCase.None)
{
return(null);
}
SignalServiceGroup.GroupType type;
switch (content.Group.Type)
{
case GroupContext.Types.Type.Deliver: type = SignalServiceGroup.GroupType.DELIVER; break;
case GroupContext.Types.Type.Update: type = SignalServiceGroup.GroupType.UPDATE; break;
case GroupContext.Types.Type.Quit: type = SignalServiceGroup.GroupType.QUIT; break;
case GroupContext.Types.Type.RequestInfo: type = SignalServiceGroup.GroupType.REQUEST_INFO; break;
default: type = SignalServiceGroup.GroupType.UNKNOWN; break;
}
if (content.Group.Type != GroupContext.Types.Type.Deliver)
{
String name = null;
IList <String> members = null;
SignalServiceAttachmentPointer avatar = null;
if (content.Group.NameOneofCase == GroupContext.NameOneofOneofCase.Name)
{
name = content.Group.Name;
}
if (content.Group.Members.Count > 0)
{
members = content.Group.Members;
}
if (content.Group.AvatarOneofCase == GroupContext.AvatarOneofOneofCase.Avatar)
{
AttachmentPointer pointer = content.Group.Avatar;
avatar = new SignalServiceAttachmentPointer(pointer.Id,
pointer.ContentType,
pointer.Key.ToByteArray(),
envelope.getRelay(),
pointer.Digest.ToByteArray(),
null,
false);
}
return(new SignalServiceGroup()
{
Type = type,
GroupId = content.Group.Id.ToByteArray(),
Name = name,
Members = members,
Avatar = avatar
});
}
return(new SignalServiceGroup()
{
GroupId = content.Group.Id.ToByteArray(),
Type = type
});
}
private SignalServiceGroup?CreateGroupInfo(DataMessage content)
{
if (content.GroupOneofCase == DataMessage.GroupOneofOneofCase.None)
{
return(null);
}
var type = content.Group.Type switch
{
GroupContext.Types.Type.Deliver => SignalServiceGroup.GroupType.DELIVER,
GroupContext.Types.Type.Update => SignalServiceGroup.GroupType.UPDATE,
GroupContext.Types.Type.Quit => SignalServiceGroup.GroupType.QUIT,
GroupContext.Types.Type.RequestInfo => SignalServiceGroup.GroupType.REQUEST_INFO,
_ => SignalServiceGroup.GroupType.UNKNOWN,
};
if (content.Group.Type != GroupContext.Types.Type.Deliver)
{
string? name = null;
IList <string>?members = null;
SignalServiceAttachmentPointer?avatar = null;
if (content.Group.NameOneofCase == GroupContext.NameOneofOneofCase.Name)
{
name = content.Group.Name;
}
if (content.Group.Members.Count > 0)
{
members = content.Group.Members;
}
if (content.Group.AvatarOneofCase == GroupContext.AvatarOneofOneofCase.Avatar)
{
AttachmentPointer pointer = content.Group.Avatar;
avatar = new SignalServiceAttachmentPointer(pointer.Id,
pointer.ContentType,
pointer.Key.ToByteArray(),
pointer.SizeOneofCase == AttachmentPointer.SizeOneofOneofCase.Size ? pointer.Size : 0,
null,
0, 0,
pointer.DigestOneofCase == AttachmentPointer.DigestOneofOneofCase.Digest ? pointer.Digest.ToByteArray() : null,
null,
false);
}
return(new SignalServiceGroup()
{
Type = type,
GroupId = content.Group.Id.ToByteArray(),
Name = name,
Members = members,
Avatar = avatar
});
}
return(new SignalServiceGroup()
{
GroupId = content.Group.Id.ToByteArray(),
Type = type
});
}
private SignalServiceSyncMessage CreateSynchronizeMessage(Metadata metadata, SyncMessage content)
{
if (content.SentOneofCase == SyncMessage.SentOneofOneofCase.Sent)
{
SyncMessage.Types.Sent sentContent = content.Sent;
var unidentifiedStatuses = new Dictionary <string, bool>();
foreach (var status in sentContent.UnidentifiedStatus)
{
unidentifiedStatuses[status.Destination] = status.Unidentified;
}
return(SignalServiceSyncMessage.ForSentTranscript(new SentTranscriptMessage(sentContent.Destination,
(long)sentContent.Timestamp,
CreateSignalServiceMessage(metadata, sentContent.Message),
(long)sentContent.ExpirationStartTimestamp,
unidentifiedStatuses)));
}
if (content.RequestOneofCase == SyncMessage.RequestOneofOneofCase.Request)
{
return(SignalServiceSyncMessage.ForRequest(new RequestMessage(content.Request)));
}
if (content.Read.Count > 0)
{
List <ReadMessage> readMessages = new List <ReadMessage>();
foreach (SyncMessage.Types.Read read in content.Read)
{
readMessages.Add(new ReadMessage(read.Sender, (long)read.Timestamp));
}
return(SignalServiceSyncMessage.ForRead(readMessages));
}
if (content.ContactsOneofCase == SyncMessage.ContactsOneofOneofCase.Contacts)
{
AttachmentPointer pointer = content.Contacts.Blob;
return(SignalServiceSyncMessage.ForContacts(new ContactsMessage(CreateAttachmentPointer(pointer), content.Contacts.Complete)));
}
if (content.GroupsOneofCase == SyncMessage.GroupsOneofOneofCase.Groups)
{
AttachmentPointer pointer = content.Groups.Blob;
return(SignalServiceSyncMessage.ForGroups(CreateAttachmentPointer(pointer)));
}
if (content.VerifiedOneofCase == SyncMessage.VerifiedOneofOneofCase.Verified)
{
try
{
Verified verified = content.Verified;
string destination = verified.Destination;
IdentityKey identityKey = new IdentityKey(verified.IdentityKey.ToByteArray(), 0);
VerifiedMessage.VerifiedState verifiedState;
if (verified.State == Verified.Types.State.Default)
{
verifiedState = VerifiedMessage.VerifiedState.Default;
}
else if (verified.State == Verified.Types.State.Verified)
{
verifiedState = VerifiedMessage.VerifiedState.Verified;
}
else if (verified.State == Verified.Types.State.Unverified)
{
verifiedState = VerifiedMessage.VerifiedState.Unverified;
}
else
{
throw new InvalidMessageException("Unknown state: " + verified.State);
}
return(SignalServiceSyncMessage.ForVerified(new VerifiedMessage(destination, identityKey, verifiedState, Util.CurrentTimeMillis())));
}
catch (InvalidKeyException e)
{
throw new InvalidMessageException(e);
}
}
if (content.BlockedOneofCase == SyncMessage.BlockedOneofOneofCase.Blocked)
{
List <string> blockedNumbers = new List <string>(content.Blocked.Numbers.Count);
foreach (var blocked in content.Blocked.Numbers)
{
blockedNumbers.Add(blocked);
}
return(SignalServiceSyncMessage.ForBlocked(new BlockedListMessage(blockedNumbers, content.Blocked.GroupIds.Select(gid => gid.ToByteArray()).ToList())));
}
if (content.VerifiedOneofCase == SyncMessage.VerifiedOneofOneofCase.Verified)
{
try
{
Verified verified = content.Verified;
string destination = verified.Destination;
IdentityKey identityKey = new IdentityKey(verified.IdentityKey.ToByteArray(), 0);
VerifiedMessage.VerifiedState verifiedState;
if (verified.State == Verified.Types.State.Default)
{
verifiedState = VerifiedMessage.VerifiedState.Default;
}
else if (verified.State == Verified.Types.State.Verified)
{
verifiedState = VerifiedMessage.VerifiedState.Verified;
}
else if (verified.State == Verified.Types.State.Unverified)
{
verifiedState = VerifiedMessage.VerifiedState.Unverified;
}
else
{
throw new ProtocolInvalidMessageException(new InvalidMessageException("Unknown state: " + verified.State),
metadata.Sender, metadata.SenderDevice);
}
return(SignalServiceSyncMessage.ForVerified(new VerifiedMessage(destination, identityKey, verifiedState, Util.CurrentTimeMillis())));
}
catch (InvalidKeyException e)
{
throw new ProtocolInvalidKeyException(e, metadata.Sender, metadata.SenderDevice);
}
}
return(SignalServiceSyncMessage.Empty());
}
