INSANEMODE/IW4M-Admin
1
0
Fork 0
mirror of https://github.com/RaidMax/IW4M-Admin.git synced 2025-06-10 15:20:48 -05:00
Code Issues Releases Wiki Activity

hopefulyl fix aliasing issue

Browse Source 
bans are applied to an account if the accounts are linked but penallty on a different accounts
This commit is contained in:
RaidMax
2018-12-29 12:43:40 -06:00
parent e31c36a1d7
commit 0e2ad04dad
5 changed files with 226 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
SharedLibraryCore/Objects/EFClient.cs
View File

@ -406,6 +406,9 @@ namespace SharedLibraryCore.Database.Models
{
var loc = Utilities.CurrentLocalization.LocalizationIndex;
LastConnection = DateTime.UtcNow;
Connections += 1;
if (Name.Length < 3)
{
CurrentServer.Logger.WriteDebug($"Kicking {this} because their name is too short");
@ -430,6 +433,7 @@ namespace SharedLibraryCore.Database.Models
}
// reserved slots stuff
// todo: is this broken on T6?
if (CurrentServer.MaxClients - (CurrentServer.GetClientsAsList().Count(_client => !_client.IsPrivileged())) < CurrentServer.ServerConfig.ReservedSlotNumber &&
!this.IsPrivileged())
{
@ -437,9 +441,6 @@ namespace SharedLibraryCore.Database.Models
Kick(loc["SERVER_KICK_SLOT_IS_RESERVED"], Utilities.IW4MAdminClient(CurrentServer));
return;
}
LastConnection = DateTime.UtcNow;
Connections += 1;
}
public async Task OnDisconnect()
@ -452,13 +453,65 @@ namespace SharedLibraryCore.Database.Models
public async Task<bool> OnJoin(int? ipAddress)
{
CurrentServer.Logger.WriteDebug($"Start join for {this}::{ipAddress}::{Level.ToString()}");
IPAddress = ipAddress;
var loc = Utilities.CurrentLocalization.LocalizationIndex;
var autoKickClient = Utilities.IW4MAdminClient(CurrentServer);
await CurrentServer.Manager.GetClientService().UpdateAlias(this);
var loc = Utilities.CurrentLocalization.LocalizationIndex;
OnConnect();
CurrentServer.Logger.WriteDebug($"OnConnect finished for {this}");
#region CLIENT_BAN
// kick them as their level is banned
if (Level == Permission.Banned)
{
CurrentServer.Logger.WriteDebug($"Kicking {this} because they are banned");
var ban = ReceivedPenalties.FirstOrDefault(_penalty => _penalty.Expires == null && _penalty.Active);
if (ban == null)
{
// this is from the old system before bans were applied to all accounts
ban = (await CurrentServer.Manager
.GetPenaltyService()
.GetActivePenaltiesAsync(AliasLinkId))
.FirstOrDefault(_penalty => _penalty.Type == Penalty.PenaltyType.Ban);
CurrentServer.Logger.WriteError($"Client {this} is banned, but no penalty exists for their ban");
// hack: re apply the automated offense to the reban
if (ban.AutomatedOffense != null)
{
autoKickClient.AdministeredPenalties?.Add(new EFPenalty()
{
AutomatedOffense = ban.AutomatedOffense
});
}
// this is a reban of the new GUID and IP
Ban($"{ban.Offense}", autoKickClient, false);
return false;
}
Kick($"{loc["SERVER_BAN_PREV"]} {ban?.Offense}", autoKickClient);
return false;
}
var tempBan = ReceivedPenalties.FirstOrDefault(_penalty => _penalty.Type == Penalty.PenaltyType.TempBan && _penalty.Expires > DateTime.UtcNow && _penalty.Active);
// they have an active tempban tied to their GUID
if (tempBan != null)
{
CurrentServer.Logger.WriteDebug($"Kicking {this} because they are temporarily banned");
Kick($"{loc["SERVER_TB_REMAIN"]} ({(tempBan.Expires.Value - DateTime.UtcNow).TimeSpanText()} {loc["WEBFRONT_PENALTY_TEMPLATE_REMAINING"]})", autoKickClient);
return false;
}
#endregion
// we want to get any penalties that are tied to their IP or AliasLink (but not necessarily their GUID)
var activePenalties = await CurrentServer.Manager.GetPenaltyService().GetActivePenaltiesAsync(AliasLinkId, ipAddress);
var currentBan = activePenalties.FirstOrDefault(p => p.Type == Penalty.PenaltyType.Ban || p.Type == Penalty.PenaltyType.TempBan);
var currentBan = activePenalties.FirstOrDefault(p => p.Type == Penalty.PenaltyType.Ban);
var currentAutoFlag = activePenalties.Where(p => p.Type == Penalty.PenaltyType.Flag && p.PunisherId == 1)
.Where(p => p.Active)
@ -475,14 +528,13 @@ namespace SharedLibraryCore.Database.Models
if (currentBan != null)
{
CurrentServer.Logger.WriteInfo($"Banned client {this} trying to join...");
var autoKickClient = Utilities.IW4MAdminClient(CurrentServer);
CurrentServer.Logger.WriteInfo($"Banned client {this} trying to evade...");
// reban the "evading" guid
if (Level != Permission.Banned &&
currentBan.Type == Penalty.PenaltyType.Ban)
if (Level != Permission.Banned)
{
CurrentServer.Logger.WriteInfo($"Banned client {this} connected using a new GUID");
// hack: re apply the automated offense to the reban
if (currentBan.AutomatedOffense != null)
{
@ -491,18 +543,13 @@ namespace SharedLibraryCore.Database.Models
AutomatedOffense = currentBan.AutomatedOffense
});
}
// this is a reban of the new GUID and IP
Ban($"{currentBan.Offense}", autoKickClient, true);
}
// the player is permanently banned
else if (currentBan.Type == Penalty.PenaltyType.Ban)
{
Kick($"{loc["SERVER_BAN_PREV"]} {currentBan.Offense} ({loc["SERVER_BAN_APPEAL"]} {CurrentServer.Website})", autoKickClient);
}
else
{
Kick($"{loc["SERVER_TB_REMAIN"]} ({(currentBan.Expires.Value - DateTime.UtcNow).TimeSpanText()} {loc["WEBFRONT_PENALTY_TEMPLATE_REMAINING"]})", autoKickClient);
CurrentServer.Logger.WriteError($"Banned client {this} is banned but, no ban penalty was found (2)");
}
return false;

158
SharedLibraryCore/Services/ClientService.cs
View File

@ -29,6 +29,7 @@ namespace SharedLibraryCore.Services
{
Active = false
},
ReceivedPenalties = new List<EFPenalty>()
};
client.CurrentAlias = new Alias()
@ -63,14 +64,15 @@ namespace SharedLibraryCore.Services
string name = entity.Name;
int? ip = entity.IPAddress;
// indicates if someone appears to have played before
bool hasExistingAlias = false;
// get all aliases by IP
// get all aliases by IP address and LinkId
var iqAliases = context.Aliases
.Include(a => a.Link)
.Where(a => a.Link.Active)
.Where(a => (a.IPAddress != null && a.IPAddress == ip) ||
a.LinkId == entity.AliasLinkId);
a.LinkId == entity.AliasLinkId);
#if DEBUG == true
var aliasSql = iqAliases.ToSql();
@ -78,102 +80,97 @@ namespace SharedLibraryCore.Services
var aliases = await iqAliases.ToListAsync();
// see if they have a matching IP + Name but new NetworkId
var existingAlias = aliases.FirstOrDefault(a => a.Name == name);
var existingAlias = aliases.FirstOrDefault(a => a.Name == name && a.IPAddress == ip);
bool exactAliasMatch = existingAlias != null;
// if existing alias matches link them
EFAliasLink aliasLink = existingAlias?.Link;
// if no exact matches find the first IP that matches
aliasLink = aliasLink ?? aliases.FirstOrDefault()?.Link;
// if no exact or IP matches, create new link
// if no matches are found, create new link
aliasLink = aliasLink ?? new EFAliasLink();
// this has to be set here because we can't evalute it properly later
hasExistingAlias = existingAlias != null;
hasExistingAlias = aliases.Count > 0;
if (hasExistingAlias && !entity.AliasLink.Active)
// the existing alias matches ip and name, so we can just ignore the temporary one
if (exactAliasMatch)
{
entity.CurrentServer.Logger.WriteDebug($"Removing temporary alias for ${entity}");
// we want to delete the temporary alias
context.Entry(entity.CurrentAlias).State = EntityState.Deleted;
entity.CurrentAlias = null;
// we want to delete the temporary alias link
context.Entry(entity.AliasLink).State = EntityState.Deleted;
entity.AliasLink = null;
// they have an existing alias so assign it
entity.CurrentAlias = existingAlias;
entity.AliasLink = aliasLink;
await context.SaveChangesAsync();
entity.AliasLinkId = aliasLink.AliasLinkId;
}
// update the temporary alias to permanent one
else if (!entity.AliasLink.Active)
{
entity.CurrentServer.Logger.WriteDebug($"Linking permanent alias for ${entity}");
// we want to track the current alias and link
var alias = context.Update(entity.CurrentAlias).Entity;
var _aliasLink = context.Update(entity.AliasLink).Entity;
alias.Active = true;
alias.IPAddress = ip;
alias.Name = name;
_aliasLink.Active = true;
existingAlias = alias;
aliasLink = _aliasLink;
await context.SaveChangesAsync();
entity.AliasLinkId = aliasLink.AliasLinkId;
}
// if no existing alias create new alias
existingAlias = existingAlias ?? new EFAlias()
{
DateAdded = DateTime.UtcNow,
IPAddress = ip,
Link = aliasLink,
Name = name,
};
if (!hasExistingAlias)
{
entity.CurrentServer.Logger.WriteDebug($"Connecting player does not have an existing alias {entity}");
}
else
{
var linkIds = aliases.Select(a => a.LinkId);
if (linkIds.Count() > 0)
// they're using the same alias as before, so we need to make sure the current aliases is set to it
if (entity.CurrentAliasId != existingAlias.AliasId)
{
var highestLevel = await context.Clients
.Where(c => linkIds.Contains(c.AliasLinkId))
.MaxAsync(c => c.Level);
context.Update(entity);
if (entity.Level != highestLevel)
{
context.Update(entity);
entity.Level = highestLevel;
await context.SaveChangesAsync();
}
entity.CurrentAlias = existingAlias;
entity.CurrentAliasId = existingAlias.AliasId;
}
}
if (entity.CurrentAlias != existingAlias ||
entity.AliasLink != aliasLink)
// theres no exact match, but they've played before with the GUID or IP
else if (hasExistingAlias)
{
entity.CurrentAlias = existingAlias;
entity.AliasLink = aliasLink;
// the current link is temporary so we need to update
if (!entity.AliasLink.Active)
{
// we want to delete the temporary alias link
context.Entry(entity.AliasLink).State = EntityState.Deleted;
context.Update(entity);
entity.AliasLink = aliasLink;
entity.AliasLinkId = aliasLink.AliasLinkId;
await context.SaveChangesAsync();
}
// they have an existing link
context.Update(entity);
entity.CurrentServer.Logger.WriteDebug($"Connecting player is using a new alias {entity}");
entity.CurrentAlias = new EFAlias()
{
DateAdded = DateTime.UtcNow,
IPAddress = ip,
Link = aliasLink,
LinkId = aliasLink.AliasLinkId,
Name = name
};
entity.AliasLink.Children.Add(entity.CurrentAlias);
await context.SaveChangesAsync();
}
// no record of them playing
else
{
context.Update(entity);
context.Update(entity.AliasLink);
entity.CurrentAlias = new EFAlias()
{
DateAdded = DateTime.UtcNow,
IPAddress = ip,
Link = aliasLink,
Name = name
};
entity.AliasLink.Active = true;
entity.AliasLink.Children.Add(entity.CurrentAlias);
await context.SaveChangesAsync();
}
var linkIds = aliases.Select(a => a.LinkId);
if (linkIds.Count() > 0)
{
var highestLevel = await context.Clients
.Where(c => linkIds.Contains(c.AliasLinkId))
.MaxAsync(c => c.Level);
if (entity.Level != highestLevel)
{
// todo: log level changes here
context.Update(entity);
entity.Level = highestLevel;
await context.SaveChangesAsync();
}
}
await context.SaveChangesAsync();
}
}
@ -251,6 +248,7 @@ namespace SharedLibraryCore.Services
context.Clients
.Include(c => c.CurrentAlias)
.Include(c => c.AliasLink.Children)
.Include(c => c.ReceivedPenalties)
.FirstOrDefault(c => c.NetworkId == networkId)
);

98
SharedLibraryCore/Services/PenaltyService.cs
View File

@ -18,38 +18,86 @@ namespace SharedLibraryCore.Services
{
using (var context = new DatabaseContext())
{
// create the actual EFPenalty
EFPenalty addedEntity = new EFPenalty()
{
OffenderId = newEntity.Offender.ClientId,
PunisherId = newEntity.Punisher.ClientId,
LinkId = newEntity.Link.AliasLinkId,
Type = newEntity.Type,
Expires = newEntity.Expires,
Offense = newEntity.Offense,
When = newEntity.When,
AutomatedOffense = newEntity.AutomatedOffense
};
context.ChangeTracker.AutoDetectChangesEnabled = true;
context.ChangeTracker.LazyLoadingEnabled = true;
context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.TrackAll;
// make bans propogate to all aliases
if (addedEntity.Type == Objects.Penalty.PenaltyType.Ban)
if (newEntity.Type == Penalty.PenaltyType.Ban)
{
await context.Clients
.Where(c => c.AliasLinkId == addedEntity.LinkId)
.ForEachAsync(c => c.Level = Permission.Banned);
.Include(c => c.ReceivedPenalties)
.Where(c => c.AliasLinkId == newEntity.Link.AliasLinkId)
.ForEachAsync(c =>
{
if (c.Level != Permission.Banned)
{
c.Level = Permission.Banned;
c.ReceivedPenalties.Add(new EFPenalty()
{
Active = true,
OffenderId = c.ClientId,
PunisherId = newEntity.Punisher.ClientId,
LinkId = c.AliasLinkId,
Type = newEntity.Type,
Expires = newEntity.Expires,
Offense = newEntity.Offense,
When = DateTime.UtcNow,
AutomatedOffense = newEntity.AutomatedOffense,
IsEvadedOffense = newEntity.IsEvadedOffense
});
}
});
}
// make flags propogate to all aliases
else if (addedEntity.Type == Objects.Penalty.PenaltyType.Flag)
else if (newEntity.Type == Penalty.PenaltyType.Flag)
{
await context.Clients
.Where(c => c.AliasLinkId == addedEntity.LinkId)
.ForEachAsync(c => c.Level = Permission.Flagged);
.Include(c => c.ReceivedPenalties)
.Where(c => c.AliasLinkId == newEntity.LinkId)
.ForEachAsync(c =>
{
if (c.Level != Permission.Flagged)
{
c.Level = Permission.Flagged;
c.ReceivedPenalties.Add(new EFPenalty()
{
Active = true,
OffenderId = c.ClientId,
PunisherId = newEntity.Punisher.ClientId,
LinkId = c.AliasLinkId,
Type = newEntity.Type,
Expires = newEntity.Expires,
Offense = newEntity.Offense,
When = DateTime.UtcNow,
AutomatedOffense = newEntity.AutomatedOffense,
IsEvadedOffense = newEntity.IsEvadedOffense
});
}
});
}
// we just want to add it to the database
else
{
context.Penalties.Add(new EFPenalty()
{
Active = true,
OffenderId = newEntity.Offender.ClientId,
PunisherId = newEntity.Punisher.ClientId,
LinkId = newEntity.Link.AliasLinkId,
Type = newEntity.Type,
Expires = newEntity.Expires,
Offense = newEntity.Offense,
When = DateTime.UtcNow,
AutomatedOffense = newEntity.AutomatedOffense,
IsEvadedOffense = newEntity.IsEvadedOffense
});
}
context.Penalties.Add(addedEntity);
await context.SaveChangesAsync();
return addedEntity;
return newEntity;
}
}
@ -228,7 +276,8 @@ namespace SharedLibraryCore.Services
Expression<Func<EFPenalty, bool>> filter = (p) => new Penalty.PenaltyType[]
{
Penalty.PenaltyType.TempBan,
Penalty.PenaltyType.Ban, Penalty.PenaltyType.Flag
Penalty.PenaltyType.Ban,
Penalty.PenaltyType.Flag
}.Contains(p.Type) &&
p.Active &&
(p.Expires == null || p.Expires > now);
@ -240,7 +289,7 @@ namespace SharedLibraryCore.Services
.Where(filter);
var iqIPPenalties = context.Aliases
.Where(a => a.IPAddress == ip)
.Where(a => a.IPAddress != null & a.IPAddress == ip)
.SelectMany(a => a.Link.ReceivedPenalties)
.Where(filter);
@ -249,7 +298,10 @@ namespace SharedLibraryCore.Services
var ipPenaltiesSql = iqIPPenalties.ToSql();
#endif
var activePenalties = (await iqLinkPenalties.ToListAsync()).Union(await iqIPPenalties.ToListAsync());
var activePenalties = (await iqLinkPenalties.ToListAsync())
.Union(await iqIPPenalties.ToListAsync())
.Distinct();
// this is a bit more performant in memory (ordering)
return activePenalties.OrderByDescending(p => p.When).ToList();
}