public void ResizeTest()
{
var h = new SafeLocalHandle(5);
Assert.That(!h.IsClosed && !h.IsInvalid && h.Size == 5);
var ptr = (IntPtr)h;
h.Size = 50;
Assert.That(!h.IsClosed && !h.IsInvalid && (IntPtr)h != ptr);
Assert.That((int)h.Size, Is.EqualTo(50));
}
public void SafeLocalHandleTest4()
{
var h = new SafeLocalHandle("0123456789");
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That((int)h.Size, Is.EqualTo(11 * Marshal.SystemDefaultCharSize));
h.Dispose();
Assert.That(h.IsClosed && h.IsInvalid);
Assert.That(SafeLocalHandle.Null.IsInvalid);
}
public void SafeLocalHandleTest()
{
var h = new SafeLocalHandle(5);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That(h.Size, Is.EqualTo(5));
h.Dispose();
Assert.That(h.IsClosed && h.IsInvalid);
h = new SafeLocalHandle(LocalAlloc(LMEM.LPTR, 5), 5);
Assert.That(!h.IsClosed && !h.IsInvalid);
Assert.That(h, Is.Not.EqualTo(SafeHGlobalHandle.Null));
h.Dispose();
Assert.That(h.IsClosed && h.IsInvalid);
Assert.That(() => new SafeLocalHandle(-1), Throws.TypeOf <ArgumentOutOfRangeException>());
}
/*****************************************************************************
* HrLoadFile
*
* Load file into allocated (*ppbData).
* The caller must free the memory by LocalFree().
*****************************************************************************/
static HRESULT HrLoadFile(string wszFileName, out SafeLocalHandle ppbData)
{
HRESULT hr = HRESULT.S_OK;
ppbData = default;
using var hFile = CreateFile(wszFileName, Kernel32.FileAccess.GENERIC_READ, 0, default, FileMode.Open, 0);
if (hFile.IsInvalid)
{
hr = (HRESULT)Win32Error.GetLastError();
goto CleanUp;
}
var pcbData = GetFileSize(hFile, out _);
if (pcbData == 0)
{
hr = HRESULT.S_FALSE;
goto CleanUp;
}
ppbData = new SafeLocalHandle(pcbData);
if (!ReadFile(hFile, ppbData, pcbData, out var cbRead))
{
hr = (HRESULT)Win32Error.GetLastError();
goto CleanUp;
}
CleanUp:
if (hr.Failed)
{
ppbData = default;
pcbData = 0;
}
return(hr);
}
/*****************************************************************************
* wmain
*
*****************************************************************************/
static int Main(string[] args)
{
HRESULT hr = HRESULT.S_OK;
SafeHCERTSTORE hStoreHandle = default;
string wszStoreName = "MY"; // by default, MY
string wszContainerName = "SAMPLE";
uint dwBits = 0;
string wszKeyAlgName = "RSA"; //
string[] rgwszCNGAlgs = new string[] { "SHA1", "RSA" };
SafeNCRYPT_KEY_HANDLE hCNGKey = default;
SafePCCERT_CONTEXT pCertContext = default;
CRYPTOAPI_BLOB SubjectName = default;
int i;
//
// options
//
for (i = 0; i < args.Length; i++)
{
if (string.Compare(args[i], "/?") == 0 || string.Compare(args[i], "-?") == 0)
{
Usage("CreateCert.exe");
goto CleanUp;
}
if (args[i][0] != '-')
{
break;
}
if (string.Compare(args[i], "-s") == 0)
{
if (i + 1 >= args.Length)
{
hr = HRESULT.E_INVALIDARG;
goto CleanUp;
}
wszStoreName = args[++i];
}
else
if (string.Compare(args[i], "-c") == 0)
{
if (i + 1 >= args.Length)
{
hr = HRESULT.E_INVALIDARG;
goto CleanUp;
}
wszContainerName = args[++i];
}
else
if (string.Compare(args[i], "-k") == 0)
{
if (i + 1 >= args.Length)
{
hr = HRESULT.E_INVALIDARG;
goto CleanUp;
}
wszKeyAlgName = args[++i];
}
else
if (string.Compare(args[i], "-h") == 0)
{
if (i + 1 >= args.Length)
{
hr = HRESULT.E_INVALIDARG;
goto CleanUp;
}
rgwszCNGAlgs[0] = args[++i];
}
else
if (string.Compare(args[i], "-l") == 0)
{
if (i + 1 >= args.Length)
{
hr = HRESULT.E_INVALIDARG;
goto CleanUp;
}
dwBits = uint.Parse(args[++i]);
}
}
if (i >= args.Length)
{
hr = HRESULT.E_INVALIDARG;
goto CleanUp;
}
var wszSubject = args[i];
//
// Find the Signature algorithm
//
var pOidInfo = CryptFindOIDInfo(CryptOIDInfoFlags.CRYPT_OID_INFO_NAME_KEY, wszKeyAlgName, OIDGroupId.CRYPT_PUBKEY_ALG_OID_GROUP_ID);
if (default == pOidInfo)
{
Console.Write("FAILED: Unable to find Public Key algorithm: '{0}'.\n", wszKeyAlgName);
hr = HRESULT.CRYPT_E_UNKNOWN_ALGO;
goto CleanUp;
}
var oidInfo = (CRYPT_OID_INFO)pOidInfo;
if (!string.IsNullOrEmpty(oidInfo.pwszCNGExtraAlgid))
{
rgwszCNGAlgs[1] = oidInfo.pwszCNGExtraAlgid;
}
else
{
rgwszCNGAlgs[1] = oidInfo.pwszCNGAlgid;
}
using (var pAlgs = SafeLocalHandle.CreateFromStringList(rgwszCNGAlgs, StringListPackMethod.Packed, CharSet.Unicode))
pOidInfo = CryptFindOIDInfo(CryptOIDInfoFlags.CRYPT_OID_INFO_CNG_SIGN_KEY, pAlgs, OIDGroupId.CRYPT_SIGN_ALG_OID_GROUP_ID);
if (default == pOidInfo)
{
Console.Write("FAILED: Unable to find signature algorithm: '{0}:{1}'\n", rgwszCNGAlgs[0], rgwszCNGAlgs[1]);
hr = HRESULT.CRYPT_E_UNKNOWN_ALGO;
goto CleanUp;
}
var SignatureAlgorithm = new CRYPT_ALGORITHM_IDENTIFIER {
pszObjId = ((CRYPT_OID_INFO)pOidInfo).pszOID
};
//-------------------------------------------------------------------
// Open a system store, in this case, the My store.
hStoreHandle = CertOpenStore(CertStoreProvider.CERT_STORE_PROV_SYSTEM, 0, default, CertStoreFlags.CERT_SYSTEM_STORE_CURRENT_USER, wszStoreName);
public static extern bool ConvertSecurityDescriptorToStringSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor, SDDL_REVISION RequestedStringSDRevision,
SECURITY_INFORMATION SecurityInformation, out SafeLocalHandle StringSecurityDescriptor, out uint StringSecurityDescriptorLen);
public static extern bool ConvertStringSidToSid(string pStringSid, out SafeLocalHandle sid);
public static extern bool ConvertStringSecurityDescriptorToSecurityDescriptor(string StringSecurityDescriptor, SDDL_REVISION StringSDRevision, out SafeLocalHandle SecurityDescriptor, out uint SecurityDescriptorSize);
public static extern bool ConvertSidToStringSid(PSID Sid, out SafeLocalHandle StringSid);
public static extern Win32Error GetLocalManagedApplications([MarshalAs(UnmanagedType.Bool)] bool bUserApps, out uint pdwApps, out SafeLocalHandle prgLocalApps);
public static extern Win32Error GetManagedApplications(IntPtr pCategory, uint dwQueryFlags, uint dwInfoLevel, out uint pdwApps, out SafeLocalHandle prgManagedApps);
public static extern Win32Error PowerGetActiveScheme([Optional] HKEY UserRootPowerKey, out SafeLocalHandle ActivePolicyGuid);
//----------------------------------------------------------------------------------------------------------------
//
// Function: HrCreateCNGHash()
//
// The caller must call LocalFree to release (*ppbHash)
//------------------------------------------------------------------------------------------------------------------
static HRESULT HrCreateCNGHash(string wszHashAlgName, IntPtr pbData, uint cbData, out SafeLocalHandle ppbHash)
{
//initialize [Out]"), parameters
ppbHash = default;
//get a handle to a cryptographic provider
var hr = BCryptOpenAlgorithmProvider(out var hAlgorithm, wszHashAlgName, default, 0);
