public static bool RequestAccountReset(Service service, TelegramSettings settings)
{
try
{
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
try
{
var result = TelegramUtils.RunSynchronously(client.Methods.AccountDeleteAccountAsync(new AccountDeleteAccountArgs
{
Reason = "Forgot Password"
}));
return(result);
}
catch (RpcErrorException ex)
{
var error = (RpcError)ex.Error;
return(false);
}
}
}
catch (Exception ex)
{
service.DebugPrint("Error in VerifyPassword: " + ex);
return(false);
}
}
public static AuthPasswordRecovery RequestPasswordRecovery(Service service, TelegramSettings settings)
{
try
{
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
try
{
var result = (AuthPasswordRecovery)TelegramUtils.RunSynchronously(client.Methods.AuthRequestPasswordRecoveryAsync(new AuthRequestPasswordRecoveryArgs
{
}));
Thread.Sleep(100);
return(result);
}
catch (RpcErrorException ex)
{
var error = (RpcError)ex.Error;
return(null);
}
}
}
catch (Exception ex)
{
service.DebugPrint("Error in VerifyPassword: " + ex);
return(null);
}
}
public static async Task <AuthInfo> FetchNewAuthentication(TcpClientTransportConfig config)
{
var authKeyNegotiater = MTProtoClientBuilder.Default.BuildAuthKeyNegotiator(config);
authKeyNegotiater.KeyChain.Add(RSAPublicKey.Get());
return(await authKeyNegotiater.CreateAuthKey());
}
public DownloadManager(Document document, Telegram telegram)
{
_document = document;
_fileSize = document.Size;
_telegram = telegram;
int dcId = (int)_document.DcId;
//initialize the dc we want to download from
if (_document.DcId != _telegram.Settings.NearestDcId)
{
Retry:
// if its not the nearest dc, it could be unintialized. so lets check and init it.
var dc = DcDatabase.Get(dcId);
if (dc == null)
{
_telegram.GetClient(dcId);
//after this our dc configuration is ready, the connection should die out in a 60 secs.
}
var dcCached = DcDatabase.Get(dcId);
if (dcCached == null)
{
return;
}
var dcOption = _telegram.Config.DcOptions.Cast <DcOption>().FirstOrDefault(x => x.Id == dcId);
var tcpConfig = new TcpClientTransportConfig(dcOption.IpAddress, (int)dcOption.Port);
var authInfo = new SharpMTProto.Authentication.AuthInfo(dcCached.Key,
BitConverter.ToUInt64(dcCached.Salt, 0));
_client = new TelegramClient(tcpConfig,
new ConnectionConfig(authInfo.AuthKey, authInfo.Salt), AppInfo);
TelegramUtils.RunSynchronously(_client.Connect());
try
{
TelegramUtils.RunSynchronously(_client.Methods.AccountGetAccountTTLAsync(new AccountGetAccountTTLArgs()));
}
catch (Exception x)
{
if (x.Message != null && x.Message.Contains("401"))
{
telegram.DebugPrint("Yikes! DC went down. Let's reinstate it...");
_client.Dispose();
DcDatabase.Delete(dcId);
goto Retry;
}
}
}
else
{
var tcpConfig = new TcpClientTransportConfig(_telegram.Settings.NearestDcIp, (int)_telegram.Settings.NearestDcPort);
var authInfo = new SharpMTProto.Authentication.AuthInfo(_telegram.Settings.AuthKey,
_telegram.Settings.Salt);
_client = new TelegramClient(tcpConfig,
new ConnectionConfig(authInfo.AuthKey, authInfo.Salt), AppInfo);
TelegramUtils.RunSynchronously(_client.Connect());
}
}
public static DcOption GetDcConfig(int migrateId, TelegramSettings settings)
{
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
var config = (Config)TelegramUtils.RunSynchronously(client.Methods.HelpGetConfigAsync(new HelpGetConfigArgs {
}));
var dcOption = config.DcOptions.OfType <DcOption>().FirstOrDefault(x => x.Id == migrateId);
return(dcOption);
}
}
public static AuthExportedAuthorization GenerateExportedAuth(int migrateId, TelegramSettings settings)
{
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
var exportedAuth = (AuthExportedAuthorization)TelegramUtils.RunSynchronously(client.Methods.AuthExportAuthorizationAsync(
new SharpTelegram.Schema.AuthExportAuthorizationArgs
{
DcId = (uint)migrateId,
}));
return(exportedAuth);
}
}
public static CodeRegister VerifyPassword(Service service, TelegramSettings settings, byte[] passwordHash)
{
try
{
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
try
{
var iresult = TelegramUtils.RunSynchronously(client.Methods.AuthCheckPasswordAsync(new AuthCheckPasswordArgs
{
PasswordHash = passwordHash
}));
var result = (AuthAuthorization)iresult;
Thread.Sleep(100); //wait until the other response comes in.
return(new CodeRegister
{
AccountId = (result.User as User).Id,
Response = CodeRegister.Type.Success
});
}
catch (RpcErrorException ex)
{
var error = (RpcError)ex.Error;
var cr = new CodeRegister();
if (error.ErrorMessage == "PASSWORD_HASH_INVALID")
{
cr.Response = CodeRegister.Type.InvalidPassword;
}
return(cr);
}
}
}
catch (Exception ex)
{
service.DebugPrint("Error in VerifyPassword: " + ex);
return(null);
}
}
public static TelegramClient GetNewClient(int migrateId, TelegramSettings settings, out TelegramSettings newSettings)
{
var dcConfig = GetDcConfig(migrateId, settings);
var transportConfig = new TcpClientTransportConfig(dcConfig.IpAddress, (int)dcConfig.Port);
var authInfo = TelegramUtils.RunSynchronously(FetchNewAuthentication(transportConfig));
var newClient = new TelegramClient(transportConfig, new ConnectionConfig(authInfo.AuthKey, authInfo.Salt), AppInfo);
newSettings = new TelegramSettings();
newSettings.AccountId = settings.AccountId;
newSettings.AuthKey = authInfo.AuthKey;
newSettings.Salt = authInfo.Salt;
newSettings.NearestDcId = (uint)migrateId;
newSettings.NearestDcIp = dcConfig.IpAddress;
newSettings.NearestDcPort = (int)dcConfig.Port;
return(newClient);
}
public static CodeRegister VerifyCode(Service service, TelegramSettings settings, string code)
{
try
{
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
try
{
var iresult = TelegramUtils.RunSynchronously(client.Methods.AuthRecoverPasswordAsync(new AuthRecoverPasswordArgs
{
Code = code
}));
var result = (AuthAuthorization)iresult;
Thread.Sleep(100); //wait until the other response comes in.
return(new CodeRegister
{
AccountId = (result.User as User).Id,
Response = CodeRegister.Type.Success
});
}
catch (RpcErrorException ex)
{
var error = (RpcError)ex.Error;
var cr = new CodeRegister();
cr.Response = CodeRegister.Type.Failure;
return(cr);
}
}
}
catch (Exception ex)
{
service.DebugPrint("Error in VerifyPassword: " + ex);
return(null);
}
}
public FullClientDisposable(Telegram telegram)
{
if (telegram.IsFullClientConnected)
{
_client = telegram._fullClient;
_isFullClient = true;
}
else
{
var transportConfig =
new TcpClientTransportConfig(telegram._settings.NearestDcIp, telegram._settings.NearestDcPort);
var client = new TelegramClient(transportConfig,
new ConnectionConfig(telegram._settings.AuthKey, telegram._settings.Salt), AppInfo);
var result = TelegramUtils.RunSynchronously(client.Connect());
if (result != MTProtoConnectResult.Success)
{
throw new Exception("Failed to connect: " + result);
}
_client = client;
_isFullClient = false;
}
}
public DownloadManager(Document document, Telegram telegram)
{
_document = document;
_fileSize = document.Size;
_telegram = telegram;
int dcId = (int)_document.DcId;
//initialize the dc we want to download from
if (_document.DcId != _telegram.Settings.NearestDcId)
{
// if its not the nearest dc, it could be unintialized. so lets check and init it.
var dc = DcDatabase.Get(dcId);
if (dc == null)
{
_telegram.GetClient(dcId);
//after this our dc configuration is ready, the connection should die out in a 60 secs.
}
var dcCached = DcDatabase.Get(dcId);
var dcOption = _telegram.Config.DcOptions.Cast <DcOption>().FirstOrDefault(x => x.Id == dcId);
var tcpConfig = new TcpClientTransportConfig(dcOption.IpAddress, (int)dcOption.Port);
var authInfo = new SharpMTProto.Authentication.AuthInfo(dcCached.Key,
BitConverter.ToUInt64(dcCached.Salt, 0));
_client = new TelegramClient(tcpConfig,
new ConnectionConfig(authInfo.AuthKey, authInfo.Salt), AppInfo);
TelegramUtils.RunSynchronously(_client.Connect());
}
else
{
var tcpConfig = new TcpClientTransportConfig(_telegram.Settings.NearestDcIp, (int)_telegram.Settings.NearestDcPort);
var authInfo = new SharpMTProto.Authentication.AuthInfo(_telegram.Settings.AuthKey,
_telegram.Settings.Salt);
_client = new TelegramClient(tcpConfig,
new ConnectionConfig(authInfo.AuthKey, authInfo.Salt), AppInfo);
TelegramUtils.RunSynchronously(_client.Connect());
}
}
public static CodeRequest RequestCode(Service service, string number, string codeHash, TelegramSettings settings, bool call)
{
try
{
service.DebugPrint("Requesting code...");
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
if (!call)
{
try
{
var result = TelegramUtils.RunSynchronously(client.Methods.AuthSendCodeAsync(new AuthSendCodeArgs
{
PhoneNumber = number,
SmsType = 0,
ApiId = AppInfo.ApiId,
ApiHash = "f8f2562579817ddcec76a8aae4cd86f6",
LangCode = PhoneBook.Language
})) as AuthSentCode;
return(new CodeRequest
{
Registered = result.PhoneRegistered,
CodeHash = result.PhoneCodeHash,
});
}
catch (RpcErrorException ex)
{
var error = (RpcError)ex.Error;
var cr = new CodeRequest();
var response = CodeRequest.Type.Failure;
switch (error.ErrorCode)
{
case 400:
cr.Response = CodeRequest.Type.NumberInvalid;
break;
default:
cr.Response = CodeRequest.Type.Failure;
break;
}
return(cr);
}
}
var result2 = (bool)TelegramUtils.RunSynchronously(client.Methods.AuthSendCallAsync(new AuthSendCallArgs
{
PhoneNumber = number,
PhoneCodeHash = codeHash,
}));
return(new CodeRequest
{
Response = result2 ? CodeRequest.Type.Success : CodeRequest.Type.Failure
});
}
}
catch (Exception ex)
{
service.DebugPrint("Error in CodeRequest: " + ex);
}
return(null);
}
public async void DoCommand(string[] args)
{
var command = args[0].ToLower();
switch (command)
{
case "setup":
{
DebugPrint("Fetching nearest DC...");
var telegramSettings = new TelegramSettings();
var authInfo = await FetchNewAuthentication(DefaultTransportConfig);
using (var client = new TelegramClient(DefaultTransportConfig,
new ConnectionConfig(authInfo.AuthKey, authInfo.Salt), AppInfo))
{
await client.Connect();
var nearestDcId = (NearestDc)await(client.Methods.HelpGetNearestDcAsync(new HelpGetNearestDcArgs {
}));
var config = (Config)await(client.Methods.HelpGetConfigAsync(new HelpGetConfigArgs {
}));
var dcOption = config.DcOptions.OfType <DcOption>().FirstOrDefault(x => x.Id == nearestDcId.NearestDcProperty);
telegramSettings.NearestDcId = nearestDcId.NearestDcProperty;
telegramSettings.NearestDcIp = dcOption.IpAddress;
telegramSettings.NearestDcPort = (int)dcOption.Port;
}
DebugPrint("Generating authentication on nearest DC...");
var authInfo2 = await FetchNewAuthentication(
new TcpClientTransportConfig(telegramSettings.NearestDcIp, telegramSettings.NearestDcPort));
telegramSettings.AuthKey = authInfo2.AuthKey;
telegramSettings.Salt = authInfo2.Salt;
SettingsManager.Save(this, telegramSettings);
DebugPrint("Great! Ready for the service to start.");
}
break;
case "sendcode":
{
var number = args[1];
var transportConfig =
new TcpClientTransportConfig(_settings.NearestDcIp, _settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(_settings.AuthKey, _settings.Salt), AppInfo))
{
await client.Connect();
var result = await client.Methods.AuthSendCodeAsync(new AuthSendCodeArgs
{
PhoneNumber = number,
SmsType = 0,
ApiId = AppInfo.ApiId,
ApiHash = "f8f2562579817ddcec76a8aae4cd86f6",
LangCode = PhoneBook.Language
});
DebugPrint(ObjectDumper.Dump(result));
}
}
break;
case "signin":
{
var number = args[1];
var hash = args[2];
var code = args[3];
var transportConfig =
new TcpClientTransportConfig(_settings.NearestDcIp, _settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(_settings.AuthKey, _settings.Salt), AppInfo))
{
await client.Connect();
var result = (AuthAuthorization)await client.Methods.AuthSignInAsync(new AuthSignInArgs
{
PhoneNumber = number,
PhoneCodeHash = hash,
PhoneCode = code,
});
DebugPrint(ObjectDumper.Dump(result));
}
}
break;
case "signup":
{
var number = args[1];
var hash = args[2];
var code = args[3];
var firstName = args[4];
var lastName = args[5];
var transportConfig =
new TcpClientTransportConfig(_settings.NearestDcIp, _settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(_settings.AuthKey, _settings.Salt), AppInfo))
{
await client.Connect();
var result = (AuthAuthorization)await client.Methods.AuthSignUpAsync(new AuthSignUpArgs
{
PhoneNumber = number,
PhoneCodeHash = hash,
PhoneCode = code,
FirstName = firstName,
LastName = lastName,
});
DebugPrint(ObjectDumper.Dump(result));
}
}
break;
case "getcontacts":
{
var result = await _fullClient.Methods.ContactsGetContactsAsync(new ContactsGetContactsArgs
{
Hash = string.Empty
});
DebugPrint(ObjectDumper.Dump(result));
}
break;
case "sendhello":
{
var contacts = (ContactsContacts)await _fullClient.Methods.ContactsGetContactsAsync(new ContactsGetContactsArgs
{
Hash = string.Empty
});
var counter = 0;
Console.WriteLine("Pick a contact:");
foreach (var icontact in contacts.Users)
{
var contact = icontact as UserContact;
if (contact == null)
{
continue;
}
Console.WriteLine(counter++ + ") " + contact.FirstName + " " + contact.LastName);
}
var choice = int.Parse(Console.ReadLine());
var chosenContact = (UserContact)contacts.Users[choice];
var result = await _fullClient.Methods.MessagesSendMessageAsync(new MessagesSendMessageArgs
{
Peer = new InputPeerContact
{
UserId = chosenContact.Id,
},
Message = "Hello from Disa!",
RandomId = (ulong)Time.GetNowUnixTimestamp(),
});
Console.WriteLine(ObjectDumper.Dump(result));
}
break;
}
}
public static CodeRequest RequestCode(Service service, string number, string codeHash, TelegramSettings settings, bool reVerify)
{
try
{
service.DebugPrint("Requesting code...");
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
try
{
AuthSentCode result;
if (reVerify)
{
result = TelegramUtils.RunSynchronously(client.Methods.AuthResendCodeAsync(new AuthResendCodeArgs
{
PhoneNumber = number,
PhoneCodeHash = codeHash
})) as AuthSentCode;
}
else
{
result = TelegramUtils.RunSynchronously(client.Methods.AuthSendCodeAsync(new AuthSendCodeArgs
{
PhoneNumber = number,
ApiId = AppInfo.ApiId,
ApiHash = "f8f2562579817ddcec76a8aae4cd86f6",
})) as AuthSentCode;
}
return(new CodeRequest
{
Registered = result.PhoneRegistered != null ? true : false,
CodeHash = result.PhoneCodeHash,
CurrentType = GetAuthSentType(result.Type),
NextType = GetAuthType(result.NextType)
});
}
catch (RpcErrorException ex)
{
Utils.DebugPrint(">>>> Send code failure " + ObjectDumper.Dump(ex));
var error = (RpcError)ex.Error;
var cr = new CodeRequest();
var response = CodeRequest.Type.Failure;
switch (error.ErrorCode)
{
case 400:
cr.Response = CodeRequest.Type.NumberInvalid;
break;
case 303:
var newDcId = GetDcId(error.ErrorMessage);
cr.Response = CodeRequest.Type.Migrate;
cr.MigrateId = newDcId;
break;
default:
cr.Response = CodeRequest.Type.Failure;
break;
}
return(cr);
}
return(new CodeRequest
{
Response = CodeRequest.Type.Success
});
}
}
catch (Exception ex)
{
service.DebugPrint("Error in CodeRequest: " + ex);
}
return(null);
}
private TelegramClient SpinUpClient(int dc)
{
object dcLock;
lock (_spinUpLocks)
{
if (_spinUpLocks.ContainsKey(dc))
{
dcLock = _spinUpLocks[dc];
}
else
{
dcLock = new object();
_spinUpLocks[dc] = dcLock;
}
}
lock (dcLock)
{
var client = GetClientInternal(dc);
if (client != null)
{
return(client);
}
if (_config == null)
{
DebugPrint("Config is null. Unable to resolve DC information.");
return(null);
}
var dcOption = _config.DcOptions.Cast <DcOption>().FirstOrDefault(x => x.Id == dc);
if (dcOption == null)
{
DebugPrint("Unable to find DC for DC ID: " + dc);
return(null);
}
var dcCached = DcDatabase.Get(dc);
var transportConfig =
new TcpClientTransportConfig(dcOption.IpAddress, (int)dcOption.Port);
SharpMTProto.Authentication.AuthInfo authInfo;
AuthExportedAuthorization exportedAuth = null;
if (dcCached == null)
{
DebugPrint("Looks like we'll have to authenticate a new connection to: "
+ ObjectDumper.Dump(dcOption));
DebugPrint(">>>>>>>> Exporting auth...");
using (var clientDisposable = new TelegramClientDisposable(this))
{
exportedAuth = (AuthExportedAuthorization)TelegramUtils.RunSynchronously(clientDisposable.Client.Methods.AuthExportAuthorizationAsync(
new SharpTelegram.Schema.Layer18.AuthExportAuthorizationArgs
{
DcId = (uint)dc,
}));
}
DebugPrint(">>>>>>> Got exported auth.");
if (exportedAuth == null)
{
DebugPrint("Exported auth is null for some weird reason. DC ID: " + dc);
return(null);
}
DebugPrint(">>>>>>> Fetching new authentication...");
authInfo = TelegramUtils.RunSynchronously(FetchNewAuthentication(transportConfig));
}
else
{
authInfo = new SharpMTProto.Authentication.AuthInfo(dcCached.Key,
BitConverter.ToUInt64(dcCached.Salt, 0));
}
DebugPrint(">>>>>>>> Starting new client...");
var newClient = new TelegramClient(transportConfig,
new ConnectionConfig(authInfo.AuthKey, authInfo.Salt), AppInfo);
newClient.OnClosedInternally += (sender, e) =>
{
DebugPrint("Removing connection to DC: " + dc);
lock (_activeClients)
{
_activeClients.Remove(dc);
}
};
var result = TelegramUtils.RunSynchronously(newClient.Connect());
if (result != MTProtoConnectResult.Success)
{
DebugPrint("Failed to connect to DC: " + dc + ": " + result);
return(null);
}
if (exportedAuth != null)
{
TelegramUtils.RunSynchronously(newClient.Methods.AuthImportAuthorizationAsync(new AuthImportAuthorizationArgs
{
Id = exportedAuth.Id,
Bytes = exportedAuth.Bytes,
}));
}
PingDelay(client, 60);
lock (_activeClients)
{
_activeClients[dc] = newClient;
}
if (dcCached == null)
{
DcDatabase.Set(new TelegramDc
{
Dc = dc,
Key = authInfo.AuthKey,
Salt = BitConverter.GetBytes(authInfo.Salt),
});
}
return(newClient);
}
}
public static CodeRegister RegisterCode(Service service, TelegramSettings settings, string number, string codeHash, string code, string firstName, string lastName, bool signIn)
{
try
{
service.DebugPrint("Registering code...");
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
try
{
IAuthAuthorization iresult = null;
if (signIn)
{
iresult = TelegramUtils.RunSynchronously(client.Methods.AuthSignInAsync(new AuthSignInArgs
{
PhoneNumber = number,
PhoneCodeHash = codeHash,
PhoneCode = code,
}));
}
else
{
iresult = TelegramUtils.RunSynchronously(client.Methods.AuthSignUpAsync(new AuthSignUpArgs
{
PhoneNumber = number,
PhoneCodeHash = codeHash,
PhoneCode = code,
FirstName = firstName,
LastName = lastName,
}));
}
var result = (AuthAuthorization)iresult;
Thread.Sleep(100); //wait until the other response comes in, if it has to.
return(new CodeRegister
{
AccountId = (result.User as User).Id,
Response = CodeRegister.Type.Success,
});
}
catch (RpcErrorException ex)
{
Utils.DebugPrint(">>>>>> Failed to sign in " + ex);
var error = (RpcError)ex.Error;
var cr = new CodeRegister();
switch (error.ErrorMessage)
{
case "PHONE_NUMBER_INVALID":
cr.Response = CodeRegister.Type.NumberInvalid;
break;
case "PHONE_CODE_EMPTY":
cr.Response = CodeRegister.Type.CodeEmpty;
break;
case "PHONE_CODE_EXPIRED":
cr.Response = CodeRegister.Type.CodeExpired;
break;
case "PHONE_CODE_INVALID":
cr.Response = CodeRegister.Type.CodeInvalid;
break;
case "FIRSTNAME_INVALID":
cr.Response = CodeRegister.Type.FirstNameInvalid;
break;
case "LASTNAME_INVALID":
cr.Response = CodeRegister.Type.LastNameInvalid;
break;
case "SESSION_PASSWORD_NEEDED":
cr.Response = CodeRegister.Type.PasswordNeeded;
GetPasswordDetails(client, cr);
break;
default:
cr.Response = CodeRegister.Type.Failure;
break;
}
return(cr);
}
}
}
catch (Exception ex)
{
service.DebugPrint("Error in CodeRequest: " + ex);
}
return(null);
}
public async void DoCommand(string[] args)
{
var command = args[0].ToLower();
switch (command)
{
case "decrypt":
{
try
{
var bytes = Convert.FromBase64String("+MW7Btpz31b0gt9WN5d5vAEAAAAVxLUcCwAAAMzG2AUAAAAAAQAAAA4xNDkuMTU0LjE3NS41MAC7AQAAzMbYBQEAAAABAAAAJzIwMDE6MGIyODpmMjNkOmYwMDE6MDAwMDowMDAwOjAwMDA6MDAwYbsBAADMxtgFAAAAAAIAAAAOMTQ5LjE1NC4xNjcuNTEAuwEAAMzG2AUBAAAAAgAAACcyMDAxOjA2N2M6MDRlODpmMDAyOjAwMDA6MDAwMDowMDAwOjAwMGG7AQAAzMbYBQAAAAADAAAADzE0OS4xNTQuMTc1LjEwMLsBAADMxtgFAQAAAAMAAAAnMjAwMTowYjI4OmYyM2Q6ZjAwMzowMDAwOjAwMDA6MDAwMDowMDBhuwEAAMzG2AUAAAAABAAAAA4xNDkuMTU0LjE2Ny45MQC7AQAAzMbYBQEAAAAEAAAAJzIwMDE6MDY3YzowNGU4OmYwMDQ6MDAwMDowMDAwOjAwMDA6MDAwYbsBAADMxtgFAgAAAAQAAAAPMTQ5LjE1NC4xNjUuMTIwuwEAAMzG2AUAAAAABQAAAA05MS4xMDguNTYuMTgwAAC7AQAAzMbYBQEAAAAFAAAAJzIwMDE6MGIyODpmMjNmOmYwMDU6MDAwMDowMDAwOjAwMDA6MDAwYbsBAADIAAAA6AMAAGQAAADA1AEAiBMAADB1AADgkwQAMHUAANwFAAAKAAAAYOoAAAIAAADIAAAAFcS1HAAAAAA=");
TLRig.Default.PrepareSerializersForAllTLObjectsInAssembly(typeof(IMTProtoAsyncMethods).Assembly);
using (var streamer = new TLStreamer(bytes))
{
var newResult = TLRig.Default.Deserialize(streamer);
int hi = 5;
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
break;
case "setup":
{
DebugPrint("Fetching nearest DC...");
var telegramSettings = new TelegramSettings();
var authInfo = await FetchNewAuthentication(DefaultTransportConfig);
using (var client = new TelegramClient(DefaultTransportConfig,
new ConnectionConfig(authInfo.AuthKey, authInfo.Salt), AppInfo))
{
await client.Connect();
var nearestDcId = (NearestDc)await(client.Methods.HelpGetNearestDcAsync(new HelpGetNearestDcArgs {
}));
var config = (Config)await(client.Methods.HelpGetConfigAsync(new HelpGetConfigArgs {
}));
var dcOption = config.DcOptions.OfType <DcOption>().FirstOrDefault(x => x.Id == nearestDcId.NearestDcProperty);
telegramSettings.NearestDcId = nearestDcId.NearestDcProperty;
telegramSettings.NearestDcIp = dcOption.IpAddress;
telegramSettings.NearestDcPort = (int)dcOption.Port;
}
DebugPrint("Generating authentication on nearest DC...");
var authInfo2 = await FetchNewAuthentication(
new TcpClientTransportConfig(telegramSettings.NearestDcIp, telegramSettings.NearestDcPort));
telegramSettings.AuthKey = authInfo2.AuthKey;
telegramSettings.Salt = authInfo2.Salt;
SettingsManager.Save(this, telegramSettings);
DebugPrint("Great! Ready for the service to start.");
}
break;
case "sendcode":
{
var number = args[1];
var transportConfig =
new TcpClientTransportConfig(_settings.NearestDcIp, _settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(_settings.AuthKey, _settings.Salt), AppInfo))
{
await client.Connect();
var result = await client.Methods.AuthSendCodeAsync(new AuthSendCodeArgs
{
PhoneNumber = number,
ApiId = AppInfo.ApiId,
ApiHash = "f8f2562579817ddcec76a8aae4cd86f6",
});
DebugPrint(ObjectDumper.Dump(result));
}
}
break;
case "signin":
{
var number = args[1];
var hash = args[2];
var code = args[3];
var transportConfig =
new TcpClientTransportConfig(_settings.NearestDcIp, _settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(_settings.AuthKey, _settings.Salt), AppInfo))
{
await client.Connect();
var result = (AuthAuthorization)await client.Methods.AuthSignInAsync(new AuthSignInArgs
{
PhoneNumber = number,
PhoneCodeHash = hash,
PhoneCode = code,
});
DebugPrint(ObjectDumper.Dump(result));
}
}
break;
case "signup":
{
var number = args[1];
var hash = args[2];
var code = args[3];
var firstName = args[4];
var lastName = args[5];
var transportConfig =
new TcpClientTransportConfig(_settings.NearestDcIp, _settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(_settings.AuthKey, _settings.Salt), AppInfo))
{
await client.Connect();
var result = (AuthAuthorization)await client.Methods.AuthSignUpAsync(new AuthSignUpArgs
{
PhoneNumber = number,
PhoneCodeHash = hash,
PhoneCode = code,
FirstName = firstName,
LastName = lastName,
});
DebugPrint(ObjectDumper.Dump(result));
}
}
break;
case "getcontacts":
{
var result = await _fullClient.Methods.ContactsGetContactsAsync(new ContactsGetContactsArgs
{
Hash = string.Empty
});
DebugPrint(ObjectDumper.Dump(result));
}
break;
// case "sendhello":
// {
// var contacts = (ContactsContacts)await _fullClient.Methods.ContactsGetContactsAsync(new ContactsGetContactsArgs
// {
// Hash = string.Empty
// });
// var counter = 0;
// Console.WriteLine("Pick a contact:");
// foreach (var icontact in contacts.Users)
// {
// var contact = icontact as UserContact;
// if (contact == null)
// continue;
// Console.WriteLine(counter++ + ") " + contact.FirstName + " " + contact.LastName);
// }
// var choice = int.Parse(Console.ReadLine());
// var chosenContact = (UserContact)contacts.Users[choice];
// var result = await _fullClient.Methods.MessagesSendMessageAsync(new MessagesSendMessageArgs
// {
// Peer = new InputPeerContact
// {
// UserId = chosenContact.Id,
// },
// Message = "Hello from Disa!",
// RandomId = (ulong)Time.GetNowUnixTimestamp(),
// });
// Console.WriteLine(ObjectDumper.Dump(result));
// }
// break;
}
}
