private byte[] CreateMultiDeviceVerifiedContent(VerifiedMessage verifiedMessage, byte[] nullMessage)
{
Content content = new Content {
};
SyncMessage syncMessage = CreateSyncMessage();
Verified verifiedMessageBuilder = new Verified
{
NullMessage = ByteString.CopyFrom(nullMessage),
Destination = verifiedMessage.Destination,
IdentityKey = ByteString.CopyFrom(verifiedMessage.IdentityKey.serialize())
};
switch (verifiedMessage.Verified)
{
case VerifiedMessage.VerifiedState.Default:
verifiedMessageBuilder.State = Verified.Types.State.Default;
break;
case VerifiedMessage.VerifiedState.Verified:
verifiedMessageBuilder.State = Verified.Types.State.Verified;
break;
case VerifiedMessage.VerifiedState.Unverified:
verifiedMessageBuilder.State = Verified.Types.State.Unverified;
break;
default:
throw new Exception("Unknown: " + verifiedMessage.Verified);
}
syncMessage.Verified = verifiedMessageBuilder;
content.SyncMessage = syncMessage;
return(content.ToByteArray());
}
private async Task SendMessage(CancellationToken token, VerifiedMessage message)
{
byte[] nullMessageBody = new DataMessage()
{
Body = Base64.EncodeBytes(Util.GetRandomLengthBytes(140))
}.ToByteArray();
NullMessage nullMessage = new NullMessage()
{
Padding = ByteString.CopyFrom(nullMessageBody)
};
byte[] content = new Content()
{
NullMessage = nullMessage
}.ToByteArray();
SendMessageResponse response = await SendMessage(token, new SignalServiceAddress(message.Destination), message.Timestamp, content, false);
if (response != null && response.NeedsSync)
{
byte[] syncMessage = CreateMultiDeviceVerifiedContent(message, nullMessage.ToByteArray());
await SendMessage(token, localAddress, message.Timestamp, syncMessage, false);
}
}
private async Task SendMessage(CancellationToken token, VerifiedMessage message, UnidentifiedAccessPair?unidentifiedAccessPair)
{
byte[] nullMessageBody = new DataMessage()
{
Body = Base64.EncodeBytes(Util.GetRandomLengthBytes(140))
}.ToByteArray();
NullMessage nullMessage = new NullMessage()
{
Padding = ByteString.CopyFrom(nullMessageBody)
};
byte[] content = new Content()
{
NullMessage = nullMessage
}.ToByteArray();
SendMessageResult result = await SendMessage(token, new SignalServiceAddress(message.Destination), unidentifiedAccessPair?.TargetUnidentifiedAccess, message.Timestamp, content);
if (result.Success.NeedsSync)
{
byte[] syncMessage = CreateMultiDeviceVerifiedContent(message, nullMessage.ToByteArray());
await SendMessage(token, LocalAddress, unidentifiedAccessPair?.SelfUnidentifiedAccess, message.Timestamp, syncMessage);
}
}
public DeviceContact(string number, string name, SignalServiceAttachmentStream avatar, string?color, VerifiedMessage verified, byte[] profileKey, bool blocked, uint?expirationTimer)
{
Number = number;
Name = name;
Avatar = avatar;
Color = color;
Verified = verified;
ProfileKey = profileKey;
Blocked = blocked;
ExpirationTimer = expirationTimer;
}
internal void LatestPriceRequestVerifiedMessage(VerifiedMessage m)
{
SyncProviders();
}
/// <summary>
/// Handles an unconnected message, usually from the auth server.
/// </summary>
private void HandleUnconnectedMessage(NetIncomingMessage im)
{
if (im == null)
{
throw new ArgumentNullException(nameof(im));
}
// Make sure the unconnected message is coming from the real auth server.
if (Equals(im.SenderEndPoint, networkManager.AuthEndpoint) &&
im.SenderEndPoint.Port == Globals.Values.DefaultAuthPort)
{
var messageType = (MessageTypes)im.ReadByte(); // Find the type of data message sent
switch (messageType)
{
case MessageTypes.AuthInit:
{
var msg = new AuthInitMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Auth.InitReceived.Invoke(
new EventManager.NetEvents.AuthServerEvents.InitEventArgs(msg.Username, msg.UUID,
msg.PrivateKey,
msg.PublicKey));
break;
}
case MessageTypes.FailedLogin:
{
var msg = new FailedLoginMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Auth.FailedLogin.Invoke(
new EventManager.NetEvents.AuthServerEvents.FailedLoginEventArgs(msg.ErrorMessage));
break;
}
case MessageTypes.Verified:
{
var msg = new VerifiedMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Auth.Verified.Invoke(
new EventManager.NetEvents.AuthServerEvents.VerifiedEventArgs(msg.Verified));
break;
}
case MessageTypes.PluginDownload:
{
var msg = new PluginDownloadMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Auth.PluginDownloadRequested.Invoke(
new EventManager.NetEvents.AuthServerEvents.PluginDownloadEventArgs(msg));
break;
}
}
}
else // Message not from auth server, instead from a game server
{
var messageType = (MessageTypes)im.ReadByte(); // Find the type of data message sent
switch (messageType)
{
case MessageTypes.ServerInfo:
{
var msg = new ServerInfoMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.ServerInfoReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.ServerInfoEventArgs(msg.Description, msg.Players,
msg.MaxPlayers, im.SenderEndPoint));
break;
}
}
}
}
