public async Task <IUpdates> SendUploadedDocument(
IInputPeer peer,
IInputFile file,
string caption,
string mimeType,
TVector <IDocumentAttribute> attributes)
{
EnsureUserAuthorized();
return(await SenderService.SendRequestAsync(new RequestSendMedia
{
RandomId = TlHelpers.GenerateRandomLong(),
Background = false,
ClearDraft = false,
Media = new TInputMediaUploadedDocument
{
File = file,
Caption = caption,
MimeType = mimeType,
Attributes = attributes
},
Peer = peer
}).ConfigureAwait(false));
}
public async Task <IInputFile> UploadFile(string name, StreamReader reader)
{
const long TenMb = 10 * 1024 * 1024;
var isBigFileUpload = reader.BaseStream.Length >= TenMb;
var file = await GetFile(reader).ConfigureAwait(false);
var fileParts = GetFileParts(file);
var partNumber = 0;
var partsCount = fileParts.Count;
var fileId = BitConverter.ToInt64(TlHelpers.GenerateRandomBytes(8), 0);
while (fileParts.Count != 0)
{
var part = fileParts.Dequeue();
if (isBigFileUpload)
{
await SenderService.SendRequestAsync(
new RequestSaveBigFilePart
{
FileId = fileId,
FilePart = partNumber,
Bytes = part,
FileTotalParts = partsCount
}).ConfigureAwait(false);
}
else
{
await SenderService.SendRequestAsync(
new RequestSaveFilePart
{
FileId = fileId,
FilePart = partNumber,
Bytes = part
}).ConfigureAwait(false);
}
partNumber++;
}
if (isBigFileUpload)
{
return(new TInputFileBig
{
Id = fileId,
Name = name,
Parts = partsCount
});
}
return(new TInputFile
{
Id = fileId,
Name = name,
Parts = partsCount,
Md5Checksum = GetFileHash(file)
});
}
private Tuple <byte[], long> DecodeMessage(byte[] body)
{
byte[] message;
long remoteMessageId;
using (var inputStream = new MemoryStream(body))
using (var inputReader = new BinaryReader(inputStream))
{
if (inputReader.BaseStream.Length < 8)
{
throw new InvalidOperationException("Can\'t decode packet");
}
var remoteAuthKeyId = inputReader.ReadUInt64(); // TODO: check auth key id
var msgKey = inputReader.ReadBytes(16); // TODO: check msg_key correctness
var keyData = TlHelpers.CalcKey(ClientSettings.Session.AuthKey.Data, msgKey, false);
var plaintext = AES.DecryptAes(
keyData,
inputReader.ReadBytes((int)(inputStream.Length - inputStream.Position)));
using (var plaintextStream = new MemoryStream(plaintext))
using (var plaintextReader = new BinaryReader(plaintextStream))
{
var remoteSalt = plaintextReader.ReadUInt64();
var remoteSessionId = plaintextReader.ReadUInt64();
remoteMessageId = plaintextReader.ReadInt64();
plaintextReader.ReadInt32();
var msgLen = plaintextReader.ReadInt32();
message = plaintextReader.ReadBytes(msgLen);
}
}
return(Tuple.Create(message, remoteMessageId));
}
/// <summary>
/// Send text message to peer
/// </summary>
/// <returns>
/// Object contains list of updates.
/// </returns>
public async Task <IUpdates> SendMessageAsync(IInputPeer peer, string message)
{
EnsureUserAuthorized();
return(await SenderService.SendRequestAsync(
new RequestSendMessage
{
Peer = peer,
Message = message,
RandomId = TlHelpers.GenerateRandomLong()
}).ConfigureAwait(false));
}
/// <summary>Send text message to peer</summary>
/// <returns>Object contains list of updates.</returns>
public async Task <IUpdates> SendMessageAsync(IInputPeer peer, string message, CancellationToken cancellationToken = default(CancellationToken))
{
AuthApiService.EnsureUserAuthorized();
return(await SenderService.SendRequestAsync(
new RequestSendMessage
{
Peer = peer,
Message = message,
RandomId = TlHelpers.GenerateRandomLong()
},
cancellationToken).ConfigureAwait(false));
}
/// <summary>Forwards single messages.</summary>
/// <param name="peer">User or chat where a message will be forwarded</param>
/// <param name="messageId">Forwarded message ID</param>
/// <returns>Returns a <see cref="IUpdates" /> object containing a service message sent during an action.</returns>
public async Task <IUpdates> ForwardMessageAsync(IInputPeer peer, int messageId, CancellationToken cancellationToken = default(CancellationToken))
{
AuthApiService.EnsureUserAuthorized();
var forwardMessage = new RequestForwardMessage
{
Peer = peer,
Id = messageId,
RandomId = TlHelpers.GenerateRandomLong()
};
return(await SenderService.SendRequestAsync(forwardMessage, cancellationToken).ConfigureAwait(false));
}
/// <summary>
/// Forwards single messages.
/// </summary>
/// <param name="peer">User or chat where a message will be forwarded</param>
/// <param name="messageId">Forwarded message ID</param>
/// <returns>Returns a <see cref="IUpdates"/> object containing a service message sent during an action.</returns>
public async Task <IUpdates> ForwardMessageAsync(IInputPeer peer, int messageId)
{
EnsureUserAuthorized();
var forwardMessage = new RequestForwardMessage
{
Peer = peer,
Id = messageId,
RandomId = TlHelpers.GenerateRandomLong()
};
return(await SenderService.SendRequestAsync(forwardMessage).ConfigureAwait(false));
}
public static async Task <TlAbsUpdates> SendUploadedPhoto(this ITelegramClient client, TlAbsInputPeer peer,
TlAbsInputFile file, string caption)
{
return(await client.SendRequestAsync <TlAbsUpdates>(new TlRequestSendMedia
{
RandomId = TlHelpers.GenerateRandomLong(),
Background = false,
ClearDraft = false,
Media = new TlInputMediaUploadedPhoto {
File = file, Caption = caption
},
Peer = peer
}));
}
private byte[] PrepareToSend(IObject obj, out long mesId)
{
var packet = Serializer.SerializeObject(obj);
var genResult = ClientSettings.Session.GenerateMsgIdAndSeqNo(obj is IRequest);
mesId = genResult.Item1;
Log.Debug($"Send message with Id = {mesId} and seqNo = {genResult.Item2}");
byte[] msgKey;
byte[] ciphertext;
var randomPaddingLenght = TlHelpers.GenerateRandomInt(1024 / 16) * 16;
using (var plaintextPacket = MakeMemory(8 + 8 + 8 + 4 + 4 + packet.Length + randomPaddingLenght))
{
using (var plaintextWriter = new BinaryWriter(plaintextPacket))
{
plaintextWriter.Write(ClientSettings.Session.Salt);
plaintextWriter.Write(ClientSettings.Session.Id);
plaintextWriter.Write(mesId);
plaintextWriter.Write(genResult.Item2);
plaintextWriter.Write(packet.Length);
plaintextWriter.Write(packet);
plaintextWriter.Write(TlHelpers.GenerateRandomBytes(randomPaddingLenght));
plaintextPacket.TryGetBuffer(out var buffer);
var authKey = ClientSettings.Session.AuthKey.Data;
msgKey = TlHelpers.CalcMsgKey(authKey, buffer.Array);
var key = TlHelpers.CalcKey(authKey, msgKey, true);
ciphertext = AES.EncryptAes(key, buffer.Array);
}
}
using (var ciphertextPacket = MakeMemory(8 + 16 + ciphertext.Length))
{
using (var writer = new BinaryWriter(ciphertextPacket))
{
writer.Write(ClientSettings.Session.AuthKey.Id);
writer.Write(msgKey);
writer.Write(ciphertext);
return(ciphertextPacket.ToArray());
}
}
}
/// <summary>
/// Sends a non-text message.
/// </summary>
/// <param name="peer">User or group to receive the message</param>
/// <param name="media">Message contents</param>
/// <returns>
/// Returns a <see cref="IUpdates"/> object containing a service message sent during the action.
/// </returns>
public async Task <IUpdates> SendMediaAsync(IInputPeer peer, IInputMedia media)
{
EnsureUserAuthorized();
var sendMedia = new RequestSendMedia
{
RandomId = TlHelpers.GenerateRandomLong(),
Peer = peer,
Media = media,
Background = false,
ClearDraft = false
};
return(await SenderService.SendRequestAsync(sendMedia).ConfigureAwait(false));
}
public async Task <IUpdates> SendUploadedPhoto(IInputPeer peer, IInputFile file, string caption)
{
EnsureUserAuthorized();
return(await SenderService.SendRequestAsync(new RequestSendMedia
{
RandomId = TlHelpers.GenerateRandomLong(),
Background = false,
ClearDraft = false,
Media = new TInputMediaUploadedPhoto {
File = file, Caption = caption
},
Peer = peer
}).ConfigureAwait(false));
}
public async Task <TlAbsUpdates> SendMessageAsync(TlAbsInputPeer peer, string message)
{
if (!this.IsUserAuthorized())
{
throw new InvalidOperationException("Authorize user first!");
}
return(await SendRequestAsync <TlAbsUpdates>(
new TlRequestSendMessage
{
Peer = peer,
Message = message,
RandomId = TlHelpers.GenerateRandomLong()
}));
}
/// <summary>
/// Forwards messages by their IDs.
/// </summary>
/// <param name="fromPeer">User or chat from where a message will be forwarded</param>
/// <param name="toPeer">User or chat where a message will be forwarded</param>
/// <param name="ids">Forwarded message IDs</param>
/// <param name="silent"></param>
/// <param name="withMyScore"></param>
/// <returns>Returns a <see cref="IUpdates"/> object containing a service message sent during an action.</returns>
public async Task <IUpdates> ForwardMessagesAsync(IInputPeer fromPeer, IInputPeer toPeer, TVector <int> ids, bool silent, bool withMyScore)
{
EnsureUserAuthorized();
var forwardMessages = new RequestForwardMessages
{
FromPeer = fromPeer,
ToPeer = toPeer,
Id = ids,
Background = false,
Silent = silent,
WithMyScore = withMyScore,
RandomId = TlHelpers.GenerateRandomTVectorLong(ids.Items.Count)
};
return(await SenderService.SendRequestAsync(forwardMessages));
}
private byte[] PrepareToSend(TlMethod request, out ulong mesId)
{
var packet = BinaryHelper.WriteBytes(request.SerializeBody);
var genResult = ClientSettings.Session.GenerateMsgIdAndSeqNo(request.Confirmed);
mesId = genResult.Item1;
Log.Debug($"Send message with Id = {mesId} and seqNo = {genResult.Item2}");
byte[] msgKey;
byte[] ciphertext;
using (var plaintextPacket = MakeMemory(8 + 8 + 8 + 4 + 4 + packet.Length))
{
using (var plaintextWriter = new BinaryWriter(plaintextPacket))
{
plaintextWriter.Write(ClientSettings.Session.Salt);
plaintextWriter.Write(ClientSettings.Session.Id);
plaintextWriter.Write(mesId);
plaintextWriter.Write(genResult.Item2);
plaintextWriter.Write(packet.Length);
plaintextWriter.Write(packet);
plaintextPacket.TryGetBuffer(out var buffer);
msgKey = TlHelpers.CalcMsgKey(buffer.Array);
ciphertext = AES.EncryptAes(TlHelpers.CalcKey(ClientSettings.Session.AuthKey.Data, msgKey, true), buffer.Array);
}
}
using (var ciphertextPacket = MakeMemory(8 + 16 + ciphertext.Length))
{
using (var writer = new BinaryWriter(ciphertextPacket))
{
writer.Write(ClientSettings.Session.AuthKey.Id);
writer.Write(msgKey);
writer.Write(ciphertext);
return(ciphertextPacket.ToArray());
}
}
}
private void AddSendHandler(Mock <ITcpTransport> mock, IRequest request)
{
mock
.BuildSend(
bytes =>
{
var session = Container.Resolve <IClientSettings>().Session;
byte[] plainText = null;
BinaryHelper.ReadBytes(
bytes,
reader =>
{
Assert.Equal(session.AuthKey.Id, reader.ReadUInt64());
var msgKey = reader.ReadBytes(16);
var cipherText = reader.ReadBytes(bytes.Length - 8 - 16);
plainText = AES.DecryptAes(TlHelpers.CalcKey(session.AuthKey.Data, msgKey, true), cipherText);
});
Assert.NotNull(plainText);
BinaryHelper.ReadBytes(
plainText,
reader =>
{
Assert.Equal(session.Salt, reader.ReadUInt64());
Assert.Equal(session.Id, reader.ReadUInt64());
Assert.Equal(0, reader.ReadInt32());
var packetLength = reader.ReadInt32();
Assert.True(packetLength > 0);
var requestBytes = Serializer.SerializeObject(request);
Assert.Equal(requestBytes, reader.ReadBytes(packetLength));
});
});
}
public static async Task <TlAbsUpdates> SendUploadedDocument(
this ITelegramClient client,
TlAbsInputPeer peer,
TlAbsInputFile file,
string caption,
string mimeType,
TlVector <TlAbsDocumentAttribute> attributes)
{
return(await client.SendRequestAsync <TlAbsUpdates>(new TlRequestSendMedia
{
RandomId = TlHelpers.GenerateRandomLong(),
Background = false,
ClearDraft = false,
Media = new TlInputMediaUploadedDocument
{
File = file,
Caption = caption,
MimeType = mimeType,
Attributes = attributes
},
Peer = peer
}));
}
private byte[] EncodePacket(byte[] packet, ulong messageId)
{
var session = Container.Resolve <IClientSettings>().Session;
var plainTextStream = BinaryHelper.WriteBytes(
8 + 8 + 8 + 4 + 4 + packet.Length,
writer =>
{
writer.Write(session.Salt);
writer.Write(session.Id);
writer.Write(messageId);
writer.Write(0);
writer.Write(packet.Length);
writer.Write(packet);
});
var plainText = plainTextStream.GetBytesWithBuffer();
plainTextStream.Dispose();
var msgKey = TlHelpers.CalcMsgKey(plainText);
var ciphertext = AES.EncryptAes(TlHelpers.CalcKey(session.AuthKey.Data, msgKey, false), plainText);
var chipedTextStream = BinaryHelper.WriteBytes(
8 + 16 + ciphertext.Length,
writer =>
{
writer.Write(session.AuthKey.Id);
writer.Write(msgKey);
writer.Write(ciphertext);
});
var result = chipedTextStream.ToArray();
chipedTextStream.Dispose();
return(result);
}
