Twlm's Blog

论文笔记《Password-Based Credentials with Securiy Against Server Compromise》

Thu, 20 Feb 2025 00:00:00 GMT

原论文地址：Password-Based Credentials with Security Against Server Compromise | SpringerLink

四个安全目标：

强不可伪造性：敌手A知道password并且服务器妥协，但不知道用户 ask (authenticated secret key)，无法伪造验证令牌
在线不可伪造性：A知道ask，服务器未妥协，则A只能通过在线猜测password来伪造令牌

服务器可发现异常行为从而阻断
离线不可伪造性：A知道ask，服务器妥协，则A能使用离线暴力猜测password

使用强口令是最后一道防线
口令隐藏性：服务器储存的avk(针对multi-key PBC 在服务器端储存的用户独有的验证凭据)不会泄露关于password的任何信息

目的是对抗服务器妥协时泄露口令信息和服务器内部模拟用户

已有的方案

1. “Password-based authentication” 基于密码的身份验证: 不能应对服务器妥协和弱密码猜测

2. “FIDO”: 高熵密钥(私钥)由用户拥有(通过加密硬件和软件管理，不便携)，服务器端只拥有用于验证的公钥(不会泄露用户信息)

3. ZWY 框架下的single-key PBC

ZWY single-key PBC

“ZWY framework(skPBC)”: 安全等级近似于key-based方案，无需用户储存密钥信息；

在注册时获取 cryptographically strong access credential，可以随意安置(via untrusted cloud providers or copied on low-security devices)
在线不可伪造性(服务器未妥协的情况下)
达不到强不可伪造性和离线不可伪造性
服务器妥协失去所有安全性：无需恢复密钥即可模拟所有用户验证
不需要Pw-Hiding

服务器拥有一个全局MAC密钥,用户凭证本质是服务器对uid生成的MAC密钥副本，注册时使用用户的password对MAC密钥进行对称加密。认证时，用户解密凭证恢复MAC密钥并与消息绑定后发送给服务器。(敌手可以让不诚实的用户注册后获取MAC密钥，但是此方案不考虑”corrupt users”的存在）

敌手不知服务器的高熵MAC密钥，则无法验证解密后的值是否有效，从而确保在线不可伪造性。

skPBC Syntax

包括五个算法 “KGen, 〈RegU, RegS〉, Sign, Vf”，两个阶段“a registration phase and an authentication phase” ，两个参与方Server / User.

Server: 长期单一密钥“KGen(λ) → (ssk, spk)”用于注册和验证所有用户，“ssk”是服务器的长期单一密钥，“spk”是与之对应的公钥

注册阶段：用户:RegU(spk,uid,pw) → ask ; 服务器: 使用ssk签出ask并储存uid

验证阶段：用户拟发送消息m，“Sign(uid, ask, pw, m) → τ”,将token τ和消息m发送给服务器，服务器执行“Vf(ssk, uid, m, τ ) → 0/1”

ZWY Framework的安全目标和威胁模型

选择消息和选择验证请求攻击下存在不可伪造性(“Existential Unforgeability under Chosen Message and Chosen Verification Queries Attack (EUF-CMVA)” (Dayanikli 和 Lehmann, 2024, p. 151))

经典的不可伪造：A只知道用户pw，对ask和server ssk一无所知
达到在线不可伪造性，A知道用户ask

Game of weak/strong UNF for A in skPBC(λ)：

现有用户列表uid_1~n,及其对应pw_1~n

敌手A可选择用户访问预言机Sign \ Vf 获取ask_i对挑战消息m进行签名和执行验证，请求过的(i,m)和i会被记录(分别在Q和RevCred中)

A获胜条件：A给出uid_j (j∈[1,n],j∉RevCred,即合法的、从未请求过的用户)、新鲜的消息m*和签名τ*，如果验证通过则A获胜

strongUNF实验中为A额外提供服务器私钥ssk

Weak/Strong Unforgeability定义为对所有PPT敌手获胜以上实验的概率≤negl(λ)

skPBC达不到Strong(and Offline) Unforgeability

一旦敌手A得知服务器的密钥ssk，就能用自己选择的口令重新注册任意诚实的用户U，以获得有效的用户凭证，并以U的名义创建令牌。在skPBC方案下，敌手赢得strongUNF的概率为1。

mkPBC

skPBC不可能具有强不可伪造性，故引入多密钥的PBC。关键的区别在于，服务器不再具有单个密钥来颁发用户凭证和验证其令牌。而是为每个注册用户生成一个特定于用户的验证密钥，并在验证用户的令牌时使用该特定于用户的密钥。

Syntax

“A multi-key PBC scheme mkPBC = (Setup, 〈RegU, RegS〉, Sign, Vf)”

Setup(λ)->pp: 输出公共参数，作为其他算法的隐式输入

〈RegU(uid, pw), RegS(uid)〉 → (ask; avk): 注册交互，用户输出凭证ask，服务器输出用户特定的验证密钥 avk

Sign(uid,ask,pw,m) → τ : 对消息m生成授权令牌

Vf(uid, avk, m, τ ) → 0/1 : 验证有效性

Game of xUNF for A in mkPBC(λ) where x∈{strong,online,offline}

现有合法注册的用户uid,pw,ask,avk，敌手在特定条件下多轮访问特定预言机后，给出新的m*,τ*，若通过验证则敌手获胜

条件如下：

x=strong: 给予敌手avk和pw, 可访问Sign预言机(O_Sign会记录挑战消息m)
x=online: 给予敌手ask, 可访问Sign和Vf预言机
x=offline: 给予敌手ask, avk, 可访问Sign和TestPW预言机((pw’)=>pw==pw’)

Game of PW-Hiding for A in mkPBC(λ)

现有合法用户uid，均匀随机选取两个可能合法的pw: pw0和pw1，给予敌手avk(敌手此时只知道pw0和pw1,不知道具体选取的是哪一个)并访问Sign预言机(预言机知道选取的pw)，之后敌手输出选取的是哪一个pw，正确则敌手获胜。

mkPBC的安全定义

对于一个mkPBC方案和所有PPT敌手A：

“Strong Unforgeability” ：Pr[Game of strongUNF for A in mkPBC(λ)=1]≤negl(λ)
“Online Unforgeability” ：Pr[Game of onlineUNF for A in mkPBC(λ)=1]≤(q_Vf+1)/|Dpw|+negl(λ)，q_Vf是猜测次数(即访问Vf预言机次数)，|Dpw|是口令域长度
“Offline Unforgeability” ：Pr[Game of offlineUNF for A in mkPBC(λ)=1]≤qf/|Dpw|+negl(λ)，qf是请求TestPW预言机次数
“Pw-Hiding” ：Pr[Game of PW-Hiding for A in mkPBC(λ)=1]≤1/2+negl(λ)

构建Sign-Then-Encrypt的PBC方案

需要三个密码学原语：

一个安全的伪随机函数PRF “F : {0, 1}^λ × X → Y”

“安全的”意味着函数F(key, · )与同域的随机函数不可区分
一个达到IND-CCA安全的非对称加密算法 ΠEnc:=(KGenE,Enc,Dec)
一个达到EUF-CMA安全的签名算法：ΠSign:=(SetupS,KGenS,SignS,VfS)

要求实现“Complete Robustness”(CROB-Security)：即对于所有PPT敌手难以找到一对(消息,签名)能在两个不同的公钥下验证通过；

以及“Randomness Injectivity” (RI)（可注入的随机性？可控的随机性？）：所有PPT敌手难以找到对于两个不同的注入参数，使得KGen输出相同的公私钥；暗含：公钥和私钥唯一匹配，对于注入参数而言是确定性生成的。

Scheme

一个基于签名后加密的多密钥PBC方案：

Setup(λ): pp ←SetupS(λ)
User与Server注册阶段 RegU(uid,pw) 和 RegS(uid):

U: 均匀随机选取PRF密钥k←{0,1}^λ，运行KGenS(pp,F(k,pw))生成签名公私钥pkSig和skSig;

运行KGenE(λ)生成加密用的公私钥pkEnc和skEnc;

发送(uid,avk:=(pkSig,skEnc))到S,输出ask:=(k,pkEnc);

签名和非对称加密的公私钥对都在客户端生成，发送签名公钥和加密私钥作为avk，保留PRF密钥k和加密公钥作为ask

S: 接收(uid,avk)储存即可，RegS输出avk
Sign(uid,ask,pw,m)

运行σ←SignS(skSig,(uid,m)) 对消息和uid签名

运行τ←Enc(pkEnc,σ)

输出τ作为token
Vf(uid,avk,m,τ)

解密σ←Dec(skEnc,τ)，输出VfS(pkSig,(uid,m),σ)

Theorem & Proof

1.如果F是安全的PRF并且ΠSign是EUF-CMA安全的签名方案，则该PBC是强不可伪造的

在服务器妥协(泄露avk)、用户pw泄露但是敌手不知道ask的情况下：敌手持有pkSig和skEnc，可解出令牌τ并得知其对应的(uid,m)；未知ask则无法运行F(k,pw)，就无法获得skSig。则可将问题归因到在未知skSig的情况下伪造签名，由于ΠSign是EUF-CMA安全，则不可行。即证明该PBC是强不可伪造的。

2. 如果F是随机预言机，ΠSign具有complete robustness和randomness injectivity，且ΠEnc具有CCA安全，则该PBC是在线不可伪造的

敌手具备 ask:=(k,pkEnc) 和 uid，未知avk:=(pkSign,skEnc)和pw。敌手通过猜测pw生成伪造的(pkSig’,skSig’):=KGenS(pp,F(k,pw’))和伪造签名σ’；由于ΠEnc具有CCA安全，则访问Sign预言机不会泄露任何关于签名σ的信息；由于未知pkSign则无法自行验证生成的签名，唯一的方法是访问Vf预言机。CROB确保Vf只会泄露pkSig的相等性，可注入随机性确保pkSig‘只能映射到单一pw猜测上，则敌手只能与Vf预言机一次猜测一次交互。至此该PBC是在线不可伪造的。

3. 如果F是随机预言机，ΠSign是EUF-CMA安全的，并且具有可注入随机性，则该PBC是离线不可伪造的

敌手具备ask,avk,uid,未知pw（作者在这里强调“具备ask”是指具备PRF密钥k，而不是签名私钥。注意到文中提及ask不储存而是即用即生成）。要伪造token τ则需要伪造skSig；此时敌手要么选择直接伪造签名(绕过skSig,但是ΠSign具有EUF-CMA安全则不可行)，要么通过离线暴力破解pw以生成skSig。且由于F是随机预言机、ΠSign有可注入随机性则只有唯一的pw能计算出正确的skSig。此时敌手的每一次猜测必须访问一次随机预言机F，则该PBC是离线不可伪造的。

4. 如果F是安全的PRF,则该PBC具有口令隐藏性

方案中唯一依赖pw的是生成签名公私钥之时敌手知道pkSig但未知k，获取的方式是与Sign预言机交互。由于k是随即均匀选取的，且通过安全的PRF转换，则无法区分pkSig是由r=F(k,pw_b)还是从随机预言机中选取(此时avk独立于pw存在)。

Appendix

“The DSA, Schnorr and BLS signature scheme all achieve randomness injectivity information-theoretically. DSA and Schnorr are CROBsecure assuming a collision-resistant hash function, and BLS is informationtheoretically CROB-secure.” (Dayanikli 和 Lehmann, 2024, p. 165) DSA、Schnorr 和 BLS 签名方案在理论上都实现了随机性注入性信息。DSA 和 Schnorr 是假设具有抗碰撞哈希函数的 CROB安全，而 BLS 在信息理论上是 CROB 安全的。

一些疑问

用户需要携带两个密钥（一个自己的password和一个PRF密钥k）牺牲了便携性。在具体的方案中，PRF应该使用流密码(e.g. AES)、HMAC或其他基于椭圆曲线构造的方案。其中某些方案并不支持所有k的长度，意味着要么选择HMAC这样支持所有长度的方案，然后让用户记住2个密钥，要么使用其他方案，k交由密钥管理器或安全芯片保管(没有FIDO的便捷性强，但是对保管方的安全性要求不高)。

“We therefore do not store (or even generate) the key normally, but derive it deterministically as (pkSig, skSig) := KGenS(pp; F (k, pw)) from a PRF key k and the user’s password pw. The user now only stores the PRF key k and re-derives the signature key pair when she wants to generate an authentication token.” (Dayanikli 和 Lehmann, 2024, p. 158)
设想一个简单的“用户名+密码(口令)”授权登录的方式：服务器储存用户id和对应的口令加盐哈希，用户端请求注册和登录时提交口令明文的哈希（避免明文网络传输），在服务器内部对比后生成授权：
- 不满足强不可伪造和离线不可伪造，服务器妥协时(泄露用户信息表，加盐算作服务器私钥的一部分)无需口令即可通过验证
- 在线不可伪造：仅能通过访问服务器暴力破解
- Pw-Hiding: 虽然满足，但是不能阻止服务器内部模拟用户
如果再加一个口令是否会更安全？不会，只会更麻烦

那么mkPBC的方案我认为优势就在于以下几点：
- 避免服务器内部腐败，擅自模拟用户操作
- 强不可伪造和离线不可伪造：服务器妥协和其中一个密钥(k;pw)泄露都无法获取授权
- password可以是便于用户记住的口令，k可以像FIDO方案一样储存，但是对储存方式安全性要求较低

Welcome to Twlm's Blog!

Mon, 20 May 2024 00:00:00 GMT

My blog is being rebuilt now.
More content is on the way.

WPF 使用 HLSL + Clip 实现高亮歌词光照效果

Sat, 17 Jan 2026 00:00:00 GMT

最近在搓一个Lyricify Lite类似物，原本使用渐变画刷实现歌词高亮，但是发现视觉效果与Apple Music相去甚远：单纯使用白色渐变画刷缺乏“高亮”的光照感觉，而Apple Music的歌词高亮则更像是有光线投射在歌词上，形成一种柔和的发光效果。

受到吕毅大佬的文章使用 WPF 做一个可以逼真地照亮你桌面的高性能阳光 - walterlv启发，遂尝试使用HLSL编写一个简单的文本高亮着色器。先来看实装在LemonLite中的效果：

整体上高亮文本与背景混色自然，渐变过渡由WPF动画驱动，高亮部分就有了光感。

以下是本文的最小可运行示例： ::github{repo="TwilightLemon/TextHighlighterTest"}

一、实现思路

简单说一下踩过的几个坑：

直接给TextBlock焊上Effect会导致文本像素化，变得模糊而且难以处理文本边界
使用VisualBrush，内部套一个Rectangle with Effect, 然后用这个VisualBrush作为TextBlock的Foreground，性能极差
给Rectangle with Effect做一个Clip裁剪出文本形状，性能可以，但是需要复刻TextBlock的排版逻辑

最终使用了第三种方案，并将其封装成一个用户控件。

如此一来，HLSL着色器要干的事情就很简单了：取一个高亮过渡位置pos，根据采样像素的X坐标计算光照强度，然后将这个强度与文本颜色做加法混合即可。

二、HLSL着色器代码

为了适配歌词高亮需求，我又追加了一些特性：

支持高亮颜色自定义
支持高亮宽度调整
支持切换高亮模式（加法混合/线性渐变）

以下是完整的HLSL代码：

sampler2D input : register(s0);

float HighlightPos : register(c0);
float HighlightWidth : register(c1);
float4 HighlightColor : register(c2);
float UseAdditive : register(c3); // 0 = lerp, 1 = additive
float HighlightIntensity : register(c4);

float4 main(float2 uv : TEXCOORD) : COLOR
{
    float4 color = tex2D(input, uv);
    float d = max(0, uv.x - HighlightPos);
    float glow = saturate(1 - d / HighlightWidth);
    glow = glow * glow;
    float intensity = glow * HighlightColor.a * HighlightIntensity;

    float3 lerpResult = lerp(color.rgb, HighlightColor.rgb, intensity);
    float lerpAlpha = lerp(color.a, 1.0, intensity);
    float3 additiveResult = color.rgb + HighlightColor.rgb * intensity;

    color.rgb = lerp(lerpResult, additiveResult, UseAdditive);
    color.a = lerp(lerpAlpha, color.a, UseAdditive);

    return color;
}

着色器输入参数

参数	作用
`input`	输入纹理（文本像素）
`HighlightPos`	高亮过渡位置（0-1，从左到右, 当然也可以取负数）
`HighlightWidth`	高亮衰减宽度（0-1）
`HighlightColor`	高亮颜色（含透明度）
`UseAdditive`	混合模式开关（0=线性渐变，1=加法混合）
`HighlightIntensity`	高亮强度倍数

计算过程

采样 → 读取当前像素颜色
color = tex2D(input, uv)
计算距离 → 像素X坐标与高亮位置的距离
d = max(0, uv.x - HighlightPos)
计算光晕强度 → 根据距离生成平滑衰减
glow = saturate(1 - d / HighlightWidth)
glow = glow * glow // 平方处理，使衰减更陡峭
最终强度 = 光晕 × 颜色透明度 × 强度倍数
混合处理 → 根据UseAdditive选择混合方式
- 线性渐变：在原色和高亮色间插值
- 加法混合：直接叠加高亮色

函数说明

saturate(x) - 将值钳制在 [0, 1] 范围内
step(edge, x) - 如果 x < edge 返回 0，否则返回 1
lerp(a, b, t) - 线性插值，计算 a + (b-a)×t
tex2D(sampler, uv) - 从纹理采样指定坐标的像素

编译并加载着色器

编译HLSL代码生成.ps文件，然后在WPF中使用PixelShader类加载：

fxc /T ps_3_0 /E main /Fo TextGlow.ps TextGlow.hlsl

封装成Effect类此处不做赘述，只需要严格按照参数顺序传递即可。

三、WPF用户控件封装

核心出装

用一个 Rectangle 承载着色器效果，通过FormattedText生成文本的几何形状作为裁剪路径，这样WPF只会渲染文本区域并且保留清晰的文本边缘。

属性继承与元数据覆写

为了让高亮控件支持标准的文本属性（字体、大小、粗细等），使用了WPF的元数据覆写机制。在静态构造函数中对 FontFamily、FontSize、FontWeight 等属性进行 OverrideMetadata，绑定到统一的 OnTextPropertyChanged 回调。当这些属性变化时，触发文本裁剪的重新计算。类似地，Foreground 属性也被覆写，当文本颜色改变时直接更新 Rectangle 的填充颜色。

static HighlightTextBlock()
{
    FontFamilyProperty.OverrideMetadata(typeof(HighlightTextBlock),
        new FrameworkPropertyMetadata(SystemFonts.MessageFontFamily, OnTextPropertyChanged));
    FontSizeProperty.OverrideMetadata(typeof(HighlightTextBlock),
        new FrameworkPropertyMetadata(14.0, OnTextPropertyChanged));
    FontWeightProperty.OverrideMetadata(typeof(HighlightTextBlock),
        new FrameworkPropertyMetadata(FontWeights.Normal, OnTextPropertyChanged));
    ForegroundProperty.OverrideMetadata(typeof(HighlightTextBlock),
        new FrameworkPropertyMetadata(Brushes.Black, OnForegroundChanged));
}

private static void OnForegroundChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    if (d is HighlightTextBlock control)
        control.PART_Rectangle.Fill = e.NewValue as Brush;
}

这样用户就可以像使用普通 TextBlock 一样使用这个控件，享受XAML的属性绑定和样式系统。

文本排版与裁剪

UpdateTextClip() 方法负责：

创建排版对象 - 通过 FormattedText 将文本按照控件的字体、大小、样式参数进行排版，获得与实际渲染完全一致的文本度量

var formattedText = new FormattedText(
    Text,
    CultureInfo.CurrentCulture,
    FlowDirection,
    new Typeface(FontFamily, FontStyle, FontWeight, FontStretch),
    FontSize,
    Brushes.Black,
    VisualTreeHelper.GetDpi(this).PixelsPerDip);

处理换行与宽度约束 - 当启用 TextWrapping 时，从 Width、MaxWidth 或 ActualWidth 中取出约束宽度。只有在需要换行且有约束宽度的情况下，才设置 MaxTextWidth 让文本自动折行

var constraintWidth = !double.IsNaN(Width) && Width > 0
    ? Width
    : (!double.IsInfinity(MaxWidth) && MaxWidth > 0 ? MaxWidth : ActualWidth);

if (TextWrapping != TextWrapping.NoWrap && constraintWidth > 0)
    formattedText.MaxTextWidth = constraintWidth;

计算容器尺寸 - NoWrap下容器宽度就是文本宽度，换行模式下则为约束宽度，以确保 Rectangle 的大小与实际文本范围匹配

var containerWidth = TextWrapping == TextWrapping.NoWrap
    ? textWidth
    : (constraintWidth > 0 ? constraintWidth : textWidth);

处理文本对齐 - 根据 TextAlignment 计算文本相对于容器的起始偏移（用于居中和右对齐），然后生成Rectangle时传入这个偏移量，同时更新 Rectangle 的水平对齐属性使其与文本对齐方式一致

double offsetX = 0;
if (containerWidth > textWidth)
{
    offsetX = TextAlignment switch
    {
        TextAlignment.Center => (containerWidth - textWidth) / 2,
        TextAlignment.Right => containerWidth - textWidth,
        _ => 0
    };
}

生成并应用裁剪 - 调用 formattedText.BuildGeometry() 得到精确的文本轮廓Rectangle，设置为 Rectangle.Clip。这样着色器的输出就被限制在文本像素范围内

var geometry = formattedText.BuildGeometry(new Point(offsetX, 0));
PART_Rectangle.Clip = geometry;
PART_Rectangle.Width = containerWidth;
PART_Rectangle.Height = textHeight;

高亮参数的动画驱动

高亮效果的三个关键参数（HighlightPos、HighlightWidth、HighlightColor）都被暴露为依赖属性，在属性变化回调中直接同步到着色器 Effect 对象：

public static readonly DependencyProperty HighlightPosProperty =
    DependencyProperty.Register(
        nameof(HighlightPos),
        typeof(double),
        typeof(HighlightTextBlock),
        new PropertyMetadata(0.0, OnHighlightPosChanged));

private static void OnHighlightPosChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    if (d is HighlightTextBlock c)
        c._effect.HighlightPos = (double)e.NewValue;
}

这样就可以在XAML中轻松使用 Storyboard 和 DoubleAnimation：

<Storyboard>
    <DoubleAnimation
        Storyboard.TargetName="HighlightBlock"
        Storyboard.TargetProperty="HighlightPos"
        From="-0.2" To="1.2" Duration="0:0:2" RepeatBehavior="Forever" />
</Storyboard>

驱动 HighlightPos 的平滑变化，从而实现光线扫过文本的连贯动画效果。

四、看看效果

对比Additive叠加和Lerp线性渐变两种模式，可以看到Additive模式下高亮部分更亮更有光感，而Lerp模式尾段偏灰。

尝试使用彩色高亮，变成了混色效果。

写在最后

LemonLite正在龟速开发中，过程中遇到的各种问题和解决方案都会陆续写成博客分享出来，欢迎各位大佬持续关注。
什么！你问我开头的背景是怎么做的？见上一篇文章：WPF 使用GDI+提取图片主色调并生成Mica材质特效背景

参考资料：

WPF 使用 RenderTransform 实现高性能平滑滚动的 ScrollViewer

Sun, 21 Dec 2025 00:00:00 GMT

在之前的两篇文章中，我们探讨了 WPF 中实现平滑滚动的不同方案：

WPF 如何流畅地滚动ScrollViewer 简单实现下：基于 DoubleAnimation 的动画方案。
WPF 使用CompositionTarget.Rendering实现平滑流畅滚动的ScrollViewer：基于 CompositionTarget.Rendering 的每帧布局更新方案。

虽然第二版方案解决了触控板和物理惯性的问题，但它引入了一个新的性能瓶颈：每帧调用 ScrollToVerticalOffset。这会导致 WPF 在每一帧都进行布局计算，在高负载场景下会直接卡死整个UI线程，造成掉帧或其他UI组件无响应。

为了解决这个问题，我进行了第三版（v3）设计，核心思路是：视觉层与逻辑层分离。

三种方案对比

方案	实现方式	优点	缺点
v1 (动画版)	`DoubleAnimation` 驱动 `VerticalOffset`	实现简单，代码量少	无法保留惯性速度（动画打断）；触控板体验差；不支持触摸/笔。
v2 (布局驱动)	`Rendering` 事件每帧调用 `ScrollToVerticalOffset`	物理模型更真实；支持多种输入设备	性能差：每帧触发 Layout Pass，高负载下掉帧严重。
v3 (视觉分离)	`RenderTransform` 驱动视觉，低频同步逻辑位置	高性能：视觉满帧运行，逻辑低频更新；物理模型完善。	实现相对复杂，需要处理坐标系转换和帧同步。

接下来，我们详细介绍 v3 版本的设计与实现原理。

一、视觉与逻辑分离

v3 的核心在于将“用户看到的滚动”（视觉层）和“控件实际的滚动”（逻辑层）分离。

视觉层：
- 使用 TranslateTransform 对 Content 进行位移。
- 在 CompositionTarget.Rendering 中以屏幕刷新率（如 60Hz 或 144Hz）更新 Transform.Y。
- 因为 RenderTransform 只影响渲染而不触发布局（Measure/Arrange），所以性能极高，完全由 GPU 加速。
逻辑层：
- 维护实际的 ScrollViewer.VerticalOffset。
- 降频更新：不再每帧调用 ScrollToVerticalOffset，而是以较低的频率（如 24Hz）同步逻辑位置。
- 这保证了滚动条的位置更新和虚拟化加载新内容，同时避免了频繁的布局计算。

渲染循环逻辑

只需遵守一条坐标系变换规则：逻辑位置 = 视觉位置 + 视觉偏差。
当用户滚动时，视觉层将以“插帧”方式在逻辑层低帧率更新之间平滑过渡。

在每一帧的渲染回调中：

计算物理模型的当前位置 _currentVisualOffset。
计算视觉偏差 _visualDelta = _currentVisualOffset - _logicalOffset。
应用 _transform.Y = -_visualDelta，实现视觉上的平滑移动，不会触发布局重置。
累加时间，如果超过 ScrollBarUpdateInterval (1/24s)，则调用 ScrollToVerticalOffset 同步逻辑位置，触发布局更新，从而允许滚动条同步和虚拟化等功能生效。

二、物理模型设计

v3 版本的物理模型沿用了 v2 的设计，但做了一些改进以提升滚动体验。以下介绍完整的物理模型。

2.1 缓动模型

适用于鼠标滚轮。该模型包含两个核心部分：动态速度因子（决定滚多快）和物理衰减（决定滚多久）。

动态速度因子 (Dynamic Velocity Factor)

在 v2 版本中，我们发现简单的线性速度叠加无法平衡缓慢滚动和快速滚动的体验。因此，v3 引入了一个基于时间间隔的动态速度因子。当用户快速连续滚动时，速度因子会呈指数级增长，从而产生更大的加速度。

$$ v_{factor} = (V_{max} - V_{min}) \cdot e^{-\frac{\Delta t}{20}} + V_{min} $$

$V_{max}$：最大速度倍率，固定为 2.5。
$V_{min}$：最小速度倍率 (MinVelocityFactor)，默认为 1.2。
$\Delta t$：两次滚动事件的时间间隔 (ms)。

这意味着：如果你慢慢滚动，每次滚动的距离约为原始值的 1.2 倍；如果你疯狂拨动滚轮，这个倍率会迅速逼近 2.5 倍，与真实的物理滚动手感更接近。

物理衰减

模拟物理摩擦力，使滚动速度随时间自然衰减。

速度衰减：$v_{new} = v_{old} \cdot f^{t_{factor}}$
位置更新：$x_{new} = x_{old} + v_{new} \cdot \frac{t_{factor}}{24}$

其中：

$f$：速率衰减系数，默认为 0.92。数值越小，停得越快。
$t_{factor}$：时间标准化因子，$\frac{dt}{TargetFrameTime}$ (基准帧率为 144Hz)。
常数 24 是一个经验值，用于调整速度到位移的映射比例。

2.2 精确模型

适用于触控板。触控板本身提供了高精度的 Delta 值，我们不需要模拟惯性（系统已处理），只需要平滑地过渡到目标位置，避免画面撕裂或抖动。

插值计算：$x_{new} = x_{old} + (x_{target} - x_{old}) \cdot (1 - (1 - l)^{t_{factor}})$

其中：

$l$：插值系数 (LerpFactor)，默认为 0.5。数值越大，跟随越紧密。
$t_{factor}$：时间标准化因子，$\frac{dt}{TargetFrameTime}$。

三、快速开始

在项目中引入FluentWpfCore包，然后使用：

<Window xmlns:fluent="clr-namespace:FluentWpf.Controls;assembly=FluentWpfCore" 
        ...>

<fluent:SmoothScrollViewer>
    <!--可选 自定义模型及其参数-->
    <fluent:SmoothScrollViewer.Physics>
        <fluent:DefaultScrollPhysics MinVelocityFactor="1.2" />
    </fluent:SmoothScrollViewer.Physics>
    ...
</fluent:SmoothScrollViewer>

</Window>

属性	类型	默认值	说明
`IsEnableSmoothScrolling`	`bool`	`true`	启用或禁用平滑滚动动画（实际上会控制所有SmoothScrolling相关功能）
`PreferredScrollOrientation`	`Orientation`	`Vertical`	首选滚动方向：`Vertical` 或 `Horizontal`
`AllowTogglePreferredScrollOrientationByShiftKey`	`bool`	`true`	允许通过按住 Shift 键切换滚动方向
`Physics`	`IScrollPhysics`	`DefaultScrollPhysics`	控制滚动动画行为的物理模型

默认模型(DefaultScrollPhysics)可选参数：

参数	类型	默认值	说明
`MinVelocityFactor`	`double`	`1.2`	鼠标滚轮的最小速度倍率
`Friction`	`double`	`0.92`	鼠标滚轮的速度衰减系数
`LerpFactor`	`double`	`0.5`	触控板滚动的插值系数

四、了解更多

1) 为什么要“视觉满帧、逻辑低频”

在 WPF 里，ScrollToVerticalOffset/ScrollToHorizontalOffset 不是一个“只改数值”的轻量操作。它往往会驱动：

滚动条位置与 ScrollChanged 事件
布局与渲染链路（尤其是内容复杂时）
虚拟化容器的生成/回收（例如 VirtualizingStackPanel）

v2的实现把它放到 CompositionTarget.Rendering 的每一帧里调用，意味着UI线程必须在每帧都完成布局计算，这在内容复杂或CPU负载高时会直接卡死UI线程，导致掉帧或其他UI组件无响应。

v3 的分层策略是：

视觉层：用 TranslateTransform 做位移补偿，只影响渲染，不触发布局。
逻辑层：用 ScrollTo*Offset 推进真实偏移，但频率降低到 24Hz。

相当于把“高频的连续运动”交给 GPU（RenderTransform），把“低频但必要的状态推进”交给布局系统（ScrollTo）。或者理解为：视觉层做“动画”，逻辑层做“状态更新”，以低帧率推进布局计算，然后由视觉层平滑过渡，显著提升性能。

2) 关键状态：视觉差值（Visual Delta）

在 v3 里，始终存在两个 offset：

逻辑 offset：ScrollViewer 真正的 VerticalOffset/HorizontalOffset，决定滚动条与虚拟化。
视觉 offset：物理模型在每帧计算出的“应该看到的位置”。

两者的差值就是视觉补偿量：

$$\Delta = offset_{visual} - offset_{logical}$$

视觉层每帧做的事情非常纯粹：把这个差值通过 Transform 反向抵消掉，让用户“看到”的内容位置跟随视觉 offset。

垂直滚动：Transform.Y = -$\Delta$
水平滚动：Transform.X = -$\Delta$

这样带来两个好处：

逻辑层什么时候同步（调用 ScrollTo*Offset）可以自由选择频率，不会影响视觉连续性。
当逻辑层因为外部原因突变（拖动滚动条、代码调用 ScrollTo...、键盘导航）时，只要立刻重算差值，视觉层就仍然能保持连续。

3) 为什么要用真实 `dt`（而不是假设固定帧率）

CompositionTarget.Rendering 的触发并不严格等间隔：后台负载、窗口被遮挡、显示器刷新率、系统节能策略都会让帧间隔波动。

因此实现中用 Stopwatch.GetTimestamp() 计算真实 dt，并把 dt 传给物理模型。这意味着：

低帧率时不会“走慢动作”或突然“加速冲刺”
高刷屏（120/144Hz）不会因为更高帧数而滚得更远

配合 DefaultScrollPhysics 中的 timeFactor = dt / TargetFrameTime，滚动手感可以在不同帧率下保持一致。

4) 关于逻辑同步频率

实现把逻辑同步频率设为 24Hz（ScrollBarUpdateInterval = 1/24s），这是一个折中：

频率更高：滚动条更“实时”，虚拟化更及时，但布局压力上升。
频率更低：性能更好，但滚动条会有视觉滞后，虚拟化加载可能会出现空白频闪。

一个可能的缓解思路是让虚拟化容器提前加载，会增加一点内存开销，但能减少空白频闪。

一般来说：

内容很重（大量图片、复杂控件、阴影/模糊多）：可以把同步频率调低一点。
列表虚拟化强依赖“及时生成下一屏”（例如聊天列表/文件列表）：可以适当提高，但要观察 CPU。

5) 注意 ScrollChanged 状态变更

只靠渲染循环还不够，因为用户可以通过滚动条拖动来改变 offset。实现里在 OnScrollChanged 中做了两件重要的事情：

更新逻辑 offset（垂直/水平各自维护）。
如果当前正在平滑滚动，并且变化来自“当前激活方向”，就立刻更新 Transform，让画面位置保持连续。

6) 横向滚动与 Shift 切换

v3 支持横向与纵向两种滚动方向，并且提供了按住 Shift 切换滚动方向的特性。

7) 为什么滚动时要临时关闭 HitTest

渲染循环开始时把 IsHitTestVisible 设为 false，结束时恢复。

高速滚动时，鼠标在大量元素上扫过会触发频繁的命中测试和状态变更（Hover、ToolTip、触发器）。关闭命中测试能够显著降低这些开销，提升滚动性能。

当然，它也意味着滚动过程中无法点击内容。

8) 如何写你自己的物理模型

IScrollPhysics 的接口设计刻意简单：

OnScroll(...)：只负责接收一次输入意图（delta + 是否精确 + 边界 + 时间间隔）。
Update(...)：每帧推进到新位置（帧率无关）。
IsStable：告诉外部何时可以退出渲染循环。

写在最后

::github{repo="TwilightLemon/FluentWpfCore"} 相关组件均开源在 FluentWpfCore 仓库，欢迎 star 和 PR！仓库保持活跃更新。

感谢阅读，文章如有不妥之处，请各位大佬不吝指正！

WPF 为ContextMenu使用Fluent风格的亚克力材质特效

Wed, 19 Nov 2025 00:00:00 GMT

书接上回，我们的Fluent WPF的版图已经完成了：

Fluent Window: WPF 模拟UWP原生窗口样式——亚克力|云母材质、自定义标题栏样式、原生DWM动画（附我封装好的类）
Fluent Popup & ToolTip: WPF中为Popup和ToolTip使用WindowMaterial特效 win10/win11
Fluent ScrollViewer: WPF 使用CompositionTarget.Rendering实现平滑流畅滚动的ScrollViewer，支持滚轮、触控板、触摸屏和笔

先来看看效果图(win11)：
有以下xaml代码：

 <TextBlock.ContextMenu>
     <ContextMenu>
         <MenuItem Header="Menu Item 1" Icon="Cd" InputGestureText="aa?" />
         <MenuItem Header="Menu Item 2" >
             <MenuItem Header="Child Item 1" Icon="Ab" />
             <MenuItem Header="Child Item 2" Icon="Ad" />
             <MenuItem Header="Child Item 3" IsCheckable="True" IsChecked="True"/>
         </MenuItem>
         <MenuItem Header="Menu Item 3" Icon="cd" />
     </ContextMenu>
 </TextBlock.ContextMenu>

(由于我的win10虚拟机坏了，暂时没有测试)

前面的工作已经解决了让任意窗口支持Acrylic材质的问题，本文重点介绍ContentMenu和MenuItem的样式适配和实现。

本文的Demo：
::github{repo="TwilightLemon/WindowEffectTest"}

一、为什么需要一个新的ContextMenu和MenuItem样式

如果你直接给ContextMenu应用WindowMaterial特效，可能会出现以下丑陋的效果：
或者：
原因在于古老的ContextMenu和MenuItem样式并不能通过简单修改Background实现我们想要的布局和交互效果。

二、ContextMenu与MenuItem的结构

1. ContextMenu 的结构

ContextMenu直观上看是一个Popup，但它的控件模板并不包含Popup，而是直接指定内部元素（包含一个ScrollViewer和StackPanel）。因此不能从控件模板中替换Popup为自定义的FluentPopup，需要使用其他手段让其内部Popup也支持Acrylic材质（见下文）。

2. MenuItem 的四种形态

在示例代码仓库中展示了较为完整的Menu相关的结构：

MenuItem根据其在菜单树中的位置，通过Role属性分为四种形态。我们在Style.Triggers中分别为它们指定了不同的模板：

TopLevelHeader: 顶级菜单项，且包含子菜单Popup（例如菜单栏上的"File"）。
TopLevelItem: 顶级菜单项，不含子菜单（例如菜单栏上的"Help"）。
SubmenuHeader: 子菜单项，且包含下一级子菜单Popup。
SubmenuItem: 子菜单项，不含子菜单（叶子节点）。其模板主要处理图标、文字、快捷键的布局。

三、重写Menu相关控件模板和样式

1. ContextMenu 样式

ContextMenu的样式主要参考了.NET 9自带的Fluent样式，并作了一些调整以适配Acrylic材质。主要目的是覆盖原始模板的Icon部分白框和分割线：因为我们的WindowMaterial已经为窗口自动附加上圆角、阴影和亚克力材质的DWM效果，所以我们只需要将ContextMenu的背景设置为透明，并移除不必要的边框和分割线即可。
此外，还添加了弹出动画（是在Popup内部做的，并非对window，效果可能不会很理想）。

2. MenuItem 样式

MenuItem的样式主要处理了图标、文字、快捷键的布局，并根据不同的角色（TopLevelHeader、TopLevelItem、SubmenuHeader、SubmenuItem）应用不同的模板。

TopLevelHeader: 只包含Icon和Header，以及弹出的Popup，只需要替换为自定义的FluentPopup即可。
TopLevelItem: 只包含Icon和Header，无Popup。
SubmenuHeader: 包含Icon、Header和Chevron图标(这里就是一个展开的箭头图标，但是官方叫做雪佛龙..?)，以及弹出的Popup，同样替换为FluentPopup。
SubmenuItem: 叶子节点，包含Icon、Header和InputGestureText。其模板主要处理图标、文字、快捷键的布局。

菜单项主要分为三个部分：Icon图标、Header文字和最右侧的提示文字或展开箭头图标。只需要保持三个部分的布局对其即可。如果IsCheckable为True，则Icon部分被自定义图标占据(√, 当IsChecked为True时)。

以下是完整的资源字典，包含了完整的注释。

<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:WindowEffectTest"
    xmlns:sys="clr-namespace:System;assembly=mscorlib">

    <!--  菜单边框内边距  -->
    <Thickness x:Key="MenuBorderPadding">0,3,0,3</Thickness>

    <!--  菜单项外边距  -->
    <Thickness x:Key="MenuItemMargin">4,1</Thickness>

    <!--  菜单项内容内边距  -->
    <Thickness x:Key="MenuItemContentPadding">10,6</Thickness>

    <!--  顶级菜单项外边距  -->
    <Thickness x:Key="TopLevelItemMargin">4</Thickness>

    <!--  顶级菜单项内容边距  -->
    <Thickness x:Key="TopLevelContentMargin">10</Thickness>

    <!--  菜单圆角半径  -->
    <CornerRadius x:Key="MenuCornerRadius">4</CornerRadius>

    <!--  顶级菜单圆角半径  -->
    <CornerRadius x:Key="TopLevelCornerRadius">6</CornerRadius>

    <!--  菜单动画持续时间  -->
    <Duration x:Key="MenuAnimationDuration">0:0:0.167</Duration>

    <!--  复选标记图标路径数据  -->
    <PathGeometry x:Key="CheckGraph">
        M392.533333 806.4L85.333333 503.466667l59.733334-59.733334 247.466666 247.466667L866.133333 213.333333l59.733334 59.733334L392.533333 806.4z
    </PathGeometry>

    <!--  前进箭头图标路径数据（用于子菜单指示器）  -->
    <PathGeometry x:Key="ForwardGraph">
        M283.648 174.081l57.225-59.008 399.479 396.929-399.476 396.924-57.228-59.004 335.872-337.92z
    </PathGeometry>

    <!--  菜单项ScrollViewer样式  -->
    <Style
        x:Key="MenuItemScrollViewerStyle"
        BasedOn="{StaticResource {x:Type ScrollViewer}}"
        TargetType="{x:Type ScrollViewer}">
        <Setter Property="HorizontalScrollBarVisibility" Value="Disabled" />
        <Setter Property="VerticalScrollBarVisibility" Value="Auto" />
    </Style>

    <!--  默认集合焦点视觉样式  得到键盘焦点时显示  -->
    <Style x:Key="DefaultCollectionFocusVisualStyle">
        <Setter Property="Control.Template">
            <Setter.Value>
                <ControlTemplate>
                    <Rectangle
                        Margin="4,0"
                        RadiusX="4"
                        RadiusY="4"
                        SnapsToDevicePixels="True"
                        Stroke="{DynamicResource AccentColor}"
                        StrokeThickness="2" />
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>

    <!--  默认上下文菜单样式  -->
    <Style x:Key="DefaultContextMenuStyle" TargetType="{x:Type ContextMenu}">
        <Setter Property="MinWidth" Value="140" />
        <Setter Property="Padding" Value="0" />
        <Setter Property="Margin" Value="0" />
        <Setter Property="HasDropShadow" Value="False" />
        <Setter Property="Grid.IsSharedSizeScope" Value="True" />
        <Setter Property="Popup.PopupAnimation" Value="None" />
        <Setter Property="SnapsToDevicePixels" Value="True" />
        <Setter Property="OverridesDefaultStyle" Value="True" />
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="{x:Type ContextMenu}">
                    <Border
                        x:Name="Border"
                        Padding="{StaticResource MenuBorderPadding}"
                        Background="{TemplateBinding Background}"
                        BorderBrush="{TemplateBinding BorderBrush}"
                        BorderThickness="{TemplateBinding BorderThickness}">
                        <!--  用于动画的转换变换  -->
                        <Border.RenderTransform>
                            <TranslateTransform />
                        </Border.RenderTransform>
                        <ScrollViewer CanContentScroll="True" Style="{StaticResource MenuItemScrollViewerStyle}">
                            <!--  菜单项容器  -->
                            <StackPanel
                                ClipToBounds="True"
                                IsItemsHost="True"
                                KeyboardNavigation.DirectionalNavigation="Cycle"
                                Orientation="Vertical" />
                        </ScrollViewer>
                    </Border>
                    <ControlTemplate.Triggers>
                        <!--  菜单打开时的动画效果  -->
                        <Trigger Property="IsOpen" Value="True">
                            <Trigger.EnterActions>
                                <BeginStoryboard>
                                    <Storyboard>
                                        <!--  Y轴平移动画：从-45向下滑入到0  -->
                                        <DoubleAnimation
                                            Storyboard.TargetName="Border"
                                            Storyboard.TargetProperty="(Border.RenderTransform).(TranslateTransform.Y)"
                                            From="-45"
                                            To="0"
                                            Duration="{StaticResource MenuAnimationDuration}">
                                            <DoubleAnimation.EasingFunction>
                                                <CircleEase EasingMode="EaseOut" />
                                            </DoubleAnimation.EasingFunction>
                                        </DoubleAnimation>
                                    </Storyboard>
                                </BeginStoryboard>
                            </Trigger.EnterActions>
                        </Trigger>
                    </ControlTemplate.Triggers>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>

    <!--  顶级菜单项头部模板（带子菜单）  -->
    <ControlTemplate x:Key="{x:Static MenuItem.TopLevelHeaderTemplateKey}" TargetType="{x:Type MenuItem}">
        <Border
            x:Name="Border"
            Margin="{StaticResource TopLevelItemMargin}"
            Background="{TemplateBinding Background}"
            BorderBrush="{TemplateBinding BorderBrush}"
            BorderThickness="{TemplateBinding BorderThickness}"
            CornerRadius="{StaticResource TopLevelCornerRadius}">
            <Grid>
                <Grid.RowDefinitions>
                    <RowDefinition Height="*" />
                    <RowDefinition Height="Auto" />
                </Grid.RowDefinitions>

                <!--  菜单项内容区域  -->
                <Grid Margin="{StaticResource TopLevelContentMargin}">
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="Auto" />
                        <ColumnDefinition Width="*" />
                    </Grid.ColumnDefinitions>

                    <!--  菜单项图标  -->
                    <ContentPresenter
                        x:Name="Icon"
                        Grid.Column="0"
                        Margin="0,0,6,0"
                        VerticalAlignment="Center"
                        Content="{TemplateBinding Icon}"
                        SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />

                    <!--  菜单项标题  -->
                    <ContentPresenter
                        x:Name="HeaderPresenter"
                        Grid.Column="1"
                        Margin="{TemplateBinding Padding}"
                        VerticalAlignment="Center"
                        ContentSource="Header"
                        RecognizesAccessKey="True"
                        SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"
                        TextElement.Foreground="{TemplateBinding Foreground}" />
                </Grid>

                <!--  子菜单弹出窗口（使用自定义FluentPopup）  -->
                <local:FluentPopup
                    x:Name="PART_Popup"
                    Grid.Row="1"
                    Grid.Column="0"
                    Focusable="False"
                    HorizontalOffset="-12"
                    IsOpen="{TemplateBinding IsSubmenuOpen}"
                    Placement="Bottom"
                    PlacementTarget="{Binding ElementName=Border}"
                    PopupAnimation="None"
                    VerticalOffset="1">
                    <Grid
                        x:Name="SubmenuBorder"
                        Background="{DynamicResource PopupWindowBackground}"
                        SnapsToDevicePixels="True">
                        <!--  子菜单动画变换  -->
                        <Grid.RenderTransform>
                            <TranslateTransform />
                        </Grid.RenderTransform>
                        <ScrollViewer
                            Padding="{StaticResource MenuBorderPadding}"
                            CanContentScroll="True"
                            Style="{StaticResource MenuItemScrollViewerStyle}">
                            <Grid>
                                <!--  子菜单项呈现器  -->
                                <ItemsPresenter
                                    x:Name="ItemsPresenter"
                                    Grid.IsSharedSizeScope="True"
                                    KeyboardNavigation.DirectionalNavigation="Cycle"
                                    KeyboardNavigation.TabNavigation="Cycle"
                                    SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />
                            </Grid>
                        </ScrollViewer>
                    </Grid>
                </local:FluentPopup>
            </Grid>
        </Border>
        <ControlTemplate.Triggers>
            <!--  无图标时隐藏图标区域  -->
            <Trigger Property="Icon" Value="{x:Null}">
                <Setter TargetName="Icon" Property="Visibility" Value="Collapsed" />
            </Trigger>
            <!--  无标题时隐藏标题并移除图标边距  -->
            <Trigger Property="Header" Value="{x:Null}">
                <Setter TargetName="Icon" Property="Margin" Value="0" />
                <Setter TargetName="HeaderPresenter" Property="Visibility" Value="Collapsed" />
            </Trigger>
            <!--  鼠标悬停高亮效果  -->
            <Trigger Property="IsHighlighted" Value="True">
                <Setter TargetName="Border" Property="Background" Value="{DynamicResource MaskColor}" />
            </Trigger>
            <!--  子菜单打开时的动画  -->
            <Trigger Property="IsSubmenuOpen" Value="True">
                <Trigger.EnterActions>
                    <BeginStoryboard>
                        <Storyboard>
                            <DoubleAnimation
                                Storyboard.TargetName="SubmenuBorder"
                                Storyboard.TargetProperty="(Border.RenderTransform).(TranslateTransform.Y)"
                                From="-45"
                                To="0"
                                Duration="{StaticResource MenuAnimationDuration}">
                                <DoubleAnimation.EasingFunction>
                                    <CircleEase EasingMode="EaseOut" />
                                </DoubleAnimation.EasingFunction>
                            </DoubleAnimation>
                        </Storyboard>
                    </BeginStoryboard>
                </Trigger.EnterActions>
            </Trigger>
        </ControlTemplate.Triggers>
    </ControlTemplate>

    <!--  顶级菜单项模板（无子菜单）  -->
    <ControlTemplate x:Key="{x:Static MenuItem.TopLevelItemTemplateKey}" TargetType="{x:Type MenuItem}">
        <Border
            x:Name="Border"
            Margin="{StaticResource TopLevelItemMargin}"
            Background="{TemplateBinding Background}"
            BorderBrush="{TemplateBinding BorderBrush}"
            BorderThickness="{TemplateBinding BorderThickness}"
            CornerRadius="{StaticResource TopLevelCornerRadius}">
            <Grid Margin="{StaticResource TopLevelContentMargin}">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="Auto" />
                    <ColumnDefinition Width="*" />
                </Grid.ColumnDefinitions>

                <!--  图标区域  -->
                <ContentPresenter
                    x:Name="Icon"
                    Grid.Column="0"
                    Margin="0,0,6,0"
                    VerticalAlignment="Center"
                    Content="{TemplateBinding Icon}"
                    SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />

                <!--  标题区域  -->
                <ContentPresenter
                    x:Name="HeaderPresenter"
                    Grid.Column="1"
                    Margin="{TemplateBinding Padding}"
                    VerticalAlignment="Center"
                    ContentSource="Header"
                    RecognizesAccessKey="True"
                    SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"
                    TextElement.Foreground="{TemplateBinding Foreground}" />
            </Grid>
        </Border>
        <ControlTemplate.Triggers>
            <!--  鼠标悬停效果  -->
            <Trigger Property="IsHighlighted" Value="True">
                <Setter TargetName="Border" Property="Background" Value="{DynamicResource MaskColor}" />
            </Trigger>
            <Trigger Property="Icon" Value="{x:Null}">
                <Setter TargetName="Icon" Property="Visibility" Value="Collapsed" />
            </Trigger>
            <Trigger Property="Header" Value="{x:Null}">
                <Setter TargetName="Icon" Property="Margin" Value="0" />
                <Setter TargetName="HeaderPresenter" Property="Visibility" Value="Collapsed" />
            </Trigger>
        </ControlTemplate.Triggers>
    </ControlTemplate>

    <!--  子菜单项模板（无子级）  -->
    <ControlTemplate x:Key="{x:Static MenuItem.SubmenuItemTemplateKey}" TargetType="{x:Type MenuItem}">
        <Border
            x:Name="Border"
            Margin="{StaticResource MenuItemMargin}"
            Background="{TemplateBinding Background}"
            BorderBrush="{TemplateBinding BorderBrush}"
            BorderThickness="{TemplateBinding BorderThickness}"
            CornerRadius="{StaticResource MenuCornerRadius}">
            <Grid Margin="{StaticResource MenuItemContentPadding}">
                <Grid.ColumnDefinitions>
                    <!--  图标/复选框列，使用共享大小组确保对齐  -->
                    <ColumnDefinition Width="Auto" SharedSizeGroup="MenuItemIconCol" />
                    <!--  标题内容列  -->
                    <ColumnDefinition Width="*" />
                    <!--  快捷键提示列，使用共享大小组确保对齐  -->
                    <ColumnDefinition Width="Auto" SharedSizeGroup="MenuItemRightPartCol" />
                </Grid.ColumnDefinitions>

                <!--  复选框图标容器  -->
                <Border
                    x:Name="CheckBoxIconBorder"
                    Grid.Column="0"
                    VerticalAlignment="Center"
                    Visibility="Collapsed">
                    <Path
                        x:Name="CheckBoxIcon"
                        Width="10"
                        Height="10"
                        HorizontalAlignment="Left"
                        VerticalAlignment="Center"
                        Fill="{TemplateBinding Foreground}"
                        Stretch="Uniform" />
                </Border>

                <!--  自定义图标  -->
                <ContentPresenter
                    x:Name="Icon"
                    Grid.Column="0"
                    Margin="0,0,6,0"
                    VerticalAlignment="Center"
                    Content="{TemplateBinding Icon}"
                    SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />

                <!--  菜单项标题内容  -->
                <ContentPresenter
                    Grid.Column="1"
                    Margin="{TemplateBinding Padding}"
                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
                    ContentSource="Header"
                    RecognizesAccessKey="True"
                    SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"
                    TextElement.Foreground="{TemplateBinding Foreground}" />

                <!--  快捷键提示文本  -->
                <TextBlock
                    x:Name="InputGestureText"
                    Grid.Column="2"
                    Margin="25,0,0,0"
                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
                    DockPanel.Dock="Right"
                    FontSize="11"
                    Opacity="0.67"
                    Text="{TemplateBinding InputGestureText}" />
            </Grid>
        </Border>
        <ControlTemplate.Triggers>
            <!--  高亮状态（鼠标悬停）  -->
            <Trigger Property="IsHighlighted" Value="True">
                <Setter TargetName="Border" Property="Background" Value="{DynamicResource MaskColor}" />
            </Trigger>
            <!--  无自定义图标时隐藏图标区域  -->
            <Trigger Property="Icon" Value="{x:Null}">
                <Setter TargetName="Icon" Property="Visibility" Value="Collapsed" />
            </Trigger>
            <!--  可复选时显示复选框图标容器  -->
            <Trigger Property="IsCheckable" Value="True">
                <Setter TargetName="CheckBoxIconBorder" Property="Visibility" Value="Visible" />
            </Trigger>
            <!--  已选中时显示复选标记  -->
            <Trigger Property="IsChecked" Value="True">
                <Setter TargetName="CheckBoxIcon" Property="Data" Value="{StaticResource CheckGraph}" />
            </Trigger>
            <!--  无快捷键时隐藏快捷键提示  -->
            <Trigger Property="InputGestureText" Value="">
                <Setter TargetName="InputGestureText" Property="Visibility" Value="Collapsed" />
            </Trigger>
        </ControlTemplate.Triggers>
    </ControlTemplate>

    <!--  子菜单头部模板（带下级子菜单）  -->
    <ControlTemplate x:Key="{x:Static MenuItem.SubmenuHeaderTemplateKey}" TargetType="{x:Type MenuItem}">
        <Grid>
            <Grid.RowDefinitions>
                <RowDefinition Height="*" />
                <RowDefinition Height="Auto" />
            </Grid.RowDefinitions>

            <!--  菜单项外观  -->
            <Border
                x:Name="Border"
                Grid.Row="1"
                Height="{TemplateBinding Height}"
                Margin="{StaticResource MenuItemMargin}"
                Background="Transparent"
                CornerRadius="{StaticResource MenuCornerRadius}">
                <Grid x:Name="MenuItemContent" Margin="{StaticResource MenuItemContentPadding}">
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="Auto" SharedSizeGroup="MenuItemIconCol" />
                        <ColumnDefinition Width="*" />
                        <ColumnDefinition Width="Auto" SharedSizeGroup="MenuItemRightPartCol" />
                    </Grid.ColumnDefinitions>

                    <!--  图标  -->
                    <ContentPresenter
                        x:Name="Icon"
                        Grid.Column="0"
                        Margin="0,0,6,0"
                        VerticalAlignment="Center"
                        Content="{TemplateBinding Icon}"
                        SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />

                    <!--  标题  -->
                    <ContentPresenter
                        x:Name="HeaderHost"
                        Grid.Column="1"
                        Margin="{TemplateBinding Padding}"
                        VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
                        ContentSource="Header"
                        RecognizesAccessKey="True"
                        SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />

                    <!--  右箭头指示器（表示有子菜单）  -->
                    <Path
                        Grid.Column="2"
                        Width="10"
                        Height="10"
                        Margin="0,0,4,0"
                        HorizontalAlignment="Right"
                        VerticalAlignment="Center"
                        Data="{StaticResource ForwardGraph}"
                        Fill="{TemplateBinding Foreground}"
                        Opacity="0.67"
                        Stretch="Uniform" />
                </Grid>
            </Border>

            <!--  子菜单弹出窗口（向右展开）  -->
            <local:FluentPopup
                x:Name="PART_Popup"
                Grid.Row="1"
                Focusable="False"
                IsOpen="{TemplateBinding IsSubmenuOpen}"
                Placement="Right"
                PlacementTarget="{Binding ElementName=MenuItemContent}"
                PopupAnimation="None">
                <Grid x:Name="PopupRoot" Background="{DynamicResource PopupWindowBackground}">
                    <!--  子菜单动画变换  -->
                    <Grid.RenderTransform>
                        <TranslateTransform />
                    </Grid.RenderTransform>
                    <ScrollViewer
                        Padding="{StaticResource MenuBorderPadding}"
                        CanContentScroll="True"
                        Style="{StaticResource MenuItemScrollViewerStyle}">
                        <!--  子菜单项容器  -->
                        <ItemsPresenter
                            x:Name="ItemsPresenter"
                            Grid.IsSharedSizeScope="True"
                            KeyboardNavigation.DirectionalNavigation="Cycle"
                            KeyboardNavigation.TabNavigation="Cycle"
                            SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />
                    </ScrollViewer>
                </Grid>
            </local:FluentPopup>
        </Grid>
        <ControlTemplate.Triggers>
            <!--  无图标时优化布局  -->
            <Trigger Property="Icon" Value="{x:Null}">
                <Setter TargetName="Icon" Property="Visibility" Value="Collapsed" />
                <Setter TargetName="Icon" Property="Margin" Value="0" />
            </Trigger>
            <!--  高亮效果  -->
            <Trigger Property="IsHighlighted" Value="true">
                <Setter TargetName="Border" Property="Background" Value="{DynamicResource MaskColor}" />
            </Trigger>
            <!--  子菜单打开动画  -->
            <Trigger Property="IsSubmenuOpen" Value="True">
                <Trigger.EnterActions>
                    <BeginStoryboard>
                        <Storyboard>
                            <!--  Y轴平移动画：从-45向下滑入到0  -->
                            <DoubleAnimation
                                Storyboard.TargetName="PopupRoot"
                                Storyboard.TargetProperty="(Grid.RenderTransform).(TranslateTransform.Y)"
                                From="-45"
                                To="0"
                                Duration="{StaticResource MenuAnimationDuration}">
                                <DoubleAnimation.EasingFunction>
                                    <CircleEase EasingMode="EaseOut" />
                                </DoubleAnimation.EasingFunction>
                            </DoubleAnimation>
                        </Storyboard>
                    </BeginStoryboard>
                </Trigger.EnterActions>
            </Trigger>
        </ControlTemplate.Triggers>
    </ControlTemplate>

    <!--  默认菜单项样式  -->
    <Style x:Key="DefaultMenuItemStyle" TargetType="{x:Type MenuItem}">
        <Setter Property="FocusVisualStyle" Value="{DynamicResource DefaultCollectionFocusVisualStyle}" />
        <Setter Property="KeyboardNavigation.IsTabStop" Value="True" />
        <Setter Property="Background" Value="Transparent" />
        <Setter Property="BorderBrush" Value="Transparent" />
        <Setter Property="BorderThickness" Value="1" />
        <Setter Property="Focusable" Value="True" />
        <Setter Property="OverridesDefaultStyle" Value="True" />
        <Style.Triggers>
            <!--  根据菜单项角色应用不同模板  -->

            <!--  顶级菜单项（带子菜单）  -->
            <Trigger Property="Role" Value="TopLevelHeader">
                <Setter Property="Template" Value="{StaticResource {x:Static MenuItem.TopLevelHeaderTemplateKey}}" />
                <Setter Property="Grid.IsSharedSizeScope" Value="True" />
                <Setter Property="Height" Value="{x:Static sys:Double.NaN}" />
            </Trigger>

            <!--  顶级菜单项（无子菜单）  -->
            <Trigger Property="Role" Value="TopLevelItem">
                <Setter Property="Template" Value="{StaticResource {x:Static MenuItem.TopLevelItemTemplateKey}}" />
                <Setter Property="Height" Value="{x:Static sys:Double.NaN}" />
            </Trigger>

            <!--  子菜单项（带子菜单）  -->
            <Trigger Property="Role" Value="SubmenuHeader">
                <Setter Property="Template" Value="{StaticResource {x:Static MenuItem.SubmenuHeaderTemplateKey}}" />
            </Trigger>

            <!--  子菜单项（无子菜单）  -->
            <Trigger Property="Role" Value="SubmenuItem">
                <Setter Property="Template" Value="{StaticResource {x:Static MenuItem.SubmenuItemTemplateKey}}" />
            </Trigger>
        </Style.Triggers>
    </Style>

</ResourceDictionary>

三、应用模板和样式到全局

将上面的资源字典合并到应用程序资源中，然后为ContextMenu和MenuItem指定默认样式：

 <Style BasedOn="{StaticResource DefaultContextMenuStyle}" TargetType="{x:Type ContextMenu}">
     <Style.Setters>
         <Setter Property="local:FluentTooltip.UseFluentStyle" Value="True" />
         <Setter Property="Background" Value="{DynamicResource PopupWindowBackground}" />
         <Setter Property="Foreground" Value="{DynamicResource ForeColor}" />
     </Style.Setters>
 </Style>
 <Style BasedOn="{StaticResource DefaultMenuItemStyle}" TargetType="MenuItem">
     <Setter Property="Height" Value="36" />
     <Setter Property="Foreground" Value="{DynamicResource ForeColor}" />
     <Setter Property="VerticalContentAlignment" Value="Center" />
 </Style>

注意，ContextMenu需要使用之前文章中的FluentTooltip.UseFluentStyle来实现亚克力材质特效。其内部原理都是反射获取popup的hwnd句柄，然后附加WindowMaterial特效。

参考连接

ContextMenu Styles and Templates WPF | Microsoft Learn

Menu Styles and Templates WPF | Microsoft Learn

PresentationFramework.Fluent/Themes/Fluent.xaml | GitHub

WPF 使用CompositionTarget.Rendering实现平滑流畅滚动的ScrollViewer，支持滚轮、触控板、触摸屏和笔

Sat, 08 Nov 2025 00:00:00 GMT

之前的文章中用WPF自带的动画库实现了一个简陋的平滑滚动ScrollViewer，它在只使用鼠标滚轮的情况下表现良好，但仍然有明显的设计缺陷和不足：

没有实现真正的动画衔接，只是单纯结束掉上一个动画，而不是继承其滚动速率；
使用触控板的体验极差
对触控屏和笔设备无效

为了解决以上问题，本文提出一种新的方案来实现平滑滚动ScrollViewer。该方案在OnMouseWheel、OnManipulationDelta和OnManipulationCompleted中直接处理(禁用)了系统的滚动效果，使用CompositionTarget.Rendering事件来驱动滚动动画。并针对滚轮方式和触控“跟手”分别进行优化，使用缓动滚动模型和精确滚动模型来实现平滑滚动。笔的支持得益于EleCho.WpfSuite库提供的StylusTouchDevice模拟，将笔输入映射为触摸输入。

为了最直观和最简单地解决问题，我们将应用场景设置为垂直滚动，水平滚动可以通过类似的方式实现。在github中查看最小可运行代码：
::github{repo="TwilightLemon/FluentScrollViewer"}

一、一些先验事实和设计思路

1.1 OnMouseWheel的触发逻辑

OnMouseWheel(MouseWheelEventArgs e)事件由WPF触发，e.Delta指示鼠标单次滚动的偏移值，通常为120或-120，这个值可以通过Mouse.MouseWheelDeltaForOneLine获得。这一逻辑在传统鼠标滚轮上顺理成章，但是在精准滚动设备（如触控板）上，滚动偏移量变得非常小，事件在高频率低偏移地触发，导致基于动画触发的滚动体验不佳。
测试发现，在以下两种场景中，OnMouseWheel事件具有特定的行为：

设备	缓慢滚动	快速滚动
鼠标滚轮	单个触发、一次一个事件	可能多个合并触发，e.Delta 是滚动值的倍数
触控板	持续滚动，间隔触发，e.Delta 值很小	Delta 快速增长，最后变为很小的值

因为触控板、触摸屏等精准滚动的使用场景，设备与人交互，意味着其数据本身就遵循物理规律。但是滚动的速率和距离被离散地传递给WPF，导致了滚动的生硬和不自然。
那么有没有一种思路，我们只需先接收这些滚动数据，然后在每一帧中根据这些数据来计算滚动位置？相当于把离散的滚动数据重新平滑化。

1.2 CompositionTarget.Rendering

CompositionTarget.Rendering是WPF渲染管线的一个事件，它在每一帧渲染之前触发。我们可以利用这个事件来实现自定义的滚动逻辑：先收集滚动参数，然后在OnRender事件中计算实际偏移值，并应用到ScrollViewer上。

1.3 两种场景、两种模型

我们将滚动分为两种场景：滚轮和触控，分别对应缓动滚动模型和精确滚动模型。

1.3.1 缓动滚动模型

类似于鞭挞陀螺使其旋转，每打一次都会给陀螺附加新的加速度，然后在接下来的时间中由于摩擦的存在而缓慢减速。我们基于这个思路来实现简易的缓动滚动模型：

先定义几个常量：衰减系数f=0.92、叠加速率力度系数n=2.0、目标帧时间frameTime=1.0/144以及行进常量p=24
每次OnMouseWheel事件触发时，叠加速率：v += e.Delta * n
在CompositionTarget.Rendering事件中：
- 计算刷新间隔时间Δt，以按照间隔时间计算滚动增量
- t= Δt / frameTime
- v *= f^t，模拟摩擦力的影响（确保在目标帧时间内衰减幅度一致）
- offset += v *(t/p)，计算滚动增量
将新的位置应用到ScrollViewer上

调整以上参数会带来相应的变化：

衰减系数f越小，滚动越快停下来
叠加速率力度系数n越大，每次滚动的速度越快
行进常量p越大，滚动越慢
通常你无需调整frameTime，它只是用来标准化滚动速度的

1.3.2 精确滚动模型

对于一个指定的滚动距离，我们希望能够精确地滚动到目标位置，而不是依赖于速率和衰减。模型只需要对离散距离补帧即可。具体而言，定义一个插值系数l，指示接近目标位置的速率，则offset=_targetOffset - _currentOffset) *l.

2025/11/08 更新

因为CompositionTarget.Rendering事件的触发频率并不固定，可能会因为系统负载等原因而变化较大，因此在计算滚动增量时需要考虑实际的时间增量。

二、实现

现在我们已经有思路了：先捕获OnMouseWheel等事件->判断使用哪个模型->挂载OnRender事件->在每一帧中计算新的滚动位置->应用到ScrollViewer上。以下实现通过继承ScrollViewer创建新的控件来实现。

2.1 先从鼠标滚轮与触控板开始

从OnMouseWheel中收集数据并判断模型:

 protected override void OnMouseWheel(MouseWheelEventArgs e)
 {
     e.Handled = true;

     //触摸板使用精确滚动模型
     _isAccuracyControl = IsTouchpadScroll(e);

     if (_isAccuracyControl)
         {
            _targetVelocity = 0; // 防止下一次触发缓动模型时继承没有消除的速度，造成滚动异常
            _targetOffset = Math.Clamp(_currentOffset - e.Delta, 0, ScrollableHeight);
        }
     else
         _targetVelocity += -e.Delta * VelocityFactor;// 鼠标滚动，叠加速度（惯性滚动）

     if (!_isRenderingHooked)
     {
         CompositionTarget.Rendering += OnRendering;
         _isRenderingHooked = true;
     }
 }

WPF似乎并没有提供直接判断触发设备的方法，这里使用了一个启发式判断逻辑：判断触发间隔时间和偏移值是否为滚轮偏移值的倍数。这一代码在诺尔大佬的EleCho.WpfSuite中亦有记载。

private bool IsTouchpadScroll(MouseWheelEventArgs e)
{
    var tickCount = Environment.TickCount;
    var isTouchpadScrolling =
            e.Delta % Mouse.MouseWheelDeltaForOneLine != 0 ||
            (tickCount - _lastScrollingTick < 100 && _lastScrollDelta % Mouse,MouseWheelDeltaForOneLine != 0);
    _lastScrollDelta = e.Delta;
    _lastScrollingTick = e.Timestamp;
    return isTouchpadScrolling;
    }

2.2 适配触摸屏和笔（更新：不建议使用）

触摸屏的输入可以通过ManipulationDelta和ManipulationCompleted事件来处理。我们将触摸输入映射为滚动偏移量，并使用精确滚动模型，在结束滚动时，可能还有由于快速滑动造成的惯性速率，我们在ManipulationCompleted中交给惯性滚动模型处理。

protected override void OnManipulationDelta(ManipulationDeltaEventArgs e)
{
    base.OnManipulationDelta(e);    //如果没有这一行则不会触发ManipulationCompleted事件??
    e.Handled = true;

    //手还在屏幕上，使用精确滚动
    _isAccuracyControl = true;
    double deltaY = -e.DeltaManipulation.Translation.Y;
    _targetOffset = Math.Clamp(_targetOffset + deltaY, 0, ScrollableHeight);
    // 记录最后一次速度
    _lastTouchVelocity = -e.Velocities.LinearVelocity.Y;

    if (!_isRenderingHooked)
    {
        CompositionTarget.Rendering += OnRendering;
        _isRenderingHooked = true;
    }
}

protected override void OnManipulationCompleted(ManipulationCompletedEventArgs e)
{
    base.OnManipulationCompleted(e);
    e.Handled = true;
    Debug.WriteLine("vel: "+ _lastTouchVelocity);
    _targetVelocity = _lastTouchVelocity; // 用系统识别的速度继续滚动
    _isAccuracyControl = false;

    if (!_isRenderingHooked)
    {
        CompositionTarget.Rendering += OnRendering;
        _isRenderingHooked = true;
    }
}

适配笔只需要把笔设备映射为触摸设备即可。这里使用了EleCho.WpfSuite库中的StylusTouchDevice来模拟触摸输入，最小可用代码在仓库中给出。

public MyScrollViewer()
{
    //...
    StylusTouchDevice.SetSimulate(this, true);
}

2.3 OnRender事件

在CompositionTarget.Rendering事件中，我们根据当前模型计算新的滚动位置，并应用到ScrollViewer上。

private void OnRendering(object? sender, EventArgs e)
{
    // 计算时间增量
    long currentTimestamp = Stopwatch.GetTimestamp();
    double deltaTime = (double)(currentTimestamp - _lastTimestamp) / Stopwatch.Frequency;
    _lastTimestamp = currentTimestamp;

    double timeFactor = deltaTime / TargetFrameTime;
    double _currentOffset = VerticalOffset;
    if (_isAccuracyControl)
    {
        // 精确滚动：Lerp 逼近目标（使用时间因子调整）
        double lerpAmount = 1.0 - Math.Pow(1.0 - LerpFactor, timeFactor);
        _currentOffset += (_targetOffset - _currentOffset) * lerpAmount;

        // 如果已经接近目标，就停止
        if (Math.Abs(_targetOffset - _currentOffset) < 0.5)
        {
            _currentOffset = _targetOffset;
            StopRendering();
        }
    }
    else
    {
        // 缓动滚动：速度衰减模拟（使用时间因子调整）
        if (Math.Abs(_targetVelocity) < 0.1)
        {
            _targetVelocity = 0;
            StopRendering();
            return;
        }

        // 使用时间因子调整摩擦力衰减
        _targetVelocity *= Math.Pow(Friction, timeFactor);

        // 根据实际时间计算偏移量
        _currentOffset = Math.Clamp(_currentOffset + _targetVelocity * (timeFactor / 24), 0, ScrollableHeight);
    }

    ScrollToVerticalOffset(_currentOffset);
}

三、已知问题

使用触摸屏时可能会造成闪烁，因为并没有完全禁用系统的滚动实现。但是如果禁用base.OnManipulationDelta(e)，则无法触发ManipulationCompleted事件，导致无法处理惯性滚动。
~~尚未测试与ListBox等控件的兼容性。~~

四、完整代码

以下是完整的MyScrollViewer代码，包含了上述所有实现细节。

using System.Diagnostics;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;

namespace FluentScrollViewer;

public class MyScrollViewer : ScrollViewer
{
    #region 模型参数
    /// <summary>
    /// 缓动模型的叠加速度力度，数值越大，滚动起始速率越快，滚得越远
    /// </summary>
    private const double VelocityFactor = 2.0;
    /// <summary>
    /// 缓动模型的速度衰减系数，数值越小，越快停下来
    /// </summary>
    private const double Friction = 0.92;

    /// <summary>
    /// 精确模型的插值系数，数值越大，滚动越快接近目标
    /// </summary>
    private const double LerpFactor = 0.5;

    /// <summary>
    /// 目标帧时间
    /// </summary>
    private const double TargetFrameTime = 1.0d / 144;
    #endregion

    public MyScrollViewer()
    {
        this.IsManipulationEnabled = true;
        this.PanningMode = PanningMode.VerticalOnly;
        this.IsManipulationEnabled = true;
        //使用此触屏滚动会导致闪屏，先不用了..
        // this.PanningDeceleration = 0; // 禁用默认惯性
        //StylusTouchDevice.SetSimulate(this, true);
        Unloaded += ScrollViewer_Unloaded;
    }
    //记录参数
    private int _lastScrollingTick = 0, _lastScrollDelta = 0;
    //private double _lastTouchVelocity = 0;
    private double _targetOffset = 0;
    private double _targetVelocity = 0;
    private long _lastTimestamp = 0;
    //标志位
    private bool _isRenderingHooked = false;
    private bool _isAccuracyControl = false;

    private void ScrollViewer_Unloaded(object sender, RoutedEventArgs e)
    {
        if (_isRenderingHooked)
        {
            CompositionTarget.Rendering -= OnRendering;
            _isRenderingHooked = false;
        }
    }

    /* protected override void OnManipulationDelta(ManipulationDeltaEventArgs e)
     {
         base.OnManipulationDelta(e);    //如果没有这一行则不会触发ManipulationCompleted事件??
         e.Handled = true;
         //手还在屏幕上，使用精确滚动
         _isAccuracyControl = true;
         double deltaY = -e.DeltaManipulation.Translation.Y;
         _targetOffset = Math.Clamp(_currentOffset + deltaY, 0, ScrollableHeight);
         // 记录最后一次速度
         _lastTouchVelocity = -e.Velocities.LinearVelocity.Y;

         if (!_isRenderingHooked)
         {
             _lastTimestamp = Stopwatch.GetTimestamp();
             CompositionTarget.Rendering += OnRendering;
             _isRenderingHooked = true;
         }
     }

     protected override void OnManipulationCompleted(ManipulationCompletedEventArgs e)
     {
         base.OnManipulationCompleted(e);
         e.Handled = true;
         Debug.WriteLine("vel: " + _lastTouchVelocity);
         _targetVelocity = _lastTouchVelocity; // 用系统识别的速度继续滚动
         _isAccuracyControl = false;

         if (!_isRenderingHooked)
         {
             _lastTimestamp = Stopwatch.GetTimestamp();
             CompositionTarget.Rendering += OnRendering;
             _isRenderingHooked = true;
         }
     }*/

    /// <summary>
    /// 判断MouseWheel事件由鼠标触发还是由触控板触发
    /// </summary>
    /// <param name="e"></param>
    /// <returns></returns>
    private bool IsTouchpadScroll(MouseWheelEventArgs e)
    {
        var tickCount = Environment.TickCount;
        var isTouchpadScrolling =
                e.Delta % Mouse.MouseWheelDeltaForOneLine != 0 ||
                (tickCount - _lastScrollingTick < 100 && _lastScrollDelta % Mouse.MouseWheelDeltaForOneLine != 0);
        //Debug.WriteLine(e.Delta + "  " + e.Timestamp + "  ==>" + isTouchpadScrolling);
        _lastScrollDelta = e.Delta;
        _lastScrollingTick = e.Timestamp;
        return isTouchpadScrolling;
    }

    protected override void OnMouseWheel(MouseWheelEventArgs e)
    {
        e.Handled = true;

        //触摸板使用精确滚动模型
        _isAccuracyControl = IsTouchpadScroll(e);

        if (_isAccuracyControl)
        {
            _targetVelocity = 0; // 防止下一次触发缓动模型时继承没有消除的速度，造成滚动异常
            _targetOffset = Math.Clamp(VerticalOffset - e.Delta, 0, ScrollableHeight);
        }
        else
            _targetVelocity += -e.Delta * VelocityFactor;// 鼠标滚动，叠加速度（惯性滚动）

        if (!_isRenderingHooked)
        {
            _lastTimestamp = Stopwatch.GetTimestamp();
            CompositionTarget.Rendering += OnRendering;
            _isRenderingHooked = true;
        }
    }

    private void OnRendering(object? sender, EventArgs e)
    {
        // 计算时间增量
        long currentTimestamp = Stopwatch.GetTimestamp();
        double deltaTime = (double)(currentTimestamp - _lastTimestamp) / Stopwatch.Frequency;
        _lastTimestamp = currentTimestamp;

        double timeFactor = deltaTime / TargetFrameTime;
        double _currentOffset = VerticalOffset;
        if (_isAccuracyControl)
        {
            // 精确滚动：Lerp 逼近目标（使用时间因子调整）
            double lerpAmount = 1.0 - Math.Pow(1.0 - LerpFactor, timeFactor);
            _currentOffset += (_targetOffset - _currentOffset) * lerpAmount;

            // 如果已经接近目标，就停止
            if (Math.Abs(_targetOffset - _currentOffset) < 0.5)
            {
                _currentOffset = _targetOffset;
                StopRendering();
            }
        }
        else
        {
            // 缓动滚动：速度衰减模拟（使用时间因子调整）
            if (Math.Abs(_targetVelocity) < 0.1)
            {
                _targetVelocity = 0;
                StopRendering();
                return;
            }

            // 使用时间因子调整摩擦力衰减
            _targetVelocity *= Math.Pow(Friction, timeFactor);

            // 根据实际时间计算偏移量
            _currentOffset = Math.Clamp(_currentOffset + _targetVelocity * (timeFactor / 24), 0, ScrollableHeight);
        }

        ScrollToVerticalOffset(_currentOffset);
    }

    private void StopRendering()
    {
        CompositionTarget.Rendering -= OnRendering;
        _isRenderingHooked = false;
    }
}

WPF 使用GDI+提取图片主色调并生成Mica材质特效背景

Wed, 28 May 2025 00:00:00 GMT

先看效果，在浅色模式下：
在深色模式下：

P.S. 此算法只是尽可能地接近Windows Mica效果，并非实际实现；主色调提取算法只能确保在绝大多数情况下适用。

测试项目在Github上开源:
::github{repo="TwilightLemon/MicaImageTest"}

一、简要原理和设计

1.1 Mica效果

Mica效果是Windows 11的一个新特性，旨在为应用程序提供一种更柔和的背景效果。它通过使用桌面壁纸的颜色和纹理来创建一个静态的模糊背景效果。一个大致的模拟过程如下：

根据颜色模式(浅色或深色)来调整图像对比度
增加一个白色/黑色的遮罩层
大半径高斯模糊处理

在仓库代码中给出了所有组件的实现，如果你想调整效果，可以修改以下几个值：

public static void ApplyMicaEffect(this Bitmap bitmap,bool isDarkmode)
{
    bitmap.AdjustContrast(isDarkmode?-1:-20);//Light Mode通常需要一个更高的对比度
    bitmap.AddMask(isDarkmode);//添加遮罩层
    bitmap.ScaleImage(2);//放大图像(原始图像一般为500x500)以提高输出图像质量
    var rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
    bitmap.GaussianBlur(ref rect, 80f, false);//按需要调整模糊半径
}

1.2 主色调提取与微调

从原始图像中提取主色调，主要过程如下：

像素采样和颜色量化便于统计
过滤过黑或过白的颜色值(我们会在调整步骤单独处理)
根据HSL的饱和度和亮度来计算权重，
- 饱和度越高，权重越大
- 亮度稳定（我们定为0.6），权重越大
选择权重最大的颜色均值作为主色调

之后为了适配UI，保证亮度、饱和度适合用于呈现内容，还要对颜色进行微调：

将颜色转为HSL空间
根据颜色模式调节亮度
分层调整饱和度，一般来说暗色模式的对比度比亮色模式高
对特定色相区间（红/绿/蓝/黄）进行差异化调整

最后计算焦点颜色（FocusAccentColor）只需要根据颜色模式调整亮度即可。

二、使用方法

将代码仓库中的ImageHelper.cs添加到项目，然后在需要的地方调用Bitmap的扩展方法来处理图像。以下是一个简单的示例：

首先开启项目允许使用UnSafe代码：

  <PropertyGroup>
    <!-- 允许使用UnSafe代码 -->
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
  </PropertyGroup>

导入本地图像文件，计算主色调、焦点色调并应用Mica效果背景：

 var image=new BitmapImage(new Uri(ImagePath));
 SelectedImg = image;
 var bitmap = image.ToBitmap();
 //major color
 var majorColor = bitmap.GetMajorColor().AdjustColor(IsDarkMode);
 var focusColor = majorColor.ApplyColorMode(IsDarkMode);
 App.Current.Resources["AccentColor"] = new SolidColorBrush(majorColor);
 App.Current.Resources["FocusedAccentColor"] = new SolidColorBrush(focusColor);
 //background
 bitmap.ApplyMicaEffect(IsDarkMode);
 BackgroundImg = bitmap.ToBitmapImage();

其中，SelectedImg和BackgroundImg是绑定到UI的BitmapImage类型属性，IsDarkMode是指示当前颜色模式的布尔值。

三、注意事项

处理大图像时可能会导致性能下降，建议使用较小的图像或在后台线程中处理。
如果高斯模糊组件报错，请确保Nuget包System.Drawing.Common的版本为8.0.1，因为代码中使用了反射获取Bitmap内部的句柄。
你可能需要根据实际情况调整模糊半径和对比度等参数，以获得最佳效果。
库中实现可能并非最佳写法，如果有更好的方法可以提交PR或者评论区见。

最后附上ImageHelper.cs的完整代码

using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows.Media.Imaging;

namespace MicaImageTest;

public static class ImageHelper
{
    #region 处理模糊图像
    [DllImport("gdiplus.dll", SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
    private static extern int GdipBitmapApplyEffect(IntPtr bitmap, IntPtr effect, ref Rectangle rectOfInterest, bool useAuxData, IntPtr auxData, int auxDataSize);
    /// <summary>
    /// 获取对象的私有字段的值
    /// </summary>
    /// <typeparam name="TResult">字段的类型</typeparam>
    /// <param name="obj">要从其中获取字段值的对象</param>
    /// <param name="fieldName">字段的名称.</param>
    /// <returns>字段的值</returns>
    /// <exception cref="System.InvalidOperationException">无法找到该字段.</exception>
    /// 
    internal static TResult GetPrivateField<TResult>(this object obj, string fieldName)
    {
        if (obj == null) return default(TResult);
        Type ltType = obj.GetType();
        FieldInfo lfiFieldInfo = ltType.GetField(fieldName, BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic);
        if (lfiFieldInfo != null)
            return (TResult)lfiFieldInfo.GetValue(obj);
        else
            throw new InvalidOperationException(string.Format("Instance field '{0}' could not be located in object of type '{1}'.", fieldName, obj.GetType().FullName));
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct BlurParameters
    {
        internal float Radius;
        internal bool ExpandEdges;
    }
    [DllImport("gdiplus.dll", SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
    private static extern int GdipCreateEffect(Guid guid, out IntPtr effect);
    private static Guid BlurEffectGuid = new Guid("{633C80A4-1843-482B-9EF2-BE2834C5FDD4}");
    [DllImport("gdiplus.dll", SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
    private static extern int GdipSetEffectParameters(IntPtr effect, IntPtr parameters, uint size);
    public static IntPtr NativeHandle(this Bitmap Bmp)
    {
        // 通过反射获取Bitmap的私有字段nativeImage的值，该值为GDI+的内部图像句柄
        //新版(8.0.1)Drawing的Nuget包中字段由 nativeImage变更为_nativeImage
        return Bmp.GetPrivateField<IntPtr>("_nativeImage");
    }
    [DllImport("gdiplus.dll", SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
    private static extern int GdipDeleteEffect(IntPtr effect);
    public static void GaussianBlur(this Bitmap Bmp, ref Rectangle Rect, float Radius = 10, bool ExpandEdge = false)
    {
        int Result;
        IntPtr BlurEffect;
        BlurParameters BlurPara;
        if ((Radius < 0) || (Radius > 255))
        {
            throw new ArgumentOutOfRangeException("半径必须在[0,255]范围内");
        }
        BlurPara.Radius = Radius;
        BlurPara.ExpandEdges = ExpandEdge;
        Result = GdipCreateEffect(BlurEffectGuid, out BlurEffect);
        if (Result == 0)
        {
            IntPtr Handle = Marshal.AllocHGlobal(Marshal.SizeOf(BlurPara));
            Marshal.StructureToPtr(BlurPara, Handle, true);
            GdipSetEffectParameters(BlurEffect, Handle, (uint)Marshal.SizeOf(BlurPara));
            GdipBitmapApplyEffect(Bmp.NativeHandle(), BlurEffect, ref Rect, false, IntPtr.Zero, 0);
            // 使用GdipBitmapCreateApplyEffect函数可以不改变原始的图像，而把模糊的结果写入到一个新的图像中
            GdipDeleteEffect(BlurEffect);
            Marshal.FreeHGlobal(Handle);
        }
        else
        {
            throw new ExternalException("不支持的GDI+版本，必须为GDI+1.1及以上版本，且操作系统要求为Win Vista及之后版本.");
        }
    }
    #endregion

    public static System.Windows.Media.Color GetMajorColor(this Bitmap bitmap)
    {
        int skip = Math.Max(1, Math.Min(bitmap.Width, bitmap.Height) / 100);

        Dictionary<int, ColorInfo> colorMap = [];
        int pixelCount = 0;

        for (int h = 0; h < bitmap.Height; h += skip)
        {
            for (int w = 0; w < bitmap.Width; w += skip)
            {
                Color pixel = bitmap.GetPixel(w, h);

                // 量化颜色 (减少相似颜色的数量)
                int quantizedR = pixel.R / 16 * 16;
                int quantizedG = pixel.G / 16 * 16;
                int quantizedB = pixel.B / 16 * 16;

                // 排除极端黑白色
                int averange = (pixel.R + pixel.G + pixel.B) / 3;
                if (averange < 24) continue;
                if (averange > 230) continue;

                int colorKey = (quantizedR << 16) | (quantizedG << 8) | quantizedB;

                if (colorMap.TryGetValue(colorKey, out ColorInfo info))
                {
                    info.Count++;
                    info.SumR += pixel.R;
                    info.SumG += pixel.G;
                    info.SumB += pixel.B;
                }
                else
                {
                    colorMap[colorKey] = new ColorInfo
                    {
                        Count = 1,
                        SumR = pixel.R,
                        SumG = pixel.G,
                        SumB = pixel.B
                    };
                }
                pixelCount++;
            }
        }

        if (pixelCount == 0 || colorMap.Count == 0)
            return System.Windows.Media.Colors.Gray;

        var weightedColors = colorMap.Values.Select(info =>
        {
            float r = info.SumR / (float)info.Count / 255f;
            float g = info.SumG / (float)info.Count / 255f;
            float b = info.SumB / (float)info.Count / 255f;

            // 转换为HSL来检查饱和度和亮度
            RgbToHsl(r, g, b, out float h, out float s, out float l);

            // 颜色越饱和越有可能是主色调，过亮或过暗的颜色权重降低
            float weight = info.Count * s * (1 - Math.Abs(l - 0.6f) * 1.8f);

            return new
            {
                R = info.SumR / info.Count,
                G = info.SumG / info.Count,
                B = info.SumB / info.Count,
                Weight = weight
            };
        })
        .OrderByDescending(c => c.Weight);

        if (weightedColors.First() is { } dominantColor)
        {
            // 取权重最高的颜色
            return System.Windows.Media.Color.FromRgb(
                (byte)dominantColor.R,
                (byte)dominantColor.G,
                (byte)dominantColor.B);
        }

        return System.Windows.Media.Colors.Gray;
    }

    private class ColorInfo
    {
        public int Count { get; set; }
        public int SumR { get; set; }
        public int SumG { get; set; }
        public int SumB { get; set; }
    }

    public static System.Windows.Media.Color AdjustColor(this System.Windows.Media.Color col, bool isDarkMode)
    {
        // 转换为HSL色彩空间，便于调整亮度和饱和度
        RgbToHsl(col.R / 255f, col.G / 255f, col.B / 255f, out float h, out float s, out float l);

        bool isNearGrayscale = s < 0.15f; // 判断是否接近灰度

        // 1. 基于UI模式进行初步亮度调整
        if (isDarkMode)
        {
            // 在暗色模式下，避免颜色过暗，提高整体亮度
            if (l < 0.5f)
                l = 0.3f + l * 0.5f;

            if (isNearGrayscale)
                l = Math.Max(l, 0.4f); // 确保足够明亮
        }
        else
        {
            // 在亮色模式下，避免颜色过亮，降低整体亮度
            if (l > 0.5f)
                l = 0.3f + l * 0.4f;

            if (isNearGrayscale)
                l = Math.Min(l, 0.6f); // 确保不过亮
        }

        // 2. 调整饱和度
        if (!isNearGrayscale)
        {
            if (s > 0.7f)
            {
                // 高饱和度降低，但是暗色模式需要更鲜明的颜色
                s = isDarkMode ? 0.7f - (s - 0.7f) * 0.2f : 0.65f - (s - 0.7f) * 0.4f;
            }
            else if (s > 0.4f)
            {
                // 中等饱和度微调
                s = isDarkMode ? s * 0.85f : s * 0.75f;
            }
            else if (s > 0.1f) // 低饱和度但不是接近灰度
            {
                // 低饱和度增强，尤其在暗色模式下
                s = isDarkMode ? Math.Min(0.5f, s * 1.5f) : Math.Min(0.4f, s * 1.3f);
            }
        }

        // 3. 特殊色相区域的处理
        if (!isNearGrayscale) // 仅处理有明显色相的颜色
        {
            // 红色区域 (0-30° 或 330-360°)
            if ((h <= 0.08f) || (h >= 0.92f))
            {
                if (isDarkMode)
                {
                    // 暗色模式下红色需要更高饱和度和亮度
                    s = Math.Min(0.7f, s * 1.1f);
                    l = Math.Min(0.8f, l * 1.15f);
                }
                else
                {
                    // 亮色模式下红色降低饱和度，避免刺眼
                    s *= 0.8f;
                    l = Math.Max(0.4f, l * 0.9f);
                }
            }
            // 绿色区域 (90-150°)
            else if (h >= 0.25f && h <= 0.42f)
            {
                if (isDarkMode)
                {
                    // 暗色模式下绿色提高亮度，降低饱和度，避免荧光感
                    s *= 0.85f;
                    l = Math.Min(0.7f, l * 1.2f);
                }
                else
                {
                    // 亮色模式下绿色降低饱和度更多
                    s *= 0.75f;
                }
            }
            // 蓝色区域 (210-270°)
            else if (h >= 0.58f && h <= 0.75f)
            {
                if (isDarkMode)
                {
                    // 暗色模式下蓝色提高亮度和饱和度
                    s = Math.Min(0.85f, s * 1.2f);
                    l = Math.Min(0.7f, l * 1.25f);
                }
                else
                {
                    // 亮色模式下蓝色保持中等饱和度
                    s = Math.Min(0.7f, Math.Max(0.4f, s));
                }
            }
            // 黄色区域 (30-90°)
            else if (h > 0.08f && h < 0.25f)
            {
                if (isDarkMode)
                {
                    // 暗色模式下黄色需要降低饱和度，提高亮度
                    s *= 0.8f;
                    l = Math.Min(0.75f, l * 1.2f);
                }
                else
                {
                    // 亮色模式下黄色大幅降低饱和度
                    s *= 0.7f;
                    l = Math.Max(0.5f, l * 0.9f);
                }
            }
        }



        // 5. 最终亮度修正 - 确保在各种UI模式下都有足够的对比度
        if (isDarkMode && l < 0.3f) l = 0.3f; // 暗色模式下确保最小亮度
        if (!isDarkMode && l > 0.7f) l = 0.7f; // 亮色模式下确保最大亮度

        // 转换回RGB
        HslToRgb(h, s, l, out float r, out float g, out float b);

        // 确保RGB值在有效范围内
        byte R = (byte)Math.Max(0, Math.Min(255, r * 255));
        byte G = (byte)Math.Max(0, Math.Min(255, g * 255));
        byte B = (byte)Math.Max(0, Math.Min(255, b * 255));

        return System.Windows.Media.Color.FromRgb(R, G, B);
    }
    public static System.Windows.Media.Color ApplyColorMode(this System.Windows.Media.Color color,bool isDarkMode)
    {
        RgbToHsl(color.R/255f,color.G/255f, color.B/255f,out float h, out float s, out float l);
        if (isDarkMode)
            l = Math.Max(0.05f, l - 0.1f);
        else
            l = Math.Min(0.95f, l + 0.1f);

        HslToRgb(h, s, l, out float r, out float g, out float b);
        return System.Windows.Media.Color.FromRgb((byte)(r * 255), (byte)(g * 255), (byte)(b * 255));
    }

    private static void RgbToHsl(float r, float g, float b, out float h, out float s, out float l)
    {
        float max = Math.Max(r, Math.Max(g, b));
        float min = Math.Min(r, Math.Min(g, b));

        // 计算亮度
        l = (max + min) / 2.0f;

        // 默认值初始化
        h = 0;
        s = 0;

        if (max == min)
        {
            // 无色调 (灰色)
            return;
        }

        float d = max - min;

        // 计算饱和度
        s = l > 0.5f ? d / (2.0f - max - min) : d / (max + min);

        // 计算色相
        if (max == r)
        {
            h = (g - b) / d + (g < b ? 6.0f : 0.0f);
        }
        else if (max == g)
        {
            h = (b - r) / d + 2.0f;
        }
        else // max == b
        {
            h = (r - g) / d + 4.0f;
        }

        h /= 6.0f;

        // 确保h在[0,1]范围内
        h = Math.Max(0, Math.Min(1, h));
    }

    private static void HslToRgb(float h, float s, float l, out float r, out float g, out float b)
    {
        // 确保h在[0,1]范围内
        h = ((h % 1.0f) + 1.0f) % 1.0f;

        // 确保s和l在[0,1]范围内
        s = Math.Max(0, Math.Min(1, s));
        l = Math.Max(0, Math.Min(1, l));

        if (s == 0.0f)
        {
            // 灰度颜色
            r = g = b = l;
            return;
        }

        float q = l < 0.5f ? l * (1.0f + s) : l + s - l * s;
        float p = 2.0f * l - q;

        r = HueToRgb(p, q, h + 1.0f / 3.0f);
        g = HueToRgb(p, q, h);
        b = HueToRgb(p, q, h - 1.0f / 3.0f);
    }

    private static float HueToRgb(float p, float q, float t)
    {
        // 确保t在[0,1]范围内
        t = ((t % 1.0f) + 1.0f) % 1.0f;

        if (t < 1.0f / 6.0f)
            return p + (q - p) * 6.0f * t;
        if (t < 0.5f)
            return q;
        if (t < 2.0f / 3.0f)
            return p + (q - p) * (2.0f / 3.0f - t) * 6.0f;
        return p;
    }
    public static BitmapImage ToBitmapImage(this Bitmap Bmp)
    {
        BitmapImage BmpImage = new();
        using (MemoryStream lmemStream = new())
        {
            Bmp.Save(lmemStream, ImageFormat.Png);
            BmpImage.BeginInit();
            BmpImage.StreamSource = new MemoryStream(lmemStream.ToArray());
            BmpImage.EndInit();
        }
        return BmpImage;
    }

    public static Bitmap ToBitmap(this BitmapImage img){
        using MemoryStream outStream = new();
        BitmapEncoder enc = new PngBitmapEncoder();
        enc.Frames.Add(BitmapFrame.Create(img));
        enc.Save(outStream);
        return new Bitmap(outStream);
    }

    public static void AddMask(this Bitmap bitmap,bool darkmode)
    {
        var color1 = darkmode ? Color.FromArgb(150, 0, 0, 0) : Color.FromArgb(160, 255, 255, 255);
        var color2 = darkmode ? Color.FromArgb(180, 0, 0, 0) : Color.FromArgb(200, 255, 255, 255);
        using Graphics g = Graphics.FromImage(bitmap);
        using LinearGradientBrush brush = new(
            new Rectangle(0, 0, bitmap.Width, bitmap.Height),
            color1,
            color2,
            LinearGradientMode.Vertical);
        g.FillRectangle(brush, new Rectangle(0, 0, bitmap.Width, bitmap.Height));
    }
    public static void AdjustContrast(this Bitmap bitmap, float contrast)
    {
        contrast = (100.0f + contrast) / 100.0f;
        contrast *= contrast;

        BitmapData data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
            ImageLockMode.ReadWrite, bitmap.PixelFormat);

        int width = bitmap.Width;
        int height = bitmap.Height;

        unsafe
        {
            for (int y = 0; y < height; y++)
            {
                byte* row = (byte*)data.Scan0 + (y * data.Stride);
                for (int x = 0; x < width; x++)
                {
                    int idx = x * 3;

                    float blue = row[idx] / 255.0f;
                    float green = row[idx + 1] / 255.0f;
                    float red = row[idx + 2] / 255.0f;

                    // 转换为HSL
                    RgbToHsl(red, green, blue, out float h, out float s, out float l);

                    // 调整亮度以增加对比度
                    l = (((l - 0.5f) * contrast) + 0.5f);

                    // 转换回RGB
                    HslToRgb(h, s, l, out red, out green, out blue);

                    row[idx] = (byte)Math.Max(0, Math.Min(255, blue * 255.0f));
                    row[idx + 1] = (byte)Math.Max(0, Math.Min(255, green * 255.0f));
                    row[idx + 2] = (byte)Math.Max(0, Math.Min(255, red * 255.0f));
                }
            }
        }

        bitmap.UnlockBits(data);
    }

    public static void ScaleImage(this Bitmap bitmap, double scale)
    {
        // 计算新的尺寸
        int newWidth = (int)(bitmap.Width * scale);
        int newHeight = (int)(bitmap.Height * scale);

        // 创建目标位图
        Bitmap newBitmap = new Bitmap(newWidth, newHeight, bitmap.PixelFormat);

        // 设置高质量绘图参数
        using (Graphics graphics = Graphics.FromImage(newBitmap))
        {
            graphics.CompositingQuality = CompositingQuality.HighQuality;
            graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
            graphics.SmoothingMode = SmoothingMode.HighQuality;
            graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;

            // 绘制缩放后的图像
            graphics.DrawImage(bitmap,
                new Rectangle(0, 0, newWidth, newHeight),
                new Rectangle(0, 0, bitmap.Width, bitmap.Height),
                GraphicsUnit.Pixel);
        }
        bitmap = newBitmap;
    }

    public static void ApplyMicaEffect(this Bitmap bitmap,bool isDarkmode)
    {
        bitmap.AdjustContrast(isDarkmode?-1:-20);
        bitmap.AddMask(isDarkmode);
        bitmap.ScaleImage(2);
        var rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
        bitmap.GaussianBlur(ref rect, 80f, false);
    }
}

Manuscript for "Identity-Based Encryption from the Weil Pairing"

Tue, 04 Mar 2025 00:00:00 GMT

Paper reference: Identity-Based Encryption from the Weil Pairing | SpringerLink

Known Public Encryption Scheme

Setup: Generate global system parameters and a master-key
Extract: use the master-key to generate the private-key corresponding to an public-key string $ID ∈ {0,1}^*$
Enc: encrypt M with ID → C
Dec: decrypt C with private-key

Application

(interesting)

Revocation of Public Keys

<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FBQTNBP2M%22%2C%22pageLabel%22%3A%22215%22%2C%22position%22%3A%7B%22pageIndex%22%3A2%2C%22rects%22%3A%5B%5B149.70940037000003%2C484.58142187000004%2C480.66033437%2C494.54442187%5D%2C%5B134.76490037000002%2C472.62582187000004%2C480.61540123999987%2C482.58882187%5D%2C%5B134.76480073999997%2C460.67022187000003%2C261.2849377400001%2C470.63322187%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FD9XP6B7N%22%5D%2C%22locator%22%3A%22215%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/BQTNBP2M?page=3">“One could potentially make this approach more granular by encrypting e-mail for Bob using “bob@hotmail.com ‖ current-date”. This forces Bob to obtain a new private key every day.”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FD9XP6B7N%22%5D%2C%22locator%22%3A%22215%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/D9XP6B7N">Boneh and Franklin, p. 215</a>)

<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FBQTNBP2M%22%2C%22pageLabel%22%3A%22215%22%2C%22position%22%3A%7B%22pageIndex%22%3A2%2C%22rects%22%3A%5B%5B381.72764474%2C400.89222187%2C480.7399387399999%2C410.85522187%5D%2C%5B134.76480073999997%2C388.93662187%2C480.66023474%2C398.89962187%5D%2C%5B134.76480073999997%2C376.98102187%2C291.50271674%2C386.94402187%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FD9XP6B7N%22%5D%2C%22locator%22%3A%22215%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/BQTNBP2M?page=3">“This approach enables Alice to send messages into the future: Bob will only be able to decrypt the e-mail on the date specified by Alice”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FD9XP6B7N%22%5D%2C%22locator%22%3A%22215%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/D9XP6B7N">Boneh and Franklin, p. 215</a>)

Delegation of Decryption Keys

bind <pk,sk> pairs with dates so that private-key can be stored in a vulnerable device: only thoses pairs are compromised and the Master-key is unharmed.
delegations of duties or other title as a skill to distribute private keys.

Construction

preparation

Bilinear Map: e.g. Weil pairing

$$ e: G_1 \times G_1 \rightarrow G_2 $$

, where $G_1$ and $G_2$ are two CYCLIC groups of some large prime order $p$ .

<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FBQTNBP2M%22%2C%22pageLabel%22%3A%22216%22%2C%22position%22%3A%7B%22pageIndex%22%3A3%2C%22rects%22%3A%5B%5B175.40282900000003%2C431.93851%2C480.096666%2C442.64928%5D%2C%5B134.765%2C418.29671934000004%2C480.64607099999995%2C432.06751%5D%2C%5B134.75561850000005%2C408.02853%2C264.157754%2C418.73827%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FD9XP6B7N%22%5D%2C%22locator%22%3A%22216%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/BQTNBP2M?page=4">“In our system, G1 is the group of points of an elliptic curve over Fp and G2 is a subgroup of F∗p2 . Therefore, we view G1 as an additive group and G2 as a multiplicative group.”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FD9XP6B7N%22%5D%2C%22locator%22%3A%22216%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/D9XP6B7N">Boneh and Franklin, p. 216</a>)

Bilinear $ e(aP,bQ) =e(P,Q)^{ab} ; for ; all ; P,Q∈G_1 ; and ; all ; a,b ∈ Z$
DH problem is hard in $G_1$

Properties of the Weil Pairing

Build:

$$ E:; y^2=x^3+1 ; over ; \mathbb{F}_p, $$

where prime $p$ satisfies $ p =2 ; (mod ; 3) ; and ; p=6q-1 ; for ; some ; prime ; q$

Syntax

Setup: k -> sys param (publicly shared) | master key (owned by PKG (<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FBQTNBP2M%22%2C%22pageLabel%22%3A%22216%22%2C%22position%22%3A%7B%22pageIndex%22%3A3%2C%22rects%22%3A%5B%5B194.46929001%2C189.19395407000002%2C303.8032520100001%2C199.15695407%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FD9XP6B7N%22%5D%2C%22locator%22%3A%22216%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/BQTNBP2M?page=4">“Private Key Generator”</a> ))
**Extract(master-key K,string ID) **=> private decryption key d.> ID is used as a public key
Enc/Dec

Secure Models

IND-ID-CCA: <span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FBQTNBP2M%22%2C%22pageLabel%22%3A%22218%22%2C%22position%22%3A%7B%22pageIndex%22%3A5%2C%22rects%22%3A%5B%5B411.2665887000001%2C530.4193803699999%2C480.6289947000001%2C540.38238037%5D%2C%5B134.75348670000005%2C518.4637803699999%2C210.6615837000001%2C528.42678037%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FD9XP6B7N%22%5D%2C%22locator%22%3A%22218%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/BQTNBP2M?page=6">“adaptive chosen ciphertext attack”</a><span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FD9XP6B7N%22%5D%2C%22locator%22%3A%22218%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/D9XP6B7N">Boneh and Franklin, p. 218</a>)
ID-OWE(one-way encryption): Given random public key $K_{pub}$ and ciphertext C which is the encryption of a random message M using $K_{pub}$ , A’s goal is to recover M.

models above allow A to conduct multi-round queries of <ID,d(private key)> pairs;

Scheme

MapToPoint(string ID)=> Point

$G: ; {0,1}^* \rightarrow \mathbb{F}_b$ , where in the security analysis G is viewed as a random oracle.

Compute $ y_0 = G(ID)$ and $ y_0 \rightarrow E:;x_0=(y^2_0 -1)^{1/3} =(y^2_0-1)^{(2p-1)/3};mod;p$
return $Q_{ID} = 6(x_0,y_0) ∈ E/\mathbb{F}_b$

Basic IBE (BasicIdent)

security parameter: $k$

Setup

Step 1: Choose a large k-bit prime p such that p = 2 mod 3 and p = 6q − 1 for some prime q > 3. Let E be the elliptic curve defined by $y^2 = x^3 + 1$ over $\mathbb{F}_b$ . Choose an arbitrary $P ∈ E/\mathbb{F}_p$ of order q.

Step 2: Pick a random $s ∈ Z^*q$ and set $P{pub} = sP$ .

Step 3: Choose a cryptographic hash function $H: ; F_{p^2} → {0, 1}^n$ for some n. Choose a cryptographic hash function $G: ; {0, 1}^∗ → \mathbb{F}_p$. The security analysis will view H and G as random oracles.

output: system params :=$<p,n,P,P_{pub},G,H>$ , master-key : $s∈\mathbb{Z}_q$ picked in Step 2.

Message space is $ M ={0,1}^n$

Ciphertext space is $ C= E/\mathbb{F}_b \times {0,1}^n$

Extract(string ID)

Step 1. $ Q_{ID} = MapToPoint(ID)$

Step 2. private key $d_{ID}=sQ_{ID}$, where s is the master key.

Encrypt

$$ Q_{ID} = MapToPoint(ID) $$

$$ r \xleftarrow{\text$} \mathbb{Z}_q $$

$$ C=<rP,M \oplus H(g^r_{ID})> ; where ; g_{ID}=e(Q_{ID},P_{pub}) $$

Decrypt

<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FBQTNBP2M%22%2C%22pageLabel%22%3A%22222%22%2C%22position%22%3A%7B%22pageIndex%22%3A9%2C%22rects%22%3A%5B%5B182.47192882999997%2C546.8013%2C480.63134203999965%2C556.7643%5D%2C%5B143.26931716999997%2C534.09952%2C480.59374037000003%2C544.80929%5D%2C%5B143.26549007000006%2C522.64177%2C339.58197999999993%2C532.85427%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FD9XP6B7N%22%5D%2C%22locator%22%3A%22222%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/BQTNBP2M?page=10">“Let C = 〈U, V 〉 ∈ C be a ciphertext encrypted using the public key ID. If U ∈ E/Fp is not a point of order q reject the ciphertext. Otherwise, to decrypt C using the private key dID compute:”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FD9XP6B7N%22%5D%2C%22locator%22%3A%22222%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/D9XP6B7N">Boneh and Franklin, p. 222</a>)

$$ M = V \oplus H(e(d_{ID},U)) $$

proof:

$$ e(d_{ID},U)=e(d_{ID},rP) =e(Q_{ID},P)^{sr} = e(Q_{ID},P_{pub}), ; where ; P_{pub}=sP ; is ; sys-param $$

IND-CCA Security: enhanced by Fujisaki-Okamoto transform

Fujisaki-Okamoto transform

Suppose $<PEnc,PDec>$ is a public key encryption scheme.H and G are hash functions(viewed as random oracles): $ H: {0,1}^n \times {0,1}^n \rightarrow \mathbb{F}_q$ , $G: {0,1}^n \rightarrow {0,1}^n$

$$ \sigma \xleftarrow{\text$} Key ; Domain ; of ; H $$

$$ Enc_{FO}: C_K = PEnc(pk,\sigma; H(\sigma,M)) , ; C_M= G(\sigma) \oplus M $$

$$ Dec_{FO}: \sigma = PDec(sk,C_K), ; verify ; C_K == Enc_{FO}(·).C_K ; then ; M= C_M \oplus G(\sigma) $$

Comparing with conventional Hybrid Encryption, FO transform surpasses as follows:

IND-CCA Security

using Hash functions to blind random seeds and message

check keys before decryption

Encrypt

$$ Q_{ID} = MapToPoint(ID) $$

$$ \sigma \xleftarrow{\text$} {0,1}^n, ; then ; r=H(\sigma,M) $$

$$ C=<rP,\sigma \oplus H(g^r_{ID}), M \oplus G(\sigma)> $$

Notice that $g^r_{ID} =e(Q_{ID,P_{pub}})^r$ binds with both the message M and the random seed $\sigma$ ,functioning as $H(\sigma,M)$ as that above.

Decrypt: receive C=<U,V,W>

Check if $U ∈ E/\mathbb{F}_p$ is not a point of order q, otherwise reject C
Compute $ \sigma = V \oplus H(e(d_{ID},U))$
Decrypt $ M=W \oplus G(\sigma)$
re-compute and check $r=H(\sigma,M) == U =rP$

Manuscript for "Public Key Encryption with Keyword Search"

Mon, 03 Mar 2025 00:00:00 GMT

Paper reference: Public Key Encryption with Keyword Search | SpringerLink

PEKS using Bilinear Maps

Construction

素数p阶群, （乘法群）定义双线性映射：

非退化性：

$ e(g,g) \rightarrow g' , ; where ; g' ; is ; a ; generator ; of ; G_2$

Hash functions:

$ H_1: {0,1}^* \rightarrow G_1$
$ H_2 : G_2 \rightarrow {0,1}^{\log{p}}$

PEKS Scheme

$$ PEKS ; Scheme:=(KeyGen,PEKS,Trapdoor,Test) $$

KeyGen:

input 安全参数$\lambda$ , 群阶p, $G_1$ ,$G_2$ ，$$ \alpha \xleftarrow{\text$} Z^*_p$$, g是 $G_1$ 的一个生成元

output $ A_{pub} = [g,h=g^\alpha] ; and ; A_{priv} =\alpha$

一个典型的RSA公私钥分发

PEKS($A_{pub},W$):

$$ r \xleftarrow{\text$} Z^*_p$$ , then compute $ t = e(H_1(W),h^r)$

output $S=[g^r,H_2(t)]$

$ Trapdoor(A_{priv},W) => T_W =H_1(W)^\alpha$

Notice that $ t ∈ G_2$ and $ T_W ∈ G_1$

Test($A_{pub}$, S, $T_W$)

S=[A,B]

output $H_2(e(T_W,A)) == B$

proof:

$$ H_2(e(T_W,A)) = H_2(e(H_1(W)^\alpha,g^r)) = H_2(e(H_1(W),g)^{\alpha r}) $$

$$ H_2(t) = H_2(e(H_1(W),h^r)) = H_2(e(H_1(W),g^{\alpha r}))= H_2(e(H_1(W),g)^{\alpha r}) $$

BDH Assumption

<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2F263DSXDA%22%2C%22pageLabel%22%3A%22512%22%2C%22position%22%3A%7B%22pageIndex%22%3A6%2C%22rects%22%3A%5B%5B134.76133%2C350.8833972%2C480.50933480000003%2C360.5445306%5D%2C%5B134.76129%2C339.0033972%2C480.6450542%2C350.71035%5D%2C%5B134.76151%2C327.0033972%2C480.55128557999967%2C336.66458059999997%5D%2C%5B134.7604%2C315.9373418%2C296.1176583800001%2C324.78413059999997%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FKYUKPHCB%22%5D%2C%22locator%22%3A%22512%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/263DSXDA?page=7">“Bilinear Diffie-Hellman Problem (BDH): Fix a generator g of G1. The BDH problem is as follows: given g, ga, gb, gc ∈ G1 as input, compute e(g, g)abc ∈ G2. We say that BDH is intractable if all polynomial time algorithms have a negligible advantage in solving BDH.”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FKYUKPHCB%22%5D%2C%22locator%22%3A%22512%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/KYUKPHCB">Boneh et al., 2004, p. 512</a>)

安全性证明

定理1. 非交互式PEKS在`适应性选择关键词攻击`下具有语义安全，如果BDH是难解问题。

安全目标：在自适应选择关键词攻击下语义安全。
归约到BDH问题：
- 假设存在攻击者 A 能以优势 ϵ 区分关键词加密，构造算法 B 利用 A 解决BDH问题。
- 模拟过程：
 1. B 接收BDH挑战 $(g,g^α,g^β,g^γ)$ ，模拟公钥 $h=g^α$ 。
 2. 对 A 的陷门查询，若关键词关联 $g^β$ ，则终止；否则返回合法陷门。
 3. 挑战阶段，随机选择 $W^b$ ，构造密文 $(g^γ,H_2(e(g^β,g^{αγ})))$ 。
 4. 攻击者成功时，B 从哈希列表提取 $ e(g,g)^{αβγ}$ 。
优势分析：
- B 的成功概率为 $ ϵ/(e \cdot q_T \cdot q_{H_2} ) $ ，其中 $q_T$ 为陷门查询次数， $q_{H_2}$ 为哈希查询次数。

Note(Manuscript) for "Device-Enhanced Secure Cloud Storage with Keyword Searchable Encryption and Deduplication"

Sun, 23 Feb 2025 00:00:00 GMT

Paper reference:

Bin-linear Map

<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FA54BVCMA%22%2C%22pageLabel%22%3A%22400%22%2C%22position%22%3A%7B%22pageIndex%22%3A4%2C%22rects%22%3A%5B%5B39.40400871913795%2C212.336551831%2C385.19543709878843%2C222.428273756752%5D%2C%5B39.4025698368481%2C200.375553295%2C385.2086489790012%2C211.0848576768476%5D%2C%5B39.402826538581394%2C189.57869231754017%2C108.45759041264529%2C198.51514429687816%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22400%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/A54BVCMA?page=5">“Suppose that G is an additive group of prime order p and GT is a multiplicative group of the same order. A bilinear map e : G × G → GT has the following three properties”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22400%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/JH5RQ343">Jiang et al., 2024, p. 400</a>)

Suppose $e$ is a map, e(param[] elements) is a function call.

Bio-linearThis means that e respects the group operations in both groups, i.e., it is linear in both arguments. The exponents a and b act multiplicatively on the map.
$ e(Q,R) \neq 1, for; all; Q,R∈G, Q \neq R $, where 1 denotes UNIT Element in Multiplicative Group.
e is effective to calcutale.

MLE

~~不用说懂得都懂~~

SAS-MA

Including 2 channels:

open channel<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FA54BVCMA%22%2C%22pageLabel%22%3A%22401%22%2C%22position%22%3A%7B%22pageIndex%22%3A5%2C%22rects%22%3A%5B%5B285.1118094399563%2C545.9691749927056%2C399.444596736801%2C554.9056269720436%5D%2C%5B53.57700598028832%2C534.0170440678318%2C399.4107235783859%2C542.9534960471698%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22401%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/A54BVCMA?page=6">“allows for transmission of messages of arbitrary length, but is subject to man-in-the-middle adversaries.”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22401%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/JH5RQ343">Jiang et al., 2024, p. 401</a>) Allow any ${0,1}^*$ messages; affacted by Man-in-the-middle Attack.
SAS channel<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FA54BVCMA%22%2C%22pageLabel%22%3A%22401%22%2C%22position%22%3A%7B%22pageIndex%22%3A5%2C%22rects%22%3A%5B%5B100.78179613468113%2C522.064913142958%2C361.072694015414%2C532.98743%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22401%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/A54BVCMA?page=6">“allows for transmission of up to t′-bit (e.g., 20-bit) messages”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22401%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/JH5RQ343">Jiang et al., 2024, p. 401</a>) Allows for any ${0,1}^{t'}$ messages.(t' is a short interger, e.g. 20)

“commitment“ is more alike a Hash sign of Message m for authentication.

Threat Model

CS \ KS: compromised<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FA54BVCMA%22%2C%22pageLabel%22%3A%22402%22%2C%22position%22%3A%7B%22pageIndex%22%3A6%2C%22rects%22%3A%5B%5B180.2653873864164%2C218.70994444120265%2C385.22794465299063%2C227.64639642054064%5D%2C%5B39.40319356190381%2C206.74884717655024%2C385.25783275250546%2C215.68529915588823%5D%2C%5B39.40319356190381%2C194.79671625167646%2C385.27178017554456%2C203.73316823101445%5D%2C%5B39.40319356190381%2C182.83561898702405%2C217.14593540814747%2C191.77207096636204%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22402%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/A54BVCMA?page=7">“An honest-but-curious cloud server may compromise the key servers to launch offline brute-force attacks and offline KGA against files and keywords, respectively. The number of compromised key servers is assumed to be less than the threshold.”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22402%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/JH5RQ343">Jiang et al., 2024, p. 402</a>)
Open Channel:
- disclose pw & pw-derived sk
- pw is low-entropy
- A can reveal pw by existing <pw,sk> pairs
Trusted device owned by R

cln. <span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FA54BVCMA%22%2C%22pageLabel%22%3A%22403%22%2C%22position%22%3A%7B%22pageIndex%22%3A7%2C%22rects%22%3A%5B%5B211.08968652198027%2C436.32279462013236%2C399.4137058101841%2C445.2592465994704%5D%2C%5B66.5273830842246%2C424.37066369525854%2C362.8977894069446%2C433.30711567459656%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22403%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/A54BVCMA?page=8">“secure against an honest-but-curious cloud server, compromised key servers, and man-in-the-middle adversaries”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22403%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/JH5RQ343">Jiang et al., 2024, p. 403</a>)

Construction

phase 1.

ParaGen:

KS*n , 0<t<n : threshold
素数p阶加法群G，生成元P；p阶乘法群GT
e双线性映射：e: G × G -> GT
Hash functions
- H: *->G
- h1: G&*->K(secure para.)
- h2: GT->K
- h3: *->K
- h4: G&*->Zp*
对称加密 SEnc\SDec
PKEnc\PKDec

ServerSecretGen:

KS 进行分布式密钥生成，产生α和β, and ones for their own.

KS_i owns αi & βi.

pk: V=α*P , Q=β*P and Vi Qi for KS_i of their own.

<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FA54BVCMA%22%2C%22pageLabel%22%3A%22403%22%2C%22position%22%3A%7B%22pageIndex%22%3A7%2C%22rects%22%3A%5B%5B276.7322854886617%2C158.5250944621%2C399.4017761988422%2C168.4876942161%5D%2C%5B53.57602892379428%2C146.9724637873616%2C399.3748729756876%2C155.90891576669958%5D%2C%5B53.57603217160175%2C133.86554353%2C399.391125895123%2C144.57494664150002%5D%2C%5B53.57731896793456%2C121.91364686200001%2C399.4062014756252%2C132.6229498155%5D%2C%5B53.579466303985384%2C109.952648327%2C325.05115699337745%2C120.6619522565%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22403%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/A54BVCMA?page=8">“the key servers perform the distributed secret generation algorithm illustrated in Algorithm 1 twice to create two secrets α and β that are shared among them. Each key server KSi (i ∈ [n]) owns the secret shares αi and βi. The public keys V = α · P , Q = β · P and the public shares Vi = αi · P , Qi = βi · P for i ∈ [n] are published.”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22403%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/JH5RQ343">Jiang et al., 2024, p. 403</a>)

运行算法两次得到的α和β分别用于File M和Keyword kw的签名

Algorithm 1:

实质是分布式密钥协商算法：

The public key PK is shared and available, while each server only knows its own private share.

prepare(input): 安全参数K, 大素数p, KS index 1~n, threshold t.

P是 Zp*的生成元

for every $KS_i$: , $$b_{i,0} \xleftarrow{\text$} Z^*p$$ $f_i(x) = poly_x: b{i,(0~t)}$
for every $KS_i$: 计算$b_{i,(0~t-1)} \cdot P$ 并公开，send $f_i(j)$ to every $KS_j$ now, for all $KS_i$ owns all KS's $b_{(index),(range: t)} \cdot P$> $b_{i,i} \cdot P$ ：目的是盲化$b_i$

threshold参数在$poly_x$上体现，只需要t个KS协作即可完成认证
all trusted KS verifies: $ f_j(para: index)\cdot P == \sum_{n=0}^{t-1}{i^n \cdot b_{j,n}} $> 确保得到的$b_i$与$KS_i$所声明的一致（在KS群中保持一致，不可能存在一个腐败的KS，除非所有KS都欺骗Server）
$KS_i$: 计算 $s_i = \sum_{q=1}^n{f_q(para:i)}$
$PK_i$ = $s_i \cdot P$ \\升阶(群内)盲化
for all KS: 协商获得 pk: $PK=\sum_{q=1}^{n}{b_{q,0} \cdot P}$

OUTPUT:

PK | {$PK_i ; for; every; KS_i$}

(${s_i}$ are stored inside KS as secure key)

$s_i,; α_i,; β_i$

use $PK_i (aka. ; V_i ; Q_i); to ; verify ; sign ; σ'_i$

ReceiverKeyGen:

k∈Zp* randomly (在device D中储存)

$$ \gamma = h_4(k \cdot H(pw) || pw ) , \Gamma = \gamma \cdot P $$

(<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FA54BVCMA%22%2C%22pageLabel%22%3A%22404%22%2C%22position%22%3A%7B%22pageIndex%22%3A8%2C%22rects%22%3A%5B%5B67.99864627306988%2C371.180908692414%2C216.33279033116298%2C380.117360671752%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22404%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/A54BVCMA?page=9">“the password-derived public key Γ”</a> )

γ是私钥，Γ是公钥 used in PKEnc\PKDec

phase 2.

MLEKey & sdk(server-derived key) Gen:

prepare: File M and its Keywords {w_j} T=|{wj}|

$$ r' ; and ; {r_j} \xleftarrow{\text{$}} Z^*_p ;,; T=|{r_j}| $$ $M’ = r’ \cdot H(M)$ 文件HASH盲化
$w’_j=r_j \cdot H(w_j)$ Keyword hash盲化
共享 M’ 与 ${w’_j}$ with All KS
for $KS_i$: Sign “the signatures $σ'i = α_i \cdot M' ; and ; δ{i',j} = β_i · w'_j ; for ; j = 1, 2, · · · , T .$ These signatures will be transmitted to S”
Server verifies signs

$$ e(σ’i,P)==e(M’,Vi); and ; e(δ’{i,j},P) ==e(w’_j,Q_i) $$

补充知识：

BLS签名的基本步骤

密钥生成：
- 选择一个椭圆曲线群 G 和双线性映射e
  
  $$ e: G \times G \rightarrow G_T $$
- 生成私钥$x \in \mathbb{Z}_q$（一个随机数，q 是群的阶）。
- 计算公钥 $P = x \cdot G$ ，其中 G 是基点。
签名生成：
- 对消息 m 进行哈希处理，得到 H(m)，这里 H(m)是一个映射到椭圆曲线的点。
- 使用私钥 x对 H(m) 进行签名：签名
  
  $$ \sigma = x \cdot H(m) $$
签名验证：
- 验证者首先计算 H(m) 并得到消息的哈希值。
- 使用公钥 P 和签名 σ 进行验证：检查是否满足以下等式：
  
  $$ e(\sigma, G) = e(H(m), P) $$
- 如果该等式成立，则签名是有效的，否则无效。
正确性验证(双线性):

$$ \sigma = x \cdot H(m)
$$

$$ P = x \cdot G
$$

e(\sigma.G) = e(H(m),G)^x $$

$$ e(H(m),P) = e(H(m),G)^x $$

拉格朗日插值（Lagrange Interpolation）

是一种多项式插值方法，用于通过已知的离散数据点（$x_i, y_i$）构建一个多项式，该多项式通过这些数据点。具体来说，给定 n+1 个数据点 $(x_0, y_0), (x_1, y_1), \dots, (x_n, y_n)$，拉格朗日插值通过构造一个多项式 L(x)，使得：

$$ L(x_i) = y_i, \quad \forall i = 0, 1, \dots, n $$

拉格朗日插值公式为：

$$ L(x) = \sum_{i=0}^{n} y_i \cdot \ell_i(x) $$

其中，$\ell_i(x)$ 为第 i 个基拉格朗日多项式，其定义为：

$$ \ell_i(x) = \prod_{\substack{0 \leq j \leq n \ j \neq i}} \frac{x - x_j}{x_i - x_j} $$

这意味着每个基多项式 $ell_i(x)$ 在 $x_i$ 处为1，其他数据点处为0。最终，L(x) 就是通过所有数据点的加权组合。

Encryption

使用MLE Key $ek_M$对称加密M：

$$ C_M = SEnc(ek_M,M). $$
Γ是用户的pw-derived pk，公钥加密MLE KEY:

$$ C_{ek_M} = PKEnc(\Gamma,ek_M) $$
加密server-derived keywords , ξj 从Zp*中随机选取：

$$ C_{sdk_wj} = (\xi_j \cdot P, h_2(\tau_j)) $$

$$ where, \tau_j = e(H(sdk_{w_k},\xi_j \cdot \Gamma)) $$

OUT SOURCE: $C_M$ , $C_(ek_M)$, ${C_(sdk_wj)}$ for j∈[T]

De-duplication

package:

$$ L_R := (Ind_{M^}, C_{eK_{M^}}, {C_{sdk_{w^*_j}}} ) $$

$$ L_G ={ Ind_M*, X_M*, C_M*} ; where, X_M* = h_3(C_m*) $$

phase 3. Data Access

R: Key Recovery (SAS-MA)

$input: pw \quad output: private-key ; \gamma$

Client interact with Device:

$$ r ∈ Z^*_p , ; z∈{0,1}^K, ; R_c ∈ {0,1}^{t'} $$

$$ 盲化 pw'=r \cdot H(pw), ; Com=h_3(pw' || R_c||z) $$

$$ pw'; and ;Com → D $$

$$ D: R_D ∈ {0,1}^{t'} → Client $$

$$ C: \Phi_C = R_C \oplus R_D ; send; (R_C,z) ;to ;D $$

在SAS信道中(C TO D)：

$$ \Phi_C = R_C \oplus R_D $$

D 计算 checksum

$$ \Phi_D =R_C \oplus R_D ; == \Phi_C $$

检查承诺

$$ Com == h_3(pw'||R_C||Z) $$

成功则进行(实质是一个同态加密，pw经过盲化，只传输并操作pw’，C拥有盲化因子, k是Device拥有的私钥)并 send to C:

$$ v'= k \cdot pw' $$

C 解盲化并得到私钥γ

$$ v=r^{-1} \cdot v' ; and ; private-key ; \gamma = h_4(v||pw) $$

即得到私钥 $\gamma = h_4(k \cdot H(pw) || pw )$

Keyword Search

$$ input:; keyword ;w^* $$

Client interacts with KS to blinds w*, r*∈Zp*

$$ W^* = r^* \cdot H(w^*) ;→ ; KS $$
For $KS_i$ :

$$ \xi'_i = \beta_i \cdot W^* ; → C $$
Client Check * threshold by:

$$ e(\xi'_i,P) = e(W^*,Q_i) $$

then computes:

$$ \xi = r^{*-1} \sum_{n∈L}\lambda_n \xi'_n $$

computes server-derived kw:

$$ sdk_{w*} = h_1(\xi||w^*) $$
$T_{sdk_{w^}} = \gamma \cdot H(sdk_{w^})$ send to CS
query $L_R$ for $C_{sdk_w} =(A,B)$
verify $h_2(e(T_{sdk_{w^*}},A)) == B$, where A is randomly selected by CS
send (enc)MLE Key $C_{ek_M}$ (and $C_M$ ?) to C

Decryption

$ek_M = PKDec(\gamma,C_{ek_M}) → MLE ; Key$

$ decrypts ; M=SDec(e_{k_M},C_M)$

Security Proof

定理1. 如果使用盲BLS签名和SAS-MA，则DULCET是抗中间人攻击的

<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FA54BVCMA%22%2C%22pageLabel%22%3A%22407%22%2C%22position%22%3A%7B%22pageIndex%22%3A11%2C%22rects%22%3A%5B%5B53.57699376294341%2C259.905737135855%2C399.433624012411%2C268.83222651543906%5D%2C%5B53.57699376294341%2C247.95360621098123%2C399.4027414712745%2C256.88009559056525%5D%2C%5B53.57699376294341%2C235.5740797566608%2C399.4024889076054%2C247.64235256299997%5D%2C%5B53.57774110636814%2C223.62231313662616%2C285.8597394107797%2C233.58491289062619%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22407%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/A54BVCMA?page=12">“Theorem 1. Assuming the blind BLS signature is of blindness and the short authentication string message authentication (SAS-MA) is secure, DULCET prevents a man-in-the-middle adversary A (e.g., CS∗) from learning the receiver R’s password-derived private key γ and password pw.”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22407%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/JH5RQ343">Jiang et al., 2024, p. 407</a>)

security provided by:

$$ private-key: ; \gamma = h_4(v||pw) $$

$$ v= k \cdot H(pw) $$

$$ where ; k \xleftarrow{\text{$}} Z^*_p ; in ; trusted ; device $$

Blinded BLS signature & SAS-MA 保证k只在device中派生，不在任何信道中显式传输，对于一个外部敌手只能获得公钥并通过DGA来匹配pw：

$$ public-key: ; \Gamma = \gamma \cdot P $$ ·

定理2. 对于所有PPT敌手，DULCET是不可预测的

<span class="highlight" data-annotation="%7B%22attachmentURI%22%3A%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FA54BVCMA%22%2C%22pageLabel%22%3A%22408%22%2C%22position%22%3A%7B%22pageIndex%22%3A12%2C%22rects%22%3A%5B%5B39.40187341822877%2C425.9870362459722%2C385.23160427594865%2C435.9496359999722%5D%2C%5B39.4018715352974%2C414.0349053210984%2C337.14611965246513%2C423.9975050750984%5D%5D%7D%2C%22citationItem%22%3A%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22408%22%7D%7D" ztype="zhighlight"><a href="zotero://open/library/items/A54BVCMA?page=13">“Theorem 2. DULCET is of unpredictability if for any PPT adversary A, the advantage of A winning the unpredictability experiment is negligible.”</a> <span class="citation" data-citation="%7B%22citationItems%22%3A%5B%7B%22uris%22%3A%5B%22http%3A%2F%2Fzotero.org%2Fusers%2F16470860%2Fitems%2FJH5RQ343%22%5D%2C%22locator%22%3A%22408%22%7D%5D%2C%22properties%22%3A%7B%7D%7D" ztype="zcitation">(<a href="zotero://select/library/items/JH5RQ343">Jiang et al., 2024, p. 408</a>)

在分布式密钥协商中，敌手最多能收集到t-1个子密钥(threshold t)

$ Exp^{UDP}_{A,DULCET}(1^{\lambda}) $

...

C++ 使用MIDI库演奏《晴天》

Thu, 13 Feb 2025 00:00:00 GMT

:::note[题记] 那些在MIDI库里徘徊的十六分音符
终究没能拼成告白的主歌

我把周杰伦的《晴天》写成C++的类
在每个midiEvent里埋藏故事的小黄花

调试器的断点比初恋更漫长
而青春不过是一串未导出的cmake工程文件

在堆栈溢出的夜晚
终将明白
有些旋律永远停在#pragma once的注释里
有些人永远停在未定义的引用里

或许你我的心跳终归运行在不同的时钟频率
却愿始终记得如何编译出一场永不落幕的晴天
:::

::github{repo="TwilightLemon/SunnyDays"}
就像在题记里说的一样，这是一个从未导出成功的工程文件。
所以如果你也想听听，可以在PowerShell里运行以下指令：

git clone https://github.com/TwilightLemon/SunnyDays
cd SunnyDays
mkdir build
cd build
cmake .. -G "MinGW Makefiles"
mingw32-make
./SunnyDays.exe

~~没环境？巧了，她也如是说。~~

下面来简单讲讲如何使用C++和MIDI库作曲吧。

一、开始工作

引入MIDI库和相关控制类

在CMakeLists.txt中：
```
target_link_libraries(SunnyDays winmm)
```

在MIDIHelper.h中：

#include <windows.h>
#pragma comment(lib,"winmm.lib")

定义Scale(音阶), Instrument(乐器, 仅包括部分)等枚举。我把Drum单独提了出来。

enum Scale
{
    X1 = 36, X2 = 38, X3 = 40, X4 = 41, X5 = 43, X6 = 45, X7 = 47,
    L1 = 48, L2 = 50, L3 = 52, L4 = 53, L5 = 55, L6 = 57, L7 = 59,
    M1 = 60, M2 = 62, M3 = 64, M4 = 65, M5 = 67, M6 = 69, M7 = 71,
    H1 = 72, H2 = 74, H3 = 76, H4 = 77, H5 = 79, H6 = 81, H7 = 83,
    LOW_SPEED = 500, MIDDLE_SPEED = 400, HIGH_SPEED = 300,
    _ = 0XFF
};
enum Drum{
    BassDrum = 36, SnareDrum = 38, ClosedHiHat = 42, OpenHiHat = 46
};
enum Instrument{
    AcousticGrandPiano = 0, BrightAcousticPiano = 1,
    ElectricGrandPiano = 2, HonkyTonkPiano = 3,
    ElectricPiano1 = 4, ElectricPiano2 = 5
};

一些基础方法，包括初始化/关闭设备、设置参数、播放单个音符和播放和弦等。

void initDevice();
void closeDevice();
void setInstrument(int channel, int instrument);
void setVolume(int channel, int volume);

void PlayNote(HMIDIOUT handle, UINT channel, UINT note, UINT velocity);

void playChord(HMIDIOUT handle, UINT channel, UINT note1, UINT note2, UINT note3, UINT note4, UINT velocity);

void playChord(HMIDIOUT handle, UINT channel, UINT note1, UINT note2, UINT note3, UINT velocity);

在MIDIHelper.cpp中：

void initDevice(){
    midiOutOpen(&hMidiOut, 0, 0, 0, CALLBACK_NULL);
}

void closeDevice(){
    midiOutClose(hMidiOut);
}

void setInstrument(int channel,int instrument){
    if (channel > 15 || instrument > 127) return;
    DWORD message = 0xC0 | channel | (instrument << 8);
    midiOutShortMsg(hMidiOut, message);
}

void setVolume(int channel,int volume){
    if (channel > 15 || volume > 127) return;
    DWORD message = 0xB0 | channel | (7 << 8) | (volume << 16);
    midiOutShortMsg(hMidiOut, message);
}

//播放单个音符，note是音符，velocity是力度
void PlayNote(HMIDIOUT handle, UINT channel, UINT note, UINT velocity) {
    if (channel > 15 || note > 127 || velocity > 127) return;
    DWORD message = 0x90 | channel | (note << 8) | (velocity << 16);
    midiOutShortMsg(handle, message);
}

//四指和弦
void playChord(HMIDIOUT handle, UINT channel, UINT note1, UINT note2, UINT note3, UINT note4, UINT velocity){
    if (channel > 15 || note1 > 127 || note2 > 127 || note3 > 127 || note4 > 127 || velocity > 127) return;
    DWORD message1 = 0x90 | channel | (note1 << 8) | (velocity << 16);
    DWORD message2 = 0x90 | channel | (note2 << 8) | (velocity << 16);
    DWORD message3 = 0x90 | channel | (note3 << 8) | (velocity << 16);
    DWORD message4 = 0x90 | channel | (note4 << 8) | (velocity << 16);
    midiOutShortMsg(handle, message1);
    midiOutShortMsg(handle, message2);
    midiOutShortMsg(handle, message3);
    midiOutShortMsg(handle, message4);
}

//三指和弦
void playChord(HMIDIOUT handle, UINT channel, UINT note1, UINT note2, UINT note3, UINT velocity) {
    if (channel > 15 || note1 > 127 || note2 > 127 || note3 > 127 || velocity > 127) return;
    DWORD message1 = 0x90 | channel | (note1 << 8) | (velocity << 16);
    DWORD message2 = 0x90 | channel | (note2 << 8) | (velocity << 16);
    DWORD message3 = 0x90 | channel | (note3 << 8) | (velocity << 16);
    midiOutShortMsg(handle, message1);
    midiOutShortMsg(handle, message2);
    midiOutShortMsg(handle, message3);
}

初始化和结束

先在头文件中定义一个全局MIDI句柄:

extern HMIDIOUT hMidiOut;

在入口处初始化MIDI设备并在结束时关闭：

HMIDIOUT hMidiOut;
int main() {
    initDevice();
    //...
    closeDevice();
    return 0;
}

初始化MIDI设备之后，为每一个乐器分配一个通道channel（0~15，通常9分配给打击类乐器,例如鼓组），控制音量volume，然后就可以开始演奏了。

二、自制简易乐谱

以Voice.cpp为例,定义一个数组为频谱，控制停顿和音符，遍历数组播放：

namespace SunnyDays{
    int channelVoice=1;
    void playVoice(int note, int velocity){
        PlayNote(hMidiOut, channelVoice, note, velocity);
    }
    void voice(){
        Sleep(13100);//等待前奏
        int sleep = 390;
        int data[] =
                {
                    //故事的小黄花
                    -90,
                    300,M5,M5,M1,M1,_,M2,M3,_,
                    //从出生那年就飘着
                    -90,
                    M5,M5,M1,M1,0,M2,M3,300,M2,M1,_,
                    //童年的荡秋千
                    -90,
                    300,M5,M5,M1,M1,_,M2,M3,_,
                    //随记忆一直晃到现在
                    -90,  
                    M3,_,500,M2,M3,M4,M3,M2,M4,M3,700,M2,700,_,
                    //...
                }
        for (auto i : data) {
            if(i==-30){logTime("Enter chorus");continue;}//调试用
            if(i==-90){NextLyric(); continue;}
            if (i == 0) { sleep = 180; continue; }
            //...
            if (i == _) {
                Sleep(390);
                continue;
            }

            playVoice(i, 80);
            Sleep(sleep);
        }
    }
}

打个鼓：

namespace SunnyDays{
    int channelBassDrum=9;

    void playDrum(int note, int velocity, int duration){
        PlayNote(hMidiOut, channelBassDrum, note, velocity);
        if(duration>0) {
            Sleep(duration);
            PlayNote(hMidiOut, channelBassDrum, note, 0);
        }
    }

    void bassDrum(){
        Sleep(11260);
        cout<<"Drum Bass Start!"<<endl;
        playDrum(SnareDrum,100,180);
        playDrum(SnareDrum,100,210);
        playDrum(BassDrum, 100, 210);
        playDrum(SnareDrum,100,190);
        playDrum(BassDrum, 100, 210);
        playDrum(SnareDrum,100,200);
        playDrum(SnareDrum,100,200);
        playDrum(OpenHiHat,100,-1);
        Sleep(200);
        //...
    }
}

简易副歌和弦，是从B站一位up主那里学的（已经忘记是哪位了qwq）：

namespace SunnyDays {
    int channelChord=2;
    void chordLevel(int level,int sleep,int repeat=2,int vel=70){
        repeat--;
        int down=8;
        if(level==1){
            //一级和弦 加右指
            playChord(hMidiOut, channelChord, M1, M3, M5, L1, vel);
            while(repeat--) {
                Sleep(sleep);
                playChord(hMidiOut, channelChord, M1, M3, M5, vel - down);
            }
        }else if(level==3){
            //三级和弦 加右指
            playChord(hMidiOut, channelChord, M3, M5, M7, L3, vel);
            while(repeat--) {
                Sleep(sleep);
                playChord(hMidiOut, channelChord, M3, M5, M7, vel - down);
            }
        }
        //...
    }
    void chord(){
        Sleep(63724);
        int sleep=740;
        int data[]={
                //刮风这天 我试过握着你手
                1,4,
                6,4,
                //但偏偏 雨渐渐
                4,2,
                5,2,
                //大到我看你不见
                1,4,
                //还有多久 我才能
                3,4,
                //↑ 在你身边
                6,4,
                //↓ 等到放晴的那天
                4,4,
                //↑ 也许我会比较好一点
                5,4,
                //..
        }
        int count=sizeof(data)/sizeof(int);
        for(int i=0;i<count;i+=2){
            cout<<"chord "<<data[i]<<"  x"<<data[i+1]<<endl;
            chordLevel(data[i],sleep,data[i+1]);
            Sleep(sleep);
        }
        //...
    }
}

三、合成演奏

我用了一个笨蛋方法，用多线程单独控制每一个通道，然后在主线程中调用：

int main(){
    //...
    initDevice();
    //设置音量
    setVolume(channelChord,80);
    setVolume(channelMainLine,80);
    setVolume(channelVoice,120);
    setVolume(channelBassDrum,80);

    //设置乐器（特定音色）
    setInstrument(channelChord,ElectricPiano1);
    setInstrument(channelMainLine,ElectricPiano1);


    system("pause");//按下回车，就开始啦
    beginLogger();


    thread t0(voice);
    thread t1(mainLine);
    thread t2(bassDrum);
    thread t3(chord);
    t0.join();
    t1.join();
    t2.join();
    t3.join();

    closeDevice();
    //...
}

（最后叠个甲，俺不懂音乐制作，更不会什么C++😿）

无加密的机密性：Chaffing and Winnowing原理和C#实验仿真

Sat, 23 Nov 2024 00:00:00 GMT

最近在Crypto 2023上看到一篇有趣的文章[1],其旨在一个存在拥有所有密钥并知道所有消息的“独裁者”的信道中，通过安排与常规密文无法区分的隐藏的“变形”消息来进行机密通信的方法——变形签名，但由于本人技术水平有限无法完整实现整个系统。而当阅读到其中的一个技术分支——Chaffing and Winnowing时惊喜地发现其实现方法之巧妙，又恰好在图灵班的密码学课程中学到了相关的Diffie-Hellman密钥交换协议和消息验证码MAC等知识，于是选取这篇上世纪的论文[2]来进行评论和仿真实验。

（是的你没看错，这是我在学校写的某低水平评论论文，觉得方法比较新颖巧妙，于是分享出来）

摘要：本文介绍了 Rivest 提出的 Chaffing and Winnowing 技术，该技术通过在消息中混入无关信息 (chaff) 并添加认证码 (MAC) 来实现机密性，即使在拥有所有加密密钥的“独裁者”信道中进行通信也能保证消息安全。文章详细阐述了该技术的原理、应用场景、潜在威胁以及未来研究方向，并通过实验仿真实现了整个技术流程。

一、简介

Rivest为我们介绍了一种新技术Chaffing and Winnowing——原意是指从谷粒中分离谷壳的过程，它不进行传统意义上的加密，而是将消息（wheat）分块并作认证，混入无关信息（chaff）之后再进行通信。 该项技术可以说是变形签名[1]的奠基之作，二者同样考虑一个问题：若独裁者拥有一个“后门”能够恢复密钥来对消息进行解密，那么如何在这样的信道上为消息提供机密性。Rivest说“像往常一样，关于规范技术的政策辩论最终会被技术创新所淘汰。试图通过规范加密来规范保密性，关闭了一扇门，却留下了另外两扇门（隐写术和Chaffing and Winnowing）.”后者与前者不同，隐写术[3]注重于在较大的、看似普通的信息（如图片）中隐藏机密，使得在算法不公开的前提下，一个PPT敌手无法有效区分机密内容和普通内容。显然这样的机密性是由算法保密性提供，并不符合卡尔霍夫原则[4]，即“一个密码系统的安全性不应依赖于算法的秘密性，而应依赖于密钥的秘密性”。 　　而在Chaffing and Winnowing中，消息机密性的保证被归因到MAC算法的认证性上，即在适应性选择明文攻击下具有存在不可伪造性[5]。对手无法怀疑两种数据包的存在，不具有机密认证则亦无法区分它们，即使原消息不受任何加密。

二、技术概要

原文中，作者循序渐进地介绍了这种技术的原理。 总体而言，发送方与接收方共享一个密钥，发送消息有两个部分：认证（添加消息认证码MAC）和添加chaff；接收方会通过验证MAC去除chaff（这个过程称为“winnowing”）以获得原始消息。整个过程中，没有对任何东西进行加密，因此可能不受出口管制（MAC不是加密）。 这是一个十分原始的想法，而后作者在考虑了实际运用的问题并做出诸多改进措施。

消息包的拆分与组装中，定义一个消息包为包含序列号、消息和MAC的三元组，以便接收方除重、组装和识别丢失。并在这里提出一种优化：发送方按顺序发送包，接收方一旦验证成功该序列号，则丢弃后续所有相同序列号的包。
一个良好的混淆过程会为消息使用的每一个序列号至少添加一个chaff。
对手可能通过每个包裹的内容来区分chaff和wheat，无限拆分wheat只会让传输更加低效。 为了解决以上问题，作者引用了自己的一项技术——全或无加密和包变换[11]。简单来说，通过这种变换之后，只有接收者收到全部消息才可逆转变换得到原文，否则只能得到垃圾消息。（让我们把算法具体实现放在仿真实验的部分。）使用此变换后，再对消息进行分包签名和发送，能够减少敌手直接通过辨识消息来查找wheat组合的机会。

三、研究分类、现状、难点分析与未来方向

我们现在已经了解到Chaffing and Winnowing技术的原理，可以发现数据包被分为了两种——为己用和混淆视听。前者的用法似乎已经固定，后者则隐藏着更大的利用潜能与危机。

1. 可否认加密[6]

如果对于每个wheat消息包，都生成一个使用特定密钥MAC认证的chaff，该chaff实际包含无害的消息，当使用该特定密钥进行认证时只能得到无害的消息，而真正在通讯双方交流的内容则被视为垃圾。如此使得在没有正确的解密密钥的情况下无法证明明文消息的来源或存在，即可否认加密。缺点在于，如果暴力机关要求通讯者提供所有密钥，则始终无法证明其是否已经提供全部密钥。

2. 防止流量分析

我尚未查找到已有的研究，只有维基百科中提及该技术的变体能够在分组网络中防止消息泄露和流量分析[7]。

3. 潜在的诬陷攻击

试想通讯双方之间存在一个发起中间人攻击的主动敌手，能够用自己的密钥生成MAC并嵌入有害信息，这对于通讯双方接受消息没有影响。此时敌手拥有通讯的全文和自己的密钥，则他可以对通信双方进行诬陷：指定其通讯内容为有害信息而他们无法辩解。一方面，由于可否认加密的存在，他们可被认定为提供虚假无害的消息密钥；另一方面，通讯双方根本没有机密性需求，也没有使用Chaffing and Winnowing技术，他们本身就没有密钥，敌手嵌入的信息在通讯双方的可忽视区内。

4. 如何协商一个私钥

原文中仅用一个段落草草带过双方协商密钥的过程——“例如”使用Diffie-Hellman密钥交换协议[8],即通讯双方交换对方的公钥与自己的私钥计算得到共有的密钥。然而原始的协议仅在窃听敌手存在的情况下是安全的，通讯双方并不知道对方的身份，如果要抵御主动攻击敌手，则需要涉及数字证书和指定验证者签名[9]等技术。这不在作者Rivest讨论的范围内，因为他的安全目标规定独裁者只知道加密密钥，而不限制认证。

5. 消息体积剧增与对抗暴力枚举

通讯双方仍需发送足够量的chaff包以迷惑敌手，使之在计算上找到包的组合不可行。这也无疑增大了包的体积，加之需要足够长度的MAC对抗碰撞。

目前该技术亟需解决的问题个人认为就是以上的3、4、5点；由此技术衍生的变形加密和变形签名相关研究已连续两年在CRYPTO发表[1][10]。

四、实验仿真

以下使用C# .NET 9 on Windows平台进行实验，模拟通讯双方使用Chaffing and Winnowing技术的全部过程。

1. 通讯双方协商密钥

生成ECDiffieHellmanCng实体并生成密钥对，输出公钥，要求输入私钥后计算共同密钥：

Console.WriteLine("Step 1: Key Exchange");
Console.WriteLine("Generating key...");
using var client = new ECDiffieHellmanCng()
{
    KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash,
    HashAlgorithm = CngAlgorithm.Sha256
};
var publicKey = client.PublicKey.ToByteArray();
Console.WriteLine($"Public Key: {Convert.ToBase64String(publicKey)}");
Console.WriteLine("Enter the public key of the other party:");
string otherKey = Console.ReadLine();
byte[] otherPublicKey = Convert.FromBase64String(otherKey);
var privateKey = client.DeriveKeyMaterial(CngKey.Import(otherPublicKey, CngKeyBlobFormat.EccPublicBlob));

2. 实现一个AONT变换

这里采用原作者的简单变换：将数据按BLOCK_SIZE分块，生成与块等大的随机生成的密钥块key，将每个数据块与key逐比特异或得到结果，再将key与结果做异或储存在结果的最后一块之后：

public static readonly int BLOCK_SIZE = 16;
    public static byte[] Transform(byte[] data){
        int blocks= (data.Length+BLOCK_SIZE-1)/BLOCK_SIZE;
        byte[] result = new byte[(blocks+1)*BLOCK_SIZE];//reserve one block for the hash
        byte[] key= new byte[BLOCK_SIZE];
        RandomNumberGenerator.Fill(key);

        Console.WriteLine($"Key: {string.Join(',',key)}");

        for(int i=0;i<blocks;i++){
            int offset = i*BLOCK_SIZE;
            for(int j=0;j<BLOCK_SIZE&&offset+j<data.Length;j++){
                result[offset+j]=(byte)(data[offset+j]^key[j]);
            }
        }

        for(int i=0;i<blocks*BLOCK_SIZE;i++){
            key[i%BLOCK_SIZE]^=result[i];  //key XOR with data blocks
        }
        Array.Copy(key,0,result,blocks*BLOCK_SIZE,BLOCK_SIZE);
        
        Console.WriteLine($"Last Block: {string.Join(',',key)}");

        return result;
    }

逆变换即先按BLOCK_SIZE分块，取出最后一块，依次与数据块做异或，解出key，再用key与数据块做异或还原原始数据。（注意，后续分包时，包的大小应该为BLOCK_SIZE的整数倍，以确保key按照相同的方式还原；逆变换时可能发现最后一块为{0}*，这并不影响解除key，因为与0异或为其本身。）

public static bool Reverse(byte[] data,out byte[] result){
    if(data.Length%BLOCK_SIZE!=0){
        result=null;
        return false;
    }

    int oriBlocks = data.Length/BLOCK_SIZE-1;
    result= new byte[oriBlocks*BLOCK_SIZE];

    byte[] key= new byte[BLOCK_SIZE];
    Array.Copy(data,oriBlocks*BLOCK_SIZE,key,0,BLOCK_SIZE);
    Console.WriteLine($"Last Block: {string.Join(',',key)}");
        
    for(int i=0;i<oriBlocks*BLOCK_SIZE;i++){
        key[i%BLOCK_SIZE]^=data[i];  //key XOR with data blocks
    }
    Console.WriteLine($"Key: {string.Join(',',key)}");

    for(int i=0;i<oriBlocks;i++){
        int offset = i*BLOCK_SIZE;
        for(int j=0;j<BLOCK_SIZE&&offset+j<result.Length;j++){
            result[offset+j]=(byte)(data[offset+j]^key[j]);
        }
    }

    return true;
}

以上，如果不首先访问消息的每个块，就不可能恢复原始明文。

有后人使用更复杂的算法实现AONT，例如使用线性变换而无任何加密假设的Stinson 算法[12]。似乎能提供更高的安全性。

调用ANOT变换，这里预先设定了发送的消息。

Console.WriteLine("Step 2: AONT");
string content = """
    The power to authenticate is in many cases the power to control, 
    and handing all authentication power to the government is beyond all reason. 
                                                    -- Ronald L. Rivest, 1998
    """;
byte[] dataBytes = Encoding.UTF8.GetBytes(content);
byte[] transformed = AONT.Transform(dataBytes);

3. 创建MAC消息验证码

这里使用HMAC-SHA256算法[13][14]给出简单的MAC算法三元组，其中Gen已由最初的密钥交换提供。

    public static byte[] Sign(byte[] key,byte[] data){
        using var hmac = new HMACSHA256(key);
        return hmac.ComputeHash(data);
    }
    public static bool Verify(byte[] key,byte[] data,byte[] signature){
        using var hmac = new HMACSHA256(key);
        byte[] computed = hmac.ComputeHash(data);
        return computed.Length==signature.Length&&computed.AsSpan().SequenceEqual(signature);
    }

4. 分包和签名

Console.WriteLine("Step 3: Packaging and Signing");
int numBlocks = (transformed.Length + BLOCK_SIZE - 1) / BLOCK_SIZE;
List<Package> packages = [];
for (int index = 0; index < numBlocks; index++)
{
    int offset = index * BLOCK_SIZE;
    int blockSize = Math.Min(BLOCK_SIZE, transformed.Length - offset);
    byte[] block = new byte[BLOCK_SIZE];
    Array.Copy(transformed, offset, block, 0, blockSize);

    byte[] signature = HMACHelper.Sign(privateKey, block);
    packages.Add(new Package(index, block, signature));
}
int packageCount = packages.Count;
Console.WriteLine($"Wheat packages: {packageCount}");

5. 加入带有随机数据的chaff

Console.WriteLine("Step 4: Adding Chaff Packages");
var rand = new Random();
for (int i = 0; i < packageCount; i++)
{
    int randCount = rand.Next(1, 5);
    for (int j = 0; j < randCount; j++)
    {
        var randData = new byte[BLOCK_SIZE];
        RandomNumberGenerator.Fill(randData);
        var randSignature = new byte[32];
        RandomNumberGenerator.Fill(randSignature);
        packages.Add(new Package(i, randData, randSignature));
    }
}
var sendPkg = packages.OrderBy(p => p.index);

6. 模拟发送

将所有的包按照index顺序排列后以Base64编码输出模拟发送，在接收端输入内容模拟接收。Base64编码能将byte[]转为文本格式，便于实验。

Console.WriteLine("Step 5: Sending Packages");
foreach (var pkg in sendPkg)
{
    Console.WriteLine($"{pkg.index},{Convert.ToBase64String(pkg.data)},{Convert.ToBase64String(pkg.signature)}");
}
Console.ReadLine();

7. 模拟接收

要求输入所有的包，键空以结束。

Console.WriteLine("Enter packages, done with empty line:");
List<Package> received = [];
try
{
      while (true)
      {
           string line = Console.ReadLine();
            if (string.IsNullOrEmpty(line)) break;
            string[] parts = line.Split(',');
            int index = int.Parse(parts[0]);
            byte[] data = Convert.FromBase64String(parts[1]);
            byte[] signature = Convert.FromBase64String(parts[2]);
            received.Add(new Package(index, data, signature));
      }
        Console.WriteLine($"Received packages: {received.Count}");
}
catch
{
     Console.WriteLine("Invalid input.");
     continue;
}

8. Winnowing和逆变获得原消息

Console.WriteLine("Winnowing...");
        var wheat = received.Where(p => HMACHelper.Verify(privateKey, p.data, p.signature)).OrderBy(p => p.index).ToList();
        var wheatCount = wheat.Count;
        Console.WriteLine($"Wheat packages: {wheatCount}");

        Console.WriteLine("Reverse AONT...");
        byte[] assembly = new byte[wheatCount * BLOCK_SIZE];
        for (int i = 0; i < wheatCount; i++)
        {
            Array.Copy(wheat[i].data, 0, assembly, i * BLOCK_SIZE, BLOCK_SIZE);
        }
        Console.WriteLine($"Assembly: {Convert.ToBase64String(assembly)}");
        if (AONT.Reverse(assembly, out byte[] result))
        {
            Console.WriteLine($"Result: {Encoding.UTF8.GetString(result)}");
        }
        else
        {
            Console.WriteLine("Reverse failed.");
        }

9. 测试

两实例交换公钥并在内部生成私钥：

发送方生成消息包：

接收方收到不完整包流，逆变得到乱码；如果接受不完整块流，逆变将失败：

只有完整获得包流才能解出原始信息：

:::note[注释]
为了方便起见，这里没有处理原消息长度，padding产生的字节被编为乱码。
在实际运用中，包的结构并非像实验中一样直接暴露。
以上实验项目代码在Github上由本人公开。
::: ::github{repo="TwilightLemon/TestCWCrypto"}

五、结论

Chaffing and Winnowing 技术提供了一种非传统的思路，利用 MAC 的认证性为消息提供机密性保障，即使在拥有所有加密密钥的信道中也能保证消息安全。该技术具有潜在的应用价值，但仍需解决一些挑战，例如协商私钥的安全性和消息体积的膨胀。未来研究可以探索更复杂的混淆过程、更高效的压缩算法以及更安全的密钥协商协议，以进一步提升 Chaffing and Winnowing 技术的安全性、效率和实用性。

参考文献

[1] Kutyłowski, M., Persiano, G., Phan, D.H., Yung, M., Zawada, M. (2023). “Anamorphic Signatures: Secrecy from a Dictator Who Only Permits Authentication!”. In: Handschuh, H., Lysyanskaya, A. (eds) Advances in Cryptology – CRYPTO 2023. Lecture Notes in Computer Science, vol 14082. Springer, Cham. https://doi.org/10.1007/978-3-031-38545-2_25

[2] Ronald L. Rivest. “Chaffing and Winnowing: Confidentiality without Encryption”. Cryptobytes, Summer 1998. MIT Laboratory for Computer Science. Web. 23 Nov. 2024. https://people.csail.mit.edu/rivest/pubs/Riv98a.pdf

[3] Peter Wayner. 1996. “Disappearing cryptography: being and nothingness on the net”. Academic Press Professional, Inc., USA. https://dl.acm.org/doi/10.5555/229879

[4] Kerckhoffs, A. (1883). “La cryptographie militaire”. Journal des sciences militaires. https://www.petitcolas.net/kerckhoffs/crypto_militaire_1.pdf

[5] Krawczyk, H., Bellare, M., and R. Canetti, “HMAC: Keyed-Hashing for Message Authentication”, RFC2104, February 1997. https://www.rfc-editor.org/rfc/rfc2104

[6] Canetti, Ran, Cynthia Dwork, Moni Naor, and Rafail Ostrovsky, “Deniable Encryption”, Proceedings CRYPTO ’97 (Springer 1997). https://link.springer.com/content/pdf/10.1007/BFb0052229.pdf

[7] Chaffing and Winnowing – Variations WikiPedia. https://en.wikipedia.org/wiki/Chaffing_and_winnowing#Variations

[8] Diffie, Whitfield; Hellman, Martin E. (November 1976). “New Directions in Cryptography”. IEEE Transactions on Information Theory. https://ee.stanford.edu/~hellman/publications/24.pdf

[9] Jakobsson, Markus, Kazue Sako, and Russell Impagliazzo, “Designated Verifier Proofs and Their Applications’’, Pro-ceedings Eurocrypt ’ 96 (Springer 1996), 143—154. https://link.springer.com/content/pdf/10.1007/3-540-68339-9_13.pdf

[10] Persiano, G., Phan, D.H., Yung, M. (2022). “Anamorphic Encryption: Private Communication Against a Dictator”. In: Dunkelman, O., Dziembowski, S. (eds) Advances in Cryptology – EUROCRYPT 2022. EUROCRYPT 2022. Lecture Notes in Computer Science, vol 13276. Springer, Cham. https://doi.org/10.1007/978-3-031-07085-3_2

[11] Rivest, R. “All-Or-Nothing Encryption and the Package Transform”. Proceedings of the 1997 Fast Software Encryption Conference (Springer, 1997). https://people.csail.mit.edu/rivest/pubs/Riv97d.pdf

[12] Stinson, D.R. “Something About All or Nothing (Transforms)”. Designs, Codes and Cryptography 22, 133–138 (2001). https://link.springer.com/article/10.1023/A:1008304703074

[13] HMACSHA256 Class (System.Security.Cryptography) | Microsoft Learn. https://learn.microsoft.com/en-us/dotnet/api/system.security.cryptography.hmacsha256

[14] Preneel, B. (2024). “HMAC”. In: Jajodia, S., Samarati, P., Yung, M. (eds) Encyclopedia of Cryptography, Security and Privacy. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-27739-9_581-2

[15] Siriwardena, P. (2020). “Base64 URL Encoding”. In: Advanced API Security. Apress, Berkeley, CA. https://doi.org/10.1007/978-1-4842-2050-4_20

WPF中为Popup和ToolTip使用WindowMaterial特效 win10/win11

Tue, 15 Oct 2024 00:00:00 GMT

先看效果图： win11: win10:

大致思路是：通过反射获取Popup内部的原生窗口句柄，然后通过前文已经实现的WindowMaterial类来应用窗口特效；对于ToolTip，为了保持其易用性，我使用了附加属性+全局样式的方式来实现，ToolTip也是一个特殊的Popup.
前文链接：WPF 模拟UWP原生窗口样式——亚克力|云母材质、自定义标题栏样式、原生DWM动画（附我封装好的类）
本文的Demo：
::github{repo="TwilightLemon/WindowEffectTest"}

一、获取原生窗口句柄

通过查阅.NET源码得知，Popup内部通过一个类型为PopupSecurityHelper的私有字段_secHelper来管理窗口hWnd，并且在创建完成之时会触发Popup.Opened事件。
通过反射来获取窗口句柄:

const BindingFlags privateInstanceFlag = BindingFlags.NonPublic | BindingFlags.Instance;
public static IntPtr GetNativeWindowHwnd(this Popup popup)
{
    //获取Popup内部的_secHelper字段Info
    var field = typeof(Popup).GetField("_secHelper", privateInstanceFlag);
    if (field != null)
    {
        //获取popup的_secHelper字段值
        if (field.GetValue(popup) is { } _secHelper)
        {
            //获取_secHelper的Handle属性Info
            if (_secHelper.GetType().GetProperty("Handle", privateInstanceFlag) is { } prop)
            {
                if (prop.GetValue(_secHelper) is IntPtr handle)
                {
                    //返回句柄
                    return handle;
                }
            }
        }
    }
    //未找到
    return IntPtr.Zero;
}

同样地，能在ToolTip内部找到私有字段_parentPopup

public static IntPtr GetNativeWindowHwnd(this ToolTip tip)
{
    var field=tip.GetType().GetField("_parentPopup", privateInstanceFlag);
    if (field != null)
    {
        if(field.GetValue(tip) is Popup{ } popup)
        {
            return popup.GetNativeWindowHwnd();
        }
    }
    return IntPtr.Zero;
}

二、应用WindowMaterial特效

有了窗口句柄那么一切都好办了，直接调用我封装好的WindowMaterial类，如果你想了解更多请查看前文。

public static void SetPopupWindowMaterial(IntPtr hwnd,Color compositionColor,
     MaterialApis.WindowCorner corner= MaterialApis.WindowCorner.Round)
{
    if (hwnd != IntPtr.Zero)
    {
        int hexColor = compositionColor.ToHexColor();
        var hwndSource = HwndSource.FromHwnd(hwnd);
        //----
        MaterialApis.SetWindowProperties(hwndSource, 0);
        MaterialApis.SetWindowComposition(hwnd, true, hexColor);
        //----
        MaterialApis.SetWindowCorner(hwnd, corner);
    }
}

根据微软的设计规范，这里默认对普通Popup使用圆角，对ToolTip使用小圆角，使用亚克力材质并附加compositionColor。
在github中获取完整的WindowMaterial.cs，我可能会不定期地更新它：WindowEffectTest/WindowMaterial.cs at master · TwilightLemon/WindowEffectTest (github.com)

如果你想使用Mica或MicaAlt等材质则将上面框起来的代码替换为：

MaterialApis.SetWindowProperties(hwndSource, -1);
MaterialApis.SetBackDropType(hwnd, MaterialType.Mica);
MaterialApis.SetDarkMode(hwnd, isDarkMode: true);

三、没错我又封装了一个即开即用的类

在Demo中查看封装好的类：WindowEffectTest/FluentPopup.cs at master · TwilightLemon/WindowEffectTest (github.com)

使用FluentPopup

<local:FluentPopup x:Name="testPopup"
                   StaysOpen="False"
                   Placement="Mouse"
                   Background="{DynamicResource PopupWindowBackground}">
    <Grid Height="120" Width="180">
        <TextBlock HorizontalAlignment="Center" VerticalAlignment="Center">
            nihao 
        </TextBlock>
    </Grid>
</local:FluentPopup>

其中，Background属性是我自定义的一个依赖属性，只允许使用SolidColorBrush，用于设置亚克力特效的CompositionColor。
如果你希望像Demo中那样让Popup失焦自动关闭，可以设置StaysOpen为False，在后台打开Popup时使用：

private async void ShowPopupBtn_Click(object sender, RoutedEventArgs e)
{
    await Task.Yield();
    testPopup.IsOpen = true;
}

关于为什么要加上await Task.Tield()，可以看看吕毅大佬的文章:一点点从坑里爬出来：如何正确打开 WPF 里的 Popup？ - Walterlv

在全局内使用FluentToolTip

我自定义了一个附加属性FluentTooltip.UseFluentStyle，你只需要在App.xaml中设置即可全局生效：这里的PopupWindowBackground和ForeColor是我自定义的颜色资源，你可以根据自己的需要来设置。
同样地Background仅支持SolidColorBrush。

<Style TargetType="{x:Type ToolTip}">
    <Setter Property="local:FluentTooltip.UseFluentStyle"
            Value="True" />
    <Setter Property="Background"
            Value="{DynamicResource PopupWindowBackground}" />
    <Setter Property="Foreground"
            Value="{DynamicResource ForeColor}" />
</Style>

这样你就可以方便地创建一个Fluent风格的ToolTip了：

<Button 
    ToolTip="xxxxx"
    />

参考链接

Popup.cs at Dotnet Source

ToolTip.cs at Dotnet Source

一点点从坑里爬出来：如何正确打开 WPF 里的 Popup？ - Walterlv

WPF 模拟UWP原生窗口样式——亚克力|云母材质、自定义标题栏样式、原生DWM动画（附我封装好的类） - TwilightLemon

WPF使用AppBar实现窗口停靠，适配缩放、全屏响应和多窗口并列（附封装好即开即用的附加属性）

Sun, 29 Sep 2024 00:00:00 GMT

:::note[AppBar] 在吕毅大佬的文章中已经详细介绍了什么是:AppBar: WPF 使用 AppBar 将窗口停靠在桌面上，让其他程序不占用此窗口的空间（附我封装的附加属性） - walterlv
即让窗口固定在屏幕某一边，并且保证其他窗口最大化后不会覆盖AppBar占据的区域（类似于Windows任务栏）。
:::

但是在我的环境中测试时，上面的代码出现了一些问题，例如非100%缩放显示时的坐标计算异常、多窗口同时停靠时布局错乱等。所以我重写了AppBar在WPF上的实现，效果如图：

一、AppBar的主要申请流程

主要流程如图：

（图注：ABN_POSCHANGED消息在任何需要调整位置之时都会触发，括号只是举个例子）

核心代码其实在于如何计算停靠窗口的位置，要点是处理好一下几个方面：

修改停靠位置时用原窗口的大小计算，被动告知需要调整位置时用即时大小计算
像素单位与WPF单位之间的转换
小心Windows的位置建议，并排停靠时会得到负值高宽，需要手动适配对齐方式
有新的AppBar加入时，窗口会被系统强制移动到工作区(WorkArea)，这点我还没能找到解决方案，只能把移动窗口的命令通过Dispatcher延迟操作

二、如何使用

下载我封装好的库：AppBarTest/AppBarCreator.cs at master · TwilightLemon/AppBarTest (github.com) ::github{repo="TwilightLemon/AppBarTest"}
在xaml中直接设置：

<Window ...>

<local:AppBarCreator.AppBar>
    <local:AppBar x:Name="appBar" Location="Top" OnFullScreenStateChanged="AppBar_OnFullScreenStateChanged"/>
</local:AppBarCreator.AppBar>

...
</Window>

或者在后台创建：

private readonly AppBar appBar=new AppBar();

...Window_Loaded...
appBar.Location = AppBarLocation.Top;
appBar.OnFullScreenStateChanged += AppBar_OnFullScreenStateChanged;
AppBarCreator.SetAppBar(this, appBar);

另外你可能注意到了，这里有一个OnFullScreenStateChanged事件：该事件由AppBarMsg注册，在有窗口进入或退出全屏时触发，参数bool为true指示进入全屏。你需要手动在事件中设置全屏模式下的行为，例如在全屏时隐藏AppBar

    private void AppBar_OnFullScreenStateChanged(object sender, bool e)
    {
        Debug.WriteLine("Full Screen State: "+e);
        Visibility = e ? Visibility.Collapsed : Visibility.Visible;
    }

我在官方的Flag上加了一个RegisterOnly，即只注册AppBarMsg而不真的停靠窗口，可以此用来作全屏模式监听。
4. 如果你需要在每个虚拟桌面都显示AppBar(像任务栏那样)，可以尝试为窗口使用SetWindowLong添加WS_EX_TOOLWINDOW标签（自行查找）

三、已知问题

在我的github上的实例程序中，如果你将两个同进程的窗口并排叠放的话，会导致explorer和你的进程双双爆栈，windows似乎不能很好地处理这两个并排放置的窗口，一直在左右调整位置，疯狂发送ABN_POSCHANGED消息。(快去clone试试，死机了不要打我) 但是并排放置示例窗口和OneNote的Dock窗口就没有问题。
计算停靠窗口时，如果选择停靠位置为Bottom，则系统建议的bottom位置值会比实际的高，测试发现是任务栏窗口占据了部分空间，应该是预留给平板模式的更大图标任务栏（猜测，很不合理的设计）自动隐藏任务栏就没有这个问题：
没有实现自动隐藏AppBar，故没有处理与之相关的WM_ACTIVATE等消息，有需要的可以参考官方文档。（嘻我懒）

参考文档：

SHAppBarMessage function (shellapi.h) - Win32 apps | Microsoft Learn

ABM_QUERYPOS message (Shellapi.h) - Win32 apps | Microsoft Learn ABM_NEW & ABM_SETPOS etc..

使用应用程序桌面工具栏 - Win32 apps | Microsoft Learn

判断是否有全屏程序正在运行（C#）_c# 判断程序当前窗口是否全屏如果是返回原来-CSDN博客

WPF 模拟UWP原生窗口样式——亚克力|云母材质、自定义标题栏样式、原生DWM动画（附我封装好的类）

Thu, 22 Aug 2024 00:00:00 GMT

先看一下最终效果，左图为使用亚克力材质并添加组合颜色的效果；右图为MicaAlt材质的效果。两者都自定义了标题栏并且最大限度地保留了DWM提供的原生窗口效果（最大化最小化、关闭出现的动画、窗口阴影、拖拽布局器等）。接下来把各部分的实现一个个拆开来讲讲。

一、使用窗口材质特效

先粗略介绍一下目前win11和win10上的材质特效类型及一些特性：

[Windows10 1903 ~ Windows11 lastest] ：Acrylic 亚克力材质 | 支持使用组合颜色 | 窗口失去焦点时不失效、有拖动窗口延迟 | API: SetWindowCompositionAttribute

1803版本开放此API 但是对Win32应用支持不好

Windows11: API: SetWindowAttribute 其实现的材质特性：原生不支持组合颜色对于非WindowStyle.None的窗口失焦失效无拖动窗口延迟提供了暗亮模式
- Acrylic 亚克力材质动态模糊，背景取决于窗口下方的内容
- Mica 云母材质背景仅取桌面壁纸(第三方动态壁纸软件无效) 颜色变化较为平缓 win11系统应用的窗口背景大部分使用此材质
- MicaAlt 同Mica材质，区别是此材质的颜色变化更突出文件管理器的标题栏使用此材质

在win11上同样支持使用win10的SetWindowCompositionAttribute启用旧版API，只不过需要不同的使用条件

前面的文章中介绍了在win11上启用材质的方法，但有不少弊端。之后诺尔大佬探究出从底层满足调用条件的方法，总结如下：

无论调用哪个API，都需要设置AllowTransparency="True"，弊端是带来性能问题和鼠标穿透(即使DWM已经绘制了底层颜色)，改为调用：

var hwndSource = (HwndSource)PresentationSource.FromVisual(_window);
hwndSource.CompositionTarget.BackgroundColor = Colors.Transparent;

WindowChrome.GlassFrameThickness 对于SetWindowCompositionAttribute需要值为-1，另一者则需要为0，弊端是可能我们并不需要WindowsChrome来拓展整个客户区，改为调用DwmExtendFrameIntoClientArea，详细见后文示例程序。

如果你想动手实现一下，可以参照：[.NET,WPF] 窗体云母, 亚克力, 透明, 混合颜色, 模糊背景, 亮暗色主题全讲 (slimenull.com)

下面给出我封装好的附加属性：

WindowEffectTest/WindowEffectTest/WindowMaterial.cs at master · TwilightLemon/WindowEffectTest (github.com)

使用方法很简单，在你的xaml中添加以下作为Window的子标签，并且将Window.Background设为Transparent.

<local:WindowMaterial.Material>
        <local:WindowMaterial x:Name="windowMaterial" 
                              IsDarkMode="True" 
                              UseWindowComposition="False" 
                              MaterialMode="MicaAlt" 
                              CompositonColor="#CC6699FF" >
        </local:WindowMaterial>
</local:WindowMaterial.Material>

属性解释：

IsDarkMode: 暗色模式，主要对Mica(Alt)材质生效
UseWindowComposition: 在win10上无效，指示使用SetWindowCompositionAttribute，在win11上启用旧版的亚克力特效，一般用于创建无边框窗口的背景材质，此属性为True时会忽略MaterialMode
MaterialMode: 指示使用的材质类型 None / Acrylic / Mica / MicaAlt
CompositionColor: 指示使用混合颜色的值，仅对MaterialMode=Acrylic(直接设置Window.Background) 和使用SetWindowCompositionAttribute时有效

幸运的话可以得到以下效果：如果尝试使用亚克力材质并设置混合色的话，无论使用哪个API都会得到类似的效果：区别在于：如果使用SetWindowAttribute提供的亚克力材质，可以调整IsDarkMode来配置背景色，但是效果不是很好。

使用附加的WindowChromeEx来将客户区拓展至标题栏

如果WindowChrome直接附加在窗口上会覆盖掉我们设置的GlassFrameThickness，故这里的设计是将WindowChrome附加在WindowMaterial上进行管理。你可以接着使用熟悉的WindowChrome提供的属性，然后把它作为资源提供给WindowMaterial.WindowChromeEx属性。

<Window.Resources>
        <WindowChrome x:Key="windowChrome" ResizeBorderThickness="8"/>
    </Window.Resources>
    
<local:WindowMaterial.Material>
    <local:WindowMaterial x:Name="windowMaterial" 
                          IsDarkMode="True" 
                          UseWindowComposition="False"
                          WindowChromeEx="{StaticResource windowChrome}"
                          MaterialMode="Acrylic" 
                          CompositonColor="#CC6699FF" >
    </local:WindowMaterial>
</local:WindowMaterial.Material>

然后就能得到： MicaAlt (DarkMode) 以及使用 WindowComposition 的亚克力材质效果：

二、自定义标题栏并保留DWM动画

简单地介绍以下我的实现：在Windows所以窗口创建底层都是走的WinAPI，WPF也不例外。可以通过仅提供WS_CAPTION标签来创建一个没有三大按钮的标题栏：

[DllImport("user32.dll", EntryPoint = "SetWindowLong")]
private static extern int SetWindowLong32(HandleRef hWnd, int nIndex, int dwNewLong);

[DllImport("user32.dll", EntryPoint = "SetWindowLongPtr")]
private static extern IntPtr SetWindowLongPtr64(HandleRef hWnd, int nIndex, IntPtr dwNewLong);

public const int GWL_STYLE = -16;
public const long WS_CAPTION = 0x00C00000L;

public static IntPtr SetWindowLongPtr(HandleRef hWnd, int nIndex, IntPtr dwNewLong)
            => IntPtr.Size == 8
            ? SetWindowLongPtr64(hWnd, nIndex, dwNewLong)
            : new IntPtr(SetWindowLong32(hWnd, nIndex, dwNewLong.ToInt32()));

public static void EnableDwmAnimation(Window w)
{
    var myHWND = new WindowInteropHelper(w).Handle;
    IntPtr myStyle = new(WS_CAPTION);
    SetWindowLongPtr(new HandleRef(null, myHWND), GWL_STYLE, myStyle);
}

然后按照上述的方法添加WindowChrome让客户区覆盖标题栏即可。（这里提前绘制好了自定义的标题栏样式，你需要自行处理暗色模式的变化等等）

这样WindowStyle就会失效，并且在实现WindowStyle.None的效果同时带上WS_CAPTION标签让DWM认为这是一个“原生”标题栏窗口。经过测试，另外还需加上WS_THICKFRAME|WS_MAXIMIZEBOX|WS_MINIMIZEBOX 等标签让窗口行为更贴近原生。（添加WS_THICKFRAME在移动窗口时出现系统的窗口布局器）

同样失效的还有ResizeMode.NoResize，如果你需要固定窗口大小，目前暂行的方法是设置WindowsChrome的ResizeBorderThickness="0"，如果按照WinAPI的方法加上WS_SYSMENU则会同时带回原生标题栏的三大按钮。（为什么微软对它的解释是标题栏菜单..?）

使用我封装好的附加属性：

WindowEffectTest/WindowEffectTest/DwmAnimation.cs at master · TwilightLemon/WindowEffectTest (github.com)

在Window标签中添加：（同样地这会使WindowStyle和ResizeMode失效）

local:DwmAnimation.EnableDwmAnimation="True"

三、添加更多窗口行为

以下Demo使用了诺尔大佬的WPF Suite来帮助简化流程。

Demo 1. 创建一个失焦不失效的亚克力材质圆角窗口 (Win11)，所有设置如下：

关键部分在ws:WindowOption.Corner="Round"这一句，始终使用圆角窗口，并且拥有原生边框阴影（右图为对照，无阴影）

手动实现参照官方文档：Apply rounded corners in desktop apps - Windows apps | Microsoft Learn

Demo 2. 添加win11的布局器

在Button中添加 ws:WindowOption.IsMaximumButton="True" 以在鼠标悬停时显示布局器

本文的所有效果均可通过诺尔大佬的WPF Suite快速实现，大家快去用呀！

Documentation | EleCho.WpfSuite

最后附上测试项目地址：

::github{repo="TwilightLemon/WindowEffectTest"}

参考文章：

在 Windows 11 应用中使用的材料 - Windows apps | Microsoft Learn

[.NET,WPF] 窗体云母, 亚克力, 透明, 混合颜色, 模糊背景, 亮暗色主题全讲 (slimenull.com)

WPF在win10/11上启用模糊特效适配Dark/Light Mode - TwilightLemon - 博客园 (cnblogs.com)

......

.NET App 与Windows系统媒体控制(SMTC)交互

Tue, 02 Jul 2024 00:00:00 GMT

当你使用Edge等浏览器或系统软件播放媒体时，Windows控制中心就会出现相应的媒体信息以及控制播放的功能，如图。
:::note[WHAT IS SMTC] SMTC (SystemMediaTransportControls) 是一个Windows App SDK (旧为UWP) 中提供的一个API，用于与系统媒体交互。接入SMTC的好处在于，将媒体控制和媒体信息共享给系统，使用通用的特性（例如接受键盘快捷键的播放暂停、接受蓝牙设备的控制），便于与其它支持SMTC的应用交互等。 ::: 在UWP App中使用它很简单，只需要调用SystemMediaTransportControls.GetForCurrentView()方法即可，但是该方法仅限在有效的UWP App中调用，否则将抛出“Invalid window handle”异常。实际上，在官方文档中提到所有XXXForCurrentView方法均不适用于UWP App以外的程序调用。

这些XxxForCurrentView方法对ApplicationView类型具有隐式依赖关系，桌面应用不支持该类型。由于桌面应用不支持 ApplicationView，因此也不支持任何XxxForCurrentView方法。

此外官方文档还给出一个可替代的接口ISystemMediaTransportControlsInterop，然而这个接口在给的SDK中有保护性，无法访问。

至此，直接创建SMTC的方法走不通。但是我发现一个奇怪的地方，UWP提供的在Windows.Media.Playback命名空间下的MediaPlayer可以和SMTC自动集成，并且可以通过SystemMediaTransportControls属性直接拿到SMTC对象。MediaPlayer内部通过某种COM组件直接创建了该NativeObject，而没有走API提供的GetForCurrentView或FromAbi方法。也就是说，SMTC组件其实不需要使用合法的UWP Window句柄来创建，只不过可能为了某些特性而加上了该限制(后文将提到)。幸运的是，MediaPlayer帮我们绕过了这点。

下文讲解手动与SMTC交互而不是直接使用MediaPlayer进行播放，你的项目可能已经有了其它的解码器(如WPF版本的MediaPlayer、Bass.Net解码器、NAudio等)，则只需要将交互部分接入SMTC而不更换解码器。

文末提供了我封装好的SMTCCreator和SMTCListener，可以直接使用。

一、引用WinRT API到项目

最便捷的方法是直接修改目标框架到win10，这样就能自动引入WinRT API:

<TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>

或者一些其他的方法，可以参考这篇博客：如何在WPF中调用Windows 10/11 API(UWP/WinRT) - zhaotianff - 博客园 (cnblogs.com)

二、通过MediaPlayer获取SMTC对象

using Windows.Media;
using Windows.Storage.Streams;
...
private readonly Windows.Media.Playback.MediaPlayer _player = new();
private readonly SystemMediaTransportControls _smtc;
...
//先禁用系统播放器的命令
_player.CommandManager.IsEnabled = false;
//直接创建SystemMediaTransportControls对象被平台限制，神奇的是MediaPlayer对象可以创建该NativeObject
_smtc = _player.SystemMediaTransportControls;
//启用smtc以进行自定义
_smtc.IsEnabled = true;

拿到SMTC对象之后的操作与UWP中无异，这里简单看一下：

1.设置可交互性

_smtc.IsPlayEnabled = true;
_smtc.IsPauseEnabled = true;
_smtc.IsNextEnabled = true;
_smtc.IsPreviousEnabled = true;

2.设置媒体信息

var updater = _smtc.DisplayUpdater;
updater.AppMediaId = "xxx"; //用于区分不同来源的媒体
updater.Type = MediaPlaybackType.Music; //必须指定媒体类型否则抛异常
updater.MusicProperties.Title = “Title”；//标题
/*...省略相同的字段设置...*/
updater.Thumbnail = RandomAccessStreamReference.CreateFromUri(new Uri(ImgUrl));//设置封面图
updater.Update();//最后调用以生效

播放状态需要单独设置:

_smtc.PlaybackStatus = MediaPlaybackStatus.Playing; //Paused \ Stopped
//直接设置无需更新

3.响应SMTC交互

_smtc.ButtonPressed += _smtc_ButtonPressed;
...
 private void _smtc_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch(args.Button)
            {
                case SystemMediaTransportControlsButton.Play:
                    //Play
                    break;
                case SystemMediaTransportControlsButton.Pause:
                    //Pause
                    break;
                case SystemMediaTransportControlsButton.Next:
                    //Next
                    break;
                case SystemMediaTransportControlsButton.Previous:
                    //Previous
                    break;
            }
        }

注意，文中所有SMTC的事件均由系统触发，意味着非同一线程，需要用Dispatcher来操作UI

三、获取和控制系统媒体

好消息是，负责这部分的模块GlobalSystemMediaTransportControlsSession公开可以任意使用，不受UWP平台限制。

1.获取媒体信息

var gsmtcsm = await GlobalSystemMediaTransportControlsSessionManager.RequestAsync();//获取SMTC会话管理器
gsmtcsm.CurrentSessionChanged += xxx; //当前会话改变或退出时发生，微软对CurrentSession的解释是用户可能最希望控制的媒体会话，实测为Windows控制中心顶部显示的媒体，当有多个媒体时用户可以在此选择切换
...
var session = gsmtcsm.GetCurrentSession();
if(session == null)
    return; //当前没有注册的SMTC会话

//接下来操作session即可，下面仅提供参考信息

//媒体信息改变时发生，奇怪的是这些事件提供的参数e并没有任何信息
session.MediaPropertiesChanged += async (sender, e)=>{
    //触发事件时主动拉取信息
    var info = await _globalSMTCSession.TryGetMediaPropertiesAsync();
};
//播放状态改变时发生
session.PlaybackInfoChanged +=(sender,e)=>{
    var status = globalSMTCSession.GetPlaybackInfo().PlaybackStatus;
};

2.控制媒体播放

直接调用即可

await session.TryPauseAsync();
await session.TryPlayAsync();
await session.TrySkipPreviousAsync();
await session.TrySkipNextAsync();

四、一些奇怪的地方

无法显示媒体来源，并且不会清空上一个来源的信息可能是因为没有提供合法的UWP句柄，Windows虽然能确定是哪个exe调用的SMTC，但是拒绝直接显示exe的信息。逻辑上来说这个来源信息会被空覆盖掉，但是并没有。

信息更新不一致和延时

系统显示的会话以及提供GlobalSMTCSessionMng.获取的信息有时会不一致，二者都有可能和应用真实在播放的不一致，后者获取的封面图有时也会不一致。此外，MusicProperty的更新有时并不会实时反馈到GlobalSMTCSession的Changed事件，我测试的时候当系统内存爆满(98% 我开了一堆浏览器标签页和4个vs)的时候，更新丢失的概率在70%左右，而资源充足时可以做到几乎即时更新。

暂未实现点击跳转到App 正统UWP App的SMTC会话是可以点击跳转到App播放界面的，但是我并没有找到相关的事件。
奇怪的MediaId Windows系统似乎通过这个来区分不同的媒体来源（明明可以获得调用者- -），神奇的是如果你为两个应用设置了同样的MediaId，那么只有两个都关闭时，SMTC会话才会释放。此外通过GlobalSMTCSession.SourceAppUserModelId并不能获得你设置的MediaId，而是调用者的文件名"xxx.exe"。

五、使用我封装的库

Demo和库已经开源：
::github{repo="TwilightLemon/MediaTest"}

简单地将现有的解码器接入SMTC：

SMTCCreator? _smtcCreator = null;
...
 _smtcCreator ??= new SMTCCreator("MediaTest");
//修改播放状态
_smtcCreator.SetMediaStatus(SMTCMediaStatus.Playing);
//设置媒体信息
_smtcCreator.Info.SetAlbumTitle("AlbumTitle")
                    .SetArtist("Taylor Swift")
                    .SetTitle("Dancing With Our Hands Tied")
                    .SetThumbnail("https://y.qq.com/music/photo_new/T002R300x300M000003OK4yP2MBOip_1.jpg?max_age=2592000")
                    .Update();
//注册交互响应
_smtcCreator.PlayOrPause += _smtcCreator_PlayOrPause;
_smtcCreator.Previous += _smtcCreator_Previous;
_smtcCreator.Next += _smtcCreator_Next;//合适的时候调用释放资源_smtcCreator.Dispose();

简单地控制系统媒体：

SMTCListener _smtcListener = null;
...
_smtcListener = await SMTCListener.CreateInstance();
_smtcListener.MediaPropertiesChanged += _smtcListener_MediaPropertiesChanged;
_smtcListener.PlaybackInfoChanged += _smtcListener_PlaybackInfoChanged;
_smtcListener.SessionExited += _smtcListener_SessionExited;
...
//媒体退出
 private void _smtcListener_SessionExited(object? sender, EventArgs e) { }

//播放状态改变
private void _smtcListener_PlaybackInfoChanged(object? sender, EventArgs e)
{
    Dispatcher.Invoke(() =>
    {
        var info = _smtcListener.GetPlaybackStatus();
        if (info == null) return;
        StatusTb.Text = info.ToString();
    });
}
//媒体信息改变
private void _smtcListener_MediaPropertiesChanged(object? sender, EventArgs e)
{
    Dispatcher.Invoke(async () =>
    {
        var info = await _smtcListener.GetMediaInfoAsync();
        if (info == null) return;
        TitleTb.Text = info.Title;
        ArtistTb.Text = info.Artist;
        AlbumTitleTb.Text = info.AlbumTitle;
        //获取封面图的方法
        if (info.Thumbnail != null)
        {
            var img = new BitmapImage();
            img.BeginInit();
            img.StreamSource = (await info.Thumbnail.OpenReadAsync()).AsStream();
            img.EndInit();
            ThumbnailImg.Source = img;
        }
    });
}
...
//控制播放
await _smtcListener.Previous();
await _smtcListener.Next();
await _smtcListener.Pause();
await _smtcListener.Play();

六、写在最后

参考资料：

SystemMediaTransportControls 类 (Windows.Media) - Windows UWP applications | Microsoft Learn

桌面应用中不支持 Windows 运行时 API - Windows 应用 |Microsoft学习 --- Windows Runtime APIs not supported in desktop apps - Windows apps | Microsoft Learn

GlobalSystemMediaTransportControlsSessionManager Class (Windows.Media.Control) - Windows UWP applications | Microsoft Learn

WPF 如何流畅地滚动ScrollViewer 简单实现下

Sat, 13 Jun 2020 00:00:00 GMT

看了看原生UWP的ScrollViewer，滑动很流畅(例如开始菜单)，但是WPF自带的ScrollViewer滚动十分生硬..

突发奇想，今天来实现一个流畅滚动的ScrollViewer.

一、目标

查阅网上的实现方法，要么直接重写控件，要么一堆Storyboard..很是无奈,还有些许bug.

主要目标如下:

1.能够流畅地滚动ScrollViewer 要求：有惯性的物理滚动而不是生硬的内容滚动.

2.在使用动画的过程中，避免多个begin导致卡顿

3.好用(? )

二、准备工作

实现以上目标需要到的几件东西:

1.对于Listbox之类的控件需要先将滚动方式变为像素滚动（若没有的话就可以不设置）

<ListBox
    VirtualizingPanel.ScrollUnit = "Pixel" 
    VirtualizingPanel.VirtualizationMode="Recycling"/>

2.选一种动画使用的缓动函数这里推荐使用 CubicEase的EaseOut函数 (优点:接近于惯性滚动对于CPU比较友好)

3.要对ScrollViewer启用滚动动画需要自己写附加属性:

public static class ScrollViewerBehavior
{
      public static readonly DependencyProperty VerticalOffsetProperty = DependencyProperty.RegisterAttached("VerticalOffset", typeof(double), typeof(ScrollViewerBehavior), new UIPropertyMetadata(0.0, OnVerticalOffsetChanged));
      public static void SetVerticalOffset(FrameworkElement target, double value) => target.SetValue(VerticalOffsetProperty, value);
      public static double GetVerticalOffset(FrameworkElement target) => (double)target.GetValue(VerticalOffsetProperty);
      private static void OnVerticalOffsetChanged(DependencyObject target, DependencyPropertyChangedEventArgs e) => (target as ScrollViewer)?.ScrollToVerticalOffset((double)e.NewValue);
}

三、编码

//继承ScrollViewer 通过截获MouseWheel事件控制滚动
    public class MyScrollViewer : ScrollViewer
    {
        //记录上一次的滚动位置
        private double LastLocation = 0;
        //重写鼠标滚动事件
        protected override void OnMouseWheel(MouseWheelEventArgs e)
        {
            double WheelChange = e.Delta;
            //可以更改一次滚动的距离倍数 (WheelChange可能为正负数!)
            double newOffset = LastLocation - (WheelChange * 2);
            //Animation并不会改变真正的VerticalOffset(只是它的依赖属性) 所以将VOffset设置到上一次的滚动位置 (相当于衔接上一个动画)
            ScrollToVerticalOffset(LastLocation);
            //碰到底部和顶部时的处理
            if (newOffset < 0)
                newOffset = 0;
            if (newOffset > ScrollableHeight)
                newOffset = ScrollableHeight;

            AnimateScroll(newOffset);
            LastLocation = newOffset;
            //告诉ScrollViewer我们已经完成了滚动
            e.Handled = true;
        }
        private void AnimateScroll(double ToValue)
        {
            //为了避免重复，先结束掉上一个动画
            BeginAnimation(ScrollViewerBehavior.VerticalOffsetProperty, null);
            DoubleAnimation Animation = new DoubleAnimation();
            Animation.EasingFunction = new CubicEase() { EasingMode = EasingMode.EaseOut };
            Animation.From = VerticalOffset;
            Animation.To = ToValue;
            //动画速度
            Animation.Duration = TimeSpan.FromMilliseconds(800);
            //考虑到性能，可以降低动画帧数
            //Timeline.SetDesiredFrameRate(Animation, 40);
            BeginAnimation(ScrollViewerBehavior.VerticalOffsetProperty, Animation);
        }
    }

使用方法:直接创建 <MyScrollViewer/> 如果是在ListBox中，可以通过修改模板的方式，把<ScrollViewer/>换成MyScrollViewer即可.

四、关于性能

按照上述方法实现的功能，CPU占用率基本稳定在10% ，但是要疯狂地上下滑动滚轮的话，25%+ 但是动画还是很流畅的

以下有几点可以改进的措施:

滚动的CPU占用不只是对偏移量的一个计算，与你滚动的UI画面内容具有很大的关系

例如大量的图片Image 3D对象复杂的自定义控件等等都需要在滚动时计算并绘制。

你可以尝试以下方法:

启用ListBox的虚拟化技术
对于图像的绘制，可以通过降低其渲染度(可能会损坏图片质量特别是低清小图 ),对你的图片对象使用:
```
RenderOptions.SetBitmapScalingMode(控件对象,BitmapScalingMode.LowQuality);
```
就像上文中所说，可以通过降低渲染帧数来控制CPU占用率（可能会有失流畅度）
如果能找到更好的缓动函数
参阅: 优化控件性能 -WPF |Microsoft Docs

C# .Net Core 3.1 中关于Process.Start 启动Url链接的问题

Sun, 15 Mar 2020 00:00:00 GMT

WPF 项目迁移到.Net Core中时居然出了一堆问题...(很无语)

今天在使用的时候居然发现Process.Start居然打不开Url链接了？报找不到指定文件的异常？！

一、bug重现

首先以.Net Core 3.1框架中一个Console项目打开百度为例:
运行然后你就会得到:

纳闷的是，这种方法打开Url在.Net Framework中是没问题的..

二、解决方法

方案一：使用windows系统自带的资源管理器来打开Url

Process.Start("explorer", "https://www.baidu.com");

你就可以得到一个浏览器窗口，打开着百度网页..
但是如果你的Url复杂一点的话，例如打开百度搜索what

Process.Start("explorer", "https://www.baidu.com/s?wd=what");
explorer表示不干，并直接给你抛了个文件管理器窗口

所以这个方法只可以用于打开简单的URL...

方案二：使用cmd中的start命令可以打开任意形式的URL

string url = "https://www.baidu.com/s?wd=what";
Process p = new Process();
p.StartInfo.FileName = "cmd.exe";
p.StartInfo.UseShellExecute = false;    //不使用shell启动
p.StartInfo.RedirectStandardInput = true;//喊cmd接受标准输入
p.StartInfo.RedirectStandardOutput = false;//不想听cmd讲话所以不要他输出
p.StartInfo.RedirectStandardError = true;//重定向标准错误输出
p.StartInfo.CreateNoWindow = true;//不显示窗口
p.Start();

//向cmd窗口发送输入信息 后面的&exit告诉cmd运行好之后就退出
p.StandardInput.WriteLine("start "+url + "&exit");
p.StandardInput.AutoFlush = true;
p.WaitForExit();//等待程序执行完退出进程
p.Close();

以上的问题我只在Windows平台上找到过，不知Linux和OSX有没有...

Thanks

C# 简单地使用下音频解码器Bass.Net

Wed, 11 Mar 2020 00:00:00 GMT

在C#中有许多音频播放的方案，例如WinForm里调用系统自带MediaPlayer的COM组件和WPF的MediaPlayer(实质上还是WindowsMediaPlayer)
以及一堆API播放和DirectX （SDK一大堆）
于是我找到了适用于全平台、高效、小巧的音频解码器--Bass (主程序基于C++ C#可通过官方库Bass.Net调用)

一、开始

首先需要到官网下载bass.dll 主程序文件(大约 257kb): http://www.un4seen.com/

以及类库(.Net平台调用) : 你可以在 http://www.bass.radio42.com/bass_register.html 中使用你的邮箱即可注册到一个key和下载Bass.Net.dll(大约520kb)

官方文档: http://www.bass.radio42.com/help/

P.S: bass.dll需要放在程序主目录下 Bass.Net.dll随意(添加到程序集引用)

二、编码

在一切开始之前，你需要先注册程序和初始化Bass解码器:

using Un4seen.Bass;//添加引用
...
BassNet.Registration("你的邮箱", "你注册到的Key");
Bass.BASS_Init(-1, 44100, BASSInit.BASS_DEVICE_CPSPEAKERS, /*窗口句柄 没有的话就IntPtr.Zero*/);

1. 实现简单的mp3播放

播放mp3有2种方式 :从文件中加载、从URL中加载

例1: 从文件中加载:

//---------调用到的方法------------
public static int BASS_StreamCreateFile(
    string file,//文件路径
    long offset,//偏移量，一般不怎么使用
    long length,//如果你使用了偏移量，定义一个偏移量之后的读取长度
    BASSFlag flags//以什么方式创建流
)
//----------------------------------

帮助链接和其他信息: http://www.bass.radio42.com/help/html/e49e005c-52c0-fc33-e5f9-f27f2e0b1c1f.htm

//创建流的id，建议作为全局变量加入(如果是播放单文件)
private int stream =  -1024;//可以自己定义一个初始值
...
//从文件中创建一个简单的FLOAT音频流,返回流的id 便于控制和查询
stream = Bass.BASS_StreamCreateFile(你的文件完整路径, 0L, 0L, BASSFlag.BASS_SAMPLE_FLOAT);
... 开始播放
//参数:int 要播放的流的id,bool 是否在播放完成之后再重新播放
Bass.BASS_ChannelPlay(stream, false);
... 暂停播放
Bass.BASS_ChannelPause(stream);

例2:从URL中加载:

stream = Bass.BASS_StreamCreateURL(url, 0, BASSFlag.BASS_SAMPLE_FLOAT, null, IntPrt.Zero);

只是加载音频流的方式改变了，其他的一致
如果你需要一些其他的功能(请求Url时的标头和下载回调)，请参阅以下:

1.添加URL请求标头:

很简单: 在url参数里添加即可，url与每一条标头之间用"\r\n"换行，例如:

stream = Bass.BASS_StreamCreateURL(url+"\r\n"+"一条标头，Header:Content"+"\r\n"+"再一条标头",...);

2.下载回调: 多用于缓存

//必须是全局变量，否则会被GC回收！
private DOWNLOADPROC _myDownloadProc;
private FileStream _fs = null;//写入文件的流
private byte[] _data; // 本地缓存

...
//添加调用
 _myDownloadProc = new DOWNLOADPROC(DownloadCallBack);
...

//下载回调，由Bass调用
private void DownloadCallBack(IntPtr buffer, int length, IntPtr user)
        {
            // file length
            long len = Bass.BASS_StreamGetFilePosition(stream, BASSStreamFilePosition.BASS_FILEPOS_END);
            // download progress
            long down = Bass.BASS_StreamGetFilePosition(stream, BASSStreamFilePosition.BASS_FILEPOS_DOWNLOAD);
            //可在此处添加下载进度的Callback

            if (_fs == null)
            {
                // 开始下载，打开文件流
               //坑:当你切歌的时候，Bass并不会继续下载而且会向你发送已经下载完成的标识，此时你得到的文件是不完整的!所以此处先作为.cache下载
                _fs = File.OpenWrite(保存的路径 + ".cache");
            }
            if (buffer == IntPtr.Zero)
            {
                // 下载完成
                _fs.Flush();
                _fs.Close();
                _fs = null;
                FileInfo fi = new FileInfo(DLPath + ".cache");
               //如果下载不完整的话就删除.cache
                if (fi.Length != len)
                {
                    fi.Delete();
                }
                else
                {
                    //如果下载完整的话就移动到缓存(下载)目录
                    fi.MoveTo(你的路径, true);
                    //这里可以做下载完成的回调
                }
            }
            else
            {
                //接受到下载数据，实质上是Bass传来数据的指针，C#根据指针从内存中复制数据
                // increase the data buffer as needed
                if (_data == null || _data.Length < length)
                    _data = new byte[length];
                // copy from managed to unmanaged memory
                Marshal.Copy(buffer, _data, 0, length);
                // write to file
                _fs.Write(_data, 0, length);
            }
        }

2. 获得和设置一些常规数据(播放进度、声音):

1. 设置、获取音量:

坑：音量的设置是暂时性的，仅对于你输入的stream,当你再次新建音频流时(例如切歌),音量会恢复默认!你可能需要记录下设置的音量并在下一次加载流时将音量设置Set到stream中!

//设置音量 值在0~1之间 默认值为1
Bass.BASS_ChannelSetAttribute(stream, BASSAttribute.BASS_ATTRIB_VOL, value);

...

//获取当前音量 ref value
float value=0;
Bass.BASS_ChannelGetAttribute(stream, BASSAttribute.BASS_ATTRIB_VOL,ref value);

2.播放进度和总长(时间):

 //长度
public TimeSpan GetLength
        {
            get
            {
                double seconds = Bass.BASS_ChannelBytes2Seconds(stream, Bass.BASS_ChannelGetLength(stream));
                return TimeSpan.FromSeconds(seconds);
            }
        }
//当前播放位置
public TimeSpan Position
        {
            get
            {
                double seconds = Bass.BASS_ChannelBytes2Seconds(stream, Bass.BASS_ChannelGetPosition(stream));
                return TimeSpan.FromSeconds(seconds);
            }
            set => Bass.BASS_ChannelSetPosition(stream, value.TotalSeconds);
        }

3.获取FFT数据，你可以用这个数据来做频谱:

//获取256位的FFT数据，当然你可以选择更大的，但是也足够了
//坑:暂停播放时获得的FFT数据仍是没有暂停前的数据(停留在此位置的FFT)如果你需要做频谱图，在暂停时应该手动设置为0，因为Bass并不会在暂停时返回0
float[] fft = new float[256];
Bass.BASS_ChannelGetData(stream, fft, (int)BASSData.BASS_DATA_FFT256);

Bass并没有提供播放完成的回调，你需要设置一个Timer来判断是否播放完成，理论上当当前位置=播放总长时算播放完成...

3. 更新设备和结束时

系统会将当前的默认设备放在集合的[0]位，但是Bass并不会自动更新设备也没有更新设备的事件回调（或是我没有找到?），所以你需要自己检查下有没有新的设备插入，你需要手动更新设备(如果需要):

public void UpdataDevice()
        {
            var data = Bass.BASS_GetDeviceInfos();
            int index = -1;
            for (int i = 0; i < data.Length; i++)
                if (data[i].IsDefault)
                {
                    index = i;
                    break;
                }
            if (!data[index].IsInitialized)
                Bass.BASS_Init(index, 44100, BASSInit.BASS_DEVICE_CPSPEAKERS, wind);
            var a = Bass.BASS_ChannelGetDevice(stream);
            if (a != index)
            {
                Bass.BASS_ChannelSetDevice(stream, index);
                Bass.BASS_SetDevice(index);
            }
        }

结束时，需要释放流和Bass解码器:

Bass.BASS_ChannelStop(stream);
Bass.BASS_StreamFree(stream);
Bass.BASS_Stop();
Bass.BASS_Free();

4.倍速播放和其他FX效果

为什么这里需要重新起个标题呢？
这个方法推翻了之前用到的stream创建形式，但是控制播放暂停等方法不变。
首先你需要引入几个Bass的概念:

音频流:stream,用于播放音频，就是你控制播放暂停时传入的stream
解码流 decode,用于解码音频，然后传给Fx效果器,Fx效果器会返回给你一个音频流

实现此方法，你需要下载FX扩展(就在bass.dll的地方下载选择add-on 即可),大约85kb
添加using引用:

using Un4seen.Bass.AddOn.Fx;

创建流:

//全局变量，解码流
private int decode;

decode = Bass.BASS_StreamCreateFile(你的文件, 0L, 0L, BASSFlag.BASS_STREAM_DECODE);
//相对于前面的你只需要把标签换成BASS_STREAM_DECODE即可，CreateURL亦是如此

//将解码流传入Fx效果器中，你将得到一个音频流
stream = BassFx.BASS_FX_TempoCreate(decode, BASSFlag.BASS_FX_FREESOURCE );

设置Fx效果:

value值在-90~0~5000之间以百分制计算例如加速/减速播放10%那么value=10,不用倍速播放value=0 减速 value=-10

Bass.BASS_ChannelSetAttribute(stream, BASSAttribute.BASS_ATTRIB_TEMPO, value);

获取Fx效果的方法和音量一致，更换标签为BASSAttribute.BASS_ATTRIB_TEMPO即可.

更多的FX效果可以参阅: http://www.bass.radio42.com/help/html/90d034c4-b426-7f7c-4f32-28210a5e6bfb.htm 原理一样修改标签和value值即可

Twlm's Blog

论文笔记 《Password-Based Credentials with Securiy Against Server Compromise》

四个安全目标：

已有的方案

ZWY single-key PBC

skPBC Syntax

ZWY Framework的安全目标和威胁模型

Game of weak/strong UNF for A in skPBC(λ)：

skPBC达不到Strong(and Offline) Unforgeability

mkPBC

Syntax

Game of xUNF for A in mkPBC(λ) where x∈{strong,online,offline}

Game of PW-Hiding for A in mkPBC(λ)

mkPBC的安全定义

构建Sign-Then-Encrypt的PBC方案

Scheme

Theorem & Proof

1.如果F是安全的PRF并且ΠSign是EUF-CMA安全的签名方案，则该PBC是强不可伪造的

2. 如果F是随机预言机，ΠSign具有complete robustness和randomness injectivity，且ΠEnc具有CCA安全，则该PBC是在线不可伪造的

3. 如果F是随机预言机，ΠSign是EUF-CMA安全的，并且具有可注入随机性，则该PBC是离线不可伪造的

4. 如果F是安全的PRF,则该PBC具有口令隐藏性

Appendix

一些疑问

Welcome to Twlm's Blog!

WPF 使用 HLSL + Clip 实现高亮歌词光照效果

一、实现思路

二、HLSL着色器代码

着色器输入参数

计算过程

函数说明

编译并加载着色器

三、WPF用户控件封装

核心出装

属性继承与元数据覆写

文本排版与裁剪

高亮参数的动画驱动

四、看看效果

写在最后

WPF 使用 RenderTransform 实现高性能平滑滚动的 ScrollViewer

三种方案对比

一、视觉与逻辑分离

渲染循环逻辑

二、物理模型设计

2.1 缓动模型

动态速度因子 (Dynamic Velocity Factor)

物理衰减

2.2 精确模型

三、快速开始

四、了解更多

1) 为什么要“视觉满帧、逻辑低频”

2) 关键状态：视觉差值（Visual Delta）

3) 为什么要用真实 dt（而不是假设固定帧率）

4) 关于逻辑同步频率

5) 注意 ScrollChanged 状态变更

6) 横向滚动与 Shift 切换

7) 为什么滚动时要临时关闭 HitTest

8) 如何写你自己的物理模型

写在最后

WPF 为ContextMenu使用Fluent风格的亚克力材质特效

一、为什么需要一个新的ContextMenu和MenuItem样式

二、ContextMenu与MenuItem的结构

1. ContextMenu 的结构

2. MenuItem 的四种形态

三、重写Menu相关控件模板和样式

1. ContextMenu 样式

2. MenuItem 样式

三、应用模板和样式到全局

参考连接

WPF 使用CompositionTarget.Rendering实现平滑流畅滚动的ScrollViewer，支持滚轮、触控板、触摸屏和笔

一、一些先验事实和设计思路

1.1 OnMouseWheel的触发逻辑

1.2 CompositionTarget.Rendering

1.3 两种场景、两种模型

1.3.1 缓动滚动模型

1.3.2 精确滚动模型

2025/11/08 更新

二、实现

2.1 先从鼠标滚轮与触控板开始

2.2 适配触摸屏和笔（更新：不建议使用）

2.3 OnRender事件

论文笔记《Password-Based Credentials with Securiy Against Server Compromise》

3) 为什么要用真实 `dt`（而不是假设固定帧率）

定理1. 非交互式PEKS在`适应性选择关键词攻击`下具有语义安全，如果BDH是难解问题。