private static DsNameResultItem[] CrackNames(
SafeDsHandle hDS,
DsNameFlags flags,
DsNameFormat formatOffered,
DsNameFormat formatDesired,
string[] names)
{
PscxArgumentException.ThrowIfIsNullOrEmpty(names);
IntPtr ptr = IntPtr.Zero;
try
{
NativeMethods.EnforceSuccess(NativeMethods.DsCrackNames(
hDS,
flags,
formatOffered,
formatDesired,
names.Length,
names,
out ptr));
DsNameResult result = Utils.PtrToStructure <DsNameResult>(ptr);
IEnumerable <DsNameResultItem> items =
Utils.ReadNativeArray <DsNameResultItem>(result.rItems, result.cItems);
return(new List <DsNameResultItem>(items).ToArray());
}
finally
{
NativeMethods.DsFreeNameResult(ptr);
}
}
public static extern uint DsCrackNames(
SafeDsHandle hSafeDs,
DS_NAME_FLAGS flags,
DS_NAME_FORMAT formatOffered,
DS_NAME_FORMAT formatDesired,
uint cNames,
[MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPTStr, SizeParamIndex = 4)] string[] rpNames,
out IntPtr ppResult);
// Creates a spn if the user hasn't specified one.
public static string Make()
{
uint ulSpn = 1;
var lpCompDN = new StringBuilder(128);
var ulCompDNSize = (uint)lpCompDN.Capacity;
var NoFailure = true;
SafeDsHandle hDS = SafeDsHandle.Null;
Win32Error status = DsGetSpn(DS_SPN_NAME_TYPE.DS_SPN_NB_HOST, "hello",
public void DsBindTest(bool validUser, bool validCred, string urn, string dn, string dcn, string domain, string un, string pwd, string notes)
{
SafeDsHandle dsb = null;
Assert.That(() => { using (dsb = new SafeDsHandle()) Assert.That(dsb.IsInvalid, Is.False); }, Throws.Nothing);
Assert.That(() => { using (dsb = new SafeDsHandle(dn, dcn)) Assert.That(dsb.IsInvalid, Is.EqualTo(!validUser)); }, validUser ? (IResolveConstraint) new ThrowsNothingConstraint() : new ThrowsExceptionConstraint());
Assert.That(() => { using (dsb = new SafeDsHandle(dn, null)) Assert.That(dsb.IsInvalid, Is.EqualTo(!validUser)); }, validUser ? (IResolveConstraint) new ThrowsNothingConstraint() : new ThrowsExceptionConstraint());
Assert.That(() => { using (dsb = new SafeDsHandle(null, dcn)) Assert.That(dsb.IsInvalid, Is.EqualTo(!validUser)); }, validUser ? (IResolveConstraint) new ThrowsNothingConstraint() : new ThrowsExceptionConstraint());
Assert.That(dsb?.IsInvalid ?? true);
}
public static DS_NAME_RESULT_ITEM[] DsCrackNames(SafeDsHandle hSafeDs, string[] names,
DS_NAME_FORMAT formatDesired = DS_NAME_FORMAT.DS_USER_PRINCIPAL_NAME,
DS_NAME_FORMAT formatOffered = DS_NAME_FORMAT.DS_UNKNOWN_NAME,
DS_NAME_FLAGS flags = DS_NAME_FLAGS.DS_NAME_NO_FLAGS)
{
var err = DsCrackNames(hSafeDs, flags, formatOffered, formatDesired, (uint)(names?.Length ?? 0), names, out SafeDsNameResult pResult);
new Win32Error((int)err).ThrowIfFailed();
return(pResult.Items);
}
public void DsCrackNamesTest(bool validUser, bool validCred, string urn, string dn, string dc, string domain, string un, string pwd, string notes)
{
using (var dsb = new SafeDsHandle())
{
var res = DsCrackNames(dsb, new[] { un }, DS_NAME_FORMAT.DS_NT4_ACCOUNT_NAME);
Assert.That(res, Has.Exactly(1).Items);
//Assert.That(res[0].ToString(), Is.EqualTo(o));
for (var i = 0; i < res.Length; i++)
{
TestContext.WriteLine($"{i}) {res[i]}");
}
}
}
public void DsBindWithCredTest(bool validUser, bool validCred, string urn, string dn, string dc, string domain, string un, string pwd, string notes)
{
void Meth()
{
SafeDsHandle dsb;
using (var cred = new SafeDsPasswordCredentialsHandle(un, dn, pwd))
using (dsb = new SafeDsHandle(cred, dn, dc))
Assert.That(dsb.IsInvalid, Is.False);
Assert.That(dsb.IsInvalid);
}
if (!validUser || !validCred)
{
Assert.That(Meth, Throws.Exception);
}
else
{
Assert.That(Meth, Throws.Nothing);
}
}
/// <summary>A wrapper function for the DsCrackNames OS call</summary>
/// <param name="hSafeDs">
/// Contains a directory service handle obtained from either the DSBind or DSBindWithCred function. If flags contains DS_NAME_FLAG_SYNTACTICAL_ONLY, hDS
/// can be NULL.
/// </param>
/// <param name="names">The names to be converted.</param>
/// <param name="flags">Contains one or m
/// ore of the DS_NAME_FLAGS values used to determine how the name syntax will be cracked.</param>
/// <param name="formatOffered">Contains one of the DS_NAME_FORMAT values that identifies the format of the input names.</param>
/// <param name="formatDesired">
/// Contains one of the DS_NAME_FORMAT values that identifies the format of the output names. The DS_SID_OR_SID_HISTORY_NAME value is not supported.
/// </param>
/// <returns>The crack results.</returns>
public static IEnumerable <DS_NAME_RESULT_ITEM> DsCrackNames(SafeDsHandle hSafeDs, string[] names = null,
DS_NAME_FLAGS flags = DS_NAME_FLAGS.DS_NAME_NO_FLAGS,
DS_NAME_FORMAT formatOffered = DS_NAME_FORMAT.DS_NT4_ACCOUNT_NAME,
DS_NAME_FORMAT formatDesired = DS_NAME_FORMAT.DS_USER_PRINCIPAL_NAME)
{
IntPtr pResult;
var err = DsCrackNames(hSafeDs, flags, formatOffered, formatDesired, (uint)(names?.Length ?? 0), names, out pResult);
if (err != NO_ERROR)
{
throw new Win32Exception((int)err);
}
try
{
return(pResult.ToStructure <DS_NAME_RESULT>().Items);
}
finally
{
DsFreeNameResult(pResult);
}
}
public string CanonicalToDistinguishedName(string cn)
{
using (SafeDsCredentialsHandle cred = MakeCredentials())
{
using (SafeDsHandle handle = Bind(cred))
{
DsNameResultItem[] items = CrackNames(
handle,
DsNameFlags.None,
DsNameFormat.CanonicalName,
DsNameFormat.DistinguishedName,
new string[] { cn });
foreach (DsNameResultItem item in items)
{
return(item.pName);
}
}
}
return(null);
}
private static int TryBind(string server, string domain, SafeDsCredentialsHandle credentials, out SafeDsHandle handle)
{
if (credentials != null)
{
return(NativeMethods.DsBindWithCred(server, domain, credentials, out handle));
}
return(NativeMethods.DsBind(server, domain, out handle));
}
