Symaptic: os/persistentdata/persistentstorage/dbms/tdbms/t

     1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // DBMS security policy - testing new APIs.

    15 // This test app has "NetworkServices" (SCHEMA) capability, which allows it to

    16 // modify the DBMS structure but not to write any data in the tables.

    17 // The UID policy file is 11335579.spd.

    18 // Please, ensure that t_dbenvcreate test is executed before t_dbplatsec<N>/t_dbplatsecperf tests!

    19 // Please, ensure that t_dbenvdestroy test is executed after t_dbplatsec<N>/t_dbplatsecperf tests!

    20 //

    21 //

    23 #include <e32test.h>

    24 #include <d32dbms.h>

    25 #include "t_dbplatsecutl.h"

    27 const TUid KSecureDbUid = {0x11335579};

    28 const TUid KProtSecureDbUid = {0x11335578};

    29 _LIT(KSecure,	"SECURE");

    30 _LIT(KDbName,	"C:TestDB2.dB");

    31 _LIT(KTblNameA,	"A");

    32 _LIT(KTblNameB,	"B");

    33 _LIT(KTblNameC,	"C");

    35 static RTest 				TheTest(_L("t_dbplatsec1: DBMS platform security testing - 1"));

    36 static RDbs 				TheDbs;

    37 static RDbNamedDatabase 	TheDb;

    38 static RDbTable 			TheTbl;

    39 static RDbView 				TheView;

    41 static void CleanupTest()

    42 	{

    43 	TheView.Close();

    44 	TheTbl.Close();

    45 	TheDb.Close();

    46 	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDbName);

    47 	TheDbs.Close();

    48 	}

    50 TDBSCUtils 	TheDbscUtils(TheTest, &CleanupTest);

    52 static TColDef const KColumns[]=

    53 	{

    54 	{_S("ID"), EDbColInt32, TDbCol::ENotNull | TDbCol::EAutoIncrement},

    55 	{_S("DATA1"), EDbColInt32, TDbCol::ENotNull},

    56 	{_S("DATA2"), EDbColInt32, TDbCol::ENotNull},

    57 	{0}

    58 	};

    60 /**

    61 @SYMTestCaseID SYSLIB-DBMS-CT-0008

    62 @SYMTestCaseDesc Database tests. Some of the calls must fail because the caller has no enough rights

    63                  for the requested operation.

    64 @SYMTestPriority High

    65 @SYMTestActions  RDbNamedDatabase::Open()/RDbNamedDatabase::DatabaseNamesL()/RDbNamedDatabase::Create().

    66 @SYMTestExpectedResults The test must not fail.

    67 @SYMREQ REQ2429

    68                  DBMS shall provide an API to apply security policies to database tables.

    69 */

    70 static void DbTestL()

    71 	{

    72 	TBuf<32> format;

    74 	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDbName);

    75 	TheTest.Printf(_L("Create database\n"));

    76 	//The test must pass, because the test app has "SCHEMA" capability

    77 	format.Copy(KSecure);

    78 	format.Append(KSecureDbUid.Name());

    79 	TInt err = TheDb.Create(TheDbs, KDbName, format);

    80 	TEST2(err, KErrNone);

    82 	//The test must pass, because "DatabaseNamesL" is a DBMS operation available for everyone.

    83 	TheTest.Printf(_L("Database list\n"));

    84 	CDbDatabaseNames* dbNames = TheDbs.DatabaseNamesL(EDriveC, KSecureDbUid);

    85 	TEST(dbNames->Count() > 0);

    86 	TBool casePreserved = EFalse;

    87 	for(TInt i=0;i<dbNames->Count();++i)

    88 		{

    89 		const TDesC& dbName = (*dbNames)[i];

    90 		RDebug::Print(_L("--Database: %S\n"), &dbName);

    91 		TBuf<128> dbName2;

    92 		dbName2.Append(TChar('A' + EDriveC));

    93 		dbName2.Append(TChar(':'));

    94 		dbName2.Append(dbName);

    95 		if(dbName2 == KDbName())

    96 			{

    97 			casePreserved = ETrue;

    98 			}

    99 		}

   100 	//if casePreserved is non-zero that means the DBMS server does not change the database names to

   101 	//upper or lower case - that's what we want to check

   102 	TEST(casePreserved);

   103 	delete dbNames;

   105 	TheDb.Close();

   107 	TheTest.Printf(_L("An attempt to create database - existing, but protected UID\n"));

   108 	//The test must fail, because the test app does not have capabilities to satisfy

   109 	//KProtSecureDbUid "SCHEMA" policy.

   110 	format.Copy(KSecure);

   111 	format.Append(KProtSecureDbUid.Name());

   112 	err = TheDb.Create(TheDbs, KDbName, format);

   113 	TEST2(err, KErrPermissionDenied);

   115 	//The test must pass, because the test app has "SCHEMA" capability (it must have capabilities,

   116 	//satisfying at least one of the UID's R/W/S policies)

   117 	TheTest.Printf(_L("Open database\n"));

   118 	format.Copy(KSecure);

   119 	format.Append(KSecureDbUid.Name());

   120 	err = TheDb.Open(TheDbs, KDbName, format);

   121 	TEST2(err, KErrNone);

   122 	}

   124 /**

   125 @SYMTestCaseID SYSLIB-DBMS-CT-0009

   126 @SYMTestCaseDesc Opening table test. The caller has a set of capabilities which satisfy database's

   127                  schema security policy only. The test checks that the capapbility checking

   128 				 on the DBMS server side works properly. Some of the initiated open table

   129 				 operations won't executed and the returned error will be KErrPermisssionDenied.

   130 @SYMTestPriority High

   131 @SYMTestActions  Attempts to execute RDbTable::Open() on different tables from the test database.

   132 @SYMTestExpectedResults The test must not fail.

   133 @SYMREQ REQ2429

   134                  DBMS shall provide an API to apply security policies to database tables.

   135 */

   136 static void TblOpenL()

   137 	{

   138 	TheTest.Printf(_L("Create tables\n"));

   139 	//The test must pass, because the test app has "SCHEMA" capability

   140 	CDbColSet* colset = TDBSCUtils::CreateColSetLC(KColumns);

   141 	TInt err = TheDb.CreateTable(KTblNameA, *colset);//R: PowerMgmt, W: WriteUserData

   142 	TEST2(err, KErrNone);

   143 	err = TheDb.CreateTable(KTblNameB, *colset);//R: None, W: WriteUserData WriteDeviceData

   144 	TEST2(err, KErrNone);

   145 	err = TheDb.CreateTable(KTblNameC, *colset);//R: None, W: WriteUserData

   146 	TEST2(err, KErrNone);

   147 	CleanupStack::PopAndDestroy(colset);

   149 	TheTest.Printf(_L("An attempt to open table A\n"));

   150 	//The test must fail, because the test app has no capabilities to satisfy

   151 	//R/W policies of table A

   152 	err = TheTbl.Open(TheDb, KTblNameA);

   153 	TEST2(err, KErrPermissionDenied);

   154 	err = TheTbl.Open(TheDb, KTblNameA, RDbRowSet::EUpdatable);

   155 	TEST2(err, KErrPermissionDenied);

   156 	err = TheTbl.Open(TheDb, KTblNameA, RDbRowSet::EReadOnly);

   157 	TEST2(err, KErrPermissionDenied);

   158 	err = TheTbl.Open(TheDb, KTblNameA, RDbRowSet::EInsertOnly);

   159 	TEST2(err, KErrPermissionDenied);

   161 	TheTest.Printf(_L("An attempt to open table B\n"));

   162 	//Open table B in insert/update mode - the test must fail, because the test app has no

   163 	//capabilities to satisfy table B, policy W.

   164 	//Open table B in read-only mode - the test must pass, because table B has no R policy.

   165 	err = TheTbl.Open(TheDb, KTblNameB);

   166 	TEST2(err, KErrPermissionDenied);

   167 	err = TheTbl.Open(TheDb, KTblNameB, RDbRowSet::EUpdatable);

   168 	TEST2(err, KErrPermissionDenied);

   169 	err = TheTbl.Open(TheDb, KTblNameB, RDbRowSet::EInsertOnly);

   170 	TEST2(err, KErrPermissionDenied);

   171 	err = TheTbl.Open(TheDb, KTblNameB, RDbRowSet::EReadOnly);

   172 	TEST2(err, KErrNone);

   173 	TheTbl.Close();

   175 	TheTest.Printf(_L("An attempt to open table C\n"));

   176 	//Open table C in insert/update mode - the test must fail, because the test app has no

   177 	//capabilities to satisfy table C, policy W.

   178 	//Open table C in read-only mode - the test must pass, because table C has no R policy.

   179 	err = TheTbl.Open(TheDb, KTblNameC);

   180 	TEST2(err, KErrPermissionDenied);

   181 	err = TheTbl.Open(TheDb, KTblNameC, RDbRowSet::EUpdatable);

   182 	TEST2(err, KErrPermissionDenied);

   183 	err = TheTbl.Open(TheDb, KTblNameC, RDbRowSet::EInsertOnly);

   184 	TEST2(err, KErrPermissionDenied);

   185 	err = TheTbl.Open(TheDb, KTblNameC, RDbRowSet::EReadOnly);

   186 	TEST2(err, KErrNone);

   187 	TheTbl.Close();

   188 	}

   190 /**

   191 @SYMTestCaseID SYSLIB-DBMS-CT-0010

   192 @SYMTestCaseDesc Table R/w operations. The caller has a set of capabilities which satisfy database's

   193                  schema security policy only. The test checks that the capapbility checking

   194 				 on the DBMS server side works properly. Some of the R/W table operations won't be

   195 				 executed and the returned error will be KErrPermisssionDenied.

   196 @SYMTestPriority High

   197 @SYMTestActions  Attempts to execute RDbTable::Insert()/RDbTable::Update()/RDbTable::FirstL()

   198                  on different tables from the test database.

   199 @SYMTestExpectedResults The test must not fail.

   200 @SYMREQ REQ2429

   201                  DBMS shall provide an API to apply security policies to database tables.

   202 */

   203 static void TblRWL()

   204 	{

   205 	TheTest.Printf(_L("An attempt to write in table B\n"));

   206 	TInt err = TheTbl.Open(TheDb, KTblNameB, RDbRowSet::EReadOnly);

   207 	TEST2(err, KErrNone);

   208 	//"Write table B" test must fail, because the test app has no capabilities

   209 	//to satisfy table B, policy W.

   210 	TRAP(err, TheTbl.InsertL());

   211 	TEST2(err, KErrPermissionDenied);

   212 	TRAP(err, TheTbl.UpdateL());

   213 	TEST2(err, KErrPermissionDenied);

   215 	TheTest.Printf(_L("An attempt to read from table B\n"));

   216 	//"Read table B" test must pass, because table B has no R policy

   217 	TBool res = TheTbl.FirstL();

   218 	TEST(!res);

   220 	TheTbl.Close();

   222 	TheTest.Printf(_L("An attempt to write in table C\n"));

   223 	//"Write table C" test must fail, because the test app has no capabilities

   224 	//to satisfy table C, policy W.

   225 	err = TheTbl.Open(TheDb, KTblNameC, RDbRowSet::EReadOnly);

   226 	TEST2(err, KErrNone);

   227 	TRAP(err, TheTbl.InsertL());

   228 	TEST2(err, KErrPermissionDenied);

   229 	TRAP(err, TheTbl.UpdateL());

   230 	TEST2(err, KErrPermissionDenied);

   232 	TheTest.Printf(_L("An attempt to read from table C\n"));

   233 	//"Read table C" test must pass, because table C has no R policy

   234 	res = TheTbl.FirstL();

   235 	TEST(!res);

   237 	TheTbl.Close();

   238 	}

   240 /**

   241 @SYMTestCaseID SYSLIB-DBMS-CT-0011

   242 @SYMTestCaseDesc SQL tests. The caller has a set of capabilities which satisfy database's

   243                  schema security policy only. The test checks that the capapbility checking

   244 				 on the DBMS server side works properly. Some of the SQL statements won't be

   245 				 executed and the returned error will be KErrPermisssionDenied.

   246 @SYMTestPriority High

   247 @SYMTestActions  Attempts to execute various INSERT/UPDATE/SELECT SQL statements.

   248 @SYMTestExpectedResults The test must not fail.

   249 @SYMREQ REQ2429

   250                  DBMS shall provide an API to apply security policies to database tables.

   251 */

   252 static void TblSqlL()

   253 	{

   254 	TheTest.Printf(_L("SELECT SQL\n"));

   255 	//The test must fail, because the test app cannot satisfy table A, policy R.

   256 	TInt err = TheView.Prepare(TheDb, TDbQuery(_L("SELECT * FROM A")));

   257 	TEST2(err, KErrPermissionDenied);

   258 	//The test must pass, because table B has no R policy.

   259 	err = TheView.Prepare(TheDb, TDbQuery(_L("SELECT * FROM B")));

   260 	TEST2(err, KErrNone);

   261 	TheView.Close();

   262 	//The test must pass, because table C has no R policy.

   263 	err = TheView.Prepare(TheDb, TDbQuery(_L("SELECT * FROM C")));

   264 	TEST2(err, KErrNone);

   265 	TheView.Close();

   267 	TheTest.Printf(_L("INSERT/UPDATE SQL\n"));

   268 	//The test must fail, because the test app cannot satisfy table A, policy W.

   269 	err = TheDb.Execute(_L("INSERT INTO A (DATA2) VALUES(45)"));

   270 	TEST2(err, KErrPermissionDenied);

   271 	//The test must fail, because the test app cannot satisfy table B, policy W.

   272 	err = TheDb.Execute(_L("INSERT INTO B (DATA2) VALUES(45)"));

   273 	TEST2(err, KErrPermissionDenied);

   274 	//The test must fail, because the test app cannot satisfy table C, policy W.

   275 	err = TheDb.Execute(_L("INSERT INTO C (DATA2) VALUES(45)"));

   276 	TEST2(err, KErrPermissionDenied);

   278 	//The test must fail, because the test app cannot satisfy table A, policy W.

   279 	err = TheDb.Execute(_L("UPDATE A SET DATA2=56 WHERE ID = 0"));

   280 	TEST2(err, KErrPermissionDenied);

   281 	//The test must fail, because the test app cannot satisfy table B, policy W.

   282 	err = TheDb.Execute(_L("UPDATE B SET DATA2=56 WHERE ID = 0"));

   283 	TEST2(err, KErrPermissionDenied);

   284 	//The test must fail, because the test app cannot satisfy table C, policy W.

   285 	err = TheDb.Execute(_L("UPDATE C SET DATA2=56 WHERE ID = 0"));

   286 	TEST2(err, KErrPermissionDenied);

   287 	}

   289 static void DoRunL()

   290 	{

   291 	TheTest.Start(_L("An app with \"SCHEMA\" capabilities set"));

   293 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0008 Database test "));

   294 	::DbTestL();

   296 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0009 Open table test "));

   297 	::TblOpenL();

   299 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0010 Read/Write table test "));

   300 	::TblRWL();

   302 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0011 SQL table test "));

   303 	::TblSqlL();

   304 	}

   306 TInt E32Main()

   307     {

   308 	__UHEAP_MARK;

   309 	CTrapCleanup* tc = CTrapCleanup::New();

   310 	TEST(tc != NULL);

   312 	TInt err = TheDbs.Connect();

   313 	TEST2(err, KErrNone);

   315 	TRAP(err, ::DoRunL());

   316 	TEST2(err, KErrNone);

   318 	::CleanupTest();

   320 	TheTest.End();

   321 	TheTest.Close();

   323 	delete tc;

   325 	__UHEAP_MARKEND;

   326 	User::Heap().Check();

   327 	return KErrNone;

   328     }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--