什么是聚合类型

C++03定义
An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3).

C++11定义
An aggregate is an array or a class (Clause 9) with no user-provided constructors (12.1), no brace-or-equal-initializers for non-static data members (9.2), no private or protected non-static data members (Clause 11), no base classes (Clause 10), and no virtual functions (10.3).

结合C++03和C++11标准定义，罗列一下聚合类型的特性：

• 聚合类型可以有构造函数，但只能是编译器定义的默认构造函数，或者用=default定义的构造函数
• 聚合类型不能有private，protected非static变量
• 聚合类型可以有copy-assignment operator and/or destructor
• 数组是聚合类型，即便数组成员是非聚合类型
• 聚合类型的数组可以是非聚合类型
• 聚合类型不能用brace-or-equal-initializers（即就地初始化）初始化非static成员。

聚合类型变量初始化

聚合类型可以采用列表初始化（其实非聚合类型，通过自定义构造函数，也可以采用列表初始化）

if(m == n)
{
    // the ith element of the array is initialized with ai
}
else if(m < n) {
    // the first m elements of the array are initialized with a1,  a2, …, am and the other n - m elements are, if possible, value-initialized (see below for the explanation of the term)
}
else if(m > n) {
    // the compiler will issue an error
}
else /*(this is the case when n isn't specified at all like int a[] = {1, 2, 3};) */
{
    // the size of the array (n) is assumed to be equal to m, so int a[] = {1, 2, 3}; is equivalent to int a[3] = {1, 2, 3};
}

聚合变量最大的特点可以做聚合初始化，除了基本的列表初始化规则，聚合初始化还体现在可以递归初始化。

struct X
{
  int i1;
  int i2;
};
struct Y
{
  char c;
  X x;
  int i[2];
  float f; 
protected:
  static double d;
private:
  void g(){}      
}; 
struct Z {
  char a;
  X x;
  Z(char a1) {};
};

Y y = {'a', {10, 20}, {20, 30}};

y.x也被初始化了。如果对Z用递归聚合初始化，例如Z z = {'a', {'b'}}，编译器就会报错。因为Z不是聚合类型，编译器会去找对应的构造函数，显然Z没定义这样的构造函数。
具体介绍可以参考Aggregate initialization。

什么是POD变量

POD = Plain Old Data，可见这是一种兼容型比较好的形态。甚至可以导出与其他语言共享此类变量定义。

C++03定义
A POD-struct is an aggregate class that has no non-static data members of type non-POD-struct, non-POD-union (or array of such types) or reference, and has no user-defined copy assignment operator and no user-defined destructor. Similarly, a POD-union is an aggregate union that has no non-static data members of type non-POD-struct, non-POD-union (or array of such types) or reference, and has no user-defined copy assignment operator and no user-defined destructor. A POD class is a class that is either a POD-struct or a POD-union.

C++11定义变得非常优雅
A POD struct is a non-union class that is both a trivial class and a standard-layout class, and has no non-static data members of type non-POD struct, non-POD union (or array of such types). Similarly, a POD union is a union that is both a trivial class and a standard layout class, and has no non-static data members of type non-POD struct, non-POD union (or array of such types). A POD class is a class that is either a POD struct or a POD union.

总而言之：
POD类型是一种特殊的聚合类型，一个POD类型为：

• 标量类型。
• 满足以下条件的自定义类型：
  • C++11之前：
    • 聚合类型。
    • 没有非POD类型的非静态成员变量。
    • 没有引用类型的非静态成员变量。
    • 没有自定义的构造函数或析构函数。
  • C++11之后：
    • 是平凡类。
    • 是标准布局类。
    • 没有非POD类型的非静态成员变量。
• POD类型的数组。

聚合类型或是POD变量有什么好处？

聚合类最大的特点就是可以采用聚合初始化。
POD的特点更为实用一些

POD的用途
平凡类的用途：

• 平凡类的对象可以与字节流之间安全转换，即：
  - 若要将对象转为字节流，直接取其地址即可。
  - 若要将字节流转为对象，直接将该地址cast为对象指针即可。
  - 直接通过复制字节的方式复制对象。
• 安全的静态初始化。
  - C++11的thread_local变量可以是非平凡类型，但在某些编译器下会有比较大的性能开销。gcc扩展的__thread只能使用POD类型。

标准布局类的用途：
跨进程、跨语言使用。

名次解释

value initialization

• 对于普通类型变量(bool, int, char, double, pointers, etc.)
  it means it is initialized with 0 for that type (false for bool, 0.0 for double, etc.).
• 对于class类型
  • 如果有自定义构造函数，则调用自定义构造函数
  • 如果没有自定一构造函数，则调用默认构造函数
  • 如果没有对应的构造函数，则报错

举例

class A
{
public:
  A(int) {} //no default constructor
};
class B
{
public:
  B() {} //default constructor available
};
int main()
{
  A a1[3] = {A(2), A(1), A(14)}; //OK n == m
  A a2[3] = {A(2)}; //ERROR A has no default constructor. Unable to value-initialize a2[1] and a2[2]
  B b1[3] = {B()}; //OK b1[1] and b1[2] are value initialized, in this case with the default-ctor
  int Array1[1000] = {0}; //All elements are initialized with 0;
  int Array2[1000] = {1}; //Attention: only the first element is 1, the rest are 0;
  bool Array3[1000] = {}; //the braces can be empty too. All elements initialized with false
  int Array4[1000]; //no initializer. This is different from an empty {} initializer in that
  //the elements in this case are not value-initialized, but have indeterminate values 
  //(unless, of course, Array4 is a global array)
  int array[2] = {1, 2, 3, 4}; //ERROR, too many initializers
}

大括号中个数不足的，用value initialization补足。这就是A a = {1};或者A a = {}的含义。大括号中个数超过声明的个数的，则编译报错。

brace-or-equal-initializers

类成员的一种初始化方法

class B {
public:
    B(int){}
};

class A {
    int a = 123;
    int b {456};
    B c {12};
    B d = {34};
};

copy-assignment operator

拷贝赋值方法

class A {
    A A(int) {}
    A(const &) {}
    A& operator= (const A&a) {}
};
void main() {
    A a;
    A b = a; // 这里调用的是拷贝构造函数
    A c;
    c = a; // 这里才会调用拷贝复制函数
}

trial stuff

trivial copyable

参考C++ named requirements: TriviallyCopyable

The following types are collectively called trivially copyable types:

• Scalar types
• Trivially copyable classes, i.e. classes satisfying following requirements:
  - At least one copy constructor, move constructor, copy assignment operator, or move assignment operator is eligible
  - Every eligible copy constructor (if any) is trivial
  - Every eligible move constructor (if any) is trivial
  - Every eligible copy assignment operator (if any) is trivial
  - Every eligible move assignment operator (if any) is trivial
  - Has a trivial non-deleted destructor
• Arrays of TriviallyCopyable objects

This implies that a trivially copyable class has no virtual functions or virtual base classes.

通过模版std::is_trivially_copyable可以检验一个类是否trivially copyable。

trivial constructor/destructor

• 编译器定义的构造/析构函数
• 用=default定义的构造析构函数

trivial class

The standard defines a trivial class as follows:

A trivially copyable class is a class that:

• has no non-trivial copy constructors (12.8),
• has no non-trivial move constructors (12.8),
• has no non-trivial copy assignment operators (13.5.3, 12.8),
• has no non-trivial move assignment operators (13.5.3, 12.8), and
• has a trivial destructor (12.4).

A trivial class is a class that has a trivial default constructor (12.1) and is trivially copyable.

[ Note: In particular, a trivially copyable or trivial class does not have virtual functions or virtual base classes. ]
另外trivial class是递归的，即trivial class不能有非trivial class的非static成员。
用模版std::is_trivial来测试

standard layout

A standard-layout class is a class that:

• has no non-static data members of type non-standard-layout class (or array of such types) or reference,

• has no virtual functions (10.3) and no virtual base classes (10.1),

• has the same access control (Clause 11) for all non-static data members,

• has no non-standard-layout base classes,

• either has no non-static data members in the most derived class and at most one base class with non-static data members, or has no base classes with non-static data members, (要么终点类没有非静态成员，并且只有一个基类有非静态成员；要么没有基类有非静态成员)，and

• has no base classes of the same type as the first non-static data member.

A standard-layout struct is a standard-layout class defined with the class-key struct or the class-key class.

A standard-layout union is a standard-layout class defined with the class-key union.

[ Note: Standard-layout classes are useful for communicating with code written in other programming languages. Their layout is specified in 9.2.]

标准内存分布，确保对象内存和C语言的结构体内存分布完全一致。使得POD变量具备了C兼容性。
用模版std::is_standard_layout可以测试

总结

用std::is_pod来测试你的类吧。

参考文献

1. What are Aggregates and PODs and how/why are they special?
2. C++对象模型（三）POD

C++11的列表初始化

在C语言和C++98/03中，大括号可以用来初始化数组，例如：

int a[] = {1, 2, 3};
int b[4] = {1, 2, 3, 4}; // 如果个数不足的，用0初始化

C++11将这类大括号初始化，扩展到自定义类型，但需要满足一定的条件，否则会编译报错。

参考C++11新特性之列表初始化、POD、聚合类

1. C++98/03标准中对于普通数组和POD类型可以直接使用列表初始化；
2. C++11标准中对于普通数组和聚合类型可以直接使用列表初始化；
3. C++11标准中对于非聚合类型可以通过自定义构造函数的方式使用列表初始化。

C++11新特性之列表初始化提到非聚合类型不能使用列表初始化是不对的。实验证明，不论是不是聚合类型，均可以采用列表初始化。

class A {
	public:
		A(int a1) {}
		A(std::initializer_list<int> l) {}
	private:
		int a {12};
};
int main()
{
	A a = {123};
    ...
}

首先声明A a={123}或者A a{123}这两种构造方法是一致的。
其次，对于这种构造方法，编译器会先尝试用A(std::initializer_list<int> l)去匹配，如果不成功，则会尝试A(int)，如果这两种构造函数都未定义，就会编译报错。
另外，成员变量也可以采用就地初始化, 虽然这会导致类成为非聚合类，但并不妨碍其采用列表初始化方法。使用虚函数，有基类的效果都是一样的，不影响列表初始化方法的使用。

C++11中的几种初始化方法

1. 就地初始化

class A {
	private:
		int a1 {12};
        double a2 = {12.0};
        float a3 = 12.0
        B b{123}
        C c = {123};
};

2. 构造函数初始化列表

class A {
    public:
        A() : a(123), b(456) {}
	private:
        int a;
        int b;
};

3. 列表初始化

class A {
    public:
        A(int, int) {}
        A(std::initializer_list<int, int>) {}
	private:
        int a;
        int b;
};
void main ()
{
    // 优先匹配A(std::initializer_list<int, int>)
    // 再匹配A(int, int)
    // 否则报错
    A a {123, 456};
}

• 就地初始化会最先得到执行，构造函数初始化列表会覆盖就地初始化的值
• 如果采用初始化列表，即a{...}初始化，std::initializer_list<T>的构造函数会优先得到执行
• 如果采用原生构造函数，即a(int)初始化，A(init)优先得到执行

什么是initializer-list

摘录C++11新特性之列表初始化-初始化列表

1. 它是一个轻量级的容器类型，内部定义了迭代器iterator等容器必须的一些概念。
2. initialzer-list<T>来说，它可以接受任意长度的初始化列表，但是元素必须是要相同的或者可以转换为T类型的。
3. 三个成员接口，begin(),end(),size(),其中size()返回initialzer-list的长度。
4. 能被整体的初始化和赋值，遍历只能通过begin和end迭代器来，遍历取得的数据是可读的，是不能对单个进行修改的。

注意一：
initialzer-list<T>保存的是T类型的引用，并不对T类型的数据进行拷贝，因此需要注意变量的生存期

std::initializer_list<int> func(void)
{
    return{ 2, 3 };
}
void main()
{
    auto c = func();
    for (auto it = c.begin(); it != c.end(); it++)
		std::cout << it - c.begin() << ":" << (*it) << std::endl;
}

此处打印是乱的。因为func返回的是右值引用，在退出函数后失效。

注意二：
列表初始化防止类型收窄

int a = 1.1; //OK
int b{ 1.1 }; //error
 
float f1 = 1e40; //OK, 科学计数法10^40
float f2{ 1e40 }; //error
 
const int x = 1024, y = 1;
char c = x; //OK
char d{ x };//error
char e = y;//error
char f{ y };//error

参考文献

initializer_list - cppreference.com

C++11新特性之列表初始化

C++11新特性之列表初始化、POD、聚合类

在Linux中，一个进程拉起另一个进程的流程大致如下：

<svg id="dt8nxf1oem4" width="100%" xmlns="http://www.w3.org/2000/svg" style="max-width: 610.796875px;" viewBox="0 0 610.796875 138.5625"><style>


#dt8nxf1oem4 .label {
  font-family: 'trebuchet ms', verdana, arial;
  color: #333; }

#dt8nxf1oem4 .node rect,
#dt8nxf1oem4 .node circle,
#dt8nxf1oem4 .node ellipse,
#dt8nxf1oem4 .node polygon {
  fill: #ECECFF;
  stroke: #9370DB;
  stroke-width: 1px; }

#dt8nxf1oem4 .node.clickable {
  cursor: pointer; }

#dt8nxf1oem4 .arrowheadPath {
  fill: #333333; }

#dt8nxf1oem4 .edgePath .path {
  stroke: #333333;
  stroke-width: 1.5px; }

#dt8nxf1oem4 .edgeLabel {
  background-color: #e8e8e8; }

#dt8nxf1oem4 .cluster rect {
  fill: #ffffde !important;
  stroke: #aaaa33 !important;
  stroke-width: 1px !important; }

#dt8nxf1oem4 .cluster text {
  fill: #333; }

#dt8nxf1oem4 div.mermaidTooltip {
  position: absolute;
  text-align: center;
  max-width: 200px;
  padding: 2px;
  font-family: 'trebuchet ms', verdana, arial;
  font-size: 12px;
  background: #ffffde;
  border: 1px solid #aaaa33;
  border-radius: 2px;
  pointer-events: none;
  z-index: 100; }

#dt8nxf1oem4 .actor {
  stroke: #CCCCFF;
  fill: #ECECFF; }

#dt8nxf1oem4 text.actor {
  fill: black;
  stroke: none; }

#dt8nxf1oem4 .actor-line {
  stroke: grey; }

#dt8nxf1oem4 .messageLine0 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  stroke: #333; }

#dt8nxf1oem4 .messageLine1 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  stroke: #333; }

#dt8nxf1oem4 #arrowhead {
  fill: #333; }

#dt8nxf1oem4 #crosshead path {
  fill: #333 !important;
  stroke: #333 !important; }

#dt8nxf1oem4 .messageText {
  fill: #333;
  stroke: none; }

#dt8nxf1oem4 .labelBox {
  stroke: #CCCCFF;
  fill: #ECECFF; }

#dt8nxf1oem4 .labelText {
  fill: black;
  stroke: none; }

#dt8nxf1oem4 .loopText {
  fill: black;
  stroke: none; }

#dt8nxf1oem4 .loopLine {
  stroke-width: 2;
  stroke-dasharray: '2 2';
  stroke: #CCCCFF; }

#dt8nxf1oem4 .note {
  stroke: #aaaa33;
  fill: #fff5ad; }

#dt8nxf1oem4 .noteText {
  fill: black;
  stroke: none;
  font-family: 'trebuchet ms', verdana, arial;
  font-size: 14px; }

#dt8nxf1oem4 .activation0 {
  fill: #f4f4f4;
  stroke: #666; }

#dt8nxf1oem4 .activation1 {
  fill: #f4f4f4;
  stroke: #666; }

#dt8nxf1oem4 .activation2 {
  fill: #f4f4f4;
  stroke: #666; }


#dt8nxf1oem4 .section {
  stroke: none;
  opacity: 0.2; }

#dt8nxf1oem4 .section0 {
  fill: rgba(102, 102, 255, 0.49); }

#dt8nxf1oem4 .section2 {
  fill: #fff400; }

#dt8nxf1oem4 .section1,
#dt8nxf1oem4 .section3 {
  fill: white;
  opacity: 0.2; }

#dt8nxf1oem4 .sectionTitle0 {
  fill: #333; }

#dt8nxf1oem4 .sectionTitle1 {
  fill: #333; }

#dt8nxf1oem4 .sectionTitle2 {
  fill: #333; }

#dt8nxf1oem4 .sectionTitle3 {
  fill: #333; }

#dt8nxf1oem4 .sectionTitle {
  text-anchor: start;
  font-size: 11px;
  text-height: 14px; }


#dt8nxf1oem4 .grid .tick {
  stroke: lightgrey;
  opacity: 0.3;
  shape-rendering: crispEdges; }

#dt8nxf1oem4 .grid path {
  stroke-width: 0; }


#dt8nxf1oem4 .today {
  fill: none;
  stroke: red;
  stroke-width: 2px; }



#dt8nxf1oem4 .task {
  stroke-width: 2; }

#dt8nxf1oem4 .taskText {
  text-anchor: middle;
  font-size: 11px; }

#dt8nxf1oem4 .taskTextOutsideRight {
  fill: black;
  text-anchor: start;
  font-size: 11px; }

#dt8nxf1oem4 .taskTextOutsideLeft {
  fill: black;
  text-anchor: end;
  font-size: 11px; }


#dt8nxf1oem4 .taskText0,
#dt8nxf1oem4 .taskText1,
#dt8nxf1oem4 .taskText2,
#dt8nxf1oem4 .taskText3 {
  fill: white; }

#dt8nxf1oem4 .task0,
#dt8nxf1oem4 .task1,
#dt8nxf1oem4 .task2,
#dt8nxf1oem4 .task3 {
  fill: #8a90dd;
  stroke: #534fbc; }

#dt8nxf1oem4 .taskTextOutside0,
#dt8nxf1oem4 .taskTextOutside2 {
  fill: black; }

#dt8nxf1oem4 .taskTextOutside1,
#dt8nxf1oem4 .taskTextOutside3 {
  fill: black; }


#dt8nxf1oem4 .active0,
#dt8nxf1oem4 .active1,
#dt8nxf1oem4 .active2,
#dt8nxf1oem4 .active3 {
  fill: #bfc7ff;
  stroke: #534fbc; }

#dt8nxf1oem4 .activeText0,
#dt8nxf1oem4 .activeText1,
#dt8nxf1oem4 .activeText2,
#dt8nxf1oem4 .activeText3 {
  fill: black !important; }


#dt8nxf1oem4 .done0,
#dt8nxf1oem4 .done1,
#dt8nxf1oem4 .done2,
#dt8nxf1oem4 .done3 {
  stroke: grey;
  fill: lightgrey;
  stroke-width: 2; }

#dt8nxf1oem4 .doneText0,
#dt8nxf1oem4 .doneText1,
#dt8nxf1oem4 .doneText2,
#dt8nxf1oem4 .doneText3 {
  fill: black !important; }


#dt8nxf1oem4 .crit0,
#dt8nxf1oem4 .crit1,
#dt8nxf1oem4 .crit2,
#dt8nxf1oem4 .crit3 {
  stroke: #ff8888;
  fill: red;
  stroke-width: 2; }

#dt8nxf1oem4 .activeCrit0,
#dt8nxf1oem4 .activeCrit1,
#dt8nxf1oem4 .activeCrit2,
#dt8nxf1oem4 .activeCrit3 {
  stroke: #ff8888;
  fill: #bfc7ff;
  stroke-width: 2; }

#dt8nxf1oem4 .doneCrit0,
#dt8nxf1oem4 .doneCrit1,
#dt8nxf1oem4 .doneCrit2,
#dt8nxf1oem4 .doneCrit3 {
  stroke: #ff8888;
  fill: lightgrey;
  stroke-width: 2;
  cursor: pointer;
  shape-rendering: crispEdges; }

#dt8nxf1oem4 .doneCritText0,
#dt8nxf1oem4 .doneCritText1,
#dt8nxf1oem4 .doneCritText2,
#dt8nxf1oem4 .doneCritText3 {
  fill: black !important; }

#dt8nxf1oem4 .activeCritText0,
#dt8nxf1oem4 .activeCritText1,
#dt8nxf1oem4 .activeCritText2,
#dt8nxf1oem4 .activeCritText3 {
  fill: black !important; }

#dt8nxf1oem4 .titleText {
  text-anchor: middle;
  font-size: 18px;
  fill: black; }

#dt8nxf1oem4 g.classGroup text {
  fill: #9370DB;
  stroke: none;
  font-family: 'trebuchet ms', verdana, arial;
  font-size: 10px; }

#dt8nxf1oem4 g.classGroup rect {
  fill: #ECECFF;
  stroke: #9370DB; }

#dt8nxf1oem4 g.classGroup line {
  stroke: #9370DB;
  stroke-width: 1; }

#dt8nxf1oem4 .classLabel .box {
  stroke: none;
  stroke-width: 0;
  fill: #ECECFF;
  opacity: 0.5; }

#dt8nxf1oem4 .classLabel .label {
  fill: #9370DB;
  font-size: 10px; }

#dt8nxf1oem4 .relation {
  stroke: #9370DB;
  stroke-width: 1;
  fill: none; }

#dt8nxf1oem4 #compositionStart {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dt8nxf1oem4 #compositionEnd {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dt8nxf1oem4 #aggregationStart {
  fill: #ECECFF;
  stroke: #9370DB;
  stroke-width: 1; }

#dt8nxf1oem4 #aggregationEnd {
  fill: #ECECFF;
  stroke: #9370DB;
  stroke-width: 1; }

#dt8nxf1oem4 #dependencyStart {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dt8nxf1oem4 #dependencyEnd {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dt8nxf1oem4 #extensionStart {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dt8nxf1oem4 #extensionEnd {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dt8nxf1oem4 .commit-id,
#dt8nxf1oem4 .commit-msg,
#dt8nxf1oem4 .branch-label {
  fill: lightgrey;
  color: lightgrey; }



#dt8nxf1oem4 .label{
  color:#18B14E;
}
#dt8nxf1oem4 .te-md-container--dark .node rect {
  fill: red;
}

#dt8nxf1oem4 .node rect,
#dt8nxf1oem4 .node circle,
#dt8nxf1oem4 .node ellipse,
#dt8nxf1oem4 .node polygon {
  fill: #F9FFFB;;
  stroke: #2DBD60;
  stroke-width: 1.5px;
}
#dt8nxf1oem4 .arrowheadPath{
  fill: #2DBD60;
}
#dt8nxf1oem4 .edgePath .path {
  stroke: #2DBD60;
  stroke-width: 1px;
}
#dt8nxf1oem4 .edgeLabel {
  background-color: #fff;
}
#dt8nxf1oem4 .cluster rect {
  fill: #F9FFFB !important;
  stroke: #2DBD60 !important;
  stroke-width: 1px !important;
}

#dt8nxf1oem4 .cluster text {
  fill: #F9FFFB;
}

#dt8nxf1oem4 div.mermaidTooltip {
  background: #F9FFFB;
  border: 1px solid #2DBD60;
}


#dt8nxf1oem4 .actor {
  stroke: #2DBD60;
  fill: #F9FFFB;
}

#dt8nxf1oem4 text.actor {
  fill: #2DBD60;
  stroke: none;
}

#dt8nxf1oem4 .actor-line {
  stroke: #2DBD60;
}

#dt8nxf1oem4 .messageLine0 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  marker-end: 'url(#arrowhead)';
  stroke: #2DBD60;
}

#dt8nxf1oem4 .messageLine1 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  stroke: #2DBD60;
}

#dt8nxf1oem4 #arrowhead {
  fill: #2DBD60;
}

#dt8nxf1oem4 #crosshead path {
  fill: #2DBD60 !important;
  stroke: #2DBD60 !important;
}

#dt8nxf1oem4 .messageText {
  fill: #2DBD60;
  stroke: none;
}

#dt8nxf1oem4 .labelBox {
  stroke: #2DBD60;
  fill: #F9FFFB;
}

#dt8nxf1oem4 .labelText {
  fill: #2DBD60;
  stroke: #2DBD60;
}

#dt8nxf1oem4 .loopText {
  fill: #2DBD60;
  stroke: #2DBD60;
}

#dt8nxf1oem4 .loopLine {
  stroke-width: 2;
  stroke-dasharray: '2 2';
  marker-end: 'url(#arrowhead)';
  stroke: #2DBD60;
}

#dt8nxf1oem4 .note {
  stroke: #2DBD60;
  fill: #F9FFFB;
}

#dt8nxf1oem4 .noteText {
  fill: #2DBD60;
  stroke: #2DBD60;
}


#dt8nxf1oem4 .section{
  opacity:1;
}
#dt8nxf1oem4 .section0,#dt8nxf1oem4  .section2 {
  fill: #ECF7F0;
}

#dt8nxf1oem4 .section1,
#dt8nxf1oem4 .section3 {
  fill: #FFF;
}
#dt8nxf1oem4 .taskText0,
#dt8nxf1oem4 .taskText1,
#dt8nxf1oem4 .taskText2,
#dt8nxf1oem4 .taskText3 {
  fill: #fff;
}

#dt8nxf1oem4 .task0,
#dt8nxf1oem4 .task1,
#dt8nxf1oem4 .task2,
#dt8nxf1oem4 .task3 {
  fill: #2DBD60;
  stroke: #359F5A;
}
</style><style>#dt8nxf1oem4 {
    color: rgb(244, 244, 244);
    font: normal normal normal normal 14px/22.399999618530273px monospace;
  }</style><g transform="translate(-12, -12)"><g class="output"><g class="clusters"></g><g class="edgePaths"><g class="edgePath" style="opacity: 1;"><path class="path" d="M128.40625,81.28125L153.40625,81.28125L178.40625,81.28125" marker-end="url(#arrowhead15559)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead15559" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M226.78125,64.26897449369507L263.9296875,38.140625L301.078125,38.140625" marker-end="url(#arrowhead15560)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead15560" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M226.78125,98.29352550630493L263.9296875,124.421875L325.734375,124.421875L389.5546875,124.421875L452.296875,124.421875" marker-end="url(#arrowhead15561)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead15561" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M350.390625,38.140625L389.5546875,38.140625L428.71875,38.140625" marker-end="url(#arrowhead15562)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead15562" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M522.296875,38.140625L547.296875,38.140625L574.0987583755885,63.140625" marker-end="url(#arrowhead15563)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead15563" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M498.71875,124.421875L547.296875,124.421875L574.0987583755885,99.421875" marker-end="url(#arrowhead15564)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead15564" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g></g><g class="edgeLabels"><g class="edgeLabel" style="opacity: 1;" transform=""><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" style="opacity: 1;" transform="translate(263.9296875,38.140625)"><g transform="translate(-16.359375,-8.0078125)" class="label"><rect rx="0" ry="0" width="24.296875" height="16.28125" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1">fork</tspan></text></g></g><g class="edgeLabel" style="opacity: 1;" transform=""><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" style="opacity: 1;" transform="translate(389.5546875,38.140625)"><g transform="translate(-16.359375,-8.0078125)" class="label"><rect rx="0" ry="0" width="28.328125" height="16.28125" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1">exec</tspan></text></g></g><g class="edgeLabel" style="opacity: 1;" transform=""><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" style="opacity: 1;" transform=""><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g></g><g class="nodes"><g class="node" style="opacity: 1;" id="F" transform="translate(74.203125,81.28125)"><rect rx="0" ry="0" x="-54.203125" y="-18.140625" width="108.40625" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-44.203125,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">parent process</tspan></text></g></g></g><g class="node" style="opacity: 1;" id="A" transform="translate(202.59375,81.28125)"><rect rx="0" ry="0" x="-24.1875" y="-18.140625" width="48.375" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-14.1875,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">start</tspan></text></g></g></g><g class="node" style="opacity: 1;" id="B" transform="translate(325.734375,38.140625)"><rect rx="0" ry="0" x="-24.65625" y="-18.140625" width="49.3125" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-14.65625,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">child</tspan></text></g></g></g><g class="node" style="opacity: 1;" id="C" transform="translate(475.5078125,124.421875)"><rect rx="0" ry="0" x="-23.2109375" y="-18.140625" width="46.421875" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-13.2109375,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">wait</tspan></text></g></g></g><g class="node" style="opacity: 1;" id="D" transform="translate(475.5078125,38.140625)"><rect rx="0" ry="0" x="-46.7890625" y="-18.140625" width="93.578125" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-36.7890625,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">new process</tspan></text></g></g></g><g class="node" style="opacity: 1;" id="E" transform="translate(593.546875,81.28125)"><rect rx="0" ry="0" x="-21.25" y="-18.140625" width="42.5" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-11.25,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">end</tspan></text></g></g></g></g></g></g></svg>

最常见的就是通过shell终端执行命令。此场景下，/bin/bash就是这个parent process，而要执行的那个命令就是new process。
Linux有一些特性，可以使得创建出的进程比拉起的进程权限高。例如可执行文件配置了set-user-ID位，则拉起的进程就是root权限，而其父进程有可能是普通用户权限。如果可执行文件配置了file capability，则创建出的进程就具备了某些capability，如果父进程没有这些capability，则这也是一种权限放大的场景。
当发生这种权限放大的场景时，Linux的安全特性要求，此时子进程中的某些敏感环境变量会被清空，例如：LD_PRELOAD,LD_LIBRARY_PATH。由于这些环境变量都是从父进程继承过来的，如果不清空，则表明会使用高权限级别执行这些环境变量指定的可执行代码。

LD_LIBRARY_PATH

参考文献[1]，ld.so搜索动态库的顺序如下：

1. DT_PATH指定的库文件（deprecated）
2. LD_LIBRARY_PATH指定的库文件
3. DT_RUNPATH指定的库文件
4. /etc/ld.so.cache这个二进制文件指定的库文件，该文件通过ldconfig命令生成
5. In the default path /lib, and then /usr/lib. (On some 64-bit architectures, the default paths for 64-bit shared objects are /lib64, and then /usr/lib64.) If the binary was linked with the -z nodeflib linker option, this step is skipped.

所以针对LD_LIBRARY_PATH，除了第二条的方法失效，其他的都可以用。

LD_PRELOAD

那针对LD_PRELOAD，是不是就没法用呢？其实也不是。
在没有setcap以及set-user-ID的情况下，如果ld.so需要预加载一个库文件，指定方法在文献[1]中同样有描述：

1. The LD_PRELOAD environment variable.
2. The --preload command-line option when invoking the dynamic linker directly.
3. The /etc/ld.so.preload file.

在secure-execution模式下，方法2和方法3均不受影响。方法1也仍然可以使用。但是需要一些特殊的设置，在[1]中也有描述。

In secure-execution mode, preload pathnames containing slashes are ignored. Furthermore, shared objects are preloaded only from the standard search directories and only if they have set-user-ID mode bit enabled (which is not typical).

综上，需要3点配置：

• LD_PRELOAD环境变量指定的库文件不能包含斜线'/'
• 库文件只会从标准路径下加载。这里标准路径可以参考LD_LIBRARY_PATH中的描述。注意，此时ld.so只会搜索标准路径，不会搜索通过其他手段配置的路径（如上一节描述的）。
• 库文件必须使能了set-user-id位

示例代码

代码目录树：

[ben@localhost test]$ tree .
.
├── lib.c
├── libtest.so
├── main
├── main.c
├── test
└── test.c

main.c生成main可执行程序，test.c生成test可执行程序，lib.c生成libtest.so。

// main.c

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main()
{
        pid_t pid = fork();
        if (pid == 0) {
                char *envp[] = {
                        "LD_PRELOAD=libtest.so",
                        // "LD_PRELOAD=./libtest.so",
                        NULL
                };
                char *argv[] = {
                        "test",
                        NULL
                };
                int err = execve("./test", argv, envp);
        }
        else {
                int status;
                wait(&status);
        }
        return 0;
}

// test.c
#include <stdio.h>
#include <stdlib.h>

int main ()
{
        const char *preload = getenv("LD_PRELOAD");
        printf("LD_PRELOAD = %s\n", preload);
        return 0;
}

// lib.c
#include <stdio.h>

static void func(void) __attribute__((constructor));
void func(void)
{
        printf("I'm libtest.so loaded\n");
}

在test可执行程序是普通的二进制时，输出为

[ben@localhost test]$ ./main
I'm libtest.so loaded
LD_PRELOAD = ./libtest.so

当test配置了capability以后：

[ben@localhost test]$ sudo setcap cap_net_admin,cap_net_raw=eip ./test
[ben@localhost test]$ ./main
LD_PRELOAD = (null)

可见LD_PRELOAD指定libtest.so未被加载，且LD_PRELOAD环境变量被清空了。

LD_PRELOAD不含斜线

[ben@localhost test]$ ./main
ERROR: ld.so: object 'libtest.so' from LD_PRELOAD cannot be preloaded (cannot open shared object file): ignored.
LD_PRELOAD = (null)

LD_PRELOAD仍然被清空了，但ld.so似乎尝试去加载libtest.so了，但是没找着。

将libtest.so放入标准路径

如果没有配置set-user-id位：

[ben@localhost test]$ ./main
ERROR: ld.so: object 'libtest.so' from LD_PRELOAD cannot be preloaded (cannot open shared object file): ignored.
LD_PRELOAD = (null)

仍然提示找不到。如果设置了set-user-id位：

[ben@localhost test]$ sudo chmod a+s /usr/lib64/libtest.so 
[ben@localhost test]$ ./main
I'm libtest.so loaded
LD_PRELOAD = (null)

在满足上一节提到的3个条件时，libteso.so就可以正常加载了。
看看如果放到/usr/lib下面会怎么样？

[ben@localhost test]$ ls /usr/lib/libtest.so -l
-rwsr-sr-x. 1 root root 8208 1月  24 19:48 /usr/lib/libtest.so
[ben@localhost test]$ ./main
ERROR: ld.so: object 'libtest.so' from LD_PRELOAD cannot be preloaded (cannot open shared object file): ignored.
LD_PRELOAD = (null)

看看还是一样找不到。可见在x64平台上，/usr/lib并非标准路径，而/usr/lib64以及/lib64才是

参考文献

[1] ld.so(8) — Linux manual page

[2] Stackoverflow - Does using linux capabilities disables LD_PRELOAD

RBAC, Role Based Access Control, 是SELinux的另一个重要的特性。但他并不是一种独立的控制方式，而是对TEAC的一种补充。其主要的作用是，构建SELinux提供的进程级的MAC机制与Linux的用户系统的映射关系。

RBAC工作原理

RBAC并不提供强制访问控制，而是通过user，role，type之间的对应关系，来控制type_transition策略能否成功。

role vs. type

role based最基本的就是定义role到type到对应关系。使用role语句可以实现：role role_name [types type_set];。例如：

role user_r types user_t;
role user_r types { staff_t, admin_t };

• role定义是累积的，即后面的对应关系不会覆盖前面语句定义的对应关系，而只会追加这种关系
• role语句通常定义在type声明附近，以确保该对应关系被及时定义

定义子role (period)
A period is used to indicate restrictions on the set of types that may be assigned to a role. For example, the set of types for a role called apache.cgi must be a subset of the type set of a role called apache.

role语句定义的基本逻辑就是，定义了role=>{ types }集合的映射关系。当发生type transition时，如果转换后的{role，type}组合未定义，则视为权限错误。从这个层面看，role对应的是主体type，即domain type，而非object type。

特殊的role: object_r

object_r是内核SELinux模块预定义的一个role，无需在policy中声明。而这个object_r被专门用来定义客体的安全上下文。

user vs. role

user是对role的再一次扩充，通过user将role与Linux user的映射关系建立起来。SELinux的用户系统独立于Linux用户系统。通过seusers文件或者semanage user命令可以定义他们之间的映射关系。但实际可定义的自由度并没有那么高。

The design decision for SELinux to have a distinct user identifier (rather than share that of Linux) is motivated by the desire to create an immutable SELinux user identifier.

定义一个user与role的映射关系，可以使用user语句：user user_name roles { role_set };
user语句所体现的逻辑和role语句类似，即定义了user=>{ roles }集合的映射关系。当应用启动时发生role transition时，如果转换后的{user, role}未定义，则视为权限错误。

当SELinux通过RBAC，建立起user=>role=>type的映射关系以后，还获得了一个好处。Linux系统的用户数可能很多，而用户的类型很少。用户并不是为了定义权限的，不同的用户之间的使用数据需要隔离。但往往一类用户的权限是相同的。例如超级用户，管理员用户，普通用户等等。系统的权限集最小粒度由domain定义。可能每个进程的权限不同，也可能一组进程的权限相同。但往往domain的数量也很庞大。如果没有RBAC，我们需要定义user到domain到映射。这样也不是不能做，但却不太优雅。每次新增用户时，需要为新增用户绑定一堆domain。定义了role之后，role相当于较稳定的一层抽象，role到types的映射关系是在定义type时候就定义了的。增加新user的时候，只要定义user到role的映射即可。这就是引入RBAC的原因。

<svg id="djdiif5uggu" width="100%" xmlns="http://www.w3.org/2000/svg" style="max-width: 269.765625px;" viewBox="0 0 269.765625 224.84375"><style>


#djdiif5uggu .label {
  font-family: 'trebuchet ms', verdana, arial;
  color: #333; }

#djdiif5uggu .node rect,
#djdiif5uggu .node circle,
#djdiif5uggu .node ellipse,
#djdiif5uggu .node polygon {
  fill: #ECECFF;
  stroke: #9370DB;
  stroke-width: 1px; }

#djdiif5uggu .node.clickable {
  cursor: pointer; }

#djdiif5uggu .arrowheadPath {
  fill: #333333; }

#djdiif5uggu .edgePath .path {
  stroke: #333333;
  stroke-width: 1.5px; }

#djdiif5uggu .edgeLabel {
  background-color: #e8e8e8; }

#djdiif5uggu .cluster rect {
  fill: #ffffde !important;
  stroke: #aaaa33 !important;
  stroke-width: 1px !important; }

#djdiif5uggu .cluster text {
  fill: #333; }

#djdiif5uggu div.mermaidTooltip {
  position: absolute;
  text-align: center;
  max-width: 200px;
  padding: 2px;
  font-family: 'trebuchet ms', verdana, arial;
  font-size: 12px;
  background: #ffffde;
  border: 1px solid #aaaa33;
  border-radius: 2px;
  pointer-events: none;
  z-index: 100; }

#djdiif5uggu .actor {
  stroke: #CCCCFF;
  fill: #ECECFF; }

#djdiif5uggu text.actor {
  fill: black;
  stroke: none; }

#djdiif5uggu .actor-line {
  stroke: grey; }

#djdiif5uggu .messageLine0 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  stroke: #333; }

#djdiif5uggu .messageLine1 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  stroke: #333; }

#djdiif5uggu #arrowhead {
  fill: #333; }

#djdiif5uggu #crosshead path {
  fill: #333 !important;
  stroke: #333 !important; }

#djdiif5uggu .messageText {
  fill: #333;
  stroke: none; }

#djdiif5uggu .labelBox {
  stroke: #CCCCFF;
  fill: #ECECFF; }

#djdiif5uggu .labelText {
  fill: black;
  stroke: none; }

#djdiif5uggu .loopText {
  fill: black;
  stroke: none; }

#djdiif5uggu .loopLine {
  stroke-width: 2;
  stroke-dasharray: '2 2';
  stroke: #CCCCFF; }

#djdiif5uggu .note {
  stroke: #aaaa33;
  fill: #fff5ad; }

#djdiif5uggu .noteText {
  fill: black;
  stroke: none;
  font-family: 'trebuchet ms', verdana, arial;
  font-size: 14px; }

#djdiif5uggu .activation0 {
  fill: #f4f4f4;
  stroke: #666; }

#djdiif5uggu .activation1 {
  fill: #f4f4f4;
  stroke: #666; }

#djdiif5uggu .activation2 {
  fill: #f4f4f4;
  stroke: #666; }


#djdiif5uggu .section {
  stroke: none;
  opacity: 0.2; }

#djdiif5uggu .section0 {
  fill: rgba(102, 102, 255, 0.49); }

#djdiif5uggu .section2 {
  fill: #fff400; }

#djdiif5uggu .section1,
#djdiif5uggu .section3 {
  fill: white;
  opacity: 0.2; }

#djdiif5uggu .sectionTitle0 {
  fill: #333; }

#djdiif5uggu .sectionTitle1 {
  fill: #333; }

#djdiif5uggu .sectionTitle2 {
  fill: #333; }

#djdiif5uggu .sectionTitle3 {
  fill: #333; }

#djdiif5uggu .sectionTitle {
  text-anchor: start;
  font-size: 11px;
  text-height: 14px; }


#djdiif5uggu .grid .tick {
  stroke: lightgrey;
  opacity: 0.3;
  shape-rendering: crispEdges; }

#djdiif5uggu .grid path {
  stroke-width: 0; }


#djdiif5uggu .today {
  fill: none;
  stroke: red;
  stroke-width: 2px; }



#djdiif5uggu .task {
  stroke-width: 2; }

#djdiif5uggu .taskText {
  text-anchor: middle;
  font-size: 11px; }

#djdiif5uggu .taskTextOutsideRight {
  fill: black;
  text-anchor: start;
  font-size: 11px; }

#djdiif5uggu .taskTextOutsideLeft {
  fill: black;
  text-anchor: end;
  font-size: 11px; }


#djdiif5uggu .taskText0,
#djdiif5uggu .taskText1,
#djdiif5uggu .taskText2,
#djdiif5uggu .taskText3 {
  fill: white; }

#djdiif5uggu .task0,
#djdiif5uggu .task1,
#djdiif5uggu .task2,
#djdiif5uggu .task3 {
  fill: #8a90dd;
  stroke: #534fbc; }

#djdiif5uggu .taskTextOutside0,
#djdiif5uggu .taskTextOutside2 {
  fill: black; }

#djdiif5uggu .taskTextOutside1,
#djdiif5uggu .taskTextOutside3 {
  fill: black; }


#djdiif5uggu .active0,
#djdiif5uggu .active1,
#djdiif5uggu .active2,
#djdiif5uggu .active3 {
  fill: #bfc7ff;
  stroke: #534fbc; }

#djdiif5uggu .activeText0,
#djdiif5uggu .activeText1,
#djdiif5uggu .activeText2,
#djdiif5uggu .activeText3 {
  fill: black !important; }


#djdiif5uggu .done0,
#djdiif5uggu .done1,
#djdiif5uggu .done2,
#djdiif5uggu .done3 {
  stroke: grey;
  fill: lightgrey;
  stroke-width: 2; }

#djdiif5uggu .doneText0,
#djdiif5uggu .doneText1,
#djdiif5uggu .doneText2,
#djdiif5uggu .doneText3 {
  fill: black !important; }


#djdiif5uggu .crit0,
#djdiif5uggu .crit1,
#djdiif5uggu .crit2,
#djdiif5uggu .crit3 {
  stroke: #ff8888;
  fill: red;
  stroke-width: 2; }

#djdiif5uggu .activeCrit0,
#djdiif5uggu .activeCrit1,
#djdiif5uggu .activeCrit2,
#djdiif5uggu .activeCrit3 {
  stroke: #ff8888;
  fill: #bfc7ff;
  stroke-width: 2; }

#djdiif5uggu .doneCrit0,
#djdiif5uggu .doneCrit1,
#djdiif5uggu .doneCrit2,
#djdiif5uggu .doneCrit3 {
  stroke: #ff8888;
  fill: lightgrey;
  stroke-width: 2;
  cursor: pointer;
  shape-rendering: crispEdges; }

#djdiif5uggu .doneCritText0,
#djdiif5uggu .doneCritText1,
#djdiif5uggu .doneCritText2,
#djdiif5uggu .doneCritText3 {
  fill: black !important; }

#djdiif5uggu .activeCritText0,
#djdiif5uggu .activeCritText1,
#djdiif5uggu .activeCritText2,
#djdiif5uggu .activeCritText3 {
  fill: black !important; }

#djdiif5uggu .titleText {
  text-anchor: middle;
  font-size: 18px;
  fill: black; }

#djdiif5uggu g.classGroup text {
  fill: #9370DB;
  stroke: none;
  font-family: 'trebuchet ms', verdana, arial;
  font-size: 10px; }

#djdiif5uggu g.classGroup rect {
  fill: #ECECFF;
  stroke: #9370DB; }

#djdiif5uggu g.classGroup line {
  stroke: #9370DB;
  stroke-width: 1; }

#djdiif5uggu .classLabel .box {
  stroke: none;
  stroke-width: 0;
  fill: #ECECFF;
  opacity: 0.5; }

#djdiif5uggu .classLabel .label {
  fill: #9370DB;
  font-size: 10px; }

#djdiif5uggu .relation {
  stroke: #9370DB;
  stroke-width: 1;
  fill: none; }

#djdiif5uggu #compositionStart {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#djdiif5uggu #compositionEnd {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#djdiif5uggu #aggregationStart {
  fill: #ECECFF;
  stroke: #9370DB;
  stroke-width: 1; }

#djdiif5uggu #aggregationEnd {
  fill: #ECECFF;
  stroke: #9370DB;
  stroke-width: 1; }

#djdiif5uggu #dependencyStart {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#djdiif5uggu #dependencyEnd {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#djdiif5uggu #extensionStart {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#djdiif5uggu #extensionEnd {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#djdiif5uggu .commit-id,
#djdiif5uggu .commit-msg,
#djdiif5uggu .branch-label {
  fill: lightgrey;
  color: lightgrey; }



#djdiif5uggu .label{
  color:#18B14E;
}
#djdiif5uggu .te-md-container--dark .node rect {
  fill: red;
}

#djdiif5uggu .node rect,
#djdiif5uggu .node circle,
#djdiif5uggu .node ellipse,
#djdiif5uggu .node polygon {
  fill: #F9FFFB;;
  stroke: #2DBD60;
  stroke-width: 1.5px;
}
#djdiif5uggu .arrowheadPath{
  fill: #2DBD60;
}
#djdiif5uggu .edgePath .path {
  stroke: #2DBD60;
  stroke-width: 1px;
}
#djdiif5uggu .edgeLabel {
  background-color: #fff;
}
#djdiif5uggu .cluster rect {
  fill: #F9FFFB !important;
  stroke: #2DBD60 !important;
  stroke-width: 1px !important;
}

#djdiif5uggu .cluster text {
  fill: #F9FFFB;
}

#djdiif5uggu div.mermaidTooltip {
  background: #F9FFFB;
  border: 1px solid #2DBD60;
}


#djdiif5uggu .actor {
  stroke: #2DBD60;
  fill: #F9FFFB;
}

#djdiif5uggu text.actor {
  fill: #2DBD60;
  stroke: none;
}

#djdiif5uggu .actor-line {
  stroke: #2DBD60;
}

#djdiif5uggu .messageLine0 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  marker-end: 'url(#arrowhead)';
  stroke: #2DBD60;
}

#djdiif5uggu .messageLine1 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  stroke: #2DBD60;
}

#djdiif5uggu #arrowhead {
  fill: #2DBD60;
}

#djdiif5uggu #crosshead path {
  fill: #2DBD60 !important;
  stroke: #2DBD60 !important;
}

#djdiif5uggu .messageText {
  fill: #2DBD60;
  stroke: none;
}

#djdiif5uggu .labelBox {
  stroke: #2DBD60;
  fill: #F9FFFB;
}

#djdiif5uggu .labelText {
  fill: #2DBD60;
  stroke: #2DBD60;
}

#djdiif5uggu .loopText {
  fill: #2DBD60;
  stroke: #2DBD60;
}

#djdiif5uggu .loopLine {
  stroke-width: 2;
  stroke-dasharray: '2 2';
  marker-end: 'url(#arrowhead)';
  stroke: #2DBD60;
}

#djdiif5uggu .note {
  stroke: #2DBD60;
  fill: #F9FFFB;
}

#djdiif5uggu .noteText {
  fill: #2DBD60;
  stroke: #2DBD60;
}


#djdiif5uggu .section{
  opacity:1;
}
#djdiif5uggu .section0,#djdiif5uggu  .section2 {
  fill: #ECF7F0;
}

#djdiif5uggu .section1,
#djdiif5uggu .section3 {
  fill: #FFF;
}
#djdiif5uggu .taskText0,
#djdiif5uggu .taskText1,
#djdiif5uggu .taskText2,
#djdiif5uggu .taskText3 {
  fill: #fff;
}

#djdiif5uggu .task0,
#djdiif5uggu .task1,
#djdiif5uggu .task2,
#djdiif5uggu .task3 {
  fill: #2DBD60;
  stroke: #359F5A;
}
</style><style>#djdiif5uggu {
    color: rgb(244, 244, 244);
    font: normal normal normal normal 14px/22.399999618530273px monospace;
  }</style><g transform="translate(-12, -12)"><g class="output"><g class="clusters"></g><g class="edgePaths"><g class="edgePath" style="opacity: 1;"><path class="path" d="M52.789433176385366,106.28125L90.5,38.140625L115.5,38.140625" marker-end="url(#arrowhead331)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead331" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M65.5,124.421875L90.5,124.421875L115.5,124.421875" marker-end="url(#arrowhead332)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead332" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M52.789433176385366,142.5625L90.5,210.703125L115.5,210.703125" marker-end="url(#arrowhead333)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead333" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M147.27773989270193,106.28125L184.328125,38.140625L209.328125,38.140625" marker-end="url(#arrowhead334)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead334" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M159.328125,124.421875L184.328125,124.421875L209.328125,124.421875" marker-end="url(#arrowhead335)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead335" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M147.27773989270193,142.5625L184.328125,210.703125L209.328125,210.703125" marker-end="url(#arrowhead336)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead336" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g></g><g class="edgeLabels"><g class="edgeLabel" style="opacity: 1;" transform=""><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" style="opacity: 1;" transform=""><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" style="opacity: 1;" transform=""><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" style="opacity: 1;" transform=""><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" style="opacity: 1;" transform=""><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" style="opacity: 1;" transform=""><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g></g><g class="nodes"><g class="node" style="opacity: 1;" id="A" transform="translate(42.75,124.421875)"><rect rx="0" ry="0" x="-22.75" y="-18.140625" width="45.5" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-12.75,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">user</tspan></text></g></g></g><g class="node" style="opacity: 1;" id="B" transform="translate(137.4140625,38.140625)"><rect rx="0" ry="0" x="-21.9140625" y="-18.140625" width="43.828125" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-11.9140625,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">role</tspan></text></g></g></g><g class="node" style="opacity: 1;" id="C" transform="translate(137.4140625,124.421875)"><rect rx="0" ry="0" x="-21.9140625" y="-18.140625" width="43.828125" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-11.9140625,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">role</tspan></text></g></g></g><g class="node" style="opacity: 1;" id="D" transform="translate(137.4140625,210.703125)"><rect rx="0" ry="0" x="-21.9140625" y="-18.140625" width="43.828125" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-11.9140625,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">role</tspan></text></g></g></g><g class="node" style="opacity: 1;" id="E" transform="translate(241.546875,38.140625)"><rect rx="0" ry="0" x="-32.21875" y="-18.140625" width="64.4375" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-22.21875,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">domain</tspan></text></g></g></g><g class="node" style="opacity: 1;" id="F" transform="translate(241.546875,124.421875)"><rect rx="0" ry="0" x="-32.21875" y="-18.140625" width="64.4375" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-22.21875,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">domain</tspan></text></g></g></g><g class="node" style="opacity: 1;" id="G" transform="translate(241.546875,210.703125)"><rect rx="0" ry="0" x="-32.21875" y="-18.140625" width="64.4375" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-22.21875,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">domain</tspan></text></g></g></g></g></g></g></svg>

Linux用户 vs. SELinux user

• 当前系统的用户可以通过查看/etc/passwd文件获取，也可以参考列出 Linux 系统上所有用户的 3 种方法.
• 查看SELinux的用户可以通过命令semanage user -l.

               标记中        MLS/       MLS/                          
SELinux 用户      前缀         MCS 级别     MCS 范围                         SELinux 角色

guest_u         user       s0         s0                             guest_r
root            user       s0         s0-s0:c0.c1023                 staff_r sysadm_r system_r unconfined_r
staff_u         user       s0         s0-s0:c0.c1023                 staff_r sysadm_r unconfined_r
sysadm_u        user       s0         s0-s0:c0.c1023                 sysadm_r
system_u        user       s0         s0-s0:c0.c1023                 system_r unconfined_r
unconfined_u    user       s0         s0-s0:c0.c1023                 system_r unconfined_r
user_u          user       s0         s0                             user_r
xguest_u        user       s0         s0                             xguest_r

• 查看两者的映射关系可以通过命令semanage login -l.

登录名                  SELinux 用户           MLS/MCS 范围           服务

__default__          unconfined_u         s0-s0:c0.c1023       *
john                 user_u               s0                   *
root                 unconfined_u         s0-s0:c0.c1023       *

Linux用户和SELinux用户的初始映射关系由seusers文件指定。这个文件不属于策略二进制的一部分，而可以直接修改生效。当然更优雅的办法是通过semanage命令来修改。
另外，在修改了context以后，或者新建了用户以后，必须要使用注销登录的方法，才能使新的context生效，而只使用su命令切换用户，并不会切换context。推测注销登录使用的是PAM登录程序，而su命令中，并没有重新加载user context的功能。
Linux用户登录后，获取shell安全上下文的步骤，可以参考文献【2】。简述如下：

1. 根据seusers文件，映射SELinux用户，如果没有seusers文件，系统就无法启动了。如果seusers文件没有对应的用户描述，则统一映射为__default__用户。如果__default__用户描述不存在，则无法登录。
2. 根据SELinux的搜索优先级，找到对应SELinux用户的安全上下文。

勘误
在[1]中，对Linux用户和SELinux的映射关系有如下描述：
On login, if there is an SELinux user identifier that is exactly the same as the Linux user identifier, the matching SELinux user identifier becomes the user identifier in the security context for the initial shell process. In this way, if a Linux user identifier also exists as a user identifier in the SELinux policy, all login processes will set the initial shell process security context user identifier to that matching Linux identity.
经实验证明，并非如此：

• 定义了一个guest_u用户，登录后，其shell的安全上下文仍为：
  
• 但事实证明，明明就有guest_u这个用户
  

总结

现在可以引用[1]中的一幅图来总结一下RBAC的工作原理了。

• Linux系统有一个用户较joe
• SELinuxcelue中规定joe和user_r绑定，user_r和user_t绑定
• 当joe登录时，系统根据seusers（此处与图不同，参见上一章勘误），找到对应的SELinux user，找不到就是__default__, __default__没有就不能登录了
• 根据以下context文件顺序，决定其shell的安全上下文，即joe:user_r:user_t
  • /etc/selinux/specified-policy/contexts/users
  • /etc/selinux/specified-policy/contexts/default_contexts
  • /etc/selinux/specified-policy/contexts/failsafe_context
  • sid kernel的安全上下文
• joe执行了一个应用，开始进行domain_transition, 要从user_t切换到passwd_t
  • 如果定义了role user_r types passwd_t和role user_r types user_t，则这次domain transition可以成功
  • 否则任意一个未定义，domain transition都会失败

高阶用法

role_transition

role transition和domain transition非常类似，也是在某个domain进程在执行某个可执行文件时，即exec系统调用时，切换进程主体的安全上下文。domain transition切换的时domain，role transtion切换的是role。实现方式通过以下两条语句：

allow staff_r sysadm_r; # 允许从staff_r切换到sysadm_r
role_transition sysadm_r http_exec_t system_r; # sysadm_r进程执行http_exec_t类型文件时，role切换为system_r

role_dominance

可以利用role来定义其他role，即role dominance。

dominance { role super_r {role sysadm_r; role secadm_r; }

上面例子中的super_r称为dominant role，它可以从它关联的role中即成types。但它只能继承该条语句之前关联的types。我们之前说role语句是可以累积的。那么在role_dominance语句之后定义的types，并不能动态的添加到dominant role上。

相关工具

跟role相关的主要是semnage的一些用法，另外[1]还介绍了一个apol的可视化工具，可以检索user和role的数据。我理解semanage通过命令行也都可以实现。

1. 前文介绍过的semanage user -l和semanage login -l, 前者用来查看所有SELinux的用户，后者用来查看Linux用户和SELinux用户两者的映射关系.
2. Modify the default user on the system to the guest_u user

• semanage login -m -s guest_u __default__

3. 修改user和role的对应关系

• semanage user -m -R "message_filter_r unconfined_r" user_u

4. 添加一个用户并指定SELinux用户

• useradd joe -Z user_u

参考文献

[1] SELinux by Example_ Using Security Enhanced Linux

[2] SELinux初始化登录用户安全上下文的方法

• 简单单例的问题
  • 谁来释放这个对象？
  • 如何处理并发？
  • 析构顺序？
    • 对象a什么时候会被析构呢？
    • 析构引入的问题
    • C++实现提供C语言接口引入的析构问题
• Take Aways
• 参考文献

SELinux对socket的控制包含这几个方面：

• context语法中的nodecon, portcon, netifcon：这一类控制本端系统资源，确保合法进程才能访问本端网络资源
• 通过iptables工具的SECMARK/CONNSECMARK扩展为socket packet打上的标签：这一类控制socket包的流向，确保只有合法进程才能访问某些网络报文
• NetLable/Labeled IPSec：这一类还没看，留待后面继续学习
  本文关注第二种控制方法，并结合iptables，简要阐述其工作原理和使用方法。

iptables简介

from wiki
iptables is a user-space utility program that allows a system administrator to configure the IP packet filter rules of the Linux kernel firewall, implemented as different Netfilter modules. The filters are organized in different tables, which contain chains of rules for how to treat network traffic packets. Different kernel modules and programs are currently used for different protocols; iptables applies to IPv4, ip6tables to IPv6, arptables to ARP, and ebtables to Ethernet frames.

iptables其实就是Linux的防火墙，用户通过配置各种规则来实现数据包的过滤。他利用了Linux的Netfilter框架的hook点对数据包进行判断，并执行action。例如：

iptables -A INPUT -s 10.10.10.10 -j DROP # 来自10.10.10.10的packet全部被丢弃
iptables -A INPUT -s 10.10.10.0/24 -j DROP # 来自10.10.10.0/255.255.255.0（24表示掩码位数）的packet全部被丢弃

iptables支持的规则很多，具体可以参考iptables(8) - Linux man page。

table & chain

如wiki page所述，iptables通过各种tables和chains来管理所有rules。其实chain就是对应了netfilter的hook点。netfilter的hook点有：

The following hooks represent various well-defined points in the networking stack:

• NF_IP_PRE_ROUTING: This hook will be triggered by any incoming traffic very soon after entering the network stack. This hook is processed before any routing decisions have been made regarding where to send the packet.
• NF_IP_LOCAL_IN: This hook is triggered after an incoming packet has been routed if the packet is destined for the local system.
• NF_IP_FORWARD: This hook is triggered after an incoming packet has been routed if the packet is to be forwarded to another host.
• NF_IP_LOCAL_OUT: This hook is triggered by any locally created outbound traffic as soon it hits the network stack.
• NF_IP_POST_ROUTING: This hook is triggered by any outgoing or forwarded traffic after routing has taken place and just before being put out on the wire.

而chain就是和这些hook点一一对应的，例如：

• PREROUTING: Triggered by the NF_IP_PRE_ROUTING hook.
• INPUT: Triggered by the NF_IP_LOCAL_IN hook.
• FORWARD: Triggered by the NF_IP_FORWARD hook.
• OUTPUT: Triggered by the NF_IP_LOCAL_OUT hook.
• POSTROUTING: Triggered by the NF_IP_POST_ROUTING hook.

而iptables又是怎么遍历这些table和chain的呢？
iptable在各个NetFilter的hook点上，依次遍历各个table的各个chain。其顺序按照如下表格：

• chain从左到右
• table从上到下

每个chain和table在整个协议栈的位置如下图。

用户还可以创建自己的chain，使用命令iptables -N <chain name>。然后使用-j参数跳转，例如：iptables -A INPUT -p tcp -j tcp_packets

When/If we reach the end of that chain, we get dropped back to the INPUT chain and the packet starts traversing from the rule one step below where it jumped to the other chain (tcp_packets in this case). If a packet is ACCEPTed within one of the sub chains, it will be ACCEPT’ed in the superset chain also and it will not traverse any of the superset chains any further. However, do note that the packet will traverse all other chains in the other tables in a normal fashion.

总结一下：

• 如果自定义chain遍历结束，则回到原先跳出的chain（super chain），继续遍历
• 如果子链（sub chain）中有ACCEPT，则父链中的规则不会再被继续遍历，但仍然会继续遍历其他chain中的规则，以及其他table中的规则。
• 如果在任意位置，packet被DROP，则后续的chain和table都不会被执行

target

-j除了指定自定义chain外，一个更重要的用途就是指定packet的目的地，也就是target。

Targets on the other hand specify an action to take on the packet in question. We could for example, DROP or ACCEPT the packet depending on what we want to do. There are also a number of other actions we may want to take.
For example: ACCEPT, DROP, CONNMARK, CLASSIFY, LOG ...

• Some targets will cause the packet to stop traversing that specific chain and superior chains as described above. ex. ACCEPT, DROP
• Other targets, may take an action on the packet, after which the packet will continue passing through the rest of the rules. ex. LOG, ULOG, TOS
• Some targets will accept extra options (What TOS value to use etc), while others don’t necessarily need any options.

注：以上摘自[5],时间有点久，可能有些已经不成立了（例如[5]中通篇未提到security table)，但基本思路应该是保持的。

SECMARK

上一章介绍了iptables的基本工作原理，和table/chain的遍历方法。而可以与SELinux联动，并提供基于socket packet的MAC机制的是iptables的security表格。从上面表格可以看到，security table只有3个chain，即：INPUT，FORWARD，OUTPUT。对应了输入，输出以及转发3种数据流。可以满足基本的packet强制访问控制需求。
一条SECMARK相关的iptables语句如下：

iptables -t security -A INPUT -i lo -p tcp --dport 9999 -j SECMARK --selctx system_u:object_r:ext_gateway_packet_t:s0

其中iptables -t security -A INPUT表示往security table的INPUT chain插入一条规则，match部分-i lo -p tcp --dport 9999表示匹配来自lo网卡，协议为tcp的报文，目标端口为9999的数据包被SECMARK目标进行处理。SECMARK目标使用--selctx参数为该类数据包打上system_u:object_r:ext_gateway_packet_t:s0的安全上下文。则SELinux的策略语法即可以针对该类packet进行权限判断。例如:

allow ext_gateway_t ext_gateway_packet_t : packet { send recv };

CONNSECMARK

CONNSECMARK实际上是SECMARK的扩展。从名字就可以看出CONNSECMARK是针对连接（connection）进行mark动作。iptables的连接管理基于NetFilter的conntrack。conntrack是内核模块，针对不同的协议类型，具有相应的连接控制管理。这已经超出本文的范围了。但不管conntrack多么复杂，功能多么强大，对应到iptables的状态只有4个，即NEW, EATABLISHED, RELATED, INVALID。所有的socket packet都被映射到这4歌状态。具体可以参考文献[5]的Chapter 7. The state machine的User-land states。

• NEW: tells us that the packet is the first packet that we see.
• ESTABLISHED: The only requirement to get into an ESTABLISHED state is that one host sends a packet, and that it later on gets a reply from the other host.
• RELATED: The ESTABLISHED connection will then spawn a connection outside of the main connection. The newly spawned connection will then be considered RELATED, if the conntrack module is able to understand that it is RELATED.
  INVALID: The INVALID state means that the packet can’t be identified or that it does not have any state.

有了这状态定义，iptables就可以使用--state maches。例如：iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT定义了规则，处于ESTABLISHED, RELATED状态的packet才被ACCEPT。
iptables与SELinux配合完全基于对socket packet进行过滤。并没有allow规则，或SELinux object是针对网络连接的。所以，iptables可以通过配合state match以及CONNSECMARK为来自于某个连接的packet进行打标签。方法就是--save和--restore参数。

• --save

  • Example: iptables -t mangle -A PREROUTING -p tcp --dport 80 -j CONNSECMARK --save
  • Explanation: Save the security context mark from the packet to the connection if the connection is not marked since before.

• --restore

  • Example: iptables -t mangle -A PREROUTING -p tcp --dport 80 -j CONNSECMARK --restore
  • Explanation: If the packet has no security context mark set on it, the --restore option will set the security context mark associated with the connection on the packet.

总结一下就是：

• --save将packet数据包的context赋予连接
• --restore将连接的context赋予packet
  此时SELinux具备更丰富的上下文，来对socket packet进行强制访问控制。

Gateway实验

简介

文献[2]的2.2章节中提供了一个很好的练习，带我们认识iptables与SELinux配合做socket packet强制访问控制的方法。该方法通过iptables和SELinux实现客户端和服务端之间的数据包过滤。整个测试框架示意图如下所示，其中client和secure_client使用同一份源码编译，只是file context有所不同，server和secure_server同理。

示例代码通过定义可执行文件的安全上下文（如下所示），和type_transition规则，使得secure_*进程工作在ext_gateway_t domain，而非secure进程工作在unconfined_t domain。各可执行文件的安全上下文如下所示：

/usr/local/bin/secure_client system_u:object_r:secure_services_exec_t:s0
/usr/local/bin/secure_server system_u:object_r:secure_services_exec_t:s0
/usr/local/bin/client system_u:object_r:unconfined_t:s0
/usr/local/bin/server system_u:object_r:unconfined_t:s0

示例代码中的策略集（.conf)文件定义了示意图中4个方向数据流的权限，包括：

• 允许访问未标记端口的数据流(default_secmark_packet_t)：auditallow unconfined_t default_secmark_packet_t : packet { send recv };
• 允许secure_*进程访问标记了端口的数据流（ext_gateway_packet_t）：allow ext_gateway_t ext_gateway_packet_t : packet { send recv };
• 允许secure_*进程访问无SECMARK标记的数据流（unconfined_t）：allow ext_gateway_t unconfined_t : packet { recv send };
  iptables_secmark使用若干iptables命令，定义数据包的标签规则，例如：
• 来自于lo网卡的，协议为tcp，目标IP为127.0.0.0，掩码为255.0.0.0输入数据包被设置成default_secmark_packet_t

# This OUTPUT rule sets all packets to default_secmark_packet_t: as it is
iptables -t security -A INPUT -i lo -p tcp -d 127.0.0.0/8 -j SECMARK --selctx system_u:object_r:default_secmark_packet_t:s0

• 来自于lo网卡的，协议为tcp，目标/源端口为9999的输入/输出数据包被设置成ext_gateway_packet_t（节选）

# These rules will replace the above context with the internal or
iptables -t security -A INPUT -i lo -p tcp --dport 9999 -j SECMARK --selctx system_u:object_r:ext_gateway_packet_t:s0
iptables -t security -A OUTPUT -o lo -p tcp --sport 9999 -j SECMARK --selctx system_u:object_r:ext_gateway_packet_t:s0

两类规则定义的数据包范围实际是有重叠的，根据注释可知，实际两者的关系是，general和特例的关系。即前者将所有特定目标的数据包设置为default_secmark_packet_t，而后者将来自特定端口的数据包指定为ext_gateway_packet_t。
经过此类策略设置，client在访问secure_server时，数据包就会被拦截。查看/var/log/audit/audit.log:

type=AVC msg=audit(1602641071.967:3475): avc:  granted  { send } for  pid=0 comm="swapper/0" saddr=127.0.0.1 src=9999 daddr=127.0.0.1 dest=47076 netif=lo scontext=unconfined_u:message_filter_r:ext_gateway_t:s0-s0:c0.c1023 tcontext=system_u:object_r:ext_gateway_packet_t:s0 tclass=packet

type=AVC msg=audit(1602641071.967:3476): avc:  denied  { recv } for  pid=10 comm="ksoftirqd/0" saddr=127.0.0.1 src=9999 daddr=127.0.0.1 dest=47076 netif=lo scontext=unconfined_u:
unconfined_r:unconfined_t:s0-s0:c0.c1023 tcontext=system_u:object_r:ext_gateway_packet_t:s0 tclass=packet permissive=0

client连接secure_server监听的9999端口，数据流为：tcp，127.0.0.1:9999 => 127.0.0.1:47076。secure_server向client发送成功，但client接收失败。因为client运行于unconfined_t，没有对应ext_gateway_packet_t的recv权限。

勘误

参考文献[2]因为成书过久（写于2014年，现在2020年），且练习基于书中前导章节中的modular-test章节，所以直接运行会产生错误。错误主要包含：

• 基于modular-test构建ext_gateway策略。因为可能是发行版变化（笔者用的CentOS8）或者时间过久的原因，直接用书中的基础策略会造成无法开机，所以modular-test练习中的策略不可用。解决方法是，编译ext_gateway module，并用semodule插入发行版自带的策略中。此时需要针对原生策略进行适配。例如：进程拉起时报错，需要增加相应allow规则，节选如下：

allow ext_gateway_t null_device_t : chr_file { read write open };
allow ext_gateway_t ld_so_t : file { map read execute };
allow ext_gateway_t ld_so_cache_t : file { open map read execute getattr };
allow ext_gateway_t lib_t : file { open map read execute getattr };
...

• 本书给出的示例代码的安全上下文未给出mls描述，在编译时会报错。例如：

iptables -t security -A INPUT -i lo -p tcp --dport 9999 -j SECMARK --selctx system_u:object_r:ext_gateway_packet_t:s0
iptables -t security -A INPUT -i lo -p tcp --sport 9999 -j SECMARK --selctx system_u:object_r:ext_gateway_packet_t:s0
/usr/local/bin/secure_client system_u:object_r:secure_services_exec_t:s0

所有的context都加上了:s0。
经过适配后，书中提供的示例可以顺利跑通，如下：
server

参考文献

[1] SELinux Networking Support

[2] The SELinux Notebook - Building The Sample Policy

[3] iptables wiki page

[4] A Deep Dive into Iptables and Netfilter Architecture

[5] Oskar Andreasson, 2001-2006, Iptables Tutorial 1.2.2

• 1号进程
• libselinux部分
• 内核部分
  • selinuxfs
    • selinuxfs SID初始化
  • selinux_init
  • security_setenforce
  • security_load_policy
• 总结
• 参考文献

• Intro
• initial SID
  • 启动时的使用
  • 系统标签无效时
• 其他SID
• 总结
• 相关工具
  • seinfo
  • initial_contexts
• 参考文献

如果想修改POSIX API的行为，通常我们的第一想法是修改libc库函数，并维护一份自定义的libc。这样做的代价非常大，因为libc是基础库，接口非常多，涉及的面也很广。修改可能不难，但后期维护，merge主干的工作比较麻烦，也没有价值。修改libc函数实现，还有一个缺点是，编译时修改，而非运行时。这会给一些无法下线并重新打包的程序带来困扰，例如程序已经分发，重新打包再分发耗时耗力。如果能找到运行时修改的方法，例如，暂停服务，替换一个库文件就可以修改某些行为。如果能做到运行时修改，对于调试也是非常友好的。
幸运的是，在Linux上，修改libc的方法很多：

1. 使用LD_PRELOAD，覆盖libc中的函数
2. 使用alias替代weak_alias，编译替换libc函数
3. 使用GOT表覆盖libc函数实现

1和3都是动态，运行时修改。3更棒的是，可以做运行时动态获得libc的原实现函数指针，并用自定义实例去覆写。这样在内部可以保存两份实例，而无需维护开源实例。
在整个的学习和实验中查阅了不少资料，回头看来，其中比较有价值的应当是文末的参考文献中列出的一些链接。

Android so注入(inject)和Hook技术学习（二）——Got表hook之导入表hook
我的实验代码基于这个网页中的方法二实例代码，通过解析.dynamic section来获取GOT地址，并覆盖对应表项

Executable and Linkable Format
这个帖子非常棒，详细阐述了动态链接的过程，包括link editor以及runtime dynamic link流程。只是可能时间比较久，其中的一些链接都失效了

Oracle Documentation

Executable and Linking Format Specification, Version 1.2
这两个链接都给出了一些较为官方的阐述，针对各个section，以及对应的取值等等，作为手册查询很好。

ELF概述

from Wiki
Executable and Linkable Format (ELF, formerly named Extensible Linking Format), is a common standard file format for executable files, object code, shared libraries, and core dumps.

              +-----------------+
         +----| ELF File Header |----+
         |    +-----------------+    |
         v                           v
 +-----------------+      +-----------------+
 | Program Headers |      | Section Headers |
 +-----------------+      +-----------------+
      ||                               ||
      ||                               ||
      ||                               ||
      ||   +------------------------+  ||
      +--> | Contents (Byte Stream) |<--+
           +------------------------+

ELF格式通常有linking view和execution view，即编译时，和运行时的不同。

我理解之所以要这么分成不同的view的原因是，运行时，内存比较宝贵，ELF文件被加载时，相关的节(section)被合并成segment。

segment列表[2]

section列表节选[2]

动态链接

我们知道当引用第三方库的时候，通常有两种链接方式，一种是动态链接，一种是静态链接。静态链接库在Windows上是.lib结尾的，在Linux平台上是.a结尾的。静态库不是一种可执行文件，而只是一些代码和数据打包（Archive）。当发生链接时，由链接器将其中的代码和数据分别放到最终的ELF文件的对应的节（section）。
而动态库是一种完全不一样的东西，动态库的行为更趋近于可执行文件。在Windows平台上，动态库文件以.dll结尾，在Linux平台上，动态库文件以.so结尾。
在Windows下，如果要进行动态链接，必须使用LoadLibrary函数打开一个.dll库文件，再用GetProcAddress获取具体函数的地址，进行调用。dll导出函数列表可以使用命令查看：dumpbin /exports <dll文件完整路径>。
Linux下也有类似的方式，就是可以用dlopen打开一个.so文件，再用dlsym找到对应的函数。但是Linux通常使用动态链接库的方式，是直接链接。例如：
gcc -L/lib -ltest main.c -o test
这就是在lib搜索路径下，找到libtest.so，并链接。注意这里默认先尝试动态链接，如果没有.so文件，会再尝试静态链接.a文件。如果都没有，就会报错。这也就是说Linux平台上，通过-l参数指定的链接参数，是默认尝试动态链接，其次才是静态链接。
如果想指定使用静态链接，可以用下面的命令：
gcc -L/lib -static -ltest main.c -o test
或者
gcc -L/lib libtest.a main.c -o test

How is an executable binary in Linux being executed ?[2]

1. sys_execve function (in arch/x86/kernel/process.c) handles the execvc system call from user space. It calls do_execve function.

2. do_execve function (in fs/exec.c) opens the executable binary file and does some preparation. It calls search_binary_handler function.

3. search_binary_handler function (in fs/exec.c) finds out the type of executable binary and calls the corresponding handler, which in our case, is load_elf_binary function.

4. load_elf_binary (in fs/binfmt_elf.c) loads the user's executable binary file into memory. It allocates memory segments and zeros out the BSS section by calling the padzero function.
   load_elf_binary also examines whether the user's executable binary contains an INTERP segment or not.

5. If the executable binary is dynamically linked, then the compiler will usually creates an INTERP segment (which is usually the same as .interp section in ELF's "linking view"), which contains the full pathname of an "interpreter", usually is the Glibc runtime linker ld.so.
   To see this, use command readelf -p .interp a.out

6. Thus, if the ELF executable binary file contains an INTERP segment, load_elf_binary will call load_elf_interp function to load the image of this interpreter as well.

7. Finally, load_elf_binary calls start_thread (in arch/x86/kernel/process_64.c) and passes control to either the interpreter or the user program.

这个1-7就是ELF文件被加载的过程，之后，再只要一个跳转语句，就可以真正的执行这个程序了。这里值得关注的就是第5步。如果被加载的二进制是动态链接生成的，即要么是动态链接库，要么是可执行文件，则加载时，内核会给ELF的内存镜像（即所谓的executing view）加一个INTERP段（segment）。而这个段就是所谓的runtime linker（compile时的linker，即ld，称为link editor），也就是ld.so。

ld.so

什么是ld.so? ld.so做了些啥？文献[2]都做了很好的说明。

ld.so is the runtime linker/loader (the compile-time linker ld is formally called "link editor") for dynamic executables. It provides the following services [2]:

• Analyzes the user's executable binary's DYNAMIC segment and determines what dependencies are required.
• Locates and loads these dependencies, analyzes their DYNAMIC segments to determine if more dependencies are required.
• Performs any necessary relocations to bind these objects.
• Calls any initialization functions (see below) provided by these dependencies.
• Passes control to user's executable binary.

How does ld.so work ?[2]

ld.so是用来加载所有的动态库的，所以ld.so本身不是动态加载的。ld.so的入口在_dl_start。可以通过gdb停在这个函数上。

(gdb) break _dl_start
Function "_dl_start" not defined.
Make breakpoint pending on future shared library load? (y or [n]) y
Breakpoint 1 (_dl_start) pending.
(gdb) run
Starting program: a.out

Breakpoint 1, 0x0000003433e00fa0 in _dl_start () from /lib64/ld-linux-x86-64.so.2
(gdb) bt
#0  0x0000003433e00fa0 in _dl_start () from /lib64/ld-linux-x86-64.so.2
#1  0x0000003433e00a78 in _start () from /lib64/ld-linux-x86-64.so.2
#2  0x0000000000000001 in ?? ()
#3  0x00007fffffffe4f2 in ?? ()
#4  0x0000000000000000 in ?? ()
...
(gdb) x/10i $pc
   0x3433e00a70 <_start>:       mov    %rsp,%rdi
   0x3433e00a73 <_start+3>:     callq  0x3433e00fa0 <_dl_start>
   0x3433e00a78 <_dl_start_user>:       mov    %rax,%r12
   0x3433e00a7b <_dl_start_user+3>:     mov    0x21b30b(%rip),%eax        # 0x343401bd8c <_dl_skip_args>
...

当_dl_start执行完后，ld.so就会为我们分析依赖关系，并加载起所有必需的动态库文件。

0000003434551000      4K rw---  /lib64/libc-2.5.so     <-- .got.plt .data sections

PLT & GOT

PLT = Procedure Linkage Table
GOT = Global Offsets Table
PLT表搭配GOT表就可以完成动态库函数的重定向。
当编译时，在链接阶段，编译器会查找函数定义，如果在所有的可重定向代码中，即.o、.a文件，无法找到函数定义，则会去链接指定的动态库.so文件中找。这里有两层意思：

1. 会优先查找有函数定义的，也就是说静态库或源文件中定义的函数是可以覆盖动态库中函数的
2. 编译器会为动态库中函数生成跳转代码。而这个跳转代码就是PLT表

可以用objdump -M intel -dj .plt a.out命令查看PLT表具体反编译代码，例如：

• 第一条汇编语句，就是跳转到GOT对应表项，当该表项尚未被填充时（函数第一次被调用），GOT表项会重新跳回到PLT表项的下一条汇编
• 第二条汇编语句，将函数编号push到栈上，此时是准备一次函数调用
• 第三条汇编语句，跳转到PLT表开始的地方。PLT第一个表项指向的是_dl_runtime_resolve函数，该函数会找到之前传入的函数编号对应的函数地址，并填充对应的GOT表项。

关于函数编号，举个例子，解释一下：

#include <stdio.h>
#include <fcntl.h>
int func(void)
{
    open("foo.txt", O_CREAT);
    fopen("foo.txt", "rw");
    printf("hello, in test.so\n");
    return 0;
}

这里引用了glibc里的3个函数，用readelf -r查看，则会得到下面的结果：

重定位节 '.rela.plt' at offset 0x508 contains 3 entries:
  偏移量          信息           类型           符号值        符号名称 + 加数
000000201018  000200000007 R_X86_64_JUMP_SLO 0000000000000000 puts@GLIBC_2.2.5 + 0
000000201020  000400000007 R_X86_64_JUMP_SLO 0000000000000000 open@GLIBC_2.2.5 + 0
000000201028  000500000007 R_X86_64_JUMP_SLO 0000000000000000 fopen@GLIBC_2.2.5 + 0

则puts对应的编号就是0，open是1，fopen是2。看看PLT表：

000000000000580 <puts@plt>:
 580:	ff 25 92 0a 20 00    	jmp    QWORD PTR [rip+0x200a92]        # 201018 <puts@GLIBC_2.2.5>
 586:	68 00 00 00 00       	push   0x0
 58b:	e9 e0 ff ff ff       	jmp    570 <.plt>

0000000000000590 <open@plt>:
 590:	ff 25 8a 0a 20 00    	jmp    QWORD PTR [rip+0x200a8a]        # 201020 <open@GLIBC_2.2.5>
 596:	68 01 00 00 00       	push   0x1
 59b:	e9 d0 ff ff ff       	jmp    570 <.plt>

00000000000005a0 <fopen@plt>:
 5a0:	ff 25 82 0a 20 00    	jmp    QWORD PTR [rip+0x200a82]        # 201028 <fopen@GLIBC_2.2.5>
 5a6:	68 02 00 00 00       	push   0x2
 5ab:	e9 c0 ff ff ff       	jmp    570 <.plt>

理解了PLT和GOT表在解析函数地址中的作用，就可以着手修改GOT表，让函数跳转到我们希望的函数执行。

替换GOT表项

正如前文所说，要做这个替换的操作，就是要找到GOT表对应的表项在哪里，然后修改对应的函数地址即可。这涉及到解析内存中的程序elf格式的镜像。

dynamic section

所有和重定向有关的信息都包含在dynamic section中，在elf的execution view中，也可以称作dynamic segment。实际上，这两者是同一个东西，只是存在的方式不同。当然，因为我们要做的是动态的GOT修改，所以我们要找到dynamic segment在内存中的位置。
由前文可知，要在execution view中查找段，应该要用到Programm Header Table（PHT）。通过objdump -x命令可以查看PHT表项。其中我们关心的就是DYNAMIC段。它包含了所有dynamic section的信息。代码里面，可以如下的获得dynamic。

// 1. 通过/proc/<pid>/maps得到elf加载的地址
    snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);

    // 打开文件/proc/pid/maps，获取指定pid进程加载的内存模块信息
    fp = fopen(filename, "r");
    if(fp != NULL){
        // 每次一行，读取文件 /proc/pid/maps中内容
        while(fgets(line, sizeof(line), fp)){
            // 查找指定的so模块
            if(strstr(line, module_name)){
                // 分割字符串
                pch = strtok(line, "-");
                // 字符串转长整形
                addr = strtoul(pch, NULL, 16);
                break;
            }
        }
    }
    fclose(fp);
  
// 2. 通过遍历program header table，找到dynameic段
    unsigned long long dynamicAddr = 0;
    unsigned int dynamicSize = 0;
    int j = 0;
    for (j = 0; j < phdr_count; j++)
    {
        if (phdr_table[j].p_type == PT_DYNAMIC)
        {
            dynamicAddr = phdr_table[j].p_vaddr + (uint64_t)base_addr;
            dynamicSize = phdr_table[j].p_memsz;
            break;
        }
    }

relocation tables

通过objdump -h命令可以查看文件包含的section。和relocation相关的节有：

• .got
• .got.plt
• .plt
• rel(a).dyn
• rel(a).plt
• 其他rel(a).xxx节
  刚开始的时候，这些类似的节名很容易让人混淆。其实和我们目标真正相关的是rel(a).plt。其他的让我依次澄清一下。不过都是我个人的理解，可能有偏颇之处。
  先用readelf -S查看一下section header table。
  

PROGBITS is stored in the disk image, as opposed to allocated and initialized at load.
节区类型：PROGBITS-程序定义的信息，NOBITS-不占用文件空间(bss),REL-重定位表项

对于各节区，[2]中的解释为：

• .plt: For dynamic binaries, this Procedure Linkage Table holds the trampoline/linkage code. See paragraphs below.
• .got: For dynamic binaries, this Global Offset Table holds the addresses of variables which are relocated upon loading.
• .got.plt: For dynamic binaries, this Global Offset Table holds the addresses of functions in dynamic libraries. They are used by trampoline code in .plt section.

对于.plt.got区网上搜到的解释是：

• This just seems to contain code to jump to the first entry of the .got.

这里很容易让人有很混乱的感觉，又是.got.plt的, 又是.plt.got的。网络上也很难查到两者之间的联系和区别。根据我个人的实验经验，后文尝试解释一下。先对这几个节区做一个总结。

• 这4个都是编译时决定的，节类型都是PROGBITS。信息都是存在可执行文件里，而runtime可用的信息都是通过重定向得到的，即通过rel(a).xxx节区获得的内存地址中存储的数据
• 所有以.plt开头的节区，都是一些跳板代码。
• 所有以.got开头的节区，都是一些数据，存储着这些函数被resolve后最终的地址。
• .plt开头表项的跳板代码，就是跳转到对应的.got表项中决定最终的执行地址。

# table of a dynamic library (.so)
  [10] .plt              PROGBITS         0000000000000610  00000610
  [11] .plt.got          PROGBITS         0000000000000640  00000640
  [20] .got              PROGBITS         0000000000200fc0  00000fc0
  [21] .got.plt          PROGBITS         0000000000201000  00001000

.plt vs .plt.got

先上2个例子，分别是.plt和.plt.got节的。可以看出，这2个节都是一些跳转代码。按照前文的解释，.plt节表项就是需要动态链接的一些函数的跳板代码。跳转代码的目的地是GOT表项。然后通过runtime linker（ld.so)来完成函数地址的解析。
.plt.got的内容与.plt非常类似，也是一些跳板代码。而且jmpq指令后，没有push指令和另一条jmpq指令。这个节和.plt节到底有啥区别？啥时候会用到该节的跳转指令？

# .plt节举例
00000000000008c0 <fopen@plt>:
 8c0:	ff 25 ea 16 20 00    	jmpq   *0x2016ea(%rip)        # 201fb0 <fopen@GLIBC_2.2.5>
 8c6:	68 09 00 00 00       	pushq  $0x9
 8cb:	e9 50 ff ff ff       	jmpq   820 <.plt>


# .plt.got节举例
00000000000005d0 <fopen@plt>:
 5d0:	ff 25 12 0a 20 00    	jmpq   *0x200a12(%rip)        # 200fe8 <fopen@GLIBC_2.2.5>
 5d6:	66 90                	xchg   %ax,%ax

经过我的实验发现，当发生类似这种函数指针赋值时，动态链接函数就会出现在.plt.got节，同时.plt节中就不再包含这个函数。

FuncPuts old_puts = NULL;
old_puts = puts; // puts as a function pointer, assigned to a variable

当函数不在.plt节时，函数的跳转变成静态的了。用objdump -S对照汇编和源码，可以发现，对此类函数的调用就是跳转到对应的.plt.got表项。

puts("hello");
 751:   48 8d 3d 8c 00 00 00    lea    0x8c(%rip),%rdi        # 7e4 <_fini+0x14>
 758:   e8 e3 fe ff ff          callq  640 <puts@plt>
 
 # 对应的.plt.got表项
 0000000000000640 <puts@plt>:
 640:   ff 25 82 09 20 00       jmpq   *0x200982(%rip)        # 200fc8 <puts@GLIBC_2.2.5>
 646:   66 90                   xchg   %ax,%ax 

注: xchg %ax, %ax是一条NOP指令，参看Why does Visual Studio use xchg ax,ax

当只有.plt.got包含该函数表项时，我们的GOT替换魔法就失效了。所以如果想保存原函数指针，正确的做法应当是：

// Don't do like this.
// It will kick puts from .plt and put it into .plt.got.
// We might not be able to substitute its address via rel tables.
// old_puts = puts; 

// Below is RECOMMENDED!!!
if (old_puts == NULL) { // save original libc function pointer
    old_puts = (FuncPuts)*(uint64_t *)(rel_table[i].r_offset + base_addr);
}
*(uint64_t *)(rel_table[i].r_offset + base_addr) = (uint64_t)my_puts;

.got vs .got.plt

按照前文的解释，.got节存储的是需要动态resolve的变量（应当是动态库中定义的全局变量）。而.got.plt是对应.plt节的函数地址表项。
实际的实验结果是：

• 对于可执行文件，.got.plt不存在，而.plt表项直接跳转到.got表项执行。函数的GOT表位置（GLOBAL_OFFSET_TABLE）在0x201f50

> objdump -d --section=.plt mytest 

mytest：     文件格式 elf64-x86-64

Disassembly of section .plt:

0000000000000820 <.plt>:
 820:   ff 35 32 17 20 00       pushq  0x201732(%rip)        # 201f58 <_GLOBAL_OFFSET_TABLE_+0x8>
 826:   ff 25 34 17 20 00       jmpq   *0x201734(%rip)        # 201f60 <_GLOBAL_OFFSET_TABLE_+0x10>
 82c:   0f 1f 40 00             nopl   0x0(%rax)
 
 > objdump -d --section=.got mytest    

mytest：     文件格式 elf64-x86-64

Disassembly of section .got:

0000000000201f50 <_GLOBAL_OFFSET_TABLE_>:
  201f50:       50 1d 20 00 00 00 00 00 00 00 00 00 00 00 00 00
        ...

• 对于一个动态链接库文件，则如前文所述一致，即.got负责跳转变量，而.got.plt负责跳转函数。函数的GOT表位置（GLOBAL_OFFSET_TABLE）在0x201000

> objdump -d --section=.plt libtest.so    

libtest.so：     文件格式 elf64-x86-64

Disassembly of section .plt:

0000000000000610 <.plt>:
 610:   ff 35 f2 09 20 00       pushq  0x2009f2(%rip)        # 201008 <_GLOBAL_OFFSET_TABLE_+0x8>
 616:   ff 25 f4 09 20 00       jmpq   *0x2009f4(%rip)        # 201010 <_GLOBAL_OFFSET_TABLE_+0x10>
 61c:   0f 1f 40 00             nopl   0x0(%rax)

> objdump -d --section=.got.plt libtest.so    

libtest.so：     文件格式 elf64-x86-64

Disassembly of section .got.plt:

0000000000201000 <_GLOBAL_OFFSET_TABLE_>:
  201000:       00 0e 20 00 00 00 00 00 00 00 00 00 00 00 00 00 
        ...

但其实，我们需要关注的是重定向的表格，而不是直接查看.got和.got.plt节区。后文会进一步解释。而在真正的GOT表项替换中，可执行文件和动态链接库并没有表现出什么不同。

Rerwrite GOT

重写GOT表项的思路就是前面讲述的PLT+GOT动态解析函数地址的方法。而覆写的方法是通过重定向表格找到GOT表，并找到对应的表项索引，修改该索引处的内存。流程大致如下：

<svg id="dafxb9aar0a" width="100%" xmlns="http://www.w3.org/2000/svg" style="max-width: 959.71875px;" viewBox="0 0 959.71875 954.9812469482422"><style>


#dafxb9aar0a .label {
  font-family: 'trebuchet ms', verdana, arial;
  color: #333; }

#dafxb9aar0a .node rect,
#dafxb9aar0a .node circle,
#dafxb9aar0a .node ellipse,
#dafxb9aar0a .node polygon {
  fill: #ECECFF;
  stroke: #9370DB;
  stroke-width: 1px; }

#dafxb9aar0a .node.clickable {
  cursor: pointer; }

#dafxb9aar0a .arrowheadPath {
  fill: #333333; }

#dafxb9aar0a .edgePath .path {
  stroke: #333333;
  stroke-width: 1.5px; }

#dafxb9aar0a .edgeLabel {
  background-color: #e8e8e8; }

#dafxb9aar0a .cluster rect {
  fill: #ffffde !important;
  stroke: #aaaa33 !important;
  stroke-width: 1px !important; }

#dafxb9aar0a .cluster text {
  fill: #333; }

#dafxb9aar0a div.mermaidTooltip {
  position: absolute;
  text-align: center;
  max-width: 200px;
  padding: 2px;
  font-family: 'trebuchet ms', verdana, arial;
  font-size: 12px;
  background: #ffffde;
  border: 1px solid #aaaa33;
  border-radius: 2px;
  pointer-events: none;
  z-index: 100; }

#dafxb9aar0a .actor {
  stroke: #CCCCFF;
  fill: #ECECFF; }

#dafxb9aar0a text.actor {
  fill: black;
  stroke: none; }

#dafxb9aar0a .actor-line {
  stroke: grey; }

#dafxb9aar0a .messageLine0 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  stroke: #333; }

#dafxb9aar0a .messageLine1 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  stroke: #333; }

#dafxb9aar0a #arrowhead {
  fill: #333; }

#dafxb9aar0a #crosshead path {
  fill: #333 !important;
  stroke: #333 !important; }

#dafxb9aar0a .messageText {
  fill: #333;
  stroke: none; }

#dafxb9aar0a .labelBox {
  stroke: #CCCCFF;
  fill: #ECECFF; }

#dafxb9aar0a .labelText {
  fill: black;
  stroke: none; }

#dafxb9aar0a .loopText {
  fill: black;
  stroke: none; }

#dafxb9aar0a .loopLine {
  stroke-width: 2;
  stroke-dasharray: '2 2';
  stroke: #CCCCFF; }

#dafxb9aar0a .note {
  stroke: #aaaa33;
  fill: #fff5ad; }

#dafxb9aar0a .noteText {
  fill: black;
  stroke: none;
  font-family: 'trebuchet ms', verdana, arial;
  font-size: 14px; }

#dafxb9aar0a .activation0 {
  fill: #f4f4f4;
  stroke: #666; }

#dafxb9aar0a .activation1 {
  fill: #f4f4f4;
  stroke: #666; }

#dafxb9aar0a .activation2 {
  fill: #f4f4f4;
  stroke: #666; }


#dafxb9aar0a .section {
  stroke: none;
  opacity: 0.2; }

#dafxb9aar0a .section0 {
  fill: rgba(102, 102, 255, 0.49); }

#dafxb9aar0a .section2 {
  fill: #fff400; }

#dafxb9aar0a .section1,
#dafxb9aar0a .section3 {
  fill: white;
  opacity: 0.2; }

#dafxb9aar0a .sectionTitle0 {
  fill: #333; }

#dafxb9aar0a .sectionTitle1 {
  fill: #333; }

#dafxb9aar0a .sectionTitle2 {
  fill: #333; }

#dafxb9aar0a .sectionTitle3 {
  fill: #333; }

#dafxb9aar0a .sectionTitle {
  text-anchor: start;
  font-size: 11px;
  text-height: 14px; }


#dafxb9aar0a .grid .tick {
  stroke: lightgrey;
  opacity: 0.3;
  shape-rendering: crispEdges; }

#dafxb9aar0a .grid path {
  stroke-width: 0; }


#dafxb9aar0a .today {
  fill: none;
  stroke: red;
  stroke-width: 2px; }



#dafxb9aar0a .task {
  stroke-width: 2; }

#dafxb9aar0a .taskText {
  text-anchor: middle;
  font-size: 11px; }

#dafxb9aar0a .taskTextOutsideRight {
  fill: black;
  text-anchor: start;
  font-size: 11px; }

#dafxb9aar0a .taskTextOutsideLeft {
  fill: black;
  text-anchor: end;
  font-size: 11px; }


#dafxb9aar0a .taskText0,
#dafxb9aar0a .taskText1,
#dafxb9aar0a .taskText2,
#dafxb9aar0a .taskText3 {
  fill: white; }

#dafxb9aar0a .task0,
#dafxb9aar0a .task1,
#dafxb9aar0a .task2,
#dafxb9aar0a .task3 {
  fill: #8a90dd;
  stroke: #534fbc; }

#dafxb9aar0a .taskTextOutside0,
#dafxb9aar0a .taskTextOutside2 {
  fill: black; }

#dafxb9aar0a .taskTextOutside1,
#dafxb9aar0a .taskTextOutside3 {
  fill: black; }


#dafxb9aar0a .active0,
#dafxb9aar0a .active1,
#dafxb9aar0a .active2,
#dafxb9aar0a .active3 {
  fill: #bfc7ff;
  stroke: #534fbc; }

#dafxb9aar0a .activeText0,
#dafxb9aar0a .activeText1,
#dafxb9aar0a .activeText2,
#dafxb9aar0a .activeText3 {
  fill: black !important; }


#dafxb9aar0a .done0,
#dafxb9aar0a .done1,
#dafxb9aar0a .done2,
#dafxb9aar0a .done3 {
  stroke: grey;
  fill: lightgrey;
  stroke-width: 2; }

#dafxb9aar0a .doneText0,
#dafxb9aar0a .doneText1,
#dafxb9aar0a .doneText2,
#dafxb9aar0a .doneText3 {
  fill: black !important; }


#dafxb9aar0a .crit0,
#dafxb9aar0a .crit1,
#dafxb9aar0a .crit2,
#dafxb9aar0a .crit3 {
  stroke: #ff8888;
  fill: red;
  stroke-width: 2; }

#dafxb9aar0a .activeCrit0,
#dafxb9aar0a .activeCrit1,
#dafxb9aar0a .activeCrit2,
#dafxb9aar0a .activeCrit3 {
  stroke: #ff8888;
  fill: #bfc7ff;
  stroke-width: 2; }

#dafxb9aar0a .doneCrit0,
#dafxb9aar0a .doneCrit1,
#dafxb9aar0a .doneCrit2,
#dafxb9aar0a .doneCrit3 {
  stroke: #ff8888;
  fill: lightgrey;
  stroke-width: 2;
  cursor: pointer;
  shape-rendering: crispEdges; }

#dafxb9aar0a .doneCritText0,
#dafxb9aar0a .doneCritText1,
#dafxb9aar0a .doneCritText2,
#dafxb9aar0a .doneCritText3 {
  fill: black !important; }

#dafxb9aar0a .activeCritText0,
#dafxb9aar0a .activeCritText1,
#dafxb9aar0a .activeCritText2,
#dafxb9aar0a .activeCritText3 {
  fill: black !important; }

#dafxb9aar0a .titleText {
  text-anchor: middle;
  font-size: 18px;
  fill: black; }

#dafxb9aar0a g.classGroup text {
  fill: #9370DB;
  stroke: none;
  font-family: 'trebuchet ms', verdana, arial;
  font-size: 10px; }

#dafxb9aar0a g.classGroup rect {
  fill: #ECECFF;
  stroke: #9370DB; }

#dafxb9aar0a g.classGroup line {
  stroke: #9370DB;
  stroke-width: 1; }

#dafxb9aar0a .classLabel .box {
  stroke: none;
  stroke-width: 0;
  fill: #ECECFF;
  opacity: 0.5; }

#dafxb9aar0a .classLabel .label {
  fill: #9370DB;
  font-size: 10px; }

#dafxb9aar0a .relation {
  stroke: #9370DB;
  stroke-width: 1;
  fill: none; }

#dafxb9aar0a #compositionStart {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dafxb9aar0a #compositionEnd {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dafxb9aar0a #aggregationStart {
  fill: #ECECFF;
  stroke: #9370DB;
  stroke-width: 1; }

#dafxb9aar0a #aggregationEnd {
  fill: #ECECFF;
  stroke: #9370DB;
  stroke-width: 1; }

#dafxb9aar0a #dependencyStart {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dafxb9aar0a #dependencyEnd {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dafxb9aar0a #extensionStart {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dafxb9aar0a #extensionEnd {
  fill: #9370DB;
  stroke: #9370DB;
  stroke-width: 1; }

#dafxb9aar0a .commit-id,
#dafxb9aar0a .commit-msg,
#dafxb9aar0a .branch-label {
  fill: lightgrey;
  color: lightgrey; }



#dafxb9aar0a .label{
  color:#18B14E;
}
#dafxb9aar0a .te-md-container--dark .node rect {
  fill: red;
}

#dafxb9aar0a .node rect,
#dafxb9aar0a .node circle,
#dafxb9aar0a .node ellipse,
#dafxb9aar0a .node polygon {
  fill: #F9FFFB;;
  stroke: #2DBD60;
  stroke-width: 1.5px;
}
#dafxb9aar0a .arrowheadPath{
  fill: #2DBD60;
}
#dafxb9aar0a .edgePath .path {
  stroke: #2DBD60;
  stroke-width: 1px;
}
#dafxb9aar0a .edgeLabel {
  background-color: #fff;
}
#dafxb9aar0a .cluster rect {
  fill: #F9FFFB !important;
  stroke: #2DBD60 !important;
  stroke-width: 1px !important;
}

#dafxb9aar0a .cluster text {
  fill: #F9FFFB;
}

#dafxb9aar0a div.mermaidTooltip {
  background: #F9FFFB;
  border: 1px solid #2DBD60;
}


#dafxb9aar0a .actor {
  stroke: #2DBD60;
  fill: #F9FFFB;
}

#dafxb9aar0a text.actor {
  fill: #2DBD60;
  stroke: none;
}

#dafxb9aar0a .actor-line {
  stroke: #2DBD60;
}

#dafxb9aar0a .messageLine0 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  marker-end: 'url(#arrowhead)';
  stroke: #2DBD60;
}

#dafxb9aar0a .messageLine1 {
  stroke-width: 1.5;
  stroke-dasharray: '2 2';
  stroke: #2DBD60;
}

#dafxb9aar0a #arrowhead {
  fill: #2DBD60;
}

#dafxb9aar0a #crosshead path {
  fill: #2DBD60 !important;
  stroke: #2DBD60 !important;
}

#dafxb9aar0a .messageText {
  fill: #2DBD60;
  stroke: none;
}

#dafxb9aar0a .labelBox {
  stroke: #2DBD60;
  fill: #F9FFFB;
}

#dafxb9aar0a .labelText {
  fill: #2DBD60;
  stroke: #2DBD60;
}

#dafxb9aar0a .loopText {
  fill: #2DBD60;
  stroke: #2DBD60;
}

#dafxb9aar0a .loopLine {
  stroke-width: 2;
  stroke-dasharray: '2 2';
  marker-end: 'url(#arrowhead)';
  stroke: #2DBD60;
}

#dafxb9aar0a .note {
  stroke: #2DBD60;
  fill: #F9FFFB;
}

#dafxb9aar0a .noteText {
  fill: #2DBD60;
  stroke: #2DBD60;
}


#dafxb9aar0a .section{
  opacity:1;
}
#dafxb9aar0a .section0,#dafxb9aar0a  .section2 {
  fill: #ECF7F0;
}

#dafxb9aar0a .section1,
#dafxb9aar0a .section3 {
  fill: #FFF;
}
#dafxb9aar0a .taskText0,
#dafxb9aar0a .taskText1,
#dafxb9aar0a .taskText2,
#dafxb9aar0a .taskText3 {
  fill: #fff;
}

#dafxb9aar0a .task0,
#dafxb9aar0a .task1,
#dafxb9aar0a .task2,
#dafxb9aar0a .task3 {
  fill: #2DBD60;
  stroke: #359F5A;
}
</style><style>#dafxb9aar0a {
    color: rgb(244, 244, 244);
    font: normal normal normal normal 14px/22.399999618530273px monospace;
  }</style><g transform="translate(-12, -12)"><g class="output"><g class="clusters"></g><g class="edgePaths"><g class="edgePath" style="opacity: 1;"><path class="path" d="M470.01171875,56.28125L470.01171875,81.28125L470.01171875,106.28125" marker-end="url(#arrowhead4326)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4326" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M470.01171875,142.5625L470.01171875,167.5625L470.01171875,192.5625" marker-end="url(#arrowhead4327)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4327" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M421.32079636001447,228.84375L354.21875,253.84375L354.21875,278.84375" marker-end="url(#arrowhead4328)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4328" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M518.7026411399855,228.84375L585.8046875,253.84375L585.8046875,278.84375" marker-end="url(#arrowhead4329)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4329" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M323.59765625,228.63966376551565L117.859375,253.84375L117.859375,278.84375" marker-end="url(#arrowhead4330)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4330" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M616.42578125,227.48896659045374L846.3046875,253.84375L846.3046875,278.84375" marker-end="url(#arrowhead4331)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4331" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M117.859375,315.125L117.859375,340.125L406.41015625,375.47407907982165" marker-end="url(#arrowhead4332)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4332" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M354.21875,315.125L354.21875,340.125L421.32079636001447,365.125" marker-end="url(#arrowhead4333)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4333" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M585.8046875,315.125L585.8046875,340.125L518.7026411399855,365.125" marker-end="url(#arrowhead4334)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4334" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M846.3046875,315.125L846.3046875,340.125L533.61328125,375.9739363821096" marker-end="url(#arrowhead4335)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4335" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M446.2069848320384,401.40625L402.71875,434.546875L402.71875,467.6875" marker-end="url(#arrowhead4336)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4336" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M402.71875,503.96875L402.71875,537.109375L437.4669191732501,603.7948011026284" marker-end="url(#arrowhead4337)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4337" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M470.51171875,764.5593734741209L470.01171875,797.1999969482422L470.01171875,830.3406219482422" marker-end="url(#arrowhead4338)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4338" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M470.01171875,866.6218719482422L470.01171875,891.6218719482422L470.01171875,916.6218719482422" marker-end="url(#arrowhead4339)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4339" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g><g class="edgePath" style="opacity: 1;"><path class="path" d="M503.5565193674085,603.7947990915301L537.3046875,537.109375L537.3046875,485.828125L537.3046875,434.546875L493.8164526679616,401.40625" marker-end="url(#arrowhead4340)" style="stroke: #333; stroke-width: 1.5px;fill:none"></path><defs><marker id="arrowhead4340" viewBox="0 0 10 10" refX="9" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" orient="auto"><path d="M 0 0 L 10 5 L 0 10 z" class="arrowheadPath" style="stroke-width: 1px; stroke-dasharray: 1px, 0px;"></path></marker></defs></g></g><g class="edgeLabels"><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" transform="translate(402.71875,434.546875)" style="opacity: 1;"><g transform="translate(-52.8125,-8.0078125)" class="label"><rect rx="0" ry="0" width="76.4375" height="16.359375" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1">the ith entry</tspan></text></g></g><g class="edgeLabel" transform="translate(402.71875,537.109375)" style="opacity: 1;"><g transform="translate(-105.46875,-8.0078125)" class="label"><rect rx="0" ry="0" width="167.03125" height="16.359375" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1">name index in symbol entry</tspan></text></g></g><g class="edgeLabel" transform="translate(470.01171875,797.1999969482422)" style="opacity: 1;"><g transform="translate(-4.203125,-8.0078125)" class="label"><rect rx="0" ry="0" width="8.03125" height="16.359375" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1">Y</tspan></text></g></g><g class="edgeLabel" transform="" style="opacity: 1;"><g transform="translate(0,0)" class="label"><rect rx="0" ry="0" width="0" height="0" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1"></tspan></text></g></g><g class="edgeLabel" transform="translate(537.3046875,485.828125)" style="opacity: 1;"><g transform="translate(-4.203125,-8.0078125)" class="label"><rect rx="0" ry="0" width="8.984375" height="16.359375" style="fill:#e8e8e8;"></rect><text><tspan xml:space="preserve" dy="1em" x="1">N</tspan></text></g></g></g><g class="nodes"><g class="node" id="A" transform="translate(470.01171875,38.140625)" style="opacity: 1;"><rect rx="0" ry="0" x="-145.4609375" y="-18.140625" width="290.921875" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-135.4609375,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">get module base from /proc/&lt;pid&gt;/maps file</tspan></text></g></g></g><g class="node" id="B" transform="translate(470.01171875,124.421875)" style="opacity: 1;"><rect rx="0" ry="0" x="-110" y="-18.140625" width="220" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-100,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">Program table is at the beginning</tspan></text></g></g></g><g class="node" id="C" transform="translate(470.01171875,210.703125)" style="opacity: 1;"><rect rx="0" ry="0" x="-146.4140625" y="-18.140625" width="292.828125" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-136.4140625,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">Find .dynamic section in PHT by PT_DYNAMIC</tspan></text></g></g></g><g class="node" id="D" transform="translate(354.21875,296.984375)" style="opacity: 1;"><rect rx="0" ry="0" x="-88.5" y="-18.140625" width="177" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-78.5,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">Get .strtab by DT_STRTAB</tspan></text></g></g></g><g class="node" id="E" transform="translate(585.8046875,296.984375)" style="opacity: 1;"><rect rx="0" ry="0" x="-93.0859375" y="-18.140625" width="186.171875" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-83.0859375,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">Get .symtab by DT_SYMTAB</tspan></text></g></g></g><g class="node" id="F" transform="translate(117.859375,296.984375)" style="opacity: 1;"><rect rx="0" ry="0" x="-97.859375" y="-18.140625" width="195.71875" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-87.859375,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">Get .rel(a).plt by DT_JMPREL</tspan></text></g></g></g><g class="node" id="G" transform="translate(846.3046875,296.984375)" style="opacity: 1;"><rect rx="0" ry="0" x="-117.4140625" y="-18.140625" width="234.828125" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-107.4140625,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">Get .rel(a).plt size by DT_PLTRELSZ</tspan></text></g></g></g><g class="node" id="I" transform="translate(470.01171875,383.265625)" style="opacity: 1;"><rect rx="0" ry="0" x="-63.6015625" y="-18.140625" width="127.203125" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-53.6015625,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">Loop in .rel(a).plt</tspan></text></g></g></g><g class="node" id="J" transform="translate(402.71875,485.828125)" style="opacity: 1;"><rect rx="0" ry="0" x="-95.1171875" y="-18.140625" width="190.234375" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-85.1171875,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">Get symbol entry in .symtab</tspan></text></g></g></g><g class="node" id="H" transform="translate(470.01171875,667.1546859741211)" style="opacity: 1;"><polygon points="96.90468750000001,0 193.80937500000002,-96.90468750000001 96.90468750000001,-193.80937500000002 0,-96.90468750000001" rx="5" ry="5" transform="translate(-96.90468750000001,96.90468750000001)"></polygon><g class="label" transform="translate(0,0)"><g transform="translate(-79.53125,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">Name in .strtab matched ?</tspan></text></g></g></g><g class="node" id="K" transform="translate(470.01171875,848.4812469482422)" style="opacity: 1;"><rect rx="0" ry="0" x="-65.0703125" y="-18.140625" width="130.140625" height="36.28125"></rect><g class="label" transform="translate(0,0)"><g transform="translate(-55.0703125,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">Update table item</tspan></text></g></g></g><g class="node" id="L" transform="translate(470.01171875,937.8015594482422)" style="opacity: 1;"><circle x="-21.1796875" y="-18.140625" r="21.1796875"></circle><g class="label" transform="translate(0,0)"><g transform="translate(-11.1796875,-8.140625)"><text><tspan xml:space="preserve" dy="1em" x="1">End</tspan></text></g></g></g></g></g></g></svg>

我的基础代码来自于[1]，总的项目后面我会更新到zhougy0717/inject_got仓库中。

Get module base

这里要做的其实就是获取对应的image在虚拟内存中的位置。例如：
可执行文件

    // 打开文件/proc/pid/maps，获取指定pid进程加载的内存模块信息
    fp = fopen(filename, "r");
    if(fp != NULL){
        // 每次一行，读取文件 /proc/pid/maps中内容
        while(fgets(line, sizeof(line), fp)){
            // 查找指定的so模块
            if(strstr(line, module_name)){
                // 分割字符串
                pch = strtok(line, "-");
                // 字符串转长整形
                addr = strtoul(pch, NULL, 16);
                break;
            }
        }
    }
    fclose(fp);
    return (void*)addr;

.rel.plt还是.rela.plt

rel和rela是两种relocation type。是rel还是rela会影响到后续选择的数据结构类型。到底该用rel还是rela，是取决于processor type的。而x86_64都是rela类型的，i386和arm32都是rel类型的。除了通过Google来得到rel type，还有更靠谱的方法是，检查.dynamic section的DT_PLTREL字段。

    for(i=0;i < dynamicSize / sizeof(Elf64_Dyn);i ++)
    {
        uint64_t val = dynamic_table[i].d_un.d_val;
        if (dynamic_table[i].d_tag == DT_PLTREL)
        {
            // DT_RELA = 7
            // DT_REL = 17
            relType = dynamic_table[i].d_un.d_val;
        }
    }

从.rel(a).plt index到.strtab index

这一段代码要做的就是找到.rel(a).plt表项所代表的函数的名字。这个函数的名字是存储在.strtab节的。代码大致如下：

    // 获取.rel(a).plt, .symtab, .strtab地址
    for(i=0;i < dynamicSize / sizeof(Elf64_Dyn);i ++)
    {
        uint64_t val = dynamic_table[i].d_un.d_val;
        if (dynamic_table[i].d_tag == DT_JMPREL)
        {
            jmpRelOff = dynamic_table[i].d_un.d_ptr;
        }
        if (dynamic_table[i].d_tag == DT_STRTAB)
        {
            strTabOff = dynamic_table[i].d_un.d_ptr;
        }
        if (dynamic_table[i].d_tag == DT_PLTRELSZ)
        {
            pltRelSz = dynamic_table[i].d_un.d_val;
        }
        if (dynamic_table[i].d_tag == DT_SYMTAB)
        {
            symTabOff = dynamic_table[i].d_un.d_ptr;
        }
    }
    
    Elf64_Rela* rel_table = (Elf64_Rela*)jmpRelOff;
    // 遍历查找要hook的导入函数
    // i ==> .rela.plt item index
    for(i = 0;i < pltRelSz / sizeof(Elf64_Rela);i++)
    {
        int number = ELF64_R_SYM(rel_table[i].r_info); // .symtab index
        Elf64_Sym* symEnt = (Elf64_Sym*)(number*sizeof(Elf64_Sym) + symTabOff);
        char* funcName = (char*)(symEnt->st_name + strTabOff);
        if(strcmp(funcName, "puts") == 0)
        {
            // 获取当前内存分页的大小
            uint64_t page_size = getpagesize();
            // 获取内存分页的起始地址（需要内存对齐）
            uint64_t mem_page_start = (uint64_t)(((Elf64_Addr)rel_table[i].r_offset + (uint64_t)base_addr)) & (~(page_size - 1));
            mprotect((void *)mem_page_start, page_size, PROT_READ | PROT_WRITE | PROT_EXEC);
            *(uint64_t *)(rel_table[i].r_offset + base_addr) = (uint64_t)my_puts; // overwrite GOT item
            break;
        }
    }

下图就是上面这段代码的示意图。

• 在解析.dynamic节，获取.rel(a).plt, .symtab, .strtab信息时，要注意的是Elf64_Dyn的定义，它是一个union结构，是区分值类型和指针类型的，其定义如下：

typedef struct {
        Elf64_Xword d_tag;
        union {
                Elf64_Xword     d_val;
                Elf64_Addr      d_ptr;
        } d_un;
} Elf64_Dyn;

在获取内存地址的时候要用d_ptr,而在获取例如DT_PLTRELSZ时，就显然是一个值类型。

• 前面说的relocation type在这里就会发挥作用。.rel(a).plt表项在不同的relocation type的情况下，其数据结构是不同的。他们的结构和尺寸都是不同的。
  • rel是Elf64_Rel
  • rela是Elf64_Rela
• DT_SYMTAB是.symtab节，每一个symbol是一个Elf64_Sym数据结构
• .strtab是所有符号的名字字符串表格。而Elf64_Sym.st_name是表格的偏移地址。注意，不是表格索引。所以获取名字的方法是symEnt->st_name + strTabOff。
• 最后，修改对应的页表属性，然后修改对应的内存地址就可以水到渠成了

参考文献

[1] Android so注入(inject)和Hook技术学习（二）——Got表hook之导入表hook

[2] Executable and Linkable Format

[3] Oracle Documentation

[4] Executable and Linking Format Specification, Version 1.2