第四届宁波网安市赛初赛

news2024/9/23 17:23:07

由于赛后官方不给wp(绿盟一向如此),交流群也没有得到其他题解,赛后就根据自己的wp来写了,wp由队友及我共同完成。比赛共解答10题,Web 5道,Misc 2道,Crypto 3道,wp只有一部分,缺少的部分有机会再补上吧

Web

赛后靶机关了,没办法再次复现,只能用当时编写的wp配图,好像源码l都换成了1

简单的php

对长度做了限制,这里代码观察后直接通配符即可

payload:?1=cat fl*

这题环境崩过几次,据说因为共用一个环境还被人删了flag

index

扫描网站目录得到源码

u s e r 和 user和 userpass存在注入点,user那里MD5加密就行

payload:user='union select '21232f297a57a5a743894a0e4a801fc3'#&pass=admin

GetFlag

验证码一直动,最离谱的是我CTRL+U里的验证码跟页面的不一样

使用脚本爆破出md5加密前的,提交得到php页面,自己脚本太烂了,放一下大佬的

import hashlib
from multiprocessing.dummy import Pool as ThreadPool


# MD5截断数值已知 求原始数据
# 例子 substr(md5(captcha), 0, 6)=60b7ef

def md5(s):  # 计算MD5字符串
    return hashlib.md5(str(s).encode('utf-8')).hexdigest()


keymd5 = '8f5fb0'  # 已知的md5截断值
md5start = 0  # 设置题目已知的截断位置
md5length = 6


def findmd5(sss):  # 输入范围 里面会进行md5测试
    key = sss.split(':')
    start = int(key[0])  # 开始位置
    end = int(key[1])  # 结束位置
    result = 0
    for i in range(start, end):
        # print(md5(i)[md5start:md5length])
        if md5(i)[0:6] == keymd5:  # 拿到加密字符串
            result = i
            print(result)  # 打印
            break


list = []  # 参数列表
for i in range(10):  # 多线程的数字列表 开始与结尾
    list.append(str(10000000 * i) + ':' + str(10000000 * (i + 1)))
pool = ThreadPool()  # 多线程任务
pool.map(findmd5, list)  # 函数 与参数列表
pool.close()
pool.join()

进去也有套娃,绕过去就行,构造payload:4e6333ed08642de989aa4af8ec40941d.php?ip=127.0.0.1%0acat+flag.php

hello,world

扫出备份文件.index.php.swp以及/index.php/login/,进入查看源码

文件包含,传入file=config.php试试

test666=sss607

php伪协议直接出

文件管理网站

扫出1.htaccess和lfi.php

文件包含

这里挂一波Mocha大佬的WEB wp,写得比我这详细得多也更有参考意义

Misc

美丽的小姐姐

因此,判断图片的chunk[0](也就是IHDR块)的数据跟crc32校验值不一致,被篡改了

import os
import binascii
import struct
misc = open("CRC-ERROR.png","rb").read()

# 爆破宽
for i in range(1024):
	data = misc[12:16] + struct.pack('>i',i)+ misc[20:29]  #IHDR数据
	crc32 = binascii.crc32(data) & 0xffffffff
	if crc32 == 0x5e687792: #IHDR块的crc32值
		print(i)
		print("hex:"+hex(i))
# 爆破高		
for i in range(1024):
    data = misc[12:20] + struct.pack('>i',i)+ misc[24:29]
    crc32 = binascii.crc32(data) & 0xffffffff
    if crc32 == 0x5e687792:
        print(i)
        print("hex:"+hex(i))

改高度,即出flag

音乐和乐谱

十六进制打开,发现末尾给了密码

把ejfg作为密码转为字符串,在线网站

Crypto

RSA

图解

flagMD5加密后大写

简单编码

下载下来,补全压缩后缀,打开后里面是jsfuck文件,在线解码

10进制转16进制

十六进制转字符串,每两位数字是一位字符,转后为id_jws,MD5加密大写

nike

原题,解压一行py脚本,格式化

(lambda __operator, __print, __g, __y: [(sys.setrecursionlimit(
        1000000), [
        [
            [
                [
                    [(decode(cipher), None)[1]
                        for __g['cipher'] in [(
                            'D6VNEIRAryZ8Opdbl3bOwqmBD+lmFXbcd/XfgHalqYBh1FDtbJo='
                        )]
                    ][0]
                    for __g['decode'], decode.__name__ in [(
                        lambda cipher: (lambda __l: [(
                                init(), [
                                    [
                                        [(lambda __after:
                                            (
                                                __print(
                                                    'sorry,you dont have the auth'
                                                ),
                                                0
                                            )[1]
                                            if(
                                                __l[
                                                    'auth'
                                                ] !=
                                                1
                                            )
                                            else
                                                __after()
                                        )(lambda:
                                            (
                                                lambda __items,
                                                __after,
                                                __sentinel:
                                                __y(
                                                    lambda __this:
                                                    lambda:
                                                    (
                                                        lambda __i: [
                                                            [
                                                                __this() for __l[
                                                                    'result'
                                                                ] in [
                                                                    (
                                                                        __operator
                                                                        .iadd(
                                                                            __l[
                                                                                'result'
                                                                            ],
                                                                            chr(
                                                                                (
                                                                                    s[
                                                                                        (
                                                                                            __l[
                                                                                                'i'
                                                                                            ] %
                                                                                            256
                                                                                        )
                                                                                    ] ^
                                                                                    ord(
                                                                                        __l[
                                                                                            'cipher'
                                                                                        ]
                                                                                        [
                                                                                            __l[
                                                                                                'i'
                                                                                            ]
                                                                                        ]
                                                                                    )
                                                                                )
                                                                            )
                                                                        )
                                                                    )
                                                                ]
                                                            ]
                                                            [
                                                                0
                                                            ]
                                                            for __l[
                                                                'i'
                                                            ] in [
                                                                (
                                                                    __i
                                                                )
                                                            ]
                                                        ]
                                                        [
                                                            0
                                                        ]
                                                        if __i is not __sentinel
                                                        else
                                                            __after()
                                                    )
                                                    (
                                                        next(
                                                            __items,
                                                            __sentinel
                                                        )
                                                    )
                                                )
                                                ()
                                            )(
                                                iter(
                                                    range(
                                                        len(
                                                            __l[
                                                                'cipher'
                                                            ]
                                                        )
                                                    )
                                                ),
                                                lambda:
                                                (
                                                    __print(
                                                        __l[
                                                            'result'
                                                        ]
                                                        .encode(
                                                            'base64'
                                                        )
                                                    ),
                                                    None
                                                )[
                                                    1
                                                ], []
                                            )) for __l[
                                            'auth'
                                        ] in [(0)]][0]
                                        for __l[
                                            'cipher'] in [
                                            (__l[
                                                'cipher'
                                            ].decode(
                                                'base64'
                                            ))
                                        ]
                                    ][0]
                                    for __l['result'] in [
                                        ('')
                                    ]
                                ][0])[1]
                            for __l['cipher'] in [(
                                cipher)]
                        ][0])(
                        {}), 'decode')]
                ][0]
                for __g['init'], init.__name__ in [(lambda: (
                    lambda __l: [
                        [(lambda __items, __after,
                            __sentinel: __y(
                                lambda __this:
                                lambda: (lambda __i: [
                                        (s.append(
                                            __l[
                                                'i'
                                            ]
                                        ), (k
                                            .append(
                                                ord(
                                                    __l[
                                                        'key'
                                                    ]
                                                    [
                                                        (
                                                            __l[
                                                                'i'
                                                            ] %
                                                            len(
                                                                __l[
                                                                    'key'
                                                                ]
                                                            )
                                                        )
                                                    ]
                                                )
                                            ),
                                            __this()
                                        )[1])[1]
                                        for __l[
                                            'i'] in [
                                            (__i)
                                        ]
                                    ][0]
                                    if __i is not __sentinel
                                    else __after()
                                )(next(__items,
                                    __sentinel
                                )))())(iter(range(
                            256)), lambda: (
                            lambda __items,
                            __after,
                            __sentinel: __y(
                                lambda __this:
                                lambda: (
                                    lambda __i: [
                                        [
                                            [
                                                [
                                                    [
                                                        __this() for s[
                                                            __l[
                                                                'j'
                                                            ]
                                                        ] in [
                                                            (
                                                                __l[
                                                                    'tmp'
                                                                ]
                                                            )
                                                        ]
                                                    ]
                                                    [
                                                        0
                                                    ]
                                                    for s[
                                                        __l[
                                                            'i'
                                                        ]
                                                    ] in [
                                                        (
                                                            s[
                                                                __l[
                                                                    'j'
                                                                ]
                                                            ]
                                                        )
                                                    ]
                                                ]
                                                [
                                                    0
                                                ]
                                                for __l[
                                                    'tmp'
                                                ] in [
                                                    (
                                                        s[
                                                            __l[
                                                                'i'
                                                            ]
                                                        ]
                                                    )
                                                ]
                                            ]
                                            [
                                                0
                                            ]
                                            for __l[
                                                'j'
                                            ] in [
                                                (
                                                    (
                                                        (
                                                            (
                                                                __l[
                                                                    'j'
                                                                ] +
                                                                s[
                                                                    __l[
                                                                        'i'
                                                                    ]
                                                                ]
                                                            ) +
                                                            k[
                                                                __l[
                                                                    'i'
                                                                ]
                                                            ]
                                                        ) %
                                                        256
                                                    )
                                                )
                                            ]
                                        ][0]
                                        for __l[
                                            'i'
                                        ] in [
                                            (
                                                __i
                                            )
                                        ]
                                    ][0]
                                    if __i is not __sentinel
                                    else
                                        __after()
                                )(next(
                                    __items,
                                    __sentinel
                                )))())(iter(
                                range(256)),
                            lambda: None, []), []) for __l[
                            'j'] in [(0)]][0]
                        for __l['key'] in [(
                            'aV9hbV9ub3RfZmxhZw=='
                            .decode('base64'))]
                    ][0])(
                {}), 'init')]
            ][0]
            for __g['k'] in [([])]
        ][0]
        for __g['s'] in [([])]
    ][0])[1]
    for __g['sys'] in [(__import__('sys', __g, __g))]
][0])(__import__('operator', level = 0), __import__('__builtin__',
    level = 0).__dict__['print'], globals(), (lambda f: (lambda x:
    x(x))(lambda y: f(lambda: y(y)()))))

格式化也好难读,这里把if(__l['auth'] !=1)修改为if(__l['auth'] ==1)运行即可出flag

进决赛了,没打过AWD,kali不太会用,师傅们手下留情,欢迎各位师傅交流交流AWD基础

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/351264.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

深度学习算法面试常问问题(一)

博主秋招遇到的面试问题以及整理其他面经相关问题,无偿分享~ 项目叙述: 算法需求及应用场景算法的调研和初步方案的制定数据的准备(包括数据标注和数据增强)算法的介绍(包括输入和输出,loss、backbone、训…

做外贸,你不能不懂的外贸流程知识

报关是履行海关进出境手续的必要环节之一,涉及两大类:进出境运输工具、物品和货物。由于性质不同,报关手续也有些不同。今天我就为大家详细介绍一下进出口报关的流程,包括出口货物报关的流程,随报关单提交的运费和商业单据&#x…

Spark中cache、persist、checkpoint三者的比较

原文链接:https://blog.csdn.net/AnameJL/article/details/124362219,再次主要是为了方便查找,把原文章复制一遍 目录 1. 三者的使用 1.1 cache的讲解与使用 1.2 persist的讲解与使用 1.3checkpoint 的讲解与使用 2. 三者的比较 2.1 优…

基于Web的智慧能源可视化管理系统

自工业革命开始,全球能源消耗持续增长,由碳循环体系破坏引发的全球变暖、海平面上升等问题严重影响着人类的可持续发展。得益于数字孪生、物联网、5G、AI识别等技术的不断成熟,以“大数据能源监控、精细化能源管理”为核心的智慧能源解决方案…

【电子学会】2022年12月图形化三级 -- 绘制雷达

绘制雷达 1. 准备工作 (1)绘制黑色背景; (2)删除默认角色小猫,添加角色Pencil。 2. 功能实现 (1)画笔的颜色设为黄色,Pencil的中心点设在笔尖位置,画笔的…

在Java 中 利用Milo通信库,实现OPCUA客户端,并生成证书

程序结构: 配置文件resources: opcua.properties 西门子PLC端口号为4840,kepserver为49320 #opcua服务端配置参数 #opcua.server.endpoint.urlopc.tcp://192.168.2.102:49320 opcua.server.endpoint.urlopc.tcp://192.168.2.11:4840 opcu…

2023年私募股权基金研究报告

第一章 概况 PE是私募,也即私募投资基金,是指以非公开发行方式向合格投资者募集的,投资于股票、股权、债券、期货、期权、基金份额及投资合同约定的其他投资标的(如艺术品、红酒等)的投资基金,简称私募基金…

【PyTorch学习3】《PyTorch深度学习实践》——反向传播(Back Propagation)

目录一、Tensor1.定义2.Tensor常见形式3.torch.tensor和torch.Tensor4.Tensor.grad二、反向传播一、Tensor 1.定义 张量的定义是一个可用来表示在一些矢量、标量和其他张量之间的线性关系的多线性函数。 在PyTorch上有这样一句话,A torch.Tensor is a multi…

TeeChart for .NET 2023.2.13 Crack

TeeChart NET Pro Edition 是一个基于 Nuget 的图表控件,旨在为您的 NET 应用程序提供即时图表、地图和仪表功能。TeeChart 拥有数十种图表类型、统计函数和开发人员工具,是当今开发人员可用的最全面的图表库之一。易于使用设计时编辑器和直观的编程结构…

蒙特卡洛计算圆周率

使用MC计算圆周率的小例子,使用python的numpy,matplotlib库import numpy as npimport matplotlib.pyplot as pltdef mc_calculate_pi(t):np.random.seed(t)rand_num np.random.rand(t)rand_num2 np.random.rand(t)l1 rand_num-0.5l2 rand_num2-0.5l0…

记录-配置unity多人游戏服务器中的踩坑经历

最近沉迷于gpt这个“魔法海螺”无法自拔,总之这是题外话了,Let.s go 文章目录前言一、IIS的HTTPS站点设置二、VS的远程部署设置三、运行.NET CORE的IIS站点——注意项四、SQL Server使用sa账号不能登录的问题解决五、SVN忽略so文件的提交,导致…

深入浅出带你学习IIS中间件常见漏洞

前言 在渗透过程中我们经常会思考如何去进行渗透,假如给了我们一个有很多中间件的网站我们要如何进行渗透呢?于是本人准备写一些包含常见中间件漏洞攻击的总结,希望可以帮到大家在面临不同渗透环境时会有渗透思路,本篇文章就先给…

开源单点登录MaxKey和JumpServer 堡垒机单点登录集成指南

1. MaxKey介绍 MaxKey社区专注于身份安全管理(IM)、单点登录(SSO)和云身份认证(IDaas)领域,将为客户提供企业级的身份管理和认证,提供全面的4A安全管理(指Account,Authentication,Authorization和Audit)。…

HCIP中期实验(华为)

题目: 实验要求: 1、该拓扑为公司网络,其中包括公司总部、公司分部以及公司骨干网,不包含运营商公网部分。 2、设备名称均使用拓扑上名称改名,并且区分大小写。 3、整张拓扑均使用私网地址进行配置。 4、整张网络中&am…

javaEE 初阶 — 延迟应答与捎带应答

文章目录1. 延迟应答2. 捎带应答TCP 工作机制:确认应答机制 超时重传机制 连接管理机制 滑动窗口 流量控制与拥塞控制 1. 延迟应答 延时应答 也是提升效率的机制,也是在滑动窗口基础上搞点事情。 滑动窗口的关键是让窗口大小大一点,传输…

骑行是什么?骑行是这十一非物质的东西

很多骑友一直在想,我们骑行是为什么?又没有什么实质性的价值,又不算是劳动,但究竟是什么?让我们坚持不懈的在坚持,在热爱? 1.骑行是一种自由,它可以让你放松心情,放空思绪…

JS中的数据类型判断

JS中的数据类型 基本数据类型 number、string、boolean、null、undefined、symbol 引用数据类型 object、array、function、date、regexp 判断数据类型的方法有 typeof 、instanceof、constructor、toString() typeof用法 从上面可以看出,typeof 对于JS中基本类型…

Promise学习笔记(一)

课程内容 1、Promise基础 2、手写Promise 3、Async和Await 4、应用实战 1、初始Promise 1.1、promise介绍 1.2、回调地狱(嵌套金字塔) 1.3、promise使用 (1)then(成功函数,失败函数):要么使用then传…

滑块连杆模型仿真(三菱ST+博途SCL计算源代码)

由滑块位置逆计算曲柄角度,请参看下面的文章链接。这篇博客主要计算由曲柄转动角度计算滑块位置。 https://blog.csdn.net/m0_46143730/article/details/128943228https://blog.csdn.net/m0_46143730/article/details/128943228简单的看下连杆滑块模型 模型的数学推导过程,大…

SpringCloud Alibaba项目环境

前言 有小伙伴说自己搭建Spring Cloud项目时,总会出现很多问题,项目无法正常启动,就算启动成功了也会出现一些难以预料的异常。 项目无法正常启动或者项目搭建不起来的原因大多是各个组件间的依赖和版本问题,这里就提供一个可以…