记一次新生赛BJDCTF（WP）

Posted 2021-03-14 tiandiyihong

1.Hello_world:

进入网站后发现就按钮点了之后不是在前端页面上跳转而是跳转到其它网页。

根据提示，在跳转时抓包得到

发现guest后面的是base64码，解开后还是guest,于是想到在访问时的数据包中加上id:admin+admin的base64,

之后出现这个界面：

想到修改XFF伪装成本地访问

之后出现页面如下：

于是想到修改Refer(伪造来源)，得：

得到flag

2.Hidden secrets

进入网页后，随便输入个密码，抓包

回复包中发现如下字段疑似md5码：

解密后为112233：

输入密码后进入新页面查看源码，得到flag：

3.easy_md5:

随便输入个密码，数据包中找到hint

暗示我让where后面的东西返回true

想到sql注入的一个情况，要让其变成password=’xxx’ or ‘1’的形式。

写个脚本找满足这样条件的md5明文：

得到个ffifdyop

输入后，查看跳转后页面的源码

由源码想到构造两个值不同，md5相同的a,b传进去：

QNKCDZO
240610708

得

这次变成了三个等于，于是想两者都传入数组绕过

得到flag

4.easy_upload

进去后让传文件,还只让传图片，就传了个图片马，看看能不能执行

上传后，弹出文件的路径：uploads/2e611bb0c1967c4f74746c36233567e9.jpg

猜测action参数后面传入对应的路径的文件能被执行，于是试试

测验成功

，再传入一句话木马，列出文件，查看文件，得flag

5.这序列化也太简单了吧

将传入的序列化中的对象数设为2，根据提示，设置对象的值为/flag

Payload如下

6.签个到？

Winhex打开发现头部有个png，猜测其为png文件，于是改后缀为png后打开，图片为二维码，扫码得flag

7.你猜我是个啥

用记事本软件打开即可得flag

8.藏藏藏

Binwalk分析出有zip文件，foremost分离出来。打开压缩包中的文件，扫描文件中的二维码，得flag

9.认真你就输了

binwalk分析出来发现有其它文件，用foremost分离后，在文件夹中找到flag.txt,打开得fag

10.just a rar

文件中，压缩包的解压密码为4位数，直接爆破可得密码为2016.

winhex打开解压后的图片发现flag

11.一叶障目

修改图片宽高即可得图片下方有flag

12.鸡你太美

第一个图看不出什么，用winhex打开第二个图发现开为9a,猜测差了个GIF8，原本GIF文件开头应为GIF89a，在前方添加后，发现图片能打开了，图片上显示的即为flag

13.纳尼

开头为9a,猜测差了个GIF8，原本GIF文件开头应为GIF89a，在前方添加后，发现图片能打开了，保存每一帧的图，图片上显示的按帧数顺序拼起来为一个base64,解码后即为flag

14.JustRe

ida打开，搜索文本BJD得到flag

(去掉%d%d)

15. Sign In

直接16进制码解码

16. 编码与调制

猜测为标准曼彻斯特编码

直接解码得flag

17. Every minute counts

直接BFS搜索，返回搜到Aqua时的前封面数

18. notakto_1

静态博弈，代码如下：

from pwn import *

pairs = {0: (0, 8),1: (1, 7), 2:(2, 6), 3:(3, 5)}

juststart=True

def find(x):

for i in range(4):

if(x) in pairs[i]:

return i

def choose(x):

global flag

p = pairs[find(x)]

if(x)==p[0]:

p = p[1]

else:

p = p[0]

k = [p-1, p+1, p-3, p+3]

for i in k:

if((i//3==p//3 or i%3 == p%3)and i<=8 and i>=0 and i!=4 and flag[find(i)]==0):

return i

def iswin(s):

global flag

global juststart

if(s.find("ROUND") != -1):

juststart = True

p = s.find("ROUND")

print(s[p-12:p+15])

flag = [0 for x in range(4)]

def recv(s):

p = s.find("My move:")

if(p==-1):

return -1

for i in s:

try:

if(i[0] == ‘M‘):

recv = int(i[9])

return recv

except:

pass

else:

return -1

r = remote("222.186.56.247", 8122)

s = r.recvuntil("Your move")

flag = [0 for i in range(4)]

while(1):

iswin(s)

if(juststart==False):

k = s.find( "My move" )

else:

k = -1

if(k==-1):

r.sendline("4")

print("send:", 4)

juststart = False

else:

k = int(s[k+9])

print("recv:", k)

flag[int(find(k))] = 1

p = choose(k)

print(‘send:‘, p)

r.sendline(str(p))

flag[find(p)] = 1

try:

s = r.recvuntil("Your move")

except:

s = r.recvuntil( "}" )

print(s)

break

19. Pyramid

打表，找规律

之后解决代码如下：

#include<stdio.h>

#include<iostream>

#include<map>

#include<algorithm>

#include<cstring>

#include<string.h>

#include<math.h>

#include<vector>

#include<map>

using namespace std;

typedef long long ll;

#define MAXN 1000005

#define INF 0x3f3f3f3f

#define MOD 1000000007

const double pi = acos(-1.0);

const double eps = 1e-6;

ll qpow(ll a, ll b, ll c)

{

ll ans = 1;

while(b)

{

if(b&1)

ans = ans*a%c;

a = a*a%c;

b >>= 1;

}

return ans;

}

int main()

{

ll n;

scanf("%lld", &t);

ll inv24 = qpow(24, MOD-2, MOD);

scanf("%lld", &n);

ll ans = n*(n+1)%MOD*(n+2)%MOD*(n+3)%MOD*inv24%MOD;

cout << ans << ‘ ‘;

return 0;

}

20. Real Hero

最短路问题，这题我用Dijkstra

解决代码如下：

#include<cstdio>

#include<vector>

#include<queue>

#include<utility>

#include<cstring>

using namespace std;

#define MAXN 1020

#define INF 0x3f

typedef long long ll;

//b、dijkstra 堆优化 O（nlogn）

typedef pair<ll, ll> P; //first是到源点最短距离，second是顶点的编号

struct edge { ll to, cost;

edge (ll too, ll costt) { to = too; cost = costt; }

};//指向顶点to的权值为cost的边

vector <edge> G[MAXN];//存图 可以理解为二维的，每个G包含若干项，这些项是以当前编号点为起点, 若干项边结构体（edge）的v为终点，cost为权值的边

void addedge (ll u, ll v, ll w) {

G[u].push_back (edge (v, w)); //添加从u到v权值为w的边

}

ll ma[MAXN][MAXN];

ll kl[MAXN];

ll dis[MAXN][MAXN];

//ll pre[MAXN];//记录前驱节点

ll d[MAXN];//最短距离

ll n, m, s ;//顶点数 边数 起点

//vector<ll> path;//路径

priority_queue<P, vector<P>, greater<P> > que;

void dijkstra () {

//fill (d, d + n + 1, INF); //fill (pre, pre + n + 1, -1);

memset(d,INF,sizeof(d));

d[s] = 0; que.push (P (0, s));

while (!que.empty()) {//核心

P p = que.top(); que.pop();

ll v = p.second;

if (d[v] < p.first) continue;

for (ll i = 0; i < G[v].size(); i++) {

edge e = G[v][i];

if (d[e.to] > d[v] + e.cost) {

d[e.to] = d[v] + e.cost;

que.push (P (d[e.to], e.to));

//pre[e.to]=v;

}

}

}

}

int main()

{

int t=1;

ll S,k,c;

memset(ma,INF,sizeof(ma));

scanf("%lld%lld%lld%lld%lld",&n,&m,&S,&k,&c);

for(ll i=0;i<k;i++)

{

scanf("%lld",&kl[i]);

}

ll x,y,z;

for(ll i=0;i<m;i++)

{

scanf("%lld%lld%lld",&x,&y,&z);

ma[x][y]=ma[y][x]=min(ma[x][y],z);

}

for(ll i=1;i<=n;i++)

{

G[i].clear();

}

for(ll i=1;i<=n;i++)

{

for(ll j=1;j<=n;j++)

{

if(ma[i][j]<=10010)

{

addedge(i,j,ma[i][j]);

//addedge(j,i,ma[i][j]);

}

}

}

s=S;

dijkstra();

ll ans1=-1,ans2=-1;//temp=0x3f3f3f3f;

for(ll i=1;i<=n;i++)

ans1=max(ans1,d[i]);

for(ll i=0;i<k;i++)

{

s=kl[i];

dijkstra();

for(int j=1;j<=n;j++)

if(s!=j)dis[s][j]=d[j];

}

ll temp=0x3f3f3f3f;

for(int j=1;j<=n;j++)

{

temp=0x3f3f3f3f;

for(int i=0;i<k;i++)

{

temp=min(temp,dis[kl[i]][j]);

}

ans2=max(ans2,temp);

}

if(m==0)

{

printf("0 ");

continue;

}

if(ans1<=c*ans2)printf("%lld ",ans1);

else printf("%lld ",ans2);

return 0;

}

21.base??

换个base64码表，脚本如下:

s = "JKLMNOxyUVzABCDEFGH789PQIabcdefghijklmWXYZ0123456RSTnopqrstuvw+/="

def My_base64_encode(inputs):

# 将字符串转化为2进制

bin_str = []

for i in inputs:

x = str(bin(ord(i))).replace(‘0b‘, ‘‘)

bin_str.append(‘{:0>8}‘.format(x))

#print(bin_str)

# 输出的字符串

outputs = ""

# 不够三倍数，需补齐的次数

nums = 0

while bin_str:

#每次取三个字符的二进制

temp_list = bin_str[:3]

if(len(temp_list) != 3):

nums = 3 - len(temp_list)

while len(temp_list) < 3:

temp_list += [‘0‘ * 8]

temp_str = "".join(temp_list)

#print(temp_str)

# 将三个8字节的二进制转换为4个十进制

temp_str_list = []

for i in range(0,4):

temp_str_list.append(int(temp_str[i*6:(i+1)*6],2))

#print(temp_str_list)

if nums:

temp_str_list = temp_str_list[0:4 - nums]

for i in temp_str_list:

outputs += s[i]

bin_str = bin_str[3:]

outputs += nums * ‘=‘

print("Encrypted String: %s "%outputs)

def My_base64_decode(inputs):

# 将字符串转化为2进制

bin_str = []

for i in inputs:

if i != ‘=‘:

x = str(bin(s.index(i))).replace(‘0b‘, ‘‘)

bin_str.append(‘{:0>6}‘.format(x))

#print(bin_str)

# 输出的字符串

outputs = ""

nums = inputs.count(‘=‘)

while bin_str:

temp_list = bin_str[:4]

temp_str = "".join(temp_list)

#print(temp_str)

# 补足8位字节

if(len(temp_str) % 8 != 0):

temp_str = temp_str[0:-1 * nums * 2]

# 将四个6字节的二进制转换为三个字符

for i in range(0,int(len(temp_str) / 8)):

outputs += chr(int(temp_str[i*8:(i+1)*8],2))

bin_str = bin_str[4:]

print("Decrypted String: %s "%outputs)

print()

print(" *************************************")

print(" * (1)encode (2)decode *")

print(" *************************************")

print()

num = input("Please select the operation you want to perform: ")

if(num == "1"):

input_str = input("Please enter a string that needs to be encrypted: ")

My_base64_encode(input_str)

else:

input_str = input("Please enter a string that needs to be decrypted: ")

My_base64_decode(input_str)