godot+c#操作sqlite并加解密

相与还2025-09-15 10:45

前言

在前面一篇文章，我已经写好了如何godot+c#使用godot-sqlite连接数据库

但是这会有一个问题，当对这个数据库有了解的人，很容易就可以实现篡改游戏数据.

因此，本次将对其进行加解密访问

注意点

需要注意的是，经过测试，本次的sqlite不需要依赖godot-sqlite依赖包,完全依赖c#的sqlite库

如下我打包

我的项目未引入godot-sqlite

启动打包后的文件，成功执行sqlite的数据库

步骤

加解密

依赖安装

  • 和前面文章一样，我们需要引入加解密的依赖。
  • 同样，找到你建立的godot游戏项目,找到有csproj格式文件的目录

  • 使用cmd命令行执行如下指令

    dotnet add package Microsoft.Data.Sqlite.Core
    dotnet add package SQLitePCLRaw.bundle_e_sqlcipher

  • 假如有看我前一个文章的进行安装的,需要卸载掉旧的引用防止程序抓的包异常，卸载命令行如下

    dotnet remove package System.Data.SQLite.Core

  • 执行安装之后，你会看到csproj文件内容应该是这样的

csharp 复制代码 
<Project Sdk="Godot.NET.Sdk/4.4.1">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <EnableDynamicLoading>true</EnableDynamicLoading>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.Data.Sqlite.Core" Version="9.0.9" />
    <PackageReference Include="SQLitePCLRaw.bundle_e_sqlcipher" Version="2.1.11" />
  </ItemGroup>
</Project>

代码调整

注意：因为已经换成了c#的sqlite库，所以完全不依赖godot-sqlite

  • 同样，我们有四个文件，采取和java的jdbc一样的模式，来访问数据库
DBConnection.cs

该代码是关于sqlite的数据库连接配置代码,里面设置了加密密钥_encryptionKey,该值根据自己来设定,相当于访问密码

  • 代码如下
csharp 复制代码 
using System;
using Microsoft.Data.Sqlite;
using Godot;
using System.IO;

public static class DBConnection
{
    private static SqliteConnection _connection;
    private static string _dbPath = "user://test.db";
    public static string _encryptionKey = "ABC123";

    // 获取数据库连接:cite[7]
    public static SqliteConnection GetConnection()
    {
        if (_connection == null)
        {
            string userDir = OS.GetUserDataDir();
            string fullPath = Path.Combine(userDir, "test.db");

            // 创建连接字符串
            var connectionString = new SqliteConnectionStringBuilder
            {
                DataSource = fullPath,
                Mode = SqliteOpenMode.ReadWriteCreate,
                Password = _encryptionKey // 添加加密密钥
            }.ToString();

            _connection = new SqliteConnection(connectionString);

            try
            {
                _connection.Open();
                InitializeTables();
                GD.Print("成功打开加密数据库连接");
            }
            catch (Exception e)
            {
                GD.PrintErr($"打开数据库失败: {e.Message}");
                _connection = null;
                throw;
            }
        }

        return _connection;
    }

    // 初始化数据库表:cite[1]
    private static void InitializeTables()
    {
        string createTableSQL = @"
            CREATE TABLE IF NOT EXISTS students (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT NOT NULL,
                age INTEGER NOT NULL,
                grade TEXT
            )";

        using (var command = new SqliteCommand(createTableSQL, _connection))
        {
            command.ExecuteNonQuery();
        }

        GD.Print("数据库表初始化成功");
    }

    // 关闭数据库连接
    public static void CloseConnection()
    {
        if (_connection != null)
        {
            _connection.Close();
            _connection = null;
            GD.Print("数据库连接已经关闭");
        }
    }

    // 更改加密密钥的方法
    public static bool ChangeEncryptionKey(string newKey)
    {
        try
        {
            using (var command = _connection.CreateCommand())
            {
                command.CommandText = $"PRAGMA rekey = '{newKey}'";
                command.ExecuteNonQuery();
                _encryptionKey = newKey;
                GD.Print("加密密钥已更改");
                return true;
            }
        }
        catch (Exception e)
        {
            GD.PrintErr($"更改密钥失败: {e.Message}");
            return false;
        }
    }

    public static void EncryptExistingDatabase(string unencryptedPath, string encryptedPath, string key)
    {
        // 连接到未加密数据库
        var unencryptedConnectionString = new SqliteConnectionStringBuilder
        {
            DataSource = unencryptedPath
        }.ToString();

        // 连接到新加密数据库
        var encryptedConnectionString = new SqliteConnectionStringBuilder
        {
            DataSource = encryptedPath,
            Password = key
        }.ToString();

        using (var unencryptedConn = new SqliteConnection(unencryptedConnectionString))
        using (var encryptedConn = new SqliteConnection(encryptedConnectionString))
        {
            unencryptedConn.Open();
            encryptedConn.Open();

            // 将未加密数据库的内容复制到加密数据库
            using (var command = unencryptedConn.CreateCommand())
            {
                command.CommandText = $"ATTACH DATABASE '{encryptedPath}' AS encrypted KEY '{key}'";
                command.ExecuteNonQuery();

                command.CommandText = "SELECT sqlcipher_export('encrypted')";
                command.ExecuteNonQuery();

                command.CommandText = "DETACH DATABASE encrypted";
                command.ExecuteNonQuery();
            }
        }

        // 备份原始未加密数据库
        File.Move(unencryptedPath, unencryptedPath + ".backup");
        File.Move(encryptedPath, unencryptedPath);

        GD.Print("数据库加密完成");
    }
}
Student.cs

和前一个文章一样，我因为采用了jdbc的模式访问数据库，所以有一个实体作为映射，一个实体对应一个表结构，这个是学生信息表，那么实际游戏开发可以替换成自己的玩家数据表，物品信息表等

  • 代码如下
csharp 复制代码 
using Godot;
using System;

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public string Grade { get; set; }

    public Student() { }

    public Student(string name, int age, string grade)
    {
        Name = name;
        Age = age;
        Grade = grade;
    }

    // 重写ToString方法便于输出
    public override string ToString()
    {
        return $"Student [ID: {Id}, Name: {Name}, Age: {Age}, Grade: {Grade}]";
    }
}
StudentDAO.cs

该文件是学生信息表的DAO层，用于操作学生信息表进行增删改查

  • 代码如下
csharp 复制代码 
using System;
using Microsoft.Data.Sqlite;
using System.Collections.Generic;
using Godot;
using System.IO;

public class StudentDAO
{

    private static string GetDbPath()
    {
        string userDir = OS.GetUserDataDir();
        return Path.Combine(userDir, "test.db");
    }

    private static string GetConnectionString()
    {
        return new SqliteConnectionStringBuilder
        {
            DataSource = GetDbPath(),
            Password = DBConnection._encryptionKey // 与DBConnection中相同的密钥
        }.ToString();
    }

    // 添加学生:cite[1]
    public static bool AddStudent(Student student)
    {
       // string dbPath = GetDbPath();
        //string connectionString = $"Data Source={dbPath};Version=3;";

        // 使用 using 语句确保连接在使用后会被正确关闭和释放:cite[10]
        var connection = DBConnection.GetConnection();
        try
        {
            connection.Open();
            string sql = @"INSERT INTO students (name, age, grade) 
                              VALUES (@name, @age, @grade)";

            using (var command = new SqliteCommand(sql, connection))
            {
                command.Parameters.AddWithValue("@name", student.Name);
                command.Parameters.AddWithValue("@age", student.Age);
                command.Parameters.AddWithValue("@grade", student.Grade);

                int rowsAffected = command.ExecuteNonQuery();
                GD.Print($"新增学生: {student.Name}, 操作结果: {rowsAffected}");
                return rowsAffected > 0;
            }
        }
        catch (Exception e)
        {
            GD.PrintErr($"添加学生失败: {e.Message}");
            return false;
        }

    }

    // 根据ID删除学生:cite[5]
    public static bool DeleteStudent(int id)
    {
        //string dbPath = GetDbPath();
        //string connectionString = $"Data Source={dbPath};Version=3;";
        try
        {
            var connection = DBConnection.GetConnection();
            connection.Open();
            string sql = "DELETE FROM students WHERE id = @id";

            using (var command = new SqliteCommand(sql, connection))
            {
                command.Parameters.AddWithValue("@id", id);

                int rowsAffected = command.ExecuteNonQuery();
                GD.Print($"使用ID删除学生: {id}, 操作结果: {rowsAffected}");
                return rowsAffected > 0;
            }

        }
        catch (Exception e)
        {
            GD.PrintErr($"删除学生失败: {e.Message}");
            return false;
        }
    }

    // 更新学生信息:cite[5]
    public static bool UpdateStudent(Student student)
    {
        //string dbPath = GetDbPath();
        //string connectionString = $"Data Source={dbPath};Version=3;";
        try
        {
            var connection = DBConnection.GetConnection();
            connection.Open();
            string sql = @"UPDATE students 
                              SET name = @name, age = @age, grade = @grade 
                              WHERE id = @id";

            using (var command = new SqliteCommand(sql, connection))
            {
                command.Parameters.AddWithValue("@name", student.Name);
                command.Parameters.AddWithValue("@age", student.Age);
                command.Parameters.AddWithValue("@grade", student.Grade);
                command.Parameters.AddWithValue("@id", student.Id);

                int rowsAffected = command.ExecuteNonQuery();
                GD.Print($"更新学生信息: {student.Name}, 操作结果: {rowsAffected}");
                return rowsAffected > 0;
            }

        }
        catch (Exception e)
        {
            GD.PrintErr($"更新学生信息失败: {e.Message}");
            return false;
        }
    }

    // 获取所有学生:cite[1]
    public static List<Student> GetAllStudents()
    {
/*        string dbPath = GetDbPath();
        string connectionString = $"Data Source={dbPath};Version=3;";*/
        var students = new List<Student>();

        try
        {
            var connection = DBConnection.GetConnection();
            connection.Open();
            string sql = "SELECT * FROM students";

            using (var command = new SqliteCommand(sql, connection))
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    students.Add(new Student
                    {
                        Id = Convert.ToInt32(reader["id"]),
                        Name = reader["name"].ToString(),
                        Age = Convert.ToInt32(reader["age"]),
                        Grade = reader["grade"].ToString()
                    });
                }
            }
            GD.Print($"已获取 {students.Count} 数量学生信息");
        }
        catch (Exception e)
        {
            GD.PrintErr($"获取学生信息失败: {e.Message}");
        }

        return students;
    }

    // 根据ID查询学生:cite[7]
    public static Student GetStudentById(int id)
    {
/*        string dbPath = GetDbPath();
        string connectionString = $"Data Source={dbPath};Version=3;";*/
        try
        {
            var connection = DBConnection.GetConnection();
            connection.Open();
            string sql = "SELECT * FROM students WHERE id = @id";

            using (var command = new SqliteCommand(sql, connection))
            {
                command.Parameters.AddWithValue("@id", id);

                using (var reader = command.ExecuteReader())
                {
                    if (reader.Read())
                    {
                        GD.Print($"使用ID获取学生信息: {id}");
                        return new Student
                        {
                            Id = Convert.ToInt32(reader["id"]),
                            Name = reader["name"].ToString(),
                            Age = Convert.ToInt32(reader["age"]),
                            Grade = reader["grade"].ToString()
                        };
                    }
                }
            }
        }
        catch (Exception e)
        {
            GD.PrintErr($"获取学生信息失败: {e.Message}");
        }

        GD.Print($"未找到学生信息: {id}");
        return null;
    }

    // 根据姓名查询学生(模糊查询):cite[7]
    public static List<Student> GetStudentsByName(string name)
    {
/*        string dbPath = GetDbPath();
        string connectionString = $"Data Source={dbPath};Version=3;";*/
        var students = new List<Student>();

        try
        {
            var connection = DBConnection.GetConnection();
            connection.Open();
            string sql = "SELECT * FROM students WHERE name LIKE @name";

            using (var command = new SqliteCommand(sql, connection))
            {
                command.Parameters.AddWithValue("@name", $"%{name}%");

                using (var reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        students.Add(new Student
                        {
                            Id = Convert.ToInt32(reader["id"]),
                            Name = reader["name"].ToString(),
                            Age = Convert.ToInt32(reader["age"]),
                            Grade = reader["grade"].ToString()
                        });
                    }
                }
            }
            GD.Print($"已获取 {students.Count} 行数据包含该名称的学生: {name}");
        }
        catch (Exception e)
        {
            GD.PrintErr($"根据名称获取学生失败: {e.Message}");
        }

        return students;
    }
}
SQLiteBridge.cs

该文件是用于演示的执行表的增删改查的逻辑代码，使用该代码，我们需要建立一个node2d或者node节点，将代码挂载上去,并编译完成之后启动游戏

csharp 复制代码 
using Godot;
using System;
using System.Collections.Generic;
using SQLitePCL;

public partial class SQLiteBridge : Node2D
{
    public override void _Ready()
    {
        Batteries_V2.Init(); // 此方法用于初始化 SQLitePCLRaw 的包提供程序

        GD.Print("Starting SQLite database operations...");
        // 测试数据库操作
        TestDatabaseOperations();

        GD.Print("All database operations completed");
    }

    private void TestDatabaseOperations()
    {
        // 1. 添加学生
        GD.Print("\n=== 添加学生 ===");
        var student1 = new Student("张三", 20, "大三");
        var student2 = new Student("李四", 19, "大二");
        var student3 = new Student("王五", 21, "大三");

        StudentDAO.AddStudent(student1);
        StudentDAO.AddStudent(student2);
        StudentDAO.AddStudent(student3);

        // 2. 查询所有学生
        GD.Print("\n=== 查询所有学生 ===");
        List<Student> allStudents = StudentDAO.GetAllStudents();
        foreach (var student in allStudents)
        {
            GD.Print(student.ToString());
        }

        // 3. 根据ID查询学生
        GD.Print("\n=== 根据ID查询学生 ===");
        Student retrievedStudent = StudentDAO.GetStudentById(1);
        if (retrievedStudent != null)
        {
            GD.Print($"找到学生: {retrievedStudent}");
        }

        // 4. 根据姓名查询学生
        GD.Print("\n=== 根据姓名查找学生 ===");
        List<Student> studentsByName = StudentDAO.GetStudentsByName("张");
        foreach (var student in studentsByName)
        {
            GD.Print($"找到学生: {student}");
        }

        // 5. 更新学生信息
        GD.Print("\n=== 更新学生信息 ===");
        if (retrievedStudent != null)
        {
            retrievedStudent.Age = 22;
            retrievedStudent.Grade = "大四";
            StudentDAO.UpdateStudent(retrievedStudent);
        }

        // 6. 删除学生
        GD.Print("\n=== 删除学生 ===");
        StudentDAO.DeleteStudent(2);

        // 7. 验证删除结果
        GD.Print("\n=== 验证删除结果 ===");
        List<Student> remainingStudents = StudentDAO.GetAllStudents();
        foreach (var student in remainingStudents)
        {
            GD.Print($"学生: {student}");
        }
    }

    public override void _ExitTree()
    {
    }
}
执行结果

执行启动游戏之后,就会看到如下信息

复制代码 
Starting SQLite database operations...

=== 添加学生 ===
数据库表初始化成功
成功打开加密数据库连接
新增学生: 张三, 操作结果: 1
新增学生: 李四, 操作结果: 1
新增学生: 王五, 操作结果: 1

=== 查询所有学生 ===
已获取 3 数量学生信息
Student [ID: 1, Name: 张三, Age: 20, Grade: 大三]
Student [ID: 2, Name: 李四, Age: 19, Grade: 大二]
Student [ID: 3, Name: 王五, Age: 21, Grade: 大三]

=== 根据ID查询学生 ===
使用ID获取学生信息: 1
找到学生: Student [ID: 1, Name: 张三, Age: 20, Grade: 大三]

=== 根据姓名查找学生 ===
已获取 1 行数据包含该名称的学生: 张
找到学生: Student [ID: 1, Name: 张三, Age: 20, Grade: 大三]

=== 更新学生信息 ===
更新学生信息: 张三, 操作结果: 1

=== 删除学生 ===
使用ID删除学生: 2, 操作结果: 1

=== 验证删除结果 ===
已获取 2 数量学生信息
学生: Student [ID: 1, Name: 张三, Age: 22, Grade: 大四]
学生: Student [ID: 3, Name: 王五, Age: 21, Grade: 大三]
All database operations completed

和前一个文章所说一样，我们的数据库是保存在我们的user://路径，因为这个路径是可读写的，所以我们可以在指定文件夹找到该数据库db格式文件
注意：如果需要知道数据库文件存在哪里，请查看我前一篇文章

图形化工具访问数据库

根据如上，我们执行完毕之后，就有了db数据库文件

  • 但是因为经过加密了,我们原本是可以直接打开数据库看到表资料的,现在是无法直接打开的。

  • 然后我们是在代码里面进行执行解密以达到可以进行表的增删改查操作，外部人员如果想简单修改破解是不容易的

  • 如我使用dbeaver尝试打开加密后的db数据库

  • 可以看到它是报错了

    [SQLITE_NOTADB] File opened that is not a database file (file is not a database)

  • 这个时候我们需要用上工具了,我有找到一个工具

DB Browser for SQLCipher3.11.2绿色便携版.7z

该工具是免安装的

解压之后找到DB Browser for SQLCipher.exe,然后双击启动

  • 然后我们点击[打开数据库]，找到我们需要解密的db数据库文件
  • 接着会让我们输入密码，密码就是我们前面设置的密钥,如我设置的ABC123
  • 如果连接成功会看到表
  • 并且我们可以右键【浏览表】可以看到我们游戏运行代码时候保存的游戏数据

结语

根据如上，我们就可以实现【godot+c#使用godot-sqlite连接数据库并加解密】,以此实现可以用在游戏存档和读档，并且防止篡改游戏数据

相关推荐
集成显卡7 小时前
Bun.js + Elysia 框架实现基于 SQLITE3 的简单 CURD 后端服务
开发语言·javascript·sqlite·bun.js
山间点烟雨8 小时前
2. WPF程序打包成一个单独的exe文件
c#·wpf·独立打包exe
m0_736927049 小时前
使用 Python 将 PowerPoint 转换为 Word 文档
java·开发语言·后端·职场和发展·c#
莫生灬灬9 小时前
[特殊字符] FBro工作流自动化平台 - 让浏览器自动化更简单
运维·chrome·c#·自动化
“抚琴”的人11 小时前
奥姆龙PLC与C#数据类型对应表
c#·上位机
fie888916 小时前
C#实现连续语音转文字
开发语言·c#
白雪公主的后妈19 小时前
Auto CAD二次开发——多边形多段线
c#·cad二次开发·多边形
wangnaisheng1 天前
【C#】EventHandler的使用
c#
唐青枫1 天前
C#.NET Cronos 实战：优雅解析与执行 Cron 表达式
c#·.net
周杰伦fans1 天前
C# SelectMany 完全指南：从入门到精通
c#·linq
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07Labelme从安装到标注：零基础完整指南08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10jdk21下载、安装（Windows、Linux、macOS）