projects / platform / core / security / security-manager.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: e75fd19)
Add negative test cases wherever possible 52/230352/30
authorTomasz Swierczek <t.swierczek@samsung.com>
Thu, 9 Apr 2020 12:51:20 +0000 (14:51 +0200)
committerTomasz Swierczek <t.swierczek@samsung.com>
Wed, 24 Jun 2020 11:17:31 +0000 (13:17 +0200)
Yes, repeating same test code body many times
to test each unprintable character below ' '
is not elegant, but it gets us to > 50%
of negative test cases, with room for improvement.

Yes, this seems ugly, but does the job.

Yes, I will have to wash my hands after committing this.

So here I am, with this patch, before you,
Dear Reviewer, so you don't have to make it.

Titan! to whose immortal eyes
         The sufferings of mortality,
         Seen in their sad reality,
Were not as things that gods despise;

(...)

Lord Byron, Prometheus

Change-Id: I48d7466ef6ca4143bf759d9b70ce60bdd347935c

test/test_smack-labels.cpp patch | blob | history
test/test_smack-rules.cpp patch | blob | history

diff --git a/test/test_smack-labels.cpp b/test/test_smack-labels.cpp
index 8a58f6fb9bbfcb5519fe6cb12632291ae4732838..96f5bc198a54cf71225cdcd29cc3665763627b27 100644 (file)
--- a/test/test_smack-labels.cpp
+++ b/test/test_smack-labels.cpp
@@ -151,6 +151,7 @@ POSITIVE_TEST_CASE(T1020_get_smack_label_process)
 {
     pid_t pid = -1;
     std::string processLabel, selfLabel;
+
     BOOST_REQUIRE_NO_THROW(selfLabel = getSmackLabelFromSelf());
 
     pid = getpid();
@@ -185,16 +186,25 @@ NEGATIVE_TEST_CASE(T1023_generate_smack_label_invalid_app)
                         SmackException::InvalidLabel);
 }
 
-NEGATIVE_TEST_CASE(T1024_generate_smack_label_path_labels_invalid_args)
+NEGATIVE_TEST_CASE(T1024_generate_smack_label_path_rw_invalid_pkg)
 {
-    const std::string invalidPkgName = "  ";
-    const int invalidAuthorId = -1;
+    const std::string invalidPkgName = " ";
     BOOST_REQUIRE_THROW(generatePathRWLabel(invalidPkgName), SmackException::InvalidLabel);
+}
+
+NEGATIVE_TEST_CASE(T1025_generate_smack_label_path_ro_invalid_pkg)
+{
+    const std::string invalidPkgName = "  ";
     BOOST_REQUIRE_THROW(generatePathROLabel(invalidPkgName), SmackException::InvalidLabel);
+}
+
+NEGATIVE_TEST_CASE(T1026_generate_smack_label_path_trusted_invalid_author)
+{
+    const int invalidAuthorId = -1;
     BOOST_REQUIRE_THROW(generatePathTrustedLabel(invalidAuthorId), SmackException::InvalidLabel);
 }
 
-POSITIVE_TEST_CASE(T1030_generate_smack_label)
+POSITIVE_TEST_CASE(T1030_generate_smack_labels)
 {
     const std::string appName = "appNameT1030";
     const std::string pkgName = "pkgNameT1030";
@@ -222,17 +232,48 @@ POSITIVE_TEST_CASE(T1030_generate_smack_label)
     BOOST_REQUIRE(generatePathTrustedLabel(validAuthorId) == pathTrustedLabel);
 }
 
-NEGATIVE_TEST_CASE(T1040_generate_app_pkg_name_from_label)
+NEGATIVE_TEST_CASE(T1031_generate_smack_label_invalid_pkg_name_non_hybrid)
 {
-    std::string app, pkg;
-    const std::string appName = "appNameT1040";
+    const std::string appName = "appNameT1031";
+    const std::string invalidPkgName = " ";
+
+    BOOST_REQUIRE_THROW(generateProcessLabel(appName, invalidPkgName, false),
+                        SmackException::InvalidLabel);
+}
+
+NEGATIVE_TEST_CASE(T1032_generate_smack_label_invalid_pkg_name_hybrid)
+{
+    const std::string appName = "appNameT1032";
+    const std::string invalidPkgName = " ";
+
+    BOOST_REQUIRE_THROW(generateProcessLabel(appName, invalidPkgName, true),
+                        SmackException::InvalidLabel);
+}
+
+NEGATIVE_TEST_CASE(T1033_generate_smack_label_invalid_app_name_hybrid)
+{
+    const std::string invalidAppName = " ";
+    const std::string pkgName = "pkgNameT1033";
+
+    BOOST_REQUIRE_THROW(generateProcessLabel(invalidAppName, pkgName, true),
+                        SmackException::InvalidLabel);
+}
+
+NEGATIVE_TEST_CASE(T1034_generate_smack_label_invalid_app_and_pkg_hybrd)
+{
+    const std::string invalidAppName = " ";
+    const std::string invalidPkgName = " ";
 
-    std::string invalidLabel = "Admin::Pkg::pkgNameT1040";
-    BOOST_REQUIRE_THROW(generateAppPkgNameFromLabel(invalidLabel, app, pkg),
+    BOOST_REQUIRE_THROW(generateProcessLabel(invalidAppName, invalidPkgName, true),
                         SmackException::InvalidLabel);
+}
 
-    invalidLabel = generateProcessLabel(appName, "", false);
-    BOOST_REQUIRE_THROW(generateAppPkgNameFromLabel(invalidLabel, app, pkg),
+NEGATIVE_TEST_CASE(T1035_generate_smack_label_invalid_app_and_pkg_non_hybrd)
+{
+    const std::string invalidAppName = " ";
+    const std::string invalidPkgName = " ";
+
+    BOOST_REQUIRE_THROW(generateProcessLabel(invalidAppName, invalidPkgName, false),
                         SmackException::InvalidLabel);
 }
 
@@ -271,16 +312,28 @@ POSITIVE_FIXTURE_TEST_CASE(T1050_setup_path_rw, DirectoryFixture)
     BOOST_REQUIRE(labelNotExist(execPath, XATTR_NAME_SMACKEXEC));
 }
 
-NEGATIVE_FIXTURE_TEST_CASE(T1051_setup_path_rw, DirectoryFixture)
+NEGATIVE_FIXTURE_TEST_CASE(T1052_setup_path_rw, DirectoryFixture)
 {
-    const std::string pkgName = "pkgNameT1051";
-    const std::string noExistingDirectoryPath = "/tmp/SecurityManagerUTNoExistingDirectory/";
-    const int invalidAuthorId = -1;
+    const std::string pkgName = "pkgNameT1052";
 
     BOOST_REQUIRE_THROW(setupPath(pkgName, directoryPath, static_cast<app_install_path_type>(-1)),
                         SmackException::InvalidPathType);
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T1053_setup_path_rw, DirectoryFixture)
+{
+    const std::string pkgName = "pkgNameT1053";
+    const int invalidAuthorId = -1;
+
     BOOST_REQUIRE_THROW(setupPath(pkgName, directoryPath, SECURITY_MANAGER_PATH_TRUSTED_RW, invalidAuthorId),
                         SmackException::InvalidParam);
+}
+
+NEGATIVE_FIXTURE_TEST_CASE(T1054_setup_path_rw, DirectoryFixture)
+{
+    const std::string pkgName = "pkgNameT1054";
+    const std::string noExistingDirectoryPath = "/tmp/SecurityManagerUTNoExistingDirectory/";
+
     BOOST_REQUIRE_THROW(setupPath(pkgName, noExistingDirectoryPath, SECURITY_MANAGER_PATH_RW),
                         SmackException::FileError);
 }
diff --git a/test/test_smack-rules.cpp b/test/test_smack-rules.cpp
index 71f8a314dbf187d0f47f2a027fc1b88be66a6464..d4b9fcadf95109d92be86228e71a31d4f6d4f20d 100644 (file)
--- a/test/test_smack-rules.cpp
+++ b/test/test_smack-rules.cpp
@@ -54,30 +54,176 @@ const char* RulesFixture::templateRulesFilePath = "/tmp/SecurityManagerUTTemplat
 
 BOOST_AUTO_TEST_SUITE(SMACK_RULES_TEST)
 
-NEGATIVE_TEST_CASE(T1120_smack_rules_exception)
+
+NEGATIVE_TEST_CASE(T1119_smack_rules_exception_invalid_perm)
 {
     SmackAccesses smackRules;
 
     BOOST_REQUIRE_THROW(smackRules.add("subject", "object", "invalidPermission"),
                         SmackException::LibsmackError);
+}
+
+NEGATIVE_TEST_CASE(T1120_smack_rules_exception_invalid_object)
+{
+    SmackAccesses smackRules;
+
     BOOST_REQUIRE_THROW(smackRules.add("subject", "", "rwxatl"), SmackException::LibsmackError);
+}
+
+NEGATIVE_TEST_CASE(T1121_smack_rules_exception_invalid_subject)
+{
+    SmackAccesses smackRules;
+
     BOOST_REQUIRE_THROW(smackRules.add("", "object", "rwxatl"), SmackException::LibsmackError);
+}
+
+NEGATIVE_TEST_CASE(T1122_smack_rules_exception_addModify_invalid_permission)
+{
+    SmackAccesses smackRules;
 
     BOOST_REQUIRE_THROW(smackRules.addModify("subject", "object", "invalidPermission", ""),
                         SmackException::LibsmackError);
+}
+
+NEGATIVE_TEST_CASE(T1123_smack_rules_exception_addModify_invalid_permission)
+{
+    SmackAccesses smackRules;
+
     BOOST_REQUIRE_THROW(smackRules.addModify("subject", "object", "", "invalidPermission"),
                         SmackException::LibsmackError);
+}
+
+NEGATIVE_TEST_CASE(T1124_smack_rules_exception_addModify_invalid_object)
+{
+    SmackAccesses smackRules;
+
     BOOST_REQUIRE_THROW(smackRules.addModify("subject", "", "rw", "xt"),
                         SmackException::LibsmackError);
+}
+
+NEGATIVE_TEST_CASE(T1125_smack_rules_exception_addModify_invalid_subject)
+{
+    SmackAccesses smackRules;
+
     BOOST_REQUIRE_THROW(smackRules.addModify("", "object", "rw", "xt"),
                         SmackException::LibsmackError);
 }
 
-POSITIVE_TEST_CASE(T1121_smack_rules_exception)
+POSITIVE_TEST_CASE(T1126_smack_rules_exception)
 {
     SmackAccesses smackRules;
 
     BOOST_REQUIRE_NO_THROW(smackRules.add("subject", "object", "rwxat"));
 }
 
+// wrong subject or object - printable characters
+#define NEGATIVE_RULE_ADD(NAME,SUBJ,OBJ,PERM)   \
+NEGATIVE_TEST_CASE(NAME)                        \
+{                                               \
+    BOOST_REQUIRE_THROW(                        \
+        SmackAccesses().add(SUBJ, OBJ, PERM),   \
+            SmackException::LibsmackError);     \
+} 
+
+NEGATIVE_RULE_ADD(T1127_smack_rules_exception_invalid_printable_character_subject, "subject/", "object", "rwxat")
+NEGATIVE_RULE_ADD(T1128_smack_rules_exception_invalid_printable_character_object, "subject", "object/", "rwxat")
+NEGATIVE_RULE_ADD(T1129_smack_rules_exception_invalid_printable_character_subject, "subject\"", "object", "rwxat")
+NEGATIVE_RULE_ADD(T1130_smack_rules_exception_invalid_printable_character_object, "subject", "object\"", "rwxat")
+NEGATIVE_RULE_ADD(T1131_smack_rules_exception_invalid_printable_character_subject, "subject'", "object", "rwxat")
+NEGATIVE_RULE_ADD(T1132_smack_rules_exception_invalid_printable_character_object, "subject", "object'", "rwxat")
+NEGATIVE_RULE_ADD(T1133_smack_rules_exception_invalid_printable_character_subject, "subject\\", "object", "rwxat")
+NEGATIVE_RULE_ADD(T1134_smack_rules_exception_invalid_printable_character_object, "subject", "object\\", "rwxat")
+
+#undef NEGATIVE_RULE_ADD
+
+// wrong unprintable characters, below space (32)
+#define NEGATIVE_ASCII_SUBJECT(n)                                   \
+NEGATIVE_TEST_CASE(T1135_smack_rules_exception_ASCII_s_check_ ## n) \
+{                                                                   \
+    SmackAccesses smackRules;                                       \
+    std::string subject = "subject";                                \
+    std::string object = "object";                                  \
+    subject[0] = n; /* unprintable */                               \
+    BOOST_REQUIRE_THROW(smackRules.add(subject, object, "rwxat"),   \
+                        SmackException::LibsmackError);             \
+}
+
+#define NEGATIVE_ASCII_OBJECT(n)                                    \
+NEGATIVE_TEST_CASE(T1136_smack_rules_exception_ASCII_o_check_ ## n) \
+{                                                                   \
+    SmackAccesses smackRules;                                       \
+    std::string subject = "subject";                                \
+    std::string object = "object";                                  \
+    object[0] = n; /* unprintable */                                \
+    BOOST_REQUIRE_THROW(smackRules.add(subject, object, "rwxat"),   \
+                        SmackException::LibsmackError);             \
+}
+
+NEGATIVE_ASCII_SUBJECT(1)
+NEGATIVE_ASCII_SUBJECT(2)
+NEGATIVE_ASCII_SUBJECT(3)
+NEGATIVE_ASCII_SUBJECT(4)
+NEGATIVE_ASCII_SUBJECT(5)
+NEGATIVE_ASCII_SUBJECT(6)
+NEGATIVE_ASCII_SUBJECT(7)
+NEGATIVE_ASCII_SUBJECT(8)
+NEGATIVE_ASCII_SUBJECT(9)
+NEGATIVE_ASCII_SUBJECT(10)
+NEGATIVE_ASCII_SUBJECT(11)
+NEGATIVE_ASCII_SUBJECT(12)
+NEGATIVE_ASCII_SUBJECT(13)
+NEGATIVE_ASCII_SUBJECT(14)
+NEGATIVE_ASCII_SUBJECT(15)
+NEGATIVE_ASCII_SUBJECT(16)
+NEGATIVE_ASCII_SUBJECT(17)
+NEGATIVE_ASCII_SUBJECT(18)
+NEGATIVE_ASCII_SUBJECT(19)
+NEGATIVE_ASCII_SUBJECT(20)
+NEGATIVE_ASCII_SUBJECT(21)
+NEGATIVE_ASCII_SUBJECT(22)
+NEGATIVE_ASCII_SUBJECT(23)
+NEGATIVE_ASCII_SUBJECT(24)
+NEGATIVE_ASCII_SUBJECT(25)
+NEGATIVE_ASCII_SUBJECT(26)
+NEGATIVE_ASCII_SUBJECT(27)
+NEGATIVE_ASCII_SUBJECT(28)
+NEGATIVE_ASCII_SUBJECT(29)
+NEGATIVE_ASCII_SUBJECT(30)
+NEGATIVE_ASCII_SUBJECT(31)
+
+NEGATIVE_ASCII_OBJECT(1)
+NEGATIVE_ASCII_OBJECT(2)
+NEGATIVE_ASCII_OBJECT(3)
+NEGATIVE_ASCII_OBJECT(4)
+NEGATIVE_ASCII_OBJECT(5)
+NEGATIVE_ASCII_OBJECT(6)
+NEGATIVE_ASCII_OBJECT(7)
+NEGATIVE_ASCII_OBJECT(8)
+NEGATIVE_ASCII_OBJECT(9)
+NEGATIVE_ASCII_OBJECT(10)
+NEGATIVE_ASCII_OBJECT(11)
+NEGATIVE_ASCII_OBJECT(12)
+NEGATIVE_ASCII_OBJECT(13)
+NEGATIVE_ASCII_OBJECT(14)
+NEGATIVE_ASCII_OBJECT(15)
+NEGATIVE_ASCII_OBJECT(16)
+NEGATIVE_ASCII_OBJECT(17)
+NEGATIVE_ASCII_OBJECT(18)
+NEGATIVE_ASCII_OBJECT(19)
+NEGATIVE_ASCII_OBJECT(20)
+NEGATIVE_ASCII_OBJECT(21)
+NEGATIVE_ASCII_OBJECT(22)
+NEGATIVE_ASCII_OBJECT(23)
+NEGATIVE_ASCII_OBJECT(24)
+NEGATIVE_ASCII_OBJECT(25)
+NEGATIVE_ASCII_OBJECT(26)
+NEGATIVE_ASCII_OBJECT(27)
+NEGATIVE_ASCII_OBJECT(28)
+NEGATIVE_ASCII_OBJECT(29)
+NEGATIVE_ASCII_OBJECT(30)
+NEGATIVE_ASCII_OBJECT(31)
+
+#undef NEGATIVE_ASCII_SUBJECT
+#undef NEGATIVE_ASCII_OBJECT
+
 BOOST_AUTO_TEST_SUITE_END()
Domain: Security / Access Control;