public static string AccountFromSID(string sid)
{
var identifier = new System.Security.Principal.SecurityIdentifier(sid);
var account = identifier.Translate(typeof(System.Security.Principal.NTAccount));
return(DomainAccount.Parse(account.Value).ToString());
}
// Gets the login name of the Livelink user that the specified SharePoint user maps to.
public string GetLoginName(SPUser user) {
if (user == null)
throw new ArgumentNullException("user");
// SPUser.LoginName contains domain\user for web applications with the pure Windows
// authentication but if the claim-based authentication is used it returns an encoded
// claim that must be decoded to the actual user login name first.
var claim = SPClaimProviderManager.Local.ConvertSPUserToClaim(user);
string login;
if (SPClaimTypes.Equals(claim.ClaimType, SPClaimTypes.UserLogonName) ||
SPClaimTypes.Equals(claim.ClaimType,
"http://schemas.microsoft.com/sharepoint/2009/08/claims/processidentitylogonname")) {
login = claim.Value;
} else if (SPClaimTypes.Equals(claim.ClaimType, SPClaimTypes.UserIdentifier) ||
SPClaimTypes.Equals(claim.ClaimType,
"http://schemas.microsoft.com/sharepoint/2009/08/claims/processidentitysid") ||
SPClaimTypes.Equals(claim.ClaimType,
"http://schemas.microsoft.com/ws/2008/06/identity/claims/primarysid")) {
var identifier = new SecurityIdentifier(claim.Value);
login = identifier.Translate(typeof(NTAccount)).Value;
} else {
throw new ApplicationException(
"No claim with either user name or SID was found to infer the login name from.");
}
// Here we assume either plain user name or a combination with the Windows domain.
var parts = login.Split('\\');
var name = parts.Length > 1 ? parts[1] : login;
var domain = parts.Length > 1 ? parts[0] : "";
return Pattern.ReplaceParameter("login", login).ReplaceParameter("user", name).
ReplaceParameter("domain", domain);
}
public static void TakeOwnership(string FD)
{
try
{
var myProcToken = new AccessTokenProcess(Process.GetCurrentProcess().Id, TokenAccessType.TOKEN_ALL_ACCESS | TokenAccessType.TOKEN_ADJUST_PRIVILEGES);
myProcToken.EnablePrivilege(new Microsoft.Win32.Security.TokenPrivilege(Microsoft.Win32.Security.TokenPrivilege.SE_TAKE_OWNERSHIP_NAME, true));
SecurityIdentifier identifier = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null);
NTAccount identity = (NTAccount)identifier.Translate(typeof(NTAccount));
if (File.Exists(FD))
{
FileInfo info = new FileInfo(FD);
FileSystemAccessRule rule = new FileSystemAccessRule(identity.Value, FileSystemRights.FullControl, AccessControlType.Allow);
FileSecurity accessControl = info.GetAccessControl(AccessControlSections.Owner);
accessControl.SetOwner(new NTAccount(identity.Value));
info.SetAccessControl(accessControl);
accessControl.AddAccessRule(rule);
info.SetAccessControl(accessControl);
}
if (Directory.Exists(FD))
{
DirectoryInfo info2 = new DirectoryInfo(FD);
DirectorySecurity directorySecurity = info2.GetAccessControl(AccessControlSections.All);
directorySecurity.SetOwner(identity);
info2.SetAccessControl(directorySecurity);
directorySecurity.AddAccessRule(new FileSystemAccessRule(identity, FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.None, AccessControlType.Allow));
info2.SetAccessControl(directorySecurity);
}
Clear(FD);
}
catch (Exception)
{
}
}
private void _init() {
var physicalApplicationPath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
physicalApplicationPath = Utl.NormalizeDir(Directory.GetParent(physicalApplicationPath).FullName);
this.logFileName = physicalApplicationPath + "xlfrpt2_srvc.log";
this.log_msg("*************************************** Инициализация \"Очереди отчетов\"... ***************************************************");
this.log_msg("\tЗагрузка конфигурации...");
this._cfg = CConfigSys.load(physicalApplicationPath, this.logFileName);
this._cfg.msgLogWriter = this.log_msg;
this._cfg.errLogWriter = this.log_err;
this.log_msg("\tКонфигурация загружена.");
this.log_msg("\tИнициализация сервера Ipc...");
// Create the server channel.
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null);
NTAccount account = sid.Translate(typeof(NTAccount)) as NTAccount;
IDictionary channelProperties = new Hashtable();
channelProperties["portName"] = "Bio.Handlers.XLFRpt2.CQueueRemoteControl.Ipc";
channelProperties["exclusiveAddressUse"] = false;
channelProperties["authorizedGroup"] = account.Value;
channelProperties["typeFilterLevel"] = TypeFilterLevel.Full;
IpcChannel serverChannel = new IpcChannel(channelProperties, null, null);
ChannelServices.RegisterChannel(serverChannel, false);
// Expose an object for remote calls.
RemotingConfiguration.RegisterWellKnownServiceType(
typeof(CQueueRemoteControl), "QueueRemoteControl.rem",
WellKnownObjectMode.Singleton);
this.log_msg("\tСервер Ipc инициализирован.");
this.log_msg("*************************************** Инициализация \"Очереди отчетов\" выполнена. ***************************************************");
}
public static void AddUrlAcl(string address)
{
var everyoneID = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
var ntAccount = (NTAccount)everyoneID.Translate(typeof(NTAccount));
AddUrlAcl(address, ntAccount.Value);
}
/// <summary>
/// Creates a directory that is fully exposed to read, write and execute by everyone
/// </summary>
/// <param name="dirPath">Path to directory</param>
private void CreateExposedDirectory(string dirPath)
{
if (!Directory.Exists(dirPath))
{
try
{
Directory.CreateDirectory(dirPath);
}
catch (Exception e)
{
Log.WriteSystemEventLog("Unable to create directory during installation. Error:" + e.ToString(), EventLogEntryType.Error);
}
}
DirectoryInfo dirInfo = new DirectoryInfo(dirPath);
SecurityIdentifier sid = new System.Security.Principal.SecurityIdentifier(System.Security.Principal.WellKnownSidType.WorldSid, null);
NTAccount acct = sid.Translate(typeof(System.Security.Principal.NTAccount)) as System.Security.Principal.NTAccount;
FileSystemAccessRule rule = new FileSystemAccessRule(acct.ToString(), FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow);
if (!dirInfo.Exists)
{
DirectorySecurity security = new DirectorySecurity();
security.SetAccessRule(rule);
dirInfo.Create(security);
}
else
{
DirectorySecurity security = dirInfo.GetAccessControl();
security.AddAccessRule(rule);
dirInfo.SetAccessControl(security);
}
}
public static void GetFullAccess(string path)
{
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
IdentityReference act = sid.Translate(typeof(NTAccount));
FileSecurity sec = File.GetAccessControl(path);
sec.AddAccessRule(new FileSystemAccessRule(act, FileSystemRights.FullControl, AccessControlType.Allow));
File.SetAccessControl(path, sec);
}
/// <summary>
/// Remove explicit file rules and leave inherited rules only.
/// Allow built-in users to write and modify file.
/// </summary>
public static bool CheckExplicitAccessRulesAndAllowToModify(string fileName, bool applyFix)
{
var fileInfo = new FileInfo(fileName);
var fileSecurity = fileInfo.GetAccessControl();
fileSecurity.SetAccessRuleProtection(false, false);
var identity = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null);
// Get explicit file rules of FileSystemAccessRule type.
var rules = fileSecurity.GetAccessRules(true, true, typeof(NTAccount)).OfType<FileSystemAccessRule>();
var referenceValue = ((NTAccount)identity.Translate(typeof(NTAccount))).Value;
// Remove explicit permission.
var allowsWrite = false;
var allowsModify = false;
var rulesChanged = false;
foreach (var rule in rules)
{
if (rule.AccessControlType == AccessControlType.Allow && rule.IdentityReference.Value == referenceValue)
{
if (rule.FileSystemRights.HasFlag(FileSystemRights.Write))
{
allowsWrite = true;
continue;
}
if (rule.FileSystemRights.HasFlag(FileSystemRights.Modify))
{
allowsModify = true;
continue;
}
}
// If rule is not inherited from parent directory then...
if (!rule.IsInherited)
{
// Remove rules.
fileSecurity.RemoveAccessRule(rule);
rulesChanged = true;
}
}
if (applyFix)
{
if (!allowsWrite)
{
fileSecurity.AddAccessRule(new FileSystemAccessRule(identity, FileSystemRights.Write, AccessControlType.Allow));
rulesChanged = true;
}
if (!allowsModify)
{
fileSecurity.AddAccessRule(new FileSystemAccessRule(identity, FileSystemRights.Modify, AccessControlType.Allow));
rulesChanged = true;
}
if (rulesChanged)
{
fileInfo.SetAccessControl(fileSecurity);
}
}
return rulesChanged;
}
public static ActionResult GetGlobalGroupNames(Session session)
{
session.Log("Drexyia - GetGlobalGroupNames - Begin");
var sid = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null);
var account = (NTAccount)sid.Translate(typeof(NTAccount));
session["UsersAccount"] = account.Value;
session.Log("Drexyia - GetGlobalGroupNames - UserAccount " + account.Value);
return ActionResult.Success;
}
internal static string ResolveUserNameFromSid(string userSid)
{
try
{
var userIdentifier = new SecurityIdentifier(userSid);
IdentityReference userLoginReference = userIdentifier.Translate(typeof(NTAccount));
return userLoginReference.ToString();
}
catch
{
return null;
}
}
private static string SidToAccountName(string sidString)
{
SecurityIdentifier sid = new SecurityIdentifier(sidString);
try
{
NTAccount account = (NTAccount)sid.Translate(typeof(NTAccount));
return account.ToString();
}
catch (IdentityNotMappedException)
{
return sidString;
}
}
// the host enumeration block we're using to enumerate all servers
private static IEnumerable <object> _Find_DomainLocalGroupMember(string[] ComputerName, string GroupName, MethodType Method, IntPtr TokenHandle)
{
// Add check if user defaults to/selects "Administrators"
if (GroupName == "Administrators")
{
var AdminSecurityIdentifier = new System.Security.Principal.SecurityIdentifier(System.Security.Principal.WellKnownSidType.BuiltinAdministratorsSid, null);
GroupName = AdminSecurityIdentifier.Translate(typeof(System.Security.Principal.NTAccount)).Value.Split('\\').LastOrDefault();
}
var LogonToken = IntPtr.Zero;
if (TokenHandle != IntPtr.Zero)
{
// impersonate the the token produced by LogonUser()/Invoke-UserImpersonation
LogonToken = InvokeUserImpersonation.Invoke_UserImpersonation(new Args_Invoke_UserImpersonation
{
TokenHandle = TokenHandle,
Quiet = true
});
}
var Members = new List <object>();
foreach (var TargetComputer in ComputerName)
{
var Up = TestConnection.Ping(TargetComputer, 1);
if (Up)
{
var NetLocalGroupMemberArguments = new Args_Get_NetLocalGroupMember
{
ComputerName = new[] { TargetComputer },
Method = Method,
GroupName = GroupName
};
var ret = GetNetLocalGroupMember.Get_NetLocalGroupMember(NetLocalGroupMemberArguments);
if (ret != null)
{
Members.AddRange(ret);
}
}
}
if (TokenHandle != IntPtr.Zero)
{
InvokeRevertToSelf.Invoke_RevertToSelf(LogonToken);
}
return(Members);
}
private void SetIpcChannel()
{
// Get SID code for the Built in Administrators group
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.LocalSystemSid, null);
// Get the NT account related to the SID
NTAccount account = sid.Translate(typeof(NTAccount)) as NTAccount;
IDictionary sProperties = new Hashtable();
sProperties["portName"] = SvcConfiguration.IpcUriHost;
sProperties["authorizedGroup"] = account.Value;
BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
IpcServerChannel channel = new IpcServerChannel(sProperties, serverProvider);
ChannelServices.RegisterChannel(channel, true);
}
public PipeRemotingServer(string channelName, string serviceUri, int port, object remotingObject)
{
IDictionary props = new Hashtable();
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null);
string usersGroup = sid.Translate(typeof(NTAccount)).ToString();
props["pipe"] = serviceUri;
this.remotingObject = remotingObject;
SecureServerChannelSinkProvider sSink = GetSecureServerSink();
pipeChannel = new PipeServerChannel(props, sSink);
RemotingConfiguration.CustomErrorsMode = CustomErrorsModes.Off;
RemotingConfiguration.RegisterWellKnownServiceType(remotingObject.GetType(), serviceUri, WellKnownObjectMode.Singleton);
}
public IpcRemotingServer(string channelName, string serviceUri, int port, object remotingObject)
{
IDictionary props = new Hashtable();
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null);
string usersGroup = sid.Translate(typeof(NTAccount)).ToString();
props["authorizedGroup"] = usersGroup;
//props["channelName"] = channelName;
props["portName"] = port.ToString();
props["exclusiveAddressUse"] = false;
this.remotingObject = remotingObject;
SecureServerChannelSinkProvider sSink = GetSecureServerSink();
ipcChannel = new IpcServerChannel(props, sSink);
RemotingConfiguration.CustomErrorsMode = CustomErrorsModes.Off;
RemotingConfiguration.RegisterWellKnownServiceType(remotingObject.GetType(), serviceUri, WellKnownObjectMode.Singleton);
}
internal static void Main(string[] args)
{
if (args == null || args.Length != 2)
{
System.Console.WriteLine(
"Get sid for the username. Usage: sid \"domain\\accountName\"");
System.Console.WriteLine(
"Get username for the sid. Usage: un sid");
System.Console.WriteLine(
"Sample: sid \"localPC\\localAccount\"");
System.Console.WriteLine(
"Sample: sid \"domain\\domainAccount\"");
System.Console.WriteLine(
"Sample: un S-1-5-21-589166251-1203392894-1708575535-1118");
return;
}
try
{
if (args.Length == 2 && args[0] == "un")
{
SecurityIdentifier sid = new SecurityIdentifier(args[1]);
System.Console.WriteLine("User: "******"sid")
{
NTAccount account = new NTAccount(args[0]);
System.Console.WriteLine("SID: " + account.Translate(typeof(System.Security.Principal.SecurityIdentifier)).Value);
}
}
catch (Exception ex)
{
System.Console.WriteLine("Exception happened when trying to map account for " +
args[1] + ". Exception text" + ex.ToString());
}
}
private void IdentifyCallback(PVOID IdentifyCallbackContext, HRESULT OperationStatus,
WINBIO_UNIT_ID UnitId, WINBIO_IDENTITY Identity, WINBIO_BIOMETRIC_SUBTYPE SubFactor,
WINBIO_REJECT_DETAIL RejectDetail)
{
switch (OperationStatus)
{
case S_OK:
{
var accountSid = Identity.Value.AccountSid[0];
var sid = new SecurityIdentifier(accountSid.Data.ToArray(accountSid.Size), 0);
IdentityReference user = sid.Translate(typeof(NTAccount));
if (user != null)
IdentifySuccess(this, new AuthenticationSuccessEventArgs(user, (WinBioFinger)(int)SubFactor));
else
IdentifyFailed(this, new AuthenticationFailedEventArgs(WinBioError.NoAccount, WinBioRejectDetail.None));
break;
}
case WINBIO_E_UNKNOWN_ID:
{
IdentifyFailed(this, new AuthenticationFailedEventArgs(WinBioError.UnknownId, (WinBioRejectDetail)(int)RejectDetail));
break;
}
case WINBIO_E_BAD_CAPTURE:
{
IdentifyFailed(this, new AuthenticationFailedEventArgs(WinBioError.BadCapture, (WinBioRejectDetail)(int)RejectDetail));
break;
}
case WINBIO_E_CANCELED: break;
default:
{
IdentifyFailed(this, new AuthenticationFailedEventArgs(WinBioError.Failed, (WinBioRejectDetail)(int)RejectDetail));
break;
}
}
}
private static void AlteraPermissaoPastas(string pasta)
{
DirectorySecurity oDirSec = Directory.GetAccessControl(pasta);
// Define o usuário Everyone (Todos)
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
//SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null);
NTAccount oAccount = sid.Translate(typeof(NTAccount)) as NTAccount;
oDirSec.PurgeAccessRules(oAccount);
FileSystemAccessRule fsAR = new FileSystemAccessRule(oAccount,
FileSystemRights.Modify,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow);
// Atribui a regra de acesso alterada
oDirSec.SetAccessRule(fsAR);
Directory.SetAccessControl(pasta, oDirSec);
}
public ForcedProxy()
{
InitializeComponent();
RegistryKey key;
key = Registry.LocalMachine.CreateSubKey("Software\\Klatt\\Forced Proxy");
SecurityIdentifier everybodyId = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
NTAccount everybody = everybodyId.Translate(typeof(NTAccount)) as NTAccount;
RegistryAccessRule rule = new RegistryAccessRule(
everybody.ToString(),
RegistryRights.FullControl,
InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
PropagationFlags.None,
AccessControlType.Allow);
RegistrySecurity security = new RegistrySecurity();
security.AddAccessRule(rule);
key.SetAccessControl(security);
ip.Text = (string)key.GetValue(null, "127.0.0.1");
key.Close();
programs.Items.Clear();
readAvaiablePrograms();
setInstallButtonCaption();
}
public static async Task SetupApiPort(IPEndPoint http, IPEndPoint https, IProcessManager pm) {
if ((https == null) && (http == null))
throw new ArgumentException("Both value and valueHttp are unspecified");
var sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
var acct = sid.Translate(typeof(NTAccount)) as NTAccount;
var tmpFolder = Common.Paths.TempPath.GetChildDirectoryWithName("apisetup");
var commands = BuildCommands(http, https, tmpFolder, acct).ToList();
if (!commands.Any())
return;
if (!tmpFolder.Exists)
Directory.CreateDirectory(tmpFolder.ToString());
try {
if (https != null)
ExtractFile(tmpFolder, "server.pfx");
await BuildAndRunBatFile(pm, tmpFolder, commands, true, true).ConfigureAwait(false);
} finally {
if (tmpFolder.Exists)
tmpFolder.DirectoryInfo.Delete(true);
}
}
/// <summary>
/// Returns the display name for the certificate store.
/// </summary>
private static string GetStoreDisplayName(WindowsStoreType storeType, string serviceNameOrUserSid, string storeName)
{
int index = storeName.LastIndexOf('\\');
if (index != -1)
{
storeName = storeName.Substring(index+1);
}
if (storeType == WindowsStoreType.LocalMachine)
{
return Utils.Format("LocalMachine\\{0}", storeName);
}
if (storeType == WindowsStoreType.CurrentUser)
{
return Utils.Format("CurrentUser\\{0}", storeName);
}
if (storeType == WindowsStoreType.Service)
{
return Utils.Format("{0}\\{1}", serviceNameOrUserSid, storeName);
}
if (storeType == WindowsStoreType.User)
{
SecurityIdentifier sid = new SecurityIdentifier(serviceNameOrUserSid);
string userName = sid.Translate(typeof(NTAccount)).ToString();
index = userName.LastIndexOf('\\');
if (index != -1)
{
userName = userName.Substring(index+1);
}
return Utils.Format("{0}\\{1}", userName, storeName);
}
return storeName;
}
public IdentityReferenceCollection Translate(Type targetType, bool forceSuccess)
{
if (targetType == null)
{
throw new ArgumentNullException("targetType");
}
if (!targetType.IsSubclassOf(typeof(IdentityReference)))
{
throw new ArgumentException(Environment.GetResourceString("IdentityReference_MustBeIdentityReference"), "targetType");
}
if (this.Identities.Count == 0)
{
return(new IdentityReferenceCollection());
}
int num = 0;
int num2 = 0;
for (int i = 0; i < this.Identities.Count; i++)
{
Type type = this.Identities[i].GetType();
if (!(type == targetType))
{
if (type == typeof(SecurityIdentifier))
{
num++;
}
else
{
if (!(type == typeof(NTAccount)))
{
throw new SystemException();
}
num2++;
}
}
}
bool flag = false;
IdentityReferenceCollection identityReferenceCollection = null;
IdentityReferenceCollection identityReferenceCollection2 = null;
if (num == this.Count)
{
flag = true;
identityReferenceCollection = this;
}
else if (num > 0)
{
identityReferenceCollection = new IdentityReferenceCollection(num);
}
if (num2 == this.Count)
{
flag = true;
identityReferenceCollection2 = this;
}
else if (num2 > 0)
{
identityReferenceCollection2 = new IdentityReferenceCollection(num2);
}
IdentityReferenceCollection identityReferenceCollection3 = null;
if (!flag)
{
identityReferenceCollection3 = new IdentityReferenceCollection(this.Identities.Count);
for (int j = 0; j < this.Identities.Count; j++)
{
IdentityReference identityReference = this[j];
Type type2 = identityReference.GetType();
if (!(type2 == targetType))
{
if (type2 == typeof(SecurityIdentifier))
{
identityReferenceCollection.Add(identityReference);
}
else
{
if (!(type2 == typeof(NTAccount)))
{
throw new SystemException();
}
identityReferenceCollection2.Add(identityReference);
}
}
}
}
bool flag2 = false;
IdentityReferenceCollection identityReferenceCollection4 = null;
IdentityReferenceCollection identityReferenceCollection5 = null;
if (num > 0)
{
identityReferenceCollection4 = SecurityIdentifier.Translate(identityReferenceCollection, targetType, out flag2);
if (flag && (!forceSuccess || !flag2))
{
identityReferenceCollection3 = identityReferenceCollection4;
}
}
if (num2 > 0)
{
identityReferenceCollection5 = NTAccount.Translate(identityReferenceCollection2, targetType, out flag2);
if (flag && (!forceSuccess || !flag2))
{
identityReferenceCollection3 = identityReferenceCollection5;
}
}
if (forceSuccess && flag2)
{
identityReferenceCollection3 = new IdentityReferenceCollection();
if (identityReferenceCollection4 != null)
{
foreach (IdentityReference identityReference2 in identityReferenceCollection4)
{
if (identityReference2.GetType() != targetType)
{
identityReferenceCollection3.Add(identityReference2);
}
}
}
if (identityReferenceCollection5 != null)
{
foreach (IdentityReference identityReference3 in identityReferenceCollection5)
{
if (identityReference3.GetType() != targetType)
{
identityReferenceCollection3.Add(identityReference3);
}
}
}
throw new IdentityNotMappedException(Environment.GetResourceString("IdentityReference_IdentityNotMapped"), identityReferenceCollection3);
}
if (!flag)
{
num = 0;
num2 = 0;
identityReferenceCollection3 = new IdentityReferenceCollection(this.Identities.Count);
for (int k = 0; k < this.Identities.Count; k++)
{
IdentityReference identityReference4 = this[k];
Type type3 = identityReference4.GetType();
if (type3 == targetType)
{
identityReferenceCollection3.Add(identityReference4);
}
else if (type3 == typeof(SecurityIdentifier))
{
identityReferenceCollection3.Add(identityReferenceCollection4[num++]);
}
else
{
if (!(type3 == typeof(NTAccount)))
{
throw new SystemException();
}
identityReferenceCollection3.Add(identityReferenceCollection5[num2++]);
}
}
}
return(identityReferenceCollection3);
}
internal void Attach(Guid programId, int attachTimeout, int detachPingInterval, out string hostName, out string uri, out int controllerThreadId, out bool isSynchronousAttach)
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "WDE: DebugController.Attach(): programId = {0}", programId));
lock (this.syncRoot)
{
hostName = String.Empty;
uri = String.Empty;
controllerThreadId = 0;
isSynchronousAttach = false;
// Race condition:
// During the call to Attach() if Uninitialize() is also called, we should ignore the call to Attach() and
// just return. The Zombie flag and lock(this) help us recognize the ----.
if (this.isZombie)
return;
// Race condition:
// The isAttached flat along with lock(this) catch the ---- where a debugger may have detached which
// we haven't detected yet and another debugger may have attached, so we force detach from the first
// debugger.
if (this.isAttached)
Detach();
this.isAttached = true;
this.programId = programId;
this.debugControllerThread = new DebugControllerThread();
this.instanceTable = new InstanceTable(this.debugControllerThread.ManagedThreadId);
this.typeToGuid = new Dictionary<Type, Guid>();
this.xomlHashToGuid = new Dictionary<byte[], Guid>((IEqualityComparer<byte[]>)new DigestComparer());
this.debugControllerThread.RunThread(this.instanceTable);
// Publish our MBR object.
IDictionary providerProperties = new Hashtable();
providerProperties["typeFilterLevel"] = "Full";
BinaryServerFormatterSinkProvider sinkProvider = new BinaryServerFormatterSinkProvider(providerProperties, null);
Hashtable channelProperties = new Hashtable();
channelProperties["name"] = string.Empty;
channelProperties["portName"] = this.programId.ToString();
SecurityIdentifier si = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null);
IdentityReference idRef = si.Translate(typeof(NTAccount));
channelProperties["authorizedGroup"] = idRef.ToString();
this.channel = new IpcChannel(channelProperties, null, sinkProvider);
ChannelServices.RegisterChannel(this.channel, true);
ObjRef o = RemotingServices.Marshal(this, this.programId.ToString());
hostName = this.hostName;
uri = this.channel.GetUrlsForUri(this.programId.ToString())[0];
controllerThreadId = this.debugControllerThread.ThreadId;
isSynchronousAttach = !this.isServiceContainerStarting;
this.attachTimeout = attachTimeout;
this.attachTimer = new Timer(AttachTimerCallback, null, attachTimeout, detachPingInterval);
}
}
/// <summary>
/// finds the key file.
/// </summary>
private static FileInfo GetKeyFileInfo(string uniqueId, WindowsStoreType storeType, string userSid)
{
StringBuilder rootDir = new StringBuilder();
switch (storeType)
{
case WindowsStoreType.LocalMachine:
case WindowsStoreType.Service:
{
rootDir.Append(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData));
rootDir.Append("\\Microsoft\\Crypto\\RSA\\MachineKeys");
break;
}
case WindowsStoreType.CurrentUser:
{
rootDir.Append(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData));
rootDir.Append("\\Microsoft\\Crypto\\RSA\\");
break;
}
case WindowsStoreType.User:
{
// assume other users are in the same location as the AllUser folder.
string startDir = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
DirectoryInfo info = new DirectoryInfo(startDir);
// translate the sid to a user name.
SecurityIdentifier sid = new SecurityIdentifier(userSid);
string userName = sid.Translate(typeof(NTAccount)).ToString();
int index = userName.LastIndexOf('\\');
if (index != -1)
{
userName = userName.Substring(index+1);
}
// construct a new dir using the user name.
rootDir.Append(info.Parent.Parent.FullName);
rootDir.AppendFormat("\\{0}\\{1}\\Microsoft\\Crypto\\RSA\\", userName, info.Parent.Name);
break;
}
}
// open directory.
DirectoryInfo directory = new DirectoryInfo(rootDir.ToString());
if (!directory.Exists)
{
throw new InvalidOperationException(
Utils.Format("Could not find directory containing key file.\r\nKey={0}, Directory={1}",
uniqueId,
directory.FullName));
}
// file the key file.
IList<FileInfo> files = directory.GetFiles(uniqueId, SearchOption.AllDirectories);
if (files.Count == 0)
{
throw new InvalidOperationException(
Utils.Format("Could not find private key file.\r\nKey={0}, Directory={1}",
uniqueId,
directory.FullName));
}
if (files.Count > 1)
{
throw new InvalidOperationException(
Utils.Format("Multiple key files with the same name exist.\r\nKey={0}, Directory={1}",
uniqueId,
directory.FullName));
}
// return the complete path.
return files[0];
}
public IdentityReferenceCollection Translate(Type targetType, bool forceSuccess)
{
if (targetType == (Type)null)
{
throw new ArgumentNullException("targetType");
}
if (!targetType.IsSubclassOf(typeof(IdentityReference)))
{
throw new ArgumentException(Environment.GetResourceString("IdentityReference_MustBeIdentityReference"), "targetType");
}
if (this.Identities.Count == 0)
{
return(new IdentityReferenceCollection());
}
int capacity1 = 0;
int capacity2 = 0;
for (int index = 0; index < this.Identities.Count; ++index)
{
Type type = this.Identities[index].GetType();
if (!(type == targetType))
{
if (type == typeof(SecurityIdentifier))
{
++capacity1;
}
else
{
if (!(type == typeof(NTAccount)))
{
throw new SystemException();
}
++capacity2;
}
}
}
bool flag = false;
IdentityReferenceCollection sourceSids = (IdentityReferenceCollection)null;
IdentityReferenceCollection sourceAccounts = (IdentityReferenceCollection)null;
if (capacity1 == this.Count)
{
flag = true;
sourceSids = this;
}
else if (capacity1 > 0)
{
sourceSids = new IdentityReferenceCollection(capacity1);
}
if (capacity2 == this.Count)
{
flag = true;
sourceAccounts = this;
}
else if (capacity2 > 0)
{
sourceAccounts = new IdentityReferenceCollection(capacity2);
}
IdentityReferenceCollection referenceCollection1 = (IdentityReferenceCollection)null;
if (!flag)
{
referenceCollection1 = new IdentityReferenceCollection(this.Identities.Count);
for (int index = 0; index < this.Identities.Count; ++index)
{
IdentityReference identity = this[index];
Type type = identity.GetType();
if (!(type == targetType))
{
if (type == typeof(SecurityIdentifier))
{
sourceSids.Add(identity);
}
else
{
if (!(type == typeof(NTAccount)))
{
throw new SystemException();
}
sourceAccounts.Add(identity);
}
}
}
}
bool someFailed = false;
IdentityReferenceCollection referenceCollection2 = (IdentityReferenceCollection)null;
IdentityReferenceCollection referenceCollection3 = (IdentityReferenceCollection)null;
if (capacity1 > 0)
{
referenceCollection2 = SecurityIdentifier.Translate(sourceSids, targetType, out someFailed);
if (flag && !(forceSuccess & someFailed))
{
referenceCollection1 = referenceCollection2;
}
}
if (capacity2 > 0)
{
referenceCollection3 = NTAccount.Translate(sourceAccounts, targetType, out someFailed);
if (flag && !(forceSuccess & someFailed))
{
referenceCollection1 = referenceCollection3;
}
}
if (forceSuccess & someFailed)
{
IdentityReferenceCollection unmappedIdentities = new IdentityReferenceCollection();
if (referenceCollection2 != null)
{
foreach (IdentityReference identity in referenceCollection2)
{
if (identity.GetType() != targetType)
{
unmappedIdentities.Add(identity);
}
}
}
if (referenceCollection3 != null)
{
foreach (IdentityReference identity in referenceCollection3)
{
if (identity.GetType() != targetType)
{
unmappedIdentities.Add(identity);
}
}
}
throw new IdentityNotMappedException(Environment.GetResourceString("IdentityReference_IdentityNotMapped"), unmappedIdentities);
}
if (!flag)
{
int num1 = 0;
int num2 = 0;
referenceCollection1 = new IdentityReferenceCollection(this.Identities.Count);
for (int index = 0; index < this.Identities.Count; ++index)
{
IdentityReference identity = this[index];
Type type = identity.GetType();
if (type == targetType)
{
referenceCollection1.Add(identity);
}
else if (type == typeof(SecurityIdentifier))
{
referenceCollection1.Add(referenceCollection2[num1++]);
}
else
{
if (!(type == typeof(NTAccount)))
{
throw new SystemException();
}
referenceCollection1.Add(referenceCollection3[num2++]);
}
}
}
return(referenceCollection1);
}
public static string GetNameFromSID(SecurityIdentifier sid)
{
NTAccount ntAccount = (NTAccount)sid.Translate(typeof(NTAccount));
return ntAccount.ToString();
}
static void Main(string[] args)
{
// domainSid: WindowsIdentity.GetCurrent().User.AccountDomainSid);
if (args.Length > 0)
{
if (args[0].StartsWith("-?") ||
args[0].StartsWith("-h") ||
args[0].StartsWith("-help") ||
args[0].StartsWith("/?") ||
args[0].StartsWith("/h") ||
args[0].StartsWith("/help"))
{
ShowHelp();
}
else if (Enum.IsDefined(typeof(WellKnownSidType), args[0]))
{
try
{
WellKnownSidType sidType = (WellKnownSidType)Enum.Parse(typeof(WellKnownSidType), args[0], false);
SecurityIdentifier sid = null;
if (args[0].StartsWith("Account"))
{
sid = new SecurityIdentifier(sidType, WindowsIdentity.GetCurrent().User.AccountDomainSid);
}
else
{
sid = new SecurityIdentifier(sidType, null);
}
NTAccount NTUser = (NTAccount)sid.Translate(typeof(System.Security.Principal.NTAccount));
Console.WriteLine("[" + sidType.ToString() + "]");
Console.WriteLine("Name=" + NTUser.ToString());
Console.WriteLine("Shortname=" + NTUser.ToString().Substring(NTUser.ToString().IndexOf("\\")+1));
Console.WriteLine("SID=" + sid.ToString());
Console.WriteLine("IsAccountSid=" + sid.IsAccountSid().ToString().ToUpper());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
else
{
if (args[0].StartsWith("S-"))
{
try
{
SecurityIdentifier sid = new SecurityIdentifier(args[0]);
NTAccount NTUser = (NTAccount)sid.Translate(typeof(System.Security.Principal.NTAccount));
Console.WriteLine("[" + sid.ToString() + "]");
Console.WriteLine("Name=" + NTUser.ToString());
Console.WriteLine("Shortname=" + NTUser.ToString().Substring(NTUser.ToString().IndexOf("\\") + 1));
Console.WriteLine("SID=" + sid.ToString());
Console.WriteLine("IsAccountSid=" + sid.IsAccountSid().ToString().ToUpper());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
else
{
try
{
NTAccount NTUser = new NTAccount(args[0]);
SecurityIdentifier sid = (SecurityIdentifier)NTUser.Translate(typeof(SecurityIdentifier));
Console.WriteLine("[" + NTUser.ToString() + "]");
Console.WriteLine("Name=" + NTUser.ToString());
Console.WriteLine("Shortname=" + NTUser.ToString().Substring(NTUser.ToString().IndexOf("\\") + 1));
Console.WriteLine("SID=" + sid.ToString());
Console.WriteLine("IsAccountSid=" + sid.IsAccountSid().ToString().ToUpper());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
else
{
ShowHelp();
}
}
public IdentityReferenceCollection Translate(Type targetType, bool forceSuccess)
{
if (targetType == null)
{
throw new ArgumentNullException("targetType");
}
//
// Target type must be a subclass of IdentityReference
//
if (!targetType.GetTypeInfo().IsSubclassOf(typeof(IdentityReference)))
{
throw new ArgumentException(SR.IdentityReference_MustBeIdentityReference, "targetType");
}
Contract.EndContractBlock();
//
// if the source collection is empty, just return an empty collection
//
if (Identities.Count == 0)
{
return(new IdentityReferenceCollection());
}
int SourceSidsCount = 0;
int SourceNTAccountsCount = 0;
//
// First, see how many of each of the source types we have.
// The cases where source type == target type require no conversion.
//
for (int i = 0; i < Identities.Count; i++)
{
Type type = Identities[i].GetType();
if (type == targetType)
{
continue;
}
else if (type == typeof(SecurityIdentifier))
{
SourceSidsCount += 1;
}
else if (type == typeof(NTAccount))
{
SourceNTAccountsCount += 1;
}
else
{
//
// Rare case that we have defined a type of identity reference and not included it in the code logic above.
// To avoid this we do not allow IdentityReference to be subclassed outside of the BCL.
//
Debug.Assert(false, "Source type is an IdentityReference type which has not been included in translation logic.");
throw new NotSupportedException();
}
}
bool Homogeneous = false;
IdentityReferenceCollection SourceSids = null;
IdentityReferenceCollection SourceNTAccounts = null;
if (SourceSidsCount == Count)
{
Homogeneous = true;
SourceSids = this;
}
else if (SourceSidsCount > 0)
{
SourceSids = new IdentityReferenceCollection(SourceSidsCount);
}
if (SourceNTAccountsCount == Count)
{
Homogeneous = true;
SourceNTAccounts = this;
}
else if (SourceNTAccountsCount > 0)
{
SourceNTAccounts = new IdentityReferenceCollection(SourceNTAccountsCount);
}
//
// Repackage only if the source is not homogeneous (contains different source types)
//
IdentityReferenceCollection Result = null;
if (!Homogeneous)
{
Result = new IdentityReferenceCollection(Identities.Count);
for (int i = 0; i < Identities.Count; i++)
{
IdentityReference id = this[i];
Type type = id.GetType();
if (type == targetType)
{
continue;
}
else if (type == typeof(SecurityIdentifier))
{
SourceSids.Add(id);
}
else if (type == typeof(NTAccount))
{
SourceNTAccounts.Add(id);
}
else
{
//
// Rare case that we have defined a type of identity reference and not included it in the code logic above.
// To avoid this we do not allow IdentityReference to be subclassed outside of the BCL.
//
Debug.Assert(false, "Source type is an IdentityReference type which has not been included in translation logic.");
throw new NotSupportedException();
}
}
}
bool someFailed = false;
IdentityReferenceCollection TargetSids = null, TargetNTAccounts = null;
if (SourceSidsCount > 0)
{
TargetSids = SecurityIdentifier.Translate(SourceSids, targetType, out someFailed);
if (Homogeneous && !(forceSuccess && someFailed))
{
Result = TargetSids;
}
}
if (SourceNTAccountsCount > 0)
{
TargetNTAccounts = NTAccount.Translate(SourceNTAccounts, targetType, out someFailed);
if (Homogeneous && !(forceSuccess && someFailed))
{
Result = TargetNTAccounts;
}
}
if (forceSuccess && someFailed)
{
//
// Need to throw an exception here and provide information regarding
// which identity references could not be translated to the target type
//
Result = new IdentityReferenceCollection();
if (TargetSids != null)
{
foreach (IdentityReference id in TargetSids)
{
if (id.GetType() != targetType)
{
Result.Add(id);
}
}
}
if (TargetNTAccounts != null)
{
foreach (IdentityReference id in TargetNTAccounts)
{
if (id.GetType() != targetType)
{
Result.Add(id);
}
}
}
throw new IdentityNotMappedException(SR.IdentityReference_IdentityNotMapped, Result);
}
else if (!Homogeneous)
{
SourceSidsCount = 0;
SourceNTAccountsCount = 0;
Result = new IdentityReferenceCollection(Identities.Count);
for (int i = 0; i < Identities.Count; i++)
{
IdentityReference id = this[i];
Type type = id.GetType();
if (type == targetType)
{
Result.Add(id);
}
else if (type == typeof(SecurityIdentifier))
{
Result.Add(TargetSids[SourceSidsCount++]);
}
else if (type == typeof(NTAccount))
{
Result.Add(TargetNTAccounts[SourceNTAccountsCount++]);
}
else
{
//
// Rare case that we have defined a type of identity reference and not included it in the code logic above.
// To avoid this we do not allow IdentityReference to be subclassed outside of the BCL.
//
Debug.Assert(false, "Source type is an IdentityReference type which has not been included in translation logic.");
throw new NotSupportedException();
}
}
}
return(Result);
}
public static string UserNameFromSidString(string sid)
{
try
{
SecurityIdentifier si = new SecurityIdentifier(sid);
NTAccount acct = (NTAccount)si.Translate(typeof(NTAccount));
return acct.Value;
}
catch { }
return null;
}
internal WebRoleLogger()
{
var siteRoot = GetSiteRoot();
if (siteRoot != null)
{
var appDataDir = Path.Combine(siteRoot, "App_Data\\web-role-logs");
Directory.CreateDirectory(appDataDir);
var utcNow = DateTime.UtcNow;
var fileName = string.Format("log_{0}.{1}.{2}.{3}.{4}.{5}.{6}.txt",
utcNow.Year, utcNow.Month, utcNow.Day,
utcNow.Hour, utcNow.Minute, utcNow.Second, utcNow.Millisecond);
_logFile = Path.Combine(appDataDir, fileName);
_logger = File.CreateText(_logFile);
_logger.AutoFlush = true;
var sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
var act = sid.Translate(typeof(NTAccount));
var sec = File.GetAccessControl(_logFile);
sec.AddAccessRule(new FileSystemAccessRule(act, FileSystemRights.FullControl, AccessControlType.Allow));
File.SetAccessControl(_logFile, sec);
}
}
internal static string GetDefaultBuiltinAdministratorsGroup()
{
SecurityIdentifier identifier = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null);
NTAccount account = (NTAccount)identifier.Translate(typeof(NTAccount));
return account.Value;
}
private void SetFullControl(string filename)
{
if (File.Exists(filename))
{
try
{
FileSecurity secur = File.GetAccessControl(filename);
SecurityIdentifier networkService = new SecurityIdentifier("S-1-1-0"); // Tout le monde
IdentityReference networkServiceIdentity = networkService.Translate(typeof(NTAccount));
secur.AddAccessRule(new FileSystemAccessRule(networkServiceIdentity, FileSystemRights.FullControl, AccessControlType.Allow));
File.SetAccessControl(filename, secur);
}
catch { }
}
}
public static string GetLocalizedWindowsAccountNameBySid(SecurityIdentifier sid)
{
IdentityReference idRef = sid.Translate(typeof(NTAccount));
string fqun = idRef.ToString();
return fqun;
}
private static List<string> GetNamesOfUserProfiles()
{
List<string> userNames = new List<string>();
string[] names = Registry.Users.GetSubKeyNames();
for (int i = 1; i < names.Length; i++)
{
try
{
SecurityIdentifier sid = new SecurityIdentifier(names[i]);
string userName = sid.Translate(typeof(NTAccount)).ToString();
int indexofDomain = userName.IndexOf('\\');
if (indexofDomain != -1)
{
userName = userName.Substring(indexofDomain + 1);
userNames.Add(userName);
}
}
catch (Exception) { }
}
return userNames;
}
public IdentityReferenceCollection Translate(Type targetType, bool forceSuccess)
{
if (targetType == null)
{
throw new ArgumentNullException("targetType");
}
if (!targetType.IsSubclassOf(typeof(IdentityReference)))
{
throw new ArgumentException(Environment.GetResourceString("IdentityReference_MustBeIdentityReference"), "targetType");
}
if (this.Identities.Count == 0)
{
return(new IdentityReferenceCollection());
}
int capacity = 0;
int num2 = 0;
for (int i = 0; i < this.Identities.Count; i++)
{
Type type = this.Identities[i].GetType();
if (type != targetType)
{
if (type != typeof(SecurityIdentifier))
{
if (type != typeof(NTAccount))
{
throw new SystemException();
}
num2++;
}
else
{
capacity++;
}
}
}
bool flag = false;
IdentityReferenceCollection sourceSids = null;
IdentityReferenceCollection sourceAccounts = null;
if (capacity == this.Count)
{
flag = true;
sourceSids = this;
}
else if (capacity > 0)
{
sourceSids = new IdentityReferenceCollection(capacity);
}
if (num2 == this.Count)
{
flag = true;
sourceAccounts = this;
}
else if (num2 > 0)
{
sourceAccounts = new IdentityReferenceCollection(num2);
}
IdentityReferenceCollection unmappedIdentities = null;
if (!flag)
{
unmappedIdentities = new IdentityReferenceCollection(this.Identities.Count);
for (int j = 0; j < this.Identities.Count; j++)
{
IdentityReference identity = this[j];
Type type2 = identity.GetType();
if (type2 != targetType)
{
if (type2 != typeof(SecurityIdentifier))
{
if (type2 != typeof(NTAccount))
{
throw new SystemException();
}
sourceAccounts.Add(identity);
}
else
{
sourceSids.Add(identity);
}
}
}
}
bool someFailed = false;
IdentityReferenceCollection references4 = null;
IdentityReferenceCollection references5 = null;
if (capacity > 0)
{
references4 = SecurityIdentifier.Translate(sourceSids, targetType, out someFailed);
if (flag && (!forceSuccess || !someFailed))
{
unmappedIdentities = references4;
}
}
if (num2 > 0)
{
references5 = NTAccount.Translate(sourceAccounts, targetType, out someFailed);
if (flag && (!forceSuccess || !someFailed))
{
unmappedIdentities = references5;
}
}
if (forceSuccess && someFailed)
{
unmappedIdentities = new IdentityReferenceCollection();
if (references4 != null)
{
foreach (IdentityReference reference2 in references4)
{
if (reference2.GetType() != targetType)
{
unmappedIdentities.Add(reference2);
}
}
}
if (references5 != null)
{
foreach (IdentityReference reference3 in references5)
{
if (reference3.GetType() != targetType)
{
unmappedIdentities.Add(reference3);
}
}
}
throw new IdentityNotMappedException(Environment.GetResourceString("IdentityReference_IdentityNotMapped"), unmappedIdentities);
}
if (!flag)
{
capacity = 0;
num2 = 0;
unmappedIdentities = new IdentityReferenceCollection(this.Identities.Count);
for (int k = 0; k < this.Identities.Count; k++)
{
IdentityReference reference4 = this[k];
Type type3 = reference4.GetType();
if (type3 == targetType)
{
unmappedIdentities.Add(reference4);
}
else if (type3 == typeof(SecurityIdentifier))
{
unmappedIdentities.Add(references4[capacity++]);
}
else
{
if (type3 != typeof(NTAccount))
{
throw new SystemException();
}
unmappedIdentities.Add(references5[num2++]);
}
}
}
return(unmappedIdentities);
}
/// <summary>
/// Retrieve account information from uderlaying authentication system
/// </summary>
/// <param name="nativeId">The native id.</param>
/// <param name="accountName">Name of the account.</param>
/// <param name="accountDisplayName">Display name of the account.</param>
protected override void GetAccountInfo(string nativeId, out string accountName, out string accountDisplayName)
{
SecurityIdentifier sid = new SecurityIdentifier(nativeId);
IdentityReference idRef = sid.Translate(typeof(NTAccount));
accountDisplayName = accountName = idRef.Value;
}
private String ResolveAccountName(SecurityIdentifier SID)
{
try
{
return SID.Translate(typeof(NTAccount)).Value;
}
catch (Exception)
{
return SID.ToString();
}
}