selinux/libsemanage/tests/test_semanage_store.c - nest-cam/4320010/selinux - Git at Google

 /* Authors: Christopher Ashworth <cashworth@tresys.com>
  *          Caleb Case <ccase@tresys.com>
  *          Chris PeBenito <cpebenito@tresys.com>
  *
  * Copyright (C) 2006 Tresys Technology, LLC
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
  *  version 2.1 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */

 /*  The purpose of this file is to provide unit tests of the functions in:
  *
  *  libsemanage/src/semanage_store.c
  *
  */

 #include "handle.h"
 #include "semanage_store.h"

 #include "utilities.h"
 #include "test_semanage_store.h"

 #include <libgen.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <CUnit/Basic.h>

 semanage_handle_t *sh = NULL;
 const char *rootpath = "./test-policy";
 const char *polpath = "./test-policy/store/";
 const char *readlockpath = "./test-policy/store/semanage.read.LOCK";
 const char *translockpath = "./test-policy/store/semanage.trans.LOCK";
 const char *actpath = "./test-policy/store/active";
 const char *modpath = "./test-policy/store/active/modules";

 /* The suite initialization function.
  * Returns zero on success, non-zero otherwise.
  */
 int semanage_store_test_init(void)
 {
 	int err;

 	/* create directories */
 	err = mkdir(rootpath, S_IRUSR | S_IWUSR | S_IXUSR);
 	if (err != 0)
 		return -1;

 	err = mkdir(polpath, S_IRUSR | S_IWUSR | S_IXUSR);
 	if (err != 0)
 		return -1;

 	err = mkdir(actpath, S_IRUSR | S_IWUSR | S_IXUSR);
 	if (err != 0)
 		return -1;

 	err = mkdir(modpath, S_IRUSR | S_IWUSR | S_IXUSR);
 	if (err != 0)
 		return -1;

 	/* initialize the handle */
 	sh = semanage_handle_create();
 	if (sh == NULL)
 		return -1;

 	/* hide error messages */
 	sh->msg_callback = test_msg_handler;

 	/* use our own policy store */
 	free(sh->conf->store_path);
 	sh->conf->store_path = strdup("store");

 	/* initialize paths */
 	err = semanage_check_init(sh, rootpath);
 	if (err != 0)
 		return -1;

 	return 0;
 }

 /* The suite cleanup function.
  * Returns zero on success, non-zero otherwise.
  */
 int semanage_store_test_cleanup(void)
 {
 	int err;

 	/* remove the test policy directories */
 	err = rmdir(modpath);
 	if (err != 0)
 		return -1;

 	err = rmdir(actpath);
 	if (err != 0)
 		return -1;

 	err = rmdir(polpath);
 	if (err != 0)
 		return -1;

 	err = rmdir(rootpath);
 	if (err != 0)
 		return -1;

 	/* cleanup the handle */
 	semanage_handle_destroy(sh);
 	return 0;
 }

 /* Adds all the tests needed for this suite.
  */
 int semanage_store_add_tests(CU_pSuite suite)
 {
 	if (NULL ==
 	    CU_add_test(suite, "semanage_store_access_check",
 			test_semanage_store_access_check)) {
 		CU_cleanup_registry();
 		return CU_get_error();
 	}

 	if (NULL ==
 	    CU_add_test(suite, "semanage_get_lock", test_semanage_get_lock)) {
 		CU_cleanup_registry();
 		return CU_get_error();
 	}

 	if (NULL ==
 	    CU_add_test(suite, "semanage_nc_sort", test_semanage_nc_sort)) {
 		CU_cleanup_registry();
 		return CU_get_error();
 	}

 	return 0;
 }

 /* Tests the semanage_store_access_check function in semanage_store.c
  */
 void test_semanage_store_access_check(void)
 {
 	int err;

 	/* create lock file */
 	err = mknod(readlockpath, S_IRUSR | S_IWUSR, S_IFREG);

 	/* check with permissions 000 */
 	err = chmod(modpath, 0);
 	CU_ASSERT(err == 0);
 	err = chmod(readlockpath, 0);
 	CU_ASSERT(err == 0);
 	err = chmod(polpath, 0);
 	CU_ASSERT(err == 0);

 	err = semanage_store_access_check();
 	CU_ASSERT(err == -1);

 	/* check with permissions 500 */
 	err = chmod(polpath, S_IRUSR | S_IXUSR);
 	CU_ASSERT(err == 0);
 	err = chmod(readlockpath, S_IRUSR);
 	CU_ASSERT(err == 0);
 	err = chmod(modpath, S_IRUSR | S_IXUSR);
 	CU_ASSERT(err == 0);

 	err = semanage_store_access_check();
 	CU_ASSERT(err == SEMANAGE_CAN_READ);

 	/* check with permissions 700 */
 	err = chmod(polpath, S_IRUSR | S_IWUSR | S_IXUSR);
 	CU_ASSERT(err == 0);
 	err = chmod(readlockpath, S_IRUSR | S_IWUSR);
 	CU_ASSERT(err == 0);
 	err = chmod(modpath, S_IRUSR | S_IWUSR | S_IXUSR);
 	CU_ASSERT(err == 0);

 	err = semanage_store_access_check();
 	CU_ASSERT(err == SEMANAGE_CAN_WRITE);

 	/* check with lock file 000 and others 500 */
 	err = chmod(polpath, S_IRUSR | S_IXUSR);
 	CU_ASSERT(err == 0);
 	err = chmod(readlockpath, 0);
 	CU_ASSERT(err == 0);
 	err = chmod(modpath, S_IRUSR | S_IXUSR);
 	CU_ASSERT(err == 0);

 	err = semanage_store_access_check();
 	CU_ASSERT(err == 0);

 	/* check with lock file 000 and others 700 */
 	err = chmod(polpath, S_IRUSR | S_IWUSR | S_IXUSR);
 	CU_ASSERT(err == 0);
 	err = chmod(readlockpath, 0);
 	CU_ASSERT(err == 0);
 	err = chmod(modpath, S_IRUSR | S_IWUSR | S_IXUSR);
 	CU_ASSERT(err == 0);

 	err = semanage_store_access_check();
 	CU_ASSERT(err == 0);

 	/* remove lock file */
 	err = remove(readlockpath);
 	CU_ASSERT(err == 0);

 	/* check with no lock file and 000 */
 	err = chmod(modpath, 0);
 	CU_ASSERT(err == 0);
 	err = chmod(polpath, 0);
 	CU_ASSERT(err == 0);

 	err = semanage_store_access_check();
 	CU_ASSERT(err == -1);

 	/* check with no lock file and 500 */
 	err = chmod(polpath, S_IRUSR | S_IXUSR);
 	CU_ASSERT(err == 0);
 	err = chmod(modpath, S_IRUSR | S_IXUSR);
 	CU_ASSERT(err == 0);

 	err = semanage_store_access_check();
 	CU_ASSERT(err == 0);

 	/* check with no lock file but write in polpath */
 	err = chmod(polpath, S_IRUSR | S_IWUSR | S_IXUSR);
 	CU_ASSERT(err == 0);

 	err = semanage_store_access_check();
 	CU_ASSERT(err == SEMANAGE_CAN_READ);

 	/* check with no lock file and 700 */
 	err = chmod(polpath, S_IRUSR | S_IWUSR | S_IXUSR);
 	CU_ASSERT(err == 0);
 	err = chmod(modpath, S_IRUSR | S_IWUSR | S_IXUSR);
 	CU_ASSERT(err == 0);

 	err = semanage_store_access_check();
 	CU_ASSERT(err == SEMANAGE_CAN_WRITE);
 }

 /* Tests the semanage_get_lock functions in semanage_store.c
  */
 void test_semanage_get_lock(void)
 {
 	int err;

 	/* attempt to get an active lock */
 	err = semanage_get_active_lock(sh);
 	CU_ASSERT(err == 0);

 	/* attempt to get the lock again */
 	err = semanage_get_active_lock(sh);
 	CU_ASSERT(err == 0);

 	/* attempt to release the active lock */
 	semanage_release_active_lock(sh);

 	/* attempt to get an active lock */
 	err = semanage_get_active_lock(sh);
 	CU_ASSERT(err == 0);

 	/* attempt to release the active lock */
 	semanage_release_active_lock(sh);

 	/* attempt to get a trans lock */
 	err = semanage_get_trans_lock(sh);
 	CU_ASSERT(err == 0);

 	/* attempt to get the lock again */
 	err = semanage_get_trans_lock(sh);
 	CU_ASSERT(err == 0);

 	/* attempt to release the trans lock */
 	semanage_release_trans_lock(sh);

 	/* attempt to get a trans lock */
 	err = semanage_get_trans_lock(sh);
 	CU_ASSERT(err == 0);

 	/* attempt to release the trans lock */
 	semanage_release_trans_lock(sh);

 	/* remove the lock files */
 	err = remove(readlockpath);
 	CU_ASSERT(err == 0);
 	err = remove(translockpath);
 	CU_ASSERT(err == 0);
 }

 /* Tests the semanage_nc_sort function in semanage_store.c
  */
 void test_semanage_nc_sort(void)
 {
 	char *source_buf, *sorted_buf = NULL, *good_buf, *bad_buf;
 	size_t source_buf_len, sorted_buf_len, good_buf_len, bad_buf_len;
 	int sourcefd, goodfd, badfd, err;
 	struct stat sb;

 	/* open source file */
 	sourcefd = open("nc_sort_unsorted", O_RDONLY);
 	if (sourcefd < 0) {
 		CU_FAIL("Missing nc_sort_unsorted test file.");
 		return;
 	}
 	fstat(sourcefd, &sb);
 	source_buf_len = sb.st_size;
 	source_buf =
 	    (char *)mmap(NULL, source_buf_len, PROT_READ, MAP_PRIVATE, sourcefd,
 			 0);

 	/* open good result file */
 	goodfd = open("nc_sort_sorted", O_RDONLY);
 	if (goodfd < 0) {
 		CU_FAIL("Missing nc_sort_sorted test file.");
 		goto out2;
 	}
 	fstat(goodfd, &sb);
 	good_buf_len = sb.st_size;
 	good_buf =
 	    (char *)mmap(NULL, good_buf_len, PROT_READ, MAP_PRIVATE, goodfd, 0);

 	/* open malformed source file (missing priorities) */
 	badfd = open("nc_sort_malformed", O_RDONLY);
 	if (badfd < 0) {
 		CU_FAIL("Missing nc_sort_malformed test file.");
 		goto out1;
 	}
 	fstat(badfd, &sb);
 	bad_buf_len = sb.st_size;
 	bad_buf =
 	    (char *)mmap(NULL, bad_buf_len, PROT_READ, MAP_PRIVATE, badfd, 0);

 	/* sort test file */
 	err =
 	    semanage_nc_sort(sh, source_buf, source_buf_len, &sorted_buf,
 			     &sorted_buf_len);
 	CU_ASSERT_FALSE(err);
 	CU_ASSERT_STRING_EQUAL(sorted_buf, good_buf);

 	/* reset for reuse in next test */
 	free(sorted_buf);
 	sorted_buf = NULL;

 	/* sort malformed source file */
 	err =
 	    semanage_nc_sort(sh, bad_buf, bad_buf_len, &sorted_buf,
 			     &sorted_buf_len);
 	CU_ASSERT_EQUAL(err, -1);

 	free(sorted_buf);

 	munmap(bad_buf, bad_buf_len);
 	close(badfd);
       out1:
 	munmap(good_buf, good_buf_len);
 	close(goodfd);
       out2:
 	munmap(source_buf, source_buf_len);
 	close(sourcefd);
 }
	/* Authors: Christopher Ashworth <cashworth@tresys.com>
	* Caleb Case <ccase@tresys.com>
	* Chris PeBenito <cpebenito@tresys.com>
	*
	* Copyright (C) 2006 Tresys Technology, LLC
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	/* The purpose of this file is to provide unit tests of the functions in:
	*
	* libsemanage/src/semanage_store.c
	*
	*/

	#include "handle.h"
	#include "semanage_store.h"

	#include "utilities.h"
	#include "test_semanage_store.h"

	#include <libgen.h>
	#include <limits.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/mman.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <unistd.h>
	#include <CUnit/Basic.h>

	semanage_handle_t *sh = NULL;
	const char *rootpath = "./test-policy";
	const char *polpath = "./test-policy/store/";
	const char *readlockpath = "./test-policy/store/semanage.read.LOCK";
	const char *translockpath = "./test-policy/store/semanage.trans.LOCK";
	const char *actpath = "./test-policy/store/active";
	const char *modpath = "./test-policy/store/active/modules";

	/* The suite initialization function.
	* Returns zero on success, non-zero otherwise.
	*/
	int semanage_store_test_init(void)
	{
	int err;

	/* create directories */
	err = mkdir(rootpath, S_IRUSR \| S_IWUSR \| S_IXUSR);
	if (err != 0)
	return -1;

	err = mkdir(polpath, S_IRUSR \| S_IWUSR \| S_IXUSR);
	if (err != 0)
	return -1;

	err = mkdir(actpath, S_IRUSR \| S_IWUSR \| S_IXUSR);
	if (err != 0)
	return -1;

	err = mkdir(modpath, S_IRUSR \| S_IWUSR \| S_IXUSR);
	if (err != 0)
	return -1;

	/* initialize the handle */
	sh = semanage_handle_create();
	if (sh == NULL)
	return -1;

	/* hide error messages */
	sh->msg_callback = test_msg_handler;

	/* use our own policy store */
	free(sh->conf->store_path);
	sh->conf->store_path = strdup("store");

	/* initialize paths */
	err = semanage_check_init(sh, rootpath);
	if (err != 0)
	return -1;

	return 0;
	}

	/* The suite cleanup function.
	* Returns zero on success, non-zero otherwise.
	*/
	int semanage_store_test_cleanup(void)
	{
	int err;

	/* remove the test policy directories */
	err = rmdir(modpath);
	if (err != 0)
	return -1;

	err = rmdir(actpath);
	if (err != 0)
	return -1;

	err = rmdir(polpath);
	if (err != 0)
	return -1;

	err = rmdir(rootpath);
	if (err != 0)
	return -1;

	/* cleanup the handle */
	semanage_handle_destroy(sh);
	return 0;
	}

	/* Adds all the tests needed for this suite.
	*/
	int semanage_store_add_tests(CU_pSuite suite)
	{
	if (NULL ==
	CU_add_test(suite, "semanage_store_access_check",
	test_semanage_store_access_check)) {
	CU_cleanup_registry();
	return CU_get_error();
	}

	if (NULL ==
	CU_add_test(suite, "semanage_get_lock", test_semanage_get_lock)) {
	CU_cleanup_registry();
	return CU_get_error();
	}

	if (NULL ==
	CU_add_test(suite, "semanage_nc_sort", test_semanage_nc_sort)) {
	CU_cleanup_registry();
	return CU_get_error();
	}

	return 0;
	}

	/* Tests the semanage_store_access_check function in semanage_store.c
	*/
	void test_semanage_store_access_check(void)
	{
	int err;

	/* create lock file */
	err = mknod(readlockpath, S_IRUSR \| S_IWUSR, S_IFREG);

	/* check with permissions 000 */
	err = chmod(modpath, 0);
	CU_ASSERT(err == 0);
	err = chmod(readlockpath, 0);
	CU_ASSERT(err == 0);
	err = chmod(polpath, 0);
	CU_ASSERT(err == 0);

	err = semanage_store_access_check();
	CU_ASSERT(err == -1);

	/* check with permissions 500 */
	err = chmod(polpath, S_IRUSR \| S_IXUSR);
	CU_ASSERT(err == 0);
	err = chmod(readlockpath, S_IRUSR);
	CU_ASSERT(err == 0);
	err = chmod(modpath, S_IRUSR \| S_IXUSR);
	CU_ASSERT(err == 0);

	err = semanage_store_access_check();
	CU_ASSERT(err == SEMANAGE_CAN_READ);

	/* check with permissions 700 */
	err = chmod(polpath, S_IRUSR \| S_IWUSR \| S_IXUSR);
	CU_ASSERT(err == 0);
	err = chmod(readlockpath, S_IRUSR \| S_IWUSR);
	CU_ASSERT(err == 0);
	err = chmod(modpath, S_IRUSR \| S_IWUSR \| S_IXUSR);
	CU_ASSERT(err == 0);

	err = semanage_store_access_check();
	CU_ASSERT(err == SEMANAGE_CAN_WRITE);

	/* check with lock file 000 and others 500 */
	err = chmod(polpath, S_IRUSR \| S_IXUSR);
	CU_ASSERT(err == 0);
	err = chmod(readlockpath, 0);
	CU_ASSERT(err == 0);
	err = chmod(modpath, S_IRUSR \| S_IXUSR);
	CU_ASSERT(err == 0);

	err = semanage_store_access_check();
	CU_ASSERT(err == 0);

	/* check with lock file 000 and others 700 */
	err = chmod(polpath, S_IRUSR \| S_IWUSR \| S_IXUSR);
	CU_ASSERT(err == 0);
	err = chmod(readlockpath, 0);
	CU_ASSERT(err == 0);
	err = chmod(modpath, S_IRUSR \| S_IWUSR \| S_IXUSR);
	CU_ASSERT(err == 0);

	err = semanage_store_access_check();
	CU_ASSERT(err == 0);

	/* remove lock file */
	err = remove(readlockpath);
	CU_ASSERT(err == 0);

	/* check with no lock file and 000 */
	err = chmod(modpath, 0);
	CU_ASSERT(err == 0);
	err = chmod(polpath, 0);
	CU_ASSERT(err == 0);

	err = semanage_store_access_check();
	CU_ASSERT(err == -1);

	/* check with no lock file and 500 */
	err = chmod(polpath, S_IRUSR \| S_IXUSR);
	CU_ASSERT(err == 0);
	err = chmod(modpath, S_IRUSR \| S_IXUSR);
	CU_ASSERT(err == 0);

	err = semanage_store_access_check();
	CU_ASSERT(err == 0);

	/* check with no lock file but write in polpath */
	err = chmod(polpath, S_IRUSR \| S_IWUSR \| S_IXUSR);
	CU_ASSERT(err == 0);

	err = semanage_store_access_check();
	CU_ASSERT(err == SEMANAGE_CAN_READ);

	/* check with no lock file and 700 */
	err = chmod(polpath, S_IRUSR \| S_IWUSR \| S_IXUSR);
	CU_ASSERT(err == 0);
	err = chmod(modpath, S_IRUSR \| S_IWUSR \| S_IXUSR);
	CU_ASSERT(err == 0);

	err = semanage_store_access_check();
	CU_ASSERT(err == SEMANAGE_CAN_WRITE);
	}

	/* Tests the semanage_get_lock functions in semanage_store.c
	*/
	void test_semanage_get_lock(void)
	{
	int err;

	/* attempt to get an active lock */
	err = semanage_get_active_lock(sh);
	CU_ASSERT(err == 0);

	/* attempt to get the lock again */
	err = semanage_get_active_lock(sh);
	CU_ASSERT(err == 0);

	/* attempt to release the active lock */
	semanage_release_active_lock(sh);

	/* attempt to get an active lock */
	err = semanage_get_active_lock(sh);
	CU_ASSERT(err == 0);

	/* attempt to release the active lock */
	semanage_release_active_lock(sh);

	/* attempt to get a trans lock */
	err = semanage_get_trans_lock(sh);
	CU_ASSERT(err == 0);

	/* attempt to get the lock again */
	err = semanage_get_trans_lock(sh);
	CU_ASSERT(err == 0);

	/* attempt to release the trans lock */
	semanage_release_trans_lock(sh);

	/* attempt to get a trans lock */
	err = semanage_get_trans_lock(sh);
	CU_ASSERT(err == 0);

	/* attempt to release the trans lock */
	semanage_release_trans_lock(sh);

	/* remove the lock files */
	err = remove(readlockpath);
	CU_ASSERT(err == 0);
	err = remove(translockpath);
	CU_ASSERT(err == 0);
	}

	/* Tests the semanage_nc_sort function in semanage_store.c
	*/
	void test_semanage_nc_sort(void)
	{
	char source_buf, sorted_buf = NULL, good_buf, bad_buf;
	size_t source_buf_len, sorted_buf_len, good_buf_len, bad_buf_len;
	int sourcefd, goodfd, badfd, err;
	struct stat sb;

	/* open source file */
	sourcefd = open("nc_sort_unsorted", O_RDONLY);
	if (sourcefd < 0) {
	CU_FAIL("Missing nc_sort_unsorted test file.");
	return;
	}
	fstat(sourcefd, &sb);
	source_buf_len = sb.st_size;
	source_buf =
	(char *)mmap(NULL, source_buf_len, PROT_READ, MAP_PRIVATE, sourcefd,
	0);

	/* open good result file */
	goodfd = open("nc_sort_sorted", O_RDONLY);
	if (goodfd < 0) {
	CU_FAIL("Missing nc_sort_sorted test file.");
	goto out2;
	}
	fstat(goodfd, &sb);
	good_buf_len = sb.st_size;
	good_buf =
	(char *)mmap(NULL, good_buf_len, PROT_READ, MAP_PRIVATE, goodfd, 0);

	/* open malformed source file (missing priorities) */
	badfd = open("nc_sort_malformed", O_RDONLY);
	if (badfd < 0) {
	CU_FAIL("Missing nc_sort_malformed test file.");
	goto out1;
	}
	fstat(badfd, &sb);
	bad_buf_len = sb.st_size;
	bad_buf =
	(char *)mmap(NULL, bad_buf_len, PROT_READ, MAP_PRIVATE, badfd, 0);

	/* sort test file */
	err =
	semanage_nc_sort(sh, source_buf, source_buf_len, &sorted_buf,
	&sorted_buf_len);
	CU_ASSERT_FALSE(err);
	CU_ASSERT_STRING_EQUAL(sorted_buf, good_buf);

	/* reset for reuse in next test */
	free(sorted_buf);
	sorted_buf = NULL;

	/* sort malformed source file */
	err =
	semanage_nc_sort(sh, bad_buf, bad_buf_len, &sorted_buf,
	&sorted_buf_len);
	CU_ASSERT_EQUAL(err, -1);

	free(sorted_buf);

	munmap(bad_buf, bad_buf_len);
	close(badfd);
	out1:
	munmap(good_buf, good_buf_len);
	close(goodfd);
	out2:
	munmap(source_buf, source_buf_len);
	close(sourcefd);
	}