Attachment #630203 for bug #754202

Attachment #630203: Part 6 - Remove mContextPrincipal usage from within nsScriptSecurityManager. v1 for bug #754202

View | Details | Raw Unified | Return to bug 754202
Collapse All | Expand All





    nsresult
    InitPrincipals(PRUint32 prefCount, const char** prefNames);

#ifdef DEBUG_CAPS_HACKER
    void
    PrintPolicyDB();
#endif

    struct ContextPrincipal {
        ContextPrincipal(ContextPrincipal *next, JSContext *cx,
                         JSStackFrame *fp, nsIPrincipal *principal)
            : mNext(next), mCx(cx), mFp(fp), mPrincipal(principal) {}

        ContextPrincipal *mNext;
        JSContext *mCx;
        JSStackFrame *mFp;
        nsCOMPtr<nsIPrincipal> mPrincipal;
    };

    // JS strings we need to clean up on shutdown
    static jsid sEnabledID;

    inline void
    ScriptSecurityPrefChanged();

    nsObjectHashtable* mOriginToPolicyMap;
    DomainPolicy* mDefaultPolicy;
    nsObjectHashtable* mCapabilities;

    nsCOMPtr<nsIPrincipal> mSystemPrincipal;
    nsCOMPtr<nsIPrincipal> mSystemCertificate;
    ContextPrincipal *mContextPrincipals;
    nsInterfaceHashtable<PrincipalKey, nsIPrincipal> mPrincipals;
    bool mPrefInitialized;
    bool mIsJavaScriptEnabled;
    bool mIsWritingPrefs;
    bool mPolicyPrefsChanged;

    static bool sStrictFileOriginPolicy;






{
    NS_PRECONDITION(rv, "Null out param");
    //-- If there's no principal on the stack, look at the global object
    //   and return the innermost frame for annotations.
    *rv = NS_OK;

    if (cx)
    {
        JSStackFrame *target = nsnull;
        nsIPrincipal *targetPrincipal = nsnull;
        for (ContextPrincipal *cp = mContextPrincipals; cp; cp = cp->mNext)
        {
            if (cp->mCx == cx)
            {
                target = cp->mFp;
                targetPrincipal = cp->mPrincipal;
                break;
            }
        }

        // Get principals from innermost JavaScript frame.
        JSStackFrame *fp = nsnull; // tell JS_FrameIterator to start at innermost
        for (fp = JS_FrameIterator(cx, &fp); fp; fp = JS_FrameIterator(cx, &fp))
        {
            if (fp == target)
                break;
            nsIPrincipal* result = GetFramePrincipal(cx, fp, rv);
            if (result)
            {
                NS_ASSERTION(NS_SUCCEEDED(*rv), "Weird return");
                *frameResult = fp;
                return result;
            }
        }

        // If targetPrincipal is non-null, then it means that someone wants to
        // clamp the principals on this context to this principal. Note that
        // fp might not equal target here (fp might be null) because someone
        // could have set aside the frame chain in the meantime.
        if (targetPrincipal)
        {
            if (fp && fp == target)
            {
                *frameResult = fp;
            }
            else
            {
                JSStackFrame *inner = nsnull;
                *frameResult = JS_FrameIterator(cx, &inner);
            }

            return targetPrincipal;
        }

        nsIScriptContextPrincipal* scp =
            GetScriptContextPrincipalFromJSContext(cx);
        if (scp)
        {
            nsIScriptObjectPrincipal* globalData = scp->GetObjectPrincipal();
            if (!globalData)
            {
                *rv = NS_ERROR_FAILURE;

nsScriptSecurityManager::IsCapabilityEnabled(const char *capability,
                                             bool *result)
{
    nsresult rv;
    JSStackFrame *fp = nsnull;
    JSContext *cx = GetCurrentJSContext();
    fp = cx ? JS_FrameIterator(cx, &fp) : nsnull;

    JSStackFrame *target = nsnull;
    nsIPrincipal *targetPrincipal = nsnull;
    for (ContextPrincipal *cp = mContextPrincipals; cp; cp = cp->mNext)
    {
        if (cp->mCx == cx)
        {
            target = cp->mFp;
            targetPrincipal = cp->mPrincipal;
            break;
        }
    }

    if (!fp)
    {
        // No script code on stack. We don't have enough information and have
        // to allow execution.
        *result = true;

        *result = (targetPrincipal && !target)
                  ? (targetPrincipal == mSystemPrincipal)
                  : true;

        return NS_OK;
    }

    *result = false;
    nsIPrincipal* previousPrincipal = nsnull;
    do
    {

        if (NS_FAILED(rv)) return rv;
        if (*result)
            return NS_OK;

        // Capabilities do not extend to calls into C/C++ and then back into
        // the JS engine via JS_EvaluateScript or similar APIs.
        if (JS_IsGlobalFrame(cx, fp))
            break;
    } while ((fp = JS_FrameIterator(cx, &fp)) != nsnull);

    if (!previousPrincipal)
    {
        // No principals on the stack, all native code.  Allow
        // execution if the subject principal is the system principal.

        return SubjectPrincipalIsSystem(result);
    }


/////////////////////////////////////////////
// Constructor, Destructor, Initialization //
/////////////////////////////////////////////
nsScriptSecurityManager::nsScriptSecurityManager(void)
    : mOriginToPolicyMap(nsnull),
      mDefaultPolicy(nsnull),
      mCapabilities(nsnull),
      mContextPrincipals(nsnull),
      mPrefInitialized(false),
      mIsJavaScriptEnabled(false),
      mIsWritingPrefs(false),
      mPolicyPrefsChanged(true)
{
    MOZ_STATIC_ASSERT(sizeof(intptr_t) == sizeof(void*),
                      "intptr_t and void* have different lengths on this platform. "
                      "This may cause a security failure with the SecurityLevel union.");


static nsScriptSecurityManager *gScriptSecMan = nsnull;

jsid nsScriptSecurityManager::sEnabledID   = JSID_VOID;

nsScriptSecurityManager::~nsScriptSecurityManager(void)
{
    Preferences::RemoveObservers(this, kObservedPrefs);
    NS_ASSERTION(!mContextPrincipals, "Leaking mContextPrincipals");
    delete mOriginToPolicyMap;
    if(mDefaultPolicy)
        mDefaultPolicy->Drop();
    delete mCapabilities;
    gScriptSecMan = nsnull;
}

void

Return to bug 754202