public async Task <Player> GetOrCreateAsync(PlayerCredentials playerCredentials)
{
using (var dbContext = _dbContextFactory.CreateDbContext())
{
var playerInDatabase = await GetAsync(playerCredentials.Username, dbContext);
if (playerInDatabase == null)
{
var defaultPlayer = new Player
{
Username = playerCredentials.Username,
Password = playerCredentials.Password,
Position = new Position(3333, 3333, 0),
Appearance = Appearance.DefaultAppearance
};
dbContext.Attach(defaultPlayer);
dbContext.Add(defaultPlayer.Position);
dbContext.Add(defaultPlayer);
await dbContext.SaveChangesAsync();
return(defaultPlayer);
}
return(playerInDatabase);
}
}
public void LoginRequest(PlayerCredentials cred)
{
string data = JsonUtility.ToJson(cred);
socket.Emit("player login", new JSONObject(data));
Debug.Log("emit player login " + data);
}
public void CreateAccountRequest(PlayerCredentials cred)
{
string data = JsonUtility.ToJson(cred);
socket.Emit("player create_account", new JSONObject(data));
Debug.Log("emit player create_account " + data);
}
public async Task <bool> Login()
{
try
{
playerCredentials = GameObject.Find("Login").GetComponent <UserManager>().playerLoginCredentials;
string jsonText = JsonConvert.SerializeObject(playerCredentials);
StringContent data = new StringContent(jsonText, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync("Login", data);
response.EnsureSuccessStatusCode();
var tokenTemp = await response.Content.ReadAsStringAsync();
if (tokenTemp != null)
{
if (token != string.Empty)
{
client.DefaultRequestHeaders.Remove("Token");
}
token = tokenTemp;
this.SetToken();
Debug.Log("Successfull");
}
await this.GetPlayerID();
return(true);
}
catch
{
Debug.Log("Login not successfull");
return(false);
}
}
static void Main(string[] args)
{
InstalledGame installedGame = new InstalledGame("D:\\Games\\MTGA");
PlayerCredentials credentials = new PlayerCredentials(installedGame.GetRefreshToken());
// PlayerCredentials credentials = new PlayerCredentials("username", "password");
Console.WriteLine("Authenticating...");
bool verified = credentials.VerifyAsyncTask().GetAwaiter().GetResult();
if (verified)
{
Console.WriteLine("Logged in!");
_ticket = credentials.AccessToken;
installedGame.SaveRefreshToken(credentials.RefreshToken);
}
else
{
Console.WriteLine("Invalid credentials!");
Console.ReadKey();
return;
}
DoYourThing();
Console.ReadKey();
}
public ClientData RegisterPlayer(PlayerCredentials credentials)
{
ClientData player = new ClientData(Guid.NewGuid().ToString(), credentials.Name, credentials.Password);
this.AllRegisteredPlayers.Add(player);
return(player);
}
private void ValidateUser(string name, byte[] passwordHash, Action <PlayerCredentials> callback)
{
PlayerCredentials credetials = GetCredentials(name);
if (credetials == null)
{
callback(null);
return;
}
callback(Equals(credetials.PasswordHash, passwordHash) ? credetials : null);
}
public ServerLogic.ClientData RegisterPlayer(PlayerCredentials player)
{
if (this.manager.AllRegisteredPlayers.Any(client => client.Name == player.Name) || player.Name == string.Empty || player.Name == null || player.Password == string.Empty || player.Password == null)
{
// already registered or name/password not valid
return(null);
}
var playermodel = this.manager.RegisterPlayer(player);
return(playermodel);
}
public ActionResult <string> RegisterPlayer([FromBody] PlayerCredentials credentials)
{
this.UpdateData();
ServerLogic.ClientData player = this.service.RegisterPlayer(credentials);
if (player != null)
{
this.rep.RegisterPlayer(player);
return(player.ID);
}
return(string.Empty);
}
private void ValidateUser(string name, string password, Action <PlayerCredentials> callback)
{
PlayerCredentials credetials = GetCredentials(name);
if (credetials == null)
{
callback(null);
return;
}
byte[] passwordHash = GenerateHash(Encoding.UTF8.GetBytes(password), credetials.Salt, credetials.Iterations, HASH_LENGTH);
callback(Equals(credetials.PasswordHash, passwordHash) ? credetials : null);
}
public void CreatePlayer(Guid guid, string name, string password, Action <Error, Player, byte[]> callback)
{
PlayerCredentials credentials = GetCredentials(name);
if (credentials != null)
{
callback(new Error(StatusCode.AlreadyExists), null, null);
return;
}
if (string.IsNullOrWhiteSpace(password) || password.Length < 1)
{
callback(new Error(StatusCode.NotAllowed)
{
Message = "Password required"
}, null, new byte[0]);
return;
}
byte[] salt = GenerateSalt(SALT_LENGTH);
byte[] pwd = GenerateHash(Encoding.UTF8.GetBytes(password), salt, ITERATIONS, HASH_LENGTH);
const string sql = "INSERT INTO Player(PlayerId, Name, Password, Salt, Iterations) VALUES (@PlayerId, @Name, @Password, @Salt, @Iterations)";
try
{
Db.Begin.ExecuteNonQuery(null, null, sql,
Db.Get.Parameter("@PlayerId", guid),
Db.Get.Parameter("@Name", name),
Db.Get.Parameter("@Password", pwd),
Db.Get.Parameter("@Salt", salt),
Db.Get.Parameter("@Iterations", ITERATIONS));
callback(new Error(StatusCode.OK),
new Player
{
Name = name,
BotType = BotType.None,
Id = guid,
Victories = 0,
},
pwd);
}
catch (Exception e)
{
callback(new Error(StatusCode.UnhandledException)
{
Message = e.ToString()
}, null, new byte[0]);
}
}
public ActionResult <string> LoginPlayer([FromBody] PlayerCredentials credentials)
{
this.UpdateData();
string token = Guid.NewGuid().ToString();
if (this.service.LoginPlayer(credentials, token) && this.rep.CheckIfPlayerExist(credentials.Name, credentials.Password, token))
{
this.rep.SetAllRegisteredPlayer(this.service.GetAllPlayers());
this.UpdateData();
return(token);
}
return(BadRequest(400));
}
private async Task <bool> Register()
{
try
{
playerCredentials = GameObject.Find("Register").GetComponent <UserManager>().playerRegisterCredentials;
string jsonText = JsonConvert.SerializeObject(playerCredentials);
StringContent data = new StringContent(jsonText, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync("Register", data);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
playerCredentials.ID = content;
return(true);
}
catch
{
Debug.Log("Register not successfull");
return(false);
}
}
private PlayerCredentials LoadPlayer()
{
if (!File.Exists(SAVE_FILE))
{
return(null);
}
var parts = File.ReadAllLines(SAVE_FILE);
if (parts.Length != 2)
{
return(null);
}
var playerCredentials = new PlayerCredentials();
playerCredentials.ChilliConnectId = parts[0];
playerCredentials.ChilliConnectSecret = parts[1];
return(playerCredentials);
}
static async Task Login()
{
InstalledGame game = new InstalledGame("");
string token = game.GetRefreshToken();
PlayerCredentials credentials;
if (token != null)
{
credentials = new PlayerCredentials(token);
}
else
{
Console.WriteLine("Please login (or try to launch the game once)");
Console.Write("Email: ");
string email = Console.ReadLine();
Console.Write("Password: "******"[!] Authentication failed!");
// if we tried to login using a token, it's probably expired
if (token != null)
{
Console.WriteLine("Please launch your game, login once and then run this tool again!");
}
Console.ReadKey();
Environment.Exit(0);
}
_ticket = credentials.AccessToken;
}
public bool LoginPlayer(PlayerCredentials credentials, string token)
{
ClientData player = this.AllRegisteredPlayers.Where(x => x.Name == credentials.Name && x.Password == credentials.Password).FirstOrDefault();
if (player == null)
{
return(false);
}
this.AllRegisteredPlayers.Where(x => x.Name == credentials.Name && x.Password == credentials.Password).FirstOrDefault().Token = token;
if (this.LoggedPlayers.Where(x => x.Name == credentials.Name && x.Password == credentials.Password).FirstOrDefault() != null)
{
this.LoggedPlayers.Where(x => x.Name == credentials.Name && x.Password == credentials.Password).FirstOrDefault().Token = token;
return(true);
}
player.Token = token;
this.LoggedPlayers.Add(player);
return(true);
}
// Start is called before the first frame update
void Start()
{
this.playerLoginCredentials = new PlayerCredentials();
this.playerRegisterCredentials = new PlayerCredentials();
}
public bool LoginPlayer(PlayerCredentials player, string token)
{
return(this.manager.LoginPlayer(player, token));
}
/// <summary>
/// Decodes the payload state.
/// </summary>
/// <param name="ctx">The ctx.</param>
/// <param name="buffer">The buffer.</param>
/// <param name="output">The output.</param>
private void DecodePayload(IChannelHandlerContext ctx, IByteBuffer buffer, List <object> output)
{
if (buffer.ReadableBytes >= _loginLength)
{
IByteBuffer payload = buffer.ReadBytes(_loginLength);
var version = 255 - payload.ReadByte();
var release = payload.ReadShort();
var memoryStatus = payload.ReadByte();
if (memoryStatus != 0 && memoryStatus != 1)
{
_logger.Information("Login memoryStatus ({0}) not in expected range of [0, 1].", memoryStatus);
WriteResponseCode(ctx, LoginStatus.StatusLoginServerRejectedSession);
return;
}
var lowMemory = memoryStatus == 1;
var crcs = new int[Constants.ArchiveCount];
for (var index = 0; index < Constants.ArchiveCount; index++)
{
crcs[index] = payload.ReadInt();
}
var length = payload.ReadByte();
if (length != _loginLength - 41)
{
_logger.Information("Login packet unexpected length ({0})", length);
WriteResponseCode(ctx, LoginStatus.StatusLoginServerRejectedSession);
return;
}
/*
* var secureBytes = payload.ReadBytes(length);
* var value = new BigInteger(secureBytes.Array.Take(length).ToArray());
*
* RSA?
* value = BigInteger.ModPow(value, Constants.RSA_MODULUS, Constants.RSA_EXPONENT);
* var secureBuffer = Unpooled.WrappedBuffer(value.ToByteArray());
*/
var id = payload.ReadByte();
if (id != 10)
{
_logger.Information("Unable to read id from secure payload.");
WriteResponseCode(ctx, LoginStatus.StatusLoginServerRejectedSession);
return;
}
var clientSeed = payload.ReadLong();
var reportedSeed = payload.ReadLong();
if (reportedSeed != _serverSeed)
{
_logger.Information("Reported seed differed from server seed.");
WriteResponseCode(ctx, LoginStatus.StatusLoginServerRejectedSession);
return;
}
var uid = payload.ReadInt();
var username = payload.ReadString();
var password = payload.ReadString();
var socketAddress = (IPEndPoint)ctx.Channel.RemoteAddress;
var hostAddress = socketAddress.Address.ToString();
var seed = new int[4];
seed[0] = (int)(clientSeed >> 32);
seed[1] = (int)clientSeed;
seed[2] = (int)(_serverSeed >> 32);
seed[3] = (int)_serverSeed;
var decodingRandom = new IsaacRandom(seed);
for (int index = 0; index < seed.Length; index++)
{
seed[index] += 50;
}
var encodingRandom = new IsaacRandom(seed);
var credentials = new PlayerCredentials
{
Username = username,
Password = password,
EncodedUsername = _usernameHash,
Uid = uid,
HostAddress = hostAddress,
};
var randomPair = new IsaacRandomPair(encodingRandom, decodingRandom);
var request = new Rs2LoginRequest
{
Credentials = credentials,
RandomPair = randomPair,
Reconnecting = _reconnecting,
LowMemory = lowMemory,
ReleaseNumber = release,
ArchiveCrcs = crcs,
ClientVersion = version,
OnResult = (loginTask) => WriteProcessorResponseAsync(loginTask, ctx, randomPair)
};
_loginProcessor.Enqueue(request);
}
}
async Task <Player> IPlayerRepository.GetOrCreateAsync(PlayerCredentials playerCredentials)
{
return(await GetOrCreateAsync(playerCredentials));
}
