记一次新生赛BJDCTF（WP）
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 << '\n';
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\n");
continue;
}
if(ans1<=c*ans2)printf("%lld\n",ans1);
else printf("%lld\n",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:\n%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:\n%s "%outputs)
print()
print(" *************************************")
print(" * (1)encode (2)decode *")
print(" *************************************")
print()
num = input("Please select the operation you want to perform:\n")
if(num == "1"):
input_str = input("Please enter a string that needs to be encrypted: \n")
My_base64_encode(input_str)
else:
input_str = input("Please enter a string that needs to be decrypted: \n")
My_base64_decode(input_str)
