【微软漏洞分析】MS10-013 Microsoft DirectShow 中的漏洞可能允许远程执行代码

最新推荐文章于 2025-06-06 16:51:25 发布
原创 最新推荐文章于 2025-06-06 16:51:25 发布
· 432 阅读 · 0 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#microsoft #补丁分析 #二进制漏洞

目录

MS10-013

Microsoft DirectShow 中的漏洞可能允许远程执行代码 (977935)

摘要

此安全更新解决 Microsoft DirectShow 中一个安全报告的漏洞。 如果用户打开特制 AVI 文件，这两个漏洞可能允许远程执行代码。 成功利用此漏洞的攻击者可以完全控制受影响的系统。 攻击者可随后安装程序；查看、更改或删除数据；或者创建拥有完全用户权限的新帐户。 那些帐户被配置为拥有较少系统用户权限的用户比具有管理用户权限的用户受到的影响要小。

补丁分析

我们这里以windows 7的x86的补丁分析，补丁解开之后的目录列表如下：
补丁解开之后的文件列表
重点查看补丁文件为：

  • directshow-core_6.1.7600.16490\
    • 2009/12/19 17:02 1,328,640 quartz.dll
  • video-for-windows_6.1.7600.16490\
    • 2009/07/14 09:14 65,024 avicap32.dll
    • 2009/12/19 17:02 91,648 avifil32.dll
    • 2009/12/19 17:02 84,480 mciavi32.dll
    • 2009/12/19 17:02 13,312 msrle32.dll
    • 2009/07/14 09:15 120,320 msvfw32.dll
    • 2009/12/19 17:02 31,744 msvidc32.dll

quartz.dll

主要包括三个更新函数：

  1. CheckVideoType
  2. CAviMSROutPin::ParseHeader
  3. CAviMSRFilter::ParseHeaderCreatePins

在这里插入图片描述

CheckVideoType

更新前

unsigned int __thiscall CColour::CheckVideoType(CColour *this, const struct _AMMediaType *a2)
{
  unsigned int result; // eax

  if ( !memcmp(a2, &MEDIATYPE_Video, 0x10u) && !memcmp(&a2->formattype, &FORMAT_VideoInfo, 0x10u) )
    result = a2->cbFormat < 0x58 ? 0x8004022A : 0;
  else
    result = -2147220950;
  return result;
}

更新后

int __thiscall CColour::CheckVideoType(CColour *this, const struct _AMMediaType *a2)
{
  int result; // eax
  ULONG v3; // ecx
  
  if ( !memcmp(a2, &MEDIATYPE_Video, 0x10u)
    && !memcmp(&a2->formattype, &FORMAT_VideoInfo, 0x10u)
    && (v3 = a2->cbFormat, v3 >= 0x58) )
  {
    result = ValidateBitmapInfoHeader((int *)a2->pbFormat + 12, v3 - 48) ? 0 : -2147220950;
  }
  else
  {
    result = -2147220950;
  }
  return result;
}

CAviMSROutPin::ParseHeader

更新前

int __thiscall CAviMSROutPin::ParseHeader(CAviMSROutPin *this, struct _rifflist *a2, unsigned int a3)

{
......
    CAviMSROutPin::BuildMT(this);
......
}

更新后

int __thiscall CAviMSROutPin::ParseHeader(CAviMSROutPin *this, struct _rifflist *a2, unsigned int a3)

{
......
  if ( CAviMSROutPin::BuildMT(this) < 0
    && *(_DWORD *)(*((_DWORD *)this + 84) + 8) == 1935960438
    && !ValidateBitmapInfoHeader((int *)(*((_DWORD *)this + 85) + 8), *(_DWORD *)(*((_DWORD *)this + 85) + 4)) )
  {
    return 0;
  }

......
}

CAviMSRFilter::ParseHeaderCreatePins

更新前

int __thiscall CAviMSRFilter::ParseHeaderCreatePins(CAviMSRFilter *this)
{
  int v2; // ebx
  struct _riffchunk *v3; // edi
  unsigned __int8 *v4; // ebx
  int result; // eax
  FOURCC v6; // eax
  int v7; // eax
  bool v8; // al
  struct _rifflist *v9; // edi
  unsigned int v10; // eax
  int v11; // [esp-4h] [ebp-18h]
  struct _riffchunk *v12; // [esp+Ch] [ebp-8h] BYREF
  v2 = *((_DWORD *)this + 45);
  *((_DWORD *)this + 46) = 0;
  v3 = (struct _riffchunk *)*((_DWORD *)this + 44);
  v4 = (unsigned __int8 *)v3 + v2;
  v12 = v3;
  if ( !IsValidRIFFChunk(v3, v4) )
    return -2147220945;
  while ( 1 )
  {
    if ( v3->fcc == 1414744396 )
    {
      if ( v3->cb >= 0xC )
      {
        v6 = v3[1].fcc;
        if ( v6 == 1819440243 )
        {
          ++*((_DWORD *)this + 31);
        }
        else if ( v6 == 1819108463 )
        {
          *((_DWORD *)this + 47) = v3;
        }
      }
    }
    else if ( v3->fcc == 1751742049 && v3->cb >= 0x28 )
    {
      *((_DWORD *)this + 46) = v3;
    }
    if ( *((_DWORD *)this + 31) >= 0x80u )
      goto LABEL_16;
    result = GetNextRIFFChunk(v3, v4, &v12);
    if ( result < 0 )
      goto LABEL_17;
    if ( result )
      break;
    v3 = v12;
  }
  v7 = *((_DWORD *)this + 46);
  if ( !v7 )
  {
LABEL_16:
    result = -2147220945;
LABEL_17:
    *((_DWORD *)this + 31) = 0;
    return result;
  }
  v8 = *((_DWORD *)this + 31) == 2 && (*(_DWORD *)(v7 + 20) & 0x100) != 0;
  *((_BYTE *)this + 205) = v8;
  result = CAviMSRFilter::CreatePins(this);
  if ( result < 0 )
    return result;
  v9 = (struct _rifflist *)*((_DWORD *)this + 44);
  v10 = 0;
  v12 = 0;
  while ( v9 < (struct _rifflist *)v4 )
  {
    if ( v9->fcc == 1414744396 && v9->fccListType == 1819440243 )
    {
      if ( v10 >= *((_DWORD *)this + 31) )
        return -2147220945;
      if ( CAviMSROutPin::ParseHeader(*(CAviMSROutPin **)(*((_DWORD *)this + 30) + 4 * v10), v9, v10) )
      {
        v12 = (struct _riffchunk *)((char *)v12 + 1);
      }
      else
      {
        --*((_DWORD *)this + 31);
        v11 = *(_DWORD *)(*((_DWORD *)this + 30) + 4 * *((_DWORD *)this + 31)) + 12;
        (*(void (__stdcall **)(int))(*(_DWORD *)v11 + 8))(v11);
        *(_DWORD *)(*((_DWORD *)this + 30) + 4 * *((_DWORD *)this + 31)) = 0;
      }
      v10 = (unsigned int)v12;
    }
    v9 = (struct _rifflist *)((char *)v9 + v9->cb + (v9->cb & 1) + 8);
  }
  *((_DWORD *)this + 31) = v10;
  return v10 != 0 ? 0 : -2147220945;
}

更新后

int __thiscall CAviMSRFilter::ParseHeaderCreatePins(CAviMSRFilter *this)
{
  struct _riffchunk *v2; // ebx
  int v3; // edi
  unsigned __int8 *v4; // edi
  int result; // eax
  FOURCC v6; // eax
  int v7; // eax
  bool v8; // al
  struct _rifflist *v9; // edi
  unsigned int v10; // ebx
  int v11; // eax
  unsigned int v12; // edx
  _DWORD *v13; // eax
  int v14; // ecx
  struct _riffchunk *v15; // ebx
  int v16; // eax
  unsigned __int8 *v17; // [esp+Ch] [ebp-10h]
  unsigned int v18; // [esp+10h] [ebp-Ch]
  struct _riffchunk *v19; // [esp+14h] [ebp-8h] BYREF
  v2 = (struct _riffchunk *)*((_DWORD *)this + 44);
  v3 = *((_DWORD *)this + 45);
  *((_DWORD *)this + 46) = 0;
  v4 = (unsigned __int8 *)v2 + v3;
  v19 = v2;
  v17 = v4;
  if ( !IsValidRIFFChunk(v2, v4) )
    return -2147220945;
  while ( 1 )
  {
    if ( v2->fcc == 1414744396 )
    {
      if ( v2->cb >= 0xC )
      {
        v6 = v2[1].fcc;
        if ( v6 == 1819440243 )
        {
          ++*((_DWORD *)this + 31);
        }
        else if ( v6 == 1819108463 )
        {
          *((_DWORD *)this + 47) = v2;
        }
      }
    }
    else if ( v2->fcc == 1751742049 && v2->cb >= 0x28 )
    {
      *((_DWORD *)this + 46) = v2;
    }
    if ( *((_DWORD *)this + 31) >= 0x80u )
      goto LABEL_16;
    result = GetNextRIFFChunk(v2, v4, &v19);
    if ( result < 0 )
      goto LABEL_17;
    if ( result )
      break;
    v2 = v19;
  }
  v7 = *((_DWORD *)this + 46);
  if ( !v7 )
  {
LABEL_16:
    result = -2147220945;
LABEL_17:
    *((_DWORD *)this + 31) = 0;
    return result;
  }
  v8 = *((_DWORD *)this + 31) == 2 && (*(_DWORD *)(v7 + 20) & 0x100) != 0;
  *((_BYTE *)this + 205) = v8;
  result = CAviMSRFilter::CreatePins(this);
  if ( result < 0 )
    return result;
  v9 = (struct _rifflist *)*((_DWORD *)this + 44);
  v10 = 0;
  v18 = 0;
  while ( v9 < (struct _rifflist *)v17 )
  {
    if ( v9->fcc == 1414744396 && v9->fccListType == 1819440243 )
    {
      if ( v10 >= *((_DWORD *)this + 31) )
        return -2147220945;
      if ( CAviMSROutPin::ParseHeader(*(CAviMSROutPin **)(*((_DWORD *)this + 30) + 4 * v10), v9, v10) )
      {
        v18 = ++v10;
      }
      else
      {
        --*((_DWORD *)this + 31);
        v11 = *(_DWORD *)(*((_DWORD *)this + 30) + 4 * v10);
        v19 = *(struct _riffchunk **)(v11 + 280);
        (*(void (__stdcall **)(int))(*(_DWORD *)(v11 + 12) + 8))(v11 + 12);
        v12 = v10;
        if ( v10 < *((_DWORD *)this + 31) )
        {
          do
          {
            v13 = (_DWORD *)(*((_DWORD *)this + 30) + 4 * v12);
            v14 = v13[1];
            v15 = *(struct _riffchunk **)(v14 + 280);
            *v13 = v14;
            v16 = *(_DWORD *)(*((_DWORD *)this + 30) + 4 * v12++);
            *(_DWORD *)(v16 + 280) = v19;
            v19 = v15;
          }
          while ( v12 < *((_DWORD *)this + 31) );
          v10 = v18;
        }
        *(_DWORD *)(*((_DWORD *)this + 30) + 4 * *((_DWORD *)this + 31)) = 0;
      }
    }
    v9 = (struct _rifflist *)((char *)v9 + v9->cb + (v9->cb & 1) + 8);
  }
  *((_DWORD *)this + 31) = v10;
  return v10 != 0 ? 0 : -2147220945;
}

msrle32.dll

主要包括二个更新函数：

  1. RleDecompressQuery
  2. RleDecompressGetFormat

RleDecompressQuery

更新前

int __stdcall RleDecompressQuery(int a1, int a2, int a3)
{
  __int16 v3; // dx
  int v4; // ecx
  int result; // eax
  if ( a2
    && ((v3 = *(_WORD *)(a2 + 14), v3 == 8) || *(_DWORD *)(a2 + 16) != 1)
    && ((v4 = *(_DWORD *)(a2 + 16)) == 0 || v4 == 1)
    && (!a3
     || !*(_DWORD *)(a3 + 16)
     && *(_WORD *)(a3 + 14) == v3
     && *(_DWORD *)(a3 + 4) == *(_DWORD *)(a2 + 4)
     && *(_DWORD *)(a3 + 8) == *(_DWORD *)(a2 + 8)) )
  {
    result = 0;
  }
  else
  {
    result = -2;
  }
  return result;
}

更新后

int __stdcall RleDecompressQuery(int a1, int a2, int a3)
{
  __int16 v3; // cx
  int v4; // eax
  int result; // eax
  if ( a2
    && ValidateBitmapInfoHeader((int *)a2, 0x90Cu)
    && ((v3 = *(_WORD *)(a2 + 14), v3 == 8) || *(_DWORD *)(a2 + 16) != 1)
    && ((v4 = *(_DWORD *)(a2 + 16)) == 0 || v4 == 1)
    && (!a3
     || !*(_DWORD *)(a3 + 16)
     && *(_WORD *)(a3 + 14) == v3
     && *(_DWORD *)(a3 + 4) == *(_DWORD *)(a2 + 4)
     && *(_DWORD *)(a3 + 8) == *(_DWORD *)(a2 + 8)) )
  {
    result = 0;
  }
  else
  {
    result = -2;
  }
  return result;
}

RleDecompressGetFormat

更新前

int __stdcall RleDecompressGetFormat(int a1, int a2, ULONG pulResult)
{
  int result; // eax
  int v4; // eax
  __int16 v5; // ax
  result = RleDecompressQuery(a1, a2, 0);
  if ( result )
    return result;
  v4 = *(_DWORD *)(a2 + 32);
  if ( !v4 && *(_WORD *)(a2 + 14) == 8 )
    v4 = 256;
  if ( !pulResult )
    return 4 * v4 + 40;
  qmemcpy((void *)pulResult, (const void *)a2, 0x28u);
  memcpy((void *)(pulResult + 40), (const void *)(a2 + *(_DWORD *)a2), 4 * v4);
  *(_DWORD *)pulResult = 40;
  v5 = *(_WORD *)(a2 + 14);
  *(_DWORD *)(pulResult + 16) = 0;
  *(_WORD *)(pulResult + 14) = v5;
  if ( SAFE_DIBSIZE(pulResult, pulResult + 20) >= 0 )
    result = 0;
  else
    result = -7;
  return result;
}

更新后

int __stdcall RleDecompressGetFormat(int a1, int a2, ULONG pulResult)
{
  int result; // eax
  unsigned int v4; // eax
  __int16 v5; // ax
  result = RleDecompressQuery(a1, a2, 0);
  if ( result )
    return result;
  v4 = *(_DWORD *)(a2 + 32);
  if ( !v4 )
  {
    if ( *(_WORD *)(a2 + 14) != 8 )
    {
LABEL_6:
      if ( *(_DWORD *)a2 < 0x28u )
        return -2;
      if ( !pulResult )
        return 4 * v4 + 40;
      qmemcpy((void *)pulResult, (const void *)a2, 0x28u);
      memcpy((void *)(pulResult + 40), (const void *)(a2 + *(_DWORD *)a2), 4 * v4);
      *(_DWORD *)pulResult = 40;
      v5 = *(_WORD *)(a2 + 14);
      *(_DWORD *)(pulResult + 16) = 0;
      *(_WORD *)(pulResult + 14) = v5;
      if ( SAFE_DIBSIZE(pulResult, pulResult + 20) >= 0 )
        return 0;
      return -7;
    }
    v4 = 256;
  }
  if ( v4 > 0x100 )
    return -2;
  goto LABEL_6;
}

重点分析

  1. 在多个函数中增加了文件header的验证函数ValidateBitmapInfoHeader
  2. 最后的利用点在函数RleDecompressGetFormat中的如下片段
v4 = *(_DWORD *)(a2 + 32);
......
memcpy((void *)(pulResult + 40), (const void *)(a2 + *(_DWORD *)a2), 4 * v4);

网上没找到相应的分析记录，这里把分析过程和结果记录一下，以方便大家的学习。

参考页面

  1. https://learn.microsoft.com/zh-cn/security-updates/securitybulletins/2010/ms10-013
  2. https://catalog.update.microsoft.com/
微软发布四月份8个安全补丁 修复23个漏洞 下载
clubsondy的专栏
05-04 1053
2009年4月的月度安全补丁，总计8个，其中5个属于最高关键级、2个是次要的重要级，还有一个中等级的。这8个补丁一共修复了多达23个安全漏洞，是近期更新规模较大的一次。这样一来，微软在今年放出的安全补丁总量已经达到16个，其中第一季度只有8个。 微软称，这10个危急安全漏洞存在于Excel电子数据表、IE浏览器、WordPad写字板、Windows操作系统及其他应用程序当中。该公司还指出，已经
利用dll加载漏洞实现远程代码执行
weixin_30448685的博客
03-24 179
微软的“不安全dll加载”漏洞涉及Windows XP至Windows 7等多个版本的操作系统。由于Windows存在加载未指明完整路径的dll文件的机制，可能导致用户在使用第三方软件、玩游戏、听音乐时，会加载由木马 病毒伪装而成的dll文件，从而让木马病毒运行起来。 例如，当我们实例化一个对象，Windows会尝试从当前工作目录中加载一个或多个DLL动态库文件。如果我们能诱使受害者，打开一个包...
CVE-2017-8464 LNK文件（快捷方式）远程代码执行漏洞复现
aijuzhou1959的博客
07-25 376
北京时间2017年6月13日凌晨，微软官方发布6月安全补丁程序，“震网三代” LNK文件远程代码执行漏洞（CVE-2017-8464）和Windows搜索远程命令执行漏洞（CVE-2017-8543）. CVE-2017-8543，当Windows搜索处理内存中的对象时，存在远程执行代码漏洞。成功利用此漏洞的攻击者可以控制受影响的系统。 CVE-2017-8464，当Windows系...
Microsoft Windows远程桌面服务远程执行代码漏洞(CVE-2019-0708)
冰恋云的专栏
07-14 1889
Microsoft： Windows远程桌面服务远程执行代码漏洞(CVE-2019-0708) 解决办法：Microsoft 已经为此发布了一个安全公告（CVE-2019-0708）以及相应补丁: CVE-2019-0708: Microsoft Windows 远程桌面服务远程执行代码漏洞. 链接： https://portal.msrc.microsoft.com/zh-CN/security-guidance/advisory/CVE-2019-0708 ...
关于Windows汇总累积更新的认识误区和正确的使用方式
wudengyu的博客
04-14 9698
关于Windows汇总累积更新的认识误区和正确的使用方式 若干年前的CIH、熊猫烧香到去年的勒索病毒告诉我们，及时打补丁特别是操作系统的安全补丁是很有很有必要的。所以，我一直都开启着Windows的自动更新功能，也很少遇到因为打补丁引起其他问题。然而，一旦重装系统，打补丁就非常头疼，因为太慢了。但是又不放心第三方的打补丁软件，必竟哪些补丁该打哪些补丁不必要打只有开发者才最具权威性。所以，2016年......
Microsoft远程桌面协议RDP远程代码可执行漏洞(CVE-2012-0002)(MS12-020)
Pnoker
08-31 3万+
Microsoft 安全公告 MS12-020 - 严重 远程桌面中的漏洞可能允许远程执行代码 (2671387) 更新程序包 KB2621440 解决 CVE-2012-0002，更新程序包 KB2667402 解决 CVE-2012-0152。如果在受影响的 Microsoft Windows 版本上，CVE-2012-0152 的严重等级低于 KB2621440，则根据 CVE-2012-0002，综合严重等
安全漏洞概念及分类
热门推荐
maoji的专栏
10-12 3万+
本文是一个安全漏洞相关的科普，介绍安全漏洞的概念认识，漏洞在几个维度上的分类及实例展示。 安全漏洞及相关的概念 本节介绍什么是安全漏洞及相关的概况。 安全漏洞的定义 我们经常听到漏洞这个概念，可什么是安全漏洞？想给它一个清晰完整的定义其实是非常困难的。如果你去搜索一下对于漏洞的定义，基本上会发现高大上的学术界和讲求实用的工业界各有各的说法，漏洞相关的各种角色，比如研究者、厂商、
微软补丁日：18个Windows安全公告，关键漏洞占一半
weixin_34006965的博客
07-04 176
微软3月份发布的Windows安全公告版本比平常内容多是因为其涵盖了两个月的漏洞修复，不过安全专家们业已完成其中一个已知的零日漏洞的补丁处理，且至少有五个漏洞已得到修补并公开于众。 MS17-006、MS17-007和MS17-023是三个常规关键Windows漏洞，分别用于Internet Explorer（IE）、Microsoft Edge和Ado...
微软安全新闻聚焦-双周刊第十期
微软大中华区安全博客
02-01 1231
Biweekly Spotlights==== 2012．1. 10 – 2012. 1 .30 第 10 期 ==== 微软可信计算（TwC）十周年里程碑                                                           2012 年 1 月 12 日 十年前的这个时候，当安全问题开始威胁软件信任度时，Bill Gates 向微软所有员工发送了一
MS Internet Explorer 7 DirectShow 溢出漏洞分析与利用代码
"MS Internet Explorer 7 DirectShow溢出源码 - SecureState R&D Team的漏洞利用代码" 本文档提供的是一个针对MS Internet Explorer 7的DirectShow组件(msvidctl.dll)堆溢出漏洞的源码，由SecureState R&D Team的...
MS12-020漏洞利用(蓝屏攻击).docx
05-06
当系统处理某些特制的媒体文件时，可能会导致远程代码执行，攻击者可以利用这个漏洞向受影响的系统发送恶意媒体文件，从而控制或破坏目标计算机。 在上述描述中，攻击者使用了一台装有Linux Kali系统的计算机作为...
MS12-020 Windows 2008r2 补丁
04-12
这个补丁解决了DirectShow中的一个远程代码执行漏洞，当用户打开特制的媒体文件或者访问包含恶意内容的网站时，攻击者可能会利用这个漏洞执行任意代码，完全控制受影响的系统。 为了保护系统，管理员和用户应该及时...
Windows6.1-KB2621440-x64.rar
05-31
总的来说，"Windows6.1-KB2621440-x64.rar"是一个针对64位Windows 7和Windows Server 2008 R2操作系统的安全更新，旨在解决MS12-020公告中描述的DirectShow漏洞。这个补丁通过".msu"文件提供，用户应将其解压后安装...
Python 隐藏法宝：双下划线 _ _Dunder_ _
weixin_53707653的博客
06-04 1405
Dunder方法（就是那些用双下划线__包裹的特殊方法）在Python中是个很大的话题，而且还在不断丰富。这篇文章当然没法面面俱到地讲完所有内容。我写这些主要是想帮你弄明白两件事：Dunder方法到底是什么？怎么用它们解决实际编程中常见的问题？说实话，不是每个程序员都必须掌握这些方法。但就我个人经验来说，当我真正搞懂它们之后，写代码的效率提高了很多。相信对你也会很有帮助。使用Dunder方法最大的好处就是：不用重复造轮子让代码更简洁易读更符合Python的编程风格。
API是什么意思？如何实现开放API？
最新发布
Leo的博客
06-06 1383
API开发与应用指南摘要 API（应用程序编程接口）是不同软件系统交互的桥梁，分为Web API（如RESTful、SOAP）、操作系统API和数据库API等类型。企业实现开放API需明确目标、评估资源并建立安全机制（如身份验证、数据加密）。开发过程需规范设计、选择技术栈、编写测试用例，并通过文档发布与监控维护确保稳定性。开放API能拓展生态，但也需防范安全风险。合理策略（如免费或收费模式）和开发者支持可提升API的吸引力。
.net Span类型和Memory类型
博客
06-05 1339
Span<T>代表一块连续的、不可变长度的内存区域，可直接读写其中的元素。它可以在栈上声明，也能指向堆上分配的数据或其他内存位置。这种设计使得在不复制数据的情况下，能高效处理内存区域，尤其适用于处理大型数据结构、高性能计算以及与操作系统交互的场景。Span<T>和Memory<T>类型为 .NET 开发者提供了强大的内存处理能力。Span<T>适用于需要直接、高效访问内存的场景，而Memory<T>则更适合处理复杂的内存所有权和跨线程、异步操作。合理运用这些类型，可以显著提升程序的性能和资源利用率。
微软的新系统Windows12未来有哪些新特性
06-04 843
在今年即将到来的重大设计升级中，苹果计划对其全线操作系统统一按年份命名，作为另一巨头微软的win12还远吗？win11和win10是微软现在正在用的主流版本，win11系统发布于2021年6月24日，win10系统发布于2015年7月29日。预计win12尝鲜版可能在2025年下半年或明年。尽管win12还没发布，可预见的会有不少眼前一亮的新特性。
算术操作符与类型转换：从基础到精通
weixin_66776566的博客
06-06 1170
在先前的文章中，我们已经学习并掌握了变量如何存储数据以及不同类型的基本特性。然而，编程的魅力远不止于静态地存储数据——真正的魔法发生在数据被动态操作的瞬间。而这一切的核心，正是运算符与数据类型转换。当我们谈论运算符时，实际上是在讨论如何让程序“思考”：通过算术运算符处理数值、用比较运算符判断逻辑关系、借位运算符优化底层操作……这些看似简单的符号，构成了程序逻辑的基石。
PlayWright | 初识微软出品的 WEB 应用自动化测试框架
集成显卡的开源主页 https://github.com/0604hx
06-05 535
Playwright enables reliable end-to-end testing for modern web apps.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值