public async Task <IActionResult> PutWhitelist(int id, Whitelist whitelist)
{
if (id != whitelist.Id)
{
return(BadRequest());
}
_context.Entry(whitelist).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WhitelistExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private async Task LookupIps(AddEntry message, Whitelist entry)
{
var lookup = new LookupClient();
var result = await lookup.QueryAsync(message.DomainName, QueryType.ANY);
foreach (var record in result.AllRecords)
{
switch (record)
{
case ARecord ipRecord:
await _uow.InsertAsync(new WhitelistedDomainIp
{
DomainId = entry.Id,
IpAddress = ipRecord.Address,
IpType = IpType.Lookup,
StoredAtUtc = DateTime.UtcNow
});
break;
case AaaaRecord ip6Record:
await _uow.InsertAsync(new WhitelistedDomainIp
{
DomainId = entry.Id,
IpAddress = ip6Record.Address,
IpType = IpType.Lookup,
StoredAtUtc = DateTime.UtcNow
});
break;
}
}
}
private void ExportWhiteListToCsv()
{
var list = Whitelist.Cast <object>().ToList();
var exportAction = new CsvImportAndExport();
exportAction.CsvExport <WhitelistMap>(list, "Whitelist.csv");
}
protected void btnSave_Click(object sender, EventArgs e)
{
Whitelist whitelist = new Whitelist();
if (divWhitelist.Visible != true)
{
whitelist.add(txtReason.Text, Convert.ToDateTime(from.Text), Convert.ToDateTime(to.Text), 0, Convert.ToInt32(ddlWorkstation.SelectedValue));
lblText.Text = "<br />Record inserted successfully<br />";
divForm.Visible = false;
txtReason.Text = "";
from.Text = "";
to.Text = "";
}
else
{
whitelist.edit(Convert.ToInt32(lbl.Text), txtReason.Text, Convert.ToDateTime(from.Text), Convert.ToDateTime(to.Text), 0, Convert.ToInt32(ddlWorkstation.SelectedValue));
lblText.Text = "<br />Record modified successfully<br />";
divForm.Visible = false;
divWhitelist.Visible = false;
lbl.Text = "";
gvWhitelists.EditIndex = -1;
}
// Bind the GridView control to the courseInfo collection.
gvWhitelists.DataSource = whitelist.load();
gvWhitelists.DataBind();
btnInsert.Visible = true;
}
private void ImportWhiteListFromCsv()
{
var importAction = new CsvImportAndExport();
var filePath = importAction.ImportCsv();
if (filePath is null)
{
return;
}
try
{
var importData = new List <Whitelist>(importAction.GetCsvRecords <Whitelist>(importAction.LoadCsv <WhitelistMap>(filePath)));
foreach (var data in importData)
{
Whitelist.Add(data);
}
MessageBox.Show(Properties.Resources.SuccessfulImport, Properties.Resources.AppName, MessageBoxButton.OK);
}
catch (Exception)
{
MessageBox.Show(Properties.Resources.ImportFailed, Properties.Resources.AppName, MessageBoxButton.OK);
}
}
public async Task <ActionResult <Whitelist> > PostWhitelist(Whitelist whitelist)
{
_context.Whitelist.Add(whitelist);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetWhitelist", new { id = whitelist.Id }, whitelist));
}
public void RequestedResourceIsWhitelisted_ReturnsFalse_IfRequestResourceIsNotWhitelisted()
{
using (var context = _apacheLogContextFactory.NewTestContext())
{
// Arrange
context.WhitelistedResources.Add(new WhitelistedResource()
{
BasePath = "media"
});
context.SaveChanges();
// Arrange
var whitelistedResources = new List <string>()
{
@"media"
}.AsQueryable();;
var whitelist = new Whitelist(context);
var accessRequest = new AccessRequest()
{
Resource = @"/admin/mysql2/index.php"
};
// Act
var result = whitelist.RequestedResourceIsWhitelisted(accessRequest);
// Assert
Assert.False(result);
}
}
public CQHub(Crypt crypt, Whitelist whitelist, RSA rsa, Action <string> onStatusChange)
{
_crypt = crypt;
_whitelist = whitelist;
_rsa = rsa;
_onStatusChange = onStatusChange;
}
public WhitelistPresentationStub(Whitelist dbItem)
{
this.Id = dbItem.id;
this.Barcode = dbItem.barcode;
this.TanggalAwal = dbItem.tanggal_awal;
this.TanggalAkhir = dbItem.tanggal_akhir;
}
public ActionResult Add(Whitelist whitelist)
{
ViewBag.Domain = whitelist.Domain;
Whitelist w = Data.whitelists.Find(x => x.Domain.Equals(whitelist.Domain));
Blacklist b = Data.blacklists.Find(x => x.Domain.Equals(whitelist.Domain));
if (b != null)
{
ViewBag.AjoutReussi = "blackcontient";
}
else if (w != null)
{
ViewBag.AjoutReussi = "contient";
}
else
{
try
{
// Vérifie si le site web existe
Dns.GetHostEntry(whitelist.Domain);
if (Data.addWhitelist(whitelist.Domain))
{
ViewBag.AjoutReussi = "reussi";
}
else
{
ViewBag.AjoutReussi = "echouer";
}
}
catch (Exception e)
{
if (!string.IsNullOrEmpty(whitelist.Domain))
{
//Vérification domain et sous domaine est un .* ou pas
if (whitelist.Domain.Equals(".") || Data.TLD.Contains(whitelist.Domain.ToUpper()))
{
if (Data.addWhitelist(whitelist.Domain))
{
ViewBag.AjoutReussi = "reussi";
}
else
{
ViewBag.AjoutReussi = "echouer";
}
}
else
{
ViewBag.AjoutReussi = "echouer";
}
}
else
{
ViewBag.AjoutReussi = "echouer";
}
}
}
ViewBag.Whitelist = Data.whitelists;
return(View("Index"));
}
public void TestScriptTagInWhiteList()
{
Whitelist whitelist = Whitelist.Relaxed;
whitelist.AddTags("script");
Assert.IsTrue(Dcsoup.IsValid("Hello<script>alert('Doh')</script>World !", whitelist));
}
// Options to be presented once a user has been selected //
public void PrintUserOptions(User user)
{
Console.WriteLine($"Account Age: {user.age}");
Console.Write($"Game List: ");
foreach (string game in user.gameList)
{
Console.WriteLine($"{game}, ");
}
Console.WriteLine($"Reports: {user.reports}");
Console.WriteLine($"Friend Requests/Friends: {user.requests}/{user.friends}");
Console.WriteLine();
Console.WriteLine("1. Blacklist this user.");
Console.WriteLine("2. Whitelist this user.");
Console.WriteLine("3. Back");
Console.Write("Choose an option: ");
int userOption = Convert.ToInt32(Console.ReadLine());
if (userOption == 1)
{
_users.Remove(user);
Blacklist newUser = new Blacklist(user.id, user.gameList, user.age, user.reports, user.playtime, user.messages, user.requests, user.friends);
_users.Add(newUser);
}
if (userOption == 2)
{
_users.Remove(user);
Whitelist newUser = new Whitelist(user.id, user.gameList, user.age, user.reports, user.playtime, user.messages, user.requests, user.friends);
_users.Add(newUser);
}
else if (userOption == 3)
{
return;
}
}
// Assigns all users to either blacklist or whitelist //
public void ScanUsers()
{
int whitelisted = 0;
int blacklisted = 0;
Console.WriteLine("--#################--");
Console.WriteLine(_users.Count);
foreach (User user in _users.ToArray())
{
double danger = user.HealthAnalysis();
if (danger <= 50)
{
_users.Remove(user);
Whitelist newUser = new Whitelist(user.id, user.gameList, user.age, user.reports, user.playtime, user.messages, user.requests, user.friends);
_users.Add(newUser);
whitelisted++;
}
else if (danger > 50)
{
_users.Remove(user);
Blacklist newUser = new Blacklist(user.id, user.gameList, user.age, user.reports, user.playtime, user.messages, user.requests, user.friends);
_users.Add(newUser);
blacklisted++;
}
}
Console.WriteLine("--#################--");
Console.WriteLine($"Total Whitelisted: {whitelisted}");
Console.WriteLine($"Total Blacklisted: {blacklisted}");
Console.WriteLine("--#################--");
}
public void LoadRunningScriptsFromWorld()
{
Log.Info("Loading running scripts from world...");
if (MyAPIGateway.Utilities.FileExistsInWorldStorage(runningScriptsFileName, typeof(ScriptManagerConfig)))
{
//Dictionary<long, long> runningScripts;
Dictionary <long, long> runningScripts = null;
try
{
using (var reader = MyAPIGateway.Utilities.ReadBinaryFileInWorldStorage(runningScriptsFileName, typeof(ScriptManagerConfig)))
runningScripts = MyAPIGateway.Utilities.SerializeFromBinary <Dictionary <long, long> >(reader.ReadBytes((int)reader.BaseStream.Length));
//runningScripts = MyAPIGateway.Utilities.SerializeFromXML<Dictionary<long, long>>(serialized);
}
catch (Exception e)
{
Log.Warn($"Parsing running scripts failed: {e.Message}");
return;
}
foreach (var kvp in runningScripts)
{
var script = Whitelist.First(item => item.Id == kvp.Value);
AddRunningScript(kvp.Key, script);
}
}
}
public void ClientAdminRead(IReadMessage incMsg)
{
int count = incMsg.ReadUInt16();
for (int i = 0; i < count; i++)
{
UInt32 key = incMsg.ReadUInt32();
if (netProperties.ContainsKey(key))
{
bool changedLocally = netProperties[key].ChangedLocally;
netProperties[key].Read(incMsg);
netProperties[key].TempValue = netProperties[key].Value;
if (netProperties[key].GUIComponent != null)
{
if (!changedLocally)
{
netProperties[key].GUIComponentValue = netProperties[key].Value;
}
}
}
else
{
UInt32 size = incMsg.ReadVariableUInt32();
incMsg.BitPosition += (int)(8 * size);
}
}
ReadMonsterEnabled(incMsg);
BanList.ClientAdminRead(incMsg);
Whitelist.ClientAdminRead(incMsg);
}
/// <summary>
/// Interpreters a series of access tags for a series of vehicle types.
/// </summary>
public static bool InterpretAccessValues(IAttributeCollection attributes, Whitelist whiteList, IEnumerable <string> keys, params string[] rootKeys)
{
bool?value = null;
var usedKey = string.Empty;
for (var i = 0; i < rootKeys.Length; i++)
{
var currentAccess = Vehicle.InterpretAccessValue(attributes, rootKeys[i]);
if (currentAccess != null)
{
value = currentAccess;
usedKey = rootKeys[i];
}
}
foreach (var key in keys)
{
var currentAccess = Vehicle.InterpretAccessValue(attributes, key);
if (currentAccess != null)
{
value = currentAccess;
usedKey = key;
}
}
if (!string.IsNullOrWhiteSpace(usedKey))
{
whiteList.Add(usedKey);
}
return(!value.HasValue || value.Value);
}
public async Task <IActionResult> Edit(int CohortId, string UserId, [Bind("CohortId,UserId,IsMentor")] Whitelist whitelist)
{
if (CohortId != whitelist.CohortId || UserId != whitelist.UserId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(whitelist);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WhitelistExists(whitelist.CohortId, whitelist.UserId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index), new { id = whitelist.CohortId }));
}
ViewData["CohortId"] = new SelectList(_context.Cohort, "CohortId", "CohortName", whitelist.CohortId);
return(View(whitelist));
}
public async Task <IActionResult> Create([Bind("CohortId,UserId,IsMentor")] Whitelist whitelist)
{
if (ModelState.IsValid)
{
_context.Add(whitelist);
await _context.SaveChangesAsync();
/* Update user privileges.*/
var user = await _context.Users.FirstOrDefaultAsync(u => u.Email.ToLower() == whitelist.UserId.ToLower());
if (user != null)
{
if (whitelist.IsMentor)
{
await _userManager.AddToRoleAsync(user, Constants.MentorRole);
}
else
{
await _userManager.AddToRoleAsync(user, Constants.StudentRole);
}
}
return(RedirectToAction(nameof(Index), new { id = whitelist.CohortId }));
}
ViewData["CohortId"] = new SelectList(_context.Cohort, "CohortId", "CohortName", whitelist.CohortId);
return(View(whitelist));
}
/// <summary>
/// Test if the input HTML has only tags and attributes allowed by the Whitelist. Useful for form validation. The input HTML should
/// still be run through the cleaner to set up enforced attributes, and to tidy the output.
/// </summary>
/// <param name="bodyHtml">HTML to test</param>
/// <param name="whitelist">whitelist to test against</param>
/// <returns>true if no tags or attributes were removed; false otherwise</returns>
/// <seealso cref="Clean(string, NSoup.Safety.Whitelist)"/>
public static bool IsValid(string bodyHtml, Whitelist whitelist)
{
Document dirty = ParseBodyFragment(bodyHtml, string.Empty);
Cleaner cleaner = new Cleaner(whitelist);
return(cleaner.IsValid(dirty));
}
public LanguageIndexer(LanguageSettings languageSettings)
{
LanguageSettings = languageSettings;
Exclusions = (from item in LanguageSettings.Tokens.Where(y => y.Type == TokenTypeOption.Stop) select item.Content).ToList();
HashSet <char> hs = new HashSet <char>();
if (LanguageSettings.Tokens.Any(y => y.Type.Equals(TokenTypeOption.Whitelist)))
{
foreach (var item in LanguageSettings.Tokens.Where(x => x.Type.Equals(TokenTypeOption.Whitelist)))
{
foreach (var c in item.Content.ToCharArray())
{
if (hs.Add(c))
{
Whitelist.Add(c);
}
}
}
}
else
{
Whitelist.AddRange(Span(65, 90));
Whitelist.AddRange(Span(97, 122));
}
}
private async Task FetchIps(Whitelist entry)
{
using (var cmd = _uow.CreateDbCommand())
{
cmd.CommandText =
$"SELECT * FROM WhitelistedDomainIps WHERE DomainId = @domainId";
cmd.AddParameter("domainId", entry.Id);
using (var reader = await cmd.ExecuteReaderAsync())
{
var addresses = new List <WhitelistedDomainIp>();
while (await reader.ReadAsync())
{
addresses.Add(new WhitelistedDomainIp()
{
DomainId = entry.Id,
IpAddress = IPAddress.Parse((string)reader["IpAddress"]),
IpType = (IpType)(int)reader["IpType"],
StoredAtUtc = (DateTime)reader["StoredAtUtc"]
});
}
entry.IpAddresses = addresses.ToArray();
}
}
}
private async Task UpdateApplications(EditEntry message, Whitelist entry)
{
var dbApps = await _uow.ToListAsync <WhitelistedDomainApplication>("DomainId = @id", new { id = message.Id });
//find new
var newApps = message.ApplicationIds.Except(dbApps.Select(x => x.ApplicationId));
foreach (var newApp in newApps)
{
var entity = new WhitelistedDomainApplication {
DomainId = entry.Id, ApplicationId = newApp
};
await _uow.InsertAsync(entity);
}
//find removed
var removedApps = dbApps.Select(x => x.ApplicationId)
.Except(message.ApplicationIds)
.Select(x => dbApps.First(y => x == y.ApplicationId));
foreach (var app in removedApps)
{
await _uow.DeleteAsync(app);
}
}
public override async Task ConfigureAsync(string configFile)
{
await base.ConfigureAsync(configFile);
ZoneParser = new ZoneParser(Resources);
Whitelist = new Whitelist(Resources);
await Whitelist.LoadDefaultWhitelist();
GameMessageReceived += HandleGameMessageAsync;
ServerStopped += () =>
{
foreach (var zone in Zones)
{
Object.Destroy(zone);
}
};
RakNetServer.ClientDisconnected += HandleDisconnect;
var _ = Task.Run(async() =>
{
await ZoneParser.LoadZoneDataAsync((int)ServerSpecification.ZoneId);
await LoadZone(ServerSpecification);
});
Logger.Information($"Setting up world server: {ServerSpecification.Id}");
}
public async Task HandleAsync(IMessageContext context, AddEntry message)
{
var entry = new Whitelist {
DomainName = message.DomainName
};
await _uow.InsertAsync(entry);
foreach (var dto in message.ApplicationIds)
{
var entity = new WhitelistedDomainApplication {
DomainId = entry.Id, ApplicationId = dto
};
await _uow.InsertAsync(entity);
}
if (message.IpAddresses?.Length > 0)
{
foreach (var ip in message.IpAddresses)
{
var entity = new WhitelistedDomainIp
{
DomainId = entry.Id,
IpType = IpType.Manual,
IpAddress = IPAddress.Parse(ip),
StoredAtUtc = DateTime.UtcNow
};
await _uow.InsertAsync(entity);
}
}
else
{
await LookupIps(message, entry);
}
}
public WhitelistFormStub(Whitelist dbItem)
: this()
{
this.Id = dbItem.id;
this.Barcode = dbItem.barcode;
this.TanggalAwal = dbItem.tanggal_awal;
this.TanggalAkhir = dbItem.tanggal_akhir;
}
/// <summary>
/// Get safe HTML from untrusted input HTML, by parsing input HTML and filtering it through a white-list of permitted
/// tags and attributes.
/// </summary>
/// <param name="bodyHtml">Input untrusted HTML (body fragment)</param>
/// <param name="baseUri">URL to resolve relative URLs against</param>
/// <param name="whitelist">White-list of permitted HTML elements</param>
/// <returns>Safe HTML (body fragment)</returns>
/// <seealso cref="Cleaner.Clean(Document)"/>
public static string Clean(string bodyHtml, string baseUri, Whitelist whitelist)
{
Document dirty = ParseBodyFragment(bodyHtml, baseUri);
Cleaner cleaner = new Cleaner(whitelist);
Document clean = cleaner.Clean(dirty);
return(clean.Body.Html());
}
public Whitelist GetDbObject(Whitelist dbItem)
{
dbItem.id = this.Id;
dbItem.barcode = this.Barcode;
dbItem.tanggal_awal = this.TanggalAwal;
dbItem.tanggal_akhir = this.TanggalAkhir;
return(dbItem);
}
public void Parse_SingleIPv6()
{
string input = "::1";
var whitelist = Whitelist.Parse(input);
Assert.IsTrue(whitelist.Match(IPAddress.Parse("::1")));
}
public void Parse_Empty()
{
string input = "";
var whitelist = Whitelist.Parse(input);
Assert.IsFalse(whitelist.Match(IPAddress.Parse("127.0.0.1")));
}
private void WhitelistLinqAndCollections()
{
Whitelist
.Namespace("System.Linq", Permission.Allowed)
.Namespace("System.Collections", Permission.Allowed)
.Namespace("System.Collections.Generic", Permission.Allowed)
;
}
