diff -r 000000000000 -r 08ec8eefde2f persistentstorage/sql/TEST/t_sqlsecurity1.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/persistentstorage/sql/TEST/t_sqlsecurity1.cpp Fri Jan 22 11:06:30 2010 +0200 @@ -0,0 +1,557 @@ +// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include +#include +#include + +/////////////////////////////////////////////////////////////////////////////////////// + +#define UNUSED_VAR(a) (a) = (a) + +RTest TheTest(_L("t_sqlsecurity1 test")); + +_LIT(KTestDir, "c:\\test\\"); +_LIT(KTestDbName, "c:[98765432]t_sqlsecurity1_1.db"); +_LIT(KTestDbName2, "c:\\test\\t_sqlsecurity1_2.db"); +_LIT(KTestDbName3, "c:[98765432]t_sqlsecurity1_3.db"); +_LIT(KTestDbName4, "c:\\private\\98765432\\t_sqlsecurity1_4.db"); +_LIT(KTestDbName5, "|00110022|33005500|c:"); +_LIT(KTestFile, "c:\\test\\policy.strm"); + +_LIT(KDb1, "C:[98765432]t_nosettings.db"); +_LIT(KDb2, "C:[98765432]t_emptysettings.db"); +_LIT(KDb3, "C:[98765432]t_invversion.db"); +_LIT(KDb4, "C:[98765432]t_nocollation.db"); +_LIT(KDb5, "C:[98765432]t_longcollation.db"); +_LIT(KDb6, "C:[98765432]t_nodefaultpolicy.db"); +_LIT(KDb7, "C:[98765432]t_invobject.db"); +_LIT(KDb8, "C:[98765432]t_2defaultpolicies.db"); + +const TSecurityPolicy KDefaultPolicy(ECapabilityDRM); +const TSecurityPolicy KPolicy1(ECapabilityTrustedUI, ECapabilityDiskAdmin); +const TSecurityPolicy KPolicy2(ECapabilityNetworkControl, ECapabilityPowerMgmt, ECapabilityCommDD); +const TSecurityPolicy KPolicy3(ECapabilityTCB, ECapabilityWriteUserData, ECapabilityUserEnvironment); + +_LIT(KTableName1, "A-tbl"); +_LIT(KTableName2, "B-table"); +_LIT(KTableName3, "T-CCCCCCCCCCCCCC"); +_LIT(KTableName11, "A-TBL"); + +RFs TheFs; + +/////////////////////////////////////////////////////////////////////////////////////// + +void DeleteTestFiles() + { + (void)TheFs.Delete(KTestFile); + (void)RSqlDatabase::Delete(KTestDbName4); + (void)RSqlDatabase::Delete(KTestDbName3); + (void)RSqlDatabase::Delete(KTestDbName2); + (void)RSqlDatabase::Delete(KTestDbName); + } + +/////////////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////////////// +//Test macros and functions +void Check1(TInt aValue, TInt aLine, TBool aPrintThreadName = EFalse) + { + if(!aValue) + { + DeleteTestFiles(); + if(aPrintThreadName) + { + RThread th; + TName name = th.Name(); + RDebug::Print(_L("*** Thread %S, Line %d\r\n"), &name, aLine); + } + else + { + RDebug::Print(_L("*** Line %d\r\n"), aLine); + } + TheTest(EFalse, aLine); + } + } +void Check2(TInt aValue, TInt aExpected, TInt aLine, TBool aPrintThreadName = EFalse) + { + if(aValue != aExpected) + { + DeleteTestFiles(); + if(aPrintThreadName) + { + RThread th; + TName name = th.Name(); + RDebug::Print(_L("*** Thread %S, Line %d Expected error: %d, got: %d\r\n"), &name, aLine, aExpected, aValue); + } + else + { + RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue); + } + TheTest(EFalse, aLine); + } + } +#define TEST(arg) ::Check1((arg), __LINE__) +#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__) +#define TTEST(arg) ::Check1((arg), __LINE__, ETrue) +#define TTEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__, ETrue) + +/////////////////////////////////////////////////////////////////////////////////////// + +void CreateTestEnv() + { + TInt err = TheFs.Connect(); + TEST2(err, KErrNone); + + err = TheFs.MkDir(KTestDir); + TEST(err == KErrNone || err == KErrAlreadyExists); + + err = TheFs.CreatePrivatePath(EDriveC); + TEST(err == KErrNone || err == KErrAlreadyExists); + } + +/////////////////////////////////////////////////////////////////////////////////////// + +TBool operator==(const TSecurityPolicy& aLeft, const TSecurityPolicy& aRight) + { + return aLeft.Package() == aRight.Package(); + } + +void CreateTestSecurityPolicy(RSqlSecurityPolicy& aSecurityPolicy) + { + TInt err = aSecurityPolicy.Create(KDefaultPolicy); + TEST2(err, KErrNone); + + err = aSecurityPolicy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, KPolicy1); + TEST2(err, KErrNone); + err = aSecurityPolicy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, KPolicy3); + TEST2(err, KErrNone); + + err = aSecurityPolicy.SetPolicy(RSqlSecurityPolicy::ETable, KTableName1, RSqlSecurityPolicy::EReadPolicy, KPolicy1); + TEST2(err, KErrNone); + err = aSecurityPolicy.SetPolicy(RSqlSecurityPolicy::ETable, KTableName1, RSqlSecurityPolicy::EWritePolicy, KPolicy2); + TEST2(err, KErrNone); + + err = aSecurityPolicy.SetPolicy(RSqlSecurityPolicy::ETable, KTableName2, RSqlSecurityPolicy::EReadPolicy, KPolicy1); + TEST2(err, KErrNone); + err = aSecurityPolicy.SetPolicy(RSqlSecurityPolicy::ETable, KTableName3, RSqlSecurityPolicy::EReadPolicy, KPolicy2); + TEST2(err, KErrNone); + + err = aSecurityPolicy.SetPolicy(RSqlSecurityPolicy::ETable, KTableName2, RSqlSecurityPolicy::EWritePolicy, KPolicy1); + TEST2(err, KErrNone); + + err = aSecurityPolicy.SetPolicy(RSqlSecurityPolicy::ETable, KTableName3, RSqlSecurityPolicy::EWritePolicy, KPolicy3); + TEST2(err, KErrNone); + } + +void CheckTestSecurityPolicy(const RSqlSecurityPolicy& aSecurityPolicy) + { + //Database policies + TSecurityPolicy policy = aSecurityPolicy.DbPolicy(RSqlSecurityPolicy::ESchemaPolicy); + TEST(policy == KPolicy1); + policy = aSecurityPolicy.DbPolicy(RSqlSecurityPolicy::EReadPolicy); + TEST(policy == KDefaultPolicy); + policy = aSecurityPolicy.DbPolicy(RSqlSecurityPolicy::EWritePolicy); + TEST(policy == KPolicy3); + //Table policies + policy = aSecurityPolicy.Policy(RSqlSecurityPolicy::ETable, KTableName11, RSqlSecurityPolicy::EReadPolicy); + TEST(policy == KPolicy1); + policy = aSecurityPolicy.Policy(RSqlSecurityPolicy::ETable, KTableName2, RSqlSecurityPolicy::EReadPolicy); + TEST(policy == KPolicy1); + policy = aSecurityPolicy.Policy(RSqlSecurityPolicy::ETable, KTableName3, RSqlSecurityPolicy::EReadPolicy); + TEST(policy == KPolicy2); + policy = aSecurityPolicy.Policy(RSqlSecurityPolicy::ETable, KTableName1, RSqlSecurityPolicy::EWritePolicy); + TEST(policy == KPolicy2); + policy = aSecurityPolicy.Policy(RSqlSecurityPolicy::ETable, KTableName3, RSqlSecurityPolicy::EWritePolicy); + TEST(policy == KPolicy3); + policy = aSecurityPolicy.Policy(RSqlSecurityPolicy::ETable, KTableName2, RSqlSecurityPolicy::EWritePolicy); + TEST(policy == KPolicy1); + } + +/** +@SYMTestCaseID SYSLIB-SQL-CT-1635 +@SYMTestCaseDesc RSqlSecurityPolicy test. + Tests RSqlSecurityPolicy API. +@SYMTestPriority High +@SYMTestActions RSqlSecurityPolicy test. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ5792 + REQ5793 +*/ +void SqlSecurityPolicyTest() + { + RSqlSecurityPolicy securityPolicy; + TInt err = securityPolicy.Create(KDefaultPolicy); + TEST2(err, KErrNone); + + //Empty RSqlSecurityPolicy object tests + //Database policies + TSecurityPolicy policy = securityPolicy.DbPolicy(RSqlSecurityPolicy::ESchemaPolicy); + TEST(policy == KDefaultPolicy); + policy = securityPolicy.DbPolicy(RSqlSecurityPolicy::EReadPolicy); + TEST(policy == KDefaultPolicy); + policy = securityPolicy.DbPolicy(RSqlSecurityPolicy::EWritePolicy); + TEST(policy == KDefaultPolicy); + //Table policies + policy = securityPolicy.Policy(RSqlSecurityPolicy::ETable, _L("A-Tbl"), RSqlSecurityPolicy::EReadPolicy); + TEST(policy == KDefaultPolicy); + policy = securityPolicy.Policy(RSqlSecurityPolicy::ETable, _L("B-Tbl"), RSqlSecurityPolicy::EWritePolicy); + TEST(policy == KDefaultPolicy); + // + securityPolicy.Close(); + + //Tests with initialized RSqlSecurityPolicy object + CreateTestSecurityPolicy(securityPolicy); + //Check the created and initialized object + CheckTestSecurityPolicy(securityPolicy); + + //Externalize, then internalize and check the security policy object + RFileWriteStream out; + err = out.Replace(TheFs, KTestFile, EFileRead | EFileWrite); + TEST2(err, KErrNone); + TRAP(err, securityPolicy.ExternalizeL(out)); + TEST2(err, KErrNone); + TRAP(err, out.CommitL()); + out.Close(); + TEST2(err, KErrNone); + + securityPolicy.Close(); + err = securityPolicy.Create(KDefaultPolicy); + TEST2(err, KErrNone); + RFileReadStream in; + err = in.Open(TheFs, KTestFile, EFileRead); + TEST2(err, KErrNone); + TRAP(err, securityPolicy.InternalizeL(in)); + in.Close(); + TEST2(err, KErrNone); + CheckTestSecurityPolicy(securityPolicy); + + //Change some security policies and check that the RqlSecurityPolicy content was properly updated + err = securityPolicy.SetPolicy(RSqlSecurityPolicy::ETable, KTableName11, RSqlSecurityPolicy::EReadPolicy, KPolicy3); + TEST2(err, KErrNone); + policy = securityPolicy.Policy(RSqlSecurityPolicy::ETable, KTableName1, RSqlSecurityPolicy::EReadPolicy); + TEST(policy == KPolicy3); + policy = securityPolicy.Policy(RSqlSecurityPolicy::ETable, KTableName11, RSqlSecurityPolicy::EWritePolicy); + TEST(policy == KPolicy2); + // + securityPolicy.Close(); + } + +/** +@SYMTestCaseID SYSLIB-SQL-CT-1637 +@SYMTestCaseDesc RSqlDatabase::Create() test. + Tests RSqlDatabase::Create() call when the request is for creation of a secure database. +@SYMTestPriority High +@SYMTestActions RSqlDatabase::Create() test. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ5792 + REQ5793 +*/ +void CreateSecureDatabaseTest() + { + RSqlSecurityPolicy securityPolicy; + + //Create and initialize RSqlSecurityPolicy object. + CreateTestSecurityPolicy(securityPolicy); + + //Create secure database using the data from securityPolicy object. + RSqlDatabase db; + TInt err = db.Create(KTestDbName, securityPolicy); + TEST2(err, KErrNone); + securityPolicy.Close(); + + //Check that the database security policy matches the policy used when the database was created. + err = db.GetSecurityPolicy(securityPolicy); + TEST2(err, KErrNone); + CheckTestSecurityPolicy(securityPolicy); + securityPolicy.Close(); + + db.Close(); + + //Reopen the database and check the security policies + err = db.Open(KTestDbName); + TEST2(err, KErrNone); + + //Check that the database security policy matches the policy used when the database was created. + err = db.GetSecurityPolicy(securityPolicy); + TEST2(err, KErrNone); + CheckTestSecurityPolicy(securityPolicy); + securityPolicy.Close(); + + db.Close(); + + err = RSqlDatabase::Delete(KTestDbName); + TEST2(err, KErrNone); + + //An attempt to create a secure database specifying the full database path + CreateTestSecurityPolicy(securityPolicy); + err = db.Create(KTestDbName2, securityPolicy); + securityPolicy.Close(); + TEST2(err, KErrArgument); + + //An attempt to create a non-secure database formatting the database file name as + err = db.Create(KTestDbName); + TEST2(err, KErrArgument); + } + +/** +@SYMTestCaseID SYSLIB-SQL-CT-1643 +@SYMTestCaseDesc SQL server private path in database file name test. + Verify that SQL API returns appropriate error, if an attempt is made to create, open + or delete a secure database, with the full path specified in the database file name. +@SYMTestPriority High +@SYMTestActions SQL server private path in database file name test. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ5792 + REQ5793 +*/ +void PrivatePathTest() + { + RSqlSecurityPolicy securityPolicy; + CreateTestSecurityPolicy(securityPolicy); + + RSqlDatabase db; + + TInt err = db.Create(_L("C:\\PrIVATE\\10281E17\\[98765432]A.DB"), securityPolicy); + TEST2(err, KErrArgument); + err = db.Create(_L("C:\\PRIVATE\\10281E17\\[98765432]A.DB")); + TEST2(err, KErrArgument); + err = db.Open(_L("C:\\PRIVATE\\10281E17\\[98765432]A.DB")); + TEST2(err, KErrArgument); + err = db.Open(_L("C:\\PRIvaTe\\10281E17\\[98765432]A.DB")); + TEST2(err, KErrArgument); + + err = db.Create(KTestDbName2); + TEST2(err, KErrNone); + err = db.Attach(_L("C:\\PRIVATe\\10281E17\\[98765432]A.DB"), _L("Db")); + TEST2(err, KErrArgument); + err = db.Attach(_L("C:\\PRIVAtE\\10281E17\\[98765432]A.DB"), _L("Db")); + TEST2(err, KErrArgument); + //This is an attempt to attach a database from the application's private data cage + err = db.Attach(KTestDbName4, _L("Db")); + TEST2(err, KErrNotFound);//There is no "Db" database file in the application's private data cage + db.Close(); + + err = RSqlDatabase::Delete(_L("C:\\pRIVATE\\10281E17\\[98765432]A.DB")); + TEST2(err, KErrArgument); + err = RSqlDatabase::Delete(_L("C:\\PRIvATE\\10281E17\\[98765432]A.DB")); + TEST2(err, KErrArgument); + + //This is an attempt to create a database in the application's private data cage + err = db.Create(KTestDbName4); + TEST2(err, KErrNone); + db.Close(); + err = RSqlDatabase::Delete(KTestDbName4); + TEST2(err, KErrNone); + + err = db.Create(KTestDbName5); + TEST2(err, KErrArgument); + + securityPolicy.Close(); + } + +//This test is here to check that the construction of the second database object on the server side passes +//without problems, if there is already one other secure database object (authorizer callback possible problems +//during the construction phase) +//Shortly: the test checks how the construction of the secure database object 2 might be influenced by +// the already existing secure database object 1. +void TwoSecureDbTest() + { + RSqlSecurityPolicy securityPolicy; + CreateTestSecurityPolicy(securityPolicy); + + RSqlDatabase db1; + TInt err = db1.Create(KTestDbName, securityPolicy); + TEST2(err, KErrNone); + + RSqlDatabase db2; + err = db2.Create(KTestDbName3, securityPolicy); + TEST2(err, KErrNone); + + securityPolicy.Close(); + db2.Close(); + db1.Close(); + } + +/** +@SYMTestCaseID SYSLIB-SQL-UT-3508 +@SYMTestCaseDesc Test for DEF109100: SQL, code coverage for TSqlDbSysSettings is low. + The test attempts to create a secure shared database with a security policy + specified for the system tables, which is not allowed. +@SYMTestPriority High +@SYMTestActions Test for DEF109100: SQL, code coverage for TSqlDbSysSettings is low. +@SYMTestExpectedResults Test must not fail +@SYMDEF DEF109100 +*/ +void StoreSysTableSecurityPolicyTest() + { + _LIT(KSecurityTable, "symbian_security"); + _LIT(KSettingsTable, "symbian_settings"); + + //Case 1: "symbian_security" table + RSqlSecurityPolicy sp; + TInt err = sp.Create(KDefaultPolicy); + TEST2(err, KErrNone); + err = sp.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, KPolicy1); + TEST2(err, KErrNone); + err = sp.SetPolicy(RSqlSecurityPolicy::ETable, KSecurityTable, RSqlSecurityPolicy::EReadPolicy, KPolicy1); + TEST2(err, KErrNone); + (void)RSqlDatabase::Delete(KTestDbName); + RSqlDatabase db; + err = db.Create(KTestDbName, sp); + TEST2(err, KErrArgument); + sp.Close(); + + //Case 2: "symbian_settings" table + err = sp.Create(KDefaultPolicy); + TEST2(err, KErrNone); + err = sp.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, KPolicy1); + TEST2(err, KErrNone); + err = sp.SetPolicy(RSqlSecurityPolicy::ETable, KSettingsTable, RSqlSecurityPolicy::EReadPolicy, KPolicy1); + TEST2(err, KErrNone); + err = RSqlDatabase::Delete(KTestDbName); + TEST2(err, KErrNotFound); + err = db.Create(KTestDbName, sp); + TEST2(err, KErrArgument); + sp.Close(); + + err = RSqlDatabase::Delete(KTestDbName); + TEST2(err, KErrNotFound); + } + +/** +@SYMTestCaseID SYSLIB-SQL-UT-3509 +@SYMTestCaseDesc Test for DEF109100: SQL, code coverage for TSqlDbSysSettings is low. + The test has 5 sub-cases, where the test attempts to open + a secure shared database with: + - no settings table; + - empty settings table; + - invalid version number of the settings; + - NULL collation dll name, stored in the settings; + - too long collation dll name, stored in the settings; +@SYMTestPriority High +@SYMTestActions Test for DEF109100: SQL, code coverage for TSqlDbSysSettings is low. +@SYMTestExpectedResults Test must not fail +@SYMDEF DEF109100 +*/ +void LoadSysSettingsTest() + { + //Case 1: no "symbian_settings" table. No error returned, because the table is recreated. + RSqlDatabase db; + TInt err = db.Open(KDb1); + TEST2(err, KErrNone); + db.Close(); + + //Case 2: "symbian_settings" table is empty. + err = db.Open(KDb2); + TEST2(err, KErrGeneral); + db.Close(); + + //Case 3: Invalid version number in "symbian_settings" table. + err = db.Open(KDb3); + TEST2(err, KErrGeneral); + db.Close(); + + //Case 4: NULL collation dll name in "symbian_settings" table. + err = db.Open(KDb4); + TEST2(err, KErrGeneral); + db.Close(); + + //Case 5: Too long collation dll name in "symbian_settings" table. + err = db.Open(KDb5); + TEST2(err, KErrOverflow); + db.Close(); + } + +/** +@SYMTestCaseID SYSLIB-SQL-UT-3510 +@SYMTestCaseDesc Test for DEF109100: SQL, code coverage for TSqlDbSysSettings is low. + The test has 3 sub-cases, where the test attempts to open + a secure shared database with: + - missing default policy in the security policy table; + - invalid database object type in the security policy table; + - 2 default policies in the security policy table; +@SYMTestPriority High +@SYMTestActions Test for DEF109100: SQL, code coverage for TSqlDbSysSettings is low. +@SYMTestExpectedResults Test must not fail +@SYMDEF DEF109100 +*/ +void LoadSecurityPolicyTest() + { + //Case 1: missing default policy. + RSqlDatabase db; + TInt err = db.Open(KDb6); + TEST2(err, KErrGeneral); + db.Close(); + + //Case 2: invalid database object type. + err = db.Open(KDb7); + TEST2(err, KErrGeneral); + db.Close(); + + //Case 3: 2 default policies. + err = db.Open(KDb8); + TEST2(err, KErrGeneral); + db.Close(); + } + +void DoTests() + { + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1635 RSqlSecurityPolicy test ")); + SqlSecurityPolicyTest(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1637 Create secure database test ")); + CreateSecureDatabaseTest(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1643 Sql server private path in the file name test ")); + PrivatePathTest(); + + TheTest.Next(_L("Two secure databases at the same time test")); + TwoSecureDbTest(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3508 DEF109100 - 1 - SQL, code coverage for TSqlBufRIterator,TSqlAttachDbRefCounter,TSqlDbSysSettings is low ")); + StoreSysTableSecurityPolicyTest(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3509 DEF109100 - 2 - SQL, code coverage for TSqlBufRIterator,TSqlAttachDbRefCounter,TSqlDbSysSettings is low ")); + LoadSysSettingsTest(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3510 DEF109100 - 3 - SQL, code coverage for TSqlBufRIterator,TSqlAttachDbRefCounter,TSqlDbSysSettings is low ")); + LoadSecurityPolicyTest(); + } + +TInt E32Main() + { + TheTest.Title(); + + CTrapCleanup* tc = CTrapCleanup::New(); + + __UHEAP_MARK; + + CreateTestEnv(); + DeleteTestFiles(); + DoTests(); + DeleteTestFiles(); + TheFs.Close(); + + __UHEAP_MARKEND; + + TheTest.End(); + TheTest.Close(); + + delete tc; + + User::Heap().Check(); + return KErrNone; + }