352 lines
9.7 KiB
C++
352 lines
9.7 KiB
C++
/*
|
|
** p r o t s t o r . c p p
|
|
**
|
|
** Purpose:
|
|
** Functions to provide blob-level access to the pstore
|
|
**
|
|
** Note:
|
|
** LocalAlloc/Free are used for memory allocation
|
|
**
|
|
** History
|
|
** 2/12/97: (t-erikne) created
|
|
**
|
|
** Copyright (C) Microsoft Corp. 1997.
|
|
*/
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Depends on
|
|
//
|
|
|
|
#include "pch.hxx"
|
|
#include <pstore.h>
|
|
#include "wstrings.h"
|
|
#include <error.h>
|
|
#ifdef MAC
|
|
#include <mapinls.h>
|
|
#endif // !MAC
|
|
#include <BadStrFunctions.h>
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Static Things
|
|
//
|
|
|
|
static void _PST_GenerateTagName(LPWSTR pwsz, DWORD cch, DWORD offset);
|
|
|
|
#ifdef DEBUG
|
|
|
|
#define test3sub_string L"Test 3 SUBType"
|
|
// {220D5CC2-853A-11d0-84BC-00C04FD43F8F}
|
|
static GUID test3sub =
|
|
{ 0x220d5cc2, 0x853a, 0x11d0, { 0x84, 0xbc, 0x0, 0xc0, 0x4f, 0xd4, 0x3f, 0x8f } };
|
|
|
|
// {4E741310-850D-11d0-84BB-00C04FD43F8F}
|
|
static GUID NOT_EXIST =
|
|
{ 0x4e741310, 0x850d, 0x11d0, { 0x84, 0xbb, 0x0, 0xc0, 0x4f, 0xd4, 0x3f, 0x8f } };
|
|
|
|
// {FFAC62F0-8533-11d0-84BC-00C04FD43F8F}
|
|
#define NoRuleSubType_string L"Foobar bang with no rules"
|
|
static GUID NoRuleSubType =
|
|
{ 0xffac62f0, 0x8533, 0x11d0, { 0x84, 0xbc, 0x0, 0xc0, 0x4f, 0xd4, 0x3f, 0x8f } };
|
|
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Functions
|
|
//
|
|
|
|
OESTDAPI_(HRESULT) PSTSetNewData(
|
|
IN IPStore *const pISecProv,
|
|
IN const GUID *const guidType,
|
|
IN const GUID *const guidSubt,
|
|
IN LPCWSTR wszAccountName,
|
|
IN const BLOB *const pclear,
|
|
OUT BLOB *const phandle)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
const int cchLookup = 80;
|
|
WCHAR wszLookup[cchLookup];
|
|
PST_PROMPTINFO PromptInfo = { sizeof(PST_PROMPTINFO), 0, NULL, L""};
|
|
DWORD count = 0;
|
|
BYTE *pb = NULL;
|
|
|
|
if (!(pISecProv &&
|
|
guidType && guidSubt &&
|
|
wszAccountName &&
|
|
pclear && pclear->pBlobData && pclear->cbSize))
|
|
return E_INVALIDARG;
|
|
|
|
if (phandle)
|
|
phandle->pBlobData = NULL;
|
|
|
|
StrCpyNW(wszLookup, wszAccountName, cchLookup);
|
|
|
|
do
|
|
{
|
|
// if they didn't give us an out param for the lookup, then it is
|
|
// dumb to make one. Just try the AccountName
|
|
if (phandle)
|
|
_PST_GenerateTagName(wszLookup, cchLookup, count++);
|
|
|
|
hr = pISecProv->WriteItem(
|
|
PST_KEY_CURRENT_USER,
|
|
guidType,
|
|
guidSubt,
|
|
wszLookup,
|
|
pclear->cbSize,
|
|
pclear->pBlobData,
|
|
&PromptInfo,
|
|
PST_CF_NONE,
|
|
PST_NO_OVERWRITE);
|
|
|
|
if (!phandle)
|
|
{
|
|
// if we didn't get an out param, we are done regardless
|
|
break;
|
|
}
|
|
}
|
|
while (PST_E_ITEM_EXISTS == hr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// we created it
|
|
|
|
if (phandle)
|
|
{
|
|
phandle->cbSize = (lstrlenW(wszLookup) + 1) * sizeof(WCHAR);
|
|
|
|
//NOTE: LocalAlloc is our memory allocator
|
|
phandle->pBlobData = (BYTE *)LocalAlloc(LMEM_ZEROINIT, phandle->cbSize);
|
|
if (!phandle->pBlobData)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exit;
|
|
}
|
|
StrCpyNW((LPWSTR)phandle->pBlobData, wszLookup, (phandle->cbSize / sizeof(wszLookup[0])));
|
|
}
|
|
}
|
|
|
|
exit:
|
|
return hr;
|
|
}
|
|
|
|
OESTDAPI_(HRESULT) PSTGetData(
|
|
IN IPStore *const pISecProv,
|
|
IN const GUID *const guidType,
|
|
IN const GUID *const guidSubt,
|
|
IN LPCWSTR wszLookupName,
|
|
OUT BLOB *const pclear)
|
|
{
|
|
HRESULT hr;
|
|
PST_PROMPTINFO PromptInfo = { sizeof(PST_PROMPTINFO), 0, NULL, L""};
|
|
|
|
pclear->pBlobData = NULL;
|
|
pclear->cbSize = 0;
|
|
|
|
if (!(pISecProv && wszLookupName && pclear))
|
|
return E_INVALIDARG;
|
|
|
|
if (SUCCEEDED(hr = pISecProv->OpenItem(
|
|
PST_KEY_CURRENT_USER,
|
|
guidType,
|
|
guidSubt,
|
|
wszLookupName,
|
|
PST_READ,
|
|
&PromptInfo,
|
|
0)))
|
|
{
|
|
hr = pISecProv->ReadItem(
|
|
PST_KEY_CURRENT_USER,
|
|
guidType,
|
|
guidSubt,
|
|
wszLookupName,
|
|
&pclear->cbSize,
|
|
&pclear->pBlobData, // ppbData
|
|
&PromptInfo, // pPromptInfo
|
|
0); // dwFlags
|
|
|
|
// don't care if this fails
|
|
pISecProv->CloseItem(
|
|
PST_KEY_CURRENT_USER,
|
|
guidType,
|
|
guidSubt,
|
|
wszLookupName,
|
|
0);
|
|
}
|
|
|
|
if (FAILED(TrapError(hr)))
|
|
hr = hrPasswordNotFound;
|
|
return hr;
|
|
}
|
|
|
|
OESTDAPI_(LPWSTR) WszGenerateNameFromBlob(IN BLOB blob)
|
|
{
|
|
LPWSTR szW = NULL;
|
|
TCHAR szT[100];
|
|
DWORD *pdw;
|
|
TCHAR *pt;
|
|
int i, max;
|
|
DWORD cch;
|
|
|
|
if (blob.cbSize > ARRAYSIZE(szT) ||
|
|
blob.cbSize % sizeof(DWORD))
|
|
return NULL;
|
|
|
|
cch = (blob.cbSize*2)+1;
|
|
szW = (LPWSTR)LocalAlloc(LMEM_ZEROINIT, cch*sizeof(WCHAR));
|
|
if (!szW)
|
|
return NULL;
|
|
|
|
pt = szT;
|
|
szT[0] = '\000';
|
|
pdw = (DWORD *)blob.pBlobData;
|
|
|
|
max = blob.cbSize / sizeof(DWORD);
|
|
for (i = 0; i < max; i++, pdw++)
|
|
{
|
|
DWORD cchLeft = (ARRAYSIZE(szT) - (DWORD)(pt - szT) - 1); // Good old typing will convert the pointer math to # of chars instead of # of bytes.
|
|
if (cchLeft)
|
|
{
|
|
pt += wnsprintf(pt, cchLeft, "%X", *pdw);
|
|
}
|
|
}
|
|
*pt = '\000';
|
|
|
|
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szT, cch, szW, cch);
|
|
szW[cch-1] = 0;
|
|
|
|
return szW;
|
|
}
|
|
|
|
OESTDAPI_(void) PSTFreeHandle(LPBYTE pb)
|
|
{
|
|
if (pb)
|
|
LocalFree((HLOCAL)pb);
|
|
}
|
|
|
|
OESTDAPI_(HRESULT) PSTCreateTypeSubType_NoUI(
|
|
IN IPStore *const pISecProv,
|
|
IN const GUID *const guidType,
|
|
IN LPCWSTR szType,
|
|
IN const GUID *const guidSubt,
|
|
IN LPCWSTR szSubt)
|
|
{
|
|
#ifdef ENABLE_RULES
|
|
PST_ACCESSRULESET RuleSet;
|
|
PST_ACCESSRULE rgRules[2];
|
|
#endif
|
|
PST_TYPEINFO Info;
|
|
HRESULT hr;
|
|
|
|
if (!pISecProv)
|
|
return E_INVALIDARG;
|
|
|
|
Info.cbSize = sizeof(PST_TYPEINFO);
|
|
|
|
// if type is not available the create it
|
|
Info.szDisplayName = (LPWSTR)szType;
|
|
if (S_OK != (hr = pISecProv->CreateType(PST_KEY_CURRENT_USER,
|
|
guidType,
|
|
&Info,
|
|
0)))
|
|
{
|
|
if (PST_E_TYPE_EXISTS != hr)
|
|
goto exit;
|
|
}
|
|
|
|
// make rules for read, write access
|
|
#ifdef ATH_RELEASE_BUILD
|
|
#error Need to enable access rules for protected store passwords? (t-erikne)
|
|
#endif
|
|
|
|
#ifdef ENABLE_RULES
|
|
// Do Rule Stuff
|
|
|
|
RuleSet.cbSize = sizeof(PST_ACCESSRULESET);
|
|
RuleSet.cRules = 2;
|
|
RuleSet.rgRules = rgRules;
|
|
|
|
//PST_BINARYCHECKDATA bindata;
|
|
PST_ACCESSCLAUSE rgClauses[1];
|
|
//N need to or on on the authenticode stuff
|
|
// derive the calling exe (me) and only allow access to me
|
|
rgClauses[0].ClaTYPE_GUID = PST_CURRENT_EXE;
|
|
rgClauses[0].cbClauseData = 0;
|
|
rgClauses[0].pbClauseData = NULL;
|
|
rgRules[0].AccessModeFlags = PST_READ; // READ: just exe
|
|
rgRules[0].cClauses = 1;
|
|
rgRules[0].rgClauses = rgClauses;
|
|
rgRules[1].AccessModeFlags = PST_WRITE; // WRITE: just exe
|
|
rgRules[1].cClauses = 1;
|
|
rgRules[1].rgClauses = rgClauses;
|
|
#endif
|
|
|
|
// create the server password subtype
|
|
Info.szDisplayName = (LPWSTR)szSubt;
|
|
if (S_OK !=
|
|
(hr = pISecProv->CreateSubtype(
|
|
PST_KEY_CURRENT_USER,
|
|
guidType,
|
|
guidSubt,
|
|
&Info,
|
|
#ifdef ENABLE_RULES
|
|
&Rules,
|
|
#else
|
|
NULL,
|
|
#endif
|
|
0)))
|
|
{
|
|
if (PST_E_TYPE_EXISTS != hr)
|
|
goto exit;
|
|
}
|
|
|
|
hr = S_OK; // cool if we made it here
|
|
exit:
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Static utility functions
|
|
//
|
|
|
|
void _PST_GenerateTagName(LPWSTR pwsz, DWORD cch, DWORD offset)
|
|
{
|
|
SYSTEMTIME stNow;
|
|
FILETIME ftNow;
|
|
const int cchArrLen = 32;
|
|
WCHAR wszTime[cchArrLen];
|
|
TCHAR szT[cchArrLen];
|
|
UINT ich=0;
|
|
UINT cchLen=lstrlenW(pwsz);
|
|
|
|
GetLocalTime(&stNow);
|
|
ZeroMemory(&ftNow, sizeof(ftNow));
|
|
SystemTimeToFileTime(&stNow, &ftNow);
|
|
|
|
// Raid 48394 - 2 backslashes in account friendly name causes the account to not be fully created
|
|
while (ich < cchLen)
|
|
{
|
|
if (L'\\' == pwsz[ich])
|
|
{
|
|
MoveMemory((LPBYTE)pwsz + (sizeof(WCHAR) * ich), (LPBYTE)pwsz + ((ich + 1) * sizeof(WCHAR)), (cchLen - ich) * sizeof(WCHAR));
|
|
cchLen--;
|
|
}
|
|
else
|
|
ich++;
|
|
}
|
|
|
|
wnsprintf(szT, ARRAYSIZE(szT), TEXT("%08.8lX"), ftNow.dwLowDateTime+offset);
|
|
if (MultiByteToWideChar(CP_ACP, 0, szT, -1, wszTime, cchArrLen))
|
|
{
|
|
const int cchTime = lstrlenW(wszTime);
|
|
if (long(cch) > lstrlenW(pwsz)+cchTime)
|
|
StrCatBuffW(pwsz, wszTime, cch);
|
|
else
|
|
StrCpyNW(&pwsz[cch-cchTime-1], wszTime, (cchTime + 1));
|
|
}
|
|
return;
|
|
}
|