1531 lines
52 KiB
C++
1531 lines
52 KiB
C++
|
|
#include <wininetp.h>
|
|
|
|
#include "cookiepolicy.h"
|
|
#include "urlmon.h"
|
|
|
|
#ifndef ARRAYSIZE
|
|
#define ARRAYSIZE(x) ((sizeof(x)/sizeof(x[0])))
|
|
#endif
|
|
|
|
extern IInternetSecurityManager* g_pSecMgr;
|
|
extern "C" DWORD GetZoneFromUrl(LPCSTR pszUrl);
|
|
|
|
GUID guidCookieSettings = {0xaeba21fa, 0x782a, 0x4a90, 0x97, 0x8d,
|
|
0xb7, 0x21, 0x64, 0xc8, 0x01, 0x20};
|
|
|
|
GUID guid3rdPartySettings = {0xa8a88c49, 0x5eb2, 0x4990,
|
|
0xa1, 0xa2, 0x08, 0x76, 0x02, 0x2c, 0x85, 0x4f};
|
|
|
|
const wchar_t *SettingTemplate[];
|
|
|
|
/* static member definition */
|
|
CP3PSettingsCache CCookieSettings::cookiePrefsCache;
|
|
|
|
/* settings signature strings */
|
|
const char gszP3PV1Signature[] = "IE6-P3PV1/settings:";
|
|
const wchar_t gszUnicodeSignature[] = L"IE6-P3PV1/settings:";
|
|
|
|
BOOL IsNoCookies(DWORD dwZone);
|
|
void SetNoCookies(DWORD dwZone, DWORD dwNewPolicy);
|
|
|
|
struct P3PSymbol {
|
|
|
|
const char *pszAcronym;
|
|
unsigned long dwSymIndex;
|
|
unsigned long dwHashCode;
|
|
};
|
|
|
|
/* Macro for determining precedence of cookie actions.
|
|
In IE6 the COOKIE_STATE_* enumeration is arranged such that higher values
|
|
take precedence. For example, downgrade overrides prompt.
|
|
If one rule evaluates to "downgrade" while others evaluate to "prompt",
|
|
the final decision is "downgrade". */
|
|
#define precedence(d) (d)
|
|
|
|
|
|
/* special symbols used for defining settings */
|
|
const char
|
|
SymNoPolicy[] = "###", /* No-policy */
|
|
SymMissingCP[] = "nopolicy", /* Same as "no-policy" */
|
|
SymConstDecision[] = "%%%", /* Constant settings */
|
|
SymApplyAll[] = "always", /* Same as constant settings */
|
|
SymSession[] = "session"; /* exclude P3P from session-cookies */
|
|
|
|
const char *acronymSet[] = {
|
|
|
|
/* purposes */
|
|
"CURa", "CURi", "CURo",
|
|
"ADMa", "ADMi", "ADMo",
|
|
"DEVa", "DEVi", "DEVo",
|
|
"CUSa", "CUSi", "CUSo",
|
|
"TAIa", "TAIi", "TAIo",
|
|
"PSAa", "PSAi", "PSAo",
|
|
"PSDa", "PSDi", "PSDo",
|
|
"IVAa", "IVAi", "IVAo",
|
|
"IVDa", "IVDi", "IVDo",
|
|
"CONa", "CONi", "CONo",
|
|
"HISa", "HISi", "HISo",
|
|
"TELa", "TELi", "TELo",
|
|
"OTPa", "OTPi", "OTPo",
|
|
|
|
/* recipients */
|
|
"OURa", "OURi", "OURo",
|
|
"DELa", "DELi", "DELo",
|
|
"SAMa", "SAMi", "SAMo",
|
|
"OTRa", "OTRi", "OTRo",
|
|
"UNRa", "UNRi", "UNRo",
|
|
"PUBa", "PUBi", "PUBo",
|
|
|
|
/* retention */
|
|
"NOR", "STP", "LEG", "BUS", "IND",
|
|
|
|
/* categories */
|
|
"PHY", "ONL", "UNI", "PUR", "FIN", "COM", "NAV", "INT",
|
|
"DEM", "CNT", "STA", "POL", "HEA", "PRE", "GOV", "OTC",
|
|
|
|
/* non-identifiable */
|
|
"NID",
|
|
|
|
/* disputes section */
|
|
"DSP",
|
|
|
|
/* access */
|
|
"NOI", "ALL", "CAO", "IDC", "OTI", "NON",
|
|
|
|
/* dispute resolution */
|
|
"COR", "MON", "LAW",
|
|
|
|
/* TST: token for indicating that a policy is test-version */
|
|
"TST",
|
|
};
|
|
|
|
|
|
const int symbolCount = sizeof(acronymSet)/sizeof(char*);
|
|
|
|
P3PSymbol symbolIndex[symbolCount];
|
|
|
|
/* 537 is the smallest modulus number which makes the function 1-1 */
|
|
const int HashModulus = 537;
|
|
unsigned char lookupArray[HashModulus];
|
|
|
|
/* This hash function is designed to be collision-free on the P3P
|
|
compact-policy tokens. If new tokens are introduced, MUST
|
|
verify that the hash-values remain unique. */
|
|
unsigned int hashP3PSymbol(const char *symbol) {
|
|
|
|
unsigned long ulValue = (symbol[0]<<24) |
|
|
(symbol[1]<<16) |
|
|
(symbol[2]<<8) |
|
|
(symbol[3]);
|
|
return (ulValue%HashModulus);
|
|
}
|
|
|
|
bool buildSymbolTable(void) {
|
|
|
|
memset(lookupArray, 0xFF, sizeof(lookupArray));
|
|
|
|
for (int si=0; si<symbolCount; si++) {
|
|
|
|
const char *pstr = acronymSet[si];
|
|
|
|
symbolIndex[si].pszAcronym = pstr;
|
|
symbolIndex[si].dwSymIndex = si;
|
|
|
|
/* Compute unique hash-code from first 3 letters, used for fast comparison */
|
|
symbolIndex[si].dwHashCode = (pstr[0]<<16) | (pstr[1]<<8) | (pstr[2]);
|
|
|
|
unsigned int hashIndex = hashP3PSymbol(pstr);
|
|
lookupArray[hashIndex] = (unsigned char) si;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* Search the symbol set used in P3P compact-policy declarations
|
|
This function correctly deals with the optional "a" extension
|
|
which can be added to some of the symbols.
|
|
Returns index into the symbol-table or negative value for failure */
|
|
int findSymbol(const char *pstr) {
|
|
|
|
static bool fReady = buildSymbolTable();
|
|
|
|
/* all symbols recognized in P3P-V1 have 3 or 4 characters */
|
|
int symlen = strlen(pstr);
|
|
if (symlen<3 || symlen>4)
|
|
return -1;
|
|
|
|
/* compute hash-code for first 3 letters */
|
|
unsigned long dwHashCode = (pstr[0]<<16) | (pstr[1]<<8) | (pstr[2]);
|
|
|
|
for (int i=0; i<symbolCount; i++) {
|
|
|
|
const char *pSymbol = acronymSet[i];
|
|
|
|
/* first three letters MUST match exactly-- otherwise move to next symbol */
|
|
if (symbolIndex[i].dwHashCode != dwHashCode)
|
|
continue;
|
|
|
|
/* if no extension is given "a" is implied */
|
|
if (pSymbol[3]==pstr[3] || (pSymbol[3]=='a' && pstr[3]==0))
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/* Semi-public version of the above function (exported by ordinal) */
|
|
INTERNETAPI_(int) FindP3PPolicySymbol(const char *pszSymbol) {
|
|
|
|
if (pszSymbol)
|
|
{
|
|
return findSymbol(pszSymbol);
|
|
}
|
|
else
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int mapCookieAction(char ch) {
|
|
|
|
int iAction = COOKIE_STATE_UNKNOWN;
|
|
|
|
switch (ch) {
|
|
|
|
case 'a': iAction = COOKIE_STATE_ACCEPT; break;
|
|
case 'p': iAction = COOKIE_STATE_PROMPT; break;
|
|
case 'l': iAction = COOKIE_STATE_LEASH; break;
|
|
case 'd': iAction = COOKIE_STATE_DOWNGRADE; break;
|
|
case 'r': iAction = COOKIE_STATE_REJECT; break;
|
|
|
|
default:
|
|
break;
|
|
};
|
|
|
|
return iAction;
|
|
}
|
|
|
|
const char *getNextToken(const char *pch, char *pszToken, int cbToken, bool fWhiteSpc, int *pLength) {
|
|
|
|
if (pch==NULL || pszToken==NULL || cbToken==0)
|
|
return NULL;
|
|
|
|
/* clear token and set optional length to zero */
|
|
*pszToken = '\0';
|
|
if (pLength)
|
|
*pLength = 0;
|
|
|
|
/* locate beginning of next token by skipping over white space */
|
|
while (*pch && isspace(*pch))
|
|
pch++;
|
|
|
|
int tksize = 0;
|
|
char chStart = *pch;
|
|
|
|
if (fWhiteSpc) {
|
|
/* copy whole token to the space provided */
|
|
while (*pch && !isspace(*pch) && tksize<cbToken)
|
|
pszToken[tksize++] = *pch++;
|
|
}
|
|
else if (ispunct(*pch))
|
|
pszToken[tksize++] = *pch++;
|
|
else {
|
|
/* copy alphanumeric token-- other characters are not included */
|
|
while (*pch && isalnum(*pch) && tksize<cbToken)
|
|
pszToken[tksize++] = *pch++;
|
|
}
|
|
|
|
pszToken[tksize] = '\0'; /* zero-terminate string */
|
|
|
|
/* store size of token in optional parameter */
|
|
if (pLength)
|
|
*pLength = tksize;
|
|
|
|
/* Return the current position after token last-scanned */
|
|
return pch;
|
|
}
|
|
|
|
void RefreshP3PSettings() {
|
|
|
|
CCookieSettings::RefreshP3PSettings();
|
|
}
|
|
|
|
void CCookieSettings::RefreshP3PSettings() {
|
|
|
|
cookiePrefsCache.evictAll();
|
|
}
|
|
|
|
bool CCookieSettings::extractCompactPolicy(const char *pszP3PHeader, char *pszPolicy, DWORD *pPolicyLen)
|
|
{
|
|
static const char gszPolicyFieldName[] = "CP";
|
|
|
|
unsigned long dwFieldLen = 0;
|
|
char *pszValue = FindNamedValue((char*) pszP3PHeader, gszPolicyFieldName, &dwFieldLen);
|
|
|
|
if (pszValue && dwFieldLen<*pPolicyLen) {
|
|
|
|
*pPolicyLen = dwFieldLen;
|
|
strncpy(pszPolicy, pszValue, dwFieldLen+1);
|
|
pszPolicy[dwFieldLen] = '\0';
|
|
return true;
|
|
}
|
|
|
|
/* Reaching this point implies header was incorrectly formatted or
|
|
there is insufficient space to copy the policy */
|
|
*pPolicyLen = dwFieldLen;
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* Converts a Unicode representation of P3P-V1 settings to ASCII.
|
|
* The settings format is guaranteed to contain only ASCII characters,
|
|
* which allows for the more efficient conversion below instead of
|
|
* calling WideCharToMultiByte()
|
|
*/
|
|
void CCookieSettings::convertToASCII(char *pszSettings, int cbBytes) {
|
|
|
|
wchar_t *pwszUC = (wchar_t*) pszSettings;
|
|
|
|
for (int i=0; i<cbBytes/2; i++)
|
|
*pszSettings++ = (char) *pwszUC++;
|
|
|
|
*pszSettings = '\0'; // nil-terminate the string
|
|
}
|
|
|
|
/*
|
|
* Input: pointer to P3P header (contained in the struct P3PCookieState)
|
|
* This functions parses the policy header, extracts and evaluates the
|
|
* compact policy. Eval results are stored in the struct.
|
|
*/
|
|
int CCookieSettings::EvaluatePolicy(P3PCookieState *pState) {
|
|
int nResult = dwNoPolicyDecision;
|
|
char *pchCompactPolicy = NULL;
|
|
unsigned long dwPolicySize = 2048;
|
|
CompactPolicy sitePolicy;
|
|
|
|
if (!pState)
|
|
goto Cleanup;
|
|
|
|
pState->fEvaluated = FALSE;
|
|
|
|
pchCompactPolicy = (char *) ALLOCATE_FIXED_MEMORY(dwPolicySize);
|
|
if (pchCompactPolicy == NULL)
|
|
goto Cleanup;
|
|
|
|
pState->fValidPolicy = pState->pszP3PHeader &&
|
|
extractCompactPolicy(pState->pszP3PHeader, pchCompactPolicy, &dwPolicySize);
|
|
|
|
pState->fIncSession = fApplyToSC ? TRUE : FALSE;
|
|
|
|
/* Are the settings independent of policy? */
|
|
if (fConstant) {
|
|
pState->fEvaluated = TRUE; /* set privacy-eval flag */
|
|
nResult = (pState->dwPolicyState = dwFixedDecision);
|
|
goto Cleanup;
|
|
}
|
|
|
|
/* If there is no compact policy in the P3P header return
|
|
the decision which would apply in the case of missing policy */
|
|
if (! pState->fValidPolicy) {
|
|
nResult = (pState->dwPolicyState = dwNoPolicyDecision);
|
|
goto Cleanup;
|
|
}
|
|
|
|
/* Otherwise: found compact policy with valid syntax in P3P: header */
|
|
pState->fEvaluated = TRUE;
|
|
|
|
const char *pszCompactPolicy = pchCompactPolicy;
|
|
|
|
int numTokens = 0;
|
|
int finalDecision = COOKIE_STATE_ACCEPT;
|
|
char achToken[128];
|
|
|
|
while (*pszCompactPolicy) {
|
|
|
|
pszCompactPolicy = getNextToken(pszCompactPolicy, achToken, sizeof(achToken));
|
|
|
|
/* An empty token means we reached end of the header */
|
|
if (!achToken[0])
|
|
break;
|
|
|
|
numTokens++;
|
|
|
|
int symindex = findSymbol(achToken);
|
|
|
|
if (symindex<0) /* Unrecognized token? */
|
|
continue; /* Ignore-- equivalent to ACCEPT decision for that token */
|
|
|
|
/* Update binary representation of compact-policy */
|
|
sitePolicy.addToken(symindex);
|
|
|
|
int tokenDecision = MPactions[symindex];
|
|
|
|
if (precedence(tokenDecision) > precedence(finalDecision))
|
|
finalDecision = tokenDecision;
|
|
|
|
/* REJECT decisions are irreversible: no other value can override this */
|
|
if (finalDecision==COOKIE_STATE_REJECT)
|
|
break;
|
|
}
|
|
|
|
/* If there were no tokens in the policy, it is considered invalid.
|
|
Note that unrecognized tokens also count towards the tally. */
|
|
if (numTokens==0) {
|
|
finalDecision = dwNoPolicyDecision;
|
|
pState->fValidPolicy = FALSE;
|
|
}
|
|
else {
|
|
/* Additional evaluation rules */
|
|
for (CPEvalRule *pRule = pRuleSet;
|
|
pRule;
|
|
pRule=pRule->pNext) {
|
|
|
|
int outcome = pRule->evaluate(sitePolicy);
|
|
|
|
if (outcome != COOKIE_STATE_UNKNOWN) {
|
|
finalDecision = outcome;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
pState->cpSitePolicy = sitePolicy;
|
|
|
|
nResult = (pState->dwPolicyState = finalDecision);
|
|
|
|
Cleanup:
|
|
if (pchCompactPolicy)
|
|
FREE_MEMORY(pchCompactPolicy);
|
|
|
|
return nResult;
|
|
}
|
|
|
|
bool CCookieSettings::GetSettings(CCookieSettings **ppCookiePref, DWORD dwZone, BOOL f3rdParty) {
|
|
|
|
/* symbolic value for corrupt settings */
|
|
static CCookieSettings InvalidSettings(NULL, 0);
|
|
|
|
bool fSuccess = false;
|
|
|
|
*ppCookiePref = NULL;
|
|
|
|
CCookieSettings *pCachedPref = cookiePrefsCache.lookupCookieSettings(dwZone, f3rdParty);
|
|
|
|
if (pCachedPref && pCachedPref != &InvalidSettings) {
|
|
*ppCookiePref = pCachedPref;
|
|
fSuccess = true;
|
|
goto ExitPoint;
|
|
}
|
|
else if (pCachedPref==&InvalidSettings)
|
|
goto ExitPoint;
|
|
|
|
if(WCHAR *pszSettings = new WCHAR[MaxPrivacySettings])
|
|
{
|
|
DWORD dwSize = MaxPrivacySettings;
|
|
|
|
if(ERROR_SUCCESS == PrivacyGetZonePreferenceW(
|
|
dwZone,
|
|
f3rdParty ? PRIVACY_TYPE_THIRD_PARTY : PRIVACY_TYPE_FIRST_PARTY,
|
|
NULL,
|
|
pszSettings,
|
|
&dwSize)
|
|
&& *pszSettings)
|
|
{
|
|
*ppCookiePref = new CCookieSettings((BYTE *)pszSettings, sizeof(WCHAR) * lstrlenW(pszSettings));
|
|
cookiePrefsCache.saveCookieSettings(dwZone, f3rdParty, *ppCookiePref);
|
|
fSuccess = true;
|
|
}
|
|
else {
|
|
InvalidSettings.AddRef();
|
|
cookiePrefsCache.saveCookieSettings(dwZone, f3rdParty, &InvalidSettings);
|
|
}
|
|
|
|
delete [] pszSettings;
|
|
}
|
|
|
|
ExitPoint:
|
|
return fSuccess;
|
|
}
|
|
|
|
bool CCookieSettings::GetSettings(CCookieSettings **pCookiePref, const char *pszURL, BOOL f3rdParty, BOOL fRestricted) {
|
|
|
|
INET_ASSERT(pszURL);
|
|
INET_ASSERT(pCookiePref);
|
|
|
|
DWORD dwZone;
|
|
|
|
if (fRestricted)
|
|
dwZone = URLZONE_UNTRUSTED;
|
|
else
|
|
dwZone = GetZoneFromUrl(pszURL);
|
|
|
|
return GetSettings(pCookiePref, dwZone, f3rdParty);
|
|
}
|
|
|
|
/* Constructor for interpreting settings in binary format */
|
|
CCookieSettings::CCookieSettings(unsigned char *pBinaryRep, int cb) {
|
|
|
|
const int siglen = sizeof(gszP3PV1Signature)/sizeof(char);
|
|
|
|
MPactions = NULL;
|
|
pRuleSet = NULL;
|
|
ppLast = &pRuleSet;
|
|
|
|
iRefCount = 1;
|
|
dwNoPolicyDecision = COOKIE_STATE_REJECT;
|
|
fConstant = false;
|
|
fApplyToSC = true;
|
|
|
|
if (!pBinaryRep || cb<=0) {
|
|
|
|
fConstant = true;
|
|
dwFixedDecision = COOKIE_STATE_ACCEPT;
|
|
return;
|
|
}
|
|
|
|
/* Create new zero-terminated copy of the settings which
|
|
can be modified for parsing steps below */
|
|
char *pszBuffer = new char[cb+2];
|
|
|
|
memcpy(pszBuffer, pBinaryRep, cb);
|
|
|
|
pszBuffer[cb] = pszBuffer[cb+1] = '\0';
|
|
|
|
/* create and initialize array for token-settings
|
|
default behavior for tokens not listed is ACCEPT */
|
|
MPactions = new unsigned char[symbolCount];
|
|
memset(MPactions, COOKIE_STATE_ACCEPT, sizeof(unsigned char)*symbolCount);
|
|
|
|
wchar_t *pwszSettings = (wchar_t*) pszBuffer;
|
|
|
|
/* convert Unicode representation to ASCII */
|
|
convertToASCII(pszBuffer, cb);
|
|
|
|
char *pszSettings = pszBuffer;
|
|
|
|
/* check for signature at the beginning of the string */
|
|
if (pszSettings == strstr(pszSettings, gszP3PV1Signature)) {
|
|
|
|
/* signature found: advance to first token */
|
|
pszSettings += siglen;
|
|
|
|
/* loop over the string, examining individual tokens */
|
|
while (*pszSettings) {
|
|
|
|
char achToken[1024], *pEqSign;
|
|
|
|
pszSettings = (char*) getNextToken(pszSettings, achToken, sizeof(achToken));
|
|
|
|
if (!achToken[0])
|
|
break;
|
|
|
|
/* logical-expression rules are enclosed in forward slashes */
|
|
if (achToken[0]=='/') {
|
|
|
|
if (CPEvalRule *pRule = parseEvalRule(achToken+1))
|
|
addEvalRule(pRule);
|
|
continue;
|
|
}
|
|
|
|
/* each setting has the format: <acronym>[a|i|o]=[a|p|l|d|r] */
|
|
pEqSign = strchr(achToken, '=');
|
|
|
|
/* skip badly formatted settings */
|
|
if (!pEqSign)
|
|
continue;
|
|
|
|
*pEqSign = '\0';
|
|
|
|
/* determine cookie state for current token.
|
|
its given by the character after the equal sign */
|
|
int iTokenSetting = mapCookieAction(pEqSign[1]);
|
|
|
|
if (iTokenSetting == COOKIE_STATE_UNKNOWN)
|
|
continue;
|
|
|
|
int symIndex = findSymbol(achToken);
|
|
|
|
if (symIndex<0) { /* not one of standard compact-policy tokens? */
|
|
/* meta-symbols are handled in a separate function */
|
|
parseSpecialSymbol(achToken, iTokenSetting);
|
|
continue; /* otherwise ignore */
|
|
}
|
|
|
|
MPactions[symIndex] = (unsigned char) iTokenSetting;
|
|
}
|
|
}
|
|
|
|
delete [] pszBuffer;
|
|
}
|
|
|
|
bool CCookieSettings::parseSpecialSymbol(char *pszToken, int iSetting) {
|
|
|
|
if (!strcmp(pszToken, SymNoPolicy) ||
|
|
!strcmp(pszToken, SymMissingCP))
|
|
dwNoPolicyDecision = iSetting;
|
|
else if (!strcmp(pszToken, SymConstDecision) ||
|
|
!strcmp(pszToken, SymApplyAll)) {
|
|
fConstant = true;
|
|
dwFixedDecision = iSetting;
|
|
}
|
|
else if (!strcmp(pszToken, SymSession) && iSetting==COOKIE_STATE_ACCEPT)
|
|
fApplyToSC = false;
|
|
else
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void CCookieSettings::addEvalRule(CPEvalRule *pRule) {
|
|
|
|
/* add evaluation rule at end of linked list */
|
|
*ppLast = pRule;
|
|
pRule->pNext = NULL;
|
|
ppLast = & (pRule->pNext);
|
|
}
|
|
|
|
void CCookieSettings::Release() {
|
|
|
|
if (! --iRefCount)
|
|
delete this;
|
|
}
|
|
|
|
CCookieSettings::~CCookieSettings() {
|
|
|
|
/* Free array of token decisions */
|
|
if (MPactions)
|
|
delete [] MPactions;
|
|
|
|
/* Free linked-list of evaluation rules */
|
|
while (pRuleSet) {
|
|
CPEvalRule *pNext = pRuleSet->pNext;
|
|
delete pRuleSet;
|
|
pRuleSet = pNext;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Implementation of CP3PSettingsCache
|
|
*/
|
|
CP3PSettingsCache::CP3PSettingsCache() {
|
|
|
|
memset (stdCookiePref, 0 ,sizeof(stdCookiePref));
|
|
memset (std3rdPartyPref, 0, sizeof(std3rdPartyPref));
|
|
|
|
InitializeCriticalSection(&csCache);
|
|
}
|
|
|
|
CP3PSettingsCache::~CP3PSettingsCache() {
|
|
|
|
DeleteCriticalSection(&csCache);
|
|
}
|
|
|
|
CCookieSettings *CP3PSettingsCache::lookupCookieSettings(DWORD dwZone, BOOL f3rdParty) {
|
|
|
|
if (dwZone>MaxKnownZone)
|
|
return NULL;
|
|
|
|
CriticalSectOwner csOwner(&csCache);
|
|
|
|
CCookieSettings **ppStore;
|
|
|
|
// Choose storage based on whether cookie is 3rd-party
|
|
if (f3rdParty)
|
|
ppStore = std3rdPartyPref;
|
|
else
|
|
ppStore = stdCookiePref;
|
|
|
|
// Increase reference count before returning pointer
|
|
if (ppStore[dwZone])
|
|
ppStore[dwZone]->AddRef();
|
|
|
|
return ppStore[dwZone];
|
|
}
|
|
|
|
void CP3PSettingsCache::saveCookieSettings(DWORD dwZone, BOOL f3rdParty, CCookieSettings *pSettings) {
|
|
|
|
if (dwZone>MaxKnownZone)
|
|
return;
|
|
|
|
CriticalSectOwner csOwner(&csCache);
|
|
|
|
CCookieSettings **ppStore;
|
|
|
|
// Choose storage based on whether cookie is 3rd-party
|
|
if (f3rdParty)
|
|
ppStore = std3rdPartyPref;
|
|
else
|
|
ppStore = stdCookiePref;
|
|
|
|
pSettings->AddRef();
|
|
|
|
ppStore[dwZone] = pSettings;
|
|
}
|
|
|
|
|
|
void CP3PSettingsCache::evictAll() {
|
|
|
|
CriticalSectOwner csOwner(&csCache);
|
|
|
|
/* Release all settings.
|
|
Destructors are not invoked if there are outstanding
|
|
references left. (eg the settings are being used for evaluation)
|
|
Object will be freed when all references are gone. */
|
|
|
|
for (int i=0; i<MaxKnownZone; i++) {
|
|
|
|
if (stdCookiePref[i])
|
|
stdCookiePref[i]->Release();
|
|
|
|
if (std3rdPartyPref[i])
|
|
std3rdPartyPref[i]->Release();
|
|
}
|
|
|
|
/* zero-out the arrays */
|
|
memset (stdCookiePref, 0 ,sizeof(stdCookiePref));
|
|
memset (std3rdPartyPref, 0, sizeof(std3rdPartyPref));
|
|
}
|
|
|
|
|
|
/*
|
|
Implementation of CompactPolicy structure
|
|
*/
|
|
CompactPolicy CompactPolicy::operator & (const CompactPolicy &ps) const {
|
|
|
|
CompactPolicy result;
|
|
|
|
result.qwLow = qwLow & ps.qwLow;
|
|
result.qwHigh = qwHigh & ps.qwHigh;
|
|
return result;
|
|
}
|
|
|
|
bool CompactPolicy::operator == (const CompactPolicy &ps) const {
|
|
|
|
return (qwLow==ps.qwLow) &&
|
|
(qwHigh==ps.qwHigh);
|
|
}
|
|
|
|
bool CompactPolicy::operator != (const CompactPolicy &ps) const {
|
|
|
|
return (qwLow!=ps.qwLow) ||
|
|
(qwHigh!=ps.qwHigh);
|
|
}
|
|
|
|
void CompactPolicy::addToken(int index) {
|
|
|
|
const quadword mask = 1;
|
|
|
|
if (index<64)
|
|
qwLow |= mask << index;
|
|
else if (index<128)
|
|
qwHigh |= mask << (index-64);
|
|
}
|
|
|
|
int CompactPolicy::contains(int index) {
|
|
|
|
quadword mask = 1 << (index%64);
|
|
|
|
if (index<64)
|
|
mask &= qwLow;
|
|
else
|
|
mask &= qwHigh;
|
|
|
|
return (mask!=0);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Privacy settings API and helper functions
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define REGSTR_PATH_ZONE L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\Zones"
|
|
#define REGSTR_VAL_FIRST_PARTY L"{AEBA21FA-782A-4A90-978D-B72164C80120}"
|
|
#define REGSTR_VAL_THIRD_PARTY L"{A8A88C49-5EB2-4990-A1A2-0876022C854F}"
|
|
|
|
#define SIGNATURE_NONE 0
|
|
#define SIGNATURE_UNICODE 1
|
|
#define SIGNATURE_MULTIBYTE 2
|
|
|
|
#define MIN(a,b) (((DWORD_PTR)a) < ((DWORD_PTR)b) ? (a) : (b))
|
|
|
|
DWORD IsSignaturePresent(BYTE *pbBuffer, DWORD dwBufferBytes)
|
|
{
|
|
if(dwBufferBytes && 0 == StrCmpNIW(
|
|
(LPCWSTR)pbBuffer,
|
|
gszUnicodeSignature,
|
|
MIN(dwBufferBytes / sizeof(WCHAR), lstrlenW(gszUnicodeSignature))
|
|
))
|
|
{
|
|
return SIGNATURE_UNICODE;
|
|
}
|
|
|
|
if(dwBufferBytes && 0 == StrCmpNI(
|
|
(LPCSTR)pbBuffer,
|
|
gszP3PV1Signature,
|
|
MIN(dwBufferBytes / sizeof(CHAR), lstrlenA(gszP3PV1Signature))
|
|
))
|
|
{
|
|
return SIGNATURE_MULTIBYTE;
|
|
}
|
|
|
|
return SIGNATURE_NONE;
|
|
}
|
|
|
|
void AddHardeningPrivacyDefaults()
|
|
{
|
|
// Internet to Medium
|
|
PrivacySetZonePreferenceW(URLZONE_TRUSTED, PRIVACY_TYPE_FIRST_PARTY, PRIVACY_TEMPLATE_MEDIUM, NULL);
|
|
PrivacySetZonePreferenceW(URLZONE_TRUSTED, PRIVACY_TYPE_THIRD_PARTY, PRIVACY_TEMPLATE_MEDIUM, NULL);
|
|
}
|
|
|
|
void RemoveHardeningPrivacyDefaults()
|
|
{
|
|
WCHAR szRegPath[MAX_PATH];
|
|
// build reg path
|
|
wnsprintfW(szRegPath, MAX_PATH, L"%ws\\2", REGSTR_PATH_ZONE);
|
|
|
|
SHDeleteValueW(HKEY_CURRENT_USER,
|
|
szRegPath,
|
|
REGSTR_VAL_FIRST_PARTY);
|
|
|
|
SHDeleteValueW(
|
|
HKEY_CURRENT_USER,
|
|
szRegPath,
|
|
REGSTR_VAL_THIRD_PARTY);
|
|
|
|
}
|
|
|
|
void
|
|
CheckPrivacyDefaults(void)
|
|
{
|
|
WCHAR szRegPath[MAX_PATH], szValue[MAX_PATH];
|
|
BOOL fWriteSettings = TRUE;
|
|
DWORD dwError, dwLen = MAX_PATH;
|
|
|
|
// build reg path
|
|
wnsprintfW(szRegPath, MAX_PATH, L"%ws\\3", REGSTR_PATH_ZONE);
|
|
|
|
dwError = SHGetValueW(
|
|
HKEY_CURRENT_USER,
|
|
szRegPath,
|
|
REGSTR_VAL_FIRST_PARTY,
|
|
NULL,
|
|
szValue,
|
|
&dwLen);
|
|
|
|
switch(dwError)
|
|
{
|
|
case ERROR_SUCCESS:
|
|
// check to see if the plaintext signature is present
|
|
if(SIGNATURE_NONE == IsSignaturePresent((BYTE *)szValue, dwLen))
|
|
{
|
|
// plaintext signature not present, don't overwrite.
|
|
fWriteSettings = FALSE;
|
|
}
|
|
break;
|
|
case ERROR_FILE_NOT_FOUND:
|
|
// no existing settings, write defaults
|
|
break;
|
|
case ERROR_MORE_DATA:
|
|
// longer than max_path... not an old setting, so leave it alone
|
|
fWriteSettings = FALSE;
|
|
break;
|
|
default:
|
|
// unknown error, write defaults
|
|
break;
|
|
}
|
|
|
|
if(fWriteSettings)
|
|
{
|
|
// Internet to Medium
|
|
PrivacySetZonePreferenceW(URLZONE_INTERNET, PRIVACY_TYPE_FIRST_PARTY, PRIVACY_TEMPLATE_MEDIUM, NULL);
|
|
PrivacySetZonePreferenceW(URLZONE_INTERNET, PRIVACY_TYPE_THIRD_PARTY, PRIVACY_TEMPLATE_MEDIUM, NULL);
|
|
|
|
// Restriced to High
|
|
PrivacySetZonePreferenceW(URLZONE_UNTRUSTED, PRIVACY_TYPE_FIRST_PARTY, PRIVACY_TEMPLATE_NO_COOKIES, NULL);
|
|
PrivacySetZonePreferenceW(URLZONE_UNTRUSTED, PRIVACY_TYPE_THIRD_PARTY, PRIVACY_TEMPLATE_NO_COOKIES, NULL);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Obfuscation of settings string
|
|
//
|
|
// GetNextObsByte takes an OBS struct detailing the current placement. 4 bits of each value in bCode are
|
|
// taken to compute the substring length to contribute to the entire code. The following bytes give
|
|
// the following contributions:
|
|
//
|
|
// 53 71 59 69 77 6a 63 51 43 67 51 78 72 45 67 4f
|
|
// 0b 0a 0d 05 0b 04 03 0b 02 04 08 0b 0b 04 04 08
|
|
//
|
|
// Total length: 119
|
|
//
|
|
// GetNextObsByte returns the 11 bytes of the array followed by the first 10,
|
|
// then 13, etc.
|
|
|
|
|
|
BYTE bCode[16] = {0x53, 0x71, 0x59, 0x69, 0x77, 0x6a, 0x63, 0x51, 0x43, 0x67, 0x51, 0x78, 0x72, 0x45, 0x67, 0x4f};
|
|
|
|
typedef struct _obs {
|
|
INT iCurNode;
|
|
INT iCurIndex;
|
|
} OBS, *POBS;
|
|
|
|
BYTE GetNextObsByte(POBS pobs)
|
|
{
|
|
BYTE bTarget = bCode[pobs->iCurIndex];
|
|
|
|
pobs->iCurIndex++;
|
|
if(pobs->iCurIndex > ((bCode[pobs->iCurNode] & 0x1e) >> 1))
|
|
{
|
|
// move to next node
|
|
pobs->iCurIndex = 0;
|
|
pobs->iCurNode++;
|
|
|
|
// move back to beginning if all done
|
|
if(pobs->iCurNode > 15)
|
|
{
|
|
pobs->iCurNode = 0;
|
|
}
|
|
}
|
|
|
|
return bTarget;
|
|
}
|
|
|
|
//
|
|
// Obfuscate a string in place and collapse out 0-bytes in unicode string
|
|
//
|
|
void ObfuscateString(LPWSTR pszString, int iLen)
|
|
{
|
|
OBS obs = {0};
|
|
INT iCur = 0;
|
|
BYTE *pbStream;
|
|
INT iIndex;
|
|
|
|
pbStream = (BYTE *)pszString;
|
|
|
|
while(iCur < iLen)
|
|
{
|
|
iIndex = obs.iCurIndex;
|
|
pbStream[iCur] = (((BYTE)(pszString[iCur]) + iIndex) ^ GetNextObsByte(&obs));
|
|
iCur++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Unobfuscate a string - undo what obfuscate does
|
|
//
|
|
void UnobfuscateString(BYTE *pbStream, LPWSTR pszString, int iLen)
|
|
{
|
|
OBS obs = {0};
|
|
INT iIndex;
|
|
INT iCur = 0;
|
|
|
|
while(iCur < iLen)
|
|
{
|
|
iIndex = obs.iCurIndex;
|
|
pszString[iCur] = (pbStream[iCur] ^ GetNextObsByte(&obs)) - iIndex;
|
|
iCur++;
|
|
}
|
|
|
|
// null terminate string
|
|
pszString[iCur] = 0;
|
|
}
|
|
|
|
//
|
|
// Set and query advanced mode
|
|
//
|
|
#define REGSTR_VAL_PRIVADV TEXT("PrivacyAdvanced")
|
|
|
|
BOOL IsAdvanced(void)
|
|
{
|
|
DWORD dwValue = 0;
|
|
BOOL fAdvanced = FALSE;
|
|
|
|
InternetReadRegistryDword(REGSTR_VAL_PRIVADV, &dwValue);
|
|
|
|
if(dwValue)
|
|
{
|
|
fAdvanced = TRUE;
|
|
}
|
|
|
|
return fAdvanced;
|
|
}
|
|
|
|
void SetAdvancedMode(BOOL fAdvanced)
|
|
{
|
|
DWORD dwAdvanced = fAdvanced? 1 : 0;
|
|
|
|
// save advanced flag
|
|
InternetWriteRegistryDword(REGSTR_VAL_PRIVADV, dwAdvanced);
|
|
}
|
|
|
|
//
|
|
// Public APIs
|
|
//
|
|
|
|
INTERNETAPI_(DWORD)
|
|
PrivacySetZonePreferenceW(
|
|
DWORD dwZone,
|
|
DWORD dwType,
|
|
DWORD dwTemplate,
|
|
LPCWSTR pszPreference
|
|
)
|
|
{
|
|
DEBUG_ENTER_API((DBG_DIALUP,
|
|
Dword,
|
|
"PrivacySetZonePreferenceW",
|
|
"%#x, %#x, %#x, %#x (%q)",
|
|
dwZone,
|
|
dwType,
|
|
dwTemplate,
|
|
pszPreference
|
|
));
|
|
|
|
DWORD dwError = ERROR_INVALID_PARAMETER;
|
|
|
|
//
|
|
// validate parameters
|
|
//
|
|
if(dwZone > URLZONE_UNTRUSTED && (dwZone < URLZONE_USER_MIN || dwZone > URLZONE_USER_MAX))
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
if(dwType > PRIVACY_TYPE_THIRD_PARTY)
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
if( dwTemplate > PRIVACY_TEMPLATE_MAX
|
|
&& (dwTemplate < PRIVACY_TEMPLATE_CUSTOM || dwTemplate > PRIVACY_TEMPLATE_ADVANCED))
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
if(pszPreference && IsBadStringPtrW(pszPreference, MaxPrivacySettings))
|
|
// in debug, verifies string is readable up to '\0' or pszPreference[MaxPrivacySettings].
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
if(pszPreference && (dwTemplate != PRIVACY_TEMPLATE_CUSTOM && dwTemplate != PRIVACY_TEMPLATE_ADVANCED))
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
if(NULL == pszPreference && dwTemplate == PRIVACY_TEMPLATE_CUSTOM)
|
|
{
|
|
// custom needs a preference string
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Make buffer with new preference
|
|
//
|
|
WCHAR *pszRegPref;
|
|
LPCWSTR pszCopyStr;
|
|
DWORD dwPrefLen;
|
|
|
|
if(dwTemplate < PRIVACY_TEMPLATE_CUSTOM)
|
|
{
|
|
// figure out appropriate template string
|
|
// Strings are organized as follows:
|
|
//
|
|
// high first
|
|
// high third
|
|
// med-hi first
|
|
// med-hi third
|
|
// ...
|
|
pszCopyStr = SettingTemplate[2 * dwTemplate + dwType];
|
|
}
|
|
else
|
|
{
|
|
// copy passed pref string to new buffer
|
|
pszCopyStr = pszPreference;
|
|
}
|
|
|
|
//
|
|
// alloc buffer, copy appropriate string
|
|
//
|
|
dwPrefLen = lstrlenW(pszCopyStr);
|
|
pszRegPref = new WCHAR[dwPrefLen + 1];
|
|
if(pszRegPref == NULL)
|
|
{
|
|
goto exit;
|
|
}
|
|
StrCpyNW(pszRegPref, pszCopyStr, dwPrefLen + 1);
|
|
|
|
//
|
|
// Obfuscate string in place, dwPrefLen *BYTES* (NOT unicode chars) left afterwards
|
|
//
|
|
dwPrefLen = lstrlenW(pszRegPref);
|
|
ObfuscateString(pszRegPref, dwPrefLen);
|
|
|
|
//
|
|
// Build reg path for appropriate setting
|
|
//
|
|
WCHAR *pszRegPath = new WCHAR[MAX_PATH];
|
|
|
|
if(pszRegPath)
|
|
{
|
|
wnsprintfW(pszRegPath, MAX_PATH, L"%ws\\%d", REGSTR_PATH_ZONE, dwZone);
|
|
|
|
//
|
|
// Stuff it in the registry
|
|
//
|
|
dwError = SHSetValueW(
|
|
HKEY_CURRENT_USER,
|
|
pszRegPath,
|
|
(dwType == PRIVACY_TYPE_FIRST_PARTY) ? REGSTR_VAL_FIRST_PARTY : REGSTR_VAL_THIRD_PARTY,
|
|
REG_BINARY,
|
|
pszRegPref,
|
|
dwPrefLen); // write out dwPrefLen *BYTES*
|
|
|
|
delete [] pszRegPath;
|
|
|
|
// update advanced and no cookies settings
|
|
BOOL fAdvanced = FALSE;
|
|
DWORD dwPolicy = URLPOLICY_QUERY;
|
|
|
|
if(URLZONE_INTERNET == dwZone && PRIVACY_TEMPLATE_ADVANCED == dwTemplate)
|
|
{
|
|
fAdvanced = TRUE;
|
|
}
|
|
|
|
if(PRIVACY_TEMPLATE_NO_COOKIES == dwTemplate)
|
|
{
|
|
dwPolicy = URLPOLICY_DISALLOW;
|
|
}
|
|
|
|
if(PRIVACY_TEMPLATE_LOW == dwTemplate)
|
|
{
|
|
dwPolicy = URLPOLICY_ALLOW;
|
|
}
|
|
|
|
SetAdvancedMode(fAdvanced);
|
|
SetNoCookies(dwZone, dwPolicy);
|
|
}
|
|
else
|
|
{
|
|
dwError = ERROR_OUTOFMEMORY;
|
|
}
|
|
|
|
delete [] pszRegPref;
|
|
|
|
exit:
|
|
DEBUG_LEAVE_API(dwError);
|
|
return dwError;
|
|
}
|
|
|
|
|
|
INTERNETAPI_(DWORD)
|
|
PrivacyGetZonePreferenceW(
|
|
DWORD dwZone,
|
|
DWORD dwType,
|
|
LPDWORD pdwTemplate,
|
|
LPWSTR pszBuffer,
|
|
LPDWORD pdwBufferLength
|
|
)
|
|
{
|
|
DEBUG_ENTER_API((DBG_DIALUP,
|
|
Dword,
|
|
"PrivacyGetZonePreferenceW",
|
|
"%#x, %#x, %#x, %#x, %#x",
|
|
dwZone,
|
|
dwType,
|
|
pdwTemplate,
|
|
pszBuffer,
|
|
pdwBufferLength
|
|
));
|
|
|
|
DWORD dwError = ERROR_INVALID_PARAMETER;
|
|
|
|
//
|
|
// validate parameters
|
|
//
|
|
if(dwZone > URLZONE_UNTRUSTED && (dwZone < URLZONE_USER_MIN || dwZone > URLZONE_USER_MAX))
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
if(dwType > PRIVACY_TYPE_THIRD_PARTY)
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
if(pdwTemplate && IsBadWritePtr(pdwTemplate, sizeof(DWORD)))
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
// both pszBuffer and pdwBufferLength must be non-null and valid or both much be null
|
|
if(pszBuffer || pdwBufferLength)
|
|
{
|
|
if(IsBadWritePtr(pdwBufferLength, sizeof(DWORD)) || IsBadWritePtr(pszBuffer, *pdwBufferLength))
|
|
{
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Allocate buffers for registry read and build path
|
|
//
|
|
WCHAR *pszRegPath = new WCHAR[MAX_PATH];
|
|
WCHAR *pszRegPref;
|
|
DWORD dwRegPrefLen = MaxPrivacySettings; // BYTES
|
|
BYTE *pbRegReadLoc;
|
|
|
|
if(NULL == pszRegPath)
|
|
{
|
|
dwError = ERROR_OUTOFMEMORY;
|
|
goto exit;
|
|
}
|
|
|
|
pszRegPref = new WCHAR[MaxPrivacySettings];
|
|
if(NULL == pszRegPref)
|
|
{
|
|
delete [] pszRegPath;
|
|
dwError = ERROR_OUTOFMEMORY;
|
|
goto exit;
|
|
}
|
|
|
|
wnsprintfW(pszRegPath, MAX_PATH, L"%ws\\%d", REGSTR_PATH_ZONE, dwZone);
|
|
|
|
//
|
|
// Read registry value.
|
|
//
|
|
// Since the written value (assuming it's valid) is at most MaxPrivacySettings BYTES, read
|
|
// it in to the second half of the buffer so it can be expanded to unicode chars in place.
|
|
//
|
|
// Note buffer is allocated to hold MaxPrivacySettings WCHARs
|
|
//
|
|
pbRegReadLoc = (BYTE *)(pszRegPref + (MaxPrivacySettings / sizeof(WCHAR)));
|
|
|
|
dwError = SHGetValueW(
|
|
HKEY_CURRENT_USER,
|
|
pszRegPath,
|
|
(dwType == PRIVACY_TYPE_FIRST_PARTY) ? REGSTR_VAL_FIRST_PARTY : REGSTR_VAL_THIRD_PARTY,
|
|
NULL,
|
|
pbRegReadLoc,
|
|
&dwRegPrefLen);
|
|
|
|
if( ERROR_SUCCESS != dwError
|
|
|| IsSignaturePresent(pbRegReadLoc, dwRegPrefLen)
|
|
)
|
|
{
|
|
// no reg setting => not fatal
|
|
// buffer too small => invalid settings string
|
|
// any other reg error => opps
|
|
// found plaintext signature => someone bogarting registry
|
|
// in any case, return empty string
|
|
dwRegPrefLen = 0;
|
|
dwError = ERROR_SUCCESS;
|
|
}
|
|
|
|
delete [] pszRegPath;
|
|
|
|
//
|
|
// Unobfuscate it
|
|
//
|
|
UnobfuscateString(pbRegReadLoc, pszRegPref, dwRegPrefLen);
|
|
if(SIGNATURE_NONE == IsSignaturePresent((BYTE *)pszRegPref, dwRegPrefLen * sizeof(WCHAR)))
|
|
{
|
|
// internal error.. never expect this to happen
|
|
*pszRegPref = 0;
|
|
dwRegPrefLen = 0;
|
|
dwError = ERROR_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Try to copy to callers buffer if necessary
|
|
//
|
|
if(pszBuffer)
|
|
{
|
|
if(dwRegPrefLen < *pdwBufferLength)
|
|
{
|
|
StrCpyNW(pszBuffer, pszRegPref, *pdwBufferLength);
|
|
}
|
|
else
|
|
{
|
|
dwError = ERROR_MORE_DATA;
|
|
}
|
|
|
|
*pdwBufferLength = dwRegPrefLen + 1;
|
|
}
|
|
|
|
//
|
|
// Try to match it to a template if necessary
|
|
//
|
|
if(pdwTemplate)
|
|
{
|
|
*pdwTemplate = PRIVACY_TEMPLATE_CUSTOM;
|
|
|
|
if(URLZONE_INTERNET == dwZone && IsAdvanced())
|
|
{
|
|
*pdwTemplate = PRIVACY_TEMPLATE_ADVANCED;
|
|
}
|
|
else if(IsNoCookies(dwZone))
|
|
{
|
|
*pdwTemplate = PRIVACY_TEMPLATE_NO_COOKIES;
|
|
}
|
|
else if(*pszRegPref)
|
|
{
|
|
DWORD dwTemplate;
|
|
DWORD dwTemplateId;
|
|
|
|
for(dwTemplate = 0; dwTemplate <= PRIVACY_TEMPLATE_MAX; dwTemplate++)
|
|
{
|
|
dwTemplateId = 2 * dwTemplate + dwType;
|
|
|
|
if(0 == StrCmpIW(SettingTemplate[dwTemplateId], pszRegPref))
|
|
{
|
|
*pdwTemplate = dwTemplate;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
delete [] pszRegPref;
|
|
|
|
exit:
|
|
DEBUG_LEAVE_API(dwError);
|
|
return dwError;
|
|
}
|
|
|
|
|
|
/*
|
|
templates for default cookie settings
|
|
Consistency condition: decision for TST token == decision for no-policy
|
|
In other words, presence of "TST" token invalidates the entire policy
|
|
*/
|
|
|
|
/*
|
|
** WARNING: Settings code assumes all the first party templates are distinct and all the third party
|
|
** templates are distinct. If you're changing a template, ensure this is true. You can simply
|
|
** swap clauses if necessary.
|
|
**
|
|
** Contact darrenmi for more info.
|
|
*/
|
|
|
|
/*
|
|
BEGIN low -- see warning above before changing
|
|
*/
|
|
|
|
const wchar_t achLow1stParty[] =
|
|
|
|
L"IE6-P3PV1/settings: always=a";
|
|
|
|
const wchar_t achLow3rdParty[] =
|
|
|
|
L"IE6-P3PV1/settings: always=a";
|
|
|
|
/*
|
|
END low
|
|
*/
|
|
|
|
|
|
/* BEGIN medium-low -- see warning above before changing */
|
|
|
|
const wchar_t achMedLow1stParty[] =
|
|
|
|
L"IE6-P3PV1/settings: nopolicy=l session=a /TST=l/ /=a/"
|
|
;
|
|
|
|
|
|
const wchar_t achMedLow3rdParty[] =
|
|
|
|
L"IE6-P3PV1/settings: nopolicy=d /TST=d/"
|
|
L" /PHY&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /ONL&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /GOV&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /FIN&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /PHY&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /ONL&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /GOV&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /FIN&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /PHY&SAM=d/ /PHY&OTR=d/ /PHY&UNR=d/ /PHY&PUB=d/ /PHY&CUS=d/ /PHY&IVA=d/ /PHY&IVD=d/"
|
|
L" /PHY&CON=d/ /PHY&TEL=d/ /PHY&OTP=d/ /ONL&SAM=d/ /ONL&OTR=d/ /ONL&UNR=d/ /ONL&PUB=d/"
|
|
L" /ONL&CUS=d/ /ONL&IVA=d/ /ONL&IVD=d/ /ONL&CON=d/ /ONL&TEL=d/ /ONL&OTP=d/ /GOV&SAM=d/"
|
|
L" /GOV&OTR=d/ /GOV&UNR=d/ /GOV&PUB=d/ /GOV&CUS=d/ /GOV&IVA=d/ /GOV&IVD=d/ /GOV&CON=d/ /GOV&TEL=d/"
|
|
L" /GOV&OTP=d/ /FIN&SAM=d/ /FIN&OTR=d/ /FIN&UNR=d/ /FIN&PUB=d/ /FIN&CUS=d/ /FIN&IVA=d/"
|
|
L" /FIN&IVD=d/ /FIN&CON=d/ /FIN&TEL=d/ /FIN&OTP=d/ /=a/"
|
|
;
|
|
|
|
/* END medium-low */
|
|
|
|
/* BEGIN medium -- see warning above before changing */
|
|
|
|
const wchar_t achMedium1stParty[] =
|
|
|
|
L"IE6-P3PV1/settings: nopolicy=l session=a /TST=l/"
|
|
L" /PHY&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /ONL&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /GOV&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /FIN&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /PHY&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /ONL&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /GOV&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /FIN&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /PHY&SAM=d/ /PHY&OTR=d/ /PHY&UNR=d/ /PHY&PUB=d/ /PHY&CUS=d/ /PHY&IVA=d/ /PHY&IVD=d/"
|
|
L" /PHY&CON=d/ /PHY&TEL=d/ /PHY&OTP=d/ /ONL&SAM=d/ /ONL&OTR=d/ /ONL&UNR=d/ /ONL&PUB=d/"
|
|
L" /ONL&CUS=d/ /ONL&IVA=d/ /ONL&IVD=d/ /ONL&CON=d/ /ONL&TEL=d/ /ONL&OTP=d/ /GOV&SAM=d/"
|
|
L" /GOV&OTR=d/ /GOV&UNR=d/ /GOV&PUB=d/ /GOV&CUS=d/ /GOV&IVA=d/ /GOV&IVD=d/ /GOV&CON=d/ /GOV&TEL=d/"
|
|
L" /GOV&OTP=d/ /FIN&SAM=d/ /FIN&OTR=d/ /FIN&UNR=d/ /FIN&PUB=d/ /FIN&CUS=d/ /FIN&IVA=d/"
|
|
L" /FIN&IVD=d/ /FIN&CON=d/ /FIN&TEL=d/ /FIN&OTP=d/ /=a/"
|
|
;
|
|
|
|
const wchar_t achMedium3rdParty[] =
|
|
|
|
L"IE6-P3PV1/settings: nopolicy=r /TST=r/"
|
|
L" /PHY&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /ONL&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /GOV&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /FIN&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /PHY&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /ONL&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /GOV&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /FIN&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /PHY&SAM=r/ /PHY&OTR=r/ /PHY&UNR=r/ /PHY&PUB=r/ /PHY&CUS=r/ /PHY&IVA=r/ /PHY&IVD=r/"
|
|
L" /PHY&CON=r/ /PHY&TEL=r/ /PHY&OTP=r/ /ONL&SAM=r/ /ONL&OTR=r/ /ONL&UNR=r/ /ONL&PUB=r/"
|
|
L" /ONL&CUS=r/ /ONL&IVA=r/ /ONL&IVD=r/ /ONL&CON=r/ /ONL&TEL=r/ /ONL&OTP=r/ /GOV&SAM=r/"
|
|
L" /GOV&OTR=r/ /GOV&UNR=r/ /GOV&PUB=r/ /GOV&CUS=r/ /GOV&IVA=r/ /GOV&IVD=r/ /GOV&CON=r/ /GOV&TEL=r/"
|
|
L" /GOV&OTP=r/ /FIN&SAM=r/ /FIN&OTR=r/ /FIN&UNR=r/ /FIN&PUB=r/ /FIN&CUS=r/ /FIN&IVA=r/"
|
|
L" /FIN&IVD=r/ /FIN&CON=r/ /FIN&TEL=r/ /FIN&OTP=r/ /=a/"
|
|
;
|
|
|
|
/* END medium */
|
|
|
|
|
|
/* BEGIN medium-high -- see warning above before changing */
|
|
|
|
const wchar_t achMedHigh1stParty[] =
|
|
|
|
L"IE6-P3PV1/settings: nopolicy=l session=a /TST=l/"
|
|
L" /PHY&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /ONL&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /GOV&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /FIN&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /PHY&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /ONL&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /GOV&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /FIN&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /PHY&SAM=r/ /PHY&OTR=r/ /PHY&UNR=r/ /PHY&PUB=r/ /PHY&CUS=r/ /PHY&IVA=r/ /PHY&IVD=r/ /PHY&CON=r/"
|
|
L" /PHY&TEL=r/ /PHY&OTP=r/ /ONL&SAM=r/ /ONL&OTR=r/ /ONL&UNR=r/ /ONL&PUB=r/ /ONL&CUS=r/ /ONL&IVA=r/"
|
|
L" /ONL&IVD=r/ /ONL&CON=r/ /ONL&TEL=r/ /ONL&OTP=r/ /GOV&SAM=r/ /GOV&OTR=r/ /GOV&UNR=r/ /GOV&PUB=r/"
|
|
L" /GOV&CUS=r/ /GOV&IVA=r/ /GOV&IVD=r/ /GOV&CON=r/ /GOV&TEL=r/ /GOV&OTP=r/ /FIN&SAM=r/ /FIN&OTR=r/"
|
|
L" /FIN&UNR=r/ /FIN&PUB=r/ /FIN&CUS=r/ /FIN&IVA=r/ /FIN&IVD=r/ /FIN&CON=r/ /FIN&TEL=r/ /FIN&OTP=r/ /=a/"
|
|
;
|
|
|
|
const wchar_t achMedHigh3rdParty[] =
|
|
|
|
/* CAUTION: this setting is identical to 3rd party HIGH.
|
|
We need a cosmetic change to the string to distinguish template levels. */
|
|
L"IE6-P3PV1/settings: /TST=r/ nopolicy=r"
|
|
L" /PHY&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /ONL&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /GOV&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /FIN&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /PHY&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /ONL&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /GOV&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /FIN&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /PHY&SAM=r/ /PHY&OTR=r/ /PHY&UNR=r/ /PHY&PUB=r/ /PHY&CUS=r/ /PHY&IVA=r/ /PHY&IVD=r/ /PHY&CON=r/"
|
|
L" /PHY&TEL=r/ /PHY&OTP=r/ /PHY&SAMo=r/ /PHY&OTRo=r/ /PHY&UNRo=r/ /PHY&PUBo=r/ /PHY&CUSo=r/"
|
|
L" /PHY&IVAo=r/ /PHY&IVDo=r/ /PHY&CONo=r/ /PHY&TELo=r/ /PHY&OTPo=r/ /ONL&SAM=r/ /ONL&OTR=r/"
|
|
L" /ONL&UNR=r/ /ONL&PUB=r/ /ONL&CUS=r/ /ONL&IVA=r/ /ONL&IVD=r/ /ONL&CON=r/ /ONL&TEL=r/ /ONL&OTP=r/"
|
|
L" /ONL&SAMo=r/ /ONL&OTRo=r/ /ONL&UNRo=r/ /ONL&PUBo=r/ /ONL&CUSo=r/ /ONL&IVAo=r/ /ONL&IVDo=r/"
|
|
L" /ONL&CONo=r/ /ONL&TELo=r/ /ONL&OTPo=r/ /GOV&SAM=r/ /GOV&OTR=r/ /GOV&UNR=r/ /GOV&PUB=r/"
|
|
L" /GOV&CUS=r/ /GOV&IVA=r/ /GOV&IVD=r/ /GOV&CON=r/ /GOV&TEL=r/ /GOV&OTP=r/ /GOV&SAMo=r/"
|
|
L" /GOV&OTRo=r/ /GOV&UNRo=r/ /GOV&PUBo=r/ /GOV&CUSo=r/ /GOV&IVAo=r/ /GOV&IVDo=r/ /GOV&CONo=r/ /GOV&TELo=r/"
|
|
L" /GOV&OTPo=r/ /FIN&SAM=r/ /FIN&OTR=r/ /FIN&UNR=r/ /FIN&PUB=r/ /FIN&CUS=r/ /FIN&IVA=r/"
|
|
L" /FIN&IVD=r/ /FIN&CON=r/ /FIN&TEL=r/ /FIN&OTP=r/ /FIN&SAMo=r/ /FIN&OTRo=r/ /FIN&UNRo=r/"
|
|
L" /FIN&PUBo=r/ /FIN&CUSo=r/ /FIN&IVAo=r/ /FIN&IVDo=r/ /FIN&CONo=r/ /FIN&TELo=r/ /FIN&OTPo=r/ /=a/"
|
|
;
|
|
|
|
/* END medium-high */
|
|
|
|
|
|
/* BEGIN high -- see warning above before changing */
|
|
|
|
const wchar_t achHigh1stParty[] =
|
|
|
|
L"IE6-P3PV1/settings: nopolicy=r /TST=r/"
|
|
L" /PHY&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /ONL&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /GOV&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /FIN&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /PHY&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /ONL&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /GOV&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /FIN&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /PHY&SAM=r/ /PHY&OTR=r/ /PHY&UNR=r/ /PHY&PUB=r/ /PHY&CUS=r/ /PHY&IVA=r/ /PHY&IVD=r/"
|
|
L" /PHY&CON=r/ /PHY&TEL=r/ /PHY&OTP=r/ /PHY&SAMo=r/ /PHY&OTRo=r/ /PHY&UNRo=r/ /PHY&PUBo=r/"
|
|
L" /PHY&CUSo=r/ /PHY&IVAo=r/ /PHY&IVDo=r/ /PHY&CONo=r/ /PHY&TELo=r/ /PHY&OTPo=r/ /ONL&SAM=r/ "
|
|
L" /ONL&OTR=r/ /ONL&UNR=r/ /ONL&PUB=r/ /ONL&CUS=r/ /ONL&IVA=r/ /ONL&IVD=r/ /ONL&CON=r/ /ONL&TEL=r/ /ONL&OTP=r/"
|
|
L" /ONL&SAMo=r/ /ONL&OTRo=r/ /ONL&UNRo=r/ /ONL&PUBo=r/ /ONL&CUSo=r/ /ONL&IVAo=r/ /ONL&IVDo=r/"
|
|
L" /ONL&CONo=r/ /ONL&TELo=r/ /ONL&OTPo=r/ /GOV&SAM=r/ /GOV&OTR=r/ /GOV&UNR=r/ /GOV&PUB=r/"
|
|
L" /GOV&CUS=r/ /GOV&IVA=r/ /GOV&IVD=r/ /GOV&CON=r/ /GOV&TEL=r/ /GOV&OTP=r/ /GOV&SAMo=r/ "
|
|
L" /GOV&OTRo=r/ /GOV&UNRo=r/ /GOV&PUBo=r/ /GOV&CUSo=r/ /GOV&IVAo=r/ /GOV&IVDo=r/ /GOV&CONo=r/ /GOV&TELo=r/"
|
|
L" /GOV&OTPo=r/ /FIN&SAM=r/ /FIN&OTR=r/ /FIN&UNR=r/ /FIN&PUB=r/ /FIN&CUS=r/ /FIN&IVA=r/"
|
|
L" /FIN&IVD=r/ /FIN&CON=r/ /FIN&TEL=r/ /FIN&OTP=r/ /FIN&SAMo=r/ /FIN&OTRo=r/ /FIN&UNRo=r/"
|
|
L" /FIN&PUBo=r/ /FIN&CUSo=r/ /FIN&IVAo=r/ /FIN&IVDo=r/ /FIN&CONo=r/ /FIN&TELo=r/ /FIN&OTPo=r/ /=a/"
|
|
;
|
|
|
|
const wchar_t achHigh3rdParty[] =
|
|
|
|
L"IE6-P3PV1/settings: nopolicy=r /TST=r/"
|
|
L" /PHY&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /ONL&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /GOV&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /FIN&!CUR&!ADM&!DEV&!CUS&!TAI&!PSA&!PSD&!IVA&!IVD&!CON&!HIS&!TEL&!OTP&!CURi&!ADMi&!DEVi&!CUSi&!TAIi&!PSAi&!PSDi&!IVAi&!IVDi&!CONi&!HISi&!TELi&!OTPi&!CURo&!ADMo&!DEVo&!CUSo&!TAIo&!PSAo&!PSDo&!IVAo&!IVDo&!CONo&!HISo&!TELo&!OTPo=r/"
|
|
L" /PHY&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /ONL&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /GOV&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /FIN&!DEL&!SAM&!UNR&!PUB&!OTR&!OUR&!DELi&!SAMi&!UNRi&!PUBi&!OTRi&!DELo&!SAMo&!UNRo&!PUBo&!OTRo=r/"
|
|
L" /PHY&SAM=r/ /PHY&OTR=r/ /PHY&UNR=r/ /PHY&PUB=r/ /PHY&CUS=r/ /PHY&IVA=r/ /PHY&IVD=r/ /PHY&CON=r/"
|
|
L" /PHY&TEL=r/ /PHY&OTP=r/ /PHY&SAMo=r/ /PHY&OTRo=r/ /PHY&UNRo=r/ /PHY&PUBo=r/ /PHY&CUSo=r/"
|
|
L" /PHY&IVAo=r/ /PHY&IVDo=r/ /PHY&CONo=r/ /PHY&TELo=r/ /PHY&OTPo=r/ /ONL&SAM=r/ /ONL&OTR=r/"
|
|
L" /ONL&UNR=r/ /ONL&PUB=r/ /ONL&CUS=r/ /ONL&IVA=r/ /ONL&IVD=r/ /ONL&CON=r/ /ONL&TEL=r/ /ONL&OTP=r/"
|
|
L" /ONL&SAMo=r/ /ONL&OTRo=r/ /ONL&UNRo=r/ /ONL&PUBo=r/ /ONL&CUSo=r/ /ONL&IVAo=r/ /ONL&IVDo=r/"
|
|
L" /ONL&CONo=r/ /ONL&TELo=r/ /ONL&OTPo=r/ /GOV&SAM=r/ /GOV&OTR=r/ /GOV&UNR=r/ /GOV&PUB=r/"
|
|
L" /GOV&CUS=r/ /GOV&IVA=r/ /GOV&IVD=r/ /GOV&CON=r/ /GOV&TEL=r/ /GOV&OTP=r/ /GOV&SAMo=r/ "
|
|
L" /GOV&OTRo=r/ /GOV&UNRo=r/ /GOV&PUBo=r/ /GOV&CUSo=r/ /GOV&IVAo=r/ /GOV&IVDo=r/ /GOV&CONo=r/ /GOV&TELo=r/"
|
|
L" /GOV&OTPo=r/ /FIN&SAM=r/ /FIN&OTR=r/ /FIN&UNR=r/ /FIN&PUB=r/ /FIN&CUS=r/ /FIN&IVA=r/"
|
|
L" /FIN&IVD=r/ /FIN&CON=r/ /FIN&TEL=r/ /FIN&OTP=r/ /FIN&SAMo=r/ /FIN&OTRo=r/ /FIN&UNRo=r/"
|
|
L" /FIN&PUBo=r/ /FIN&CUSo=r/ /FIN&IVAo=r/ /FIN&IVDo=r/ /FIN&CONo=r/ /FIN&TELo=r/ /FIN&OTPo=r/ /=a/"
|
|
;
|
|
|
|
/* END high */
|
|
|
|
/* BEGIN NO COOKIES -- see warning above before changing */
|
|
|
|
const wchar_t achNoCookies1stParty[] =
|
|
|
|
L"IE6-P3PV1/settings: always=r";
|
|
|
|
const wchar_t achNoCookies3rdParty[] =
|
|
|
|
L"IE6-P3PV1/settings: always=r";
|
|
|
|
/* END NO COOKIES */
|
|
|
|
|
|
const wchar_t *SettingTemplate[] = {
|
|
|
|
achNoCookies1stParty,
|
|
achNoCookies3rdParty,
|
|
achHigh1stParty,
|
|
achHigh3rdParty,
|
|
achMedHigh1stParty,
|
|
achMedHigh3rdParty,
|
|
achMedium1stParty,
|
|
achMedium3rdParty,
|
|
achMedLow1stParty,
|
|
achMedLow3rdParty,
|
|
achLow1stParty,
|
|
achLow3rdParty,
|
|
};
|