言

很久没做内网了，温习一下。希望正在学习安全的小伙伴不要踏入我初学内网的误区。
先来谈谈我对内网的理解吧，不是技术的方向。
内网学的东西很多，很杂。当时我问了我的大哥，他给我的一句话确实影响我至今。我说内网就说信息收集，cmd命令能收集，powershell收集也很多，还有类似wmic，或者一些脚本语言写的信息收集工具，太多了，这些都要学真的太浪费时间了。他是这么跟我说的，很多东西你要学一辈子都学不完，但是你把一个东西学好了，结果都是一样的。确实是这么个道理，学习需要广度，能让你碰到不同的情况乃至极限情况你有解决问题的思路。学习需要深度，你能在正常情况下创造乃至开辟一条新的道路。所以说完全没有必要什么命令都背什么命令都记得清清楚楚，最重要的是要有自己的一套渗透手法，能够达到效果，就是好的。没人在乎你的过程，除非你真的很6。好了。开始今天的主题。
内网这一块不是我的擅长，但是也有幸参加过一些护网，做过一点内网渗透。总结性的来说说我的思路。
一般来说，我们拿了权限做的第一件事是维权，维权这一块以后再说。因为现在很多时候涉及免杀，免杀这一块我研究的不是很多。然后就会对当前主机进行信息收集。我就献丑说一下自己的信息收集思路。可能命令不是很多，都是靠平时自己收集的，主要是提供一个思路，如何实现自动化并且不触发告警，才是应该操心的。

文件类

（1）配置文件
如果是从web打进去的，配置文件是一定要找到，找到了数据库的账号密码，如果是站库分离可能会拿下第二台，如果不是也能获取数据库的数据，或者说用来做密码复用。配置文件一般就在web目录找config等标志性文件。其中如果密码存在加密的大众系统可以试试去github找找有没有解密脚本。自定义的加密可以尝试找源码进行破解。

（2）敏感文件
桌面是一定要看的，很多人有保存文件在桌面的习惯，特别是个人机。很有可能记录了一些密码信息或者其他网站的登录账号密码信息，以及一些敏感文件。
（3）其他目录
这种就是比较随缘了，因为个人习惯不同，稍微有点安全的人可能不会放在桌面，放在D盘啊等地方。这种可能就不是很好找，但是也可以全局搜索文件名，文件内容包含passwd，user，password等字段的文件。回收站也可以看看。
下面放一些我常用的命令，来源于之前记录的别人发的，但是原文找不到了。自己根据实际情况改。

dir %APPDATA%\Microsoft\Windows\Recent //查看最近打开的文档
findstr /si password  config.*  *.ini *.txt *.properties //递归搜索后面文件的password字段
dir /a /s /b "*conf*" > 1.txt    //递归查找当前目录包含conf的文件
findstr /s /i /c:"Password" 目录\*.txt  //递归查找目录下的txt中的oassword字段
for /r 目录 %i in (account.docx,pwd.docx,login.docx,login*.xls) do @echo  %i >> C:\Users\e0mlja\desktop\123.txt     //递归查找目录下的敏感文件输出到桌面123.txt中
指定目录搜索各类敏感文件
dir /a /s /b d:\"*.txt"
dir /a /s /b d:\"*.xml"
dir /a /s /b d:\"*.mdb"
dir /a /s /b d:\"*.sql"
dir /a /s /b d:\"*.mdf"
dir /a /s /b d:\"*.eml"
dir /a /s /b d:\"*.pst"
dir /a /s /b d:\"*conf*"
dir /a /s /b d:\"*bak*"
dir /a /s /b d:\"*pwd*"
dir /a /s /b d:\"*pass*"
dir /a /s /b d:\"*login*"
dir /a /s /b d:\"*user*"
收集各类账号密码信息
findstr /si pass *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si userpwd *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si pwd *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si login *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si user *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak

第一阶段：计算机信息类

毕竟域环境多了一些拿域控，或者kerberos认证等等的东西，就还是分开吧。很多时候盲目地去找一些命令是徒劳无功的，最主要是你要清楚自己要做什么，针对性的作信息收集。这里都是说得手动的，工具类的会放到最后面。

工作组

（1）ip信息（主要判断自己的位置已经确定能横向的方向）

ipconfig /all 网卡信息 
route print 查看路由表 看能到达的地方
arp -a 查看arp表 看缓存
hosts  文件

还有其他的可以自行去做去找，正常情况下这几个命令也够了，wmic ps那些也可以做到，但是没必要，集成的现在太容易被杀了，其他工具也还是靠着平时自己积累。

（2）端口收集（主要是判断开放了哪些端口，和哪些机器连通，有没有后续利用的可能）
netstat-ano //一条就够了，不需要太多的花里胡哨 也可以自己去根据习惯找一些其他的方式。还有一些简化的比如查看特定状态端口根据自己的需要去筛选。findstr命令等实现。

（3）进程收集（主要是看看开启了哪些进程，管理员进程可能涉及提权，杀软进程可能涉及免杀，还有一些第三方的进程可能涉及可以做权限维持，这种都是根据需要去确定的）

tasklist /svc //查看所有进程
tasklist /v //查看进程启动的用户
taskkill /f /PID //关闭某个pid的进程
wmic /namespace:\\root\securitycenter2 path antivirusproduct GET displayName,productState,pathToSignedProductExe //查看本机杀软

对于防火墙配置一类的，我这里没有涉及，是因为特殊情况下才会做。
（4）服务收集（主要是可能涉及一些提权，已经从服务中提取敏感信息比如说抓取密码等，可以通过产品和进程去判断）

wmic product get name,version
tasklist /svc
wmic service list brief //服务信息收集

（5）计划任务 （涉及提权，权限维持等，也可能通过计划任务发现脚本文件中可能存在敏感内容）

schtasks /query

（6）用户收集（主要是对提权或者横向移动做铺垫）

net user 查看用户
net localgroup Administrators 查看管理员组
whoami 当前用户

（7）凭证收集

（1）hash mimikatz
（2）浏览器及第三方软件密码 （利用各种工具或自己写）
（3）wifi密码等
（4）rdp密码

这一块最常用的还是抓hash，肯定首推是mimikatz。不过要做好免杀，免杀的方式就不说了，之前测试一些脚本加载过某0还是没有问题的，现在很久没用过了不知道了。关于其他的一些比如xshell，浏览器密码抓取的工具，就需要自己平时多收集了，当前有条件的自己写也还是没问题的。还要个人机上一些wifi密码可能也有用，这个就看自己习惯了。

（8）其他收集（主要是一些共享啊之类的）

net share  //查看共享
net use //查看ipc$
systeminfo //查看计算机信息（提权可能会用，也能判断域环境已经操作系统版本）
wmic startup get command,caption 查看自启动
wmic share get name,path,status 查看共享 
net start 查看当前机器启动的服务 
cmdkey /l# 查看保存的凭证

域环境

工作组的环境比较单一，且鉴权都是在本地做，所以没有太多的花里胡哨。域环境可能会麻烦一点，接下来我会从思路上去简述信息收集，争取能够给大家一个比较清晰的脑图，现在我们暂定我们的目标是域控。

（1）当我们拿到一个机器之后，肯定是先判断域环境
（2）确实是域环境以后，要对本机做信息收集
（3）需要判断域控
（4）鉴于有委派或者约束委派这些攻击方式，可能会需要查找一些服务用户，也就是spn相关。
（5）域环境中exchange的权限很高的，有经验的老师傅可能会进来就找邮服，这一块我没有做过，就说一下我自己收集的。
（6）面试的时候会必问的问题，如果寻找域控，如何拿下域控，对于这些方法需要的前提，都是我们必须要进行收集的。

对于本机的收集上面重复的我就不多说了，注意一下下面的点就行了。

（1）ip收集

此时的ip收集我们需要关注一下dns，因为通常情况下，域控可能就是dns服务器。

（2）端口搜集

本机端口收集还是正常的和工作组一样

（3）进程收集

此时的进程收集我们需要留意一下域管启用的进程，如果能够窃取hash，或者直接导出域管hash，基本已经意味着我们有域控权限了。

（4）服务收集

setspn -T domain -q */* //spn收集 后续能利用的太多了，搜索服务用户，搜索域中存在的服务

（5）用户与机器收集

wmic useraccount get /all 查看域用户详情
net user /domain ------> 查询域用户
net group /domain ------> 查询域里面的工作组
net group "domain admins" /domain ------> 查询域管理员用户组
net localgroup administrators /domain ------> 登录本机的域管理员
query user || qwinsta 查看在线用户
net view ------> 查询同一域内机器列表 
net view /domain ------> 查询域列表

（6）凭证收集

和上面一样，只不过这里可以针对权限区分出来从目前的用户看我们有什么权限

（7）其他收集

也是属于捡垃圾了，杂七杂八的收集，没想到，想到了再说。

第二阶段：横向信息收集

经过我们上面各个模块的收集完成后，我们对我们当前计算机的情况已经有所了解了。该提权提权，改拿小本本记录就记录。现在进入第二阶段了，横向移动的收集。横向我分为两种，一种是定向横向，比如我专门打邮服，或者专门打弱口令，只扫描特定端口。还有一种是全方位横向，就是我对所有可达的ip端都进行探测，这种动静就会比较大，但是横向最主要其实也是收集ip和端口了。有web业务打web，有弱口令能ssh或者rdp就试试，ftp能匿名访问也是分，redis未授权可能还能弹回来个shell。这里就八仙过海各显神通了。我这里分为ip和端口进行收集来讨论。
ip类
集成的工具最后再说，先说手动的。
常见的可能是利用脚本或者cmd命令进行收集。这里列举几个

1:ping
for /l %i in (1,1,255) do @ping 172.16.2.%i -w 1 -n 1|find /i "ttl="
2.powershell
1..255 | % {echo "192.168.158.$_"; ping -n 1 -w 100 192.168.158.$_} | Select-String ttl
3.集成脚本
@echo off

rem 内网存活段自动发现脚本 [Windows] 
rem By Klion
rem 2020.7.1

setlocal enabledelayedexpansion

for /l %%i in (0,1,255) do (
  for /l %%k in (0,1,255) do (
    ping -w 1 -n 1 10.%%i.%%k.1 | findstr "TTL=" >nul || ping -w 1 -n 1 10.%%i.%%k.254 | findstr "TTL=" >nul
    if !errorlevel! equ 0 (echo 10.%%i.%%k.0/24 is alive ! >> alive.txt ) else (echo 10.%%i.%%k.0/24 May be sleeping ! )
  )
)

for /l %%s in (16,1,31) do (
  for /l %%d in (0,1,255) do (
    ping -n 1 -w 1 172.%%s.%%d.1  | findstr "TTL=" >nul || ping -w 1 -n 1 172.%%s.%%d.254 | findstr "TTL=" >nul
    if !errorlevel! equ 0 (echo 172.%%s.%%d.0/24 is alive ! >> alive.txt ) else (echo 172.%%s.%%d.0/24 May be sleeping ! )
  )
)

for /l %%t in (0,1,255) do (
  ping -n 1 -w 1 192.168.%%t.1  | findstr "TTL=" >nul || ping -n 1 -w 1 192.168.%%t.254 | findstr "TTL=" >nul
  if !errorlevel! equ 0 (echo 192.168.%%t.0/24 is alive ! >> alive.txt ) else (echo 192.168.%%t.0/24 May be sleeping ! )
)
4.自己利用python等写一些扫描的脚本
5.利用arp，netBios，tcp，udp等协议探测

端口类

1.python
# This script runs on Python 3
import socket, threading

def TCP_connect(ip, port_number, delay, output):
    TCPsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    TCPsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    TCPsock.settimeout(delay)
    try:
        TCPsock.connect((ip, port_number))
        output[port_number] = 'Listening'
    except:
        output[port_number] = ''

def scan_ports(host_ip, delay):

    threads = []        # To run TCP_connect concurrently
    output = {}         # For printing purposes

    # Spawning threads to scan ports
    for i in range(10000):
        t = threading.Thread(target=TCP_connect, args=(host_ip, i, delay, output))
        threads.append(t)

    # Starting threads
    for i in range(10000):
        threads[i].start()

    # Locking the script until all threads complete
    for i in range(10000):
        threads[i].join()

    # Printing listening ports from small to large
    for i in range(10000):
        if output[i] == 'Listening':
            print(str(i) + ': ' + output[i])

def main():
    host_ip = input("Enter host IP: ")
    delay = int(input("How many seconds the socket is going to wait until timeout: "))   
    scan_ports(host_ip, delay)

if __name__ == "__main__":
    main()
2.powershell
24..25 | % {echo ((new-object Net.Sockets.TcpClient).Connect("192.168.1.119",$_)) "Port $_ is open!"} 2>$null

24..25 |% {echo "$_ is "; Test-NetConnection -Port $_ -InformationLevel "Quiet" 192.168.1.119}2>null
3.telnet

按照这种思路下来，我们只需要针对我们某个步骤，选择我们理想的方式或者工具去实现，就能收集到很多的信息。而且思路清晰，明确自己下一步需要做什么。

1.用户名枚举（因为kerberos验证的原因，非域情况下能够枚举域用户，原理自己可以看一下，这里我没有能力自己写工具，就放一些工具链接）
msf：auxiliary/gather/kerberos_enumusers
nmap:Nmap –p 88 –script-args krb5-enum-users.realm=’[domain]’,userdb=[user list] [DC IP]
kerbrute:kerbrute_windows_amd64.exe userenum --dc ip -d 域名 user.txt
DomainPasswordSpray:
Get-DomainUserList -Domain 域名 -RemoveDisabled -RemovePotentialLockouts | Out-File -Encoding ascii userlist.txt
2.密码喷射
kerbrute：kerbrute_windows_amd64.exe passwordspray --dc ip -d 域名 user.txt 密码
nvoke-DomainPasswordSpray -Domain 域名 -UserList .\userlist.txt -Password '密码

3.查找域控
nltest /DCLIST:GOD  查域控
Nslookup -type=SRV _ldap._tcp 查看域控主机名
net group “Domain Controllers” /domain 查看域控组内域控主机
net group “Domain Controllers” /domain 查看域控列表
net time /domain
nltest /dclist:[域名] 查看域控机器名
dsquery server 得到域控制器的IP
netdom query pdc
ipconfig /all 查看dns
扫描139等不常见但域控会开启的端口

4.获取域控的方法(这里不说钓鱼欺骗类的这种，中继后续都开了SMB签名也不说吧）
(1).抓域管密码横向
(2).通过域管进程横向
(3)利用已知漏洞（打印机，14068，zerologon等）
(4)委派攻击
(5)利用第三方软件如邮服等
(6)组策略做密码复用
(7)金银票据（主要用来做维权的，多学点没错，也写在这里吧）

5.判断域环境
 net time /domain
 ipconfig /all
 systeminfo 
 net config workstation

工具

用户
用户爆破
https://github.com/ropnop/kerbrute
用户枚举
https://github.com/chrisdee/Tools/tree/master/AD/ADFindUsersLoggedOn
https://github.com/mubix/netview/
获取服务用户
kerberoast
GetUserSPNs.ps1
ip
（1）nbtscan.exe
（2）arpscan.exe
（3）ServerScan https://github.com/Adminisme/ServerScan
（4）msf模块
auxiliary/scanner/discovery/arp_sweep
auxiliary/scanner/discovery/udp_sweep
auxiliary/scanner/discovery/udp_probe
auxiliary/scanner/netbios/nbname
端口
端口爆破
PortBrute https://github.com/awake1t/PortBrute
服务
MSF
auxiliary/scanner/smb/smb_version
auxiliary/scanner/ftp/ftp_version 发现ftp
auxiliary/scanner/ssh/ssh_version 发现ssh
auxiliary/scanner/telnet/telnet_version 发现telnet
auxiliary/scanner/mysql/mysql_version 发现mysql
密码爆破
https://github.com/fireeye/gocrack
https://github.com/dafthack/DomainPasswordSpray
web扫描
https://github.com/broken5/bscan
https://github.com/phantom0301/PTscan

域与非域集合工具
（1）Seatbelt.exe
Seatbelt.exe -group=user -full 运行普通用户权限检查的模块 -full返回输出
Seatbelt.exe -group=all 运行所有模块（需要管理员权限）
Seatbelt.exe -group=system #运行检查系统相关的信息
Seatbelt.exe -group=misc #运行所有其他检查（包括浏览器记录）
Seatbelt.exe -group=chrome 运行浏览器历史等模块
（2）BloodHound
https://github.com/BloodHoundAD/BloodHound/releases
（3）WinPwn
https://github.com/S3cur3Th1sSh1t/WinPwn/
（4）domainTools
https://github.com/SkewwG/domainTools
（5）Rubeus.exe
https://github.com/GhostPack/Rubeus
（6）powerview && powersploit
（7）fscan
https://github.com/shadow1ng/fscan

集合脚本

（1）wmic
for /f "delims=" %%A in ('dir /s /b %WINDIR%\system32\*htable.xsl') do set "var=%%A"
wmic process get CSName,Description,ExecutablePath,ProcessId /format:"%var%" >> out.html
wmic service get Caption,Name,PathName,ServiceType,Started,StartMode,StartName /format:"%var%" >> out.html
wmic USERACCOUNT list full /format:"%var%" >> out.html
wmic group list full /format:"%var%" >> out.html
wmic nicconfig where IPEnabled='true' get Caption,DefaultIPGateway,Description,DHCPEnabled,DHCPServer,IPAddress,IPSubnet,MACAddress /format:"%var%" >> out.html
wmic volume get Label,DeviceID,DriveLetter,FileSystem,Capacity,FreeSpace /format:"%var%" >> out.html
wmic netuse list full /format:"%var%" >> out.html
wmic qfe get Caption,Description,HotFixID,InstalledOn /format:"%var%" >> out.html
wmic startup get Caption,Command,Location,User /format:"%var%" >> out.html
wmic PRODUCT get Description,InstallDate,InstallLocation,PackageCache,Vendor,Version /format:"%var%" >> out.html
wmic os get name,version,InstallDate,LastBootUpTime,LocalDateTime,Manufacturer,RegisteredUser,ServicePackMajorVersion,SystemDirectory /format:"%var%" >> out.html
wmic Timezone get DaylightName,Description,StandardName /format:"%var%" >> out.html

（2）powershell
Function Get-InstalledSoftware{
    <#
    .SYNOPSIS
    Gets a computers Name, Operating System,OS Architecture and all installed Software Name,Version and IdentifyingNumber.
    Returns it all in a powershell object.
    .EXAMPLE
    Get-InstalledSoftware -computername localhost
    .EXAMPLE
    Get-InstalledSoftware -computername comp1,comp2,comp3
    .EXAMPLE
    Get-Content computers.txt | Get-InstalledSoftware | Export-Csv C:\SoftwareReport.csv
    .PARAMETER computername
    One or more computer names seperated by comma.
    #>

    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true,ValueFromPipeline=$true)]
        [string[]]$ComputerName
    )
    BEGIN{
    }
    PROCESS 
    {
        foreach($computer in $ComputerName){

            try {

            $software = Get-WmiObject -Class Win32_Product -ComputerName $ComputerName -ErrorAction Stop

            } catch {

                Write-Host "$computer Offline"
            }

            $os = Get-WMIObject -Class win32_operatingsystem -ComputerName $ComputerName
            $osname = ($os.Name).Split("|") | Select-Object -First 1     

                foreach($installed in $software){

                    $props = [ordered] @{
                        'ComputerName' = $os.PSComputerName;
                        'OperatingSystem' = $osname;
                        'Archtecture' = $os.OSArchitecture;
                        'Name' = $installed.Name;
                        'Version' = $installed.Version;
                        'Vendor' = $installed.Vendor;
                        'IdentifyingNumber' = $installed.IdentifyingNumber}          

                    $obj = New-Object -TypeName psobject -Property $props
                    Write-Output $obj

                }

            }
        }
    END{
    }
}

最后

自动化方便是一回事，必然会带来弊端。动静大，易查杀等。脚本小子终究只是一时爽。最后还是要自己走安全开发自己写工具，在特定的环境下能实现功能才行。就难得总结工具了，多培养培养思维多学习学习底层还是长久之道。
这篇文章只是抛砖引玉给大家提供一个思路，还有很多东西没用收到。但是信息收集和漏洞利用总是相依相存的。比如委派，邮服这些。或者是需要一些漏洞利用链的时候。扩大自己的攻击技术和攻击面，了解新的攻击方式应该是最重要的，可能一条路不同我换了一种攻击方式，搜集一下需要实现的前置条件都满足，自然也就打下来了。随机应变。有些工具是之前收集的说实话都没有用上过，所以工具在精在顺手不在多。选择合适自己的才最重要。参考文献

福利

关注私我获取更多【网络安全学习攻略·资料】

0x00 前言

首先，YARA规则是VT的开发人员发布的，用于同类样本的批量检索和查杀。

通过Yara引擎和我们编写的Yara规则，可以快速对一批样本进行扫描和识别，从而找到我们希望得到的样本。

官方的github库地址：https://github.com/VirusTotal/yara/releases

官方文档说明：https://yara.readthedocs.io/en/v3.7.0/index.html

0x01 Yara的安装和使用

如何安装Yara

Yara的安装非常简单，在Windows操作系统下，我们可以直接在yara的github库下载可执行文件到本地，配置环境变量即可用

可以看到，当前（2020-07-20）的最新版本是Yara4.0.2

这里下载yara-v3.11.0-994-win64.zip，下载到本地之后直接将压缩包中了两个exe解压并到C:\Windows目录下并分别重命名位yarac.exe和yara.exe

然后启动cmd 直接输入yara —help 即可查看yara的参数

在Mac下，可以直接使用pip工具或者brew直接安装。

我是通过brew install yara的方式直接安装的。安装完成之后，使用方式也是一样的。

Yara食用

现在，以官方提供的yara规则示例我们来看看yara可以做什么。官方给出的示例yara如下：

rule silent_banker : banker
{
    meta:
        description = "This is just an example"
        thread_level = 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
}

首先，第一行的rule silent_banker : banker是声明该规则用于检出banker类型的样本。

meta 后面的是一些描述信息，比如规则说明、作者信息等。

strings 定义了$a $b $c 两个十六进制字符串（十六进制字符串用大括号括起来）和一个文本字符串（文本字符串直接用双引号括起来）

最后condition 规定了匹配的条件，这里写的是or，表明样本中只要匹配到了$a $b $c 三个字符串中的任意一个，那么样本就会被识别为banker

我们新建一个demo1.yara文件，然后将这部分内容复制进去。

然后在当前目录下新建一个文件夹<111> 在该文件夹中分别存放三个文件，一个py文件，一个json文件和一个exe文件。

现在我们回到demo1.yara所在的目录，执行yara demo1.yara 111/

执行完之后，没有任何输出，根据Unix内核的无回显则运行成功原则，我们可以知道该指令已经成功执行。

而没有输出是因为我们的yara规则没有命中111文件夹下的任何文件。于是我们修改规则如下：

我们增加了一个十六进制字符串$d 所匹配的值是4D 5A。 而4D 5A是PE文件（包括exe、dll等）的文件头，也就是说一个正常的PE文件中是一定会包含4D 5A这个十六进制的数据的。

且我们在最后的condition中加入了or $d，表示如果$d条件满足，样本也可以成功识别。

demo1.yara保存之后我们重新对111文件夹下的文件进行扫描：

这里可以看到，yara规则已经成功识别到了111/svchost.exe文件命中了我们的yara特征，并且提扫描之后自动标记为silent_banker，这个silent_banker就是我们在最上面定义的检出名称。

现在我们将更多的PE文件拷贝到111文件夹下以及111文件夹下的子目录中。

然后再次对111文件夹进行扫描

这里可以看到还是只有一条结果，于是我们通过yara —hlep查看一些帮助文档：

  -t,  --tag=TAG                   print only rules tagged as TAG
  -i,  --identifier=IDENTIFIER     print only rules named IDENTIFIER
  -n,  --negate                    print only not satisfied rules (negate)
  -D,  --print-module-data         print module data
  -g,  --print-tags                print tags
  -m,  --print-meta                print metadata
  -s,  --print-strings             print matching strings
  -L,  --print-string-length       print length of matched strings
  -e,  --print-namespace           print rules' namespace
  -p,  --threads=NUMBER            use the specified NUMBER of threads to scan a directory
  -l,  --max-rules=NUMBER          abort scanning after matching a NUMBER of rules
  -d VAR=VALUE                     define external variable
  -x MODULE=FILE                   pass FILE's content as extra data to MODULE
  -a,  --timeout=SECONDS           abort scanning after the given number of SECONDS
  -k,  --stack-size=SLOTS          set maximum stack size (default=16384)
  -r,  --recursive                 recursively search directories
  -f,  --fast-scan                 fast matching mode
  -w,  --no-warnings               disable warnings
       --fail-on-warnings          fail on warnings
  -v,  --version                   show version information
  -h,  --help                      show this help and exit

这些参数很重要，我们可以翻译了之后多看，多用

-t、 --tag=tag只打印标记为tag的规则
-i、 --identifier=identifier只打印名为identifier的规则
-n、 --negate只打印不满足的规则（negate）
-D、 --打印模块数据打印模块数据
-g、 --打印标签打印标签
-m、 --打印元数据
-s、 --打印字符串打印匹配的字符串
-L、 --打印字符串长度打印匹配字符串的长度
-e、 --打印命名空间打印规则的命名空间
-p、 --threads=NUMBER使用指定的线程数扫描目录
-l、 --max rules=NUMBER匹配多个规则后中止扫描
-d VAR=值定义外部变量
-x MODULE=文件将文件内容作为额外数据传递到模块
-a、 --timeout=秒在给定秒数后中止扫描
-k、 --堆栈大小=插槽设置的最大堆栈大小（默认值=16384）
-r、 --递归递归搜索目录
-f、 ——快速扫描快速匹配模式
-w、 --无警告禁用警告
         --警告失败警告失败
-v、 --版本显示版本信息
-h、 --help显示此帮助并退出

这里可以看到 -r recursively search directories表示递归遍历所有子目录。于是我们重新运行，带上-r 参数：yara -r demo1.yara 111/

这样就可以对指定目录进行递归扫描了。

我们还可以集合-r和-m参数，在扫描时输出详细信息：

通过上面的例子，我们对Yara有了一个大概的了解，接下来我们来看一下Yara的一些更方便的特性。我们上面提到，Yara可以匹配文本字符串、十六进制字符串。其实除了这两种，Yara还支持正则表达式的写法。

在上面，我们已经测试了十六进制字符串的匹配。匹配的方式是扫描文件是否包含了4D 5A。这里都不能算是一条规则，因为这条规则没有意义。其实十六进制还包含了很多高级的写法，包括通配符、可变长度等。这里空讲无用，之后遇到比较好的样本再做分享。

我们来测试一下字符串的写法，我们新建一个demo2.yara，内容如下：

这条yara的规则很简单，就是扫描的文件中是否包含了if name == ‘main‘:这个字符串，如果有，则将其标记为python_file

然后还是对111目录进行扫描：

可以看到成功扫描到python文件。这里需要注意，我们在yara中直接写字符串的话，是区分大小写的，如果想要扫描时不区分大小写，可以加入nocase关键字，比如：

接下来我们看看yara中的正则是如何写的。Yara的正则其实和字符串写法很类似，并且可以用在字符串上的特性都可以用在正则表达式中。

以匹配身份证号为例，我就直接以一个非常简单粗暴的方式来匹配身份证，就是直接查看文件中是否包含了18位连续的数字（我这种匹配当然不标准，只是为了方便测试）。此外，我还加上了一个$peflag的标志条件，在condition的地方通过 and not 的方式过滤掉所有的PE文件。demo3.yara如下：

扫描结果如下：

这里出现了一个warning：demo3.yara(11): warning: $reg1 is slowing down scanning (critical!)

提示demo3.yara规则中的$reg1这个匹配条件写的不好，会引起yara的性能下降。这是因为我们直接使用正则表达式瞎匹配，这样肯定是不对的，因为如果扫描一个1M或是2M的脚本文件，这个yara规则一跑，基本上就会卡死。所以在书写yara规则的时候，在可达成目的的情况下，也要考虑扫描的性能。关于yara的优化，我们在后面的实战样本中会提到。

0x02 CobaltStrike安装和使用

CobaltStrike安装

CobaltStrike的安装非常简单，只需要在本机装好JAVA环境，然后分别运行CobaltStrike的客户端和服务器端即可。以3.14为例，3.14版本的CobaltStrike解压后文件结构如下：

其中的teamserver就是CobaltStrike的服务器端，CobaltStrike文件就是客户端。

只需要./teamserver 服务器ip地址 cs密码即可成功启动CobaltStrike的服务器。然后在客户端使用./cobaltstrike 然后填写服务器的ip地址和密码即可（端口一般不变）成功登录。

4.0的结构稍微有所不同

在4.0中不再有CobaltStrike客户端文件，取而代之的是CobaltStrike.bat文件所以我们首先启动CobaltStrike服务器，这里的ip地址就是本机的ip地址，后面的123456是登录密码

服务器成功启动之后，我们启动客户端：

成功登录上cs客户端：

大概介绍一下CobaltStrike各个菜单的的功能：

CobaltStrike的监听器主要分为beacon和foreign，其中bacon是CobaltStrike内置的，我们使用CobaltStrike生成的payload反弹shell回来直接就可以用foreign是外置的，比如想通过CobaltStrike反弹到msf，就可以使用foreign

CobaltStrike生成码

我们可以通过上面介绍的图标快捷菜单生成木马，也可以通过Attacks菜单栏生成我们想要的木马。

我这里分别生成了beacon、foreign、HTML、powershell、VBS、office宏等cs马。接下里先分析分析这些木马尝试提取CobaltStrike特征，生成码如下（3.14）：

0x03 CobaltStrike样本查杀

Win32_PE

我们首先来看看32位的PE文件，包括exe和dll。为了防止样本在Windows操作系统下被误执行，我这里给所有的样本都加上了.bin后缀，然后统计这些文件的时候可以发现，通常情况下CobaltStrike默认生成的beacon的PE马大小都在278kb到303kb的样子。红框部分的foreign马的大小却只有十多kb。

所以我们可以尝试编写第一个filter来过滤掉其他的样本。

为什么要编写filter呢，因为比如我们扫描Windows的系统目录或是一个程序目录，该目录下有上千，上万甚至上十万的文件，如果我们不写filter，那么Yara在扫描的时候将会每个文件都完整的去匹配我们写的规则，在上面的时候我们提到，yara规则是会全文扫描的，那么这样将会大大降低扫描效率，如果我们能够写一些filter过滤掉大部分的不相关样本，那么yara在扫描的时候将会只对疑似的文件进行有效的扫描而不会浪费资源。

Yara提供了文件大小的变量，标准写法为

rule FileSizeExample{condition:filesize > 200KB}

第一个条件写好之后，可以看到基本上就筛选了刚才我们看到的PE我文件，但是多了一个beacon3.ps1，没关系，我们在后面的规则中过滤掉。

现在我们随便加载两个exe到IDA中分析。

IDA加载之后，一对比发现两个码的入口点是几乎完全一样的，唯一细微的区别就是这里mov语句的参数2不同。

空格转换为汇编代码显示，可以看到样本此时默认是main函数。这里目前至少是说明CobaltStrike的两个beacon码的main函数入口点结构相同。

Ctrl + E ，然后跳转到start函数，看看两个样本的入口点是否相同：

来到start函数之后，我们可以发现两个CobaltStrike样本的入口点是完全一致的，程序入口点都是004014B0

减去基地址00400000，那么入口点应该就是偏移14B0的位置。

我们再加载一个beacon的样本，看看入口点是否还是一致，这里发现三个样本的入口点都是14b0的地方，所以我们推测CobaltStrike的样本入口点都在14b0的地方，所以我们编写第二个规则去验证一下。

在yara3.0以下的版本中，可以直接使用entry_point变量获取入口点，在3.0以上的版本中，该变量已经被弃用。取而代之的是一个pe模块。现在可以使用pe.entry_point来获取入口点，但是需要注意的是，这里是获取到的文件偏移，也就是offset，并不是我们在IDA中看到的entry_point，这里需要注意一下。程序的Offset是0x8b0：

所以我们可以将条件写成如下形式：

官方文档给的写法是用关键字at：

但是需要注意，使用at是取值，并不是匹配地址。也就是说上图这种写法是去找一下$a变量的值是否在entrypoint这个地址能找到。也就是在我们这条规则中，如果要用at，可以写成如下：

这里的$name中的十六进制值需要大写，匹配的值就是IDA入口点的十六进制数据：

但是我们同时也可以看到，at的写法没有那么有通用性，我们还是使用上面 == 的写法。

那么现在第二条规则就已经写好了，我们继续来看其他的内容。我们静态分别看下这个样本的main函数：

在Main函数中可以看到，关键就调用了两个call，分别是4027b0和401800

我们大概看一下就可以知道sub_401800才是关键函数，在sub_401800函数中，程序会通过CreateThread创建一个新线程，并且可以看到有一个奇怪的%c%c%c%c%c%c%c%c%cMSSE-%d-server看起来像是通信协议。

这里CreateThread的lpStartAddress是sub_4016D3,在sub_4016D3的sub_401608函数中可以看到正在通过CreateNamedPipeA的方式创建管道准备通信。

我们调试器里直接过来可以看到跟我们想的应该一样，这里的确是跟通信相关的内容。

查看多个样本，可以发现%c%c%c%c%c%c%c%c%cMSSE-%d-server 这个值是固定的。所以可以直接尝试匹配这个串试试：

可以看到再次成功匹配。到这里，我们关于CobaltStrike的Beacon木马的yara规则基本上就提取完成了。最后，我们给规则加上一个PE的判断条件：

现在这个条件就比较完整了。

1. 通过uint16(0) 的方式取文件的前两个字节，判断是否等于0x5A4D 如果等于则说明是PE，这里用于过滤PE文件
2. 判断程序的pe.entry_point是否等于0x8B0，这里是文件的file offset，这里也算是一个很好的过滤条件，可以直接过滤掉大部分的文件。
3. 通过两个filesize的比较限制文件的大小
4. 最后用一个关键的字符串来做最终的验证。

这里是看到这个串的确是CobaltStrike使用来通信的，且一批CobaltStrike的码都包含了这个串，相对来说，应该不会命中到其他的正常文件，这个通信协议应该是cs专用的，所以可以直接这样写，如果不想误报，想要提高检测的精准性，可以继续找其他的特征提取。反正在写yara规则的时候，通用性和精准性，是分析人员需要权衡的条件，如果我们想要提高特征的通用性，势必就需要减少一些匹配条件，精准性就会下降，至于到底是通用性优先还是精准性优先就得看具体的应用场景。

powershell马特征

处理了CobaltStrike的PE马，我们再来看看其他类型的木马规则如何提取。首先是powershell木马，也就是ps1的文件。我这里只生成了两个。

分别查看一下文件内容。32位：

64位：

这里可以看到，32位和64位的powershell马结构其实是一样的，只是32位的马使用了$DoIt= @’’的方式来定义两个函数，其实和64位这里是一样的。

这里很明显，程序最后关键执行的数据在24行开始的地方，这里定义了超级大的base64串。经过观察可以发现32为和64执行的串的头部是不一样的：32位：

64位：

经过分析我们可以发现，代码的最下面，上面定义的这个$var_code的执行语句，且两个版本的ps码都是这样写的，于是我们直接尝试用字符串匹配这一段试试。

就直接在原有yara的基础上增加一个rule即可：

然后命令行测试，可以看到两个ps1脚本都被成功匹配

html_pe马特征

CobaltStrike的html木马分为了三种，分别是包含PE文件的hta 包含VBS的hta 包含powers的Hta，我们分别来看看。

首先是包含PE的hta：该类别的cs马会直接将一个PE文件的十六进制数据流硬编码到文件中：

在马最下面，程序会定义一个var_tempexe文件用于接受上面的数据流，将该文件写入到本地并且通过run执行之后删除该文件。这里其实写入的文件应该也是beacon的木马，在14行代码的位置，有着var_tempexe变量的赋值语句，经过与多个样本的对比分析发现，后面的beacon_evil.exe不是固定的，而是攻击者在使用CobaltStrike生成木马的时候给定的文件名。所以我们可以考虑用正则来匹配这一段，作为条件之一。

编写yara特征之后进行扫描，成功捕获对应的样本

完整的正则表达式如下：/var_tempexe = var_basedir & \”\” & \”[A-z]{1,20}.exe\”\s*Set var_stream = var_obj.CreateTextFile(var_tempexe, true , false)/

我们来一点点拆解。首先，我们在yara中使用正则表达式要使用//标识，我们将正则写到两个斜杠之间。var_tempexe = var_basedir & 这段是我们直接从原始代码中复制出来的。\”\” 用于转义匹配中间的 “\”由于我们刚刚已经分析过，后面的beacon_evil.exe不是固定的，是由攻击者指定，所以我这里写了一个范围，1-20，然后通过\s*将后面的语句给组合起来进行匹配。

html_VBS特征

接下来我们看看html的VBS码，结构如下：

经过分析，我们可以看出来，下面的一大段代码，其实是带轻微混淆的VBA代码。混淆方法很简单，就是通过&符号拼接由chr函数转换的ascii“&Chr(61)

我们尽量找一个比较通用的地方来提取特征，稍微分析一下，可以发现，上面部分都是一些函数的导入，变量的定义，没有做神什么比较奇怪的操作，在57行的位置，定义了一个很大的数组，数组名为myAr&ray 后面的Chr(61)转换之后是等于符号 = 。 后面的一大段数据都是用于给myArray赋值的。所以我们可以考虑将特征提取到这里。

这里应该可以直接写字符串进行匹配了：

html_powershell

最后，html类别的马就只剩下powershell类型的了，还是先来看看代码结构

cs的powershell马结构相对来说就很简单了，就是通过powershell执行了超级长一段base64编码的脚本命令。直接取这个base64串的头部出来解码看看是是不是常见的语句JABzAD0ATgBlAHcALQBPAGIAagBlAGMAdAAgAEkATwAuAE0AZQBtAG8Acg

解码之后发现是$s=New-Object IO.Memor结合代码分析，这里是将后面的数据加载到内存中执行，这里是在做准备工作。

结合前面的powershell -nop -w hidden -encodedcommand本身也不是常见的powershell语句，正经人谁会这样干，所以我们直接尝试提这里的字符串看能否通杀。貌似可以

Macro

现在还有一类Macro样本，也就是Office宏代码。这个其实也是简单，但是这里我生成的时候偷了一个懒，没有按照cs的文档将宏代码存储到Office文档中。关于Office文档的查杀，在后面再结合oledump等工具继续介绍。

0x04 查杀效果

我们回到上级目录，看看同时查杀3.14和4.0的效果怎样我们将结果写入到1.txt中

一共是查杀了24个样本

可以看到，一共27个文件，除了vba和这里的两个raw没写规则外，全部查杀了。所以，对CobaltStrike木马基本查杀的yara规则就这样写好了。后面我们学习了yara的高级写法或是遇到其他cs的样本可以再继续完善，但是目前这个yara应该可以识别绝大多数的正常cs码了。

最后，CobaltStrike解压之后，目录中会有一个CobaltStrike.jar文件

使用解压缩工具将这个文件也解压：

这里面有一个名为resources的文件夹，就是CobaltStrike的配置信息，我们在CobaltStrike控制台生成的木马都来源于这个文件夹。

所以我们也可以直接分析这里面的样本，提取规则进行查杀。

0x05 完整yara

import "pe"
rule beacon32
{
    meta:
        description = "This rule is used for discovery CobaltStrike’s beacon32PE Trojan"
        author = "int3"
        date = "2020-07-21"
        reference = "reference"
        hash = "hash"
    strings:
        $name = "%c%c%c%c%c%c%c%c%cMSSE-%d-server"
    condition:
        uint16(0) == 0x5A4D and pe.entry_point == 0x8b0 and filesize > 277KB and filesize < 304KB and $name
}


rule ps
{
    meta:
        description = "This rule is used for discovery CobaltStrike’s powershell Trojan"
        author = "int3"
        date = "2020-07-21"
        reference = "reference"
        hash = "hash"
    strings:
        $str1 = "$var_va.Invoke([IntPtr]::Zero, $var_code.Length, 0x3000, 0x40)"
        $str2 = "[System.Runtime.InteropServices.Marshal]::Copy($var_code, 0, $var_buffer, $var_code.length)"
    condition:
       uint16(0) != 0x5A4D and $str1 and $str2
}

rule CobaltStrike_hta_pe
{
    meta:
        description = "This rule is used for discovery CobaltStrike’s hta'pe Trojan"
        author = "int3"
        date = "2020-07-21"
        reference = "reference"
        hash = "hash"
    strings:
        $reg1 = /var_tempexe = var_basedir & \"\\\" & \"[A-z]{1,20}.exe\"\s*Set var_stream = var_obj.CreateTextFile\(var_tempexe, true , false\)/
    condition:
       uint16(0) != 0x5A4D and  $reg1
}

rule hta_VBS
{
    meta:
        description = "This rule is used for discovery CobaltStrike’s hta'vbs Trojan"
        author = "int"
        date = "2020-07-21"
        reference = "reference"
        hash = "hash"
    strings:
        $str = "myAr\"&\"ray \"&Chr(61)&\" Array\"&Chr(40)&Chr(45)&\"4\"&Chr(44)&Chr(45)&\"24\"&Chr(44)&Chr(45)&\"119\"&Chr(44)"
    condition:
       uint16(0) != 0x5A4D and  $str
}


rule hta_ps1
{
    meta:
        description = "This rule is used for discovery CobaltStrike’s hta'vbs Trojan"
        author = "int"
        date = "2020-07-21"
        reference = "reference"
        hash = "hash"
    strings:
        $str = "var_shell.run \"powershell -nop -w hidden -encodedcommand JABzAD0ATgBlAHcALQBPAGIAagBlAGMAdAAgAEkATwAuAE0AZQBtAG8A"
    condition:
       uint16(0) != 0x5A4D and  $str
}

0x06 总结

本篇是YARA规则的入门篇，通过本节的内容我们可以发现，Yara在恶意样本检测中有着至关重要的作用（虽然本节中写的YARA很简单，但是Yara可以做的远远不止于此）。此外，我们还可以通过别人写好的yara，辅助我们分析恶意软件，阅读大佬写的Yara我们可以知道大佬在分析对应的样本的时候，关注点在哪里，他提取到了目标木马/家族的哪些特征等等。

我是安仔，一名刚入职网络安全圈的网安萌新，欢迎关注我，跟我一起成长； 欢迎大家私信回复【入群】，加入安界网大咖交流群，跟我一起交流讨论。

安界网周年庆，cisp考证报名送价值6000元电脑；nisp一级报名送100元现金劵；nisp二级报名送1000元现金劵。更多优惠联系我们。

小白入行网络安全、混迹安全行业找大咖，以及更多成长干货资料，欢迎关注#安界网人才培养计划#、#网络安全在我身边#、@安界人才培养计划。