fastfilter::Engine Class Reference

#include <fast_filter.h>

Public Member Functions
	Engine ()
	Engine (const Config &c)
bool	load_patterns_file (const std::string &path)
bool	load_regex_file (const std::string &path)
bool	load_patterns_sqlite (const std::string &db_path, const std::string &table="phishing_rules")
Verdict	check_url (const std::string &url)
size_t	get_pattern_count () const

Private Member Functions
void	build_bloom (size_t n)

Static Private Member Functions
static void	trim (std::string &s)
static void	tolower_inplace (std::string &s)
static std::string	lowercase (const std::string &s)

Private Attributes
Config	cfg
Bloom	bloom
Automaton	ac
LRUCache	cache
size_t	total_patterns =0

Detailed Description

Definition at line 150 of file fast_filter.h.

Constructor & Destructor Documentation

Engine() [1/2]

fastfilter::Engine::Engine ( )

inline

Definition at line 152 of file fast_filter.h.

: cfg(Config{}), cache(cfg.cache_capacity) {}

References cache, and cfg.

Engine() [2/2]

fastfilter::Engine::Engine ( const Config & c )

inlineexplicit

Definition at line 153 of file fast_filter.h.

: cfg(c), cache(c.cache_capacity) {}

References cache, and cfg.

Member Function Documentation

build_bloom()

void fastfilter::Engine::build_bloom ( size_t n )

inlineprivate

Definition at line 199 of file fast_filter.h.

{ bloom.init(n>0?n:1, cfg.bloom_fp_rate); }

References bloom, fastfilter::Config::bloom_fp_rate, cfg, and fastfilter::Bloom::init().

Referenced by load_patterns_file(), and load_patterns_sqlite().

check_url()

Verdict fastfilter::Engine::check_url ( const std::string & url )

inline

Definition at line 176 of file fast_filter.h.

                                         {
    auto norm = lowercase(url);
    uint64_t key = murmur3_64(norm.data(), norm.size()); bool cv; if(cache.get(key, cv)) return {cv, cv?Verdict::AC:Verdict::NONE, cv?"cache-hit": "cache-hit"};
    if(!bloom.m_bits || !bloom.might_contain(norm)){ cache.put(key,false); return {false, Verdict::BLOOM, "bloom-negative"}; }
    bool hit = ac.search_any(norm);
    if(!hit){ cache.put(key,false); return {false, Verdict::AC, "ac-nohit"}; }
#ifdef FASTFILTER_USE_RE2
    // stage 3: regex (if any)
    for(const auto& r: regexes){ if(RE2::PartialMatch(norm, *r)){ cache.put(key,true); return {true, Verdict::REGEX, "regex-match"}; } }
    cache.put(key,true); return {true, Verdict::AC, "ac-match"};
#else
    cache.put(key,true); return {true, Verdict::AC, "ac-match"};
#endif
  }

References fastfilter::Verdict::AC, ac, fastfilter::Verdict::BLOOM, bloom, cache, fastfilter::LRUCache::get(), lowercase(), fastfilter::Bloom::m_bits, fastfilter::Bloom::might_contain(), fastfilter::murmur3_64(), fastfilter::Verdict::NONE, fastfilter::LRUCache::put(), fastfilter::Verdict::REGEX, and fastfilter::Automaton::search_any().

get_pattern_count()

size_t fastfilter::Engine::get_pattern_count ( ) const

inline

Definition at line 191 of file fast_filter.h.

{ return total_patterns; }

References total_patterns.

load_patterns_file()

bool fastfilter::Engine::load_patterns_file ( const std::string & path )

inline

Definition at line 156 of file fast_filter.h.

                                                {
    std::ifstream in(path); if(!in) return false; std::vector<std::string> pats; pats.reserve(100000);
    std::string line; while(std::getline(in,line)){ trim(line); if(line.empty()||line[0]=='#') continue; tolower_inplace(line); pats.push_back(line); }
    build_bloom(pats.size()); for(const auto& p: pats){ bloom.add(p);} for(const auto& p: pats){ ac.add(p);} ac.build(); total_patterns = pats.size(); return true;
  }

References ac, fastfilter::Automaton::add(), fastfilter::Bloom::add(), bloom, fastfilter::Automaton::build(), build_bloom(), tolower_inplace(), total_patterns, and trim().

load_patterns_sqlite()

bool fastfilter::Engine::load_patterns_sqlite ( const std::string & db_path, const std::string & table = "phishing_rules" )

inline

Definition at line 207 of file fast_filter.h.

                                                                                         {
    sqlite3* db = nullptr;
    if (sqlite3_open(db_path.c_str(), &db) != SQLITE_OK) return false;
 
    std::string sql = "SELECT pattern, is_regex FROM " + table + ";";
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
        sqlite3_close(db);
        return false;
    }
 
    std::vector<std::string> pats; pats.reserve(100000);
    std::vector<std::string> regex_pats; regex_pats.reserve(10000);
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        const unsigned char* p = sqlite3_column_text(stmt, 0);
        int is_regex = sqlite3_column_int(stmt, 1);
        if (!p) continue;
        std::string s = reinterpret_cast<const char*>(p);
        trim(s); tolower_inplace(s);
        if (s.empty()) continue;
        if (is_regex) regex_pats.push_back(s); else pats.push_back(s);
    }
    sqlite3_finalize(stmt);
    sqlite3_close(db);
 
    // build bloom + AC
    build_bloom(pats.size());
    for (auto& p : pats) bloom.add(p);
    for (auto& p : pats) ac.add(p);
    ac.build();
    total_patterns = pats.size();
 
#ifdef FASTFILTER_USE_RE2
    regexes.clear();
    for (auto& r : regex_pats) regexes.emplace_back(std::make_unique<RE2>(r));
#endif
 
    return true;
}

References ac, fastfilter::Automaton::add(), fastfilter::Bloom::add(), bloom, fastfilter::Automaton::build(), build_bloom(), tolower_inplace(), total_patterns, and trim().

load_regex_file()

bool fastfilter::Engine::load_regex_file ( const std::string & path )

inline

Definition at line 162 of file fast_filter.h.

                                             {
#ifdef FASTFILTER_USE_RE2
    std::ifstream in(path); if(!in) return false; std::string line; size_t cnt=0; regexes.clear();
    while(std::getline(in,line)){
      trim(line); if(line.rfind("Pattern:",0)==0){ std::string pat = line.substr(8); trim(pat); if(!pat.empty()){ regexes.emplace_back(std::make_unique<RE2>(pat)); cnt++; } }
    }
    return cnt>0;
#else
    (void)path; return false;
#endif
  }

References trim().

lowercase()

std::string fastfilter::Engine::lowercase ( const std::string & s )

inlinestaticprivate

Definition at line 203 of file fast_filter.h.

{ std::string t=s; tolower_inplace(t); return t; }

References tolower_inplace().

Referenced by check_url().

tolower_inplace()

void fastfilter::Engine::tolower_inplace ( std::string & s )

inlinestaticprivate

Definition at line 202 of file fast_filter.h.

{ for(char& c: s) c=(char)std::tolower((unsigned char)c); }

Referenced by load_patterns_file(), load_patterns_sqlite(), and lowercase().

trim()

void fastfilter::Engine::trim ( std::string & s )

inlinestaticprivate

Definition at line 201 of file fast_filter.h.

{ size_t a=0; while(a<s.size() && std::isspace((unsigned char)s[a])) a++; size_t b=s.size(); while(b>a && std::isspace((unsigned char)s[b-1])) b--; s.assign(s.substr(a,b-a)); }

Referenced by load_patterns_file(), load_patterns_sqlite(), and load_regex_file().

Member Data Documentation

ac

Automaton fastfilter::Engine::ac

private

Definition at line 194 of file fast_filter.h.

Referenced by check_url(), load_patterns_file(), and load_patterns_sqlite().

bloom

Bloom fastfilter::Engine::bloom

private

Definition at line 194 of file fast_filter.h.

Referenced by build_bloom(), check_url(), load_patterns_file(), and load_patterns_sqlite().

cache

LRUCache fastfilter::Engine::cache

private

Definition at line 194 of file fast_filter.h.

Referenced by check_url(), Engine(), and Engine().

cfg

Config fastfilter::Engine::cfg

private

Definition at line 194 of file fast_filter.h.

Referenced by build_bloom(), Engine(), and Engine().

total_patterns

size_t fastfilter::Engine::total_patterns =0

private

Definition at line 194 of file fast_filter.h.

Referenced by get_pattern_count(), load_patterns_file(), and load_patterns_sqlite().

---

The documentation for this class was generated from the following file:

• BastionGuard/src/filters/fast_filter.h