😃



### Fuzz Farm

---



#### Fuzz Farm #1

项目1 主要是复现 GEGL 开源库的漏洞挖掘过程

> 项目版本: a566b738331757cf25118af5bdc65218ae5eb3b2



##### 环境配置

```bash
$ git clone https://gitlab.gnome.org/GNOME/gegl.git
$ git checkout a566b
$ sudo pip3 install meson
$ CC=afl-gcc CXX=afl-g++ meson _build
$ ASAN_OPTIONS=detect_leaks=0 AFL_USE_ASAN=1 ninja -C _build
$ ninja -C _build install
```



##### Fuzz 配置

虽然GEGL 提供了一个二进制文件`gegl`但是如果直接对二进制文件进行 Fuzz 可能会出现效率低下的问题 所以这里采用编写harness 的方式来进行`Fuzz`

```c
gint main(gint argc, gchar **argv) {
  GeglNode    *gegl      = NULL;
  gchar       *script    = NULL;
  GError      *err       = NULL;
  gchar       *path_root = NULL;

  // [1]
  gegl_init(NULL, NULL);
  path_root = g_get_current_dir ();

  // [2]
  g_file_get_contents (argv[1], &script, NULL, &err);
  if (err != NULL) {
    return 1;
  }

  // [3]
  gegl = gegl_node_new_from_xml (script, path_root);
  if (!gegl) {
    return 1;
  }

  // [4]
  GeglNode *output = gegl_node_new_child (gegl,
                                          "operation", "gegl:save",
                                          "path", "out.png",
                                          NULL);                              
  gegl_node_connect_from (output, "input", gegl, "output");
  gegl_node_process (output);

  // [5]
  g_object_unref (output);
  g_object_unref (gegl);

  g_free (script);
  g_clear_error (&err);
  g_free (path_root);
  gegl_exit ();

  return 0;
}
```



使用`afl-clang-fast`进行编译即可

```bash
$ afl-clang-fast -o test test.c `pkg-config --cflags --libs gegl-0.4 glib-2.0`
```



语料库使用的是项目内的`tests/compositions`内的文件

```bash
$ afl-fuzz -i ./compositions -o ./out -m none -t 20000 -- ./test @@
```



一会就能跑出 crash (虽然 harness 也快不到哪里去就对了..)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811111459.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811111604.png)



这个时候可以编译出来一版包含 ASAN 的 harness 看看到底是哪里 crash 了

```bash
$ AFL_USE_ASAN=1 afl-clang-fast -o test1 test.c `pkg-config --cflags --libs gegl-0.4 glib-2.0`
```



可以看到与预估漏洞一致 是 crash 在`gegl_path_parse_string`中

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811112129.png)



##### 漏洞 1 - SEGV



可以根据 ASAN 爆出的信息直接定位漏洞所在地 根据GDB 动态调试复现 漏洞实际触发于`../gegl/property-type/gegl-path.c:817`

```c
void
gegl_path_parse_string (GeglPath    *vector,
                        const gchar *path)
{
  GeglPathPrivate *priv = GEGL_PATH_GET_PRIVATE (vector);
  const gchar *p = path;
  InstructionInfo *previnfo = NULL;
  gdouble x0, y0, x1, y1, x2, y2;

  while (*p)
    {
      gchar            type = *p;
      InstructionInfo *info = lookup_instruction_info(type);

      if (!info && ((type>= '0' && type <= '9') || type == '-')) // [1]
        {
          if (previnfo->type == 'M') // here
            {
              info = lookup_instruction_info(type = 'L');
            }
          else if (previnfo->type == 'm')
            {
              info = lookup_instruction_info(type = 'l');
            }
          else if (previnfo->type == ' ')
            g_warning ("EEEK");
        }

      ...
        if (*p)
        p++;
    }

  gegl_path_dirty (vector);
}
```



漏洞成因也很简单`gegl_path_parse_string`主要的作用是针对 xml 中传入的路径 对传入的路径进行上色 例如`<gegl:fill-path path='M100,100 L200,100 L200,200 Z' color=ff0000>` 就是针对`路径 "M100,100 L200,100 L200,200 Z" 定义的区域上红色` 

如果我们传入`<gegl:fill-path path="0">` 可以发现`*p = path = type` 那么此时`type = 0` 可以顺利通过`[1]`处的 if 语句 然后到达 crash 处 

至于为什么 crash 可以发现在函数刚开始`InstructionInfo *previnfo = NULL;`且后面没有对`previnfo`进行赋值导致访问`0x0`地址 导致`SEGV`



##### 漏洞 2 - 资源耗尽漏洞

经过继续的`Fuzz`发现一个资源耗尽漏洞 可以申请`0xfffffffffffd9d7c`大小的堆块 很显然这是一个地址 肯定是在申请堆块之前存在问题

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811114216.png)



可以看到是`g_malloc`之前的问题 直接上`GDB`然后查栈帧

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811145620.png)



很明显问题的调用存在于`datauri_parse_header -> g_strndup -> g_malloc` 重点就是这个`datauri_parse_header`

```c
static gchar **
datauri_parse_header(const gchar *uri, 
                     gchar      **raw_data_out, 
                     gint        *header_items_no_out)
{
  // Determine data format
  const gchar * header_end = g_strstr_len (uri, -1, ","); 
  const gint data_prefix_len = strlen("data:");

  const gint header_len = header_end - uri - data_prefix_len;
  gchar *header = g_strndup(uri+data_prefix_len, header_len);   // here

  gchar **header_items = g_strsplit(header, ";", 3);
  gint header_items_no = -1;
  while (header_items[++header_items_no]) {
  }
  g_free(header);

  if (header_items_no_out)
    {
      *header_items_no_out = header_items_no;
    }

  if (raw_data_out)
    {
      *raw_data_out = (gchar *)uri+data_prefix_len+header_len;
    }
  return header_items;
}
```



经过动态调试很明显问题是出在`header_end`这个值上

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811150058.png)



其中`g_strstr_len(const gchar* haystack, gssize haystack_len, const gchar* needle)`的作用是从`haystack`字符串中搜索`needle`其中最大搜索长度为`haystack_len`

很显然传入的参数`uri`并没有问题 问题主要出现在`g_strstr_len`的调用上

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811150428.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811151739.png)



因为匹配长度是`-1` 也就是`0xffffffffffffffff` 可以简单理解成无穷大 因为 uri 是一个存在栈上的参数 如果 uri 中没有匹配到`,`那近乎就是实现了全栈的搜索 很显然这是不合理的 返回回来的地址自然也是预料之外的 那么当后面调用`str_dup`时 因为长度过大 会申请一个堆块用于存放输出的字符串 很显然这时候申请的堆块长度是不合理的 自然也就造成了资源耗尽

[Fuzz] Fuzz Farm

👍



###  CVE-2023-37176
---
 
##### 版本

```bash
commit 231df822d2ec2096d4ccf8d0b9e6a9c6bbfd3b69 (HEAD -> master, origin/master, origin/HEAD)
Author: Thomas Bernard <miniupnp@free.fr>
Date:   Sat Mar 4 11:48:58 2023 +0100
```



##### 综述

在输入特定构造的gif文件之后可以导致目标`segment fault`





##### 编译方式

```bash
$ CC="${CarpetFuzz}/fuzzer/afl-clang-fast -fsanitize=address -g" CFLAGS+=-DNGIFLIB_NO_FILE make
```



##### 触发方式

```
$ ./gif2tga -i ./poc
```

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627180451.png)



##### 效果

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627172116.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627172136.png)



##### 漏洞分析

漏洞存在于158行中 要求条件使用`NGIFLIB_MODE_INDEXED`其实就是加上`-i`参数 可以看到本身只是一个写入操作 将当前GIF图像的`palette`写入到目标的tga文件中 

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627172247.png)



其中`img`来自113行的`gif->cur_img` 而`gif`来自107行的`err = LoadGif(gif)` 之前的`gif`变量只是一个初始化 对其进行分配内存空间 追入`LoadGif`

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627172428.png)



其中的`cur_img`相关的操作在`ngiflib.c::864`附近 没有看到`palette`相关操作 追入`DecodeGifImg`

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627172946.png)



追入`DecodeGifImg`后 关于`palette`相关操作在494行附近 其分支是由`flags&128`决定的 经过动态调试发现`flags == 0` 直接进入下面的分支 也就是`i->palette = i->parent->palette` 而这个`i->parent`就是上级函数中的`g`

![image-20230627173441273](/Users/du4t/Library/Application Support/typora-user-images/image-20230627173441273.png)

> 经过查询资料 每个GIF图片中都可能包含多个图片信息(废话 不然为啥有GIF动图) 所以为了区分每一帧的图片信息 采用标志位`0x2C`标志着每个图像的开始 然后前4个WORD分别为x偏移量 y偏移量 图像宽 图像高 经过审阅DecodeGIFImg内容发现在483行之前已经读取过相应数据 而`GetByte`和`GetWord`内部有个计数器 类似`fseek`的作用 指定当前读到哪里防止越界读 本来是好心 但是内部审查不严 当可能越界读时不抛出异常而是直接返回0 造成了`flags == 0`



返回上级查看`g->palette` 相关操作在714行附近 分支决定了相关值直接是`NULL`还是从文件中取 

![image-20230627174815393](/Users/du4t/Library/Application Support/typora-user-images/image-20230627174815393.png)



`tmp`相关操作在694行 在此之前对于文件流的操作有`校验文件头和版本` `取宽` `取高` 

![image-20230627174923203](/Users/du4t/Library/Application Support/typora-user-images/image-20230627174923203.png)



那么就是文件中的此位置 经过动态调试确认正确 程序会流向`g->palette = NULL`

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627175043.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627175256.png)



##### 总结

那么至此 因为特定的`flag`导致`GIF的palette属性为NULL` 进而搭配`GetByte`的审查不严格 导致了`GIF下每帧的palette属性都为NULL` 最终在生成tga文件时造成了无效访问 且由此发现该程序对GIF文件结尾特定标志位`0x3B`校验不严格

```c
static u8 GetByte(struct ngiflib_gif * g) {
#ifndef NGIFLIB_NO_FILE
	if(g->mode & NGIFLIB_MODE_FROM_MEM) {
#endif /* NGIFLIB_NO_FILE */
		if (g->input.buffer.count > 0) {
			g->input.buffer.count--;
			return *(g->input.buffer.bytes++);
		} else {
			return 0;
		}
#ifndef NGIFLIB_NO_FILE
	} else {
#ifdef DEBUG
		int c = getc(g->input.file);
		if (c != EOF)
			return (u8)c;
		else {
			if(g->log) fprintf(g->log, "getc() returned EOF !\n");
			return 0;
		}
#else
		return (u8)(getc(g->input.file));
#endif
	}
#endif /* NGIFLIB_NO_FILE */
}
```

[CVE] ngiflib CVE-2023-37176 漏洞分析

[Paper] Blacktooth: Breaking through the Defense of Bluetooth in Silence

🤔




#### 手写数字判断

> 数据集: mnist

##### 简单全连接神经网络

最基础的如果不使用卷积神经网络 而使用全连接神经网络的话 可以简单设计一个架构

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230723111034.jpeg)

```python
def simple_network2():
    EPOCHS = 50
    BATCH_SIZE = 128
    VERBOSE = 1
    NB_CLASSES = 10
    N_HIDDEN = 128
    VALIDATION_SPLIT = 0.2

    mnist = keras.datasets.mnist
    (X_train, Y_train), (X_test, Y_test) = mnist.load_data() # 此时X_train的shape为(60000, 28, 28) 也就是每张图像为一个二维数组 表示对应位置的像素值

    RESHAPED = 784
    X_train = X_train.reshape(60000, RESHAPED) # 将训练集重新reshape成为一个一维数组 便于输入到神经网络中
    X_test = X_test.reshape(10000, RESHAPED) # 将测试集进行相同操作
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')

    X_train, X_test = X_train / 255.0, X_test / 255.0 # 归一化处理 将一个像素值的范围缩小到0~1之间 这样做的好处是提高模型的收敛速度和稳定性

    Y_train = tf.keras.utils.to_categorical(Y_train, NB_CLASSES) # 将其转化为one_hot类型
    Y_test = tf.keras.utils.to_categorical(Y_test, NB_CLASSES)

    model = tf.keras.models.Sequential() # 层与层之间顺序执行
    model.add(keras.layers.Dense(N_HIDDEN, input_shape=(RESHAPED,), name='dense_layer', activation='relu'))
    '''
    N_HIDDEN: 神经元数量
    input_shape: 指定了输入数据的形状 这里我们输入的肯定是上面已经reshape成一维数组的训练集数据
    name: 指定了该层的名称
    activation: 激活函数
    '''
    model.add(keras.layers.Dense(N_HIDDEN, name='dense_layer2', activation='relu')) # 后续的层会自动推断输入形状
    model.add(keras.layers.Dense(NB_CLASSES, name='dense_layer3', activation='softmax')) # 输出层 神经元个数为数据种类
    model.summary()
    model.compile(optimizer='SGD', loss='categorical_crossentropy', metrics=['accuracy'])
    '''
    compile() 设定训练参数 将所有层编译到一起
    optimizer: 优化器类型 这里使用的是随机梯度下降(SGD)
    loss: 损失函数 这里使用的是分类交叉熵(categorical_crossentropy)
    metrics: 衡量指标 这里使用的是准确率(accuracy)
    '''

    history = model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=VERBOSE, validation_split=VALIDATION_SPLIT)
    '''
    fit() 开始训练
    X_train: 输入的训练集数据
    Y_train: 对应训练集的标签数据
    batch_size: 单次输入到神经网络的数据个数
    epochs: 数据集重复次数
    verbose: 日志详细程度 0-2
    validation_split: 从训练集中划分一部分为测试集
    '''
    model.save('mnist_model.h5') # 保存模型
    train_acc = history.history['accuracy']
    val_acc = history.history['val_accuracy']
    train_loss = history.history['loss']
    val_loss = history.history['val_loss']

    # 绘制准确率曲线
    plt.plot(range(1, len(train_acc) + 1), train_acc, label='Training Accuracy')
    plt.plot(range(1, len(val_acc) + 1), val_acc, label='Validation Accuracy')
    plt.title('Training and Validation Accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.show()

    # 绘制损失曲线
    plt.plot(range(1, len(train_loss) + 1), train_loss, label='Training Loss')
    plt.plot(range(1, len(val_loss) + 1), val_loss, label='Validation Loss')
    plt.title('Training and Validation Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.show()

    test_loss, test_acc = model.evaluate(X_test, Y_test)
    '''
    evaluate() 使用测试集对训练出来的模型进行评估
    X_test: 测试集数据
    Y_test: 测试集标签
    '''
    print("Accuracy: ", test_acc)
```

可以看到随着训练次数的增加 准确率在不断上升 虽然最后通过总览来看 发生了过拟合 但是影响不大 后面我们再改善这个问题

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230722161134.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230722161237.png)

此时在测试集上的准确率为`96%`左右

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230723105149.png)



这里就可以引入Dropout机制 在训练时随机使神经元失效 这样可以让其他神经元认为"除自己之外的神经元状况都不可靠" 即尽最大能力提高鲁棒性 代码层面改变很简单 在层与层之间新加Dropout层即可

```python
def simple_network2():
    EPOCHS = 50
    BATCH_SIZE = 128
    VERBOSE = 1
    NB_CLASSES = 10
    N_HIDDEN = 128
    VALIDATION_SPLIT = 0.2
    DROPOUT = 0.3
    mnist = keras.datasets.mnist
    (X_train, Y_train), (X_test, Y_test) = mnist.load_data() # 此时X_train的shape为(60000, 28, 28) 也就是每张图像为一个二维数组 表示对应位置的像素值

    RESHAPED = 784
    X_train = X_train.reshape(60000, RESHAPED) # 将训练集重新reshape成为一个一维数组 便于输入到神经网络中
    X_test = X_test.reshape(10000, RESHAPED) # 将测试集进行相同操作
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')

    X_train, X_test = X_train / 255.0, X_test / 255.0 # 归一化处理 将一个像素值的范围缩小到0~1之间 这样做的好处是提高模型的收敛速度和稳定性

    Y_train = tf.keras.utils.to_categorical(Y_train, NB_CLASSES) # 将其转化为one_hot类型
    Y_test = tf.keras.utils.to_categorical(Y_test, NB_CLASSES)

    model = tf.keras.models.Sequential() # 层与层之间顺序执行
    model.add(keras.layers.Dense(N_HIDDEN, input_shape=(RESHAPED,), name='dense_layer', activation='relu'))
    '''
    N_HIDDEN: 神经元数量
    input_shape: 指定了输入数据的形状 这里我们输入的肯定是上面已经reshape成一维数组的训练集数据
    name: 指定了该层的名称
    activation: 激活函数
    '''
    model.add(keras.layers.Dropout(DROPOUT))
    model.add(keras.layers.Dense(N_HIDDEN, name='dense_layer2', activation='relu')) # 后续的层会自动推断输入形状
    model.add(keras.layers.Dropout(DROPOUT)) # dropout层 防止过拟合
    model.add(keras.layers.Dense(NB_CLASSES, name='dense_layer3', activation='softmax')) # 输出层 神经元个数为数据种类
    model.summary()
    model.compile(optimizer='SGD', loss='categorical_crossentropy', metrics=['accuracy'])
    '''
    compile() 设定训练参数 将所有层编译到一起
    optimizer: 优化器类型 这里使用的是随机梯度下降(SGD)
    loss: 损失函数 这里使用的是分类交叉熵(categorical_crossentropy)
    metrics: 衡量指标 这里使用的是准确率(accuracy)
    '''

    history = model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=VERBOSE, validation_split=VALIDATION_SPLIT)
    '''
    fit() 开始训练
    X_train: 输入的训练集数据
    Y_train: 对应训练集的标签数据
    batch_size: 单次输入到神经网络的数据个数
    epochs: 数据集重复次数
    verbose: 日志详细程度 0-2
    validation_split: 从训练集中划分一部分为测试集
    '''
    model.save('mnist_model.h5') # 保存模型
    train_acc = history.history['accuracy']
    val_acc = history.history['val_accuracy']
    train_loss = history.history['loss']
    val_loss = history.history['val_loss']

    # 绘制准确率曲线
    plt.plot(range(1, len(train_acc) + 1), train_acc, label='Training Accuracy')
    plt.plot(range(1, len(val_acc) + 1), val_acc, label='Validation Accuracy')
    plt.title('Training and Validation Accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.show()

    # 绘制损失曲线
    plt.plot(range(1, len(train_loss) + 1), train_loss, label='Training Loss')
    plt.plot(range(1, len(val_loss) + 1), val_loss, label='Validation Loss')
    plt.title('Training and Validation Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.show()

    test_loss, test_acc = model.evaluate(X_test, Y_test)
    '''
    evaluate() 使用测试集对训练出来的模型进行评估
    X_test: 测试集数据
    Y_test: 测试集标签
    '''
    print("Accuracy: ", test_acc)
```

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230722163645.png)



很显然我们成功抑制了过拟合现象 提高了模型的泛化能力 此时验证集准确率全程高于训练集是使用Dropout层正常现象 这里稍微修改一下源码 让其可以直接加载之前存在的模型进行训练 当然此时的模型准确率依然堪忧

```python
def simple_network2():
    EPOCHS = 200
    BATCH_SIZE = 128
    VERBOSE = 1
    NB_CLASSES = 10
    N_HIDDEN = 128
    VALIDATION_SPLIT = 0.2
    DROPOUT = 0.3
    mnist = keras.datasets.mnist
    (X_train, Y_train), (X_test, Y_test) = mnist.load_data() # 此时X_train的shape为(60000, 28, 28) 也就是每张图像为一个二维数组 表示对应位置的像素值

    RESHAPED = 784
    X_train = X_train.reshape(60000, RESHAPED) # 将训练集重新reshape成为一个一维数组 便于输入到神经网络中
    X_test = X_test.reshape(10000, RESHAPED) # 将测试集进行相同操作
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')

    X_train, X_test = X_train / 255.0, X_test / 255.0 # 归一化处理 将一个像素值的范围缩小到0~1之间 这样做的好处是提高模型的收敛速度和稳定性

    Y_train = tf.keras.utils.to_categorical(Y_train, NB_CLASSES) # 将其转化为one_hot类型
    Y_test = tf.keras.utils.to_categorical(Y_test, NB_CLASSES)
    try:
        model = tf.keras.models.load_model('mnist_model.h5')
    except:
        model = tf.keras.models.Sequential() # 层与层之间顺序执行
        model.add(keras.layers.Dense(N_HIDDEN, input_shape=(RESHAPED,), name='dense_layer', activation='relu'))
        '''
        N_HIDDEN: 神经元数量
        input_shape: 指定了输入数据的形状 这里我们输入的肯定是上面已经reshape成一维数组的训练集数据
        name: 指定了该层的名称
        activation: 激活函数
        '''
        model.add(keras.layers.Dropout(DROPOUT))
        model.add(keras.layers.Dense(N_HIDDEN, name='dense_layer2', activation='relu')) # 后续的层会自动推断输入形状
        model.add(keras.layers.Dropout(DROPOUT)) # dropout层 防止过拟合
        model.add(keras.layers.Dense(NB_CLASSES, name='dense_layer3', activation='softmax')) # 输出层 神经元个数为数据种类
        model.summary()
        model.compile(optimizer='SGD', loss='categorical_crossentropy', metrics=['accuracy'])
        '''
        compile() 设定训练参数 将所有层编译到一起
        optimizer: 优化器类型 这里使用的是随机梯度下降(SGD)
        loss: 损失函数 这里使用的是分类交叉熵(categorical_crossentropy)
        metrics: 衡量指标 这里使用的是准确率(accuracy)
        '''

    history = model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=VERBOSE, validation_split=VALIDATION_SPLIT)
    '''
    fit() 开始训练
    X_train: 输入的训练集数据
    Y_train: 对应训练集的标签数据
    batch_size: 单次输入到神经网络的数据个数
    epochs: 数据集重复次数
    verbose: 日志详细程度 0-2
    validation_split: 从训练集中划分一部分为测试集
    '''
    model.save('mnist_model.h5') # 保存模型
    train_acc = history.history['accuracy']
    val_acc = history.history['val_accuracy']
    train_loss = history.history['loss']
    val_loss = history.history['val_loss']

    # 绘制准确率曲线
    plt.plot(range(1, len(train_acc) + 1), train_acc, label='Training Accuracy')
    plt.plot(range(1, len(val_acc) + 1), val_acc, label='Validation Accuracy')
    plt.title('Training and Validation Accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.show()

    # 绘制损失曲线
    plt.plot(range(1, len(train_loss) + 1), train_loss, label='Training Loss')
    plt.plot(range(1, len(val_loss) + 1), val_loss, label='Validation Loss')
    plt.title('Training and Validation Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.show()

    test_loss, test_acc = model.evaluate(X_test, Y_test)
    '''
    evaluate() 使用测试集对训练出来的模型进行评估
    X_test: 测试集数据
    Y_test: 测试集标签
    '''
    print("Accuracy: ", test_acc)
```

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230723105451.png)



##### 卷积神经网络

可以简单设计一个架构 即 卷积层 -> 池化层 -> 卷积层 -> 池化层 -> Flatten层 -> 全连接层

> 卷积层: 卷积网络内最重要的层 利用卷积核对图像特征进行识别 用于学习特征
>
> 池化层: 降低特征图的空间分辨率 减少计算量
>
> Flatten层: 在卷积神经网络内 图像是二维数组的形式进行传递学习 在传入全连接层之前需要将其平展为一维数组

```python
def con_network():
    EPOCHS = 200
    BATCH_SIZE = 128
    VERBOSE = 1
    NB_CLASSES = 10
    VALIDATION_SPLIT = 0.2
    DROPOUT = 0.3
    mnist = keras.datasets.mnist
    (X_train, Y_train), (X_test, Y_test) = mnist.load_data() # 此时X_train的shape为(60000, 28, 28) 也就是每张图像为一个二维数组 表示对应位置的像素值

    RESHAPED = 784
    

    X_train, X_test = X_train / 255.0, X_test / 255.0 # 归一化处理 将一个像素值的范围缩小到0~1之间 这样做的好处是提高模型的收敛速度和稳定性
    X_train = X_train[..., tf.newaxis]
    X_test = X_test[..., tf.newaxis]

    Y_train = tf.keras.utils.to_categorical(Y_train, NB_CLASSES) # 将其转化为one_hot类型
    Y_test = tf.keras.utils.to_categorical(Y_test, NB_CLASSES)

    try:
        model = tf.keras.models.load_model('con_mnist_model.h5')
    except:
        model = tf.keras.models.Sequential() # 层与层之间顺序执行
        model.add(keras.layers.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))
        model.add(keras.layers.MaxPool2D(pool_size=(2, 2)))
        model.add(keras.layers.Conv2D(64, kernel_size=(3, 3), activation='relu'))
        model.add(keras.layers.MaxPool2D(pool_size=(2, 2)))
        model.add(keras.layers.Flatten())
        model.add(keras.layers.Dense(64, activation='relu'))
        model.add(keras.layers.Dense(10, activation='softmax'))
        model.summary()
        model.compile(optimizer='SGD', loss='categorical_crossentropy', metrics=['accuracy'])
    history = model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=VERBOSE, validation_split=VALIDATION_SPLIT)
    model.save('con_mnist_model.h5') # 保存模型

    train_acc = history.history['accuracy']
    val_acc = history.history['val_accuracy']
    train_loss = history.history['loss']
    val_loss = history.history['val_loss']

    # 绘制准确率曲线
    plt.plot(range(1, len(train_acc) + 1), train_acc, label='Training Accuracy')
    plt.plot(range(1, len(val_acc) + 1), val_acc, label='Validation Accuracy')
    plt.title('Training and Validation Accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.show()

    # 绘制损失曲线
    plt.plot(range(1, len(train_loss) + 1), train_loss, label='Training Loss')
    plt.plot(range(1, len(val_loss) + 1), val_loss, label='Validation Loss')
    plt.title('Training and Validation Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.show()

    test_loss, test_acc = model.evaluate(X_test, Y_test)
    '''
    evaluate() 使用测试集对训练出来的模型进行评估
    X_test: 测试集数据
    Y_test: 测试集标签
    '''
    print("Accuracy: ", test_acc)
```

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230723110710.png)



此时准确率提升到了`98%`

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230723110722.png)