rule silent_banker : banker // 分类空白
{
    meta:
        description = "This is just an example"
        thread_level = 3    // 威胁等级3
        in_the_wild = true  // 这条规则是基于真实世界中捕获的样本写的，不是仅用于测试或概念验证
    strings:
        $a = {6A 40 68 00 30 00 00 6A 14 8D 91}
        $b = {8D 4D B0 2B C1 83 C0 27 99 6A 4E 59 F7 F9}
        $c = "UVODFRYSIHLNWPEJXQZAKCBGMT"
    condition:
        $a or $b or $c
}

import "pe"
rule pe_example
{
    condition:
        pe.number_of_sections == 1
        pe.exports("CPlApplet")
        // 判断目标 PE文件是否导出了名为CPlApplet的函数
        // 这是一个Windows控制面板小程序必须导出的函数，Windows会调用这个函数来与.cpl文件进行交互
        // 如果一个PE文件.dll/.cpl导出了这个函数，那么它极有可能是一个控制面板小程序
        pe.characteristics & pe.DLL
        // pe特性字段位与pe.DLL，判断当前文件是否是dll文件
}

import "elf"
rule single_section
{
    condition:
        elf.number_of_sections == 1
        elf.machine == elf.EM_X86_64
}

# 传统的YARA规则主要依赖于文件中的字符串、结构、二进制特征等静态内容
# 传统规则基于静态字符串的检测如下所示
#   1.误报(合法程序可能只是把这个域名当作文档、示例或者调试信息写进了文件，并不会真正访问该域名)
#   2.漏报(真正的恶意程序可能根本不会以明文形式存储域名，而是加密、Base64 编码、拆分拼接等方式)
# cuckoo模块允许动态行为与静态内容联合分析, Cuckoo模块为执行文件生成行为报告

rule evil_domain
{
    strings:
        $domain = "someone.doingevil.com"
    condition:
        $domain
}

yara -x cuckoo=behavior.json rules.yar malware.exe
import "cuckoo"
rule evil_doer
{
    strings:
        $some_string = { 01 02 03 04 05 06 }

    condition:
        $some_string and
        cuckoo.network.http_request(/http:\/\/someone\.doingevil\.com/)
        // cuckoo模块会加载behavior.json文件，该文件又cuckoo生成，进而判断威胁
}

import "magic"
rule is_pdf
{
    condition:
        magic.mime_type == "application/pdf"
}

import "hash"
rule detect_known_hash
{
    condition:
        hash.sha256(0, filesize) == "a7a287d6ce872f9ab6fffc31db9f6369"
        // 参数0表示文件的偏移
}

import "time"
rule created_after_2024
{
    condition:
        time.created > 1704067200  // 2024-01-01 00:00:00 UTC
        // 判断文件是否是2024年后创建
}

#include <yara/modules.h>

#define MODULE_NAME demo

int my_hello_function(
    YR_OBJECT* function_obj,
    YR_SCAN_CONTEXT* context,
    int argc,
    YR_OBJECT_FUNCTION_ARGUMENT* args,
    YR_OBJECT** result)
{
    // 创建一个返回值对象并设置值
    *result = yr_object_create(YR_OBJECT_STRING, NULL);
    if (*result == NULL)
        return ERROR_INSUFFICIENT_MEMORY;
    return yr_object_set_string(*result, "Hello from YARA module", context);
}

int my_add_function(
    YR_OBJECT* function_obj,
    YR_SCAN_CONTEXT* context,
    int argc,
    YR_OBJECT_FUNCTION_ARGUMENT* args,
    YR_OBJECT** result)
{
    int a = args[0].value.i;
    int b = args[1].value.i;

    *result = yr_object_create(YR_OBJECT_INTEGER, NULL);
    if (*result == NULL)
        return ERROR_INSUFFICIENT_MEMORY;
    return yr_object_set_integer(*result, a + b, context);
}

begin_declarations;
  
  // 申明可以在规则中使用的函数和数据结构
  declare_string("greeting");
  
  // 更复杂的数据结构
  begin_struct("some_structure");
    declare_integer("foo");
    begin_struct("nested_structure");
        declare_integer("bar");
        declare_string_array("bat");
        declare_string("baq");
        declare_float("tux");
    end_struct("nested_structure");
  end_struct("some_structure");
  
  // "ii"表示接受两个整数参数, "i"表示返回整数
  declare_function("add", "ii", "i", my_add_function);
  declare_function("hello", "", "s", my_hello_function);
end_declarations;

int module_initialize(  
    YR_MODULE* module)
{
  // 模块的构造函数，函数允许开发者初始化模块可能使用的全局化的数据结构
  return ERROR_SUCCESS;
}

int module_finalize(  
    YR_MODULE* module)
{
  // 模块的析构函数
  return ERROR_SUCCESS;
}

int module_load(
    YR_SCAN_CONTEXT* context,
    YR_OBJECT* module_object,
    void* module_data,
    size_t module_data_size)
{
  // 这个函数会在每个被扫描的文件上调用一次，但前提是某个规则通过import指令导入了该模块
  // module_load函数是模块获取扫描文件的机会，在这个阶段你可以以你喜欢的方式分析或解析这个文件，然后将分析结果填充到你在模块的declarations部分定义的数据结构中
  // 下面操作将"Hello World!"赋值给前期定义的greeting变量
  set_string("Hello World!", module_object, "greeting");
  return ERROR_SUCCESS;
}

int module_unload(
    YR_OBJECT* module_object)
{
  // 允许开发者在此刻释放在module_load阶段申请的相关资源
  return ERROR_SUCCESS;
}

#undef MODULE_NAME

import "demo"
rule use_hello
{
    condition:
        demo.hello() contains "Hello"
}

#include <unistd.h>
#include "yara.h"

void compile_callback(int error, const char *file, int line, const YR_RULE *rule, const char *msg, void *data) {
  fprintf(stderr, "[%s] %s:%d: %s\n", error == YARA_ERROR_LEVEL_WARNING ? "warning" : "error", file, line, msg);
}

// 函数必须返回CALLBACK_CONTINUE，CALLBACK_ABORT，CALLBACK_ERROR
int scan_callback(YR_SCAN_CONTEXT *ctx, int message, void *message_data, void *user_data) {
  int result = CALLBACK_CONTINUE;
  YR_RULES *rule = NULL;
  YR_MODULE_IMPORT *module = NULL;
  YR_OBJECT_STRUCTURE *obj = NULL;
  switch (message) {
    case CALLBACK_MSG_RULE_MATCHING:
    case CALLBACK_MSG_RULE_NOT_MATCHING:
      rule = (YR_RULES *)message_data;
      fprintf(stdout, "threat %s\r\n", message == CALLBACK_MSG_RULE_MATCHING ? "found" : "not found");
      break;
    case CALLBACK_MSG_IMPORT_MODULE:
      // 模块导入时调用，每扫描一个文件都会调用，只要规则中包含import语句
      // 初始化module结构体中，data和size字段，data字段存放cuckoo的json报告，size内容大小
      module = (YR_MODULE_IMPORT *)message_data;
      break;
    case CALLBACK_MSG_MODULE_IMPORTED:
      // 模块导入完成时调用
      // 可以根据加载结果输出日志或做统计分析
      obj = (YR_OBJECT_STRUCTURE *)message_data;
      break;
    case CALLBACK_MSG_SCAN_FINISHED:
      fprintf(stdout, "scan finish\r\n");
      break;
    default:
      break;
  }
  return result;
};

YR_RULES *do_yara_rule_load(YR_COMPILER *compiler) {
  YR_RULES *rules = NULL;
  struct {
    const char *name;
    FILE *f;
  } predef_rules[] = {
      {"./rules/malware.yar", NULL},
  };

  yr_compiler_set_callback(compiler, compile_callback, NULL);
  for (int i = 0; i < sizeof(predef_rules) / sizeof(predef_rules[0]); i++) {
    predef_rules[i].f = fopen(predef_rules[i].name, "r");
    if (!predef_rules[i].f) {
      fprintf(stderr, "failed to open yara rule %s \r\n", predef_rules[i].name);
      goto done;
    }
    int errors = yr_compiler_add_file(compiler, predef_rules[i].f, NULL, NULL);
    if (errors) {
      fclose(predef_rules[i].f);
      fprintf(stderr, "failed to compile %s, total %d errors find\r\n", predef_rules[i].name, errors);
      break;
    }
    fclose(predef_rules[i].f);
  }
  // yr_rules_save() and yr_rules_load() 可以保存和加载已编译的规则
  // 一旦yr_compiler_get_rules调用，后面不可以再编译规则
  yr_compiler_get_rules(compiler, &rules);
  yr_rules_save(rules, "rules.compile");
done:
  return rules;
}

int main(int argc, char** argv) {
  int result = -1;
  YR_COMPILER *compiler = NULL;
  YR_RULES *rules = NULL;

  // 分配库运行所需的资源，初始化内部的数据结构
  // 在使用规则前必须使用yara编译器将规则编译成二进制形式
  // 多线程环境只需要主线程调用初始化构造与析构函数

  if (yr_initialize()) {
    fprintf(stderr, "failed to inital yara\r\n");
    return 0;
  }

  if (yr_compiler_create(&compiler)) {
    fprintf(stderr, "failed to create yara compiler\r\n");
    goto done;
  }

  // 如果你的规则中引用外部变量，必须在编译前定义，在编译后你可以改变该值，编译期间只做检查而已
  // yr_compiler_define_integer_variable(compiler, "my_var", 0);
  if (access("rules.compile", F_OK) != 0) {
    if (!(rules = do_yara_rule_load(compiler))) goto done;
  } else
    yr_rules_load("rules.compile", &rules);

  // 把大象塞进冰箱的最后一步，就是调用yr_rules_scan_xxx函数族扫描文件
  // flag字段目前只支持SCAN_FLAGS_FAST_MODE和0，fastmod表示一旦某个字符串在文件中被找到，后续即使它再次出现，也不会再被匹配
  // timeout字段0表示永不超时
  // yr_scanner_xxx函数族也可以扫描文件内存等
  yr_rules_scan_file(rules, "test.txt", SCAN_FLAGS_FAST_MODE, scan_callback, NULL, 0);
  result = 0;
done:
  if (rules) yr_rules_destroy(rules);
  if (compiler) yr_compiler_destroy(compiler);
  yr_finalize();
  return result;
}

rule apt_UAC0063_Settings_xml_containing_VBE {   
       meta:   
           intrusion_set = "UAC-0063"   
           description = "Detects settings.xml file containing a VBE in hex"   
           source = "Sekoia.io"   
           creation_date = "2024-12-03"   
           classification = "TLP:GREEN"   
           hash = "e3f6d079d99eeb54566fc37fa24ff6f7"   
       strings:   
           $start = "<w:settings"   
           $vbe_head = "23407e5e"   
           $vbe_tail = "5e237e40"   
           $var = "w:val="   
       condition:   
           filesize < 50KB   
           and $start   
           and $vbe_head   
           and $vbe_tail   
           and #var > 100   
   }