第一题身份鉴别
分数:100
【IP】:172.20.2.30
【端口】 9001
【标准要求】8.1.4.1 身份鉴别 b)应具有登录失败处理功能，应配置并启用结束会话、限制非法登录次数和当登录连接超时自动退出等相关措施。
【场景说明】网络安全等级保护标准中要求，应用系统应该对用户进行身份标识和鉴别，当存在非法暴力破解、弱口令猜测、连续登录失败次数过多等情况，应该配置并启用结束会话、限制非法登录次数/频率和当登录连接超时自动退出等相关措施，防止用户名和口令被暴力破解。在攻防实战中发现，攻击者找到后台地址后，往往会尝试收集大量以往泄露的或者攻击者自己收集的社工库去尝试对后台进行撞库攻击。请利用你所掌握的知识，测试出本场景中登录的用户名和口令，并进入后台，获取象征敏感信息的flag。
右键查看源码，提示robots.txt，然后得到一个www.rar下载下来，里面有两个文件，是账号和密码，使用bp爆破一下，得到flag
第二题入侵防范1
【IP】:172.20.2.30
【端口】 9002
【标准要求】8.1.4.4 入侵防范 d)应提供数据有效性检验功能，保证通过人机接口输入或通过通信接口输入的内容符合系统设定要求。
【场景说明】在通常的渗透测试中，攻击者往往会根据系统接口对数据有效性处理的缺陷，通过SQL注入等方式直接获取系统中的敏感数据，对后台数据库进行拖库。请利用你所掌握的知识，发现本场景中系统存在的漏洞，获取象征敏感信息的flag。
宽字节注入，使用sqlmap跑就可以得到flag。
第三题恶意代码和垃圾邮件防范
分数:400
【IP】:172.20.2.30
【端口】 9003
【标准要求】8.1.3.4 恶意代码和垃圾邮件防范 a)应在关键网络节点处对恶意代码进行检测和清除，并维护恶意代码防护机制的升级和更新；
b) 应在关键网络节点处对垃圾邮件进行检测和防护，并维护垃圾邮件防护机制的升级和更新。
【场景说明】近年来，社会工程学攻击手段泛滥，邮件系统成为其攻击途径之一。某单位的网络中因为缺少垃圾邮件防范和网络恶意代码防范措施，导致携带勒索软件的邮件被该单位员工点开，一份重要文档被加密。请你模拟攻击者尝试登录邮件系统，找到收件箱里的勒索病毒样本，分析找出解密方式，还原文档内容，获取象征敏感信息的flag。（勒索病毒样本运行后只会加密特定目录中后缀为.abcdef的文件，请在虚拟机里运行）
首先通过注入可以登陆邮箱，邮箱里有个附件，下载下来之后需要逆向，这题不会。
第四题数据保密性和数据完整性
分数:300
【IP】:172.20.2.30
【端口】 9004
【标准要求】8.1.4.8 数据保密性 b)应采用密码技术保证重要数据在存储过程中的保密性，包括但不限于鉴别数据、重要业务数据和重要个人信息等。
8.1.4.7 数据完整性 b) 应采用校验技术或密码技术保证重要数据在存储过程中的完整性，包括但不限于鉴别数据、重要业务数据、重要审计数据、重要配置数据、重要视频数据和重要个人信息等。
【场景说明】一个优秀的信息系统平台应该具备信息加密和完整性保护措施，攻击者即使截获或拖取数据也因无法解密或破坏完整性而变得毫无价值。同时，随着我国《密码法》的颁布实施，商用密码（SM）的应用安全性也显得尤为重要。
在通常的渗透测试时，攻击者往往会利用各种方法手段去破解密文，以获得明文。请利用你所掌握的知识，发现本场景中的漏洞利用点，通过商用密码（SM4）算法对密文进行解密，并采用SM3算法生成该明文信息的完整性摘要值。
注入得到数据库中的密文，然后下载sm4，sm3算法，使用sm4算法解密得到
SM4_0c62148892ee
再使用sm3做完整性摘要计算。
# -*- coding:utf-8 -*-
"""
SM4 GM
"""
import copy
# Expanded SM4 S-boxes Sbox table: 8bits input convert to 8 bits output
SboxTable = [
0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,
0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62,
0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6,
0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8,
0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35,
0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87,
0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e,
0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1,
0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3,
0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f,
0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51,
0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8,
0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0,
0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84,
0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48,
]
# System parameter
FK = [0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc]
# fixed parameter
CK = [
0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,
0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,
0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279
]
ENCRYPT = 0
DECRYPT = 1
def GET_UINT32_BE(key_data):
tmp_data = int((key_data[0] << 24) | (key_data[1] << 16) | (key_data[2] << 8) | (key_data[3]))
return tmp_data
def PUT_UINT32_BE(n):
return [int((n >> 24) & 0xff), int((n >> 16) & 0xff), int((n >> 8) & 0xff), int((n) & 0xff)]
# rotate shift left marco definition
def SHL(x, n):
xx = int(int(x << n) & 0xffffffff)
return xx
def ROTL(x, n):
xx = SHL(x, n)
yy = xx | int((x >> (32 - n)) & 0xffffffff)
return yy
def XOR(a, b):
return list(map(lambda x, y: x ^ y, a, b))
# look up in SboxTable and get the related value.
# args: [in] inch: 0x00~0xFF (8 bits unsigned value).
def sm4Sbox(idx):
return SboxTable[idx]
# Calculating round encryption key.
# args: [in] a: a is a 32 bits unsigned value;
# return: sk[i]: i{0,1,2,3,...31}.
def sm4CalciRK(ka):
b = [0, 0, 0, 0]
a = PUT_UINT32_BE(ka)
b[0] = sm4Sbox(a[0])
b[1] = sm4Sbox(a[1])
b[2] = sm4Sbox(a[2])
b[3] = sm4Sbox(a[3])
bb = GET_UINT32_BE(b[0:4])
rk = bb ^ (ROTL(bb, 13)) ^ (ROTL(bb, 23))
return rk
# private F(Lt) function:
# "T algorithm" == "L algorithm" + "t algorithm".
# args: [in] a: a is a 32 bits unsigned value;
# return: c: c is calculated with line algorithm "L" and nonline algorithm "t"
def sm4Lt(ka):
b = [0, 0, 0, 0]
a = PUT_UINT32_BE(ka)
b[0] = sm4Sbox(a[0])
b[1] = sm4Sbox(a[1])
b[2] = sm4Sbox(a[2])
b[3] = sm4Sbox(a[3])
bb = GET_UINT32_BE(b[0:4])
c = bb ^ (ROTL(bb, 2)) ^ (ROTL(bb, 10)) ^ (ROTL(bb, 18)) ^ (ROTL(bb, 24))
return c
# private F function:
# Calculating and getting encryption/decryption contents.
# args: [in] x0: original contents;
# args: [in] x1: original contents;
# args: [in] x2: original contents;
# args: [in] x3: original contents;
# args: [in] rk: encryption/decryption key;
# return the contents of encryption/decryption contents.
def sm4F(x0, x1, x2, x3, rk):
return (x0 ^ sm4Lt(x1 ^ x2 ^ x3 ^ rk))
class Sm4(object):
def __init__(self):
self.sk = [0] * 32
self.mode = ENCRYPT
def sm4_set_key(self, key_data, mode):
self.sm4_setkey(key_data, mode)
def sm4_setkey(self, key, mode):
MK = [0, 0, 0, 0]
k = [0] * 36
MK[0] = GET_UINT32_BE(key[0:4])
MK[1] = GET_UINT32_BE(key[4:8])
MK[2] = GET_UINT32_BE(key[8:12])
MK[3] = GET_UINT32_BE(key[12:16])
k[0:4] = XOR(MK[0:4], FK[0:4])
for i in range(32):
k[i + 4] = k[i] ^ (sm4CalciRK(k[i + 1] ^ k[i + 2] ^ k[i + 3] ^ CK[i]))
self.sk[i] = k[i + 4]
self.mode = mode
if mode == DECRYPT:
for idx in range(16):
t = self.sk[idx]
self.sk[idx] = self.sk[31 - idx]
self.sk[31 - idx] = t
def sm4_one_round(self, sk, in_put):
out_put = []
ulbuf = [0] * 36
ulbuf[0] = GET_UINT32_BE(in_put[0:4])
ulbuf[1] = GET_UINT32_BE(in_put[4:8])
ulbuf[2] = GET_UINT32_BE(in_put[8:12])
ulbuf[3] = GET_UINT32_BE(in_put[12:16])
for idx in range(32):
ulbuf[idx + 4] = sm4F(ulbuf[idx], ulbuf[idx + 1], ulbuf[idx + 2], ulbuf[idx + 3], sk[idx])
out_put += PUT_UINT32_BE(ulbuf[35])
out_put += PUT_UINT32_BE(ulbuf[34])
out_put += PUT_UINT32_BE(ulbuf[33])
out_put += PUT_UINT32_BE(ulbuf[32])
return out_put
def sm4_crypt_ecb(self, input_data):
# SM4-ECB block encryption/decryption
length = len(input_data)
i = 0
output_data = []
while length > 0:
output_data += self.sm4_one_round(self.sk, input_data[i:i + 16])
i += 16
length -= 16
return output_data
def sm4_crypt_cbc(self, iv, input_data):
# SM4-CBC buffer encryption/decryption
length = len(input_data)
i = 0
output_data = []
tmp_input = [0] * 16
if self.mode == ENCRYPT:
while length > 0:
tmp_input[0:16] = XOR(input_data[i:i + 16], iv[0:16])
output_data += self.sm4_one_round(self.sk, tmp_input[0:16])
iv = copy.deepcopy(output_data[i:i + 16])
i += 16
length -= 16
else:
while length > 0:
output_data += self.sm4_one_round(self.sk, input_data[i:i + 16])
output_data[i:i + 16] = XOR(output_data[i:i + 16], iv[0:16])
iv = copy.deepcopy(input_data[i:i + 16])
i += 16
length -= 16
return output_data
def sm4_crypt_ecb(mode, key, data):
sm4_d = Sm4()
sm4_d.sm4_set_key(key, mode)
en_data = sm4_d.sm4_crypt_ecb(data)
return en_data
def sm4_crypt_cbc(mode, key, iv, data):
sm4_d = Sm4()
sm4_d.sm4_set_key(key, mode)
en_data = sm4_d.sm4_crypt_cbc(iv, data)
return en_data
def encrypt(key, message):
sm4_d = Sm4()
sm4_d.sm4_set_key(key, ENCRYPT)
cipher = sm4_d.sm4_crypt_ecb(message)
return cipher
def decrypt(key, cipher):
sm4_d = Sm4()
sm4_d.sm4_set_key(key, DECRYPT)
de_data = sm4_d.sm4_crypt_ecb(cipher)
message = (''.join(map(chr, de_data)))
return message
def read_file(filepath):
fp = open(filepath)
content = fp.readlines()
fp.close()
return content
if __name__ == "__main__":
# key = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
# message = [115, 109, 52, 32, 116, 101, 115, 116, 48, 49, 50, 51, 52, 53, 54, 55]
cipher = [167, 67, 35, 40, 2, 174, 156, 180, 14, 3, 97, 185, 54, 222, 236, 63]
ret = read_file('sm4_keys.txt')
for i in ret:
keys = []
exec ('keys = ' + i)
#print keys
print decrypt(keys, cipher)
#SM4_0c62148892ee
# print(ret)
# print encrypt(key,message)
# print decrypt(key, cipher)#coding:utf-8
#杂凑算法，非对称加密
import struct
IV="7380166f 4914b2b9 172442d7 da8a0600 a96f30bc 163138aa e38dee4d b0fb0e4e"
IV = int(IV.replace(" ", ""), 16)
a = []
for i in range(0, 8):
a.append(0)
a[i] = (IV >> ((7 - i) * 32)) & 0xFFFFFFFF
IV = a
def out_hex(list1):
for i in list1:
print "%08x" % i,
print "\n",
def rotate_left(a, k):
k = k % 32
return ((a << k) & 0xFFFFFFFF) | ((a & 0xFFFFFFFF) >> (32 - k))
T_j = []
for i in range(0, 16):
T_j.append(0)
T_j[i] = 0x79cc4519
for i in range(16, 64):
T_j.append(0)
T_j[i] = 0x7a879d8a
def FF_j(X, Y, Z, j):
if 0 <= j and j < 16:
ret = X ^ Y ^ Z
elif 16 <= j and j < 64:
ret = (X & Y) | (X & Z) | (Y & Z)
return ret
def GG_j(X, Y, Z, j):
if 0 <= j and j < 16:
ret = X ^ Y ^ Z
elif 16 <= j and j < 64:
#ret = (X | Y) & ((2 ** 32 - 1 - X) | Z)
ret = (X & Y) | ((~ X) & Z)
return ret
def P_0(X):
return X ^ (rotate_left(X, 9)) ^ (rotate_left(X, 17))
def P_1(X):
return X ^ (rotate_left(X, 15)) ^ (rotate_left(X, 23))
def CF(V_i, B_i):
W = []
for j in range(0, 16):
W.append(0)
unpack_list = struct.unpack(">I", B_i[j*4:(j+1)*4])
W[j] = unpack_list[0]
for j in range(16, 68):
W.append(0)
W[j] = P_1(W[j-16] ^ W[j-9] ^ (rotate_left(W[j-3], 15))) ^ (rotate_left(W[j-13], 7)) ^ W[j-6]
str1 = "%08x" % W[j]
W_1 = []
for j in range(0, 64):
W_1.append(0)
W_1[j] = W[j] ^ W[j+4]
str1 = "%08x" % W_1[j]
A, B, C, D, E, F, G, H = V_i
"""
print "00",
out_hex([A, B, C, D, E, F, G, H])
"""
for j in range(0, 64):
SS1 = rotate_left(((rotate_left(A, 12)) + E + (rotate_left(T_j[j], j))) & 0xFFFFFFFF, 7)
SS2 = SS1 ^ (rotate_left(A, 12))
TT1 = (FF_j(A, B, C, j) + D + SS2 + W_1[j]) & 0xFFFFFFFF
TT2 = (GG_j(E, F, G, j) + H + SS1 + W[j]) & 0xFFFFFFFF
D = C
C = rotate_left(B, 9)
B = A
A = TT1
H = G
G = rotate_left(F, 19)
F = E
E = P_0(TT2)
A = A & 0xFFFFFFFF
B = B & 0xFFFFFFFF
C = C & 0xFFFFFFFF
D = D & 0xFFFFFFFF
E = E & 0xFFFFFFFF
F = F & 0xFFFFFFFF
G = G & 0xFFFFFFFF
H = H & 0xFFFFFFFF
"""
str1 = "%02d" % j
if str1[0] == "0":
str1 = ' ' + str1[1:]
print str1,
out_hex([A, B, C, D, E, F, G, H])
"""
V_i_1 = []
V_i_1.append(A ^ V_i[0])
V_i_1.append(B ^ V_i[1])
V_i_1.append(C ^ V_i[2])
V_i_1.append(D ^ V_i[3])
V_i_1.append(E ^ V_i[4])
V_i_1.append(F ^ V_i[5])
V_i_1.append(G ^ V_i[6])
V_i_1.append(H ^ V_i[7])
return V_i_1
def hash_msg(msg):
len1 = len(msg)
reserve1 = len1 % 64
msg = msg + chr(0x80)
reserve1 = reserve1 + 1
for i in range(reserve1, 56):
msg = msg + chr(0x00)
bit_length = (len1) * 8
bit_length_string = struct.pack(">Q", bit_length)
msg = msg + bit_length_string
#print len(msg)
group_count = len(msg) / 64
m_1 = B = []
for i in range(0, group_count):
B.append(0)
B[i] = msg[i*64:(i+1)*64]
V = []
V.append(0)
V[0] = IV
for i in range(0, group_count):
V.append(0)
V[i+1] = CF(V[i], B[i])
return V[i+1]
print "abc"
y = hash_msg("SM4_0c62148892ee")
print "result: ",
out_hex(y)
print y
# print "abcd" * 16
# y = hash_msg("abcd" * 16)
# print "result: ",
# out_hex(y)第五题入侵防范2
分数:100
【IP】:172.20.2.50
【端口】 80
【标准要求】8.1.4.4 入侵防范 e)应能发现可能存在的已知漏洞，并在经过充分测试评估后，及时修补漏洞。
【场景说明】在通常的渗透测试中，攻击者往往会根据信息系统中组件的版本去寻找相关漏洞利用，所以必须要及时跟踪和发现已知漏洞，防止已知漏洞被利用。近年来，黑客也经常出于政治和经济目的，利用第三方组件漏洞控制服务并篡改网页，突破重要系统获取敏感数据。在近些年的攻防实战演练中，第三方组件的漏洞也成为常见的突破口。请利用你所掌握的知识，发现本场景中系统存在的漏洞，获取象征敏感信息的Flag。
打开页面，整个页面是一整张图片，没有什么漏洞，使用nmap进行扫描，扫到有8080端口，打开后发现是struts2框架，直接使用struts2漏洞利用工具命令执行，得到flag
第六题恶意代码防范
分数:100
【IP】:172.20.2.30
【端口】 9006
【标准要求】8.1.4.5 恶意代码防范 应采用免受恶意代码攻击的技术措施或主动免疫可信验证机制及时识别入侵和病毒行为，并将其有效阻断。
【场景说明】一个防护优秀的网络系统，应当采用免受恶意代码攻击的技术措施或主动免疫可信验证机制及时识别入侵和病毒行为，并将其有效阻断。某单位的系统采用了名为ThinkPHP的开源PHP框架。2019年1月，ThinkPHP 5.0爆发远程命令执行漏洞。该单位系统由于修补漏洞不及时，服务器上疑似已有被入侵的痕迹，由于缺乏可信验证的机制，怀疑攻击者留下了的恶意代码能够成功执行。通过源代码泄露的漏洞，请利用你所掌握的知识，找出攻击者留下的恶意代码并分析，获取象征敏感信息的flag。
给了源码，下载后搜索$_POST，第一个就是一句话木马，但是屏蔽了一些命令，最后时间不够了，没做出来。
第七题访问控制
分数:200
【IP】:172.20.2.30
【端口】 9007
【标准要求】8.1.4.2 访问控制 e)应由授权主体配置访问控制策略，访问控制策略规定主体对客体的访问规则。
【场景说明】一个设计良好的系统应该具备访问权限控制功能，良好的权限控制能有效地阻止未授权访问，对不同权限用户开放不同等级的访问权限。
在通常的渗透测试时，攻击者会尝试通过平行越权和垂直越权去访问原本非授权访问的模块或信息。请利用你所掌握的知识，发现本场景中信息系统存在的权限控制漏洞，并利用该漏洞去获取象征敏感信息的Flag。
根据提示判断是越权访问漏洞，先注册个账号，登录成功后发现cookie中有一个像base64的字符串，解密一下，发现是乱码，解密成16进制，记录16进制的值。
通过多注册几个账号测试发现，原base64加密是每隔4位加密是相同的值，这题是3位加密是相同的值，我们先注册一个值为：adm 的账号获取 adm的加密值，再注册一个123in的账号获取到后两位的加密值，把adm的加密值和in的加密值拼接到一起，就得到了admin的加密值，然后设置cookie，登录成功得到flag
第八题云计算安全
分数:200
【IP】:172.20.2.70
【端口】 80
【标准要求】8.2 云计算安全扩展要求
8.2.4.1 身份鉴别 当远程管理云计算平台中设备时，管理终端和云计算平台之间应建立双向身份验证机制。
8.2.4.3 入侵防范 b)应能检测非授权新建虚拟机或者重新启用虚拟机，并进行告警。
【场景说明】云计算平台作为承载上层应用系统的底层资源平台，其安全性尤为重要。云计算平台不同于以往安全计算环境的问题，场景更加复杂多样，攻击面更加广阔。请利用你所掌握的知识，发现本场景中云计算平台存在的漏洞，绕过资源隔离机制，获取象征敏感信息的Flag。
这题不会，只能通过2222端口使用test test登录一个服务器，不知道有什么用。
