TEST_F(PacksTests, test_check_platform) { Pack fpack("discovery_pack", getPackWithDiscovery()); EXPECT_TRUE(fpack.checkPlatform()); // Depending on the current build platform, this check will be true or false. fpack.platform_ = kSDKPlatform; EXPECT_TRUE(fpack.checkPlatform()); fpack.platform_ = (kSDKPlatform == "darwin") ? "linux" : "darwin"; EXPECT_FALSE(fpack.checkPlatform()); fpack.platform_ = "null"; EXPECT_TRUE(fpack.checkPlatform()); fpack.platform_ = ""; EXPECT_TRUE(fpack.checkPlatform()); fpack.platform_ = "bad_value"; EXPECT_FALSE(fpack.checkPlatform()); fpack.platform_ = "posix"; if (isPlatform(PlatformType::TYPE_POSIX) || isPlatform(PlatformType::TYPE_LINUX) || isPlatform(PlatformType::TYPE_OSX) || isPlatform(PlatformType::TYPE_FREEBSD)) { EXPECT_TRUE(fpack.checkPlatform()); } if (isPlatform(PlatformType::TYPE_WINDOWS)) { EXPECT_FALSE(fpack.checkPlatform()); } }
bool Map::isAnyPlatformBelow(float X, float Y) { Y += pPlayer_sy; short current_px = -1 * pOffset_X; short next_px = current_px + pSize; int index_x = pos_X; while (!(current_px <= X && next_px > X)) { ++index_x; current_px = next_px; next_px += pSize; } short current_py = App::getScreenHeight(); short next_py = current_py - pSize; int index_y = pAmountEntityVertical - 1; while (!(current_py >= Y && next_py < Y)) { --index_y; current_py = next_py; next_py -= pSize; } if (isPlatform(pMap[index_x][index_y]) || isPlatform(pMap[index_x + 1][index_y])) return true; return false; }
QueryData genChromeExtensions(QueryContext& context) { fs::path chromePath; /// Each home directory will include custom extensions. if (isPlatform(PlatformType::TYPE_WINDOWS)) { chromePath = "\\AppData\\Local\\Google\\Chrome\\User Data\\%\\Extensions\\"; } else if (isPlatform(PlatformType::TYPE_OSX)) { chromePath = "/Library/Application Support/Google/Chrome/%/Extensions/"; } else { chromePath = "/.config/google-chrome/%/Extensions/"; } return genChromeBasedExtensions(context, chromePath); }
std::shared_ptr<PlatformProcess> PlatformProcess::launchTestPythonScript( const std::string& args) { std::string osquery_path; auto osquery_path_option = getEnvVar("OSQUERY_DEPS"); if (osquery_path_option) { osquery_path = *osquery_path_option; } else { if (!isPlatform(PlatformType::TYPE_FREEBSD)) { osquery_path = "/usr/local/osquery"; } else { osquery_path = "/usr/local"; } } // The whole-string, space-delimited, python process arguments. auto argv = osquery_path + "/bin/python " + args; std::shared_ptr<PlatformProcess> process; int process_pid = ::fork(); if (process_pid == 0) { // Start a Python script ::execlp("sh", "sh", "-c", argv.c_str(), nullptr); ::exit(0); } else if (process_pid > 0) { process.reset(new PlatformProcess(process_pid)); } return process; }
void SetUp() override { if (isPlatform(PlatformType::TYPE_WINDOWS)) { socket_path = OSQUERY_SOCKET; } else { socket_path = kTestWorkingDirectory; } socket_path += "testextmgr" + std::to_string(rand()); if (!isPlatform(PlatformType::TYPE_WINDOWS)) { remove(socket_path); if (pathExists(socket_path)) { throw std::domain_error("Cannot test sockets: " + socket_path); } } }
TEST_F(FlagsTests, test_platform) { PlatformType mPlatformType = PlatformType::TYPE_POSIX; EXPECT_TRUE(isPlatform(PlatformType::TYPE_POSIX, mPlatformType)); mPlatformType = PlatformType::TYPE_OSX | PlatformType::TYPE_POSIX; EXPECT_TRUE(isPlatform(PlatformType::TYPE_POSIX, mPlatformType)); EXPECT_TRUE(isPlatform(PlatformType::TYPE_OSX, mPlatformType)); // Now set and check a valid casting. mPlatformType = static_cast<PlatformType>(8); EXPECT_EQ(PlatformType::TYPE_LINUX, mPlatformType); // Set something that doesn't make sense mPlatformType = PlatformType::TYPE_WINDOWS | PlatformType::TYPE_BSD; EXPECT_FALSE(isPlatform(PlatformType::TYPE_LINUX, mPlatformType)); EXPECT_FALSE(isPlatform(PlatformType::TYPE_OSX, mPlatformType)); }
void TearDown() override { Dispatcher::stopServices(); Dispatcher::joinServices(); if (!isPlatform(PlatformType::TYPE_WINDOWS)) { remove(socket_path); } }
QueryData genListeningPorts(QueryContext& context) { QueryData results; auto sockets = SQL::selectAllFrom("process_open_sockets"); for (const auto& socket : sockets) { if (socket.at("family") == kAF_UNIX && socket.at("path").empty()) { // Skip anonymous unix domain sockets continue; } if ((socket.at("family") == kAF_INET || socket.at("family") == kAF_INET6) && socket.at("remote_port") != "0") { // Listening UDP/TCP ports have a remote_port == "0" continue; } Row r; r["pid"] = socket.at("pid"); if (socket.at("family") == kAF_UNIX) { r["port"] = "0"; r["path"] = socket.at("path"); r["socket"] = "0"; } else { r["address"] = socket.at("local_address"); r["port"] = socket.at("local_port"); auto socket_it = socket.find("socket"); if (socket_it != socket.end()) { r["socket"] = socket_it->second; } else { r["socket"] = "0"; } } r["protocol"] = socket.at("protocol"); r["family"] = socket.at("family"); auto fd_it = socket.find("fd"); if (fd_it != socket.end()) { r["fd"] = fd_it->second; } else { r["fd"] = "0"; } // When running under linux, we also have the user namespace // column available. It can be used with the docker_containers // table if (isPlatform(PlatformType::TYPE_LINUX)) { r["net_namespace"] = socket.at("net_namespace"); } results.push_back(r); } return results; }
QueryData genPythonPackages(QueryContext& context) { QueryData results; std::set<std::string> paths; if (context.constraints.count("directory") > 0 && context.constraints.at("directory").exists(EQUALS)) { paths = context.constraints["directory"].getAll(EQUALS); } else { paths = kPythonPath; } for (const auto& key : paths) { genSiteDirectories(key, results); } if (isPlatform(PlatformType::TYPE_OSX)) { for (const auto& dir : kDarwinPythonPath) { std::vector<std::string> versions; if (!listDirectoriesInDirectory(dir, versions, false).ok()) { continue; } for (const auto& version : versions) { // macOS will link older versions to 2.6. auto version_path = fs::path(version).parent_path(); if (fs::is_symlink(symlink_status(version_path))) { continue; } auto complete = version + "lib/python" + version_path.filename().string() + "/site-packages/"; genSiteDirectories(complete, results); } } } else if (isPlatform(PlatformType::TYPE_WINDOWS)) { // Enumerate any system installed python packages auto installPathKey = "HKEY_LOCAL_MACHINE\\" + kWinPythonInstallKey; genWinPythonPackages(installPathKey, results); // Enumerate any user installed python packages installPathKey = "HKEY_USERS\\%\\" + kWinPythonInstallKey; genWinPythonPackages(installPathKey, results); } return results; }
TEST_F(LoggerTests, test_recursion) { // Stop the internal Glog facilities. google::ShutdownGoogleLogging(); auto& rf = RegistryFactory::get(); auto plugin = std::make_shared<RecursiveLoggerPlugin>(); rf.registry("logger")->add("recurse", plugin); EXPECT_TRUE(rf.exists("logger", "recurse")); EXPECT_TRUE(rf.setActive("logger", "recurse").ok()); FLAGS_logtostderr = true; initStatusLogger("logger_test"); initLogger("logger_test"); LOG(WARNING) << "Log to the recursive logger"; EXPECT_EQ(1U, plugin->statuses); FLAGS_logger_status_sync = false; LOG(WARNING) << "recurse"; if (isPlatform(PlatformType::TYPE_WINDOWS)) { for (size_t i = 0; i < 100; i++) { std::this_thread::sleep_for(std::chrono::microseconds(10)); if (plugin->statuses == 3U) { break; } } } EXPECT_EQ(3U, plugin->statuses); // Try again with the tool type as a daemon. auto tool_type = kToolType; kToolType = ToolType::DAEMON; LOG(WARNING) << "recurse"; // The daemon calls the status relay within the scheduler. EXPECT_EQ(3U, plugin->statuses); // All of recursive log lines will sink during the next call. relayStatusLogs(true); EXPECT_EQ(4U, plugin->statuses); relayStatusLogs(true); EXPECT_EQ(5U, plugin->statuses); kToolType = tool_type; EXPECT_EQ(0U, queuedStatuses()); EXPECT_EQ(0U, queuedSenders()); // Make sure the test file does not create a filesystem log. // This will happen if the logtostderr is not set. EXPECT_FALSE(pathExists("logger_test.INFO")); FLAGS_logtostderr = false; }
TEST_F(SQLiteUtilTests, test_table_attributes_event_based) { { SQLInternal sql_internal("select * from process_events"); if (!isPlatform(PlatformType::TYPE_WINDOWS)) { EXPECT_TRUE(sql_internal.ok()); EXPECT_TRUE(sql_internal.eventBased()); } } { SQLInternal sql_internal("select * from time"); EXPECT_TRUE(sql_internal.ok()); EXPECT_FALSE(sql_internal.eventBased()); } }
bool Pack::checkPlatform(const std::string& platform) const { if (platform.empty() || platform == "null") { return true; } if (platform.find("any") != std::string::npos || platform.find("all") != std::string::npos) { return true; } auto linux_type = (platform.find("linux") != std::string::npos || platform.find("ubuntu") != std::string::npos || platform.find("centos") != std::string::npos); if (linux_type && isPlatform(PlatformType::TYPE_LINUX)) { return true; } auto posix_type = (platform.find("posix") != std::string::npos); if (posix_type && isPlatform(PlatformType::TYPE_POSIX)) { return true; } return (platform.find(kSDKPlatform) != std::string::npos); }
TEST_F(FilesystemLoggerTests, test_log_status) { if (isPlatform(PlatformType::TYPE_WINDOWS)) { // Cannot test status deterministically on windows. return; } initStatusLogger("osqueryd"); initLogger("osqueryd"); LOG(WARNING) << "Filesystem logger test is generating a warning status (1/3)"; auto status_path = fs::path(FLAGS_logger_path) / "osqueryd.INFO"; EXPECT_TRUE(osquery::pathExists(status_path)); std::string content; EXPECT_TRUE(readFile(status_path, content)); auto lines = osquery::split(content, "\n").size(); EXPECT_EQ(4U, lines); LOG(WARNING) << "Filesystem logger test is generating a warning status (2/3)"; content.clear(); readFile(status_path, content); lines = osquery::split(content, "\n").size(); EXPECT_EQ(5U, lines); auto& rf = RegistryFactory::get(); auto filesystem_test = std::make_shared<FilesystemTestLoggerPlugin>(); rf.registry("logger")->add("filesystem_test", filesystem_test); EXPECT_TRUE(rf.setActive("logger", "filesystem,filesystem_test").ok()); LOG(WARNING) << "Filesystem logger test is generating a warning status (3/3)"; content.clear(); readFile(status_path, content); lines = osquery::split(content, "\n").size(); EXPECT_EQ(6U, lines); relayStatusLogs(true); content.clear(); readFile(status_path, content); lines = osquery::split(content, "\n").size(); EXPECT_EQ(6U, lines); }
void Initializer::initShell() const { // Get the caller's home dir for temporary storage/state management. auto homedir = osqueryHomeDirectory(); if (osquery::pathExists(homedir).ok()) { // Only apply user/shell-specific paths if not overridden by CLI flag. if (Flag::isDefault("database_path")) { osquery::FLAGS_database_path = (fs::path(homedir) / "shell.db").make_preferred().string(); } if (Flag::isDefault("extensions_socket")) { if (isPlatform(PlatformType::TYPE_WINDOWS)) { osquery::FLAGS_extensions_socket = "\\\\.\\pipe\\shell.em"; } else { osquery::FLAGS_extensions_socket = (fs::path(homedir) / "shell.em").make_preferred().string(); } } } else { fprintf( stderr, "Cannot access or create osquery home: %s", homedir.c_str()); FLAGS_disable_extensions = true; FLAGS_disable_database = true; } }
/** Sciaga ze stosu ostatni element na ktorym wykryto kolizje */ short Map::checkColision(const short& Player_x, const short& Player_y,ColisionSide& cSide) { pPlayer_x = Player_x; pPlayer_y = Player_y; /** Pobieranie kolizcji z bonusem badz przeszkoda ( kolizje bez powtorzen ) * odlozonej na stos podczas rysowania */ short result = -1; if (pColisionStack.size() > 0) { Point point = pColisionStack.top(); pColisionStack.pop(); short X = point.X; short Y = point.Y; if (!itWasReturn[X][Y]) { itWasReturn[X][Y] = true; result = pMap[X][Y]; if ( isBonus( result ) || isAdditionalBonus( result ) ) { drawID->at(X)[Y] = false; return result; } } } { /** wykrywanie kolizji z platforma */ short X = Player_x + 5; short Y = Player_y; short current_px = -1 * pOffset_X; short next_px = current_px + pSize; ushort index_x = pos_X; // szukanie kolumny w ktorej jest kolizja while (!(current_px <= X && next_px > X)) { ++index_x; current_px = next_px; next_px += pSize; } ushort current_py = App::getScreenHeight(); ushort next_py = current_py - pSize; int index_y = pAmountEntityVertical - 1; // szukanie wiersza w ktorym jest kolizja od gory while (!(current_py >= Y && next_py < Y)) { --index_y; current_py = next_py; next_py -= pSize; } if (isPlatform(pMap[index_x][index_y]) || isPlatform(pMap[index_x + 1][index_y])) { cSide.up = true; cSide.pos_Y_px = current_py; } current_py = App::getScreenHeight(); next_py = current_py - pSize; index_y = pAmountEntityVertical - 1; Y = Player_y + pPlayer_sy; // szukanie wiersza w ktorym jest kolizja od dolu while (!(current_py >= Y && next_py < Y)) { --index_y; current_py = next_py; next_py -= pSize; } if (isPlatform(pMap[index_x][index_y]) || isPlatform(pMap[index_x + 1][index_y])) { cSide.down = true; cSide.pos_Y_px = (current_py - 3 * pSize) + 1; } current_py = App::getScreenHeight(); next_py = current_py - pSize; index_y = pAmountEntityVertical - 1; Y = Player_y; // szukanie wiersza w ktorym kolizja jest od boku while (!( current_py < Y + pPlayer_sy && current_py > Y && next_py < Y + pPlayer_sy && next_py > Y ) ) { --index_y; current_py = next_py; next_py -= pSize; if( index_y < 0 ) break; } if( index_y > 0 && ( isPlatform(pMap[index_x][index_y]) || isPlatform(pMap[index_x + 1][index_y]) )) { float halfTiles = current_py - 0.5 * pSize; float halfPlayer = pPlayer_y + 0.5 * pPlayer_sy; if( halfTiles < halfPlayer ) { cSide.up = true; cSide.pos_Y_px = current_py; } else { cSide.down = true; cSide.pos_Y_px = (current_py - 3 * pSize) + 1; } } } //END ADD return (result); }