深海游弋的鱼 – 第 2 页

Flutter手势冲突与手势竞争

手势冲突的原因

当多个手势同时出现在同一控件上时，就会发生手势冲突。这可能会导致系统无法准确识别用户的意图，从而导致错误的操作。iOS 上的 UIScrollView 是手势冲突的主要来源，因为它可以响应滚动、缩放和点击等各种手势。当 Flutter 视图与 UIScrollView 同时存在时，很容易发生手势冲突。

常见的冲突场景

最常见的场景是将 Flutter 视图嵌套在 UIScrollView 中。在这种情况下，UIScrollView 的滚动手势和 Flutter 视图的手势很容易发生冲突。例如，当用户在 Flutter 视图上拖动时，UIScrollView 可能将其误认为是滚动操作，从而导致 Flutter 视图无法响应拖动手势。

解决方案：手势竞技场

解决手势冲突的最有效方法之一是使用 Flutter 的手势竞技场。这是一个负责协调手势的系统，可确保同一时间只有一个手势被识别。要使用手势竞技场，需要在 Flutter 视图的最顶层添加一个 GestureRecognizer Widget，并将其作为竞技场的子控件。

手势竞技场的使用

以下是使用手势竞技场的示例代码：

import 'package:flutter/gestures.dart';

class MyGestureRecognizer extends GestureRecognizer {
  // 实现手势识别器的方法
}

class MyFlutterView extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return RawGestureDetector(
      gestures: {
        MyGestureRecognizer(): GestureRecognizerFactoryWithHandlers<MyGestureRecognizer>(
          () => MyGestureRecognizer(),
          (MyGestureRecognizer instance) => instance.addPointer(event),
          (MyGestureRecognizer instance) => instance.handleEvent(event),
        ),
      },
      child: // Flutter 视图的内容
    );
  }
}

import 'package:flutter/gestures.dart';

class MyGestureRecognizer extends GestureRecognizer {

// 实现手势识别器的方法

}

class MyFlutterView extends StatelessWidget {

@override

Widget build(BuildContext context) {

return RawGestureDetector(

gestures: {

MyGestureRecognizer(): GestureRecognizerFactoryWithHandlers<MyGestureRecognizer>(

() => MyGestureRecognizer(),

(MyGestureRecognizer instance) => instance.addPointer(event),

(MyGestureRecognizer instance) => instance.handleEvent(event),

child: // Flutter 视图的内容

);

}

通过使用这种方法，Flutter 视图的手势和 UIScrollView 的手势可以同时响应，互不干扰，从而完美解决 iOS 上的 Flutter 页面手势冲突问题。

常见问题解答

1. 为什么手势冲突在 iOS 上很常见？

因为 iOS 上的 UIScrollView 可以响应多种手势，并且它经常与 Flutter 视图一起使用，这可能导致手势冲突。

2. 手势竞技场是如何工作的？

手势竞技场是一个负责协调手势的系统，可确保同一时间只有一个手势被识别。它通过让手势识别器注册自己并协调它们的活动来实现此目的。

3. 如何在 Flutter 中使用手势竞技场？

在 Flutter 视图的最顶层添加一个 GestureRecognizer Widget，并将其作为竞技场的子控件。

4. 除了手势竞技场，还有其他解决手势冲突的方法吗？

是的，还有其他方法，例如使用 GestureDetector Widget 或重写控件的手势识别逻辑。

5. 为什么解决手势冲突很重要？

解决手势冲突很重要，因为它可以防止错误的操作，并确保用户获得流畅、无缝的体验。

参考链接

你把它发给产品经理，他看了一眼说：“我一定要完整的输入国家名称吗，当我输入文字时难道你就不能给我展示些建议吗？”，你想了想：“好吧，他是对的”，因此，你决定开发一个‘自动补全‘的’预先输入’功能，随便你怎么称呼它：一个文本展示框 TextField ，当用户输入文字的时候展示一些建议选项。开始工作了..你知道怎么拿到建议数据，你知道怎么写逻辑，你知道所有要做的事情..除了不知道怎么将建议选项浮动展示在 Widgets 之上。

你想了想：打算重新设计代码结构，为了实现悬浮效果，决定将整个页面包装进一个 Stack 组件中，你需要准确的计算每个 Widget 显示的位置，非常侵入性、必须要严谨、容易出错，并且直觉告诉你这么做可能是错误的，有其他的实现方式吗？

方案就是：你可以使用 Flutter 已经提供好的 Stack ：Overlay

在这片文章中，我将会介绍如何使用 Overlay ，来创建悬浮在其他 Widget 之上的 Widgets，并且并不需要重构你的整个页面。

你可以使用 Overlay 来展示自动匹配的建议选项，小提示，或着基本上所有的浮动的东西。

Overlay是什么？

官方文档这样定义

A Stack of entries that can be managed independently. // 一个可以独立管理的Stack子类

Overlays let independent child widgets “float” visual elements on top of other widgets by inserting them into the overlay’s Stack. // 通过将可独立管理的子节点widgets加入到overlay的栈中，Overlays可以将这些widgets浮动展示到显现的elements节点的顶部

这看起来就是我们正在寻找的内容，当我们创建 MaterialApp 的时候，它会自动创建一个Navigator，Navigator 则又会创建一个 Overlay : 一个 Navigator 用来管理所展示的 Views 视图的 Stack 组件。

接下来，让我们一起看看怎么使用 Overlay 来解决我们的问题吧。

注意：这篇文章的核心是介绍如何显示浮动 Widgets，因此不会涉及太多如何实现自动补全文本输入框 TextField 的细节，如果你对一个编写良好、可高度自定义的自动补全 Widget 感兴趣的话，可以参考 flutter_typeahead 。

初始代码

我们以最初的代码开始吧：

Scaffold(
  body: Padding(
    padding: const EdgeInsets.all(50.0),
    child: Form(
      child: ListView(
        children: <Widget>[
          TextFormField(
            decoration: InputDecoration(
                labelText: 'Address'
            ),
          ),
          SizedBox(height: 16.0,),
          TextFormField(
            decoration: InputDecoration(
                labelText: 'City'
            ),
          ),
          SizedBox(height: 16.0,),
          TextFormField(
            decoration: InputDecoration(
                labelText: 'Address'
            ),
          ),
          SizedBox(height: 16.0,),
          RaisedButton(
            child: Text('SUBMIT'),
            onPressed: () {
              // submit the form
            },
          )
        ],
      ),
    ),
  ),
)

Scaffold(

body: Padding(

padding: const EdgeInsets.all(50.0),

child: Form(

child: ListView(

children: <Widget>[

TextFormField(

decoration: InputDecoration(

labelText: 'Address'

SizedBox(height: 16.0,),

TextFormField(

decoration: InputDecoration(

labelText: 'City'

SizedBox(height: 16.0,),

TextFormField(

decoration: InputDecoration(

labelText: 'Address'

SizedBox(height: 16.0,),

RaisedButton(

child: Text('SUBMIT'),

onPressed: () {

// submit the form

)

*一个简单页面，包含了三个文本输入框：country、city、address。

然后我们就以 country 文本输入框为例吧，将它封装成一个我们自己的 StatefulWidget，命名为 CountriesField 。

class CountriesField extends StatefulWidget {
  @override
  _CountriesFieldState createState() => _CountriesFieldState();
}

class _CountriesFieldState extends State<CountriesField> {
  @override
  Widget build(BuildContext context) {
    return TextFormField(
      decoration: InputDecoration(
        labelText: 'Country'
      ),
    );
  }
}

class CountriesField extends StatefulWidget {

@override

_CountriesFieldState createState() => _CountriesFieldState();

}

class _CountriesFieldState extends State<CountriesField> {

@override

Widget build(BuildContext context) {

return TextFormField(

decoration: InputDecoration(

labelText: 'Country'

);

}

接下来我们将要做的是，每次当选中文本输入框获取焦点 Focus 的时候，将一个浮动的 List 列表展示出来。当失去焦点 Focus 的时候，再将它隐藏起来，当然你可以按照自己需求来决定如何实现，你可能需要在用户输入了一些文字后展示它，或者当用户点击 Enter 按钮的时候再隐藏。无论怎样，让我们先看看如何展示这个悬浮的 Widget吧：

class CountriesField extends StatefulWidget {
  @override
  _CountriesFieldState createState() => _CountriesFieldState();
}

class _CountriesFieldState extends State<CountriesField> {

  final FocusNode _focusNode = FocusNode();

  OverlayEntry _overlayEntry;

  @override
  void initState() {
    _focusNode.addListener(() {
      if (_focusNode.hasFocus) {

        this._overlayEntry = this._createOverlayEntry();
        Overlay.of(context).insert(this._overlayEntry);

      } else {
        this._overlayEntry.remove();
      }
    });
  }

  OverlayEntry _createOverlayEntry() {

    RenderBox renderBox = context.findRenderObject();
    var size = renderBox.size;
    var offset = renderBox.localToGlobal(Offset.zero);

    return OverlayEntry(
      builder: (context) => Positioned(
        left: offset.dx,
        top: offset.dy + size.height + 5.0,
        width: size.width,
        child: Material(
          elevation: 4.0,
          child: ListView(
            padding: EdgeInsets.zero,
            shrinkWrap: true,
            children: <Widget>[
              ListTile(
                title: Text('Syria'),
              ),
              ListTile(
                title: Text('Lebanon'),
              )
            ],
          ),
        ),
      )
    );
  }

  @override
  Widget build(BuildContext context) {
    return TextFormField(
        focusNode: this._focusNode,
      decoration: InputDecoration(
        labelText: 'Country'
      ),
    );
  }
}

class CountriesField extends StatefulWidget {

@override

_CountriesFieldState createState() => _CountriesFieldState();

}

class _CountriesFieldState extends State<CountriesField> {

final FocusNode _focusNode = FocusNode();

OverlayEntry _overlayEntry;

@override

void initState() {

_focusNode.addListener(() {

if (_focusNode.hasFocus) {

this._overlayEntry = this._createOverlayEntry();

Overlay.of(context).insert(this._overlayEntry);

} else {

this._overlayEntry.remove();

}

});

}

OverlayEntry _createOverlayEntry() {

RenderBox renderBox = context.findRenderObject();

var size = renderBox.size;

var offset = renderBox.localToGlobal(Offset.zero);

return OverlayEntry(

builder: (context) => Positioned(

left: offset.dx,

top: offset.dy + size.height + 5.0,

width: size.width,

child: Material(

elevation: 4.0,

child: ListView(

padding: EdgeInsets.zero,

shrinkWrap: true,

children: <Widget>[

ListTile(

title: Text('Syria'),

ListTile(

title: Text('Lebanon'),

)

);

}

@override

Widget build(BuildContext context) {

return TextFormField(

focusNode: this._focusNode,

decoration: InputDecoration(

labelText: 'Country'

);

}

我们给 TextFormField 绑定了一个 FocusNode，并且在 initState 里面给 FocusNode 添加了一个监听事件，通过监听事件来获取什么时候获得/失去焦点。
每次当我们获取焦点 (_focusNode.hasFocus == true) 的时候，我们通过 _createOverlayEntry 创建一个OverlayEntry 实例对象，然后通过使用 Overlay.of(context).insert，将它插入到最邻近的 Overlay Widget 中去。
每次当我们失去焦点 (_focusNode.hasFocus == false) 的时候，我们通过使用 _overlayEntry.remove 来移除刚才添加的 Overlay 实例。
_createOverlayEntry 通过使用 context.findRenderObject 来获取我们的 Widget 所在的渲染对象 RenderBox ，渲染对象里包含位置 Position、大小 Size、和一些其他关于渲染的信息，有了这些信息能够帮助我们计算在哪里展示我们的悬浮列表。
_createOverlayEntry 通过渲染信息来获取当前 Widget 的大小，也可以使用 renderBox.localToGlobal 来获取当前 Widget 在屏幕上的坐标。我们将 localToGlobal 设置为 Offset.zero 这意味着我们将在渲染对象中使用（0,0）坐标，并且将他们转换为屏幕上相对应的坐标。
接着我们创建了 OverlayEntry，这时一个用来将 Widgets 展示到 Overlay 中的 Widget。
当前创建的 OverlayEntry 的是一个 Positioned Widget。请牢记 Positioned Widgets 只能被插入到 Stack 中，当然 Overlay 其实也是一个 Stack。
我们设置 Positioned Widget 的坐标，给它和 TextField 相同的 X 轴坐标，相同的宽度，相同的 Y 轴坐标，当然为了不遮挡到 TextField，在底部进行了一些偏移。
在 Positioned 内部，我们设置了一个展示建议选项的 ListView（里面默写了例子中的一些国家）。注意到我把所有的内容都包在了 Material 中，关于这样写有两个原因： Overlay 默认不包含 Material Widget，并且很多 Widgets 如果没有有 Material 祖先节点的话不能展示，除此之外 Material 还提供了 elevation 属性，可以让我们给 Widget 设置阴影效果，看起来就像真正浮在上面一样。

以上，我们的建议选择项可以浮在所有 Widget 之上了！

彩蛋：跟随 Widget 滑动！

在我们离开之前，让我们在多学喜一点吧！假如我们的页面是可以滚动，我们可能注意到如下现象：

建议选择列表固定在了屏幕上！在某些场景下你可能的确需要固定的，但是在当前场景中，我们不想要它固定，我们想要它跟随我们的 TextField 一起滚动！

关键词滚动，Flutter给我们提供了两个widget：CompositedTransformFollower、CompositedTransformTarget，简单介绍就是，如果我们关联起一个 follower 和一个 target ，那么无论 target 滚动到哪里，这个 follower 将跟随它一起滚动！为了关联起一个 follower 和一个target，我们需要给他们设置相同的LayerLink.

因此我们需要将建议选择列表用 CompositedTransformFollower 包起来，将 TextField 用 CompositedTransformTarget 包起来。然后我们将他们使用想用的 LayerLink 关联起来，这样就可以是建议选择列表跟随 TextField 一起滑动了：

class CountriesField extends StatefulWidget {
  @override
  _CountriesFieldState createState() => _CountriesFieldState();
}
class _CountriesFieldState extends State<CountriesField> {

  final FocusNode _focusNode = FocusNode();

  OverlayEntry _overlayEntry;

  final LayerLink _layerLink = LayerLink();

  @override
  void initState() {
    _focusNode.addListener(() {
      if (_focusNode.hasFocus) {

        this._overlayEntry = this._createOverlayEntry();
        Overlay.of(context).insert(this._overlayEntry);

      } else {
        this._overlayEntry.remove();
      }
    });
  }

  OverlayEntry _createOverlayEntry() {

    RenderBox renderBox = context.findRenderObject();
    var size = renderBox.size;

    return OverlayEntry(
      builder: (context) => Positioned(
        width: size.width,
        child: CompositedTransformFollower(
          link: this._layerLink,
          showWhenUnlinked: false,
          offset: Offset(0.0, size.height + 5.0),
          child: Material(
            elevation: 4.0,
            child: ListView(
              padding: EdgeInsets.zero,
              shrinkWrap: true,
              children: <Widget>[
                ListTile(
                  title: Text('Syria'),
                  onTap: () {
                    print('Syria Tapped');
                  },
                ),
                ListTile(
                  title: Text('Lebanon'),
                  onTap: () {
                    print('Lebanon Tapped');
                  },
                )
              ],
            ),
          ),
        ),
      )
    );
  }

  @override
  Widget build(BuildContext context) {
    return CompositedTransformTarget(
      link: this._layerLink,
      child: TextFormField(
          focusNode: this._focusNode,
        decoration: InputDecoration(
          labelText: 'Country'
        ),
      ),
    );
  }
}

class CountriesField extends StatefulWidget {

@override

_CountriesFieldState createState() => _CountriesFieldState();

}

class _CountriesFieldState extends State<CountriesField> {

final FocusNode _focusNode = FocusNode();

OverlayEntry _overlayEntry;

final LayerLink _layerLink = LayerLink();

@override

void initState() {

_focusNode.addListener(() {

if (_focusNode.hasFocus) {

this._overlayEntry = this._createOverlayEntry();

Overlay.of(context).insert(this._overlayEntry);

} else {

this._overlayEntry.remove();

}

});

}

OverlayEntry _createOverlayEntry() {

RenderBox renderBox = context.findRenderObject();

var size = renderBox.size;

return OverlayEntry(

builder: (context) => Positioned(

width: size.width,

child: CompositedTransformFollower(

link: this._layerLink,

showWhenUnlinked: false,

offset: Offset(0.0, size.height + 5.0),

child: Material(

elevation: 4.0,

child: ListView(

padding: EdgeInsets.zero,

shrinkWrap: true,

children: <Widget>[

ListTile(

title: Text('Syria'),

onTap: () {

print('Syria Tapped');

ListTile(

title: Text('Lebanon'),

onTap: () {

print('Lebanon Tapped');

)

);

}

@override

Widget build(BuildContext context) {

return CompositedTransformTarget(

link: this._layerLink,

child: TextFormField(

focusNode: this._focusNode,

decoration: InputDecoration(

labelText: 'Country'

);

}

我们将 Material Widget 用 CompositedTransformFollower 包裹进 OverlayEntry 中，将TextFormField 包裹进 CompositedTransformTarget 中。
我们使用相同的 LayerLink 示例，来关联 follower 和 target，这样 follower 和 target 将会在相同的坐标系中，高效的跟随 target 而动。
从 Positioned Widget 中移除了 top 和 left 属性，因为默认 follower 和target 有相同的坐标，因此不在需要。然而我们保留了 width 属性，因为如果不设置的话，follower 将会无限的延伸。
为了不遮挡 TextFormField ，我们给 CompositedTransformFollower 设置了一个offset（和之前一样的原因）。
最后，我们将 showWhenUnlinked 属性设置为 false，当 TextFormField 在屏幕上不可见时，用来隐藏OverlayEntry（比如我们滑动出屏幕底部很远的时候）。

经过这些操作，我们的 OverlayEntry 现在可以跟随我们的 TextField 一起滚动啦！

重要提示：CompositedTransformFollower 仍然有一点问题，当 target 不可见时，即使 follower 已经从屏幕上隐藏了，这个 follower 仍然会响应点击事件，我已经给 Flutter Team 提了 issue ，此 issue 已经关闭，标记为解决。

Overlay 是一个强大的 Widget ，它给我们提供了一个简单易用的的用来展示浮动 Widget 的的 Stack 组件。

参考链接

Flutter - 左右侧滑菜单：drawer和endDrawer

侧滑菜单可以从左面滑出，也可以从右面滑出。在Scaffold中有drawer和endDrawer两个参数，分别对应左边的菜单和右边的菜单。

      drawer: new Drawer(
        child: new ListView(
          children: <Widget>[
            
          ],
        ),
      ),

drawer: new Drawer(

child: new ListView(

children: <Widget>[

      endDrawer: new Drawer(
        child: new ListView(
          children: <Widget>[
            
          ],
        ),
      ),

endDrawer: new Drawer(

child: new ListView(

children: <Widget>[

参考链接

Flutter监听软键盘的弹出和关闭获取键盘高度

通过 WidgetsBindingObserver 实现监听软键盘的弹出关闭

实现 WidgetsBindingObserver

 class _State extends State<MyPage> with WidgetsBindingObserver {

  @override
  void initState() {
    super.initState();
    // 初始化
    WidgetsBinding.instance.addObserver(this);
  }

  @override
  void dispose() {
    // 销毁
    WidgetsBinding.instance.removeObserver(this);
    super.dispose();
  }

  // 监听
  @override
  void didChangeMetrics() {
    super.didChangeMetrics();
    WidgetsBinding.instance.addPostFrameCallback((_) {
      if(mounted){
        if(0 == MediaQuery.viewInsetsOf(context).bottom) {
           // 关闭键盘
        } else {
           // 显示键盘
        }
      }
    });
  }
}

class _State extends State<MyPage> with WidgetsBindingObserver {

@override

void initState() {

super.initState();

// 初始化

WidgetsBinding.instance.addObserver(this);

}

@override

void dispose() {

// 销毁

WidgetsBinding.instance.removeObserver(this);

super.dispose();

}

// 监听

@override

void didChangeMetrics() {

super.didChangeMetrics();

WidgetsBinding.instance.addPostFrameCallback((_) {

if(mounted){

if(0 == MediaQuery.viewInsetsOf(context).bottom) {

// 关闭键盘

} else {

// 显示键盘

}

});

}

注意:

如果使用 Scaffold 作为父组件，在使用 MediaQuery.viewInsetsOf(context).bottom 获取键盘高度如果无论如何都是 0 。

此时有两种方案：

1. 需设置父级 Scaffold 的 resizeToAvoidBottomInset 为 false 。

Scaffold(
  // 子组件若需要监听键盘高度，需设置为false
  resizeToAvoidBottomInset:false,
  appBar: AppBar(
    title: '页面title',
  ),
  body: ContentPage(),//子页面中监听键盘高度
),

Scaffold(

// 子组件若需要监听键盘高度，需设置为false

resizeToAvoidBottomInset:false,

appBar: AppBar(

title: '页面title',

body: ContentPage(),//子页面中监听键盘高度

但是这样设置之后，会导致键盘弹出的时候，Scaffold 不会自动向上移动，导致输入范围被遮挡。

2. 使用 Scaffold 上层/同层的 BuildContext 作为参数传递给子 View ，然后传递给 MediaQuery 作为参数。

原始链接

通过共享内存优化Flutter外接纹理的渲染性能，实时渲染不是梦

前言

看了咸鱼这篇《万万没想到——Flutter这样外接纹理》的文章，我们了解到 Flutter 提供一种机制，可以将 Native 的纹理共享给 Flutter 来进行渲染。但是，由于 Flutter 获取 Native 纹理的数据类型是 CVPixelBuffer，导致 Native 纹理需要经过 GPU->CPU->GPU 的转换过程消耗额外性能，这对于需要实时渲染的音视频类需求，是不可接受的。

闲鱼这边的解决方案是修改了 Flutter Engine 的代码，将 Flutter 的 GL 环境和 native 的 GL 环境通过 ShareGroup 来联通，避免2个环境的纹理传递还要去 CPU 内存绕一圈。此方案能够解决内存拷贝的性能问题，但暴露 Flutter 的 GL 环境，毕竟是一个存在风险的操作，给以后的 Flutter 渲染问题定位也增加了复杂度。所以，有没有一个完美、简便的方案呢？答案就是利用 CVPixelBuffer 的共享内存机制。

Flutter外接纹理的原理

先回顾下前置知识，看看官方提供的外接纹理机制究竟是怎样运行的。

图中红色块，是我们自己要编写的 Native 代码，黄色是 Flutter Engine 的内部代码逻辑。整体流程分为注册纹理，和整体的纹理渲染逻辑。

注册纹理

创建一个对象，实现FlutterTexture协议，该对象用来管理具体的纹理数据
通过FlutterTextureRegistry来注册第一步的FlutterTexture对象，获取一个flutter纹理id
将该id通过channel机制传递给dart侧，dart侧就能够通过Texture这个widget来使用纹理了，参数就是id

纹理渲染

dart侧声明一个Texture widget，表明该widget实际渲染的是native提供的纹理
engine侧拿到layerTree，layerTree的TextureLayer节点负责外接纹理的渲染
首先通过dart侧传递的id，找到先注册的FlutterTexture，该flutterTexture是我们自己用native代码实现的，其核心是实现了copyPixelBuffer方法
flutter engine调用copyPixelBuffer拿到具体的纹理数据，然后交由底层进行gpu渲染

CVPixelBuffer格式分析

一切问题的根源就在这里了：CVPixelBuffer。从上面flutter外接纹理的渲染流程来看，native纹理到flutter纹理的数据交互，是通过 copyPixelBuffer 传递的，其参数就是 CVPixelBuffer。而前面咸鱼文章里面说的性能问题，就来自于纹理与 CVPixelBuffer 之间的转换。

那么，如果 CVPixelBuffer 能够和OpenGL的纹理同享同一份内存拷贝，GPU -> CPU -> GPU的性能瓶颈，是否就能够迎刃而解了呢？其实我们看一下flutter engine里面利用CVPixelBuffer来创建纹理的方法，就能够得到答案：

void IOSExternalTextureGL::CreateTextureFromPixelBuffer() {
	// 注意buffer_ref就是copyPixelBuffer返回的buffer数据
  CVOpenGLESTextureRef texture;
  CVReturn err = CVOpenGLESTextureCacheCreateTextureFromImage(
      kCFAllocatorDefault, cache_ref_, buffer_ref_, nullptr, GL_TEXTURE_2D, GL_RGBA,
      static_cast<int>(CVPixelBufferGetWidth(buffer_ref_)),
      static_cast<int>(CVPixelBufferGetHeight(buffer_ref_)), GL_BGRA, GL_UNSIGNED_BYTE, 0,
      &texture);
  if (err != noErr) {
    FML_LOG(WARNING) << "Could not create texture from pixel buffer: " << err;
  } else {
    texture_ref_.Reset(texture);
  }
}

void IOSExternalTextureGL::CreateTextureFromPixelBuffer() {

// 注意buffer_ref就是copyPixelBuffer返回的buffer数据

CVOpenGLESTextureRef texture;

CVReturn err = CVOpenGLESTextureCacheCreateTextureFromImage(

kCFAllocatorDefault, cache_ref_, buffer_ref_, nullptr, GL_TEXTURE_2D, GL_RGBA,

static_cast<int>(CVPixelBufferGetWidth(buffer_ref_)),

static_cast<int>(CVPixelBufferGetHeight(buffer_ref_)), GL_BGRA, GL_UNSIGNED_BYTE, 0,

&texture);

if (err != noErr) {

FML_LOG(WARNING) << "Could not create texture from pixel buffer: " << err;

} else {

texture_ref_.Reset(texture);

}

Flutter Engine是使用 CVOpenGLESTextureCacheCreateTextureFromImage 这个接口来从 CVPixelBuffer 对象创建OpenGL纹理的，那么这个接口实际上做了什么呢？我们来看一下官方文档

This function either creates a new or returns a cached CVOpenGLESTextureRef texture object mapped to the CVImageBufferRef and associated parameters. This operation creates a live binding between the image buffer and the underlying texture object. The EAGLContext associated with the cache may be modified to create, delete, or bind textures. When used as a source texture or GL_COLOR_ATTACHMENT, the image buffer must be unlocked before rendering. The source or render buffer texture should not be re-used until the rendering has completed. This can be guaranteed by calling glFlush().

从文档里面，我们了解到几个关键点：

返回的纹理对象，是直接映射到了CVPixelBufferRef对象的内存的
这块buffer内存，其实是可以同时被CPU和GPU访问的，我们只需要遵循如下的规则：
- GPU访问的时候，该 CVPixelBuffer ，不能够处于lock状态。
  使用过pixelbuffer的同学应该都知道，通常CPU操作pixelbuffer对象的时候，要先进行lock操作，操作完毕再unlock。所以这里也容易理解，GPU使用纹理的时候，其必然不能够同时被CPU操作。
- CPU访问的时候，要保证GPU已经渲染完成，通常是指在 glFlush() 调用之后。
  这里也容易理解，CPU要读写这个buffer的时候，要保证关联的纹理不能正在被OpenGL渲染。

我们用instrument的allocation来验证一下：

instrument的结果，也能够印证文档中的结论。只有在创建pixelBuffer的时候，才分配了内存，而映射到纹理的时候，并没有新的内存分配。

这里也能印证我们的结论，创建pixelBuffer的时候，才分配了内存，映射到纹理的时候，并没有新的内存分配。

共享内存方案

既然了解到CVPixelBuffer对象，实际上是可以桥接一个OpenGL的纹理的，那我们的整体解决方案就水到渠成了，可以看看下面这个图

关键点在于，首先需要创建pixelBuffer对象，并分配内存。然后在native gl环境和flutter gl环境里面分别映射一个纹理对象。这样，在2个独立的gl环境里面，我们都有各自的纹理对象，但实际上其内存都被映射到同一个CVPixelBuffer上。在实际的每一帧渲染流程里面，native环境做渲染到纹理，而flutter环境里面则是从纹理读取数据。

Demo演示

这里我写了个小demo来验证下实际效果，demo的主要逻辑是以60FPS的帧率，渲染一个旋转的三角形到一个pixelBuffer映射的纹理上。然后每帧绘制完成之后，通知 Flutter 侧来读取这个pixelBuffer对象去做渲染。

核心代码展示如下：

- (void)createCVBufferWith:(CVPixelBufferRef *)target withOutTexture:(CVOpenGLESTextureRef *)texture {
  	
  	// 创建纹理缓存池，这个不是重点
    CVReturn err = CVOpenGLESTextureCacheCreate(kCFAllocatorDefault, NULL, _context, NULL, &_textureCache);
		
  	// 其他代码略
   	// 核心参数是这个，共享内存必须要设置这个kCVPixelBufferIOSurfacePropertiesKey
    CFDictionarySetValue(attrs, kCVPixelBufferIOSurfacePropertiesKey, empty);
  
  	// 分配pixelBuffer对象的内存，注意flutter需要的是BGRA格式
  	CVPixelBufferCreate(kCFAllocatorDefault, _size.width, _size.height, kCVPixelFormatType_32BGRA, attrs, target);
    
  	// 映射上面的pixelBuffer对象到一个纹理上
    CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault, _textureCache, *target, NULL, GL_TEXTURE_2D, GL_RGBA, _size.width, _size.height, GL_BGRA, GL_UNSIGNED_BYTE, 0, texture);
    
    CFRelease(empty);
    CFRelease(attrs);
}

- (CVPixelBufferRef)copyPixelBuffer {
		// 实现FlutterTexture协议的接口，每次flutter是直接读取我们映射了纹理的pixelBuffer对象
  	CVBufferRetain(_target);
    return _target;
}

- (void)initGL {
    _context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
    [EAGLContext setCurrentContext:_context];
  	
  	// 先调用上面的函数创建共享内存的pixelBuffer和texture对象
    [self createCVBufferWith:&_target withOutTexture:&_texture];
        
    // 创建帧缓冲区
    glGenFramebuffers(1, &_frameBuffer);
    glBindFramebuffer(GL_FRAMEBUFFER, _frameBuffer);
    
    // 将纹理附加到帧缓冲区上
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, CVOpenGLESTextureGetName(_texture), 0);
		
  	// 略
}

- (void)createCVBufferWith:(CVPixelBufferRef *)target withOutTexture:(CVOpenGLESTextureRef *)texture {

// 创建纹理缓存池，这个不是重点

CVReturn err = CVOpenGLESTextureCacheCreate(kCFAllocatorDefault, NULL, _context, NULL, &_textureCache);

// 其他代码略

// 核心参数是这个，共享内存必须要设置这个kCVPixelBufferIOSurfacePropertiesKey

CFDictionarySetValue(attrs, kCVPixelBufferIOSurfacePropertiesKey, empty);

// 分配pixelBuffer对象的内存，注意flutter需要的是BGRA格式

CVPixelBufferCreate(kCFAllocatorDefault, _size.width, _size.height, kCVPixelFormatType_32BGRA, attrs, target);

// 映射上面的pixelBuffer对象到一个纹理上

CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault, _textureCache, *target, NULL, GL_TEXTURE_2D, GL_RGBA, _size.width, _size.height, GL_BGRA, GL_UNSIGNED_BYTE, 0, texture);

CFRelease(empty);

CFRelease(attrs);

}

- (CVPixelBufferRef)copyPixelBuffer {

// 实现FlutterTexture协议的接口，每次flutter是直接读取我们映射了纹理的pixelBuffer对象

CVBufferRetain(_target);

return _target;

}

- (void)initGL {

_context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];

[EAGLContext setCurrentContext:_context];

// 先调用上面的函数创建共享内存的pixelBuffer和texture对象

[self createCVBufferWith:&_target withOutTexture:&_texture];

// 创建帧缓冲区

glGenFramebuffers(1, &_frameBuffer);

glBindFramebuffer(GL_FRAMEBUFFER, _frameBuffer);

// 将纹理附加到帧缓冲区上

glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, CVOpenGLESTextureGetName(_texture), 0);

// 略

}

关键代码都添加了注释，这里就不分析了

我们从上面的gif图上可以看到整个渲染过程是十分流畅的，最后看displayLink的帧率也能够达到60FPS。该demo是可以套用到其他的需要CPU与GPU共享内存的场景的。

完整的demo代码在这里flutter_texture

参考链接

通过共享内存优化flutter外接纹理的渲染性能，实时渲染不是梦

Flutter格式化排除代码段

前置条件

ubuntu 24.04.2 LTS

Visual Studio Code 1.98.2

Android Studio Meerkat | 2024.3.1

Flutter 3.29.1

问题描述

在使用 Flutter 编写代码的时候，如下代码进行格式化

final List<String> symbols = ["+", "@", "\\", "/", "*", "#", "\$", "&", "%"];                                                            
final List<String> digits = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];

1 2	final List<String> symbols = ["+", "@", "\\", "/", "*", "#", "\$", "&", "%"]; final List<String> digits = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];

可以发现格式化后的结果变成了如下的样子：

 final List<String> symbols = ["+", "@", "\\", "/", "*", "#", "\$", "&", "%"];                                                                   
 final List<String> digits = [                                                                                                                   
    "0",                                                                                                                                          
    "1",                                                                                                                                          
    "2",                                                                                                                                          
    "3",                                                                                                                                          
    "4",                                                                                                                                          
    "5",                                                                                                                                          
    "6",                                                                                                                                          
    "7",                                                                                                                                          
    "8",                                                                                                                                          
    "9"                                                                                                                                           
  ];

final List<String> symbols = ["+", "@", "\\", "/", "*", "#", "\$", "&", "%"];

final List<String> digits = [

"0",

"1",

"2",

"3",

"4",

"5",

"6",

"7",

"8",

"9"

];

这部分代码我们不希望格式化，尤其是编写加解密算法的时候，里面的置换数组格式化之后会完全乱掉。

可以使用

// @formatter:off

 ..........................

// @formatter:on

// @formatter:off

..........................

// @formatter:on

阻止格式化工具对具体代码块格式化。

比如如下代码：

import 'dart:convert';

import 'package:convert/convert.dart';

// ignore: constant_identifier_names
enum SM4CryptoMode { ECB, CBC }

class SM4 {
// @formatter:off
// ignore: constant_identifier_names
  static const List<int> S_BOX = [
    0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,
    0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
    0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62,
    0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6,
    0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8,
    0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35,
    0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87,
    0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e,
    0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1,
    0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3,
    0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f,
    0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51,
    0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8,
    0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0,
    0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84,
    0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48
  ];

  // ignore: constant_identifier_names
  static const List<int> FK = [
    0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC
  ];

  // ignore: constant_identifier_names
  static const List<int> CK = [
    0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
    0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
    0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
    0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
    0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,
    0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
    0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,
    0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279
  ];
  // @formatter: on

  // ignore: constant_identifier_names
  static const int SM4_ENCRYPT = 1;

  // ignore: constant_identifier_names
  static const int SM4_DECRYPT = 0;

  static const int blockSize = 16;

  static final _encryptKey = List<int>.filled(32, 0);
  static final _decryptKey = List<int>.filled(32, 0);

  static int _leftShift(int x, int n

      ) {
    int s = n & 31;
    x = (x & 0xFFFFFFFF).toSigned(32);
    return (((x << s) | ((x & 0xFFFFFFFF) >> (32 - s))) & 0xFFFFFFFF)
        .toSigned(32);
  }

  static int _readUint32BE(List<int> b, int i) {
    return ((b[i] & 0xff) << 24) |
        ((b[i + 1] & 0xff) << 16) |
        ((b[i + 2] & 0xff) << 8) |
        (b[i + 3] & 0xff);
  }

  static void _writeUint32BE(int n, List<int> b, int i) {
    b[i] = ((n >> 24) & 0xff);
    b[i + 1] = ((n >> 16) & 0xff);
    b[i + 2] = ((n >> 8) & 0xff);
    b[i + 3] = n & 0xff;
  }

  static int _sBox(int inch) => S_BOX[inch & 0xFF];

  static int _sm4F(int x0, int x1, int x2, int x3, int rk) {
    final x = x1 ^ x2 ^ x3 ^ rk;
    int bb = 0;
    int c = 0;
    List<int> a = List<int>.filled(4, 0);
    List<int> b = List<int>.filled(4, 0);
    _writeUint32BE(x, a, 0);
    b[0] = _sBox(a[0]);
    b[1] = _sBox(a[1]);
    b[2] = _sBox(a[2]);
    b[3] = _sBox(a[3]);
    bb = _readUint32BE(b, 0);

    c = bb ^
        _leftShift(bb, 2) ^
        _leftShift(bb, 10) ^
        _leftShift(bb, 18) ^
        _leftShift(bb, 24);
    return x0 ^ c;
  }

  static int _calculateRoundKey(int key) {
    int roundKey = 0;
    List<int> keyBytes = List<int>.filled(4, 0);
    List<int> sBoxBytes = List<int>.filled(4, 0);
    _writeUint32BE(key, keyBytes, 0);
    for (int i = 0; i < 4; i++) {
      sBoxBytes[i] = _sBox(keyBytes[i]);
    }
    int temp = _readUint32BE(sBoxBytes, 0);
    roundKey = temp ^ _leftShift(temp, 13) ^ _leftShift(temp, 23);
    return roundKey;
  }

  static void setKey(String key) {
    final List<int> keyBytes = utf8.encoder.convert(key);
    final List<int> intermediateKeys = List<int>.filled(36, 0);
    for (int i = 0; i < 4; i++) {
      intermediateKeys[i] = _readUint32BE(keyBytes, i * 4) ^ FK[i];
    }
    for (int i = 0; i < 32; i++) {
      intermediateKeys[i + 4] = intermediateKeys[i] ^
          _calculateRoundKey(intermediateKeys[i + 1] ^
              intermediateKeys[i + 2] ^
              intermediateKeys[i + 3] ^
              CK[i]);
      _encryptKey[i] = intermediateKeys[i + 4];
    }

    for (int i = 0; i < 16; i++) {
      int temp = _encryptKey[i];
      _decryptKey[i] = _encryptKey[31 - i];
      _decryptKey[31 - i] = temp;
    }
  }

  static void _round(List<int> sk, List<int> input, List<int> output) {
    int i = 0;
    final List<int> buf = List<int>.filled(36, 0);
    buf[0] = _readUint32BE(input, 0);
    buf[1] = _readUint32BE(input, 4);
    buf[2] = _readUint32BE(input, 8);
    buf[3] = _readUint32BE(input, 12);
    while (i < 32) {
      buf[i + 4] =
          _sm4F(buf[i], buf[i + 1], buf[i + 2], buf[i + 3], sk[i]);
      i++;
    }

    _writeUint32BE(buf[35], output, 0);
    _writeUint32BE(buf[34], output, 4);
    _writeUint32BE(buf[33], output, 8);
    _writeUint32BE(buf[32], output, 12);
  }

  static List<int> _padding(List<int> input, int mode) {
    final int padLen = blockSize - (input.length % blockSize);

    if (mode == SM4_ENCRYPT) {
      final paddedList = List<int>.filled(input.length + padLen, 0);
      paddedList.setRange(0, input.length, input);
      for (int i = input.length; i < paddedList.length; i++) {
        paddedList[i] = padLen;
      }
      return paddedList;
    } else {
      final lastByte = input.last;
      final cutLen = input.length - lastByte;
      return input.sublist(0, cutLen);
    }
  }

  static List<int> crypto(
      List<int> data, int flag, SM4CryptoMode mode, String? iv) {
    late List<int> lastVector;
    if (mode == SM4CryptoMode.CBC) {
      if (iv == null || iv.length != 32) {
        throw Exception("IV must be a string of length 16");
      } else {
        lastVector = hex.decoder.convert(iv);
      }
    }
    final key = (flag == SM4_ENCRYPT) ? _encryptKey : _decryptKey;
    if (flag == SM4_ENCRYPT) {
      data = _padding(data, SM4_ENCRYPT);
    }
    final length = data.length;
    final List<int> output = [];

    for (int offset = 0; offset < length; offset += blockSize) {
      final outData = List<int>.filled(blockSize, 0);
      final copyLen =
          (offset + blockSize <= length) ? blockSize : length - offset;
      final input = data.sublist(offset, offset + copyLen);
      if (mode == SM4CryptoMode.CBC && flag == SM4_ENCRYPT) {
        for (int i = 0; i < blockSize; i++) {
          input[i] = input[i] ^ lastVector[i];
        }
      }
      _round(key, input, outData);

      if (mode == SM4CryptoMode.CBC && flag == SM4_DECRYPT) {
        for (int i = 0; i < blockSize; i++) {
          outData[i] ^= lastVector[i];
        }
      }
      output.addAll(outData);

      if (mode == SM4CryptoMode.CBC) {
        if (flag == SM4_ENCRYPT) {
          lastVector = outData;
        } else {
          lastVector = input;
        }
      }
    }
    if (flag == SM4_DECRYPT) {
      return _padding(output, SM4_DECRYPT);
    }
    return output;
  }

  static String encrypt(String plainText,
      {String? key, SM4CryptoMode mode = SM4CryptoMode.ECB, String? iv}) {
    if (key != null) setKey(key);
    final List<int> input = utf8.encode(plainText);
    final List<int> output = crypto(input, SM4_ENCRYPT, mode, iv);
    return hex.encoder.convert(output);
  }

  static decrypt(String cipherText,
      {String? key, SM4CryptoMode mode = SM4CryptoMode.ECB, String? iv}) {
    if (key != null) setKey(key);
    List<int> input = hex.decoder.convert(cipherText);
    List<int> output = crypto(input, SM4_DECRYPT, mode, iv);
    return utf8.decode(output);
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

import 'dart:convert';

import 'package:convert/convert.dart';

// ignore: constant_identifier_names

enum SM4CryptoMode { ECB, CBC }

class SM4 {

// @formatter:off

// ignore: constant_identifier_names

static const List<int> S_BOX = [

0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,

0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,

0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62,

0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6,

0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8,

0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35,

0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87,

0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e,

0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1,

0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3,

0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f,

0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51,

0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8,

0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0,

0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84,

0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48

];

// ignore: constant_identifier_names

static const List<int> FK = [

0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC

];

// ignore: constant_identifier_names

static const List<int> CK = [

0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,

0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,

0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,

0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,

0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,

0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,

0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,

0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279

];

// @formatter: on

// ignore: constant_identifier_names

static const int SM4_ENCRYPT = 1;

// ignore: constant_identifier_names

static const int SM4_DECRYPT = 0;

static const int blockSize = 16;

static final _encryptKey = List<int>.filled(32, 0);

static final _decryptKey = List<int>.filled(32, 0);

static int _leftShift(int x, int n

) {

int s = n & 31;

x = (x & 0xFFFFFFFF).toSigned(32);

return (((x << s) | ((x & 0xFFFFFFFF) >> (32 - s))) & 0xFFFFFFFF)

.toSigned(32);

}

static int _readUint32BE(List<int> b, int i) {

return ((b[i] & 0xff) << 24) |

((b[i + 1] & 0xff) << 16) |

((b[i + 2] & 0xff) << 8) |

(b[i + 3] & 0xff);

}

static void _writeUint32BE(int n, List<int> b, int i) {

b[i] = ((n >> 24) & 0xff);

b[i + 1] = ((n >> 16) & 0xff);

b[i + 2] = ((n >> 8) & 0xff);

b[i + 3] = n & 0xff;

}

static int _sBox(int inch) => S_BOX[inch & 0xFF];

static int _sm4F(int x0, int x1, int x2, int x3, int rk) {

final x = x1 ^ x2 ^ x3 ^ rk;

int bb = 0;

int c = 0;

List<int> a = List<int>.filled(4, 0);

List<int> b = List<int>.filled(4, 0);

_writeUint32BE(x, a, 0);

b[0] = _sBox(a[0]);

b[1] = _sBox(a[1]);

b[2] = _sBox(a[2]);

b[3] = _sBox(a[3]);

bb = _readUint32BE(b, 0);

c = bb ^

_leftShift(bb, 2) ^

_leftShift(bb, 10) ^

_leftShift(bb, 18) ^

_leftShift(bb, 24);

return x0 ^ c;

}

static int _calculateRoundKey(int key) {

int roundKey = 0;

List<int> keyBytes = List<int>.filled(4, 0);

List<int> sBoxBytes = List<int>.filled(4, 0);

_writeUint32BE(key, keyBytes, 0);

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

sBoxBytes[i] = _sBox(keyBytes[i]);

}

int temp = _readUint32BE(sBoxBytes, 0);

roundKey = temp ^ _leftShift(temp, 13) ^ _leftShift(temp, 23);

return roundKey;

}

static void setKey(String key) {

final List<int> keyBytes = utf8.encoder.convert(key);

final List<int> intermediateKeys = List<int>.filled(36, 0);

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

intermediateKeys[i] = _readUint32BE(keyBytes, i * 4) ^ FK[i];

}

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

intermediateKeys[i + 4] = intermediateKeys[i] ^

_calculateRoundKey(intermediateKeys[i + 1] ^

intermediateKeys[i + 2] ^

intermediateKeys[i + 3] ^

CK[i]);

_encryptKey[i] = intermediateKeys[i + 4];

}

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

int temp = _encryptKey[i];

_decryptKey[i] = _encryptKey[31 - i];

_decryptKey[31 - i] = temp;

}

static void _round(List<int> sk, List<int> input, List<int> output) {

int i = 0;

final List<int> buf = List<int>.filled(36, 0);

buf[0] = _readUint32BE(input, 0);

buf[1] = _readUint32BE(input, 4);

buf[2] = _readUint32BE(input, 8);

buf[3] = _readUint32BE(input, 12);

while (i < 32) {

buf[i + 4] =

_sm4F(buf[i], buf[i + 1], buf[i + 2], buf[i + 3], sk[i]);

i++;

}

_writeUint32BE(buf[35], output, 0);

_writeUint32BE(buf[34], output, 4);

_writeUint32BE(buf[33], output, 8);

_writeUint32BE(buf[32], output, 12);

}

static List<int> _padding(List<int> input, int mode) {

final int padLen = blockSize - (input.length % blockSize);

if (mode == SM4_ENCRYPT) {

final paddedList = List<int>.filled(input.length + padLen, 0);

paddedList.setRange(0, input.length, input);

for (int i = input.length; i < paddedList.length; i++) {

paddedList[i] = padLen;

}

return paddedList;

} else {

final lastByte = input.last;

final cutLen = input.length - lastByte;

return input.sublist(0, cutLen);

}

static List<int> crypto(

List<int> data, int flag, SM4CryptoMode mode, String? iv) {

late List<int> lastVector;

if (mode == SM4CryptoMode.CBC) {

if (iv == null || iv.length != 32) {

throw Exception("IV must be a string of length 16");

} else {

lastVector = hex.decoder.convert(iv);

}

final key = (flag == SM4_ENCRYPT) ? _encryptKey : _decryptKey;

if (flag == SM4_ENCRYPT) {

data = _padding(data, SM4_ENCRYPT);

}

final length = data.length;

final List<int> output = [];

for (int offset = 0; offset < length; offset += blockSize) {

final outData = List<int>.filled(blockSize, 0);

final copyLen =

(offset + blockSize <= length) ? blockSize : length - offset;

final input = data.sublist(offset, offset + copyLen);

if (mode == SM4CryptoMode.CBC && flag == SM4_ENCRYPT) {

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

input[i] = input[i] ^ lastVector[i];

}

_round(key, input, outData);

if (mode == SM4CryptoMode.CBC && flag == SM4_DECRYPT) {

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

outData[i] ^= lastVector[i];

}

output.addAll(outData);

if (mode == SM4CryptoMode.CBC) {

if (flag == SM4_ENCRYPT) {

lastVector = outData;

} else {

lastVector = input;

}

if (flag == SM4_DECRYPT) {

return _padding(output, SM4_DECRYPT);

}

return output;

}

static String encrypt(String plainText,

{String? key, SM4CryptoMode mode = SM4CryptoMode.ECB, String? iv}) {

if (key != null) setKey(key);

final List<int> input = utf8.encode(plainText);

final List<int> output = crypto(input, SM4_ENCRYPT, mode, iv);

return hex.encoder.convert(output);

}

static decrypt(String cipherText,

{String? key, SM4CryptoMode mode = SM4CryptoMode.ECB, String? iv}) {

if (key != null) setKey(key);

List<int> input = hex.decoder.convert(cipherText);

List<int> output = crypto(input, SM4_DECRYPT, mode, iv);

return utf8.decode(output);

}

参考链接

在Visual Studio Code中调试Flutter Dart代码报错未验证断点（Unverified Breakpoint）

前置条件

ubuntu 24.04.2 LTS

Visual Studio Code 1.98.2

Flutter 3.29.1

问题描述

在使用 Visual Studio Code 调试 Flutter 代码的时候，如果在依赖库的代码中设置断点，会无法断点，并且提示断点未验证，"Unverified Breakpoint"。

如下图：

继续阅读在Visual Studio Code中调试Flutter Dart代码报错未验证断点（Unverified Breakpoint）

Flutter多平台打包发布

fastforge (原名 flutter_distributor)是一个强大的工具，支持跨平台发布和高级打包选项。

安装

确保 fastforge 已安装：

$ dart pub global activate fastforge

1	$ dart pub global activate fastforge

配置文件

为高级打包配置所需的文件：

macOS:

如果打包 DMG 安装包：macos/packaging/dmg/make_config.yaml

title: 应用名称
contents:
  - x: 448
    y: 244
    type: link
    path: "/Applications"
  - x: 192
    y: 244
    type: file
    path: 应用名称.app

title: 应用名称

contents:

- x: 448

y: 244

type: link

path: "/Applications"

- x: 192

y: 244

type: file

path: 应用名称.app

如果打包 PKG 安装包：macos/packaging/pkg/make_config.yaml

macos/packaging/pkg/make_config.yaml
YAML

install-path: /Applications #sign-identity: <your-sign-identity>

1
2

install-path: /Applications
#sign-identity: <your-sign-identity>
distribute_options.yaml

distribute_options.yaml
YAML

output: dist/

1

output: dist/

Windows:

如果打包 exe 安装包：windows/packaging/exe/inno_setup.sas

[Setup]
AppId={{APP_ID}}
AppVersion={{APP_VERSION}}
AppName={{DISPLAY_NAME}}
AppPublisher={{PUBLISHER_NAME}}
AppPublisherURL={{PUBLISHER_URL}}
AppSupportURL={{PUBLISHER_URL}}
AppUpdatesURL={{PUBLISHER_URL}}
DefaultDirName={{INSTALL_DIR_NAME}}
DisableProgramGroupPage=yes
OutputDir=.
OutputBaseFilename={{OUTPUT_BASE_FILENAME}}
Compression=lzma
SolidCompression=yes
SetupIconFile={{SETUP_ICON_FILE}}
WizardStyle=modern
PrivilegesRequired={{PRIVILEGES_REQUIRED}}
ArchitecturesAllowed=x64
ArchitecturesInstallIn64BitMode=x64
CloseApplications=force

[Languages]
{% for locale in LOCALES %}
{% if locale == 'en' %}Name: "english"; MessagesFile: "compiler:Default.isl"{% endif %}
{% if locale == 'hy' %}Name: "armenian"; MessagesFile: "compiler:Languages\\Armenian.isl"{% endif %}
{% if locale == 'bg' %}Name: "bulgarian"; MessagesFile: "compiler:Languages\\Bulgarian.isl"{% endif %}
{% if locale == 'ca' %}Name: "catalan"; MessagesFile: "compiler:Languages\\Catalan.isl"{% endif %}
{% if locale == 'zh' %}Name: "chinesesimplified"; MessagesFile: "compiler:Languages\\ChineseSimplified.isl"{% endif %}
{% if locale == 'co' %}Name: "corsican"; MessagesFile: "compiler:Languages\\Corsican.isl"{% endif %}
{% if locale == 'cs' %}Name: "czech"; MessagesFile: "compiler:Languages\\Czech.isl"{% endif %}
{% if locale == 'da' %}Name: "danish"; MessagesFile: "compiler:Languages\\Danish.isl"{% endif %}
{% if locale == 'nl' %}Name: "dutch"; MessagesFile: "compiler:Languages\\Dutch.isl"{% endif %}
{% if locale == 'fi' %}Name: "finnish"; MessagesFile: "compiler:Languages\\Finnish.isl"{% endif %}
{% if locale == 'fr' %}Name: "french"; MessagesFile: "compiler:Languages\\French.isl"{% endif %}
{% if locale == 'de' %}Name: "german"; MessagesFile: "compiler:Languages\\German.isl"{% endif %}
{% if locale == 'he' %}Name: "hebrew"; MessagesFile: "compiler:Languages\\Hebrew.isl"{% endif %}
{% if locale == 'is' %}Name: "icelandic"; MessagesFile: "compiler:Languages\\Icelandic.isl"{% endif %}
{% if locale == 'it' %}Name: "italian"; MessagesFile: "compiler:Languages\\Italian.isl"{% endif %}
{% if locale == 'ja' %}Name: "japanese"; MessagesFile: "compiler:Languages\\Japanese.isl"{% endif %}
{% if locale == 'no' %}Name: "norwegian"; MessagesFile: "compiler:Languages\\Norwegian.isl"{% endif %}
{% if locale == 'pl' %}Name: "polish"; MessagesFile: "compiler:Languages\\Polish.isl"{% endif %}
{% if locale == 'pt' %}Name: "portuguese"; MessagesFile: "compiler:Languages\\Portuguese.isl"{% endif %}
{% if locale == 'ru' %}Name: "russian"; MessagesFile: "compiler:Languages\\Russian.isl"{% endif %}
{% if locale == 'sk' %}Name: "slovak"; MessagesFile: "compiler:Languages\\Slovak.isl"{% endif %}
{% if locale == 'sl' %}Name: "slovenian"; MessagesFile: "compiler:Languages\\Slovenian.isl"{% endif %}
{% if locale == 'es' %}Name: "spanish"; MessagesFile: "compiler:Languages\\Spanish.isl"{% endif %}
{% if locale == 'tr' %}Name: "turkish"; MessagesFile: "compiler:Languages\\Turkish.isl"{% endif %}
{% if locale == 'uk' %}Name: "ukrainian"; MessagesFile: "compiler:Languages\\Ukrainian.isl"{% endif %}
{% endfor %}

[Tasks]
Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: {% if CREATE_DESKTOP_ICON != true %}unchecked{% else %}checkedonce{% endif %}
Name: "launchAtStartup"; Description: "{cm:AutoStartProgram,{{DISPLAY_NAME}}}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: {% if LAUNCH_AT_STARTUP != true %}unchecked{% else %}checkedonce{% endif %}
[Files]
Source: "{{SOURCE_DIR}}\\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
; NOTE: Don't use "Flags: ignoreversion" on any shared system files

[Icons]
Name: "{autoprograms}\\{{DISPLAY_NAME}}"; Filename: "{app}\\{{EXECUTABLE_NAME}}"
Name: "{autodesktop}\\{{DISPLAY_NAME}}"; Filename: "{app}\\{{EXECUTABLE_NAME}}"; Tasks: desktopicon
Name: "{userstartup}\\{{DISPLAY_NAME}}"; Filename: "{app}\\{{EXECUTABLE_NAME}}"; WorkingDir: "{app}"; Tasks: launchAtStartup
[Run]
Filename: "{app}\\{{EXECUTABLE_NAME}}"; Description: "{cm:LaunchProgram,{{DISPLAY_NAME}}}"; Flags: {% if PRIVILEGES_REQUIRED == 'admin' %}runascurrentuser{% endif %} nowait postinstall skipifsilent


[Code]
function InitializeSetup(): Boolean;
var
  ResultCode: Integer;
begin
  Exec('taskkill', '/F /IM 应用名称.exe', '', SW_HIDE, ewWaitUntilTerminated, ResultCode)
  Result := True;
end;

[Setup]

AppId={{APP_ID}}

AppVersion={{APP_VERSION}}

AppName={{DISPLAY_NAME}}

AppPublisher={{PUBLISHER_NAME}}

AppPublisherURL={{PUBLISHER_URL}}

AppSupportURL={{PUBLISHER_URL}}

AppUpdatesURL={{PUBLISHER_URL}}

DefaultDirName={{INSTALL_DIR_NAME}}

DisableProgramGroupPage=yes

OutputDir=.

OutputBaseFilename={{OUTPUT_BASE_FILENAME}}

Compression=lzma

SolidCompression=yes

SetupIconFile={{SETUP_ICON_FILE}}

WizardStyle=modern

PrivilegesRequired={{PRIVILEGES_REQUIRED}}

ArchitecturesAllowed=x64

ArchitecturesInstallIn64BitMode=x64

CloseApplications=force

[Languages]

{% for locale in LOCALES %}

{% if locale == 'en' %}Name: "english"; MessagesFile: "compiler:Default.isl"{% endif %}

{% if locale == 'hy' %}Name: "armenian"; MessagesFile: "compiler:Languages\\Armenian.isl"{% endif %}

{% if locale == 'bg' %}Name: "bulgarian"; MessagesFile: "compiler:Languages\\Bulgarian.isl"{% endif %}

{% if locale == 'ca' %}Name: "catalan"; MessagesFile: "compiler:Languages\\Catalan.isl"{% endif %}

{% if locale == 'zh' %}Name: "chinesesimplified"; MessagesFile: "compiler:Languages\\ChineseSimplified.isl"{% endif %}

{% if locale == 'co' %}Name: "corsican"; MessagesFile: "compiler:Languages\\Corsican.isl"{% endif %}

{% if locale == 'cs' %}Name: "czech"; MessagesFile: "compiler:Languages\\Czech.isl"{% endif %}

{% if locale == 'da' %}Name: "danish"; MessagesFile: "compiler:Languages\\Danish.isl"{% endif %}

{% if locale == 'nl' %}Name: "dutch"; MessagesFile: "compiler:Languages\\Dutch.isl"{% endif %}

{% if locale == 'fi' %}Name: "finnish"; MessagesFile: "compiler:Languages\\Finnish.isl"{% endif %}

{% if locale == 'fr' %}Name: "french"; MessagesFile: "compiler:Languages\\French.isl"{% endif %}

{% if locale == 'de' %}Name: "german"; MessagesFile: "compiler:Languages\\German.isl"{% endif %}

{% if locale == 'he' %}Name: "hebrew"; MessagesFile: "compiler:Languages\\Hebrew.isl"{% endif %}

{% if locale == 'is' %}Name: "icelandic"; MessagesFile: "compiler:Languages\\Icelandic.isl"{% endif %}

{% if locale == 'it' %}Name: "italian"; MessagesFile: "compiler:Languages\\Italian.isl"{% endif %}

{% if locale == 'ja' %}Name: "japanese"; MessagesFile: "compiler:Languages\\Japanese.isl"{% endif %}

{% if locale == 'no' %}Name: "norwegian"; MessagesFile: "compiler:Languages\\Norwegian.isl"{% endif %}

{% if locale == 'pl' %}Name: "polish"; MessagesFile: "compiler:Languages\\Polish.isl"{% endif %}

{% if locale == 'pt' %}Name: "portuguese"; MessagesFile: "compiler:Languages\\Portuguese.isl"{% endif %}

{% if locale == 'ru' %}Name: "russian"; MessagesFile: "compiler:Languages\\Russian.isl"{% endif %}

{% if locale == 'sk' %}Name: "slovak"; MessagesFile: "compiler:Languages\\Slovak.isl"{% endif %}

{% if locale == 'sl' %}Name: "slovenian"; MessagesFile: "compiler:Languages\\Slovenian.isl"{% endif %}

{% if locale == 'es' %}Name: "spanish"; MessagesFile: "compiler:Languages\\Spanish.isl"{% endif %}

{% if locale == 'tr' %}Name: "turkish"; MessagesFile: "compiler:Languages\\Turkish.isl"{% endif %}

{% if locale == 'uk' %}Name: "ukrainian"; MessagesFile: "compiler:Languages\\Ukrainian.isl"{% endif %}

{% endfor %}

[Tasks]

Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: {% if CREATE_DESKTOP_ICON != true %}unchecked{% else %}checkedonce{% endif %}

Name: "launchAtStartup"; Description: "{cm:AutoStartProgram,{{DISPLAY_NAME}}}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: {% if LAUNCH_AT_STARTUP != true %}unchecked{% else %}checkedonce{% endif %}

[Files]

Source: "{{SOURCE_DIR}}\\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs

; NOTE: Don't use "Flags: ignoreversion" on any shared system files

[Icons]

Name: "{autoprograms}\\{{DISPLAY_NAME}}"; Filename: "{app}\\{{EXECUTABLE_NAME}}"

Name: "{autodesktop}\\{{DISPLAY_NAME}}"; Filename: "{app}\\{{EXECUTABLE_NAME}}"; Tasks: desktopicon

Name: "{userstartup}\\{{DISPLAY_NAME}}"; Filename: "{app}\\{{EXECUTABLE_NAME}}"; WorkingDir: "{app}"; Tasks: launchAtStartup

[Run]

Filename: "{app}\\{{EXECUTABLE_NAME}}"; Description: "{cm:LaunchProgram,{{DISPLAY_NAME}}}"; Flags: {% if PRIVILEGES_REQUIRED == 'admin' %}runascurrentuser{% endif %} nowait postinstall skipifsilent

[Code]

function InitializeSetup(): Boolean;

var

ResultCode: Integer;

begin

Exec('taskkill', '/F /IM 应用名称.exe', '', SW_HIDE, ewWaitUntilTerminated, ResultCode)

Result := True;

end;

windows/packaging/exe/make_config.yaml

app_id: 6L913538-42B1-4596-G479-BJ779F21A65D
publisher: 应用名称
publisher_url: https://github.com/aaa/aaa
display_name: 应用名称
executable_name: 应用名称.exe
output_base_file_name: 应用名称.exe
create_desktop_icon: true
install_dir_name: "{autopf64}\\应用名称"
setup_icon_file: ..\..\windows\runner\resources\app_icon.ico
locales:
  - ar
  - en
  - fa
  - ru
  - pt
  - tr
script_template: inno_setup.sas

app_id: 6L913538-42B1-4596-G479-BJ779F21A65D

publisher: 应用名称

publisher_url: https://github.com/aaa/aaa

display_name: 应用名称

executable_name: 应用名称.exe

output_base_file_name: 应用名称.exe

create_desktop_icon: true

install_dir_name: "{autopf64}\\应用名称"

setup_icon_file: ..\..\windows\runner\resources\app_icon.ico

locales:

- ar

- en

- fa

- ru

- pt

- tr

script_template: inno_setup.sas

如果打包 msix windows/packaging/msix/make_config.yaml

# 应用名称
display_name: 应用名称

# 应用名称
publisher_display_name: 应用名称

# 应用名称
identity_name: 应用名称.appioi

msix_version: 2.5.7.0

# 应用图标
logo_path: windows\runner\resources\app_icon.ico

# 应用能力
capabilities: internetClient, internetClientServer, privateNetworkClientServer

# 多语言
languages: en-us, zh-cn, zh-tw, tr-tr,fa-ir,ru-ru,pt-br,es-es

protocol_activation: 应用名称

execution_alias: 应用名称

# 签名证书
# certificate_path: windows\sign.pfx

# 签名证书密码
certificate_password:

# 发布者的唯一识别ID
publisher: CN=8CB43675-F44B-4AA5-9372-E8727781BDC4

install_certificate: "false"

# let OS know if the application can be run on start_up. If it's false
# the application will deny to the OS if it was added as a start_up
# application
enable_at_startup: "false"

# 应用启动参数
startup_task:
  parameters: --autostart

# 应用名称

display_name: 应用名称

# 应用名称

publisher_display_name: 应用名称

# 应用名称

identity_name: 应用名称.appioi

msix_version: 2.5.7.0

# 应用图标

logo_path: windows\runner\resources\app_icon.ico

# 应用能力

capabilities: internetClient, internetClientServer, privateNetworkClientServer

# 多语言

languages: en-us, zh-cn, zh-tw, tr-tr,fa-ir,ru-ru,pt-br,es-es

protocol_activation: 应用名称

execution_alias: 应用名称

# 签名证书

# certificate_path: windows\sign.pfx

# 签名证书密码

certificate_password:

# 发布者的唯一识别ID

publisher: CN=8CB43675-F44B-4AA5-9372-E8727781BDC4

install_certificate: "false"

# let OS know if the application can be run on start_up. If it's false

# the application will deny to the OS if it was added as a start_up

# application

enable_at_startup: "false"

# 应用启动参数

startup_task:

parameters: --autostart

Linux:

linux/packaging/appimage

有两个文件 linux/packaging/appimage/AppRun

#!/bin/bash

cd "$(dirname "$0")"
export LD_LIBRARY_PATH=usr/lib

# Usage info
show_help() {
cat << EOF
Usage: ${0##*/} ...
start app or app, when no parameter is given, app is executed.
    -v              show version
EOF
}
show_version() {
    printf "app version "
    jq .version <./data/flutter_assets/version.json
}
# Initialize variables:
service=0 #declare -i service
OPTIND=1

# Resetting OPTIND is necessary if getopts was used previously in the script.
# It is a good idea to make OPTIND local if you process options in a function.

# if no arg is provided, execute app
if [[ $# == 0 ]];then
    exec ./app
else

# processing arguments

    case $1 in
        appCli)
            exec ./appCli ${@:3}
            exit 0
            ;;
        h)
            show_help
            exit 0
            ;;
        v)  show_version
            exit 0
            ;;
        *)
            show_help >&2
            exit 1
            ;;
    esac
fi

#!/bin/bash

cd "$(dirname "$0")"

export LD_LIBRARY_PATH=usr/lib

# Usage info

show_help() {

cat << EOF

Usage: ${0##*/} ...

start app or app, when no parameter is given, app is executed.

-v show version

EOF

}

show_version() {

printf "app version "

jq .version <./data/flutter_assets/version.json

}

# Initialize variables:

service=0 #declare -i service

OPTIND=1

# Resetting OPTIND is necessary if getopts was used previously in the script.

# It is a good idea to make OPTIND local if you process options in a function.

# if no arg is provided, execute app

if [[ $# == 0 ]];then

exec ./app

else

# processing arguments

case $1 in

appCli)

exec ./appCli ${@:3}

exit 0

;;

show_help

exit 0

;;

v) show_version

exit 0

;;

show_help >&2

exit 1

;;

esac

linux/packaging/appimage/make_config.yaml

display_name: App名称

icon: ./assets/images/source/ic_launcher_border.png

keywords:
  - Hi

generic_name: App名称

actions:
  - name: Start
    label: start
    arguments:
      - --start
  - name: Stop
    label: stop
    arguments:
      - --stop

categories:
  - Network

startup_notify: true

app_run_file: AppRun

# You can specify the shared libraries that you want to bundle with your app
#
# flutter_distributor automatically detects the shared libraries that your app
# depends on, but you can also specify them manually here.
#
# The following example shows how to bundle the libcurl library with your app.
#
# include:
#   - libcurl.so.4
include: []

display_name: App名称

icon: ./assets/images/source/ic_launcher_border.png

keywords:

- Hi

generic_name: App名称

actions:

- name: Start

label: start

arguments:

- --start

- name: Stop

label: stop

arguments:

- --stop

categories:

- Network

startup_notify: true

app_run_file: AppRun

# You can specify the shared libraries that you want to bundle with your app

# flutter_distributor automatically detects the shared libraries that your app

# depends on, but you can also specify them manually here.

# The following example shows how to bundle the libcurl library with your app.

# include:

# - libcurl.so.4

include: []

linux/packaging/deb 文件 linux/packaging/deb/make_config.yaml

# the name used to display in the OS. Specifically desktop
# entry name
display_name: AppName

# package name for debian/apt repository
# the name should be all lowercase with -+.
package_name: AppName

# 所有者
maintainer:
  name: xxx
  email: xxx@xxx.com

# 联合作者
# co_authors:
#   - name: xxxx
#     email: xxxx@xxxx.com

# enum options -> required, important, standard, optional, extra
# refer: https://www.debian.org/doc/debian-policy/ch-archive.html#s-priorities
priority: optional

# enum options: admin, cli-mono, comm, database, debug, devel, doc, editors, education, electronics, embedded, fonts, games, gnome, gnu-r, gnustep, graphics, hamradio, haskell, httpd, interpreters, introspection, java, javascript, kde, kernel, libdevel, libs, lisp, localization, mail, math, metapackages, misc, net, news, ocaml, oldlibs, otherosfs, perl, php, python, ruby, rust, science, shells, sound, tasks, tex, text, utils, vcs, video, web, x11, xfce, zope
# refer: https://www.debian.org/doc/debian-policy/ch-archive.html#s-subsections
section: x11

# the size of binary in kilobyte
installed_size: 6604

# direct dependencies required by the application
# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html
dependencies:
  - libqt5widgets5 (>= 5.15)
  - libwebkit2gtk (>= 4.0), libsoup (>= 2.4), gettext (>= 0.21)

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html
# build_dependencies_indep:
#   - texinfo

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html
# build_dependencies:
#   - kernel-headers-2.2.10 [!hurd-i386]
#   - gnumach-dev [hurd-i386]
#   - libluajit5.1-dev [i386 amd64 kfreebsd-i386 armel armhf powerpc mips]

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html
# recommended_dependencies:
#   - neofetch

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html
# suggested_dependencies:
#   - libkeybinder-3.0-0 (>= 0.3.2)


# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html
# enhances:
#   - spotube

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html
# pre_dependencies:
#   - libc6

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html#packages-which-break-other-packages-breaks
# breaks:
#   - libspotify (<< 3.0.0)

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html#conflicting-binary-packages-conflicts
# conflicts:
#  - spotify

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html#virtual-packages-provides
# provides:
#   - libx11

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html#overwriting-files-and-replacing-packages-replaces
# replaces:
#   - spotify

essential: false

postinstall_scripts:
  - echo "Installed AppName"

postuninstall_scripts:
  - echo "Surprised Why?"

# application icon path relative to project url
# icon: assets/logo.png

keywords:
  - AppName

# a name to categorize the app into a section of application
generic_name: EisApp

# supported mime types that can be opened using this application
# supported_mime_type:
#  - audio/mpeg

# shown when right clicked the desktop entry icons
# actions:
#  - Gallery
#  - Create

# the categories the application belong to
# refer: https://specifications.freedesktop.org/menu-spec/latest/
categories:
  - Network

# let OS know if the application can be run on start_up. If it's false
# the application will deny to the OS if it was added as a start_up
# application
startup_notify: false

100

101

102

103

104

105

106

107

108

109

110

111

112

113

# the name used to display in the OS. Specifically desktop

# entry name

display_name: AppName

# package name for debian/apt repository

# the name should be all lowercase with -+.

package_name: AppName

# 所有者

maintainer:

name: xxx

email: xxx@xxx.com

# 联合作者

# co_authors:

# - name: xxxx

# email: xxxx@xxxx.com

# enum options -> required, important, standard, optional, extra

# refer: https://www.debian.org/doc/debian-policy/ch-archive.html#s-priorities

priority: optional

# enum options: admin, cli-mono, comm, database, debug, devel, doc, editors, education, electronics, embedded, fonts, games, gnome, gnu-r, gnustep, graphics, hamradio, haskell, httpd, interpreters, introspection, java, javascript, kde, kernel, libdevel, libs, lisp, localization, mail, math, metapackages, misc, net, news, ocaml, oldlibs, otherosfs, perl, php, python, ruby, rust, science, shells, sound, tasks, tex, text, utils, vcs, video, web, x11, xfce, zope

# refer: https://www.debian.org/doc/debian-policy/ch-archive.html#s-subsections

section: x11

# the size of binary in kilobyte

installed_size: 6604

# direct dependencies required by the application

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html

dependencies:

- libqt5widgets5 (>= 5.15)

- libwebkit2gtk (>= 4.0), libsoup (>= 2.4), gettext (>= 0.21)

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html

# build_dependencies_indep:

# - texinfo

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html

# build_dependencies:

# - kernel-headers-2.2.10 [!hurd-i386]

# - gnumach-dev [hurd-i386]

# - libluajit5.1-dev [i386 amd64 kfreebsd-i386 armel armhf powerpc mips]

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html

# recommended_dependencies:

# - neofetch

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html

# suggested_dependencies:

# - libkeybinder-3.0-0 (>= 0.3.2)

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html

# enhances:

# - spotube

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html

# pre_dependencies:

# - libc6

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html#packages-which-break-other-packages-breaks

# breaks:

# - libspotify (<< 3.0.0)

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html#conflicting-binary-packages-conflicts

# conflicts:

# - spotify

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html#virtual-packages-provides

# provides:

# - libx11

# refer: https://www.debian.org/doc/debian-policy/ch-relationships.html#overwriting-files-and-replacing-packages-replaces

# replaces:

# - spotify

essential: false

postinstall_scripts:

- echo "Installed AppName"

postuninstall_scripts:

- echo "Surprised Why?"

# application icon path relative to project url

# icon: assets/logo.png

keywords:

- AppName

# a name to categorize the app into a section of application

generic_name: EisApp

# supported mime types that can be opened using this application

# supported_mime_type:

# - audio/mpeg

# shown when right clicked the desktop entry icons

# actions:

# - Gallery

# - Create

# the categories the application belong to

# refer: https://specifications.freedesktop.org/menu-spec/latest/

categories:

- Network

# let OS know if the application can be run on start_up. If it's false

# the application will deny to the OS if it was added as a start_up

# application

startup_notify: false

linux/packaging/rpm 文件 linux/packaging/rpm/make_config.yaml

display_name: App
url: https://github.com/app/app-next/
license: Other

packager: App
packagerEmail: linux@App.com

priority: optional
section: x11
installed_size: 6604
essential: false
icon: ./assets/images/source/ic_launcher_border.png

keywords:
  - Hi

generic_name: App

group: Applications/Internet

startup_notify: true

display_name: App

url: https://github.com/app/app-next/

license: Other

packager: App

packagerEmail: linux@App.com

priority: optional

section: x11

installed_size: 6604

essential: false

icon: ./assets/images/source/ic_launcher_border.png

keywords:

- Hi

generic_name: App

group: Applications/Internet

startup_notify: true

命令示例

打包 macOS (DMG 和 PKG)

$ export PATH="$PATH":"$HOME/.pub-cache/bin" $ fastforge package --flutter-build-args=verbose --platform macos --targets dmg,pkg

1
2
3

$ export PATH="$PATH":"$HOME/.pub-cache/bin"

$ fastforge package --flutter-build-args=verbose --platform macos --targets dmg,pkg

打包 Windows (EXE 和 MSIX)

$Env:PATH += ";$HOME/AppData/Local/Pub/Cache/bin"

dart pub global activate fastforge

fastforge package --flutter-build-args=verbose --platform windows --targets exe,msix

$Env:PATH += ";$HOME/AppData/Local/Pub/Cache/bin"

dart pub global activate fastforge

fastforge package --flutter-build-args=verbose --platform windows --targets exe,msix

打包 Linux (DEB、RPM 和 AppImage)

$ export PATH="$PATH":"$HOME/.pub-cache/bin" $ fastforge package --flutter-build-args=verbose --platform linux --targets deb,rpm,appimage

1
2
3

$ export PATH="$PATH":"$HOME/.pub-cache/bin"

$ fastforge package --flutter-build-args=verbose --platform linux --targets deb,rpm,appimage

参考链接

Flutter 3.29.1-使用U盾完成数据的加解密（国密算法SKF接口）

参考 Python3-使用U盾完成数据的加解密（国密算法SKF接口），那么相同的功能如何使用 Flutter FFI 实现呢？

Flutter 3.29.1

ffi 2.1.4

pointycastle 3.6.0

pkcs7 1.0.5

convert 3.1.2

代码参考如下：

import 'dart:ffi';
import 'dart:io';

import 'package:ffi/ffi.dart';
import 'package:flutter/cupertino.dart';

/// 无效句柄
///
// ignore: constant_identifier_names
const SKF_INVALID_HANDLE = 0;

/// SM3 算法定义
///
/// \# define SGD_SM3 0x00000001
// ignore: constant_identifier_names
const SGD_SM3 = 0x00000001;

/// 异常错误
///
/// \# define SAR_UNKNOWNERR 0x0A000002
// ignore: constant_identifier_names
const SAR_UNKNOWNERR = 0x0A000002;

/// 对象未导出
///
/// \# define SAR_NOTEXPORTERR 0x0A00001D
// ignore: constant_identifier_names
const SAR_NOTEXPORTERR = 0x0A00001D;

/// ECC 签名结构体
///
/// 信息安全技术 智能密码钥匙应用接口规范 GB/T 35291-2017
///
/// #define ECC_MAX_XCOORDINATE_BITS_LEN 512
///
/// typedef struct Struct_ECCSIGNATUREBLOB {
///
///    BYTE r[ECC_MAX_XCOORDINATE_BITS_LEN/8];
///
///    BYTE s[ECC_MAX_XCOORDINATE_BITS_LEN/8];
///
/// } ECCSIGNATUREBLOB, *PECCSIGNATUREBLOB
// ignore: constant_identifier_names
const ECC_MAX_XCOORDINATE_BITS_LEN = 512;

@Packed(8)
// ignore: camel_case_types
final class Struct_ECCSIGNATUREBLOB extends Struct {
  @Array(ECC_MAX_XCOORDINATE_BITS_LEN ~/ 8)
  external Array<Uint8> r;

  @Array(ECC_MAX_XCOORDINATE_BITS_LEN ~/ 8)
  external Array<Uint8> s;
}

// ignore: constant_identifier_names
const TRUE = 0x00000001;

// ignore: constant_identifier_names
const FALSE = 0x00000000;

/// ECC 公钥结构体
///
/// 信息安全技术 智能密码钥匙应用接口规范 GB/T 35291-2017
@Packed(8)
// ignore: camel_case_types
final class Struct_ECCPUBLICKEYBLOB extends Struct {
  /*
   * 官方文档是C语言的 ULONG，不管操作系统是32位还是64位，都要求是 4个字节。
  **/
  @Uint32()
  external int bitLen;
  @Array(64)
  external Array<Uint8> xCoordinate;
  @Array(64)
  external Array<Uint8> yCoordinate;

  int lengthInBytes() {
    return sizeOf<Struct_ECCPUBLICKEYBLOB>();
  }
}

/// 密文数据结构，经典的Flutter变长结构体处理
///
/// 信息安全技术 智能密码钥匙应用接口规范 GB/T 35291-2017
@Packed(8)
// ignore: camel_case_types
final class Struct_ECCCIPHERBLOB extends Struct {
  /*
   * 官方文档是C语言的 ULONG，不管操作系统是32位还是64位，都要求是 4个字节。
  **/
  @Array(64)
  external Array<Uint8> xCoordinate;
  @Array(64)
  external Array<Uint8> yCoordinate;
  @Array(32)
  external Array<Uint8> hash;
  @Uint32()
  external int cipherLen;

  @Array.variable()
  external Array<Uint8> cipher;

  static Pointer<Struct_ECCCIPHERBLOB> allocate(final int length) {
    final lengthInBytes = lengthBytes(length);
    final result = calloc.allocate<Struct_ECCCIPHERBLOB>(lengthInBytes);
    result.ref.cipherLen = length;
    return result;
  }

  static int lengthBytes(final int length) {
    return sizeOf<Struct_ECCCIPHERBLOB>() + sizeOf<Uint8>() * length;
  }

  int lengthInBytes() {
    return lengthBytes(cipherLen);
  }
}

/// 注意，虽然SKF标准中规定 HANDLE 类型为 ULONG (32位无符号整数） 但是实际上目前发现，在64位系统上，SDK底层返回的是 64 位的无符号整数
/// 其实就是内存的指针地址，没有经过二次映射
/// 因此下面函数的 HANDLE 类型都被定义成了 Uint64 (64位无符号整数) 而不是 Uint32 (32位无符号整数）
class SkfLib {
  /// 动态库加载
  late final DynamicLibrary? _skfLib;

  late final int Function(
    int bPresent,
    Pointer<Uint8> szNameList,
    Pointer<Uint32> pulSize,
  )?
  _skfEnumDev;

  late final int Function(Pointer<Utf8> szName, Pointer<Uint64> phDev)?
  _skfConnectDev;

  late final int Function(int hDev)? _skfDisConnectDev;

  late final int Function(
    int hDev,
    Pointer<Utf8> szAppName,
    Pointer<Uint64> phApplication,
  )?
  _skfOpenApplication;

  late final int Function(
    int hDev,
    Pointer<Uint8> szAppName,
    Pointer<Uint32> pulSize,
  )?
  _skfEnumApplication;

  late final int Function(int hApplication)? _skfCloseApplication;

  late final int Function(
    int hApplication,
    Pointer<Uint8> szContainerName,
    Pointer<Uint32> pulSize,
  )?
  _skfEnumContainer;

  late final int Function(
    int hApplication,
    Pointer<Utf8> szContainerName,
    Pointer<Uint64> phContainer,
  )?
  _skfOpenContainer;

  late final int Function(int hContainer)? _skfCloseContainer;

  late final int Function(
    int hContainer,
    int bSignFlag,
    Pointer<Struct_ECCPUBLICKEYBLOB> pbBlob,
    Pointer<Uint32> pulBlobLen,
  )?
  _skfExportPublicKey;

  late final int Function(
    int hContainer,
    int bSignFlag,
    Pointer<Uint8> pbCert,
    Pointer<Uint32> pulCertLen,
  )?
  _skfExportCertificate;

  late final int Function(
    int hDev,
    Pointer<Struct_ECCPUBLICKEYBLOB> pECCPubKeyBlob,
    Pointer<Utf8> pbPlainText,
    int ulPlainTextLen,
    Pointer<Struct_ECCCIPHERBLOB> pCipherText,
  )?
  _skfExtECCEncrypt;

  late final int Function(
    int hContainer,
    int bSignFlag,
    Pointer<Struct_ECCCIPHERBLOB> pCipherText,
    Pointer<Uint8> pbData,
    Pointer<Uint32> pbDataLen,
  )?
  _skfECCDecrypt;

  late final int Function(
    int hContainer,
    int ulAlgID,
    Pointer<Utf8> pbPlainText,
    int ulPlainTextLen,
    Pointer<Struct_ECCSIGNATUREBLOB> pSignature,
  )?
  _skfECCDigestSignData;

  late final int Function(
    int hContainer,
    int ulAlgID,
    Pointer<Utf8> pbPlainText,
    int ulPlainTextLen,
    Pointer<Struct_ECCSIGNATUREBLOB> pSignature,
  )?
  _skfECCSignDataEx;

  late final int Function(
    int hApplication,
    int ulPINType,
    Pointer<Utf8> szPIN,
    Pointer<Uint32> pulRetryCount,
  )?
  _skfVerifyPIN;

  SkfLib(final String dllPath) {
    try {
      _skfLib = Platform.isMacOS || Platform.isIOS
          ? DynamicLibrary.process()
          : DynamicLibrary.open(dllPath); // 加载dll,获取句柄
    } catch (e) {
      _skfLib = null;
      debugPrint('SkfLib Load Failed: $e');
    }
    // 获取函数指针
    const fnEnumDev = "SKF_EnumDev";
    if (_providesSymbol(fnEnumDev)) {
      _skfEnumDev = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(Uint32, Pointer<Uint8>, Pointer<Uint32>)
            >
          >(fnEnumDev)
          .asFunction();
    } else {
      _skfEnumDev = null;
    }

    const fnConnectDev = "SKF_ConnectDev";
    if (_providesSymbol(fnConnectDev)) {
      _skfConnectDev = _skfLib!
          .lookup<
            NativeFunction<Uint32 Function(Pointer<Utf8>, Pointer<Uint64>)>
          >(fnConnectDev)
          .asFunction();
    } else {
      _skfConnectDev = null;
    }

    const fnDisConnectDev = "SKF_DisConnectDev";
    if (_providesSymbol(fnDisConnectDev)) {
      _skfDisConnectDev = _skfLib!
          .lookup<NativeFunction<Uint32 Function(Uint64)>>(fnDisConnectDev)
          .asFunction();
    } else {
      _skfDisConnectDev = null;
    }

    const fnEnumApplication = "SKF_EnumApplication";
    if (_providesSymbol(fnEnumApplication)) {
      _skfEnumApplication = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(Uint64, Pointer<Uint8>, Pointer<Uint32>)
            >
          >(fnEnumApplication)
          .asFunction();
    } else {
      _skfEnumApplication = null;
    }

    const fnOpenApplication = "SKF_OpenApplication";
    if (_providesSymbol(fnOpenApplication)) {
      _skfOpenApplication = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(Uint64, Pointer<Utf8>, Pointer<Uint64>)
            >
          >(fnOpenApplication)
          .asFunction();
    } else {
      _skfOpenApplication = null;
    }

    const fnCloseApplication = "SKF_CloseApplication";
    if (_providesSymbol(fnCloseApplication)) {
      _skfCloseApplication = _skfLib!
          .lookup<NativeFunction<Uint32 Function(Uint64)>>(fnCloseApplication)
          .asFunction();
    } else {
      _skfCloseApplication = null;
    }

    const fnEnumContainer = "SKF_EnumContainer";
    if (_providesSymbol(fnEnumContainer)) {
      _skfEnumContainer = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(Uint64, Pointer<Uint8>, Pointer<Uint32>)
            >
          >(fnEnumContainer)
          .asFunction();
    } else {
      _skfEnumContainer = null;
    }

    const fnOpenContainer = "SKF_OpenContainer";
    if (_providesSymbol(fnOpenContainer)) {
      _skfOpenContainer = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(Uint64, Pointer<Utf8>, Pointer<Uint64>)
            >
          >(fnOpenContainer)
          .asFunction();
    } else {
      _skfOpenContainer = null;
    }

    const fnCloseContainer = "SKF_CloseContainer";
    if (_providesSymbol(fnCloseContainer)) {
      _skfCloseContainer = _skfLib!
          .lookup<NativeFunction<Uint32 Function(Uint64)>>(fnCloseContainer)
          .asFunction();
    } else {
      _skfCloseContainer = null;
    }

    const fnExportPublicKey = "SKF_ExportPublicKey";
    if (_providesSymbol(fnExportPublicKey)) {
      _skfExportPublicKey = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(
                Uint64,
                Uint32,
                Pointer<Struct_ECCPUBLICKEYBLOB>,
                Pointer<Uint32>,
              )
            >
          >(fnExportPublicKey)
          .asFunction();
    } else {
      _skfExportPublicKey = null;
    }

    const fnExportCertificate = "SKF_ExportCertificate";
    if (_providesSymbol(fnExportCertificate)) {
      _skfExportCertificate = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(Uint64, Uint32, Pointer<Uint8>, Pointer<Uint32>)
            >
          >(fnExportCertificate)
          .asFunction();
    } else {
      _skfExportCertificate = null;
    }

    const fnExtECCEncrypt = "SKF_ExtECCEncrypt";
    if (_providesSymbol(fnExtECCEncrypt)) {
      _skfExtECCEncrypt = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(
                Uint64,
                Pointer<Struct_ECCPUBLICKEYBLOB>,
                Pointer<Utf8>,
                Uint32,
                Pointer<Struct_ECCCIPHERBLOB>,
              )
            >
          >(fnExtECCEncrypt)
          .asFunction();
    } else {
      _skfExtECCEncrypt = null;
    }

    const fnECCDecrypt = "SKF_ECCDecrypt";
    if (_providesSymbol(fnECCDecrypt)) {
      _skfECCDecrypt = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(
                Uint64,
                Uint32,
                Pointer<Struct_ECCCIPHERBLOB>,
                Pointer<Uint8>,
                Pointer<Uint32>,
              )
            >
          >(fnECCDecrypt)
          .asFunction();
    } else {
      _skfECCDecrypt = null;
    }

    const fnECCDigestSignData = "SKF_ECCDigestSignData";
    if (_providesSymbol(fnECCDigestSignData)) {
      _skfECCDigestSignData = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(
                Uint64,
                Uint32,
                Pointer<Utf8>,
                Uint32,
                Pointer<Struct_ECCSIGNATUREBLOB>,
              )
            >
          >(fnECCDigestSignData)
          .asFunction();
    } else {
      _skfECCDigestSignData = null;
    }

    const fnECCSignDataEx = "SKF_ECCSignDataEx";
    if (_providesSymbol(fnECCSignDataEx)) {
      _skfECCSignDataEx = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(
                Uint64,
                Uint32,
                Pointer<Utf8>,
                Uint32,
                Pointer<Struct_ECCSIGNATUREBLOB>,
              )
            >
          >(fnECCSignDataEx)
          .asFunction();
    } else {
      _skfECCSignDataEx = null;
    }

    const fnVerifyPIN = "SKF_VerifyPIN";
    if (_providesSymbol(fnVerifyPIN)) {
      _skfVerifyPIN = _skfLib!
          .lookup<
            NativeFunction<
              Uint32 Function(Uint64, Uint32, Pointer<Utf8>, Pointer<Uint32>)
            >
          >(fnVerifyPIN)
          .asFunction();
    } else {
      _skfVerifyPIN = null;
    }
  }

  /// Checks whether this dynamic library provides a symbol with the given name.
  bool _providesSymbol(final String symbolName) {
    return _skfLib?.providesSymbol(symbolName) ?? false;
  }

  @mustCallSuper
  void close() {
    _skfLib?.close();
  }

  /// 功能描述：
  ///
  /// 获得当前系统中的设备列表。
  ///
  /// 参数：
  ///
  /// [bPresent] [IN] 为 TRUE 表示获取当前设备状态为存在的设备列表。
  /// 为 FALSE 表示取当前取得支持的设备列表。
  ///
  /// [szNameList] [OUT] 设备名称列表。如果该参数为 NULL ，将由 pulSize 返回所需要的内存空间大小。
  /// 每个设备的名称以单个 '\0' 结束，以双 '\0' 表示列表结束。
  ///
  /// [pulSize] [IN, OUT] 输入时表示设备名称列表的缓冲区长度，输出时表示 szNameList 所占用的空间大小。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_EnumDev(
    final int bPresent,
    final Pointer<Uint8> szNameList,
    final Pointer<Uint32> pulSize,
  ) {
    if (null != _skfEnumDev) {
      return _skfEnumDev(bPresent, szNameList, pulSize);
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 通过设备名称连接设备，返回设备的句柄。
  ///
  /// 参数：
  ///
  /// [szName] [IN] 设备名称。
  ///
  /// [phDev] [OUT] 返回设备操作句柄。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_ConnectDev(final Pointer<Utf8> szName, final Pointer<Uint64> phDev) {
    if (null != _skfConnectDev) {
      return _skfConnectDev(szName, phDev);
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 断开一个已经连接的设备，并释放句柄。
  ///
  /// 参数：
  ///
  /// [hDev] [IN] 连接设备时返回的设备句柄。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_DisConnectDev(final int hDev) {
    if (null != _skfDisConnectDev) {
      return _skfDisConnectDev(hDev);
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 枚举设备中存在的所有应用。
  ///
  /// 参数：
  ///
  /// [hDev] [IN] 连接设备时返回的设备句柄。
  ///
  /// [szAppName] [OUT] 返回应用名称列表，如果该参数为空，将由 pulSize 返回所需要的内存空间大小。
  /// 每个应用的名称以单个 '\0' 结束，以双 '\0' 表示列表结束。
  ///
  /// [pulSize] [IN, OUT] 输入时表示应用名称列表的缓冲区长度，输出时表示 szAppName 所占用的空间大小。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_EnumApplication(
    final int hDev,
    final Pointer<Uint8> szAppName,
    final Pointer<Uint32> pulSize,
  ) {
    if (null != _skfEnumApplication) {
      return _skfEnumApplication(hDev, szAppName, pulSize);
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 打开指定的应用。
  ///
  /// 参数：
  ///
  /// [hDev] [IN] 连接设备时返回的设备句柄。
  ///
  /// [szAppName] [IN] 应用名称。
  ///
  /// [phApplication] [OUT] 应用的句柄。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_OpenApplication(
    final int hDev,
    final Pointer<Utf8> szAppName,
    final Pointer<Uint64> phApplication,
  ) {
    if (null != _skfOpenApplication) {
      return _skfOpenApplication(hDev, szAppName, phApplication);
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 关闭应用并释放应用句柄。
  ///
  /// 参数：
  ///
  /// [hApplication] [IN] 应用句柄。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_CloseApplication(final int hApplication) {
    if (null != _skfCloseApplication) {
      return _skfCloseApplication(hApplication);
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 枚举容器下所有容器并返回容器名称列表。
  ///
  /// 参数：
  ///
  /// [hApplication] [IN] 应用句柄。
  ///
  /// [szContainerName] [OUT] 指向容器名称列表缓冲区，如果该参数为 NULL 时，pulSize 表示返回数据所需缓冲区的长度，
  /// 如果此参数不为 NULL 时，返回容器名称列表，每个容器名以 '\0' 结束，列表以双 '\0' 结束。
  ///
  /// [pulSize] [IN, OUT] 输入时表示 szContainerName 缓冲区长度，输出时表示容器名称列表的长度。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_EnumContainer(
    final int hApplication,
    final Pointer<Uint8> szContainerName,
    final Pointer<Uint32> pulSize,
  ) {
    if (null != _skfEnumContainer) {
      return _skfEnumContainer(hApplication, szContainerName, pulSize);
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 获取容器句柄。
  ///
  /// 参数：
  ///
  /// [hApplication] [IN] 应用句柄。
  ///
  /// [szContainerName] [IN] 容器的名称。
  ///
  /// [phContainer] [OUT] 返回所打开容器的句柄。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_OpenContainer(
    final int hApplication,
    final Pointer<Utf8> szContainerName,
    final Pointer<Uint64> phContainer,
  ) {
    if (null != _skfOpenContainer) {
      return _skfOpenContainer(hApplication, szContainerName, phContainer);
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 关闭容器句柄，并释放容器句柄相关资源。
  ///
  /// 参数：
  ///
  /// [hContainer] [IN] 容器句柄。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_CloseContainer(final int hContainer) {
    if (null != _skfCloseContainer) {
      return _skfCloseContainer(hContainer);
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 从导出公钥。
  ///
  /// 参数：
  ///
  /// [hContainer] [IN] 容器句柄。
  ///
  /// [bSignFlag] [IN] TRUE 表示签名证书，FALSE 表示加密证书。
  ///
  /// [pbBlob] [OUT] 指向公钥内容缓冲区，如果此参数为 NULL 时，pulBlobLen 返回数据所需要
  /// 缓冲区长度，如果此参数不为 NULL 时，返回公钥内容。
  ///
  /// [pulBlobLen] [IN/OUT] 输入时表示 pbBlob 缓冲区的长度，输出时表示证书内容的长度。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_ExportPublicKey(
    final int hContainer,
    final int bSignFlag,
    final Pointer<Struct_ECCPUBLICKEYBLOB> pbBlob,
    final Pointer<Uint32> pulBlobLen,
  ) {
    if (null != _skfExportPublicKey) {
      return _skfExportPublicKey(hContainer, bSignFlag, pbBlob, pulBlobLen);
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 从容器内导出数字证书。
  ///
  /// 参数：
  ///
  /// [hContainer] [IN] 容器句柄。
  ///
  /// [bSignFlag] [IN] TRUE 表示签名证书，FALSE 表示加密证书。
  ///
  /// [pbCert] [OUT] 指向证书内容缓冲区，如果此参数为 NULL 时，pulCertLen 返回数据所需要
  /// 缓冲区长度，如果此参数不为 NULL 时，返回数字证书内容。
  ///
  /// [pulCertLen] [IN/OUT] 输入时表示 pbCert 缓冲区的长度，输出时表示证书内容的长度。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_ExportCertificate(
    final int hContainer,
    final int bSignFlag,
    final Pointer<Uint8> pbCert,
    final Pointer<Uint32> pulCertLen,
  ) {
    if (null != _skfExportCertificate) {
      return _skfExportCertificate(hContainer, bSignFlag, pbCert, pulCertLen);
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 使用外部传入的 ECC 公钥对输入数据做加密运算并输出结果。
  ///
  /// 参数：
  ///
  /// [hDev] [IN] 设备句柄。
  ///
  /// [pECCPubKeyBlob] [IN] ECC公钥数据结构。
  ///
  /// [pbPlainText] [IN] 待加密的明文数据。
  ///
  /// [ulPlainTextLen] [IN] 待加密的明文数据长度。
  ///
  /// [pCipherText] [OUT] 密文数据。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_ExtECCEncrypt(
    final int hDev,
    final Pointer<Struct_ECCPUBLICKEYBLOB> pECCPubKeyBlob,
    final Pointer<Utf8> pbPlainText,
    final int ulPlainTextLen,
    final Pointer<Struct_ECCCIPHERBLOB> pCipherText,
  ) {
    if (null != _skfExtECCEncrypt) {
      return _skfExtECCEncrypt(
        hDev,
        pECCPubKeyBlob,
        pbPlainText,
        ulPlainTextLen,
        pCipherText,
      );
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 私钥解密。
  ///
  /// 参数：
  ///
  /// [hContainer] [IN] 密钥容器句柄。
  ///
  /// [bSignFlag] [IN] TRUE 表示签名证书，FALSE 表示加密证书。
  ///
  /// [pCipherText] [IN] 加密数据的结构。
  ///
  /// [pbData] [OUT] 解密后的明文数据。
  ///
  /// [pbDataLen] [OUT] 明文数据长度。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_ECCDecrypt(
    final int hContainer,
    final int bSignFlag,
    final Pointer<Struct_ECCCIPHERBLOB> pCipherText,
    final Pointer<Uint8> pbData,
    final Pointer<Uint32> pbDataLen,
  ) {
    if (null != _skfECCDecrypt) {
      return _skfECCDecrypt(
        hContainer,
        bSignFlag,
        pCipherText,
        pbData,
        pbDataLen,
      );
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 厂商实现的 ECC 数据签名扩展。
  ///
  /// 参数：
  ///
  /// [hContainer] [IN] 密钥容器句柄。
  ///
  /// [ulAlgID] [IN] 杂凑算法标识，这里选择SGD_SM3（0x00000001），表明使用SM3算法。
  ///
  /// [pbPlainText] [IN] 待签名的明文数据。
  ///
  /// [ulPlainTextLen] [IN] 待签名的明文数据长度。
  ///
  /// [pSignature] [OUT] 签名结果。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_ECCSignDataEx(
    final int hContainer,
    final int ulAlgID,
    final Pointer<Utf8> pbPlainText,
    final int ulPlainTextLen,
    final Pointer<Struct_ECCSIGNATUREBLOB> pSignature,
  ) {
    // WQ 扩展接口 SKF_ECCSignDataEx

    // FT/HB 扩展接口 SKF_ECCDigestSignData
    if (null != _skfECCDigestSignData) {
      return _skfECCDigestSignData(
        hContainer,
        ulAlgID,
        pbPlainText,
        ulPlainTextLen,
        pSignature,
      );
    } else if (null != _skfECCSignDataEx) {
      return _skfECCSignDataEx(
        hContainer,
        ulAlgID,
        pbPlainText,
        ulPlainTextLen,
        pSignature,
      );
    }
    return SAR_NOTEXPORTERR;
  }

  /// 功能描述：
  ///
  /// 校验 PIN 码。校验成功后，会获得相应的权限，如果 PIN 码错误，会返回 PIN 码的重试次数，
  /// 当重试次数为 0 时表示 PIN 码已经锁死。
  ///
  /// 参数：
  ///
  /// [hApplication] [IN] 应用句柄。
  ///
  /// [ulPINType] [IN] PIN 类型。 0 是管理员账户，1 为普通用户，这个参数一般选择 1。
  ///
  /// [szPIN] [IN] PIN 值。
  ///
  /// [pulRetryCount] [OUT] 出错后返回的重试次数。
  ///
  /// 返回值：
  ///
  /// SAR_OK : 成功。
  ///
  /// 其他： 错误码。
  // ignore: non_constant_identifier_names
  int SKF_VerifyPIN(
    final int hApplication,
    final int ulPINType,
    final Pointer<Utf8> szPIN,
    final Pointer<Uint32> pulRetryCount,
  ) {
    if (null != _skfVerifyPIN) {
      return _skfVerifyPIN(hApplication, ulPINType, szPIN, pulRetryCount);
    }
    return SAR_NOTEXPORTERR;
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

import 'dart:ffi';

import 'dart:io';

import 'package:ffi/ffi.dart';

import 'package:flutter/cupertino.dart';

/// 无效句柄

///

// ignore: constant_identifier_names

const SKF_INVALID_HANDLE = 0;

/// SM3 算法定义

///

/// \# define SGD_SM3 0x00000001

// ignore: constant_identifier_names

const SGD_SM3 = 0x00000001;

/// 异常错误

///

/// \# define SAR_UNKNOWNERR 0x0A000002

// ignore: constant_identifier_names

const SAR_UNKNOWNERR = 0x0A000002;

/// 对象未导出

///

/// \# define SAR_NOTEXPORTERR 0x0A00001D

// ignore: constant_identifier_names

const SAR_NOTEXPORTERR = 0x0A00001D;

/// ECC 签名结构体

///

/// 信息安全技术智能密码钥匙应用接口规范 GB/T 35291-2017

///

/// #define ECC_MAX_XCOORDINATE_BITS_LEN 512

///

/// typedef struct Struct_ECCSIGNATUREBLOB {

///

/// BYTE r[ECC_MAX_XCOORDINATE_BITS_LEN/8];

///

/// BYTE s[ECC_MAX_XCOORDINATE_BITS_LEN/8];

///

/// } ECCSIGNATUREBLOB, *PECCSIGNATUREBLOB

// ignore: constant_identifier_names

const ECC_MAX_XCOORDINATE_BITS_LEN = 512;

@Packed(8)

// ignore: camel_case_types

final class Struct_ECCSIGNATUREBLOB extends Struct {

@Array(ECC_MAX_XCOORDINATE_BITS_LEN ~/ 8)

external Array<Uint8> r;

@Array(ECC_MAX_XCOORDINATE_BITS_LEN ~/ 8)

external Array<Uint8> s;

}

// ignore: constant_identifier_names

const TRUE = 0x00000001;

// ignore: constant_identifier_names

const FALSE = 0x00000000;

/// ECC 公钥结构体

///

/// 信息安全技术智能密码钥匙应用接口规范 GB/T 35291-2017

@Packed(8)

// ignore: camel_case_types

final class Struct_ECCPUBLICKEYBLOB extends Struct {

* 官方文档是C语言的 ULONG，不管操作系统是32位还是64位，都要求是 4个字节。

**/

@Uint32()

external int bitLen;

@Array(64)

external Array<Uint8> xCoordinate;

@Array(64)

external Array<Uint8> yCoordinate;

int lengthInBytes() {

return sizeOf<Struct_ECCPUBLICKEYBLOB>();

}

/// 密文数据结构，经典的Flutter变长结构体处理

///

/// 信息安全技术智能密码钥匙应用接口规范 GB/T 35291-2017

@Packed(8)

// ignore: camel_case_types

final class Struct_ECCCIPHERBLOB extends Struct {

* 官方文档是C语言的 ULONG，不管操作系统是32位还是64位，都要求是 4个字节。

**/

@Array(64)

external Array<Uint8> xCoordinate;

@Array(64)

external Array<Uint8> yCoordinate;

@Array(32)

external Array<Uint8> hash;

@Uint32()

external int cipherLen;

@Array.variable()

external Array<Uint8> cipher;

static Pointer<Struct_ECCCIPHERBLOB> allocate(final int length) {

final lengthInBytes = lengthBytes(length);

final result = calloc.allocate<Struct_ECCCIPHERBLOB>(lengthInBytes);

result.ref.cipherLen = length;

return result;

}

static int lengthBytes(final int length) {

return sizeOf<Struct_ECCCIPHERBLOB>() + sizeOf<Uint8>() * length;

}

int lengthInBytes() {

return lengthBytes(cipherLen);

}

/// 注意，虽然SKF标准中规定 HANDLE 类型为 ULONG (32位无符号整数）但是实际上目前发现，在64位系统上，SDK底层返回的是 64 位的无符号整数

/// 其实就是内存的指针地址，没有经过二次映射

/// 因此下面函数的 HANDLE 类型都被定义成了 Uint64 (64位无符号整数) 而不是 Uint32 (32位无符号整数）

class SkfLib {

/// 动态库加载

late final DynamicLibrary? _skfLib;

late final int Function(

int bPresent,

Pointer<Uint8> szNameList,

Pointer<Uint32> pulSize,

_skfEnumDev;

late final int Function(Pointer<Utf8> szName, Pointer<Uint64> phDev)?

_skfConnectDev;

late final int Function(int hDev)? _skfDisConnectDev;

late final int Function(

int hDev,

Pointer<Utf8> szAppName,

Pointer<Uint64> phApplication,

_skfOpenApplication;

late final int Function(

int hDev,

Pointer<Uint8> szAppName,

Pointer<Uint32> pulSize,

_skfEnumApplication;

late final int Function(int hApplication)? _skfCloseApplication;

late final int Function(

int hApplication,

Pointer<Uint8> szContainerName,

Pointer<Uint32> pulSize,

_skfEnumContainer;

late final int Function(

int hApplication,

Pointer<Utf8> szContainerName,

Pointer<Uint64> phContainer,

_skfOpenContainer;

late final int Function(int hContainer)? _skfCloseContainer;

late final int Function(

int hContainer,

int bSignFlag,

Pointer<Struct_ECCPUBLICKEYBLOB> pbBlob,

Pointer<Uint32> pulBlobLen,

_skfExportPublicKey;

late final int Function(

int hContainer,

int bSignFlag,

Pointer<Uint8> pbCert,

Pointer<Uint32> pulCertLen,

_skfExportCertificate;

late final int Function(

int hDev,

Pointer<Struct_ECCPUBLICKEYBLOB> pECCPubKeyBlob,

Pointer<Utf8> pbPlainText,

int ulPlainTextLen,

Pointer<Struct_ECCCIPHERBLOB> pCipherText,

_skfExtECCEncrypt;

late final int Function(

int hContainer,

int bSignFlag,

Pointer<Struct_ECCCIPHERBLOB> pCipherText,

Pointer<Uint8> pbData,

Pointer<Uint32> pbDataLen,

_skfECCDecrypt;

late final int Function(

int hContainer,

int ulAlgID,

Pointer<Utf8> pbPlainText,

int ulPlainTextLen,

Pointer<Struct_ECCSIGNATUREBLOB> pSignature,

_skfECCDigestSignData;

late final int Function(

int hContainer,

int ulAlgID,

Pointer<Utf8> pbPlainText,

int ulPlainTextLen,

Pointer<Struct_ECCSIGNATUREBLOB> pSignature,

_skfECCSignDataEx;

late final int Function(

int hApplication,

int ulPINType,

Pointer<Utf8> szPIN,

Pointer<Uint32> pulRetryCount,

_skfVerifyPIN;

SkfLib(final String dllPath) {

try {

_skfLib = Platform.isMacOS || Platform.isIOS

? DynamicLibrary.process()

: DynamicLibrary.open(dllPath); // 加载dll,获取句柄

} catch (e) {

_skfLib = null;

debugPrint('SkfLib Load Failed: $e');

}

// 获取函数指针

const fnEnumDev = "SKF_EnumDev";

if (_providesSymbol(fnEnumDev)) {

_skfEnumDev = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(Uint32, Pointer<Uint8>, Pointer<Uint32>)

>(fnEnumDev)

.asFunction();

} else {

_skfEnumDev = null;

}

const fnConnectDev = "SKF_ConnectDev";

if (_providesSymbol(fnConnectDev)) {

_skfConnectDev = _skfLib!

.lookup<

NativeFunction<Uint32 Function(Pointer<Utf8>, Pointer<Uint64>)>

>(fnConnectDev)

.asFunction();

} else {

_skfConnectDev = null;

}

const fnDisConnectDev = "SKF_DisConnectDev";

if (_providesSymbol(fnDisConnectDev)) {

_skfDisConnectDev = _skfLib!

.lookup<NativeFunction<Uint32 Function(Uint64)>>(fnDisConnectDev)

.asFunction();

} else {

_skfDisConnectDev = null;

}

const fnEnumApplication = "SKF_EnumApplication";

if (_providesSymbol(fnEnumApplication)) {

_skfEnumApplication = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(Uint64, Pointer<Uint8>, Pointer<Uint32>)

>(fnEnumApplication)

.asFunction();

} else {

_skfEnumApplication = null;

}

const fnOpenApplication = "SKF_OpenApplication";

if (_providesSymbol(fnOpenApplication)) {

_skfOpenApplication = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(Uint64, Pointer<Utf8>, Pointer<Uint64>)

>(fnOpenApplication)

.asFunction();

} else {

_skfOpenApplication = null;

}

const fnCloseApplication = "SKF_CloseApplication";

if (_providesSymbol(fnCloseApplication)) {

_skfCloseApplication = _skfLib!

.lookup<NativeFunction<Uint32 Function(Uint64)>>(fnCloseApplication)

.asFunction();

} else {

_skfCloseApplication = null;

}

const fnEnumContainer = "SKF_EnumContainer";

if (_providesSymbol(fnEnumContainer)) {

_skfEnumContainer = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(Uint64, Pointer<Uint8>, Pointer<Uint32>)

>(fnEnumContainer)

.asFunction();

} else {

_skfEnumContainer = null;

}

const fnOpenContainer = "SKF_OpenContainer";

if (_providesSymbol(fnOpenContainer)) {

_skfOpenContainer = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(Uint64, Pointer<Utf8>, Pointer<Uint64>)

>(fnOpenContainer)

.asFunction();

} else {

_skfOpenContainer = null;

}

const fnCloseContainer = "SKF_CloseContainer";

if (_providesSymbol(fnCloseContainer)) {

_skfCloseContainer = _skfLib!

.lookup<NativeFunction<Uint32 Function(Uint64)>>(fnCloseContainer)

.asFunction();

} else {

_skfCloseContainer = null;

}

const fnExportPublicKey = "SKF_ExportPublicKey";

if (_providesSymbol(fnExportPublicKey)) {

_skfExportPublicKey = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(

Uint64,

Uint32,

Pointer<Struct_ECCPUBLICKEYBLOB>,

Pointer<Uint32>,

)

>(fnExportPublicKey)

.asFunction();

} else {

_skfExportPublicKey = null;

}

const fnExportCertificate = "SKF_ExportCertificate";

if (_providesSymbol(fnExportCertificate)) {

_skfExportCertificate = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(Uint64, Uint32, Pointer<Uint8>, Pointer<Uint32>)

>(fnExportCertificate)

.asFunction();

} else {

_skfExportCertificate = null;

}

const fnExtECCEncrypt = "SKF_ExtECCEncrypt";

if (_providesSymbol(fnExtECCEncrypt)) {

_skfExtECCEncrypt = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(

Uint64,

Pointer<Struct_ECCPUBLICKEYBLOB>,

Pointer<Utf8>,

Uint32,

Pointer<Struct_ECCCIPHERBLOB>,

)

>(fnExtECCEncrypt)

.asFunction();

} else {

_skfExtECCEncrypt = null;

}

const fnECCDecrypt = "SKF_ECCDecrypt";

if (_providesSymbol(fnECCDecrypt)) {

_skfECCDecrypt = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(

Uint64,

Uint32,

Pointer<Struct_ECCCIPHERBLOB>,

Pointer<Uint8>,

Pointer<Uint32>,

)

>(fnECCDecrypt)

.asFunction();

} else {

_skfECCDecrypt = null;

}

const fnECCDigestSignData = "SKF_ECCDigestSignData";

if (_providesSymbol(fnECCDigestSignData)) {

_skfECCDigestSignData = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(

Uint64,

Uint32,

Pointer<Utf8>,

Uint32,

Pointer<Struct_ECCSIGNATUREBLOB>,

)

>(fnECCDigestSignData)

.asFunction();

} else {

_skfECCDigestSignData = null;

}

const fnECCSignDataEx = "SKF_ECCSignDataEx";

if (_providesSymbol(fnECCSignDataEx)) {

_skfECCSignDataEx = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(

Uint64,

Uint32,

Pointer<Utf8>,

Uint32,

Pointer<Struct_ECCSIGNATUREBLOB>,

)

>(fnECCSignDataEx)

.asFunction();

} else {

_skfECCSignDataEx = null;

}

const fnVerifyPIN = "SKF_VerifyPIN";

if (_providesSymbol(fnVerifyPIN)) {

_skfVerifyPIN = _skfLib!

.lookup<

NativeFunction<

Uint32 Function(Uint64, Uint32, Pointer<Utf8>, Pointer<Uint32>)

>(fnVerifyPIN)

.asFunction();

} else {

_skfVerifyPIN = null;

}

/// Checks whether this dynamic library provides a symbol with the given name.

bool _providesSymbol(final String symbolName) {

return _skfLib?.providesSymbol(symbolName) ?? false;

}

@mustCallSuper

void close() {

_skfLib?.close();

}

/// 功能描述：

///

/// 获得当前系统中的设备列表。

///

/// 参数：

///

/// [bPresent] [IN] 为 TRUE 表示获取当前设备状态为存在的设备列表。

/// 为 FALSE 表示取当前取得支持的设备列表。

///

/// [szNameList] [OUT] 设备名称列表。如果该参数为 NULL ，将由 pulSize 返回所需要的内存空间大小。

/// 每个设备的名称以单个 '\0' 结束，以双 '\0' 表示列表结束。

///

/// [pulSize] [IN, OUT] 输入时表示设备名称列表的缓冲区长度，输出时表示 szNameList 所占用的空间大小。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_EnumDev(

final int bPresent,

final Pointer<Uint8> szNameList,

final Pointer<Uint32> pulSize,

) {

if (null != _skfEnumDev) {

return _skfEnumDev(bPresent, szNameList, pulSize);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 通过设备名称连接设备，返回设备的句柄。

///

/// 参数：

///

/// [szName] [IN] 设备名称。

///

/// [phDev] [OUT] 返回设备操作句柄。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_ConnectDev(final Pointer<Utf8> szName, final Pointer<Uint64> phDev) {

if (null != _skfConnectDev) {

return _skfConnectDev(szName, phDev);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 断开一个已经连接的设备，并释放句柄。

///

/// 参数：

///

/// [hDev] [IN] 连接设备时返回的设备句柄。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_DisConnectDev(final int hDev) {

if (null != _skfDisConnectDev) {

return _skfDisConnectDev(hDev);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 枚举设备中存在的所有应用。

///

/// 参数：

///

/// [hDev] [IN] 连接设备时返回的设备句柄。

///

/// [szAppName] [OUT] 返回应用名称列表，如果该参数为空，将由 pulSize 返回所需要的内存空间大小。

/// 每个应用的名称以单个 '\0' 结束，以双 '\0' 表示列表结束。

///

/// [pulSize] [IN, OUT] 输入时表示应用名称列表的缓冲区长度，输出时表示 szAppName 所占用的空间大小。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_EnumApplication(

final int hDev,

final Pointer<Uint8> szAppName,

final Pointer<Uint32> pulSize,

) {

if (null != _skfEnumApplication) {

return _skfEnumApplication(hDev, szAppName, pulSize);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 打开指定的应用。

///

/// 参数：

///

/// [hDev] [IN] 连接设备时返回的设备句柄。

///

/// [szAppName] [IN] 应用名称。

///

/// [phApplication] [OUT] 应用的句柄。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_OpenApplication(

final int hDev,

final Pointer<Utf8> szAppName,

final Pointer<Uint64> phApplication,

) {

if (null != _skfOpenApplication) {

return _skfOpenApplication(hDev, szAppName, phApplication);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 关闭应用并释放应用句柄。

///

/// 参数：

///

/// [hApplication] [IN] 应用句柄。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_CloseApplication(final int hApplication) {

if (null != _skfCloseApplication) {

return _skfCloseApplication(hApplication);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 枚举容器下所有容器并返回容器名称列表。

///

/// 参数：

///

/// [hApplication] [IN] 应用句柄。

///

/// [szContainerName] [OUT] 指向容器名称列表缓冲区，如果该参数为 NULL 时，pulSize 表示返回数据所需缓冲区的长度，

/// 如果此参数不为 NULL 时，返回容器名称列表，每个容器名以 '\0' 结束，列表以双 '\0' 结束。

///

/// [pulSize] [IN, OUT] 输入时表示 szContainerName 缓冲区长度，输出时表示容器名称列表的长度。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_EnumContainer(

final int hApplication,

final Pointer<Uint8> szContainerName,

final Pointer<Uint32> pulSize,

) {

if (null != _skfEnumContainer) {

return _skfEnumContainer(hApplication, szContainerName, pulSize);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 获取容器句柄。

///

/// 参数：

///

/// [hApplication] [IN] 应用句柄。

///

/// [szContainerName] [IN] 容器的名称。

///

/// [phContainer] [OUT] 返回所打开容器的句柄。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_OpenContainer(

final int hApplication,

final Pointer<Utf8> szContainerName,

final Pointer<Uint64> phContainer,

) {

if (null != _skfOpenContainer) {

return _skfOpenContainer(hApplication, szContainerName, phContainer);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 关闭容器句柄，并释放容器句柄相关资源。

///

/// 参数：

///

/// [hContainer] [IN] 容器句柄。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_CloseContainer(final int hContainer) {

if (null != _skfCloseContainer) {

return _skfCloseContainer(hContainer);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 从导出公钥。

///

/// 参数：

///

/// [hContainer] [IN] 容器句柄。

///

/// [bSignFlag] [IN] TRUE 表示签名证书，FALSE 表示加密证书。

///

/// [pbBlob] [OUT] 指向公钥内容缓冲区，如果此参数为 NULL 时，pulBlobLen 返回数据所需要

/// 缓冲区长度，如果此参数不为 NULL 时，返回公钥内容。

///

/// [pulBlobLen] [IN/OUT] 输入时表示 pbBlob 缓冲区的长度，输出时表示证书内容的长度。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_ExportPublicKey(

final int hContainer,

final int bSignFlag,

final Pointer<Struct_ECCPUBLICKEYBLOB> pbBlob,

final Pointer<Uint32> pulBlobLen,

) {

if (null != _skfExportPublicKey) {

return _skfExportPublicKey(hContainer, bSignFlag, pbBlob, pulBlobLen);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 从容器内导出数字证书。

///

/// 参数：

///

/// [hContainer] [IN] 容器句柄。

///

/// [bSignFlag] [IN] TRUE 表示签名证书，FALSE 表示加密证书。

///

/// [pbCert] [OUT] 指向证书内容缓冲区，如果此参数为 NULL 时，pulCertLen 返回数据所需要

/// 缓冲区长度，如果此参数不为 NULL 时，返回数字证书内容。

///

/// [pulCertLen] [IN/OUT] 输入时表示 pbCert 缓冲区的长度，输出时表示证书内容的长度。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_ExportCertificate(

final int hContainer,

final int bSignFlag,

final Pointer<Uint8> pbCert,

final Pointer<Uint32> pulCertLen,

) {

if (null != _skfExportCertificate) {

return _skfExportCertificate(hContainer, bSignFlag, pbCert, pulCertLen);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 使用外部传入的 ECC 公钥对输入数据做加密运算并输出结果。

///

/// 参数：

///

/// [hDev] [IN] 设备句柄。

///

/// [pECCPubKeyBlob] [IN] ECC公钥数据结构。

///

/// [pbPlainText] [IN] 待加密的明文数据。

///

/// [ulPlainTextLen] [IN] 待加密的明文数据长度。

///

/// [pCipherText] [OUT] 密文数据。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_ExtECCEncrypt(

final int hDev,

final Pointer<Struct_ECCPUBLICKEYBLOB> pECCPubKeyBlob,

final Pointer<Utf8> pbPlainText,

final int ulPlainTextLen,

final Pointer<Struct_ECCCIPHERBLOB> pCipherText,

) {

if (null != _skfExtECCEncrypt) {

return _skfExtECCEncrypt(

hDev,

pECCPubKeyBlob,

pbPlainText,

ulPlainTextLen,

pCipherText,

);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 私钥解密。

///

/// 参数：

///

/// [hContainer] [IN] 密钥容器句柄。

///

/// [bSignFlag] [IN] TRUE 表示签名证书，FALSE 表示加密证书。

///

/// [pCipherText] [IN] 加密数据的结构。

///

/// [pbData] [OUT] 解密后的明文数据。

///

/// [pbDataLen] [OUT] 明文数据长度。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_ECCDecrypt(

final int hContainer,

final int bSignFlag,

final Pointer<Struct_ECCCIPHERBLOB> pCipherText,

final Pointer<Uint8> pbData,

final Pointer<Uint32> pbDataLen,

) {

if (null != _skfECCDecrypt) {

return _skfECCDecrypt(

hContainer,

bSignFlag,

pCipherText,

pbData,

pbDataLen,

);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 厂商实现的 ECC 数据签名扩展。

///

/// 参数：

///

/// [hContainer] [IN] 密钥容器句柄。

///

/// [ulAlgID] [IN] 杂凑算法标识，这里选择SGD_SM3（0x00000001），表明使用SM3算法。

///

/// [pbPlainText] [IN] 待签名的明文数据。

///

/// [ulPlainTextLen] [IN] 待签名的明文数据长度。

///

/// [pSignature] [OUT] 签名结果。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_ECCSignDataEx(

final int hContainer,

final int ulAlgID,

final Pointer<Utf8> pbPlainText,

final int ulPlainTextLen,

final Pointer<Struct_ECCSIGNATUREBLOB> pSignature,

) {

// WQ 扩展接口 SKF_ECCSignDataEx

// FT/HB 扩展接口 SKF_ECCDigestSignData

if (null != _skfECCDigestSignData) {

return _skfECCDigestSignData(

hContainer,

ulAlgID,

pbPlainText,

ulPlainTextLen,

pSignature,

);

} else if (null != _skfECCSignDataEx) {

return _skfECCSignDataEx(

hContainer,

ulAlgID,

pbPlainText,

ulPlainTextLen,

pSignature,

);

}

return SAR_NOTEXPORTERR;

}

/// 功能描述：

///

/// 校验 PIN 码。校验成功后，会获得相应的权限，如果 PIN 码错误，会返回 PIN 码的重试次数，

/// 当重试次数为 0 时表示 PIN 码已经锁死。

///

/// 参数：

///

/// [hApplication] [IN] 应用句柄。

///

/// [ulPINType] [IN] PIN 类型。 0 是管理员账户，1 为普通用户，这个参数一般选择 1。

///

/// [szPIN] [IN] PIN 值。

///

/// [pulRetryCount] [OUT] 出错后返回的重试次数。

///

/// 返回值：

///

/// SAR_OK : 成功。

///

/// 其他：错误码。

// ignore: non_constant_identifier_names

int SKF_VerifyPIN(

final int hApplication,

final int ulPINType,

final Pointer<Utf8> szPIN,

final Pointer<Uint32> pulRetryCount,

) {

if (null != _skfVerifyPIN) {

return _skfVerifyPIN(hApplication, ulPINType, szPIN, pulRetryCount);

}

return SAR_NOTEXPORTERR;

}

import 'dart:convert';
import 'dart:ffi';
import 'dart:typed_data';

import 'package:convert/convert.dart';
import 'package:ffi/ffi.dart';
import 'package:pkcs7/pkcs7.dart';
import 'package:pointycastle/asn1.dart';

import 'slf.dart';

class SkfProvider extends SkfLib {
  /// 设备名
  late final String _devName;

  /// 设备句柄
  late int _devHandle = SKF_INVALID_HANDLE;

  /// 应用名
  late final String _appName;

  /// 应用句柄
  late int _appHandle = SKF_INVALID_HANDLE;

  /// 容器名
  late final List<String> _cntNames;

  /// 容器句柄
  late int _cntHandle = SKF_INVALID_HANDLE;

  int error = 0;

  SkfProvider(super.dllPath) {
    _initHandle();
  }

  /// 句柄获取
  ///
  /// 获取设备、应用、容器句柄
  void _initHandle() {
    _devName = _getDevName(); // 获取设备名
    _devHandle = _connectDev(); // 获取设备句柄 需要用到设备名
    _appName = _getAppName(); // 获取应用名
    _appHandle = _openApplication(); // 定义应用句柄
    _cntNames = _getCntNames(); // 获取容器名
    if (0 == error) {
      /// 获取容器名的时候返回的error为0，正常执行
      /// 此处选择第一个容器作为ECC密钥对，如果第一个不是ECC密钥对，可能导致应用闪退
      /// 请根据实际情况进行相关调整
      _cntHandle = _openContainer(_cntNames[1]);
    }
  }

  /// 句柄释放
  ///
  /// 释放设备、应用、容器句柄
  @override
  close() {
    if (SKF_INVALID_HANDLE != _cntHandle) {
      SKF_CloseContainer(_cntHandle);
      _cntHandle = SKF_INVALID_HANDLE;
    }
    if (SKF_INVALID_HANDLE != _appHandle) {
      SKF_CloseApplication(_appHandle);
      _appHandle = SKF_INVALID_HANDLE;
    }
    if (SKF_INVALID_HANDLE != _devHandle) {
      SKF_DisConnectDev(_devHandle);
      _devHandle = SKF_INVALID_HANDLE;
    }
    super.close();
  }

  /// 获取设备名
  ///
  /// 多设备的情况只会获取到第一个设备
  String _getDevName() {
    final pulSize = calloc<Uint32>(); // 为指针分配内存
    error = SKF_EnumDev(TRUE, nullptr, pulSize);
    final szNameList = calloc.allocate<Uint8>(pulSize.value); //为szNameList分配内存
    error = SKF_EnumDev(TRUE, szNameList, pulSize);
    calloc.free(pulSize);
    final String devName = szNameList.cast<Utf8>().toDartString();
    calloc.free(szNameList);
    return devName;
  }

  int _connectDev() {
    final phDev = calloc<Uint64>();
    error = SKF_ConnectDev(_devName.toNativeUtf8(), phDev); // 连接设备
    final res = phDev.value;
    calloc.free(phDev);
    return res;
  }

  String _getAppName() {
    final pulSize = calloc<Uint32>(); // 用于获取应用名长度
    error = SKF_EnumApplication(_devHandle, nullptr, pulSize);
    final szNameList = calloc<Uint8>(pulSize.value); //为szNameList分配内存
    error = SKF_EnumApplication(
      _devHandle,
      szNameList,
      pulSize,
    ); // 获取应用名，这里默认返回第一个应用名
    calloc.free(pulSize);
    final String appName = szNameList.cast<Utf8>().toDartString();
    calloc.free(szNameList);
    return appName;
  }

  int _openApplication() {
    final phApp = calloc<Uint64>();
    error = SKF_OpenApplication(
      _devHandle,
      _appName.toNativeUtf8(),
      phApp,
    ); // 打开应用
    final res = phApp.value;
    calloc.free(phApp);
    return res;
  }

  List<String> _getCntNames() {
    final List<String> cntNames = [];
    using((Arena arena) {
      final pulSize = arena<Uint32>(); // 用于获取应用名长度:
      error = SKF_EnumContainer(_appHandle, nullptr, pulSize);
      final szNameList = arena<Uint8>(pulSize.value); //为szNameList分配内存
      // 由于szNameList是以'\0'为分隔符，获取多个容器名列表切分获取
      error = SKF_EnumContainer(_appHandle, szNameList, pulSize);
      int start = 0;
      final Utf8Decoder decoder = const Utf8Decoder(allowMalformed: true);
      final szNameListArr = szNameList.asTypedList(pulSize.value);
      for (int i = 0; i < pulSize.value; i++) {
        if (0 == szNameList[i]) {
          if (0 != szNameList[start]) {
            final name = decoder.convert(szNameListArr, start, i);
            cntNames.add(name);
            start = i + (i <= pulSize.value - 1 ? 1 : 0); // 此处提防最后一个字符越界
          }
        }
      }
    });
    return cntNames; // 容器列表
  }

  int _openContainer(final String cntName) {
    final phCnt = calloc<Uint64>(); // 容器句柄
    error = SKF_OpenContainer(
      _appHandle,
      cntName.toNativeUtf8(),
      phCnt,
    ); // 打开容器
    final res = phCnt.value;
    calloc.free(phCnt);
    return res;
  }

  /// 1-导出ECC的加密密钥对的公钥
  ///
  /// 2-用公钥加密SKF_ExtECCEncrypt
  Pointer<Struct_ECCCIPHERBLOB> eccEncrypt(final String plainText) {
    // 创建公钥接收对象
    final pbBlob = calloc<Struct_ECCPUBLICKEYBLOB>();
    final pulBlobLen = calloc<Uint32>();
    pulBlobLen.value = pbBlob.ref.lengthInBytes();
    error = SKF_ExportPublicKey(_cntHandle, FALSE, pbBlob, pulBlobLen);
    calloc.free(pulBlobLen);

    final pCipherText = Struct_ECCCIPHERBLOB.allocate(plainText.length);
    final nativeText = plainText.toNativeUtf8();
    // 用公钥进行加密
    error = SKF_ExtECCEncrypt(
      _devHandle,
      pbBlob,
      nativeText,
      nativeText.length,
      pCipherText,
    );

    calloc.free(pbBlob);

    return pCipherText;
  }

  /// 1-导出ECC的加密密钥对的公钥
  ///
  /// 2-用公钥加密SKF_ExtECCEncrypt
  ///
  /// 3-转成Hex字符串
  String eccEncryptHex(final String plainText) {
    final cipherText = eccEncrypt(plainText);
    // 将密文结构内容转成Hex字符串
    final res = cipherTextToStrHex(cipherText);
    calloc.free(cipherText);
    return res;
  }

  String eccDecrypt(final Pointer<Struct_ECCCIPHERBLOB> cipherText) {
    var plainText = "";
    using((Arena arena) {
      final plainTextLen = arena<Uint32>();
      // 解密，传None，获得plain_text的长度
      error = SKF_ECCDecrypt(
        _cntHandle,
        FALSE,
        cipherText,
        nullptr,
        plainTextLen,
      );
      // plain_text分配空间
      final plainTextBuffer = arena<Uint8>(plainTextLen.value);
      // 解密
      error = SKF_ECCDecrypt(
        _cntHandle,
        FALSE,
        cipherText,
        plainTextBuffer,
        plainTextLen,
      );

      // 返回明文
      plainText = plainTextBuffer.cast<Utf8>().toDartString();
    });

    return plainText;
  }

  String eccDecryptHex(final String cipherHex) {
    final cipherText = strHexToCipherText(cipherHex); // 先将Hex密文字符串转为ECC密文结构

    final res = eccDecrypt(cipherText); // 解密

    calloc.free(cipherText);
    return res;
  }

  Pointer<Struct_ECCSIGNATUREBLOB> eccSignEx(final String plainText) {
    // 签名返回结果
    final pbBlob = calloc<Struct_ECCSIGNATUREBLOB>();

    // WQ 扩展接口 SKF_ECCSignDataEx

    // FT/HB 扩展接口 SKF_ECCDigestSignData

    final nativeText = plainText.toNativeUtf8();
    error = SKF_ECCSignDataEx(
      _cntHandle,
      SGD_SM3,
      nativeText,
      nativeText.length,
      pbBlob,
    );
    return pbBlob;
  }

  /// 1-对原文进行SM2签名
  ///
  /// 2-获取签名证书信息
  ///
  /// 3-返回签名证书字符数组，SM2签名结果 (ByteData, ByteData, ByteData)
  (ByteData, ByteData, ByteData) sm2Sign(final String plainText) {
    //签名
    final signRes = eccSignEx(plainText);

    // 取ECC签名的后 32 位 作为SM2签名，参考
    // https: // github.com/guanzhi/GmSSL/blob/master/src/skf/skf.c
    // SKF_ECCSIGNATUREBLOB_to_SM2_SIGNATURE
    const int validBytes = 32;
    final sm2R = ByteData(validBytes);
    for (int i = validBytes; i < 64; i++) {
      sm2R.setUint8(i - validBytes, signRes.ref.r[i]);
    }
    final sm2S = ByteData(validBytes);
    for (int i = validBytes; i < 64; i++) {
      sm2S.setUint8(i - validBytes, signRes.ref.s[i]);
    }

    calloc.free(signRes);

    var certDerBytes = ByteData(0);
    using((Arena arena) {
      // 导出签名证书
      final pulBlobLen = arena<Uint32>();
      error = SKF_ExportCertificate(_cntHandle, TRUE, nullptr, pulBlobLen);

      // 申请内存
      final certDer = arena<Uint8>(pulBlobLen.value);

      error = SKF_ExportCertificate(_cntHandle, TRUE, certDer, pulBlobLen);

      certDerBytes = ByteData(pulBlobLen.value);
      for (int i = 0; i < pulBlobLen.value; i++) {
        certDerBytes.setUint8(i, (certDer + i).value);
      }
    });

    return (certDerBytes, sm2R, sm2S);
  }

  /// 1-对原文进行签名
  ///
  /// 2-获取签名证书信息
  ///
  /// 3-对报文进行P7 DER格式封装
  Uint8List sm2SignP7DER(final String plainText) {
    final (certDer, sm2R, sm2S) = sm2Sign(plainText);
    return buildSm2SignP7DER(plainText, certDer, sm2R, sm2S);
  }

  /// 对报文进行签名，并对结果进行 P7 格式封装，返回结果使用HEX格式
  String sm2SignP7DERHex(final String plainText) {
    final res = sm2SignP7DER(plainText);
    return hex.encoder.convert(res);
  }

  /// 对报文进行签名，并对结果进行 P7 格式封装，返回结果使用PEM(Base64)格式
  String sm2SignP7PEM(final String plainText) {
    final res = sm2SignP7DER(plainText);
    return base64.encoder.convert(res);
  }

  ///  构建 P7 DER 格式的SM2签名报文
  ///
  ///  1-plainText 签名原文
  ///
  ///  2-certDer DER格式的签名证书
  ///
  ///  3-sm2R SM2格式签名返回的 r 32位字符数组
  ///
  ///  4-sm2S SM2格式签名返回的 s 32位字符数组
  Uint8List buildSm2SignP7DER(
    final String plainText,
    final ByteData certDer,
    final ByteData sm2R,
    final ByteData sm2S,
  ) {
    // ignore: constant_identifier_names
    const CONTEXT_SPECIFIC = ASN1Tags.TAGGED | ASN1Tags.CONSTRUCTED | 0; //A0

    // SM3 摘要算法 OID
    final sm3DigestOid = ASN1ObjectIdentifier.fromIdentifierString(
      "1.2.156.10197.1.401",
    );
    // SM3 摘要算法
    // 'digest_algorithms'
    final sm3DigestAlg = ASN1Sequence(
      elements: [sm3DigestOid, ASN1Null()],
    ); // 签名算法类型 SM3withSM2

    // SM2 签名算法 OID
    final sm2SignOid = ASN1ObjectIdentifier.fromIdentifierString(
      "1.2.156.10197.1.301.1",
    );
    // SM2 签名算法
    final sm2SignAlg = ASN1Sequence(elements: [sm2SignOid, ASN1Null()]);

    final der = certDer.buffer.asUint8List();
    final asn1Cert = ASN1Parser(der).nextObject() as ASN1Sequence;
    final X509 cert = X509(asn1Cert);

    final signVal = BytesBuilder();
    signVal.add(sm2R.buffer.asUint8List());
    signVal.add(sm2S.buffer.asUint8List());

    final signerInfo = ASN1Sequence(
      elements: [
        // 'version'
        ASN1Integer.fromtInt(1),
        // 'sid' 签名证书信息 'issuer_and_serial_number'
        cert.asn1Issuer,
        // 'digest_algorithm'
        sm3DigestAlg, // 摘要算法
        // 'signature_algorithm'
        sm2SignAlg, // 签名算法
        // 'signature'
        ASN1OctetString(octets: signVal.toBytes()), // 签名信息 （OCTET STRING）
      ],
    );

    // 构建完整证书的 ASN.1 PKCS#7 SignedData 结构
    final signedData = ASN1Sequence(
      elements: [
        // 'version' 签名版本 v1
        ASN1Integer.fromtInt(1),
        // 'digest_algorithms' 摘要算法
        ASN1Set(
          elements: [
            sm3DigestAlg, // SM3
          ],
        ),
        // 'encap_content_info' 签名载核（业务）数据
        ASN1Sequence(
          elements: [
            // 载核（业务）数据类型 (PKCS #7)
            ASN1ObjectIdentifier.fromIdentifierString(
              '1.2.840.113549.1.7.1',
            ), //'content_type'
            // 签名载核(业务)数据
            ASN1Set(
              elements: [
                ASN1OctetString(octets: utf8.encoder.convert(plainText)),
              ],
              tag: CONTEXT_SPECIFIC,
            ), // 'content'
          ],
        ),
        // 'certificates'  证书集合
        ASN1Set(elements: [asn1Cert], tag: CONTEXT_SPECIFIC),
        // 'signer_infos' 签名信息
        ASN1Set(elements: [signerInfo]),
      ],
    );

    // 数据传输封装
    final payloadContent = ASN1Sequence(
      elements: [
        // 数据类型 (PKCS #7)
        ASN1ObjectIdentifier.fromIdentifierString(
          '1.2.840.113549.1.7.2',
        ), //'content_type'
        // 签名数据
        ASN1Set(elements: [signedData], tag: CONTEXT_SPECIFIC), // 'content'
      ],
    );

    return payloadContent.encode();
  }

  /// PIN校验
  ///
  /// user_pin：字符串
  ///
  /// return：返回剩余尝试次数
  int verifyPIN(final String userPin) {
    var leftTimes = 0;
    final int ulPINType = 1; // PIN类型，1表示用户PIN
    using((Arena arena) {
      final pulRetryCount = arena<Uint32>(); // PIN剩余尝试次数
      // 调用验证PIN接口
      error = SKF_VerifyPIN(
        _appHandle,
        ulPINType,
        userPin.toNativeUtf8(),
        pulRetryCount,
      );
      leftTimes = pulRetryCount.value;
    });
    return leftTimes;
  }

  /// 将Hex字符串转成ECC密文结构
  ///
  /// strHex：Hex字符串
  ///
  /// return：ECC密文结构
  Pointer<Struct_ECCCIPHERBLOB> strHexToCipherText(final String strHex) {
    // 密文结构中 Cipher 长度（C3）
    final cipherLen =
        (strHex.length - Struct_ECCCIPHERBLOB.lengthBytes(0) * 2) ~/ 2;
    final pCipherText = Struct_ECCCIPHERBLOB.allocate(
      cipherLen,
    ); // 声明pCipherText密文结构变量

    final xCoordinateHex = strHex.substring(
      0,
      64,
    ); // 获取密文结构的 XCoordinate 的Hex字符串
    final yCoordinateHex = strHex.substring(
      64,
      128,
    ); // 获取密文结构的 YCoordinate 的Hex字符串
    final hashHex = strHex.substring(128, 192); // 获取密文结构的 HASH 的Hex字符串
    final cipherTextHex = strHex.substring(192); // C2：密文结构中的Cipher
    // 为密文结构中的每部分赋值
    for (int i = 0; i < 32; i++) {
      pCipherText.ref.xCoordinate[32 + i] = int.parse(
        xCoordinateHex.substring(i * 2, 2),
        radix: 16,
      );
    }
    for (int i = 0; i < 32; i++) {
      pCipherText.ref.yCoordinate[32 + i] = int.parse(
        yCoordinateHex.substring(i * 2, 2),
        radix: 16,
      );
    }
    for (int i = 0; i < 32; i++) {
      pCipherText.ref.hash[i] = int.parse(
        hashHex.substring(i * 2, 2),
        radix: 16,
      );
    }
    // 密文部分转为Uint8类型
    for (int i = 0; i < cipherLen; i++) {
      pCipherText.ref.cipher[i] = int.parse(
        cipherTextHex.substring(i * 2, 2),
        radix: 16,
      );
    }
    return pCipherText;
  }

  /// 将ECC密文结构转成Hex字符串
  String cipherTextToStrHex(final Pointer<Struct_ECCCIPHERBLOB> cipherText) {
    final textHex = StringBuffer();
    // 将密文结构内容转成Hex字符串
    for (int i = 32; i < 64; i++) {
      // 获取密文结构中 XCoordinate
      textHex.write(
        cipherText.ref.xCoordinate[i].toRadixString(16).padLeft(2, '0'),
      );
    }
    for (int i = 32; i < 64; i++) {
      // 获取密文结构中 YCoordinate
      textHex.write(
        cipherText.ref.yCoordinate[i].toRadixString(16).padLeft(2, '0'),
      );
    }
    for (int i = 0; i < 32; i++) {
      // 获取密文结构中 HASH
      textHex.write(cipherText.ref.hash[i].toRadixString(16).padLeft(2, '0'));
    }
    for (int i = 0; i < cipherText.ref.cipherLen; i++) {
      // 将 Cipher 转成Hex字符串
      textHex.write(cipherText.ref.cipher[i].toRadixString(16).padLeft(2, '0'));
    }
    return textHex.toString().toUpperCase();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

import 'dart:convert';

import 'dart:ffi';

import 'dart:typed_data';

import 'package:convert/convert.dart';

import 'package:ffi/ffi.dart';

import 'package:pkcs7/pkcs7.dart';

import 'package:pointycastle/asn1.dart';

import 'slf.dart';

class SkfProvider extends SkfLib {

/// 设备名

late final String _devName;

/// 设备句柄

late int _devHandle = SKF_INVALID_HANDLE;

/// 应用名

late final String _appName;

/// 应用句柄

late int _appHandle = SKF_INVALID_HANDLE;

/// 容器名

late final List<String> _cntNames;

/// 容器句柄

late int _cntHandle = SKF_INVALID_HANDLE;

int error = 0;

SkfProvider(super.dllPath) {

_initHandle();

}

/// 句柄获取

///

/// 获取设备、应用、容器句柄

void _initHandle() {

_devName = _getDevName(); // 获取设备名

_devHandle = _connectDev(); // 获取设备句柄需要用到设备名

_appName = _getAppName(); // 获取应用名

_appHandle = _openApplication(); // 定义应用句柄

_cntNames = _getCntNames(); // 获取容器名

if (0 == error) {

/// 获取容器名的时候返回的error为0，正常执行

/// 此处选择第一个容器作为ECC密钥对，如果第一个不是ECC密钥对，可能导致应用闪退

/// 请根据实际情况进行相关调整

_cntHandle = _openContainer(_cntNames[1]);

}

/// 句柄释放

///

/// 释放设备、应用、容器句柄

@override

close() {

if (SKF_INVALID_HANDLE != _cntHandle) {

SKF_CloseContainer(_cntHandle);

_cntHandle = SKF_INVALID_HANDLE;

}

if (SKF_INVALID_HANDLE != _appHandle) {

SKF_CloseApplication(_appHandle);

_appHandle = SKF_INVALID_HANDLE;

}

if (SKF_INVALID_HANDLE != _devHandle) {

SKF_DisConnectDev(_devHandle);

_devHandle = SKF_INVALID_HANDLE;

}

super.close();

}

/// 获取设备名

///

/// 多设备的情况只会获取到第一个设备

String _getDevName() {

final pulSize = calloc<Uint32>(); // 为指针分配内存

error = SKF_EnumDev(TRUE, nullptr, pulSize);

final szNameList = calloc.allocate<Uint8>(pulSize.value); //为szNameList分配内存

error = SKF_EnumDev(TRUE, szNameList, pulSize);

calloc.free(pulSize);

final String devName = szNameList.cast<Utf8>().toDartString();

calloc.free(szNameList);

return devName;

}

int _connectDev() {

final phDev = calloc<Uint64>();

error = SKF_ConnectDev(_devName.toNativeUtf8(), phDev); // 连接设备

final res = phDev.value;

calloc.free(phDev);

return res;

}

String _getAppName() {

final pulSize = calloc<Uint32>(); // 用于获取应用名长度

error = SKF_EnumApplication(_devHandle, nullptr, pulSize);

final szNameList = calloc<Uint8>(pulSize.value); //为szNameList分配内存

error = SKF_EnumApplication(

_devHandle,

szNameList,

pulSize,

); // 获取应用名，这里默认返回第一个应用名

calloc.free(pulSize);

final String appName = szNameList.cast<Utf8>().toDartString();

calloc.free(szNameList);

return appName;

}

int _openApplication() {

final phApp = calloc<Uint64>();

error = SKF_OpenApplication(

_devHandle,

_appName.toNativeUtf8(),

phApp,

); // 打开应用

final res = phApp.value;

calloc.free(phApp);

return res;

}

List<String> _getCntNames() {

final List<String> cntNames = [];

using((Arena arena) {

final pulSize = arena<Uint32>(); // 用于获取应用名长度:

error = SKF_EnumContainer(_appHandle, nullptr, pulSize);

final szNameList = arena<Uint8>(pulSize.value); //为szNameList分配内存

// 由于szNameList是以'\0'为分隔符，获取多个容器名列表切分获取

error = SKF_EnumContainer(_appHandle, szNameList, pulSize);

int start = 0;

final Utf8Decoder decoder = const Utf8Decoder(allowMalformed: true);

final szNameListArr = szNameList.asTypedList(pulSize.value);

for (int i = 0; i < pulSize.value; i++) {

if (0 == szNameList[i]) {

if (0 != szNameList[start]) {

final name = decoder.convert(szNameListArr, start, i);

cntNames.add(name);

start = i + (i <= pulSize.value - 1 ? 1 : 0); // 此处提防最后一个字符越界

}

});

return cntNames; // 容器列表

}

int _openContainer(final String cntName) {

final phCnt = calloc<Uint64>(); // 容器句柄

error = SKF_OpenContainer(

_appHandle,

cntName.toNativeUtf8(),

phCnt,

); // 打开容器

final res = phCnt.value;

calloc.free(phCnt);

return res;

}

/// 1-导出ECC的加密密钥对的公钥

///

/// 2-用公钥加密SKF_ExtECCEncrypt

Pointer<Struct_ECCCIPHERBLOB> eccEncrypt(final String plainText) {

// 创建公钥接收对象

final pbBlob = calloc<Struct_ECCPUBLICKEYBLOB>();

final pulBlobLen = calloc<Uint32>();

pulBlobLen.value = pbBlob.ref.lengthInBytes();

error = SKF_ExportPublicKey(_cntHandle, FALSE, pbBlob, pulBlobLen);

calloc.free(pulBlobLen);

final pCipherText = Struct_ECCCIPHERBLOB.allocate(plainText.length);

final nativeText = plainText.toNativeUtf8();

// 用公钥进行加密

error = SKF_ExtECCEncrypt(

_devHandle,

pbBlob,

nativeText,

nativeText.length,

pCipherText,

);

calloc.free(pbBlob);

return pCipherText;

}

/// 1-导出ECC的加密密钥对的公钥

///

/// 2-用公钥加密SKF_ExtECCEncrypt

///

/// 3-转成Hex字符串

String eccEncryptHex(final String plainText) {

final cipherText = eccEncrypt(plainText);

// 将密文结构内容转成Hex字符串

final res = cipherTextToStrHex(cipherText);

calloc.free(cipherText);

return res;

}

String eccDecrypt(final Pointer<Struct_ECCCIPHERBLOB> cipherText) {

var plainText = "";

using((Arena arena) {

final plainTextLen = arena<Uint32>();

// 解密，传None，获得plain_text的长度

error = SKF_ECCDecrypt(

_cntHandle,

FALSE,

cipherText,

nullptr,

plainTextLen,

);

// plain_text分配空间

final plainTextBuffer = arena<Uint8>(plainTextLen.value);

// 解密

error = SKF_ECCDecrypt(

_cntHandle,

FALSE,

cipherText,

plainTextBuffer,

plainTextLen,

);

// 返回明文

plainText = plainTextBuffer.cast<Utf8>().toDartString();

});

return plainText;

}

String eccDecryptHex(final String cipherHex) {

final cipherText = strHexToCipherText(cipherHex); // 先将Hex密文字符串转为ECC密文结构

final res = eccDecrypt(cipherText); // 解密

calloc.free(cipherText);

return res;

}

Pointer<Struct_ECCSIGNATUREBLOB> eccSignEx(final String plainText) {

// 签名返回结果

final pbBlob = calloc<Struct_ECCSIGNATUREBLOB>();

// WQ 扩展接口 SKF_ECCSignDataEx

// FT/HB 扩展接口 SKF_ECCDigestSignData

final nativeText = plainText.toNativeUtf8();

error = SKF_ECCSignDataEx(

_cntHandle,

SGD_SM3,

nativeText,

nativeText.length,

pbBlob,

);

return pbBlob;

}

/// 1-对原文进行SM2签名

///

/// 2-获取签名证书信息

///

/// 3-返回签名证书字符数组，SM2签名结果 (ByteData, ByteData, ByteData)

(ByteData, ByteData, ByteData) sm2Sign(final String plainText) {

//签名

final signRes = eccSignEx(plainText);

// 取ECC签名的后 32 位作为SM2签名，参考

// https: // github.com/guanzhi/GmSSL/blob/master/src/skf/skf.c

// SKF_ECCSIGNATUREBLOB_to_SM2_SIGNATURE

const int validBytes = 32;

final sm2R = ByteData(validBytes);

for (int i = validBytes; i < 64; i++) {

sm2R.setUint8(i - validBytes, signRes.ref.r[i]);

}

final sm2S = ByteData(validBytes);

for (int i = validBytes; i < 64; i++) {

sm2S.setUint8(i - validBytes, signRes.ref.s[i]);

}

calloc.free(signRes);

var certDerBytes = ByteData(0);

using((Arena arena) {

// 导出签名证书

final pulBlobLen = arena<Uint32>();

error = SKF_ExportCertificate(_cntHandle, TRUE, nullptr, pulBlobLen);

// 申请内存

final certDer = arena<Uint8>(pulBlobLen.value);

error = SKF_ExportCertificate(_cntHandle, TRUE, certDer, pulBlobLen);

certDerBytes = ByteData(pulBlobLen.value);

for (int i = 0; i < pulBlobLen.value; i++) {

certDerBytes.setUint8(i, (certDer + i).value);

}

});

return (certDerBytes, sm2R, sm2S);

}

/// 1-对原文进行签名

///

/// 2-获取签名证书信息

///

/// 3-对报文进行P7 DER格式封装

Uint8List sm2SignP7DER(final String plainText) {

final (certDer, sm2R, sm2S) = sm2Sign(plainText);

return buildSm2SignP7DER(plainText, certDer, sm2R, sm2S);

}

/// 对报文进行签名，并对结果进行 P7 格式封装，返回结果使用HEX格式

String sm2SignP7DERHex(final String plainText) {

final res = sm2SignP7DER(plainText);

return hex.encoder.convert(res);

}

/// 对报文进行签名，并对结果进行 P7 格式封装，返回结果使用PEM(Base64)格式

String sm2SignP7PEM(final String plainText) {

final res = sm2SignP7DER(plainText);

return base64.encoder.convert(res);

}

/// 构建 P7 DER 格式的SM2签名报文

///

/// 1-plainText 签名原文

///

/// 2-certDer DER格式的签名证书

///

/// 3-sm2R SM2格式签名返回的 r 32位字符数组

///

/// 4-sm2S SM2格式签名返回的 s 32位字符数组

Uint8List buildSm2SignP7DER(

final String plainText,

final ByteData certDer,

final ByteData sm2R,

final ByteData sm2S,

) {

// ignore: constant_identifier_names

const CONTEXT_SPECIFIC = ASN1Tags.TAGGED | ASN1Tags.CONSTRUCTED | 0; //A0

// SM3 摘要算法 OID

final sm3DigestOid = ASN1ObjectIdentifier.fromIdentifierString(

"1.2.156.10197.1.401",

);

// SM3 摘要算法

// 'digest_algorithms'

final sm3DigestAlg = ASN1Sequence(

elements: [sm3DigestOid, ASN1Null()],

); // 签名算法类型 SM3withSM2

// SM2 签名算法 OID

final sm2SignOid = ASN1ObjectIdentifier.fromIdentifierString(

"1.2.156.10197.1.301.1",

);

// SM2 签名算法

final sm2SignAlg = ASN1Sequence(elements: [sm2SignOid, ASN1Null()]);

final der = certDer.buffer.asUint8List();

final asn1Cert = ASN1Parser(der).nextObject() as ASN1Sequence;

final X509 cert = X509(asn1Cert);

final signVal = BytesBuilder();

signVal.add(sm2R.buffer.asUint8List());

signVal.add(sm2S.buffer.asUint8List());

final signerInfo = ASN1Sequence(

elements: [

// 'version'

ASN1Integer.fromtInt(1),

// 'sid' 签名证书信息 'issuer_and_serial_number'

cert.asn1Issuer,

// 'digest_algorithm'

sm3DigestAlg, // 摘要算法

// 'signature_algorithm'

sm2SignAlg, // 签名算法

// 'signature'

ASN1OctetString(octets: signVal.toBytes()), // 签名信息（OCTET STRING）

);

// 构建完整证书的 ASN.1 PKCS#7 SignedData 结构

final signedData = ASN1Sequence(

elements: [

// 'version' 签名版本 v1

ASN1Integer.fromtInt(1),

// 'digest_algorithms' 摘要算法

ASN1Set(

elements: [

sm3DigestAlg, // SM3

// 'encap_content_info' 签名载核（业务）数据

ASN1Sequence(

elements: [

// 载核（业务）数据类型 (PKCS #7)

ASN1ObjectIdentifier.fromIdentifierString(

'1.2.840.113549.1.7.1',

), //'content_type'

// 签名载核(业务)数据

ASN1Set(

elements: [

ASN1OctetString(octets: utf8.encoder.convert(plainText)),

tag: CONTEXT_SPECIFIC,

), // 'content'

// 'certificates' 证书集合

ASN1Set(elements: [asn1Cert], tag: CONTEXT_SPECIFIC),

// 'signer_infos' 签名信息

ASN1Set(elements: [signerInfo]),

);

// 数据传输封装

final payloadContent = ASN1Sequence(

elements: [

// 数据类型 (PKCS #7)

ASN1ObjectIdentifier.fromIdentifierString(

'1.2.840.113549.1.7.2',

), //'content_type'

// 签名数据

ASN1Set(elements: [signedData], tag: CONTEXT_SPECIFIC), // 'content'

);

return payloadContent.encode();

}

/// PIN校验

///

/// user_pin：字符串

///

/// return：返回剩余尝试次数

int verifyPIN(final String userPin) {

var leftTimes = 0;

final int ulPINType = 1; // PIN类型，1表示用户PIN

using((Arena arena) {

final pulRetryCount = arena<Uint32>(); // PIN剩余尝试次数

// 调用验证PIN接口

error = SKF_VerifyPIN(

_appHandle,

ulPINType,

userPin.toNativeUtf8(),

pulRetryCount,

);

leftTimes = pulRetryCount.value;

});

return leftTimes;

}

/// 将Hex字符串转成ECC密文结构

///

/// strHex：Hex字符串

///

/// return：ECC密文结构

Pointer<Struct_ECCCIPHERBLOB> strHexToCipherText(final String strHex) {

// 密文结构中 Cipher 长度（C3）

final cipherLen =

(strHex.length - Struct_ECCCIPHERBLOB.lengthBytes(0) * 2) ~/ 2;

final pCipherText = Struct_ECCCIPHERBLOB.allocate(

cipherLen,

); // 声明pCipherText密文结构变量

final xCoordinateHex = strHex.substring(

64,

); // 获取密文结构的 XCoordinate 的Hex字符串

final yCoordinateHex = strHex.substring(

64,

128,

); // 获取密文结构的 YCoordinate 的Hex字符串

final hashHex = strHex.substring(128, 192); // 获取密文结构的 HASH 的Hex字符串

final cipherTextHex = strHex.substring(192); // C2：密文结构中的Cipher

// 为密文结构中的每部分赋值

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

pCipherText.ref.xCoordinate[32 + i] = int.parse(

xCoordinateHex.substring(i * 2, 2),

radix: 16,

);

}

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

pCipherText.ref.yCoordinate[32 + i] = int.parse(

yCoordinateHex.substring(i * 2, 2),

radix: 16,

);

}

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

pCipherText.ref.hash[i] = int.parse(

hashHex.substring(i * 2, 2),

radix: 16,

);

}

// 密文部分转为Uint8类型

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

pCipherText.ref.cipher[i] = int.parse(

cipherTextHex.substring(i * 2, 2),

radix: 16,

);

}

return pCipherText;

}

/// 将ECC密文结构转成Hex字符串

String cipherTextToStrHex(final Pointer<Struct_ECCCIPHERBLOB> cipherText) {

final textHex = StringBuffer();

// 将密文结构内容转成Hex字符串

for (int i = 32; i < 64; i++) {

// 获取密文结构中 XCoordinate

textHex.write(

cipherText.ref.xCoordinate[i].toRadixString(16).padLeft(2, '0'),

);

}

for (int i = 32; i < 64; i++) {

// 获取密文结构中 YCoordinate

textHex.write(

cipherText.ref.yCoordinate[i].toRadixString(16).padLeft(2, '0'),

);

}

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

// 获取密文结构中 HASH

textHex.write(cipherText.ref.hash[i].toRadixString(16).padLeft(2, '0'));

}

for (int i = 0; i < cipherText.ref.cipherLen; i++) {

// 将 Cipher 转成Hex字符串

textHex.write(cipherText.ref.cipher[i].toRadixString(16).padLeft(2, '0'));

}

return textHex.toString().toUpperCase();

}

使用方式：

const path = "/opt/apps/xxxx.so";
skfProvider = SkfProvider(path);
skfProvider?.verifyPIN("123456");
skfProvider?.eccEncryptHex("123456");
const plain = "123456";
var res = skfProvider?.sm2SignP7PEM(plain);
debugPrint(res);

const path = "/opt/apps/xxxx.so";

skfProvider = SkfProvider(path);

skfProvider?.verifyPIN("123456");

skfProvider?.eccEncryptHex("123456");

const plain = "123456";

var res = skfProvider?.sm2SignP7PEM(plain);

debugPrint(res);

参考链接

VSCode GDB调试控制台报错"-var-create: unable to create variable object"

背景

在使用 Visual Studio Code (1.97.2) 进行 GDB 调试时，想使用 x 命令看一下某地址处的数值。出现如下报错：

-var-create: unable to create variable object

1	-var-create: unable to create variable object

解决方案

其实，在刚刚开始调试程序时，就以黄色字体给出了解决方案。

Execute debugger commands using "-exec <command>", for example "-exec info registers" will list registers in use (when GDB is the debugger)

1	Execute debugger commands using "-exec <command>", for example "-exec info registers" will list registers in use (when GDB is the debugger)

也就是说：

如果是想查看某个变量的值，直接在输入框里输入变量名就好了；
如果要执行GDB命令，则需要加-exec前缀，如下图：

2026 年 3 月
一	二	三	四	五	六	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31