efc8aa982db48edcd33a0e66c308331e353287c1
[WebKit.git] / WebCore / platform / SecurityOrigin.cpp
1 /*
2  * Copyright (C) 2007 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "SecurityOrigin.h"
31
32 #include "Document.h"
33 #include "Frame.h"
34 #include "FrameLoader.h"
35 #include "FrameTree.h"
36 #include "KURL.h"
37 #include "PlatformString.h"
38
39 namespace WebCore {
40
41 SecurityOrigin::SecurityOrigin(const String& protocol, const String& host, unsigned short port)
42     : m_protocol(protocol.lower())
43     , m_host(host.lower())
44     , m_port(port)
45     , m_portSet(port)
46     , m_noAccess(false)
47     , m_domainWasSetInDOM(false)
48 {
49     // These protocols do not create security origins; the owner frame provides the origin
50     if (m_protocol == "about" || m_protocol == "javascript")
51         m_protocol = String();
52
53     // data: URLs are not allowed access to anything other than themselves.
54     if (m_protocol == "data")
55         m_noAccess = true;
56 }
57
58 bool SecurityOrigin::isEmpty() const
59 {
60     return m_protocol.isEmpty();
61 }
62
63 PassRefPtr<SecurityOrigin> SecurityOrigin::create(const String& protocol, const String& host, unsigned short port, SecurityOrigin* ownerFrameOrigin)
64 {
65     RefPtr<SecurityOrigin> origin = new SecurityOrigin(protocol, host, port);
66
67     // If we do not obtain a meaningful origin from the URL, then we try to find one
68     // via the frame hierarchy.
69     // We alias the SecurityOrigins to match Firefox, see Bug 15313
70     // http://bugs.webkit.org/show_bug.cgi?id=15313
71     if (origin->isEmpty() && ownerFrameOrigin)
72         return ownerFrameOrigin;
73
74     return origin.release();
75 }
76
77 PassRefPtr<SecurityOrigin> SecurityOrigin::createForFrame(Frame* frame)
78 {
79     if (!frame)
80         return create("", "", 0, 0);
81
82     FrameLoader* loader = frame->loader();
83     KURL url = loader->url();
84
85     Frame* ownerFrame = frame->tree()->parent();
86     if (!ownerFrame)
87         ownerFrame = loader->opener();
88
89     SecurityOrigin* ownerFrameOrigin = 0;
90     if (ownerFrame && ownerFrame->document())
91         ownerFrameOrigin = ownerFrame->document()->securityOrigin();
92
93     return create(url.protocol(), url.host(), url.port(), ownerFrameOrigin);
94 }
95
96 PassRefPtr<SecurityOrigin> SecurityOrigin::copy()
97 {
98     return create(m_protocol.copy(), m_host.copy(), m_port, 0);
99 }
100
101
102 void SecurityOrigin::setDomainFromDOM(const String& newDomain)
103 {
104     m_domainWasSetInDOM = true;
105     m_host = newDomain.lower();
106 }
107
108 bool SecurityOrigin::canAccess(const SecurityOrigin* other) const
109 {
110     if (FrameLoader::shouldTreatSchemeAsLocal(m_protocol))
111         return true;
112
113     if (m_noAccess || other->m_noAccess)
114         return false;
115
116     // Here are two cases where we should permit access:
117     //
118     // 1) Neither document has set document.domain.  In this case, we insist
119     //    that the scheme, host, and port of the URLs match.
120     //
121     // 2) Both documents have set document.domain.  In this case, we insist
122     //    that the documents have set document.domain to the same value and
123     //    that the scheme of the URLs match.
124     //
125     // This matches the behavior of Firefox 2 and Internet Explorer 6.
126     //
127     // Internet Explorer 7 and Opera 9 are more strict in that they require
128     // the port numbers to match when both pages have document.domain set.
129     //
130     // FIXME: Evaluate whether we can tighten this policy to require matched
131     //        port numbers.
132     //
133     // Opera 9 allows access when only one page has set document.domain, but
134     // this is a security vulnerability.
135
136     if (m_protocol == other->m_protocol) {
137         if (!m_domainWasSetInDOM && !other->m_domainWasSetInDOM) {
138             if (m_host == other->m_host && m_port == other->m_port)
139                 return true;
140         }
141         if (m_domainWasSetInDOM && other->m_domainWasSetInDOM) {
142             if (m_host == other->m_host)
143                 return true;
144         }
145     }
146
147     return false;
148 }
149
150 bool SecurityOrigin::isSecureTransitionTo(const KURL& url) const
151
152     // New window created by the application
153     if (isEmpty())
154         return true;
155
156     if (FrameLoader::shouldTreatSchemeAsLocal(m_protocol))
157         return true;
158
159     return equalIgnoringCase(m_host, String(url.host())) && equalIgnoringCase(m_protocol, String(url.protocol())) && m_port == url.port();
160 }
161
162 String SecurityOrigin::toString() const
163 {
164     return m_protocol + ":" + m_host + ":" + String::number(m_port);
165 }
166
167 static const char SeparatorCharacter = '_';
168
169 PassRefPtr<SecurityOrigin> SecurityOrigin::createFromIdentifier(const String& stringIdentifier)
170
171     // Make sure there's a first separator
172     int separator1 = stringIdentifier.find(SeparatorCharacter);
173     if (separator1 == -1)
174         return create("", "", 0, 0);
175         
176     // Make sure there's a second separator
177     int separator2 = stringIdentifier.find(SeparatorCharacter, separator1 + 1);
178     if (separator2 == -1)
179         return create("", "", 0, 0);
180         
181     // Make sure there's not a third separator
182     if (stringIdentifier.reverseFind(SeparatorCharacter) != separator2)
183         return create("", "", 0, 0);
184         
185     // Make sure the port section is a valid port number or doesn't exist
186     bool portOkay;
187     int port = stringIdentifier.right(stringIdentifier.length() - separator2 - 1).toInt(&portOkay);
188     if (!portOkay && separator2 + 1 == static_cast<int>(stringIdentifier.length()))
189         return create("", "", 0, 0);
190     
191     if (port < 0 || port > 65535)
192         return create("", "", 0, 0);
193         
194     // Split out the 3 sections of data
195     String protocol = stringIdentifier.substring(0, separator1);
196     String host = stringIdentifier.substring(separator1 + 1, separator2 - separator1 - 1);
197     return create(protocol, host, port, 0);
198 }
199     
200     
201 String SecurityOrigin::stringIdentifier() const 
202 {
203     static String separatorString = String(&SeparatorCharacter, 1);
204     return m_protocol + separatorString + m_host + separatorString + String::number(m_port); 
205 }
206
207 } // namespace WebCore