树莓派

都不清楚自己为啥好像一直很忙的样子, 买来树莓派吃灰了快一年, 今天终于有闲心再好好折腾下了

首先是装系统, 按着这里 http://www.ruanyifeng.com/blog/2017/06/raspberry-pi-tutorial.html 的步骤

• 下载 NOOBS。
• 在 mac 磁盘工具格式化 Micro SD 卡为 FAT 格式（操作指导）。
• 解压 NOOBS.zip 到 Micro SD 卡根目录。
• 插入 Micro SD 卡到树莓派底部的卡槽，接通电源，启动系统。
  插上鼠标点击安装, 等个十来分钟就好, 然后把 ssh 打开, 密码改一下(顺便把 root 也改了)

之前可能是没找对小触屏的驱动, 本来好好的系统一装完这个就挂了
今天好好看了下壳子上的版本号: KeDei 3.5 inch SPI TFTLCD version 6.3, 才发现官网其实很好找(只要用的是Google而不是百度…)
http://www.kedei.net/raspberry/raspberry.html
v6.3 用的应该就是这个驱动 http://www.kedei.net/raspberry/v6_1/LCD_show_v6_1_3.tar.gz

不过保险起见, 先备份一下系统吧
shutdown 后拔下 SD 卡, 插回 mac 可以看到自动挂载了 /boot 和 /recover 分区, 但其实还有两个分区, 打开磁盘工具可以看到
mount 看一下 /boot 和 /recover 是什么盘符:
/dev/disk3s6 68Mi 23Mi 45Mi 34% 0 0 100% /Volumes/boot
/dev/disk3s1 1.8Gi 1.7Gi 90Mi 96% 0 0 100% /Volumes/RECOVERY

所以把整个 disk3 备份一下就可以了
sudo dd if=/dev/disk3 of=/Users/air9/Downloads/raspi/backup.img
不过因为是整个 32G 的 SD 卡, 很是有些慢…

以后要恢复的话, 反着来就行(当然也是要先 mount 看一下啦)
sudo dd if=/Users/air9/Downloads/raspi/backup.img of=/dev/disk3

准备就绪, 开始尝试触屏了
将之前下载的 6.3 驱动 scp 到树莓派里
然后按照 http://blog.sina.com.cn/s/blog_163c3da910102whds.html 的步骤
解压驱动并 cd 进入
sudo apt-get update
sudo ./LCD_backup # 备份当前显示设置
sudo ./LCD35_v # 切换到小触屏的显示设置, 并自动重启

这时外接的大显示屏已经不亮了, 一开始还以为系统又挂了, 后来插上小触屏才发现…原来这俩显示模式不能共存…
然后用手指触控基本不可能…只能用一个上个世纪电阻屏手机的那种触控笔…
好吧…只能不情愿的接受这个设定了…

这个命令切换回正常的显示模式
sudo ./LCD_restore

evernote markdown

用 vim 写 markdown 还是太捉急了: 输入法切换, URL 换行, 列表换行…

另外考虑到同步问题, 把笔记全都放到一个地方还是更便于管理一点, 最终决定是 evernote 了, 有道的 mac 客户端太渣了连个全局搜索的快捷键都没有…

sublime evernote

参照 http://www.tuicool.com/articles/MfMZveq 配置好 sublime evernote 插件, 目前感觉还是挺不错的

遇到了 package control 的同步问题(http://www.jianshu.com/p/a3af44257b15), 其实 ss 切全局后重启 sublime 就可以了, 以后出问题了记得 cmd + `

本来想试试 cmd markdown 将本地笔记导入 Evernote 的, 结果这是付费功能而且不能批量导入… 还是 sublime 手动导入吧…

常用命令

• ever new
• ever send
• ever recent
• ever open
• ever update

vscode evermonkey

vscode 上有两个 evernote 相关的插件, evermonkey 远好于另外一个, 功能更全, 但还是比不上 sublime 的 evernote 插件, 不过也够用了, 另外也好看得多.

常用命令

• ever new
• ever publish
• ever recent
• ever open
• ever client (用本地客户端打开, 这个很实用的功能是 sublime 没有的)

优点

• Markdown 高亮比 st 好看
• 最后生成的笔记排版也更好看些
• 交互信息更友好

缺点

• 一旦保存文件到本地后, publish 附带的 update 功能就会失效, 会变成创建新文件
• open 后是一个 untitled 文件, 可能会出现莫名其妙的 html 标签
• 不会记忆上一次的命令

vscode

今天这一折腾, 突然发现 vscode 原来是个非常棒的编辑器. 目前已发现的优点:

• 整体性更强, 没有 st 的分裂感, 扩展和配置的管理比 st 更先进, 注释也非常友好
• 速度略逊于 st, 但远好于 atom 那个渣渣…
• 大部分默认快捷键都近似 st, 基本无缝切换
• vim 插件居然是官方提供的, 质量远高于 st
• 支持当前工作区设置, 项目目录下单独的配置文件, 十分简便

推荐插件 https://github.com/varHarrie/Dawn-Blossoms/issues/10

shell

参考 https://stackoverflow.com/questions/30065227/run-open-vscode-from-mac-terminal

Command + Shift + P 后 Shell Command : Install code in PATH, vscode 就会在 /usr/local/bin 加入一个脚本命令, 然后就能在终端直接code .了

polipo

似乎 10.11 引入 SIP 以来 Proxychains 就不能正常工作了, 导致终端代理一直出问题, 今天意外发现 polipo 这个不受 SIP 影响的工具, 尝试了一下果然不错

brew install polipo
polipo socksParentProxy=localhost:1086

即可实现配合 Shadowsocks(sock5 默认工作在 1086 端口)

为了方便日常切换, 在.zshrc中加入

#proxy
alias proxy="polipo socksParentProxy=localhost:1086"
export no_proxy="localhost,127.0.0.1,localaddress,.localdomain.com"
pon () {
    export http_proxy="http://127.0.0.1:8123/"
    export https_proxy="http://127.0.0.1:8123/"
    export ftp_proxy="http://127.0.0.1:8123/"
}
poff () {
    unset http_proxy
    unset https_proxy
    unset ftp_proxy
}
# charles proxy
pch () {
    export http_proxy="http://127.0.0.1:8888/"
    export https_proxy="http://127.0.0.1:8888/"
    export ftp_proxy="http://127.0.0.1:8888/"
}

以后常驻一个 pane 挂着proxy, 然后其他 pane 通过pon和poff切换即可

Charles

其中附加的pch, 可以实现 Charles 对终端的抓包

如果 Charles 打开 macOS 模式, 同时将 External Proxy 端口设置为 1087(Shadowsocks http/https 代理的默认端口), 可以翻墙的同时进行抓包

需要注意的是, 在没有导入证书的情况下对 HTTPS 抓包会出现失败或是乱码等问题

测试

> $ pon
> $ curl ip.cn
当前 IP：x.x.x.x 来自：香港特别行政区 xTom
> $ poff
> $ curl ip.cn
当前 IP：x.x.x.x 来自：北京市 电信
> $ pch
> $ curl ip.cn
当前 IP：x.x.x.x 来自：香港特别行政区 xTom

Kali rolling x86-64 环境，默认动态链接
参考 32 位： http://dbp-consulting.com/tutorials/debugging/linuxProgramStartup.html

流程图如下：

64 位草图

最简单的 main

int main()
{
}

gcc -ggdb -o prog1 prog1.c

execve

运行程序时，shell 或者 gui 调用 execve() 函数触发系统调用：

• 系统会分配栈区并将 argc, argv, envp 压栈
• 按照 shell 设定 FD
• 装载器负责重定位和调用preinitializers（图中preinitarray1..n）
• 从程序代码段中 _start 位置开始执行程序

_start

_start 是程序执行的初始位置，通过objdump -d prog1查看汇编

00000000004003b0 <_start>:
  4003b0:       31 ed                   xor    %ebp,%ebp
  4003b2:       49 89 d1                mov    %rdx,%r9                 # argv
  4003b5:       5e                      pop    %rsi                     # argc
  4003b6:       48 89 e2                mov    %rsp,%rdx                # linker destructor
  4003b9:       48 83 e4 f0             and    $0xfffffffffffffff0,%rsp
  4003bd:       50                      push   %rax
  4003be:       54                      push   %rsp
  4003bf:       49 c7 c0 30 05 40 00    mov    $0x400530,%r8            # <__libc_csu_fini>
  4003c6:       48 c7 c1 c0 04 40 00    mov    $0x4004c0,%rcx           # <__libc_csu_init>
  4003cd:       48 c7 c7 a6 04 40 00    mov    $0x4004a6,%rdi           # <main>
  4003d4:       ff 15 16 0c 20 00       callq  *0x200c16(%rip)        # 600ff0 <__libc_start_main@GLIBC_2.2.5>
  4003da:       f4                      hlt
  4003db:       0f 1f 44 00 00          nopl   0x0(%rax,%rax,1)

_start的作用就是配置__libc_start_main的参数并进行调用：

• xor %ebp, %ebp用于将 %ebp 清零，同时作为最外层标记

• 对 %rdi, %rsi, %rdx, %rcx, %r8, %r9 的操作均为传参，因为共 7 个参数，还用到了栈来传递第一个参数

  1. main地址, 由__libc_start_main调用, 另外在程序终止后main的返回值会由__libc_start_main传递给exit
  2. argc
  3. argv
  4. __libc_csu_init
  5. __libc_csu_fini
  6. Destructor of dynamic linker. Registered by libc_start_main with cxat_exit()
     to call the FINI for dynamic libraries that got loaded before us.
  7. 栈 - 函数调用前的%rsp

• 为了提升访存效率，编译器通常采用 16B 对齐。为了保证函数调用时的新栈帧是 16B 对齐的，使用and指令将 %esp 对齐。

• 同时，为了将 %esp 保存在 16B 对齐的位置，使用push %rax提前填充 8B

_start调用__libc_start_main前的状态:

__libc_start_main

__libc_start_main定义如下：

int __libc_start_main(  
    int (*main) (int, char * *, char * *),
    int argc, 
    char * * ubp_av,
    void (*init) (void),
    void (*fini) (void),
    void (*rtld_fini) (void),
    void (* stack_end)
 );

main的完整参数调用应该是int main(int argc, char** argv, char** envp), 但是__libc_start_main中却并不包含 envp, 因为envp可以由argc和argv计算得到

ELF auxiliary vector

使用 gdb 调试 prog1, 在_start处下断点, 运行初始状态如下:

可以看到从栈顶向栈底依次放置的是: argc, argv, 0x0, 环境变量等, 即ELF 辅助向量.

__libc_start_main 的主要功能

• setuid, setgid

• 启动线程

• 寄存fini和rtld_fini的参数, 等待at_exit调用

• 调用__libc_csu_init

• 调用main

• 调用exit

  ​

__libc_csu_init

void __libc_csu_init (int argc, char **argv, char **envp)
{
  _init ();
  const size_t size = __init_array_end - __init_array_start;
  for (size_t i = 0; i < size; i++)
      (*__init_array_start [i]) (argc, argv, envp);
}

00000000004004c0 <__libc_csu_init>:
  4004c0:	41 57                	push   %r15
  4004c2:	41 56                	push   %r14
  4004c4:	41 89 ff             	mov    %edi,%r15d
  4004c7:	41 55                	push   %r13
  4004c9:	41 54                	push   %r12
  4004cb:	4c 8d 25 76 09 20 00 	lea    0x200976(%rip),%r12        # 600e48 <__frame_dummy_init_array_entry>
  4004d2:	55                   	push   %rbp
  4004d3:	48 8d 2d 76 09 20 00 	lea    0x200976(%rip),%rbp        # 600e50 <__init_array_end>
  4004da:	53                   	push   %rbx
  4004db:	49 89 f6             	mov    %rsi,%r14
  4004de:	49 89 d5             	mov    %rdx,%r13
  4004e1:	4c 29 e5             	sub    %r12,%rbp
  4004e4:	48 83 ec 08          	sub    $0x8,%rsp
  4004e8:	48 c1 fd 03          	sar    $0x3,%rbp
  4004ec:	e8 9f fe ff ff       	callq  400390 <_init>
  4004f1:	48 85 ed             	test   %rbp,%rbp
  4004f4:	74 20                	je     400516 <__libc_csu_init+0x56>
  4004f6:	31 db                	xor    %ebx,%ebx
  4004f8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  4004ff:	00
  400500:	4c 89 ea             	mov    %r13,%rdx
  400503:	4c 89 f6             	mov    %r14,%rsi
  400506:	44 89 ff             	mov    %r15d,%edi
  400509:	41 ff 14 dc          	callq  *(%r12,%rbx,8)
  40050d:	48 83 c3 01          	add    $0x1,%rbx
  400511:	48 39 dd             	cmp    %rbx,%rbp
  400514:	75 ea                	jne    400500 <__libc_csu_init+0x40>
  400516:	48 83 c4 08          	add    $0x8,%rsp
  40051a:	5b                   	pop    %rbx
  40051b:	5d                   	pop    %rbp
  40051c:	41 5c                	pop    %r12
  40051e:	41 5d                	pop    %r13
  400520:	41 5e                	pop    %r14
  400522:	41 5f                	pop    %r15
  400524:	c3                   	retq
  400525:	90                   	nop
  400526:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40052d:	00 00 00

0000000000400390 <_init>:
  400390:	48 83 ec 08          	sub    $0x8,%rsp
  400394:	48 8b 05 5d 0c 20 00 	mov    0x200c5d(%rip),%rax        # 600ff8 <__gmon_start__>
  40039b:	48 85 c0             	test   %rax,%rax
  40039e:	74 02                	je     4003a2 <_init+0x12>
  4003a0:	ff d0                	callq  *%rax
  4003a2:	48 83 c4 08          	add    $0x8,%rsp
  4003a6:	c3                   	retq

__libc_csu_init返回__libc_start_main前:

Python 的反汇编框架很多，尤其是 capstone 非常好用
但是将常见汇编语句汇编成对应机器码的框架居然一直没找到
难道没有其他懒得记机器码的人了吗╮(╯_╰)╭

今天突然发现 capstone 的作者似乎居然早就听到了我的心声
在上半年就发布了一个汇编框架 keystone
pip install keystone-engine 就可以安装，用法和 capstone 非常相似
甚至连毛病也一样，把动态库放到正确的位置才能正常使用…

cp /usr/local/lib/python2.7/site-packages/usr/local/Cellar/python/2.7.12_1/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/keystone/libkeystone.dylib /usr/local/lib/python2.7/site-packages/keystone/libkeystone.dylib

使用起来非常简单

#!/usr/bin/python
from __future__ import print_function
from keystone import *
def ks_asm(code, arch=KS_ARCH_X86, mode=KS_MODE_64, syntax=0):
    ks = Ks(arch, mode)
    if syntax != 0:
        ks.syntax = syntax
    encoding, count = ks.asm(code)
    # print(encoding)
    print('{} = '.format(code), end='')
    for i in encoding:
        print('{:02x} '.format(i), end='')
code = 'mov rax, rsp; syscall; nop; pop rbx; ret'
ks_asm(code)
# mov rax, rsp; syscall; nop; pop rbx; ret = 48 89 e0 0f 05 90 5b c3

另外官方用例：https://github.com/keystone-engine/keystone/blob/master/bindings/python/sample.py

简直爱死这个作者了 -0-
另外发现他还有一个 CPU emulator 框架 Unicorn
有时间了可以学习下

今天知道了一个控制终端输出颜色的第三方库 termcolor，代码很简单：

# coding: utf-8
# Copyright (c) 2008-2011 Volvox Development Team
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# Author: Konstantin Lepa <konstantin.lepa@gmail.com>
"""ANSII Color formatting for output in terminal."""
from __future__ import print_function
import os
__ALL__ = [ 'colored', 'cprint' ]
VERSION = (1, 1, 0)
ATTRIBUTES = dict(
        list(zip([
            'bold',
            'dark',
            '',
            'underline',
            'blink',
            '',
            'reverse',
            'concealed'
            ],
            list(range(1, 9))
            ))
        )
del ATTRIBUTES['']
HIGHLIGHTS = dict(
        list(zip([
            'on_grey',
            'on_red',
            'on_green',
            'on_yellow',
            'on_blue',
            'on_magenta',
            'on_cyan',
            'on_white'
            ],
            list(range(40, 48))
            ))
        )
COLORS = dict(
        list(zip([
            'grey',
            'red',
            'green',
            'yellow',
            'blue',
            'magenta',
            'cyan',
            'white',
            ],
            list(range(30, 38))
            ))
        )
RESET = '\033[0m'
def colored(text, color=None, on_color=None, attrs=None):
    """Colorize text.
    Available text colors:
        red, green, yellow, blue, magenta, cyan, white.
    Available text highlights:
        on_red, on_green, on_yellow, on_blue, on_magenta, on_cyan, on_white.
    Available attributes:
        bold, dark, underline, blink, reverse, concealed.
    Example:
        colored('Hello, World!', 'red', 'on_grey', ['blue', 'blink'])
        colored('Hello, World!', 'green')
    """
    if os.getenv('ANSI_COLORS_DISABLED') is None:
        fmt_str = '\033[%dm%s'
        if color is not None:
            text = fmt_str % (COLORS[color], text)
        if on_color is not None:
            text = fmt_str % (HIGHLIGHTS[on_color], text)
        if attrs is not None:
            for attr in attrs:
                text = fmt_str % (ATTRIBUTES[attr], text)
        text += RESET
    return text
def cprint(text, color=None, on_color=None, attrs=None, **kwargs):
    """Print colorize text.
    It accepts arguments of print function.
    """
    print((colored(text, color, on_color, attrs)), **kwargs)
if __name__ == '__main__':
    print('Current terminal type: %s' % os.getenv('TERM'))
    print('Test basic colors:')
    cprint('Grey color', 'grey')
    cprint('Red color', 'red')
    cprint('Green color', 'green')
    cprint('Yellow color', 'yellow')
    cprint('Blue color', 'blue')
    cprint('Magenta color', 'magenta')
    cprint('Cyan color', 'cyan')
    cprint('White color', 'white')
    print(('-' * 78))
    print('Test highlights:')
    cprint('On grey color', on_color='on_grey')
    cprint('On red color', on_color='on_red')
    cprint('On green color', on_color='on_green')
    cprint('On yellow color', on_color='on_yellow')
    cprint('On blue color', on_color='on_blue')
    cprint('On magenta color', on_color='on_magenta')
    cprint('On cyan color', on_color='on_cyan')
    cprint('On white color', color='grey', on_color='on_white')
    print('-' * 78)
    print('Test attributes:')
    cprint('Bold grey color', 'grey', attrs=['bold'])
    cprint('Dark red color', 'red', attrs=['dark'])
    cprint('Underline green color', 'green', attrs=['underline'])
    cprint('Blink yellow color', 'yellow', attrs=['blink'])
    cprint('Reversed blue color', 'blue', attrs=['reverse'])
    cprint('Concealed Magenta color', 'magenta', attrs=['concealed'])
    cprint('Bold underline reverse cyan color', 'cyan',
            attrs=['bold', 'underline', 'reverse'])
    cprint('Dark blink concealed white color', 'white',
            attrs=['dark', 'blink', 'concealed'])
    print(('-' * 78))
    print('Test mixing:')
    cprint('Underline red on grey color', 'red', 'on_grey',
            ['underline'])
    cprint('Reversed green on red color', 'green', 'on_red', ['reverse'])

不过它不支持 Windows，另外有一个复杂一些但是全平台通用的 colorama，见 http://stackoverflow.com/questions/21858567/why-termcolor-doesnt-work-in-python

代码中设置颜色的部分有点费解，查阅其用到的知识点如下

ANSI 控制码

ANSI 控制码即控制序列（Control Sequence）。大多数终端模拟器（Unix，Linux，Windows）都支持 ANSI 控制码。ANSI 控制码以 ESC 字符（ASCII 27/0x1b/033）开头，分为两类：

• 非 CSI 序列
  双字符控制码，格式为ESC``字符，第二个字符的范围是 ASCII 64~95 (‘@’~’_’)
• CSI 序列
  多于两个字符，格式为ESC[``其余字符

常用序列表可见 https://en.wikipedia.org/wiki/ANSI_escape_code

颜色控制

其中设定终端文本颜色的序列格式为ESC[``编号``;编号``m

颜色分为字体色（前景色）和背景色，30~37用来设置字体色，40~47设置背景色，其他常用控制码：

• \033[0m 重置所有属性
• \033[1m 设置高亮度
• \033[4m 下划线
• \033[5m 闪烁
• \033[7m 反色

用例

\033[1;31;40m
1-高亮显示，31-前景色红色，40-背景色黑色

\033[0m
重置，即恢复默认设置

python-magic 是一个用来判断文件类型的第三方库，效果与 linux 命令file类似

使用pip install python-magic安装后，在 mac 上还需要brew install libmagic，之后即可正常使用

>>> import magic
>>> magic.from_file('readme.md')
'ASCII text'

不过在 kali rolling 上则会报错

>>> import magic
>>> magic.from_file("testdata/test.pdf")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'from_file'

在 stackoverflow 中有人提到原因：

python-magic 有多种实现，apt-get 中预装了 5.19.1 版，import时优先于刚刚用 pip 安装的版本，使用起来相对复杂一些

>>> import magic
>>> m=magic.open(magic.MAGIC_NONE)
>>> m.load()
0
>>> m.file('/etc/passwd')
'ASCII text'
>>> m.file('/usr/share/cups/data/default.pdf')
'PDF document, version 1.5'
>>> m=magic.open(magic.MAGIC_MIME)
>>> m.load()
0
>>> m.file('/etc/passwd')
'text/plain; charset=us-ascii'
>>> m.file('/usr/share/cups/data/default.pdf')
'application/pdf; charset=binary'

如果想使用带有from_file方法的版本将其替换为 pip 版即可

apt-get remove python-magic
pip install python-magic

目录结构

.
├── batch.py
├── detail
│   ├── heap_test.txt
│   ├── heap_test_static.txt
│   ├── libc2.21.txt
│   ├── ls.txt
│   ├── mv.txt
│   ├── stack_test.txt
│   └── stack_test_static.txt
├── elf
│   ├── heap_test
│   ├── heap_test_static
│   ├── libc2.21
│   ├── ls
│   ├── mv
│   ├── stack_test
│   └── stack_test_static
├── fragment
│   ├── heap_test.txt
│   ├── heap_test_static.txt
│   ├── libc2.21.txt
│   ├── ls.txt
│   ├── mv.txt
│   ├── stack_test.txt
│   └── stack_test_static.txt
├── ganalyzer.py
├── gcollector.py
├── gvalidator.py
├── lib
│   ├── __init__.py
│   ├── __init__.pyc
│   ├── classifier.py
│   ├── classifier.pyc
│   ├── extra_archinfo.py
│   ├── extra_archinfo.pyc
│   ├── gadget.py
│   ├── gadget.pyc
│   ├── utils.py
│   ├── utils.pyc
│   ├── validator.py
│   └── validator.pyc
├── pin
│   ├── heap_test.txt
│   ├── heap_test_static.txt
│   ├── libc2.21.txt
│   ├── ls.txt
│   ├── mv.txt
│   ├── stack_test.txt
│   └── stack_test_static.txt
└── result.txt
5 directories, 46 files

执行流程

具体步骤

1. 将要分析的 elf 文件放入 elf 目录
2. 在主目录运行python batch.py
3. 脚本会批量使用 ida 静态分析 elf 目录内的所有 elf 文件并在完成后自动关闭 ida
4. 由于版本功能限制，无法完全自动化，每个 elf 需要在弹窗时手动回车确认 2 次
5. 中间结果分别保存于 fragment, detail 和 pin 目录，最终结果保存于主目录下的 result.txt

主要模块

gcollector.py

目标

找到所有间接跳转（IBR)，再按 IBR 所在地址回溯，直到上一条跳转指令为止，输出其间所有可能构成 gadget 的指令片段，按不同文件名保存到 fragment 目录

例如

> length: 1
|-- .fini:80485B7	retn
c3
----------------------------------------
> length: 2
|-- .fini:80485B6	pop     ebx
|-- .fini:80485B7	retn
5bc3
----------------------------------------
> length: 3
|-- .fini:80485B3	add     esp, 8
|-- .fini:80485B6	pop     ebx
|-- .fini:80485B7	retn
83c4085bc3
----------------------------------------
> length: 4
|-- .fini:80485AD	add     ebx, 1217h
|-- .fini:80485B3	add     esp, 8
|-- .fini:80485B6	pop     ebx
|-- .fini:80485B7	retn
81c31712000083c4085bc3

回溯到第 5 条指令时为另一条跳转指令，所以以 80485B7 retn为结尾所有可能为 gadget 的指令片段一共只有 4 种

思路

1. 利用 ida-python 提供的 api Segments()获得所有段起始地址，SegEnd()获取段结束地址
2. 根据对应段的起止地址，利用Heads(start, end)得到段内所有指令的起始地址
3. 利用disasm(head)函数获得指令的机器码和汇编代码
4. 通过正则表达式和机器码判断指令是否为间接跳转指令并按如上目标格式保存，同时加上call-preceded和syscall等标记
5. 对总指令数等数据进行统计，同时利用Functions()收集所有函数入口

gvalidator.py

目标

以每个间接跳转为单位，对所有以该间接跳转为结尾的指令片段进行判断：

1. 是否存在 functional gadget， 最大长度多少
2. 是否存在 nop gadget， 最大长度多少
3. 是否为 call-preceded gadget

思路

1. 遍历 fragment 目录中所有 txt 文件并依次进行逐行读取，根据+>|-*等预设标记判断该行内容类型，然后收集对应长度的指令片段、片段内部遭到修改的寄存器
2. 读取到整个指令片段的机器码时，利用 Q 的 api classifier.GadgetClassifier()判断片段是否为 functional gadget，并统计相关数据
3. 若非 functional gadget，根据可容忍的最大寄存器修改数量判断可否归为 nop gadget，并统计相关数据
4. 按文件名保存所有统计数据到 detail 目录
5. 另外按照 pin 动态分析所需的输入数据格式将对应部分数据保存到 pin 目录

ganalyzer.py

目标

将 detail 目录中所有统计数据汇总到 result.txt 中

输出样例

heap_test, heap_test_static, libc2, ls, mv, stack_test, stack_test_static
+ Files: 7
+ [AVG]
|-- Functions: 794.00
|-- Instructions: 86870.29
|-- Branch instructions: 17118.00
|-- Indirect branch instructions: 1609.29
    |-- ret: 1211.43 (9 ~ 5587)
    |-- jmp: 88.00 (1 ~ 408)
    |-- call: 284.43 (4 ~ 1300)
    |-- system call: 90.57 (0 ~ 462)
    |-- call preceded: 284.43 (4 ~ 1300)
|-- Functional gadgets: 6145.29
    |-- length: 4.15 (0 ~ 48)
|-- Nop gadgets: 3634.14
    |-- length: 2.07 (0 ~ 71)
|-- Normal code fragments: 924.57
    |-- length: 9.01 (0 ~ 80)

使用 ionic 附带的 ngResource 时需要在 index.html 中加上

<script src="lib/ionic/js/angular/angular-resource.js"></script>

否则会报错

另外，官方文档中关于使用popover独立 html 模板的格式有点小问题：

<script id="my-popover.html" type="text/ng-template">
  <ion-popover-view>
    <ion-header-bar>
      <h1 class="title">My Popover Title</h1>
    </ion-header-bar>
    <ion-content>
      Hello!
    </ion-content>
  </ion-popover-view>
</script>

需改为

<ion-popover-view>
  <ion-header-bar>
    <h1 class="title">My Popover Title</h1>
  </ion-header-bar>
  <ion-content>
    Hello!qwew
  </ion-content>
</ion-popover-view>

否则会无法找到对应 template 而产生Error: popoverEle[0] is undefined

转自：http://www.nowamagic.net/librarys/veda/detail/2053

Code Smell中文译名一般为“代码异味”，或“代码味道”，它是提示代码中某个地方存在错误的一个暗示，开发人员可以通过这种smell（异味）在代码中追捕到问题。

在计算机编程社区中，code smell代表了任何标志着事物变坏的征兆。它常常标志代码应该被refactored或者全部的设计都应该被reviewed。这个短语出现在 WardsWiki上，它是被Kent Beck杜撰出来的。在refactoring兴起之后，这个短语的使用率骤增。

判断是否存在code smell经常是主观判断，并且随着语言、开发者、开发理论的不同而存在差异。

经验丰富和知识渊博的开发人员通过对优秀设计有一种“感觉”，他们已经达到一种称之为“无意识能力 （UnconsciousCompetence）”的状态。也就是说，他们无需思考，只要通过查看代码或一段设计就可以立马对这个项目的代码质量有一种 “感觉”，能够对代码设计的优劣有一个大致的判断。

但大家需要注意，code smell只是一种“暗示”，而非一种“确定”。将某些事物称之为“code smell”并未是一种攻击，它只是一种提示：开发人员需要对项目设计进行更进一步的查看。因此，code smell更多是“直觉的，本能的”。

code smell一般包括：

1. Duplicated Code。代码重复几乎是最常见的异味了。他也是Refactoring 的主要目标之一。代码重复往往来自于copy-and-paste 的编程风格。与他相对应OAOO 是一个好系统的重要标志。

2. Long method。它是传统结构化的“遗毒”。一个方法应当具有自我独立的意图，不要把几个意图放在一起，特别注意大类和长方法。

3. Large Class。大类就是你把太多的责任交给了一个类。这里的规则是One Class One。

4. Divergent Change。一个类里面的内容变化率不同。某些状态一个小时变一次，某些则几个月一年才变一次；某些状态因为这方面的原因发生变化，而另一些则因为其他方面的原因变一 次。面向对象的抽象就是把相对不变的和相对变化相隔离。把问题变化的一方面和另一方面相隔离。这使得这些相对不变的可以重用。问题变化的每个方面都可以单 独重用。这种相异变化的共存使得重用非常困难。

5. Shotgun Surgery。这正好和上面相反。对系统一个地方的改变涉及到其他许多地方的相关改变。这些变化率和变化内容相似的状态和行为通常应当放在同一个类中。

6. Feature Envy。对象的目的就是封装状态以及与这些状态紧密相关的行为。如果一个类的方法频繁用get 方法存取其他类的状态进行计算，那么你要考虑把行为移到涉及状态数目最多的那个类。

7. Data Clumps。某些数据通常像孩子一样成群玩耍：一起出现在很多类的成员变量中，一起出现在许多方法的参数中……，这些数据或许应该自己独立形成对象。

8. Primitive Obsession。面向对象的新手通常习惯使用几个原始类型的数据来表示一个概念。譬如对于范围，他们会使用两个数字。对于Money，他们会用一个浮点数来表示。因为你没 有使用对象来表达问题中存在的概念，这使得代码变的难以理解，解决问题的难度大大增加。好的习惯是扩充语言所能提供原始类型，用小对象来表示范围、金额、 转化率、邮政编码等等。

9. Switch Statement。基于常量的开关语句是OO 的大敌，你应当把他变为子类、state 或strategy。

10. Parallel Inheritance Hierarchies。并行的继承层次是shotgun surgery 的特殊情况。因为当你改变一个层次中的某一个类时，你必须同时改变另外一个层次的并行子类。

11. Lazy Class。一个干活不多的类。类的维护需要额外的开销，如果一个类承担了太少的责任，应当消除它。

12. Speculative Generality。一个类实现了从未用到的功能和通用性。通常这样的类或方法唯一的用户是test case。不要犹豫，删除它。

13. Temporary Field。一个对象的属性可能只在某些情况下才有意义。这样的代码将难以理解。专门建立一个对象来持有这样的孤儿属性，把只和他相关的行为移到该类。最常见的是一个特定的算法需要某些只有该算法才有用的变量。

14. Message Chain。消息链发生于当一个客户向一个对象要求另一个对象，然后客户又向这另一对象要求另一个对象，再向这另一个对象要求另一个对象，如此如此。这时，你需要隐藏分派。

15. Middle Man。对象的基本特性之一就是封装，而你经常会通过分派去实现封装。但是这一步不能走得太远，如果你发现一个类接口的一大半方法都在做分派，你可能需要移去这个中间人。

16. Inappropriate Intimacy。某些类相互之间太亲密，它们花费了太多的时间去砖研别人的私有部分。对人类而言，我们也许不应该太假正经，但我们应当让自己的类严格遵守禁欲主义。

17. Alternative Classes with Different Interfaces。做相同事情的方法有不同的函数signature，一致把它们往类层次上移，直至协议一致。

18. Incomplete Library Class。要建立一个好的类库非常困难。我们大量的程序工作都基于类库实现。然而，如此广泛而又相异的目标对库构建者提出了苛刻的要求。库构建者也不是万能的。有时 候我们会发现库类无法实现我们需要的功能。而直接对库类的修改有非常困难。这时候就需要用各种手段进行Refactoring。

19. Data Class。对象包括状态和行为。如果一个类只有状态没有行为，那么肯定有什么地方出问题了。

20. Refused Bequest。超类传下来很多行为和状态，而子类只是用了其中的很小一部分。这通常意味着你的类层次有问题。

21. Comments。经常觉得要写很多注释表示你的代码难以理解。如果这种感觉太多，表示你需要Refactoring。

Mac 下按照官网说明 安装 mongodb 并配置好PATH后直接mongo会报错：

$ brew install mongodb
...
$ export PATH=$PATH:/usr/local/Cellar/mongodb/3.2.9/bin
$ mongo
MongoDB shell version: 3.2.9
connecting to: test
2016-09-22T20:15:48.787+0800 W NETWORK  [thread1] Failed to connect to 127.0.0.1:27017, reason: errno:61 Connection refused
2016-09-22T20:15:48.789+0800 E QUERY    [thread1] Error: couldn't connect to server 127.0.0.1:27017, connection attempt failed :
connect@src/mongo/shell/mongo.js:229:14
@(connect):1:6
exception: connect failed

好在 Stackoverflow 一个答案提到，是因为没有启动 mongodb service:

Did you run mongod before running mongo?

I followed installation instructions for mongodb from http://docs.mongodb.org/manual/tutorial/install-mongodb-on-os-x/ and I had the same error as you only when I ran mongo before actually running the mongo process with mongod. I thought installing mongodb would also launch it but you need to launch it manually with mongod before you do anything else that needs mongodb.

不过还是报错：

$ mongod
2016-09-22T20:28:37.094+0800 I CONTROL  [initandlisten] MongoDB starting : pid=75109 port=27017 dbpath=/data/db 64-bit host=localhost
2016-09-22T20:28:37.095+0800 I CONTROL  [initandlisten] db version v3.2.9
2016-09-22T20:28:37.095+0800 I CONTROL  [initandlisten] git version: 22ec9e93b40c85fc7cae7d56e7d6a02fd811088c
2016-09-22T20:28:37.095+0800 I CONTROL  [initandlisten] OpenSSL version: OpenSSL 1.0.2h  3 May 2016
2016-09-22T20:28:37.095+0800 I CONTROL  [initandlisten] allocator: system
2016-09-22T20:28:37.095+0800 I CONTROL  [initandlisten] modules: none
2016-09-22T20:28:37.095+0800 I CONTROL  [initandlisten] build environment:
2016-09-22T20:28:37.095+0800 I CONTROL  [initandlisten]     distarch: x86_64
2016-09-22T20:28:37.095+0800 I CONTROL  [initandlisten]     target_arch: x86_64
2016-09-22T20:28:37.095+0800 I CONTROL  [initandlisten] options: {}
2016-09-22T20:28:37.097+0800 I -        [initandlisten] Detected data files in /data/db created by the 'mmapv1' storage engine, so setting the active storage engine to 'mmapv1'.
2016-09-22T20:28:37.100+0800 I STORAGE  [initandlisten] exception in initAndListen: 98 Unable to create/open lock file: /data/db/mongod.lock errno:13 Permission denied Is a mongod instance already running?, terminating
2016-09-22T20:28:37.100+0800 I CONTROL  [initandlisten] dbexit:  rc: 100

看见lock file习惯性想去删掉，结果依然不行

最后还是在 Stackoverflow 找到解决方法：

$ sudo chown -R $USER /data/db
$ mongod
2016-09-22T21:08:07.066+0800 I CONTROL  [initandlisten] MongoDB starting : pid=75729 port=27017 dbpath=/data/db 64-bit host=localhost
2016-09-22T21:08:07.066+0800 I CONTROL  [initandlisten] db version v3.2.9
2016-09-22T21:08:07.066+0800 I CONTROL  [initandlisten] git version: 22ec9e93b40c85fc7cae7d56e7d6a02fd811088c
2016-09-22T21:08:07.066+0800 I CONTROL  [initandlisten] OpenSSL version: OpenSSL 1.0.2h  3 May 2016
2016-09-22T21:08:07.066+0800 I CONTROL  [initandlisten] allocator: system
2016-09-22T21:08:07.066+0800 I CONTROL  [initandlisten] modules: none
2016-09-22T21:08:07.066+0800 I CONTROL  [initandlisten] build environment:
2016-09-22T21:08:07.066+0800 I CONTROL  [initandlisten]     distarch: x86_64
2016-09-22T21:08:07.066+0800 I CONTROL  [initandlisten]     target_arch: x86_64
2016-09-22T21:08:07.067+0800 I CONTROL  [initandlisten] options: {}
2016-09-22T21:08:07.069+0800 I -        [initandlisten] Detected data files in /data/db created by the 'mmapv1' storage engine, so setting the active storage engine to 'mmapv1'.
2016-09-22T21:08:07.096+0800 I JOURNAL  [initandlisten] journal dir=/data/db/journal
2016-09-22T21:08:07.096+0800 I JOURNAL  [initandlisten] recover : no journal files present, no recovery needed
2016-09-22T21:08:07.112+0800 I JOURNAL  [durability] Durability thread started
2016-09-22T21:08:07.112+0800 I JOURNAL  [journal writer] Journal writer thread started
2016-09-22T21:08:07.438+0800 I FTDC     [initandlisten] Initializing full-time diagnostic data capture with directory '/data/db/diagnostic.data'
2016-09-22T21:08:07.438+0800 I NETWORK  [HostnameCanonicalizationWorker] Starting hostname canonicalization worker
2016-09-22T21:08:07.439+0800 I NETWORK  [initandlisten] waiting for connections on port 27017

开启mongod后再mongo就可以了

$ mongo
MongoDB shell version: 3.2.9
connecting to: test
>

感觉 mongodb 的官方文档有点掉链子啊…

安装

1. 安装 Python 2.7

2. 下载 https://github.com/idapython/bin/raw/master/idapython-6.9.0-python2.7-mac.zip 并解压

3. 将 Python 内的所有内容复制到 IDA 根目录的 Python 内（没有就新建）

4. 将 Plugins 内的所有内容复制到 IDA 根目录的 Plugins 内

5. 将 python.cfg 复制到 IDA 根目录的 cfg 内

6. 重启 IDA，File 菜单下面会有 Python Command 选项，而且 Script files 选项中可以选择 py 文件

python 目录中的四个文件：

• init.py 是初始的基础文件
• idaapi.py 中导入了 _idaapi 模块，这个以下划线开始的 idaapi 模块就是对 IDA API 的低层封装，idaapi.py 则是作为调用 IDA API 的用户层
• idautils.py 提供了一些高级功能的函数
• idc.py 则是对 IDA 内置的 IDC 脚本语言的兼容

用法

调用 idapython 脚本时总是要鼠标点来点去很不方便，在官网找了找

https://www.hex-rays.com/products/ida/support/idadoc/417.shtml

该页面提供了命令行使用 ida 时的可用参数，比较常用的有：

-A 让 ida 自动运行，不需要人工干预。也就是在处理的过程中不会弹出交互窗口，但是如果从来没有使用过 ida 那么许可协议的窗口无论你是否使用这个参数都将会显示。

-c 参数会删除所有与参数中指定的文件相关的数据库，并且生成一个新的数据库。

-S 参数用于指定 ida 在分析完数据之后执行的 idc 脚本，注意：该选项和参数之间没有空格，并且搜索目录为 ida 目录下的 idc 目录。

-B 参数指定批量模式，等效于-A –c –Sanylysis.idc.在分析完成后会自动生成相关的数据库和 asm 代码。并且在最后关闭 ida，以保存新的数据库。

这篇文章²比较详细地讲解了批量模式的用法

实例

from idautils import *
from idaapi import *
import idc
idc.Wait()	# idaapi.autoWait()
ea = BeginEA()
dll_functions = []
fp = open("fun_output.txt", "w")
fp.write("check")
for funcea in Functions(SegStart(ea), SegEnd(ea)):
    functionName = GetFunctionName(funcea)
    dll_functions.append(functionName)
    fp.write(functionName)
    print(functionName)
fp.close()
idc.Exit(0)

其中idc.Wait()表示带有-A参数时，等待 ida 自动分析过程完成后再运行后续脚本，idc.Exit(0)表示脚本运行结束后自动关闭 ida

不过在实际测试时，idaq -c -A -Stest.py heap_test失败且没有任何错误提示，参阅了Using IDAPython to Make Your Life Easier: Part 6 ³，脚本和命令都没什么问题，不知是不是因为 Demo 版的缘故。。。

idaq -c -Stest.py heap_test倒是一切正常，只好暂且如此了。。。

参考

1. http://blog.csdn.net/zhangmiaoping23/article/details/14521995
2. http://www.h4ck.org.cn/2012/03/ida-batch-mode/
3. http://researchcenter.paloaltonetworks.com/2016/06/unit42-using-idapython-to-make-your-life-easier-part-6/

$ brew install redis
==> Downloading https://homebrew.bintray.com/bottles/redis-3.2.3.el_capitan.bottle.tar.gz
######################################################################## 100.0%
==> Pouring redis-3.2.3.el_capitan.bottle.tar.gz
==> Caveats
To have launchd start redis now and restart at login:
  brew services start redis
Or, if you don't want/need a background service you can just run:
  redis-server /usr/local/etc/redis.conf
==> Summary
🍺  /usr/local/Cellar/redis/3.2.3: 10 files, 1.7M

这样就安装好了，很是方便
不过暂时有一个问题：每次都要手动打开redis-server后才能redis-cli，否则提示not connected

$ redis-cli
Could not connect to Redis at 127.0.0.1:6379: Connection refused
Could not connect to Redis at 127.0.0.1:6379: Connection refused
not connected>

其实brew很贴心，之前安装完已经提醒过可以brew services start redis来自动启动，另外还可以使用brew info来看看提示信息

...
$ brew info redis
redis: stable 3.2.3 (bottled), HEAD
Persistent key-value database, with built-in net interface
http://redis.io/
/usr/local/Cellar/redis/3.2.3 (10 files, 1.7M) *
  Poured from bottle on 2016-09-18 at 09:51:13
From: https://github.com/Homebrew/homebrew-core/blob/master/Formula/redis.rb
==> Options
--with-jemalloc
	Select jemalloc as memory allocator when building Redis
--HEAD
	Install HEAD version
==> Caveats
To have launchd start redis now and restart at login:
  brew services start redis
Or, if you don't want/need a background service you can just run:
  redis-server /usr/local/etc/redis.conf
$ brew services start redis
==> Tapping homebrew/services
Cloning into '/usr/local/Library/Taps/homebrew/homebrew-services'...
remote: Counting objects: 7, done.
remote: Compressing objects: 100% (6/6), done.
remote: Total 7 (delta 0), reused 3 (delta 0), pack-reused 0
Unpacking objects: 100% (7/7), done.
Checking connectivity... done.
Tapped 0 formulae (32 files, 46.3K)
==> Successfully started `redis` (label: homebrew.mxcl.redis)
$ redis-cli
127.0.0.1:6379>

这样就可以了

今天在利用 Q 判断 Gadget 时发现，在 IDA 中静态分析时显示如下的指令片段：

align 10h
ret

会被判断为 Gadget，并且还莫名其妙扯上了 esi

8d7600c3
MoveReg(Address: 0x40000, Complexity 0.67, Stack 0x4, Ip 0x0, Output: esi, Inputs [esi])
AndGadget(Address: 0x40000, Complexity 0.67, Stack 0x4, Ip 0x0, Output: esi, Inputs [esi, esi])
OrGadget(Address: 0x40000, Complexity 0.67, Stack 0x4, Ip 0x0, Output: esi, Inputs [esi, esi])

实在百思不得其解

按理说伪指令并没有实际的机器码与之对应，但是ret对应c3，那么只能解释为align 10h对应8d7600了

好在 Google 到了一篇文章，提到了汇编器处理align伪指令的原理

我原来以为, VC 将插入 NOP 来对齐代码, 结果发现, 为了提高效率, VC 按情况填入了单字节,双字节, 三字节指令做空操作, 使空操作的时间最短. 当需要插入 1 字节时, 理所当然的插入一个 0x90 (NOP); 需要插入 2 字节时则是 0x8b 0xff (MOV DI,DI) 这也无可厚非, 此指令不破坏任何寄存器, 也不影响标志位; 可需要填入 3 个字节的时候, 我用的 VC6 却令人费解的填入了 0x8d 0x49 0x00 (LEA CX,[BX+DI+00]), 很明显它影响了 CX, 而风魂的代码就是受到了它的影响.

我这才恍然大悟，拿 capstone 反汇编了一下8d7600得到

lea	esi, dword ptr [esi]

果然，汇编器在处理align时，插入了这样一个不破坏任何寄存器也不影响标志位的指令来实现对齐效果

而 Q（使用 capstone 反汇编）接收到传入的指令时，自然会按照实际的机器指令而不是align 10h来进行 Gadget 判断，所以出现了上面的结果

大致如此…

今天重看 Flask 时，发现对backref仍然没有理解透彻。查阅文档后发现，以前试图孤立地理解backref是问题之源，backref是与relationship配合使用的。

一对多关系

db.relationship()用于在两个表之间建立一对多关系。例如书中 roles 表中一个 User 角色，可以对应 users 表中多个实际的普通用户。实现这种关系时，要在“多”这一侧加入一个外键，指向“一”这一侧联接的记录。

class Role(db.Model):
	# ...
	users = db.relationship('User', backref='role')
class User(db.Model):
	# ...
	role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))

relationship & ForeighKey

大多数情况下, db.relationship() 都能自行找到关系中的外键, 但有时却无法决定把 哪一列作为外键。 例如, 如果 User 模型中有两个或以上的列定义为 Role 模型的外键, SQLAlchemy 就不知道该使用哪列。如果无法决定外键,你就要为 db.relationship() 提供额外参数,从而确定所用外键。（见书 P49）

relationship & backref

通过db.relationship()，Role 模型有了一个可以获得对应角色所有用户的属性users。默认是列表形式，lazy='dynamic'时返回的是一个 query 对象。即relationship提供了 Role 对 User 的访问。

而backref正好相反，提供了 User 对 Role 的访问。

不妨设一个 Role 实例为 user_role，一个 User 实例为 u。relationship 使 user_role.users 可以访问所有符合角色的用户，而 backref 使 u.role 可以获得用户对应的角色。

示例

$ p manage.py shell
>>> user_role = Role.query.filter_by(name='User').all()
>>> user_role
[<Role u'User'>]
>>> user_role = Role.query.filter_by(name='User').first()
>>> user_role
<Role u'User'>
>>> user_role.users
<sqlalchemy.orm.dynamic.AppenderBaseQuery object at 0x1087c1050>
>>> user_role.users.order_by(User.username).all()
[<User u'alice78'>, <User u'andrea86'>, <User u'hmr'>]
>>> Role.query.all()
[<Role u'Moderator'>, <Role u'Administrator'>, <Role u'User'>]
>>> user_role.users.count()
3
>>> u = User.query.filter_by(username='hmr').first()
>>> u
<User u'hmr'>
>>> u.role
<Role u'User'>
>>>

一对一关系

除了一对多之外, 还有几种其他的关系类型。一对一关系可以用前面介绍的一对多关系表示, 但调用 db.relationship() 时要把 uselist 设为 False , 把“多”变成“一”。

多对多关系

多对多关系在书 P131 讲得很清楚。

在 P134 的实际例子中，使用两个一对多关系实现多对多关系。

今天突然发现没给博客添加RSS订阅和sitemap（站点地图，方便搜索引擎的收录）
尝试了一下发觉还挺方便的

npm install hexo-generator-feed --save
npm install hexo-generator-baidu-sitemap --save

这里一定要加上--save，否则无法generate对应的 xml

然后在根目录的_config.xml加入

# RSS & sitemap
# Extensions
Plugins:
- hexo-generator-feed
- hexo-generator-sitemap
# Feed Atom
feed:
  type: atom
  path: atom.xml
  limit: 20
# sitemap
sitemap:
  path: sitemap.xml

然后hexo g即可生成对应 xml

INFO Start processing
INFO Files loaded in 650 ms
INFO Generated: atom.xml
INFO Generated: sitemap.xml
INFO 2 files generated in 2.47 s

这时访问对应路径即可验证，另外边栏也可以看见RSS图标了

Closure(闭包)

什么是闭包?简单说,闭包就是根据不同的配置信息得到不同的结果。

专业的解释:闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。

概念总是有点抽象，下面结合示例说下我自己的理解。

特点

• 外部函数包裹内部函数
• 外部函数最终返回一个函数对象，即一个内部函数实例
• 外部函数传入的参数不同时，会返回不同的内部函数实例
• 外部函数用于绑定，内部函数用于处理
• 外部函数绑定的参数为函数时，即为装饰器

示例

def plus(augend):
    print 'augend:', augend
    def plus_inside(addend):
        print 'addend:', addend
        result = augend + addend
        print 'result:', result
        return result
    return plus_inside
p20 = plus(20)
# -> augend: 20
# 只打印 augend 说明内部处理函数尚未执行
# 只是完成了将 augend 与处理函数绑定的操作
p20(1)
# -> addend: 1
# -> result: 21

Decorator(装饰器)

前面已经提到，装饰器本质就是外部函数绑定参数为函数的闭包。

另外 Python 给它添加了一个更优雅的调用方式，用在被绑定函数f之前添加@wrapper的方式，代替在被绑定函数f定义后使用f = wrapper(f)手动赋值的方式，来进行绑定。

示例

def makebold(fn):
    def wrapped():
        return "<b>" + fn() + "</b>"
    return wrapped
def makeitalic(fn):
    def wrapped():
        return "<i>" + fn() + "</i>"
    return wrapped
@makebold
@makeitalic
def hello():
    return "hello world"
print hello() 
# -> <b><i>hello world</i></b>
# 注意<b>和<i>的顺序

保持函数默认参数常新的装饰器

Cookbook 20.1 里有个特别的例子。

Python 里函数的默认参数只在函数定义时求值一次，然后存入函数内建的 func_defaults 元组内。如果是不可变参数（如 1、’qwe’、None 等），完全没有问题；但如果是类似列表这样的可变参数，重新调用函数时默认的列表可能已经面目全非。

书中提供了两种解决该问题的方法：

标准方法

def packitem(item, pkg=None):
    if pkg is None:
        pkg = []
    pkg.append(item)
    return pkg

装饰器方法

import copy
def freshdefaults(f):
    "a decorator to wrap f and keep its default values fresh between calls"
    fdefaults = f.func_defaults
    def refresher(*args, **kwds):
        f.func_defaults = deepcopy(fdefaults)
        return f(*args, **kwds)
        
    # 用于在 print 时区别不同的被绑定函数，2.4 后有效，见 Cookbook 20.1 
    refresher.__name__ = f.__name__
    
    return refresher
# usage as a decorator, in python 2.4:
@freshdefaults
def packitem(item, pkg=[]):
    pkg.append(item)
    return pkg
# usage in python 2.3: after the function definition, explicitly assign:
# f = freshdefaults(f)

Ref.

• http://www.cnblogs.com/ma6174/archive/2013/04/15/3022548.html
• Cookbook 20.1

以前对「字符集与编码」的认识完全来源于廖雪峰的这篇文章，但是总容易忘记
而且依稀记得很早的时候在知乎看到梁海大神提到过字符集与编码是不一样的概念

今天仔细查阅了一下，记录如下

字符集与编码

顾名思义，「字符」的「集合」，每个「字符」有一个唯一的「数字」与之对应
而如何将「数字」改写成内存中的「字节」，即所谓的「编码」或「编码方式」

引自字符集和编码方式的区别？ - 梁海的回答：

「字符集」和「编码」等几个层次的概念被彻底分离且模块化的这样一个模型，其实是 Unicode 时代才得到广泛认同的。

而对于 ASCII、GB2312、Big5 之类的遗留（legacy）方案，其字符集及其编码的关系基本是锁定的，所以常常用「字符编码」（character encoding）、「代码页」（code page）等概念来统称它们那样从字符到编码字节流的整体方案。比如 ASCII 本身就既是字符集又是编码方案，而 GB2312 用的都是 EUC-CN 编码方案。

ASCII

ASCII 既是字符集又是编码方案，其字符集为「它所能表示的 128 种字符（包括控制字符和显示字符）」，编码方案为「128 个字节码与字符集间的映射」

ANSI

ASCII 本身就是 ANSI(American National Standard Institute) 制定的标准。虽然 ASCII 使用一个字节即 8 位的长度，但由于在英文世界中 7 位已经完全够用，所以最高位始终为 0。其他国家便将最高位利用起来，用于扩展表示其他语言的字符。

ANSI 指的是这样一种编码方式：表示通用英文字符时，最高位为 0，使用 ASCII 编码，长度为一个字节；表示其他语言的专有字符时，最高位为 1，使用其他编码。其中「其他编码」可以是 ANSI 标准中的任意一页，比如「GB2312」，用两个最高位为 1 的字节来表示一个简体中文字符。

Unicode 字符集

Unicode 原本只是个字符集，freebuf 的一篇译文讲得很生动：

Unicode 背后的想法非常简单，然而却被普遍的误解了。Unicode 就像一个电话本，标记着字符和数字之间的映射关系。Joel 称之为「神奇数字」，因为它们可能是随机指定的，而且不会给出任何解释。官方术语是码位（Code Point），总是用 U+ 开头。理论上每种语言中的每种字符都被 Unicode 协会指定了一个神奇数字。例如希伯来文中的第一个字母 א，是 U+2135，字母 A 是 U+0061。

Unicode 并不涉及字符是怎么在字节中表示的，它仅仅指定了字符对应的数字，仅此而已。

关于 Unicode 的其它误解包括：Unicode 支持的字符上限是 65536 个，Unicode 字符必须占两个字节。告诉你这些的人应该去换换脑子了。

记住，Unicode 只是一个用来映射字符和数字的标准。它对支持字符的数量没有限制，也不要求字符必须占两个、三个或者其它任意数量的字节。

Unicode 编码

Unicode 的实现方式不同于编码方式。一个字符的 Unicode 编码是确定的。但是在实际传输过程中，由于不同系统平台的设计不一定一致，以及出于节省空间的目的，对 Unicode 编码的实现方式有所不同。Unicode 的实现方式称为 Unicode 转换格式（Unicode Transformation Format，简称为 UTF）。

UTF-8 编码

如果一个仅包含基本 7 位 ASCII 字符的 Unicode 文件，如果每个字符都使用 2 字节的原 Unicode 编码传输，其第一字节的 8 位始终为 0 。这就造成了比较大的浪费。

对于这种情况，可以使用 UTF-8 编码，这是一种变长编码，它将基本 7 位 ASCII 字符仍用 7 位编码表示，占用一个字节（首位补 0）。

而遇到与其他 Unicode 字符混合的情况，将按一定算法转换，每个字符使用 1-3 个字节编码，并利用首位为 0 或 1 进行识别。这样对以 7 位 ASCII 字符为主的西文文档就大大节省了编码长度（具体方案参见 UTF-8）。

UTF-16 编码

类似的，另一个流行的可变长度编码方案是 UTF-16，它使用 2 个或者 4 个字节来存储字符。然而，人们逐渐意识到 UTF-16 可能会浪费存储空间，但那是另一个话题了。

狭义的 Unicode 编码

需要注意的是，狭义的 Unicode 编码方式与 ISO 10646 的通用字符集（Universal Character Set，UCS）概念相对应，目前实际应用的 Unicode 版本对应于 UCS-2 ，使用 16 位的编码空间。也就是每个字符占用 2 个字节。

这样理论上一共最多可以表示 216 即 65536 个字符。基本满足各种语言的使用。实际上当前版本的 Unicode 尚未填满这 16 位编码，保留了大量空间作为特殊使用或将来扩展。

以 Python 为例，unicode(s,'utf8') 所返回的结果就是这种狭义的 Unicode 编码。

又是梁海在廖雪峰答案的评论里提到:

廖雪峰说的「Unicode」指的是 UCS-2（所以不能改成「UTF-32」）。当年只有 BMP 的时候 UCS-2 和 UTF-16 是等价的，又被称作「Unicode」（所以这里不是「Unicode 是字符集，不是编码方式」这个问题，只是 UCS-2 也被称作「Unicode」而已）。但现在这种用「Unicode」指代 UCS-2/UTF-16 的做法已经过时了，很不合适。

总结

简单总结一下，Unicode 是「字符集」而不是「编码」。但由于历史原因，某些时候提到的「Unicode 编码」指的是曾经定长的 UCS-2/UTF-16（现在 UTF-16 也是变长）。

由于 UTF-8 可以兼容 ASCII，且其变长特性能相对高效地利用空间，在应用或传输过程中一般使用的是 UTF-8。例如 Python shell 中 str 使用的就是 ASCII(UTF-8)。

而内存一般使用的是这种「Unicode 编码」，所以在进行编码转换时，通常将各类编码decode成「Unicode 编码」，在encode成最终编码形式。

eg:

>>> a='在'
>>> a
'\xe5\x9c\xa8'
>>> b=unicode(a,'utf8') // 或 b=a.decode('utf8')，其中'utf-8'等同于'utf8' 
>>> b
u'\u5728'
>>> b.encode('gbk')
'\xd4\xda'

在 Python 2.x 版本中，字符串实际上是字节串，这种字符串中的每个字符长度为 1，实际上就是一个字节，等同于 ASCII。（参考《Python Cookbook》1.21）

不过在 Python 3.x 版本中，把 ‘xxx’ 和 u’xxx’ 统一成了 Unicode 编码，即写不写前缀 u 都是一样的，而以字节形式表示的字符串则必须加上 b 前缀。

Coursera AngularJS 课程的最后一个任务，添加提交 feedback 到 server 的功能
之前已经实现了添加 feedback 并保存在 client 的功能
现在只需要利用$resource的$save方法将 feedback 的 json 对象post到 server

本以为照葫芦画瓢很简单，结果总是会报错如下

TypeError: feedbackFactory.getFeedbacks(…).$save is not a function

仔细对照官方文档找到原因：

The action methods on the class object or instance object can be invoked with the following parameters:

• HTTP GET “class” actions: Resource.action([parameters], [success], [error])
• non-GET “class” actions: Resource.action([parameters], postData, [success], [error])
• non-GET instance actions: instance.$action([parameters], [success], [error])

问题出在我试图使用non-GET "class" actions，却加了$符号且没有带上postData

所以解决方式有两种

non-GET “class” actions

...
        .constant("baseURL", "http://localhost:3000/")
        .service('feedbackFactory', ['$resource', 'baseURL', function($resource,baseURL) { 
            this.getFeedbacks = function(){
                return $resource(baseURL+"feedback",null);
            };
        }])
...

...
        .controller('FeedbackController', ['$scope', 'feedbackFactory', function($scope, feedbackFactory) {
            $scope.feedbacks = feedbackFactory.getFeedbacks().query(
                function(response){
                    $scope.feedbacks = response;
                    console.log($scope.feedbacks);
                }
            );
            $scope.sendFeedback = function() {
                console.log($scope.feedbacks);
                $scope.feedbacks.push($scope.feedback);
                feedbackFactory.getFeedbacks().save($scope.feedback);
                if ($scope.feedback.agree && ($scope.feedback.mychannel == "")) {
                    $scope.invalidChannelSelection = true;
                    console.log('incorrect');
                }
                else {
                    $scope.invalidChannelSelection = false;
                    $scope.feedback = {mychannel:"", firstName:"", lastName:"", agree:false, email:"" };
                    $scope.feedbackForm.$setPristine();
                    console.log($scope.feedback);
                }
            };
        }])
...

non-GET instance actions

...
        .constant("baseURL", "http://localhost:3000/")
        .service('feedbackFactory', ['$resource', 'baseURL', function($resource,baseURL) { 
                return $resource(baseURL+"feedback/:id",null);
        }])
...

...
        .controller('FeedbackController', ['$scope', 'feedbackFactory', function($scope, feedbackFactory) {
            // $scope.feedbacks = feedbackFactory.getFeedbacks().query(
            //     function(response){
            //         $scope.feedbacks = response;
            //         console.log($scope.feedbacks);
            //     }
            // );
            $scope.sendFeedback = function() {
                var newFeedback = new feedbackFactory($scope.feedback);
                newFeedback.$save();
                // $scope.feedbacks.push($scope.feedback);
                // feedbackFactory.getFeedbacks().save($scope.feedback);
                if ($scope.feedback.agree && ($scope.feedback.mychannel == "")) {
                    $scope.invalidChannelSelection = true;
                    console.log('incorrect');
                }
                else {
                    $scope.invalidChannelSelection = false;
                    $scope.feedback = {mychannel:"", firstName:"", lastName:"", agree:false, email:"" };
                    $scope.feedbackForm.$setPristine();
                    console.log($scope.feedback);
                }
            };
        }])
...

由于第二种方式没有加上[success], [error]处理，看起来要简单许多
Stackoverflow 里一位疑似该课程的同学用的就是这种方式
不过相对来说第一种方式跟其他部分代码风格更统一

大致如此.

今天学习 Coursera 的 AngularJS 课程时尝试使用ng-include添加模板
发觉 Brackets 的 Live Preview 在 Chrome 里总是无法正常显示

这篇博文提到：

chrome提示很明显：不能跨域访问。通过上面的错误提示，可以看到:使用ng-include指令的时候，会用到AJAX请求XMLHttpRequest。但是我们是直接用浏览器打开的parent.html，并没有通过web容器访问，所以存在跨域访问问题，加载child.html也就失败了。解决办法很简单：将代码部署到tomcat等web容器下，通过http访问即可。

Coursera Discussions 里也有人提到了这个问题，可以有 3 种解决方式

gulp

之前的课程刚好提到 gulp 可以使用 brower-sync 建立一个 Web 容器来访问项目
把Gulpfile.js略作修改之后gulp watch却仍然无法访问

在 stackoverflow (1, 2) 找到答案，又是 Chrome 的锅，触发了其Content-Security-Policy

修改端口号即可解决

Brackets Live Preview

尝试之后发现，我在预览单个 html 时，使用的是file协议，在 Chrome 里无法跨域访问
而使用 Brackets 打开整个项目时，Live Preview 将项目放入了自建的 Web 容器里，使用的是http协议，即可在 Chrome 中正常跨域访问

http-server or json-server

使用 node 安装其它小型 Web 容器后放入运行也可解决

大致如此.