65 #define TEST(arg) ::Check1((arg), __LINE__) |
68 #define TEST(arg) ::Check1((arg), __LINE__) |
66 #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__) |
69 #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__) |
67 |
70 |
68 /////////////////////////////////////////////////////////////////////////////////////// |
71 /////////////////////////////////////////////////////////////////////////////////////// |
69 |
72 |
|
73 RSqlSecurityPolicy CreateTestSecurityPolicy() |
|
74 { |
|
75 RSqlSecurityPolicy policy; |
|
76 TInt err = policy.Create(TSecurityPolicy::EAlwaysPass); |
|
77 TEST2(err, KErrNone); |
|
78 |
|
79 err = policy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, TSecurityPolicy::EAlwaysPass); |
|
80 TEST2(err, KErrNone); |
|
81 err = policy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, TSecurityPolicy::EAlwaysPass); |
|
82 TEST2(err, KErrNone); |
|
83 err = policy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, TSecurityPolicy::EAlwaysPass); |
|
84 TEST2(err, KErrNone); |
|
85 |
|
86 err = policy.SetPolicy(RSqlSecurityPolicy::ETable, _L("A"), RSqlSecurityPolicy::EWritePolicy, TSecurityPolicy::EAlwaysPass); |
|
87 TEST2(err, KErrNone); |
|
88 err = policy.SetPolicy(RSqlSecurityPolicy::ETable, _L("A"), RSqlSecurityPolicy::EReadPolicy, TSecurityPolicy::EAlwaysPass); |
|
89 TEST2(err, KErrNone); |
|
90 |
|
91 return policy; |
|
92 } |
|
93 |
70 enum TDbEncoding |
94 enum TDbEncoding |
71 { |
95 { |
72 EDbEncUtf16, |
96 EDbEncUtf16, |
73 EDbEncUtf8, |
97 EDbEncUtf8, |
74 }; |
98 }; |
75 |
99 |
76 void DoCorruptedSecureDbTest(TDbEncoding aEncoding) |
100 void DoCorruptedSecureDbTest(TDbEncoding aEncoding) |
77 { |
101 { |
78 (void)RSqlDatabase::Delete(KDbName); |
102 (void)RSqlDatabase::Delete(KDbName); |
79 |
103 |
80 RSqlSecurityPolicy policy; |
104 RSqlSecurityPolicy policy = CreateTestSecurityPolicy(); |
81 TInt err = policy.Create(TSecurityPolicy::EAlwaysPass); |
105 TInt err = KErrNone; |
82 TEST2(err, KErrNone); |
|
83 |
|
84 err = policy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, TSecurityPolicy::EAlwaysPass); |
|
85 TEST2(err, KErrNone); |
|
86 err = policy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, TSecurityPolicy::EAlwaysPass); |
|
87 TEST2(err, KErrNone); |
|
88 err = policy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, TSecurityPolicy::EAlwaysPass); |
|
89 TEST2(err, KErrNone); |
|
90 |
|
91 err = policy.SetPolicy(RSqlSecurityPolicy::ETable, _L("A"), RSqlSecurityPolicy::EWritePolicy, TSecurityPolicy::EAlwaysPass); |
|
92 TEST2(err, KErrNone); |
|
93 err = policy.SetPolicy(RSqlSecurityPolicy::ETable, _L("A"), RSqlSecurityPolicy::EReadPolicy, TSecurityPolicy::EAlwaysPass); |
|
94 TEST2(err, KErrNone); |
|
95 |
|
96 if(aEncoding == EDbEncUtf16) |
106 if(aEncoding == EDbEncUtf16) |
97 { |
107 { |
98 err = TheDb.Create(KDbName, policy); |
108 err = TheDb.Create(KDbName, policy); |
99 } |
109 } |
100 else |
110 else |
122 const TInt KCorruptBlockLen = 19; |
132 const TInt KCorruptBlockLen = 19; |
123 const TInt KIterationCnt = entry.iSize / KCorruptBlockLen; |
133 const TInt KIterationCnt = entry.iSize / KCorruptBlockLen; |
124 // |
134 // |
125 TBuf8<KCorruptBlockLen> invalidData; |
135 TBuf8<KCorruptBlockLen> invalidData; |
126 invalidData.SetLength(KCorruptBlockLen); |
136 invalidData.SetLength(KCorruptBlockLen); |
127 invalidData.Fill(TChar(0xCC)); |
137 TChar invalidChar[] = {TChar((TUint)0xCC), TChar(0x00), TChar((TUint)-1), TChar(0x1D)}; |
128 // |
138 for(TInt j=0;j<(sizeof(invalidChar)/sizeof(invalidChar[0]));++j) |
129 for(TInt i=0;i<KIterationCnt;++i) |
139 { |
130 { |
140 invalidData.Fill(invalidChar[j]); |
131 TheTest.Printf(_L("% 4d\r"), i + 1); |
141 TheTest.Printf(_L("Invalid char: %X\r\n"), (TUint)(invalidChar[j])); |
132 //Corrupt the database |
142 for(TInt i=0;i<KIterationCnt;++i) |
133 err = fm->Copy(KFullDbName2, KFullDbName); |
|
134 TEST2(err, KErrNone); |
|
135 RFile file; |
|
136 err = file.Open(TheFs, KFullDbName, EFileRead | EFileWrite); |
|
137 TEST2(err, KErrNone); |
|
138 err = file.Write(i * KCorruptBlockLen, invalidData); |
|
139 TEST2(err, KErrNone); |
|
140 file.Close(); |
|
141 //Try to open the database and read the record |
|
142 TBool testPassed = EFalse; |
|
143 err = TheDb.Open(KDbName); |
|
144 if(err == KErrNone) |
|
145 { |
143 { |
146 RSqlStatement stmt; |
144 TheTest.Printf(_L("% 4d\r"), i + 1); |
147 err = stmt.Prepare(TheDb, _L("SELECT I FROM A")); |
145 //Corrupt the database |
|
146 err = fm->Copy(KFullDbName2, KFullDbName); |
|
147 TEST2(err, KErrNone); |
|
148 RFile file; |
|
149 err = file.Open(TheFs, KFullDbName, EFileRead | EFileWrite); |
|
150 TEST2(err, KErrNone); |
|
151 TInt fpos = i * KCorruptBlockLen; |
|
152 err = file.Write(fpos, invalidData); |
|
153 TEST2(err, KErrNone); |
|
154 file.Close(); |
|
155 //Try to open the database and read the record |
|
156 TBool testPassed = EFalse; |
|
157 err = TheDb.Open(KDbName); |
148 if(err == KErrNone) |
158 if(err == KErrNone) |
149 { |
159 { |
150 err = stmt.Next(); |
160 RSqlStatement stmt; |
151 if(err == KSqlAtRow) |
161 err = stmt.Prepare(TheDb, _L("SELECT I FROM A")); |
|
162 if(err == KErrNone) |
152 { |
163 { |
153 TInt val = stmt.ColumnInt(0); |
164 err = stmt.Next(); |
154 if(val == 10) |
165 if(err == KSqlAtRow) |
155 { |
166 { |
156 testPassed = ETrue; |
167 TInt val = stmt.ColumnInt(0); |
157 err = KErrNone; |
168 if(val == 10) |
|
169 { |
|
170 testPassed = ETrue; |
|
171 err = KErrNone; |
|
172 } |
|
173 else |
|
174 { |
|
175 err = KErrGeneral; |
|
176 } |
158 } |
177 } |
159 else |
178 stmt.Close(); |
160 { |
|
161 err = KErrGeneral; |
|
162 } |
|
163 } |
179 } |
164 stmt.Close(); |
|
165 } |
180 } |
166 } |
181 |
167 |
182 TheDb.Close(); |
168 TheDb.Close(); |
183 (void)RSqlDatabase::Delete(KDbName); |
169 (void)RSqlDatabase::Delete(KDbName); |
184 TheTest.Printf(_L("Iteration % 4d, err=%d\r\n"), i + 1, err); |
170 TheTest.Printf(_L("Iteration % 4d, err=%d\r\n"), i + 1, err); |
185 if(!testPassed) |
171 if(!testPassed) |
186 { |
172 { |
187 TEST(err != KErrNone); |
173 TEST(err != KErrNone); |
188 } |
174 } |
189 }//end of - for(TInt i=0;i<KIterationCnt;++i) |
175 }//end of - for(TInt i=0;i<KIterationCnt;++i) |
190 TheTest.Printf(_L("\r\n")); |
176 |
191 } |
|
192 (void)fm->Delete(KFullDbName2); |
177 delete fm; |
193 delete fm; |
178 TheTest.Printf(_L("\r\n")); |
|
179 } |
194 } |
180 |
195 |
181 /** |
196 /** |
182 @SYMTestCaseID PDS-SQL-CT-4202 |
197 @SYMTestCaseID PDS-SQL-CT-4202 |
183 @SYMTestCaseDesc Invalid UTF16 encoded secure database test. |
198 @SYMTestCaseDesc Invalid UTF16 encoded secure database test. |
206 void CorruptedSecureDbTest8() |
221 void CorruptedSecureDbTest8() |
207 { |
222 { |
208 DoCorruptedSecureDbTest(EDbEncUtf8); |
223 DoCorruptedSecureDbTest(EDbEncUtf8); |
209 } |
224 } |
210 |
225 |
|
226 const TInt KDbPolicyTypeTooSmall = 1; |
|
227 const TInt KDbPolicyTypeTooBig = 2; |
|
228 const TInt KDefaultPolicyWithObjName = 3; |
|
229 const TInt KDbPolicyWithObjName = 4; |
|
230 const TInt KInvObjPolicyWithObjName = 5; |
|
231 const TInt KDefaultPolicyMoved = 6; |
|
232 const TInt KDuplicatedDbPolicy = 7; |
|
233 const TInt KTablePolicyTypeTooSmall = 8; |
|
234 const TInt KTablePolicyTypeTooBig = 9; |
|
235 const TInt KTablePolicyNameInvalid = 10; |
|
236 const TInt KTwoDefaultPolicies = 11; |
|
237 |
|
238 void CorruptDbPolicy(TInt aType) |
|
239 { |
|
240 TBuf8<200> dbName; |
|
241 dbName.Copy(KFullDbName()); |
|
242 sqlite3* dbHandle = NULL; |
|
243 TInt err = sqlite3_open((const char*)(dbName.PtrZ()), &dbHandle); |
|
244 TEST2(err, SQLITE_OK); |
|
245 switch(aType) |
|
246 { |
|
247 case KDbPolicyTypeTooSmall: //Invalid database poicy type - less than the schema policy type |
|
248 err = sqlite3_exec(dbHandle, "UPDATE symbian_security SET PolicyType=-10 WHERE ObjectType=-1 AND PolicyType=0", NULL, 0, NULL); |
|
249 TEST2(err, SQLITE_OK); |
|
250 break; |
|
251 case KDbPolicyTypeTooBig: //Invalid database poicy type - bigger than the write policy type |
|
252 err = sqlite3_exec(dbHandle, "UPDATE symbian_security SET PolicyType=10 WHERE ObjectType=-1 AND PolicyType=0", NULL, 0, NULL); |
|
253 TEST2(err, SQLITE_OK); |
|
254 break; |
|
255 case KDefaultPolicyWithObjName: //Default database policy with valid object name |
|
256 err = sqlite3_exec(dbHandle, "UPDATE symbian_security SET ObjectName='aaaa' WHERE ObjectType=-2", NULL, 0, NULL); |
|
257 TEST2(err, SQLITE_OK); |
|
258 break; |
|
259 case KDbPolicyWithObjName: //Database policy with valid object name |
|
260 err = sqlite3_exec(dbHandle, "UPDATE symbian_security SET ObjectName='aaaa' WHERE ObjectType=-1", NULL, 0, NULL); |
|
261 TEST2(err, SQLITE_OK); |
|
262 break; |
|
263 case KInvObjPolicyWithObjName: //Invalid object type is with valid object name |
|
264 err = sqlite3_exec(dbHandle, "UPDATE symbian_security SET ObjectType=5, ObjectName='aaaa' WHERE ObjectType=0", NULL, 0, NULL); |
|
265 TEST2(err, SQLITE_OK); |
|
266 break; |
|
267 case KDefaultPolicyMoved: //The default security policy is the last in the table |
|
268 err = sqlite3_exec(dbHandle, "DELETE FROM symbian_security WHERE ObjectType=-2", NULL, 0, NULL); |
|
269 TEST2(err, SQLITE_OK); |
|
270 err = sqlite3_exec(dbHandle, "INSERT INTO symbian_security VALUES(20,-2,'',0, x'1122334455667788')", NULL, 0, NULL); |
|
271 TEST2(err, SQLITE_OK); |
|
272 break; |
|
273 case KDuplicatedDbPolicy: //Two database policies of the same type |
|
274 err = sqlite3_exec(dbHandle, "INSERT INTO symbian_security VALUES(9,-1,'',1, x'1122334455667788')", NULL, 0, NULL); |
|
275 TEST2(err, SQLITE_OK); |
|
276 break; |
|
277 case KTablePolicyTypeTooSmall: //Invalid table poicy type - less than the read policy type |
|
278 err = sqlite3_exec(dbHandle, "UPDATE symbian_security SET PolicyType=-10 WHERE ObjectType=0 AND PolicyType=1", NULL, 0, NULL); |
|
279 TEST2(err, SQLITE_OK); |
|
280 break; |
|
281 case KTablePolicyTypeTooBig: //Invalid table poicy type - less than the write policy type |
|
282 err = sqlite3_exec(dbHandle, "UPDATE symbian_security SET PolicyType=10 WHERE ObjectType=0 AND PolicyType=2", NULL, 0, NULL); |
|
283 TEST2(err, SQLITE_OK); |
|
284 break; |
|
285 case KTablePolicyNameInvalid: |
|
286 err = sqlite3_exec(dbHandle, "UPDATE symbian_security SET ObjectName='' WHERE ObjectType=0 AND PolicyType=2", NULL, 0, NULL); |
|
287 TEST2(err, SQLITE_OK); |
|
288 break; |
|
289 case KTwoDefaultPolicies: |
|
290 err = sqlite3_exec(dbHandle, "INSERT INTO symbian_security VALUES(9,-2,'',1, x'1122334455667788')", NULL, 0, NULL); |
|
291 TEST2(err, SQLITE_OK); |
|
292 break; |
|
293 default: |
|
294 TEST(0); |
|
295 break; |
|
296 } |
|
297 sqlite3_close(dbHandle); |
|
298 } |
|
299 |
|
300 /** |
|
301 @SYMTestCaseID PDS-SQL-CT-4240 |
|
302 @SYMTestCaseDesc Invalid settings in symbian_security table. |
|
303 @SYMTestPriority High |
|
304 @SYMTestActions The test creates a secure test database. Then the test runs a set of test |
|
305 iterations. On each itertaion the test makes onle of the stored security |
|
306 policies invalied (symbian_security table). Then the test attempts to open |
|
307 the database and checks the behaviour of the SQL server - whether an error |
|
308 will be reproted back or not. |
|
309 @SYMTestExpectedResults Test must not fail |
|
310 */ |
|
311 void BadDbPolicyTest() |
|
312 { |
|
313 sqlite3SymbianLibInit(); |
|
314 |
|
315 RSqlSecurityPolicy policy = CreateTestSecurityPolicy(); |
|
316 // |
|
317 (void)RSqlDatabase::Delete(KDbName); |
|
318 TInt err = TheDb.Create(KDbName, policy); |
|
319 TEST2(err, KErrNone); |
|
320 err = TheDb.Exec(_L("CREATE TABLE A(I INTEGER); INSERT INTO A VALUES(10)")); |
|
321 TEST(err >= 0); |
|
322 TheDb.Close(); |
|
323 policy.Close(); |
|
324 // |
|
325 CFileMan* fm = NULL; |
|
326 TRAP(err, fm = CFileMan::NewL(TheFs)); |
|
327 TEST2(err, KErrNone); |
|
328 //Make a copy of the database |
|
329 err = fm->Copy(KFullDbName, KFullDbName2); |
|
330 TEST2(err, KErrNone); |
|
331 //Invalid database policy - policy type value less than the schema policy type value |
|
332 CorruptDbPolicy(KDbPolicyTypeTooSmall); |
|
333 err = TheDb.Open(KDbName); |
|
334 TheDb.Close(); |
|
335 TEST2(err, KErrGeneral); |
|
336 err = fm->Copy(KFullDbName2, KFullDbName); |
|
337 TEST2(err, KErrNone); |
|
338 //Invalid database policy - policy type value bigger than the write policy type value |
|
339 CorruptDbPolicy(KDbPolicyTypeTooBig); |
|
340 err = TheDb.Open(KDbName); |
|
341 TheDb.Close(); |
|
342 TEST2(err, KErrGeneral); |
|
343 err = fm->Copy(KFullDbName2, KFullDbName); |
|
344 TEST2(err, KErrNone); |
|
345 //Invalid database policy - the default database policy is with valid object name |
|
346 CorruptDbPolicy(KDefaultPolicyWithObjName); |
|
347 err = TheDb.Open(KDbName); |
|
348 TheDb.Close(); |
|
349 TEST2(err, KErrNone); |
|
350 err = fm->Copy(KFullDbName2, KFullDbName); |
|
351 TEST2(err, KErrNone); |
|
352 //Invalid database policy - database policy is with valid object name |
|
353 CorruptDbPolicy(KDbPolicyWithObjName); |
|
354 err = TheDb.Open(KDbName); |
|
355 TheDb.Close(); |
|
356 TEST2(err, KErrNone); |
|
357 err = fm->Copy(KFullDbName2, KFullDbName); |
|
358 TEST2(err, KErrNone); |
|
359 //Invalid database policy - invalid object type is with valid object name |
|
360 CorruptDbPolicy(KInvObjPolicyWithObjName); |
|
361 err = TheDb.Open(KDbName); |
|
362 TheDb.Close(); |
|
363 TEST2(err, KErrGeneral); |
|
364 err = fm->Copy(KFullDbName2, KFullDbName); |
|
365 TEST2(err, KErrNone); |
|
366 //Invalid database policy - the default security policy is the last in the table |
|
367 CorruptDbPolicy(KDefaultPolicyMoved); |
|
368 err = TheDb.Open(KDbName); |
|
369 TheDb.Close(); |
|
370 TEST2(err, KErrNone); |
|
371 err = fm->Copy(KFullDbName2, KFullDbName); |
|
372 TEST2(err, KErrNone); |
|
373 //Invalid database policy - duplicated database policy |
|
374 CorruptDbPolicy(KDuplicatedDbPolicy); |
|
375 err = TheDb.Open(KDbName); |
|
376 TheDb.Close(); |
|
377 TEST2(err, KErrGeneral); |
|
378 err = fm->Copy(KFullDbName2, KFullDbName); |
|
379 TEST2(err, KErrNone); |
|
380 //Invalid table policy - policy type value less than the read policy type value |
|
381 CorruptDbPolicy(KTablePolicyTypeTooSmall); |
|
382 err = TheDb.Open(KDbName); |
|
383 TheDb.Close(); |
|
384 TEST2(err, KErrGeneral); |
|
385 err = fm->Copy(KFullDbName2, KFullDbName); |
|
386 TEST2(err, KErrNone); |
|
387 //Invalid table policy - policy type value bigger than the write policy type value |
|
388 CorruptDbPolicy(KTablePolicyTypeTooBig); |
|
389 err = TheDb.Open(KDbName); |
|
390 TheDb.Close(); |
|
391 TEST2(err, KErrGeneral); |
|
392 err = fm->Copy(KFullDbName2, KFullDbName); |
|
393 TEST2(err, KErrNone); |
|
394 //Invalid table policy - emtpy string as a table name |
|
395 CorruptDbPolicy(KTablePolicyNameInvalid); |
|
396 err = TheDb.Open(KDbName); |
|
397 TheDb.Close(); |
|
398 TEST2(err, KErrGeneral); |
|
399 err = fm->Copy(KFullDbName2, KFullDbName); |
|
400 TEST2(err, KErrNone); |
|
401 //Two default policies |
|
402 CorruptDbPolicy(KTwoDefaultPolicies); |
|
403 err = TheDb.Open(KDbName); |
|
404 TheDb.Close(); |
|
405 TEST2(err, KErrGeneral); |
|
406 err = fm->Copy(KFullDbName2, KFullDbName); |
|
407 TEST2(err, KErrNone); |
|
408 // |
|
409 (void)RSqlDatabase::Delete(KDbName); |
|
410 (void)fm->Delete(KFullDbName2); |
|
411 delete fm; |
|
412 |
|
413 sqlite3SymbianLibFinalize(); |
|
414 CloseSTDLIB(); |
|
415 } |
|
416 |
|
417 |
211 void CreateTestEnv() |
418 void CreateTestEnv() |
212 { |
419 { |
213 TInt err = TheFs.Connect(); |
420 TInt err = TheFs.Connect(); |
214 TEST2(err, KErrNone); |
421 TEST2(err, KErrNone); |
215 |
422 |