Reviewed by Sam
[WebKit-https.git] / WebCore / storage / DatabaseAuthorizer.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 #include "config.h"
29 #include "DatabaseAuthorizer.h"
30
31 #include "Database.h"
32 #include "PlatformString.h"
33
34 namespace WebCore {
35
36 DatabaseAuthorizer::DatabaseAuthorizer()
37     : m_securityEnabled(false)
38 {
39     reset();
40 }
41
42 void DatabaseAuthorizer::reset()
43 {
44     m_lastActionWasInsert = false;
45     m_lastActionIncreasedSize = false;
46 }
47
48 int DatabaseAuthorizer::createTable(const String& tableName)
49 {
50     m_lastActionIncreasedSize = true;
51     return denyBasedOnTableName(tableName);
52 }
53
54 int DatabaseAuthorizer::createTempTable(const String& tableName)
55 {
56     return denyBasedOnTableName(tableName);
57 }
58
59 int DatabaseAuthorizer::dropTable(const String& tableName)
60 {
61     return denyBasedOnTableName(tableName);
62 }
63
64 int DatabaseAuthorizer::dropTempTable(const String& tableName)
65 {
66     return denyBasedOnTableName(tableName);
67 }
68
69 int DatabaseAuthorizer::allowAlterTable(const String& databaseName, const String& tableName)
70 {
71     m_lastActionIncreasedSize = true;
72     return denyBasedOnTableName(tableName);
73 }
74
75 int DatabaseAuthorizer::createIndex(const String& indexName, const String& tableName)
76 {
77     m_lastActionIncreasedSize = true;
78     return denyBasedOnTableName(tableName);
79 }
80
81 int DatabaseAuthorizer::createTempIndex(const String& indexName, const String& tableName)
82 {
83     return denyBasedOnTableName(tableName);
84 }
85
86 int DatabaseAuthorizer::dropIndex(const String& indexName, const String& tableName)
87 {
88     return denyBasedOnTableName(tableName);
89 }
90
91 int DatabaseAuthorizer::dropTempIndex(const String& indexName, const String& tableName)
92 {
93     return denyBasedOnTableName(tableName);
94 }
95
96 int DatabaseAuthorizer::createTrigger(const String& triggerName, const String& tableName)
97 {
98     m_lastActionIncreasedSize = true;
99     return denyBasedOnTableName(tableName);
100 }
101
102 int DatabaseAuthorizer::createTempTrigger(const String& triggerName, const String& tableName)
103 {
104     return denyBasedOnTableName(tableName);
105 }
106
107 int DatabaseAuthorizer::dropTrigger(const String& triggerName, const String& tableName)
108 {
109     return denyBasedOnTableName(tableName);
110 }
111
112 int DatabaseAuthorizer::dropTempTrigger(const String& triggerName, const String& tableName)
113 {
114     return denyBasedOnTableName(tableName);
115 }
116
117 int DatabaseAuthorizer::createVTable(const String& tableName, const String& moduleName)
118 {
119     m_lastActionIncreasedSize = true;
120     return m_securityEnabled ? SQLAuthDeny : SQLAuthAllow;
121 }
122
123 int DatabaseAuthorizer::dropVTable(const String& tableName, const String& moduleName)
124 {
125     return m_securityEnabled ? SQLAuthDeny : SQLAuthAllow;
126 }
127
128 int DatabaseAuthorizer::allowDelete(const String& tableName)
129 {
130     return denyBasedOnTableName(tableName);
131 }
132
133 int DatabaseAuthorizer::allowInsert(const String& tableName)
134 {
135     m_lastActionIncreasedSize = true;
136     m_lastActionWasInsert = true;
137     return denyBasedOnTableName(tableName);
138 }
139
140 int DatabaseAuthorizer::allowUpdate(const String& tableName, const String& columnName)
141 {
142     m_lastActionIncreasedSize = true;
143     return denyBasedOnTableName(tableName);
144 }
145
146 int DatabaseAuthorizer::allowTransaction()
147 {
148     return m_securityEnabled ? SQLAuthDeny : SQLAuthAllow;
149 }
150
151 int DatabaseAuthorizer::allowRead(const String& tableName, const String& columnName)
152 {
153     return denyBasedOnTableName(tableName);
154 }
155
156 int DatabaseAuthorizer::allowAnalyze(const String& tableName)
157 {
158     return denyBasedOnTableName(tableName);
159 }
160
161 int DatabaseAuthorizer::allowPragma(const String& pragmaName, const String& firstArgument)
162 {
163     return m_securityEnabled ? SQLAuthDeny : SQLAuthAllow;
164 }
165
166 int DatabaseAuthorizer::allowAttach(const String& filename)
167 {
168     return m_securityEnabled ? SQLAuthDeny : SQLAuthAllow;
169 }
170
171 int DatabaseAuthorizer::allowDetach(const String& databaseName)
172 {
173     return m_securityEnabled ? SQLAuthDeny : SQLAuthAllow;
174 }
175
176 int DatabaseAuthorizer::allowFunction(const String& functionName)
177 {
178     // FIXME: Are there any of these we need to prevent?  One might guess current_date, current_time, current_timestamp because
179     // they would violate the "sandbox environment" part of 4.11.3, but scripts can generate the local client side information via
180     // javascript directly, anyways.  Are there any other built-ins we need to be worried about?
181     return SQLAuthAllow;
182 }
183
184 void DatabaseAuthorizer::disable()
185 {
186     m_securityEnabled = false;
187 }
188
189 void DatabaseAuthorizer::enable()
190 {
191     m_securityEnabled = true;
192 }
193
194 int DatabaseAuthorizer::denyBasedOnTableName(const String& tableName)
195 {
196     if (!m_securityEnabled)
197         return SQLAuthAllow;
198
199     // Sadly, normal creates and drops end up affecting sqlite_master in an authorizer callback, so
200     // it will be tough to enforce all of the following policies
201     //if (equalIgnoringCase(tableName, "sqlite_master") || equalIgnoringCase(tableName, "sqlite_temp_master") ||
202     //    equalIgnoringCase(tableName, "sqlite_sequence") || equalIgnoringCase(tableName, Database::databaseInfoTableName()))
203     //        return SQLAuthDeny;
204
205     if (equalIgnoringCase(tableName, Database::databaseInfoTableName()))
206         return SQLAuthDeny;
207
208     return SQLAuthAllow;
209 }
210
211
212 } // namespace WebCore