public void ToSecureStringTest(string sval)
        {
            var ms = new SafeCoTaskMemString(sval);
            var ss = ms.DangerousGetHandle().ToSecureString();

            if (sval != null)
            {
                Assert.That(ss, Is.Not.Null);
                Assert.That(ss.Length, Is.EqualTo(sval.Length));
                var s = ss.ToInsecureString();
                Assert.That(s, Is.EqualTo(sval));

                if (sval.Length > 1)
                {
                    ss = ms.DangerousGetHandle().ToSecureString(1);
                    Assert.That(ss, Is.Not.Null);
                    Assert.That(ss.Length, Is.EqualTo(1));
                    s = ss.ToInsecureString();
                    Assert.That(s, Is.EqualTo(sval.Substring(0, 1)));
                }
            }
            else
            {
                Assert.That(ss, Is.Null);
            }
        }
Exemple #2
0
        public void PathCchSkipRootTest()
        {
            var sb = new SafeCoTaskMemString(TestCaseSources.TempDirWhack, 64);

            Assert.That(PathCchSkipRoot((IntPtr)sb, out var end), Is.EqualTo((HRESULT)0));
            Assert.That(end, Is.EqualTo(sb.DangerousGetHandle().Offset(6)));
        }
Exemple #3
0
        public void PathCchFindExtensionTest()
        {
            var sb = new SafeCoTaskMemString(@"C:\Temp\dog.txt", 64);

            Assert.That(PathCchFindExtension((IntPtr)sb, sb.Capacity, out var ptr), Is.EqualTo((HRESULT)0));
            Assert.That(ptr, Is.EqualTo(sb.DangerousGetHandle().Offset(22)));
        }
Exemple #4
0
        public void PathCchAddBackslashExTest2()
        {
            var sb = new SafeCoTaskMemString(TestCaseSources.TempDirWhack, 64);

            Assert.That(PathCchAddBackslashEx((IntPtr)sb, sb.Capacity, out var end, out var rem), Is.EqualTo((HRESULT)HRESULT.S_FALSE));
            Assert.That(sb.ToString(), Is.EqualTo(TestCaseSources.TempDirWhack));
            Assert.That(end, Is.EqualTo(sb.DangerousGetHandle().Offset(sb.Length * 2)));

            sb = new SafeCoTaskMemString(TestCaseSources.TempDir, 64);
            Assert.That(PathCchAddBackslashEx((IntPtr)sb, sb.Size, out end, out rem), Is.EqualTo((HRESULT)0));
            Assert.That(sb.ToString(), Is.EqualTo(TestCaseSources.TempDirWhack));
            Assert.That(end, Is.EqualTo(sb.DangerousGetHandle().Offset(sb.Length * 2)));
        }
Exemple #5
0
        public void PathCchRemoveBackslashExTest()
        {
            var sb = new SafeCoTaskMemString(@"C:\Temp\", 64);

            Assert.That(PathCchRemoveBackslashEx((IntPtr)sb, sb.Capacity, out var end, out var rem), Is.EqualTo((HRESULT)0));
            Assert.That(sb.ToString(), Is.EqualTo(@"C:\Temp"));
            Assert.That(end, Is.EqualTo(sb.DangerousGetHandle().Offset(14)));

            sb = new SafeCoTaskMemString(@"C:\Temp", 64);
            Assert.That(PathCchRemoveBackslashEx((IntPtr)sb, sb.Capacity, out end, out rem), Is.EqualTo((HRESULT)HRESULT.S_FALSE));
            Assert.That(sb.ToString(), Is.EqualTo(@"C:\Temp"));
            Assert.That(end, Is.EqualTo(sb.DangerousGetHandle().Offset(14)));
        }
Exemple #6
0
        public void UnPack(bool decryptProtectedCredentials, out SecureString userName, out SecureString domainName, out SecureString password)
        {
            var pUserName      = new SafeCoTaskMemString(CRED_MAX_USERNAME_LENGTH);
            var pDomainName    = new SafeCoTaskMemString(CRED_MAX_USERNAME_LENGTH);
            var pPassword      = new SafeCoTaskMemString(CREDUI_MAX_PASSWORD_LENGTH);
            var userNameSize   = pUserName.CharCapacity;
            var domainNameSize = pDomainName.CharCapacity;
            var passwordSize   = pPassword.CharCapacity;

            if (!CredUnPackAuthenticationBuffer(decryptProtectedCredentials ? CredPackFlags.CRED_PACK_PROTECTED_CREDENTIALS : 0x0, buffer, bufferSize,
                                                (IntPtr)pUserName, ref userNameSize, (IntPtr)pDomainName, ref domainNameSize, (IntPtr)pPassword, ref passwordSize))
            {
                throw new Win32Exception();
            }

            userName   = pUserName.DangerousGetHandle().ToSecureString();
            domainName = pDomainName.DangerousGetHandle().ToSecureString();
            password   = pPassword.DangerousGetHandle().ToSecureString();
        }
        public void UnPack(bool decryptProtectedCredentials, out SecureString userName, out SecureString domainName, out SecureString password)
        {
            var pUserName      = new SafeCoTaskMemString(CredUI.CRED_MAX_USERNAME_LENGTH);
            var pDomainName    = new SafeCoTaskMemString(CredUI.CRED_MAX_USERNAME_LENGTH);
            var pPassword      = new SafeCoTaskMemString(CredUI.CREDUI_MAX_PASSWORD_LENGTH);
            int userNameSize   = pUserName.Size;
            int domainNameSize = pDomainName.Size;
            int passwordSize   = pPassword.Size;

            if (!CredUI.CredUnPackAuthenticationBuffer(decryptProtectedCredentials ? 0x1 : 0x0, buffer, bufferSize,
                                                       (IntPtr)pUserName, ref userNameSize, (IntPtr)pDomainName, ref domainNameSize, (IntPtr)pPassword, ref passwordSize))
            {
                throw new Win32Exception();
            }

            userName   = pUserName.DangerousGetHandle().ToSecureString();
            domainName = pDomainName.DangerousGetHandle().ToSecureString();
            password   = pPassword.DangerousGetHandle().ToSecureString();
        }
Exemple #8
0
        private static void PropVariant()
        {
            Ole32.PROPVARIANT pv;
            // SafeArray
            pv = new Ole32.PROPVARIANT(new object[] { 1, DateTime.Now, Guid.NewGuid() });
            AddTestResult(null, pv.ToString(), pv.parray);
            pv = new Ole32.PROPVARIANT(new object[] { 1, 2, 3 });
            AddTestResult(null, pv.ToString(), pv.parray);

            // Struct
            var ms = new SafeCoTaskMemString("TESTFMT");

            pv = new Ole32.PROPVARIANT(new[] { new Ole32.CLIPDATA(ms.DangerousGetHandle(), ms.Length), new Ole32.CLIPDATA(0xCFF) });
            AddTestResult(null, pv.ToString(), pv.caclipdata.ToArray()[0].ulClipFmt);

            // Dates
            pv = new Ole32.PROPVARIANT((DateTime?)null);
            AddTestResult(null, pv.ToString(), pv.pdate);
            pv = new Ole32.PROPVARIANT(DateTime.Now.AddYears(-500));
            AddTestResult(null, pv.ToString(), pv.Value);
            pv = new Ole32.PROPVARIANT(DateTime.Now);
            AddTestResult(null, pv.ToString(), new[] { pv.Value, pv.date, pv.pdate });
            pv = new Ole32.PROPVARIANT(DateTime.Now, VarEnum.VT_FILETIME);
            AddTestResult(null, pv.ToString(), pv.filetime.ToString(null));
            pv = new Ole32.PROPVARIANT(new[] { DateTime.Now, DateTime.Today, DateTime.MaxValue });
            AddTestResult(null, pv.ToString(), pv.cadate);

            // FILETIME
            var ft = DateTime.Now.ToFileTimeStruct();

            pv = new Ole32.PROPVARIANT(ft);
            AddTestResult(null, pv.ToString(), pv.filetime.ToString(null));
            pv = new Ole32.PROPVARIANT(new[] { ft, ft });
            AddTestResult(null, pv.ToString(), pv.cafiletime?.Select(f => f.ToString("G")));
            pv = new Ole32.PROPVARIANT(new[] { DateTime.Now, DateTime.Today, DateTime.MaxValue }, VarEnum.VT_FILETIME);
            AddTestResult(null, pv.ToString(), pv.cafiletime?.Select(f => f.ToString("G")));

            // Bool
            pv = new Ole32.PROPVARIANT(true);
            AddTestResult(null, pv.ToString(), new[] { pv.pboolVal, pv.boolVal });
            pv = new Ole32.PROPVARIANT(new[] { true, false, true, false });
            AddTestResult(null, pv.ToString(), pv.cabool);
            PropSys.InitPropVariantFromBooleanVector(new[] { true, false, true, false }, 4, pv);
            AddTestResult(null, pv.ToString(), pv.cabool);
            AddTestResult(null, pv.ToString(), pv.cai);

            // Int
            pv = new Ole32.PROPVARIANT((int?)null);
            AddTestResult(null, pv.ToString(), pv.plVal);
            pv = new Ole32.PROPVARIANT(3);
            AddTestResult(null, pv.ToString(), new[] { pv.Value, pv.bVal, pv.cVal, pv.iVal, pv.uiVal, pv.intVal, pv.lVal, pv.uintVal, pv.ulVal, pv.hVal, pv.uhVal, pv.scode });
            pv = new Ole32.PROPVARIANT(new Win32Error(5));
            AddTestResult(null, pv.ToString(), $"{pv.lVal}/{(int)pv.scode}");
            pv = new Ole32.PROPVARIANT(new[] { 0, 1, 2 });
            AddTestResult(null, pv.ToString(), pv.cal);

            // Decimal
            pv = new Ole32.PROPVARIANT(3.3m);
            AddTestResult(null, pv.ToString(), new[] { pv.Value, pv.pdecVal, pv.bVal, pv.cVal, pv.iVal, pv.uiVal, pv.intVal, pv.lVal, pv.uintVal, pv.ulVal, pv.hVal, pv.uhVal, pv.fltVal, pv.dblVal });
            pv = new Ole32.PROPVARIANT(3.3m, VarEnum.VT_CY);
            AddTestResult(null, pv.ToString(), new[] { pv.Value, pv.pdecVal, pv.cyVal, pv.pcyVal });
            pv = new Ole32.PROPVARIANT(new[] { 0m, 1m, 2m }, VarEnum.VT_CY);
            AddTestResult(null, pv.ToString(), pv.cacy);

            // Single/double precision
            pv = new Ole32.PROPVARIANT(3.3f);
            AddTestResult(null, pv.ToString(), new[] { pv.Value, pv.fltVal, pv.dblVal, pv.pdecVal, pv.bVal, pv.cVal, pv.iVal, pv.uiVal, pv.intVal, pv.lVal, pv.uintVal, pv.ulVal, pv.hVal, pv.uhVal });
            pv = new Ole32.PROPVARIANT(3.3);
            AddTestResult(null, pv.ToString(), new[] { pv.Value, pv.fltVal, pv.dblVal });
            pv = new Ole32.PROPVARIANT(new[] { 0.0f, 1.1f, 2.2f });
            AddTestResult(null, pv.ToString(), pv.caflt);
            pv = new Ole32.PROPVARIANT(new[] { 0.0, 1.1, 2.2 });
            AddTestResult(null, pv.ToString(), pv.cadbl);

            // Byte
            pv = new Ole32.PROPVARIANT((byte)3);
            AddTestResult(null, pv.ToString(), pv.bVal);
            pv = new Ole32.PROPVARIANT(new byte[] { 0, 1, 2 });
            AddTestResult(null, pv.ToString(), pv.caub);

            // Guid
            pv = new Ole32.PROPVARIANT(Guid.NewGuid());
            AddTestResult(null, pv.ToString(), pv.puuid);
            pv = new Ole32.PROPVARIANT(new[] { Guid.NewGuid(), Guid.NewGuid() });
            AddTestResult(null, pv.ToString(), pv.cauuid);

            // String
            pv = new Ole32.PROPVARIANT("TestNoVTVal");
            AddTestResult(null, pv.ToString(), new[] { pv.Value, pv.pszVal, pv.pwszVal, pv.bstrVal, pv.pbstrVal });
            pv = new Ole32.PROPVARIANT("TestBSTR", VarEnum.VT_BSTR);
            AddTestResult(null, pv.ToString(), new[] { pv.Value, pv.pszVal, pv.pwszVal, pv.bstrVal, pv.pbstrVal });
            pv = new Ole32.PROPVARIANT("TestLPSTR", VarEnum.VT_LPSTR);
            AddTestResult(null, pv.ToString(), new[] { pv.Value, pv.pszVal, pv.pwszVal, pv.bstrVal, pv.pbstrVal });
            pv = new Ole32.PROPVARIANT("TestLPWSTR", VarEnum.VT_LPWSTR);
            AddTestResult(null, pv.ToString(), new[] { pv.Value, pv.pszVal, pv.pwszVal, pv.bstrVal, pv.pbstrVal });
            pv = new Ole32.PROPVARIANT(new[] { "TestStrVec", "X" });
            AddTestResult(null, pv.ToString(), pv.calpwstr);
            pv = new Ole32.PROPVARIANT(new[] { 1, 2, 3 }, VarEnum.VT_LPWSTR);
            AddTestResult(null, pv.ToString(), pv.calpwstr);
            PropSys.InitPropVariantFromStringVector(new[] { "TestStrVec", "X" }, 2, pv);
            AddTestResult(null, pv.ToString(), pv.calpwstr);
        }
Exemple #9
0
        /// <summary>Shows the dialog box to let the user browse for and select a folder.</summary>
        /// <param name="parentWindowHandle">The HWND of the parent window.</param>
        /// <returns>The selected folder or <c>null</c> if no folder was selected by the user.</returns>
        protected override bool RunDialog(IntPtr parentWindowHandle)
        {
            // Setup BROWSEINFO.dwFlag value
            EnumFlagIndexer <BrowseInfoFlag> browseInfoFlag = BrowseInfoFlag.BIF_SHAREABLE;

            browseInfoFlag[BrowseInfoFlag.BIF_NEWDIALOGSTYLE]      = Application.OleRequired() == ApartmentState.STA;
            browseInfoFlag[BrowseInfoFlag.BIF_DONTGOBELOWDOMAIN]   = HideDomainFolders;
            browseInfoFlag[BrowseInfoFlag.BIF_BROWSEFILEJUNCTIONS] = ShowFileJunctions;
            browseInfoFlag[BrowseInfoFlag.BIF_RETURNONLYFSDIRS]    = LocalFileSystemOnly;
            browseInfoFlag[BrowseInfoFlag.BIF_NONEWFOLDERBUTTON]   = !ShowNewFolderButton;
            browseInfoFlag[BrowseInfoFlag.BIF_EDITBOX | BrowseInfoFlag.BIF_VALIDATE] = ShowFolderPathEditBox;
            switch (BrowseOption)
            {
            case FolderBrowserDialogOptions.Folders:
                break;

            case FolderBrowserDialogOptions.FoldersAndFiles:
                browseInfoFlag |= BrowseInfoFlag.BIF_BROWSEINCLUDEFILES;
                break;

            case FolderBrowserDialogOptions.Computers:
                browseInfoFlag |= BrowseInfoFlag.BIF_BROWSEFORCOMPUTER;
                RootFolder      = defaultComputersFolder;
                break;

            case FolderBrowserDialogOptions.Printers:
                browseInfoFlag |= BrowseInfoFlag.BIF_BROWSEFORPRINTER;
                RootFolder      = defaultPrintersFolder;
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            // Setup the BROWSEINFO structure
            var dn = new SafeCoTaskMemString(Kernel32.MAX_PATH);
            var bi = new BROWSEINFO(parentWindowHandle, rootPidl.DangerousGetHandle(), Description, browseInfoFlag, OnBrowseEvent, dn.DangerousGetHandle());

            // Show the dialog
            pidl = SHBrowseForFolder(ref bi);
            href = default(HandleRef);
            if (pidl.IsInvalid)
            {
                return(false);
            }
            if (browseInfoFlag[BrowseInfoFlag.BIF_BROWSEFORPRINTER] || browseInfoFlag[BrowseInfoFlag.BIF_BROWSEFORCOMPUTER])
            {
                SelectedItem = bi.DisplayName;
            }
            else
            {
                SelectedItem = GetNameForPidl(pidl);
            }
            return(true);
        }