private void RefreshProcessList(string filter, bool hideUnrestricted)
{
bool filter_name = !String.IsNullOrWhiteSpace(filter);
ClearList(listViewProcesses);
ClearList(listViewThreads);
using (var processes = new DisposableList <NtProcess>(NtProcess.GetProcesses(ProcessAccessRights.QueryLimitedInformation)))
{
processes.Sort((a, b) => a.ProcessId - b.ProcessId);
using (var tokens = new DisposableList <NtToken>(processes.Select(p => GetToken(p))))
{
List <ListViewItem> procs = new List <ListViewItem>();
List <ListViewItem> threads = new List <ListViewItem>();
Debug.Assert(processes.Count == tokens.Count);
for (int i = 0; i < processes.Count; ++i)
{
NtProcess p = processes[i];
NtToken t = tokens[i];
if (t == null || !t.IsAccessGranted(TokenAccessRights.Query))
{
continue;
}
if (filter_name)
{
if (!p.FullPath.ToLower().Contains(filter.ToLower()))
{
continue;
}
}
if (hideUnrestricted)
{
if (!IsRestrictedToken(t))
{
continue;
}
}
procs.Add(CreateProcessNode(p, t));
threads.AddRange(CreateThreads(p));
}
listViewProcesses.Items.AddRange(procs.ToArray());
listViewThreads.Items.AddRange(threads.ToArray());
ResizeColumns(listViewProcesses);
ResizeColumns(listViewThreads);
}
}
}
private void BuildAuthZContext()
{
_resource_manager = string.IsNullOrWhiteSpace(Server) ? AuthZResourceManager.Create(GetType().Name,
AuthZResourceManagerInitializeFlags.NoAudit | AuthZResourceManagerInitializeFlags.NoCentralAccessPolicies,
null) : AuthZResourceManager.Create(Server, null, AuthZResourceManagerRemoteServiceType.Default);
var sids = new HashSet <Sid>();
if (UserSid != null)
{
foreach (var sid in UserSid)
{
sids.Add(sid);
}
}
if (UserName != null)
{
foreach (var name in UserName)
{
sids.Add(NtSecurity.LookupAccountName(name));
}
}
if (sids.Count == 0)
{
sids.Add(NtToken.CurrentUser.Sid);
}
if (_resource_manager.Remote || UseLocalGroup)
{
_context.AddRange(sids.Select(s => _resource_manager.CreateContext(s, AuthZContextInitializeSidFlags.None)));
}
else
{
foreach (var sid in sids)
{
if (!NtSecurity.IsDomainSid(sid) || NtSecurity.IsLocalDomainSid(sid))
{
_context.AddResource(_resource_manager.CreateContext(sid, AuthZContextInitializeSidFlags.None));
continue;
}
WriteProgress($"Building security context for {sid.Name}");
var context = _context.AddResource(_resource_manager.CreateContext(sid, AuthZContextInitializeSidFlags.SkipTokenGroups));
context.AddSids(_cached_user_groups.GetOrAdd(Tuple.Create(Domain, sid), _ => GetUserDomainSids(Domain, sid)));
}
}
foreach (var context in Context)
{
if (sids.Add(context.User.Sid))
{
var next_ctx = _context.AddResource(_resource_manager.CreateContext(context.User.Sid, AuthZContextInitializeSidFlags.SkipTokenGroups));
foreach (var group in context.Groups)
{
next_ctx.AddSid(group.Sid);
}
}
}
_token_info = _context.Select(c => new TokenInformation(c)).ToList();
}
static Texture CreateTextureFromImage(string path, string textureName, TextureSettings textureSettings, bool isDecalsWad)
{
// Load the main texture image, and any available mipmap images:
using (var images = new DisposableList <Image <Rgba32> >(GetMipmapFilePaths(path).Prepend(path)
.Select(imagePath => File.Exists(imagePath) ? ImageReading.ReadImage(imagePath) : null)))
{
// Verify image sizes:
if (images[0].Width % 16 != 0 || images[0].Height % 16 != 0)
{
throw new InvalidDataException($"Texture '{path}' width or height is not a multiple of 16.");
}
for (int i = 1; i < images.Count; i++)
{
if (images[i] != null && (images[i].Width != images[0].Width >> i || images[i].Height != images[0].Height >> i))
{
throw new InvalidDataException($"Mipmap {i} for texture '{path}' width or height does not match texture size.");
}
}
if (isDecalsWad)
{
return(CreateDecalTexture(textureName, images.ToArray(), textureSettings));
}
var filename = Path.GetFileName(path);
var isTransparentTexture = filename.StartsWith("{");
var isAnimatedTexture = AnimatedTextureNameRegex.IsMatch(filename);
var isWaterTexture = filename.StartsWith("!");
// Create a suitable palette, taking special texture types into account:
var transparencyThreshold = isTransparentTexture ? Clamp(textureSettings.TransparencyThreshold ?? 128, 0, 255) : 0;
Func <Rgba32, bool> isTransparentPredicate = null;
if (textureSettings.TransparencyColor != null)
{
var transparencyColor = textureSettings.TransparencyColor.Value;
isTransparentPredicate = color => color.A < transparencyThreshold || (color.R == transparencyColor.R && color.G == transparencyColor.G && color.B == transparencyColor.B);
}
else
{
isTransparentPredicate = color => color.A < transparencyThreshold;
}
var colorHistogram = ColorQuantization.GetColorHistogram(images.Where(image => image != null), isTransparentPredicate);
var maxColors = 256 - (isTransparentTexture ? 1 : 0) - (isWaterTexture ? 2 : 0);
var colorClusters = ColorQuantization.GetColorClusters(colorHistogram, maxColors);
// Always make sure we've got a 256-color palette (some tools can't handle smaller palettes):
if (colorClusters.Length < maxColors)
{
colorClusters = colorClusters
.Concat(Enumerable
.Range(0, maxColors - colorClusters.Length)
.Select(i => (new Rgba32(), new[] { new Rgba32() })))
.ToArray();
}
// Make palette adjustments for special textures:
if (isWaterTexture)
{
var fogColor = textureSettings.WaterFogColor ?? ColorQuantization.GetAverageColor(colorHistogram);
var fogIntensity = new Rgba32((byte)Clamp(textureSettings.WaterFogColor?.A ?? (int)((1f - GetBrightness(fogColor)) * 255), 0, 255), 0, 0);
colorClusters = colorClusters.Take(3)
.Append((fogColor, new[] { fogColor })) // Slot 3: water fog color
.Append((fogIntensity, new[] { fogIntensity })) // Slot 4: fog intensity (stored in red channel)
.Concat(colorClusters.Skip(3))
.ToArray();
}
if (isTransparentTexture)
{
var colorKey = new Rgba32(0, 0, 255);
colorClusters = colorClusters
.Append((colorKey, new[] { colorKey })) // Slot 255: used for transparent pixels
.ToArray();
}
// Create the actual palette, and a color index lookup cache:
var palette = colorClusters
.Select(cluster => cluster.Item1)
.ToArray();
var colorIndexMappingCache = new Dictionary <Rgba32, int>();
for (int i = 0; i < colorClusters.Length; i++)
{
(_, var colors) = colorClusters[i];
foreach (var color in colors)
{
colorIndexMappingCache[color] = i;
}
}
// Create any missing mipmaps:
for (int i = 1; i < images.Count; i++)
{
if (images[i] == null)
{
images[i] = images[0].Clone(context => context.Resize(images[0].Width >> i, images[0].Height >> i));
}
}
// Create texture data:
var textureData = images
.Select(image => CreateTextureData(image, palette, colorIndexMappingCache, textureSettings, isTransparentPredicate, disableDithering: isAnimatedTexture))
.ToArray();
return(Texture.CreateMipmapTexture(
name: textureName,
width: images[0].Width,
height: images[0].Height,
imageData: textureData[0],
palette: palette,
mipmap1Data: textureData[1],
mipmap2Data: textureData[2],
mipmap3Data: textureData[3]));
}
}