centos 6.7mnimal是centos提供的最小安装盘, 其网卡默认不启动
1.修改配置文件: /etc/sysconfig/network-script/ifcfg-eth0为ONBOOT=yes和NM_CONTROLLED=no
2.重启网卡: service network restart

centos 7.1mnimal是centos提供的最小安装盘, 其网卡默认不启动
1.修改配置文件: /etc/sysconfig/network-script/ifcfg-nep0s3为ONBOOT=yes
2.重启网卡: service network restart
3.安装网络管理工具: yum install net-tools

变量

变量可以认为是程序在内存中申请一块数据存储空间的名称, 程序常常声明一个变量, 然后再内存中申请一块空间, 将内存空间指向变量

• 变量声明
  go语言使用var关键字声明一个变量, 格式: var var_name var_type

  1 2 3 4 5 6 7 8 9 10

  var _i_var int var _s_var string var _iarr_var [32]int var _lslice_var []long var _struct_var struct { _i_var int } var _p_var *int var _map_var [string]int var _func_var func(args int) int

可以使用var定义多个变量:

1
2
3
4

var (
    _i_var int
    _s_var string
)

• 变量初始化&赋值
  可以在声明变量时进行初始化操作, 也可以在声明后对变量进行赋值

  1 2 3

  var _i1_var int = 10 var _i2_var = 10 _i3_var := 10

说明:

1. 以上三种方式均为在声明变量时进行初始化, 因为在go是强类型语言, 因此在初始化时可以推测出数据类型所以使用声明并赋值的时可以省略类型的定义
2. 使用:=明确表示此处为声明变量并初始化, 操作符前的变量不能被声明

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

var _i4_var int
_i4_var = 10

var (
    _i5_var int
    _i6_var int
)
_i5_var, _i6_var = 11, 12

_i5_var, _i6_var = _i6_var, _i5_var

fmt.Println("i5:", _i5_var, "i6:", _i6_var)

说明:

1. 以上两种方式均为先声明变量 在进行赋值
2. go支持多重赋值操作, 当然也支持像Python那么强大的变量交换

• 匿名变量
  在某个时候接收函数返回的多个变量时, 可能只关注某个或某几个变量, 此时可以使用”_”接收不关注的变量

  1 2 3 4 5

  func get_name() (firstname, lastname) { return "uk", "silence" } _, lastname := get_name()

常量

常量表示在编译时已经知道且不可改变的值, 包括整型、浮点型、复数型、布尔型、字符串型等

• 字面常量
  指硬编码在代码中的常量

• 常量定义
  通过const来定义一个常量

  1 2 3 4 5 6 7 8 9

  const pi float64 = 3.1415926 const zero = 0.0 const ( size int64 = 1024 eof = -1 ) const a, b, c = 1, 1.1, "test"

常量可以指定类型也可以不指定类型, 在不指定类型时为无类型常量, 常量的右操作数不可以是在运行期得到的结果，必须为编译期已知的值

• 预定义常量
  go中预定义了true, false和iota

iota表示在编译期修改的常数, 当iota第一次出现时为0, 每出现一次iota变量加1

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

const (
    c0 = 1 << iota    // c0 = 1
    c1 = 1 << iota    // c1 = 2
    c2 = 1 << iota    // c2 = 4
)

const (
    c0 = 1 << iota
    c1
    c2
)

const (
    Sunday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Firday
    Saturday
    numberOfDays    //注意此处变量名开头为小写, 表示对外(package)不可见
)

说明:

1. 在const中两个赋值表达式一样可以省了后一个，因此以上两种方式结果是一样的
2. go中未提供enum关键字用来定义枚举类型, 但是可以使用const+iota来实现
3. 在go中使用命名约定表示变量对外的权限, 大写表示对外可见, 小写表示对外不可见

数据类型

go中的基本数据类型有:

• 布尔类型: bool
  使用关键字bool定义布尔类型, 只接收true, false两个值, 不支持其他类型转换

  1 2 3 4 5 6 7

  var _is_alive = true var _is_equals = (1 == 1) var _is_empty = bool('') //error fmt.Println("is Alive:", _is_alive)

• 整数类型:
  go支持的整数类型有:

说明:

1. 为避免程序移植问题在常规开发中使用int, uint, uintptr
2. 不同类型数据转化, 必须使用关键字强制转化, 需要注意数据截断造成的数据溢出和精度问题
3. 在使用”:=”初始化整数类型时默认为int类型
4. 数值运算支持 +, -, *, /, %
5. 比较运算支持 ==, !=, >, >=, <, <=, 注意两个不同数据类型的变量不能进行比较, 但是可以和字面常量比较
6. 位操作符支持 |, &, ~, ^, <<, >>

• 浮点类型: float32, float64
  浮点类型用于表示有小数点的不准确的数值类型

1. go定义了两种浮点类型float32和float64
2. 在使用”:=”初始化浮点类型时默认为float64类型
3. 在使用关键字强制转化浮点数类型时，需要注意截断和数据溢出问题
4. 因为浮点型为非精确的数值，因此在等于比较时应使用在一定误差范围内近似等于

• 复数类型: complex64, complex128
  复数表示由两个实数分别表示实部和虚部组成

  1 2 3

  var point complex64 = 32 + 64.0i fmt.Println(point, real(point), imag(point))

1. complex64表示由两个float32组成复数, complex128自然对应float64组成的复数
2. 可以使用real和image分别获取复数的实部和虚部

• 字符串类型: string

  1 2 3 4 5

  var name string = "silence" fc := name[0] fmt.Printfln("my name is %s, length %s, the first character is %s", name, len(name), fc)

1. 可以通过索引访问字符串内字符, 但不可以通过索引进行修改
2. 可以通过len方法获取字符串占字节长度
3. go中只支持utf-8和unicode两种编码
4. 可以使用连接符+, 将两个字符串连接为一个新的字符串
5. 字符串比遍历
   go支持两种字符串遍历方式, 一种使用字节数组方式, 一种以unicode字符遍历

   1 2 3 4 5 6 7 8 9

   cxt = "Hello, 世界!" _length = len(cxt) for i := 0; i < _length; _length++ { ch := cxt[i] fmt.Println(i, ch) } for i, ch := range cxt { fmt.Println(i, ch) }

unicode字符宝石遍历时每个字符类型为rune

• 字符类型: rune
  go支持两种字符类型, 一种为byte表示utf-8字符串的单个字节值, 一个是rune，表似单个unicode字符

• 错误类型: error

go中符合数据类型有:

• 指针类型: pointer
• 数组类型: array
  表示一系列相同类型数据的集合

  1 2 3 4 5

  [32]byte //长度为32, 每个元素为一个字节 [2*N] struct {x, y int32} //复杂类型数组 [1000]*float64 //定义指针数组 [3][5]int //二位数组 [2][3][4]float64 //多维数组

1. 数组长度定义后不可修改, 可以在声明长度时使用常量或常量表达式, 数组的长度为数组类型的一个内置常量通过len函数获取数组长度

2. 通过索引访问数组元素，可以使用索引和range两种方式遍历数组元素

   1 2 3 4 5 6 7 8

   _len = len(array) for i := 0; i < _len; i++ { fmt.Println(i, array[i]) } for i, v := range array { fmt.Println(i, v) }

3. go中数组类型为一种值类型, 表示在变量赋值时将发生数组复制

• 切片: slice
  切片主要用于弥补数组的缺陷, 数组切片可以抽象为:

1. 一个指向原生的数组的指针
2. 数组切片中的元素个数
3. 数组切片已经分配的存储
   切片的操作:

4. 创建
   可以通过数组或者直使用make函数接创建切片

   1 2 3 4 5 6 7 8 9

   var _arr [5]int = [5]int{1, 2, 3, 4, 5} var _slice_1 []int = _arr[:2] var _slice_2 []int = _arr[2:] var _slice_3 []int = _arr[:] _slice_5 := make([]int, 5) //创建5个元素初始值为0数组切片 _slice_6 := make([]int, 5, 10) //创建5个元素初始值为0数组切片, 并预留10个的存储空间 _slice_7 := []int{1, 2, 3, 4, 5} //创建5个元素切片, 此时也会创建一个匿名数组

5. 切片的遍历操作数组相同

6. 动态增减元素
   go提供cap函数和len函数分别获取切片分配的空间大小和已存储的元素个数
   可使用append函数将不定个参数追加到切片后并返回一个新的数组切片，可一个使用将数组切片追加到另一个切片后

   1 2 3

   slice_2 = append(slice_1, 1, 2, 3) slice_3 := []int{8, 9, 10} slice_4 = append(slice_2, slice_3...)

7. 基于数组切片创建数组切片

   1 2	slice_1 := []int{8, 9, 10} slice_2 := slice_1[:2]

5.内容复制
可以使用copy函数将一个数组切片赋值到另一个数组切片, 若两个切片大小不同, 则使用最小的数组切片的长度进行复制

• 字典: map
  map是一堆键值对的未排序集合

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

  var users map[string] User users = make(map[string] User) users["1"] = User{"1", "test1"} users["2"] = User{"2", "test2"} user, _ok := users["12"] if _ok { fmt.Println(user.Name) } else { fmt.Println("not found") }

1. 声明: var name map[key_type] value_type

2. 创建: 使用make来创建一个新的map, make(map[key_type] value_type, length)
   创建一个初始存储为length的map
   可以创建时并对map进行初始化:

   1 2 3 4

   users = map[string] User { "1": User{"1", "test1"}, "2": User{"2", "test2"} }

3. 可以通过key对map进行赋值

4. 可以通过delete方法删除map内的元素: delete(map, key)
5. 读取操作, 通过key读取map的值时会返回两个值, 第二个值表示十分读取到, 若读取到则第一个值表示读取的值

• 通道: chan
• 结构体: struct
• 接口: interface

流程控制

go语句支持条件, 选择, 循环, 跳转四种语句和扩展的关键字break, continue fallthrough

• 选择: if, else, else if

  1 2 3 4 5 6 7

  var _i int = 23 if i > 32 { fmt.Println('gt 32') } else { fmt.Println('lte 32') }

• 选择: switch, case, select

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

  var _i int = 2 switch i { case 1: fmt.Println('one') case 2: fmt.Println('two') case 3: fallthrough case 4: fmt.Println('three four') case 5, 6, 7: fmt.Println('five six seven') default: fmt.Println('other') } switch { case _i < 5: fmt.Println('lt 5') case _i == 5: fmt.Println('eq 5') case default: fmt.Println('gt 5') }

• 循环: for, range

  1 2 3 4 5 6 7 8 9 10 11

  for i :=0; i < num; i++ { fmt.Println(i) } num := 0 for { num++ if num >= 10 { break } }

break后可标签, 表示跳转到标签定义同层的for循环外

• 跳转: goto
  同c语言的goto, 可以指定跳转到任意位置

函数

函数由func关键字, 函数名, 参数, 返回值, 函数体, 返回语句组成
函数定义:

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

package mmath
import "errors"

func Madd(a, b int) (ret int, err error) {
    if a < 0 || b < 0 {
        err = errors.New("shoud be non-negative numbers")
        return
    }
    return a + b, nil
}

func Mnegate(a int) int {
    return -a
}

函数调用:

1
2
3

import "mmath"

c := mmath.Madd(1, 2)

说明:

1. 若连续若干个参数的类型相同, 可只保留最后一个参数的类型
2. 若返回值只有一个则可以省略参数名和括号
3. 函数名字为小写表示在本包中访问, 大小表示在包外可以访问
4. 在参数中可以使用不定参数

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

   func PrintArgs(args ...int) { for _, v := range args { fmt.Println(v) } PrintArgs2(args...) } func PrintArgs2(args ...int) { for _, v := range args { fmt.Println(v) } }

说明:
a. 在函数顶定义时使用…type 表示不定参数, 这些参数类型必须相同, 既有固定的参数又有可变参数时，可变参数放在最后
b. 可变参数可以向下传递, 使用args…

1. 任意类型的不定参数

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

   func PrintArgs3(args ...interface{}) { for _, arg := range args { switch arg.(type) { case int: fmt.Println(arg, "is int") case string: fmt.Println(arg, "is string") default: fmt.Println(arg, "is other") } } } PrintArgs3(1, "2", 5.0)

6.匿名函数&闭包
go可以在任意位置定义匿名函数并赋值给某个变量

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

genrate_factory := func() (func()) {
    var _id int = 0
    //return func() int {
    return func() {
        _id += 1
        fmt.Println(_id)
        //return _id
    }
}
g1 := genrate_factory()
//fmt.Println(g1())
g1()

7.错误处理
在go中定义error接口来进行错误处理
函数定义:

1
2
3

func func_name(args ...interface{}) (rt type, err error) {
    
}

调用:

1
2
3
4

rt err := func_name()
if err != nil {
    //正确处理   
}

自定义错误类型:

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

type MyError struct {
    err error
    text string
}

func (e *MyError) Error() string {
    return e.text + " " + e.err.Error()
}
func test_error(a int) (rt int, err error) {
    if a == 0 {
        return 0, &MyError{errors.New(""), "zero"}
    }
    return a, nil
}

func main() {
    _rt, err := test_error(0)
    if err == nil {
        fmt.Println(_rt)
    } else {
        fmt.Println(err)
    }
}

1. defer关键字
   使用java或python的同学比较熟悉, 类似于在发生不管是否发生异常在函数执行完成后执行finally体内的代码

1
2
3

defer func() {
   //清理函数 
}()

1. panic, recover
   go提供函数painic和recover报告和处理运行时错误和程序中错误:

   1 2	func panic(interface{}) func recover() interface{}

到调用panic函数后，函数执行将终止返回到函数, 并依次逐层执行panic知道goroutine中所有正在的函数被终止, 错误信息通过panic的参数传递

1
2

panic(404)
panic(Erro("file not found"))

recover函数用于终止错误，一般情况下, recover应该在一个使用defer关键字的函数中执行已有效截取错误处理, 若在没有发生异常的gorouting中明确调用recover将导致该gorouting所属进程打印异常信息并直接退出

1
2
3
4
5

def func() {
    if r := recover(); r != nil {
        log.Printf("Runtime error:%v", r)
    }
} ()

panic类似于java或python中的抛出异常关键字throw和raise
recover类似于java或python中捕获异常的关键字catch和except

环境搭建

• windows x64

1. 下载安装包, x64安装包戳这里下载, 提取码为: ce54
2. 安装程序
3. 设置环境变量, 新建变量GOROOT为GO的安装目录, 将%GOROOT%\bin添加到Path中
4. 打开新cmd, 输入: go version, 查看go版本号验证程序和配置OK

• ubuntu

1. 使用apt命令进行安装: sudo apt-get install golang
2. 在/etc/environment中配置环境变量

   1 2	export GOROOT=GO_HOME export PATH=$GOROOT\bin;$PATH

说明:

1. 配置完成后使用source /etc/environment使配置文件生效
2. 使用apt-get等工具在linux上安装go后, 会自动将go的执行程序拷贝到/usr/bin/下, 因此一般不许要配置环境

示例

1
2
3
4
5
6
7

#file: main.go
package main

import "fmt"
func main() {
    fmt.Println("Hello, World!")
}

运行程序: go run helloworld.go
编译&运行程序: go build hellowrold.go && helloworld.exe

说明:

1. go程序的入口为package为main的main方法
2. 在相同的目录下go文件package必须相同, 若以目录为单位编译&运行项目, 则在编译目录下的所有go文件中的package名称必须为main且只能有一个main函数
   使用: cd pk_dir && go run ./pk_name
3. 在项目编译或运行时若使用main以外的package, 则package所在目录或其父目录必须设置的环境变量GOPATH中
   若想要在非pk_dir运行go run pk_name进行运行目录的项目, 则pk_dir目录或其父目录必须在GOPATH中

1. 修改my.ini文件
   mysqld节点下添加
   basedir = D:\MySQL\MySQL5.7
   datadir = D:\MySQL\datas
   port = 3306

注意datadir不能在basedir下

1. 初始化系统数据库
   mysqld –initialize-insecure –explicit_defaults_for_timestamp

2. 安装服务
   mysqld install MySQL57 –defaults-file=D:\MySQL\MySQL5.7\my.ini

3. 启动服务
   net start MySQL57

4. 设置root密码
   默认root密码为空可以使用mysql -u root -p, 输入回车直接进入mysql交互环境
   可以使用mysqladmin命令修改root密码, mysqladmin -u root -p password XXX

Netfilter介绍

Netfilter是linux内核提供对报文修改和过滤的框架, 可用于将某些钩子函数作用于网络协议栈, 他本身不对数据包进行过滤, 只是允许过滤数据包和修改数据包的函数挂接到内核网络协议栈的位置, 这些函数是自定义的
Netfilter提供的挂接位置有:

• 内核空间, 从一个网络接口进来到另一个网络接口去
• 数据从内核到用户空间
• 数据从用户空间流出
• 进入/离开本机的外网接口
• 进入/离开本机的内网接口

前3个和后2个貌似有些冲突, 已经在网络接口处做了限制为啥还要在内核和用户空间做限制? 因为在网络接口数据包尚未进行路由决策, 不知道下一步去哪里, 因此无法实现数据过滤. 那为啥还要网络接口限制呢? 因为在做NAT和DNAT的时候, 目标地址转换必须在路由之前转换, 示意图:

1
2
3
4
5
6
7
8
9

用户空间                                         --------------------->本地进程------------------------
                                                 |                                                    |
*********************************************************************************************************************************************************
内核空间                                         |                                                    |
                                                 |                                               filter output
                                           filter input                                               |
                                                 |                                                [路由决策]
  流入数据包                                     |                                                   \|/                               流出数据包
-------------->nat prerouting-------------->[路由决策]-------------->filter forward------------------->-------------->nat postrouting-------------->

Netfilter分别在这五个位置定义了不同的钩子函数叫做五个规则链，只要是数据包经过本计算机必然经过这五个位置之一:

• PREOUTING: 路由前
• INPUT: 数据流入口
• FORWARD: 转发
• OUTPUT: 数据流出口
• POSTROUTING: 路由后

iptables介绍

iptables是liunx提供给用户层的命令接口, 可以通过iptables为Netfilter添加策略, 从而实现报文修改和过滤功能

防火墙功能

根据防火墙功能的不同, 引入”表”的概念, 常用的有:

• filter: 定义允许/允许的功能, 只能在INPUT, FORWARD, OUTPUT三条链中修改
• nat: 定义地址转换, 只能在PREROUTING, OUTPUT, POSTROUTING三条链中修改
• managle: 用于修改数据包，在5条链中都可以实现

目前防火墙主要使用定义策略来定义功能，主要分阻止和接收两种动作, 防火墙根据网络数据包中的信息与依次从前到后与定义的策略中比较, 匹配到一条策略则执行策略定义的动作, 若未匹配则执行默认动作

服务控制

目前iptables主要以服务的形式运行在*nix当中, 通过命令: /etc/init.d/iptables restart/start/stop/status/save 或 service iptables restart/start/stop/status/save 可以控制和产看服务
注意: iptables修改后只对当前系统状态有效, 当系统重启后则失效, 若需要持久有效, 一定要在编辑完成iptables以后使用save命令进行保存

练习准备

在对iptables不熟悉的情况下, 防止在配置iptables后, 不能通过ssh服务进行远程登陆的, 可以使用crontab设置定时任务, 每5分钟停止一次iptables服务, 配置命令如下:
*/5 * * * * /etc/init.d/iptables stop

iptables使用

命令格式:iptables [-t table] COMMAND chain [options] [-j] ACTION
说明:

• -t table: 用于指定最那个表操作, 主要是filter, nat, managle, 默认为filter
• COMMAND: 常用-P(设置默认动作), -A(添加), -D(删除), -I(插入), -R(替换), -L(列举策略), -S(打印策略), -F(删除所策略)
• chain: 定义策略应用于五个规则链中的哪条上
• options: 定义数据包中的特征, 比如源ip，目的ip，源端口，目的端口，协议类型等
• -j: 定义匹配到策略数据包的执行动作, 常用ACCEPT, DROP, REJECT

对于使用iptables修改策略后, 策略会立即生效

例如:

• 列举所有策略并显示规则号: iptables -nvL --line-number
• 设置INPUT链路默认动作为阻断: iptables -P INPUT DROP
• 添加只有192.168.1.1/24可以使用tcp协议访问本地8080端口: iptables -A INPUT -s 192.168.1.1/24 -d 0.0.0.0/0 -p tcp --dport=8080 -j ACCEPT

COMMAND详解

• 链路管理

1. -P: 用于设置链路默认处理的动作, 格式: iptables -P chain ACCEPT/DROP
2. -F: 清空指定规则链中或所有规则链中的策略，格式: iptables -F [chain]
3. -N: iptables允许自定义规则链, 但是自定义的规则链必须与特定的规则链关联，表示当执行特定规则链前首先执行自定义的规则链，当执行完成后再返回到特定规则链中执行, 格式: iptables -N chain
4. -X: 删除用户自定义的规则链, 需要注意: 在删除规则链之前需要清空链路中的策略, 格式: iptables -X chain
5. -E: 重命名自定义的规则链, 格式: iptables -E oname nname
6. -Z: 将指定链路或者策略中的计数归零, iptables会对每个策略统计匹配到数据包总个数和总大小, 格式: iptables -Z [chain [rulenum]]

• 策略管理：

1. -A: 添加策略
2. -D: 删除策略
3. -R: 修改策略
4. -I: 插入策略

• 策略查看
  策略查看使用: -L命令, 附加子命令有：

1. -n: 将策略中的ip信息直接打印, 若不添加则会将ip反向域名解析，显示为域名信息
2. -v: 打印详细信息
3. -x: 显示精确信息不对统计数据进行格式化处理
4. –line-num: 显示策略编号

options详解

• -s: 指定源ip地址, 必须为ip地址、CIDR或者为0.0.0.0/0.0.0.0表示全部, 可在ip地址之前添加!表示取反操作
• -d: 表示目的ip地址

• -p: 表示协议类型, 可使用协议编号或者协议名, tcp, udp, icmp
  扩展参数: 在指定协议类型时, 可以在策略中设置源端口、目的端口、TCP标识位等信息对数据包进行过滤

  1. -p tcp扩展:
     a. –dport: 设置目的端口号, 格式: --dport 80或者--dport 1-1024
     b. –sport: 设置源端口号
     c. –tcp-flag:
  2. -p udp扩展:
     a. –dport:
     b. –sport:

  3. -p icmp扩展:
     a. –icmp-type: 可设置为0或8，0表示匹配响应的数据包, 8表示匹配请求回显的数据
     例如, 需要禁用别人ping自己，但是自己可以ping别人时可添加两条策略:

     1 2	iptables -A INPUT -p icmp --icmp-type 0 -j ACCEPT iptables -A OUTPUT -p icmp --icmp-type 8 -j ACCEPT

     对于自己ping自己需要添加:

     1 2	iptables -A INPUT -s 127.0.0.1 -d 127.0.0.1 -j ACCEPT iptables -A OUTPUT -s 127.0.0.1 -d 127.0.0.1 -j ACCEPT

• -i: 指定应用于从某网流入的流量, 格式: -i eth0, 一般在chain为PREROUTING和INPUT时使用

• -o: 指定应用于从某网卡流出的流量, 格式: -o eth0, 一般在chain为OUTPUT和PREROUTING时使用
• -m: 显示扩展
  1.若需要设置端口号为支持多个用逗号分隔的端口可以使用-m multiport --dport 21,22
  2.若需要对tcp连接状态进行检测, 比如在tcp连接的三次握手过程中, 连接的状态依次为: LISTENING->NEW->ESTABLISHED, 当发起syn=1 ack=1 rst=1时, 连接不能识别会将状态修改为: INVALID, 在FTP协议中使用20端口作为入口, 21端口作为出口, 但是之间具有关系, 此关系成为RELATED, 我们需要定义值允许NEW和ESTABLISHED状态的数据进入, 只允许ESTABLISHED状态出，则我们添加如此两条策略:

  1 2	iptables -A INPUT -s 0.0.0.0/0.0.0.0 -d 0.0.0.0/0.0.0.0 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -m state --state ESTABLISHED -j ACCEPT

-j参数详解

常用的ACTION主要有:
DROP: 表示丢弃, 常用于隐藏服务
REJECT: 明确拒绝
ACCEPT: 接受
custom_chain: 转向自定义规则链
DNAT
SNAT
MASQUERADE: 源地址伪装
REDIRECT: 重定向, 主要用于端口重定向
MARK: 打防火墙标记
RETURN: 返回，在自定义规则链执行完成后返回到源规则链

DNAT和SNAT

• SNAT: 源地址转换
  当内网用户使用同一外网网口进行上网时, 此时需要在外网网口处将数据包的源IP进行修改为外网网口的IP地址, 就可以实现链接外网其他IP地址, 命令:
  iptables -t nat -A POSTROUTING -s sip -j SNAT --to-source source_ip
  当外网IP地址是随机时, 可以使用源地址伪装, 可实现自动寻找外网IP地址并进行修改, 但不一定适合于任何场合
  iptables -t nat -A POSTROUTING -s sip -j MASQUERADE

• DNAT: 目的地址转换
  目的地址转换的数据流向是从外向内, 常使用外网的IP提供对内网服务的访问, 命令:
  iptables -t nat -A PREROUTING -d dip -p proto --dport dport -j DNAT --to-destination dest_ip