vue与usbkey交互

最新推荐文章于 2024-10-09 18:14:30 发布
最新推荐文章于 2024-10-09 18:14:30 发布
阅读量1.7k 收藏 7
点赞数 2
文章标签： vue.js javascript elementui
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shn_207/article/details/129663570
版权

1.淘宝购买usbkey，本文使用的是UKEY3000D

购买链接(店家看到请自行打赏 ^_^)：Ukey3000D 国密SM2算法Usb key Usbkey证书Ukey二次开发

2.废话不多说，请看图：

 

 

代码片段：

<template>

  <div class="demo-input-suffix">
    <el-button type="primary" @click="login_onclick">点我有惊喜</el-button>

    <el-row style="line-height:20px;font-size:14px;margin-top:10px;margin-bottom:20px;">
      <el-col>
        <el-button type="primary" @click="getChipID">获取UKEY唯一编号</el-button>
        <el-input style="width: 300px;" v-model="ukeyId" disabled></el-input>
      </el-col>
    </el-row>

    <el-row style="line-height:20px;font-size:14px;margin-top:10px;margin-bottom:20px;">
      <el-col>
        <el-button type="primary" @click="setCal_2">设置增强算法密钥</el-button>
        <el-input style="width: 300px;" v-model="secretKey"></el-input>
      </el-col>
    </el-row>

    <el-row style="line-height:20px;font-size:14px;margin-top:10px;margin-bottom:20px;">
      <el-col>
        <el-input style="width: 300px;" v-model="text"></el-input>
        <el-button type="primary" @click="encode">加密</el-button>
        <el-input style="width: 300px;" v-model="secretText" disabled></el-input>
      </el-col>
    </el-row>

    <el-row style="line-height:20px;font-size:14px;margin-top:10px;margin-bottom:20px;">
      <el-col>
        <el-input style="width: 300px;" v-model="secretText"></el-input>
        <el-button type="primary" @click="decode">解密</el-button>
        <el-input style="width: 300px;" v-model="decodeText" disabled></el-input>
      </el-col>
    </el-row>

    <el-row style="line-height:20px;font-size:14px;margin-top:10px;margin-bottom:20px;">
      <el-col>
        <hr/>
        <h1>SM2</h1>
        <el-button type="primary" @click="genKeyPair">生成密钥对</el-button>
        <el-button type="primary" @click="genPubKeyY">GenPubKeyY</el-button>
        <el-button type="primary" @click="genPubKeyX">GenPubKeyX</el-button>
        <el-button type="primary" @click="genPriKey">获取私钥</el-button>
        <el-button type="primary" @click="setSM2KeyPair">设置密钥进锁中</el-button>
      </el-col>
    </el-row>

    <el-row style="line-height:20px;font-size:14px;margin-top:10px;margin-bottom:20px;">
      <el-col>
        <el-button type="primary" @click="reSetUkey">初始化UKEY</el-button>
        <el-button type="primary" @click="ytSetPin">设置PIN</el-button>
      </el-col>
    </el-row>

    <el-row style="line-height:20px;font-size:14px;margin-top:10px;margin-bottom:20px;">
      <el-col>
        <el-input style="width: 300px;" v-model="text"></el-input>
        <el-button type="primary" @click="sm2EncString">加密</el-button>
        <el-input style="width: 300px;" v-model="secretText" disabled></el-input>
      </el-col>
    </el-row>
    <el-row style="line-height:20px;font-size:14px;margin-top:10px;margin-bottom:20px;">
      <el-col>
        <el-input style="width: 300px;" v-model="secretText"></el-input>
        <el-button type="primary" @click="sm2DecString">解密</el-button>
        <el-input style="width: 300px;" v-model="decodeText" disabled></el-input>
      </el-col>
    </el-row>


  </div>

</template>

<script>
import SoftKey3W from "../components/sm/Syunew3";

export default {
  name: 'UKEY',

  data() {
    return {
      myUserName: "",
      myPassword: "",
      ukeyId: "",
      mSoftKey3W: null,
      devicePath: "",
      bConnect: 0,
      text: "",//待加密串
      secretText: "",//已加密串
      decodeText: "",//解密串
      secretKey: "",
      PriKey: "",
      PubKeyX : "",
      PubKeyY: "",
      CompName: "Levi"
    }
  },
  beforeMount() {

  },

  mounted() {
    this.intSoftKey3A();
  },
  methods: {

    setCal_2: function () {
      let ms = this.mSoftKey3W;
      let _this = this;

      ms.SetCal_2(_this.secretKey, _this.devicePath); //重置ukey

      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("setCal_2 onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("设置增强密钥时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }

        console.log("成功设置增强密钥 ： " + UK_Data.return_value);
      }
    },

    reSetUkey: function () {
      let ms = this.mSoftKey3W;
      let _this = this;

      ms.ReSet(_this.devicePath); //重置ukey

      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("sm2 reSetPin onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("初始化UKEY时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }

        // _this.secretText = UK_Data.return_value;
        console.log("成功初始化UKEY ： " + UK_Data.return_value);
      }
    },

    ytSetPin: function () {
      let ms = this.mSoftKey3W;
      let _this = this;

      ms.ReSet(_this.devicePath); //重置ukey
      ms.ResetOrder();//重置order
      ms.YtSetPin("111", "123", _this.devicePath)//加密

      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("sm2 ytSetPin onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("设置Pin码时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }

        // _this.secretText = UK_Data.return_value;
        console.log("成功设置了设置Pin码为 111 ： " + UK_Data.return_value);
      }
    },
    sm2EncString: function () {
      console.log("this.text = ", this.text)

      let ms = this.mSoftKey3W;
      let _this = this;

      ms.ResetOrder();//重置order
      ms.SM2_EncString(_this.text, _this.devicePath)//加密

      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("sm2 encode onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("sm2进行加密运算时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }

        _this.secretText = UK_Data.return_value;
        console.log("sm2加密成功：" + UK_Data.return_value);
      }
    },
    sm2DecString: function () {
      console.log("this.text = ", this.secretText)

      let ms = this.mSoftKey3W;
      let _this = this;

      ms.ResetOrder();//重置order
      ms.SM2_DecString(_this.secretText, "123", _this.devicePath)

      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("sm2 decode onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("sm2进行解密运算时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }

        _this.decodeText = UK_Data.return_value;
        console.log("sm2解密成功：" + UK_Data.return_value);
      }
    },

    /**
     * 生成密钥
     */
    genKeyPair : function () {
      let ms = this.mSoftKey3W;
      let _this = this;

      ms.ResetOrder();//重置order
      ms.StarGenKeyPair(_this.devicePath);
      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("生成密钥对时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }

        // _this.secretText = UK_Data.return_value;
        console.log("生成密钥对成功：" + UK_Data.return_value);

      }
    },

    genPubKeyY : function () {
      let ms = this.mSoftKey3W;
      let _this = this;

      ms.ResetOrder();//重置order
      ms.GenPubKeyY();
      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("获取GenPubKeyY时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }

        _this.PubKeyY = UK_Data.return_value;
        console.log("获取GenPubKeyY成功：" + UK_Data.return_value);

      }
    },

    genPubKeyX : function () {
      let ms = this.mSoftKey3W;
      let _this = this;

      ms.ResetOrder();//重置order
      ms.GenPubKeyX();
      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("获取GenPubKeyX时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }

        _this.PubKeyX = UK_Data.return_value;
        console.log("获取GenPubKeyX成功：" + UK_Data.return_value);

      }
    },
    genPriKey : function () {
      let ms = this.mSoftKey3W;
      let _this = this;

      ms.ResetOrder();//重置order
      ms.GenPriKey();
      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("获取GenPriKey时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }

        _this.PriKey = UK_Data.return_value;
        console.log("获取GenPriKey成功：" + UK_Data.return_value);

      }
    },

    // 设置密钥对到锁中
    setSM2KeyPair: function () {
      let ms = this.mSoftKey3W;
      let _this = this;

      ms.ResetOrder();//重置order
      ms.Set_SM2_KeyPair(_this.PriKey, _this.PubKeyX, _this.PubKeyY, _this.CompName, _this.devicePath);

      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("setSM2KeyPair onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("设置密钥对到锁中时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }

        // _this.secretText = UK_Data.return_value;
        console.log("设置密钥对到锁中成功：" + UK_Data.return_value);

      }
    },

    encode: function () {
      console.log("this.text = ", this.text)

      let ms = this.mSoftKey3W;
      let _this = this;

      ms.ResetOrder();//重置order
      ms.EncString(_this.text, _this.devicePath)//加密

      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("进行加密运算时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }

        _this.secretText = UK_Data.return_value;
        console.log("加密成功：" + UK_Data.return_value);

      }

    },
    decode: function () {
      console.log("this.secretText = ", this.secretText)

      let ms = this.mSoftKey3W;
      let _this = this;

      ms.ResetOrder();//重置order
      ms.DecString(_this.secretText, _this.secretKey)//加密
      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("进行加密运算时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }
        _this.decodeText = UK_Data.return_value;
        console.log("解密成功：" + UK_Data.return_value);
      }

    },
    login_onclick: function () {
      myLogin_onclick(this.bConnect)
    },
    getChipID: function () {
      let ms = this.mSoftKey3W;
      let _this = this;

      // ms.ResetOrder();//重置order
      ms.GetChipID(_this.devicePath)//获取唯一ID
      ms.Socket_UK.onmessage = function gotPacket(Msg) {
        console.log("onmessage Msg：" + Msg.data);
        var UK_Data = JSON.parse(Msg.data);
        if (UK_Data.type != "Process") return;

        if (UK_Data.LastError != 0) {
          window.alert("返回芯片唯一ID时出现错误，错误码为：" + UK_Data.LastError.toString());
          ms.Socket_UK.close();
          return false;
        }
        _this.ukeyId = UK_Data.return_value;
        console.log("已成功返回芯片唯一ID：" + UK_Data.return_value);
      }
    },
    /**
     * 初始化
     * @returns {boolean}
     */
    intSoftKey3A: function () {
      console.log("this实例指向： ", this)
      let _this = this;
      //如果是IE10及以下浏览器，则跳过不处理
      if (navigator.userAgent.indexOf("MSIE") > 0 && !navigator.userAgent.indexOf("opera") > -1) return;
      try {
        let mSoftKey3W = new SoftKey3W();
        _this.mSoftKey3W = mSoftKey3W;
        mSoftKey3W.Socket_UK.onopen = function () {
          _this.bConnect = 1;//代表已经连接，用于判断是否安装了客户端服务
          console.log("客户端连接")
          mSoftKey3W.FindPort(0)
        }

        //在使用事件插拨时，注意，一定不要关掉Sockey，否则无法监测事件插拨
        mSoftKey3W.Socket_UK.onmessage = function got_packet(Msg) {
          console.log("load onmessage Msg = ", Msg)
          var PnpData = JSON.parse(Msg.data);
          if (PnpData.type == "PnpEvent")//如果是插拨事件处理消息
          {
            if (PnpData.IsIn) {
              alert("UKEY已被插入，被插入的锁的路径是：" + PnpData.DevicePath);
            } else {
              alert("UKEY已被拨出，被拨出的锁的路径是：" + PnpData.DevicePath);
            }
          }

          if (PnpData.type == "Process") {
            switch (PnpData.order) {
              case 0: {
                if (PnpData.LastError != 0) {
                  window.alert("未发现加密锁，请插入加密锁");
                  ms.Socket_UK.close();
                  return false;
                }
                _this.devicePath = PnpData.return_value;//获得返回的UK的路径
                console.log("获得返回的UK的路径：" + PnpData.return_value);
              }
            }
          }
        }

        mSoftKey3W.Socket_UK.onclose = function () {

        }
      } catch (e) {
        alert(e.name + ": " + e.message);
        return false;
      }
    },

    toHex: (n) => {
      var result = ''
      var start = true;

      for (var i = 32; i > 0;) {
        i -= 4;
        var digit = (n >> i) & 0xf;

        if (!start || digit != 0) {
          start = false;
          result += digitArray[digit];
        }
      }

      return (result == '' ? '0' : result);
    }

  }
}

var digitArray = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f');

function myLogin_onclick(bConnect) {

  console.log("bConnect = ", bConnect)
  //如果是IE10及以下浏览器，则使用AVCTIVEX控件的方式
  if (navigator.userAgent.indexOf("MSIE") > 0 && !navigator.userAgent.indexOf("opera") > -1) return Handle_IE10();

  //判断是否安装了服务程序，如果没有安装提示用户安装
  if (bConnect == 0) {
    window.alert("未能连接服务程序，请确定服务程序是否安装。");
    return false;
  }
  try {
    var DevicePath, mylen, ret, keyid, username, mykey, outstring, address, mydata, i, InString, versionex,
      version;
    var PubKeyX, PubKeyY, PriKey, UserName, Pin;

    //由于是使用事件消息的方式与服务程序进行通讯，
    //好处是不用安装插件，不分系统及版本，控件也不会被拦截，同时安装服务程序后，可以立即使用，不用重启浏览器
    //不好的地方，就是但写代码会复杂一些
    var s_simnew1 = new SoftKey3W(); //创建UK类

    s_simnew1.Socket_UK.onopen = function () {
      s_simnew1.ResetOrder();//这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
    }


    //写代码时一定要注意，每调用我们的一个UKEY函数，就会生产一个计数，即增加一个序号，较好的逻辑是一个序号的消息处理中，只调用我们一个UKEY的函数
    s_simnew1.Socket_UK.onmessage = function got_packet(Msg) {
      var UK_Data = JSON.parse(Msg.data);
      if (UK_Data.type != "Process") return;//如果不是流程处理消息，则跳过
      //alert(Msg.data);
      switch (UK_Data.order) {
        case 0: {
          s_simnew1.FindPort(0);//查找加密锁
        }
          break;//!!!!!重要提示，如果在调试中，发现代码不对，一定要注意，是不是少了break,这个少了是很常见的错误
        case 1: {
          if (UK_Data.LastError != 0) {
            window.alert("未发现加密锁，请插入加密锁");
            s_simnew1.Socket_UK.close();
            return false;
          }
          DevicePath = UK_Data.return_value;//获得返回的UK的路径
          s_simnew1.GetChipID(DevicePath);//返回芯片唯一ID
        }
          break;
        case 2: {
          if (UK_Data.LastError != 0) {
            window.alert("返回芯片唯一ID时出现错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          outstring = UK_Data.return_value;
          window.alert("已成功返回芯片唯一ID：" + outstring);
          s_simnew1.YtSetPin("123", "123", DevicePath); //设置Pin码,使用默认的PIN码
        }
          break;
        case 3: {
          if (UK_Data.LastError != 0) {
            window.alert("设置Pin码时出现错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          window.alert("已成功设置了设置Pin码.");

          //对数据进行签名
          Pin = "123" //使用默认的PIN码
          s_simnew1.YtSign("加密锁", Pin, DevicePath);
        }
          break;
        case 4: {
          if (UK_Data.LastError != 0) {
            window.alert("对数据进行签名时出现错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          outstring = UK_Data.return_value;
          window.alert("已成功对数据进行签名，签名后的数据是：" + outstring);

          //对数据进行加密
          s_simnew1.SM2_EncString("加密锁", DevicePath);
        }
          break;
        case 5: {
          if (UK_Data.LastError != 0) {
            window.alert("对数据进行加密时出现错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          outstring = UK_Data.return_value;
          window.alert("已成功对数据进行加密，加密后的数据是：" + outstring);

          //对数据进行解密,使用默认的PIN码
          s_simnew1.SM2_DecString(outstring, Pin, DevicePath);
        }
          break;
        case 6: {
          if (UK_Data.LastError != 0) {
            window.alert("对数据进行解密时出现错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          outstring = UK_Data.return_value;
          window.alert("已成功对数据进行解密，解密后的数据是：" + outstring);

          //产生密钥对
          s_simnew1.StarGenKeyPair(DevicePath);
        }
          break;
        case 7: {
          if (UK_Data.LastError != 0) {
            window.alert("产生密钥对出现错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }

          //获取生成的私钥
          s_simnew1.GenPriKey();

        }
          break;
        case 8: {
          if (UK_Data.LastError != 0) {
            window.alert("获取生成的私钥时错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          PriKey = UK_Data.return_value;

          //获取生成的公钥X
          s_simnew1.GenPubKeyX();
        }
          break;
        case 9: {
          if (UK_Data.LastError != 0) {
            window.alert("获取生成的公钥X时错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          PubKeyX = UK_Data.return_value;

          //获取生成的公钥Y
          s_simnew1.GenPubKeyY();

        }
          break;
        case 10: {
          if (UK_Data.LastError != 0) {
            window.alert("获取生成的公钥Y时错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          PubKeyY = UK_Data.return_value;

          //设置密钥对及用户身份到锁中
          UserName = "xxx公司";
          s_simnew1.Set_SM2_KeyPair(PriKey, PubKeyX, PubKeyY, UserName, DevicePath);
        }
          break;
        case 11: {
          if (UK_Data.LastError != 0) {
            window.alert("设置密钥对及用户身份时出现错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          window.alert("已成功设置密钥对及用户身份.");

          //返回设置在锁中的公钥X
          s_simnew1.GetPubKeyX(DevicePath);
        }
          break;
        case 12: {
          if (UK_Data.LastError != 0) {
            window.alert("返回设置在锁中的公钥X时出现错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          outstring = UK_Data.return_value;
          window.alert("已成功返回设置在锁中的公钥X：" + outstring);

          //返回设置在锁中的公钥Y
          s_simnew1.GetPubKeyY(DevicePath);
        }
          break;
        case 13: {
          if (UK_Data.LastError != 0) {
            window.alert("返回设置在锁中的公钥Y时出现错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          outstring = UK_Data.return_value;
          window.alert("已成功返回设置在锁中的公钥Y：" + outstring);

          //返回设置在锁中的身份
          s_simnew1.GetSm2UserName(DevicePath);
        }
          break;
        case 14: {
          if (UK_Data.LastError != 0) {
            window.alert("返回设置在锁中的用户身份时出现错误，错误码为：" + UK_Data.LastError.toString());
            s_simnew1.Socket_UK.close();
            return false;
          }
          outstring = UK_Data.return_value;
          window.alert("已成功返回设置在锁中的用户身份：" + outstring);


          //所有工作处理完成后，关掉Socket
          s_simnew1.Socket_UK.close();
        }
          break;
      }
    }

    s_simnew1.Socket_UK.onclose = function () {

    }
    return true;
  } catch (e) {
    alert(e.name + ": " + e.message);
    return false;
  }

}

function Handle_IE10() {

  try {
    var DevicePath, mylen, ret, keyid, username, mykey, outstring, address, mydata, i, InString, versionex,
      version;
    var PubKeyX, PubKeyY, PriKey, UserName, Pin;

    //创建控件
    var s_simnew1 = new ActiveXObject("Syunew3A.s_simnew3");

    DevicePath = s_simnew1.FindPort(0);//'查找加密锁
    if (s_simnew1.LastError != 0) {
      window.alert("未发现加密锁，请插入加密锁");
      return false;
    } else {
      //返回芯片唯一ID
      {
        outstring = s_simnew1.GetChipID(DevicePath);
        if (s_simnew1.LastError != 0) {
          window.alert("返回芯片唯一ID时出现错误");
          return;
        }
        window.alert("已成功返回芯片唯一ID：" + outstring);
      }
      //设置Pin码
      {
        ret = s_simnew1.YtSetPin("123", "123", DevicePath);
        if (ret != 0) {
          window.alert("设置Pin码时出现错误");
          return;
        }
        window.alert("已成功设置了设置Pin码.");
      }
      //使用默认的PIN码
      Pin = "123"
      //对数据进行签名
      {
        outstring = s_simnew1.YtSign("加密锁", Pin, DevicePath);
        if (s_simnew1.LastError != 0) {
          window.alert("对数据进行签名时出现错误");
          return;
        }
        window.alert("已成功对数据进行签名：" + outstring);
      }
      //对数据进行加密
      {
        outstring = s_simnew1.SM2_EncString("加密锁", DevicePath);
        if (s_simnew1.LastError != 0) {
          window.alert("对数据进行加密时出现错误");
          return;
        }
        window.alert("已成功对数据进行加密：" + outstring);
      }
      //对数据进行解密,使用默认的PIN码
      {
        outstring = s_simnew1.SM2_DecString(outstring, Pin, DevicePath);
        if (s_simnew1.LastError != 0) {
          window.alert("对数据进行解时出现错误");
          return;
        }
        window.alert("已成功对数据进行解密：" + outstring);
      }

      //产生密钥对
      {
        ret = s_simnew1.StarGenKeyPair(DevicePath);
        if (ret != 0) {
          window.alert("产生密钥对出现错误");
          return;
        }

        PriKey = s_simnew1.GenPriKey;
        window.alert("已成功返回生成的私钥：" + PriKey);

        PubKeyX = s_simnew1.GenPubKeyX;
        window.alert("已成功返回生成的公钥X：" + PubKeyX);

        PubKeyY = s_simnew1.GenPubKeyY;
        window.alert("已成功返回生成的公钥Y：" + PubKeyY);
      }

      //对设置密钥对及用户身份
      UserName = "xxx公司";
      {
        ret = s_simnew1.Set_SM2_KeyPair(PriKey, PubKeyX, PubKeyY, UserName, DevicePath);
        if (s_simnew1.LastError != 0) {
          window.alert("设置密钥对及用户身份时出现错误");
          return;
        }
        window.alert("已成功设置密钥对及用户身份.");
      }
      //返回设置在锁中的公钥X
      {
        outstring = s_simnew1.GetPubKeyX(DevicePath);
        if (s_simnew1.LastError != 0) {
          window.alert("返回设置在锁中的公钥X时出现错误");
          return;
        }
        window.alert("已成功返回设置在锁中的公钥X：" + outstring);
      }
      //返回设置在锁中的公钥Y
      {
        outstring = s_simnew1.GetPubKeyY(DevicePath);
        if (s_simnew1.LastError != 0) {
          window.alert("返回设置在锁中的公钥Y时出现错误");
          return;
        }
        window.alert("已成功返回设置在锁中的公钥Y：" + outstring);
      }
      //返回设置在锁中的身份
      {
        outstring = s_simnew1.GetSm2UserName(DevicePath);
        if (s_simnew1.LastError != 0) {
          window.alert("返回设置在锁中的身份时出现错误");
          return;
        }
        window.alert("已成功返回设置在锁中的身份：" + outstring);
      }

    }
    return true;
  } catch (e) {
    alert(e.name + ": " + e.message);
    return false;
  }
}


</script>

<!-- Add "scoped" attribute to limit CSS to this component only -->
<style scoped>
h1, h2 {
  font-weight: normal;
}

ul {
  list-style-type: none;
  padding: 0;
}

li {
  display: inline-block;
  margin: 0 10px;
}

a {
  color: #42b983;
}

.input-class {
  width: 200px;
  position: relative;
  padding-left: 15px;
}
</style>

 

 

源码：https://download.csdn.net/download/shn_207/87593876

 

shn_207
关注
vue项目中对USB检测
weixin_44635214的博客
09-14 3631
usb-detection 使您可以侦听系统上USB设备的插入/删除事件。 安装 npm install usb-detection 使用 var usbDetect = require('usb-detection'); //开始监听USB添加/删除/更改事件。这将导致Node.js进程保持打开状态直到您调用usbDetect.stopMonitoring() usbDetect.startMonitoring(); // 检测添加/插入 usbDetect.on('add', function(
VueSerial的usb.json
09-23
VueSerial的usb.json,内容太多，文章对字数限制了，就放这里了
如何检测U盘插入拔出？
Leo is BACK!
01-17 1181
windows检测到设备变更后，会给所有程序主窗口发送 WM_DEVICECHANGE 消息。BOOL CUManageAppsDlg::OnDeviceChange(UINT nEventType, DWORD dwData){         if( nEventType == 36768)   //u盘插入         else if (nEventType == 327
VUE项目与原生Javascript Js功能模块的整合-政府项目涉及Ukey使用和开发
最新发布
本博客记录了从2014年以来在工作学习中遇到的技术问题、解决方法以及部分个人人生经历、经验等内容。
10-09 1468
我在使用第三方厂商的 SetOnUsbKeyChangeCallBack UKEY证书的拔出 回调时尝试了很多次，在登录界面可行、在登录之后的页面框架层也加载了这个拔出触发JS操作，但就是奇怪总是出现开始能检测后来又检测不了的情况，可能是我的JS有问题吧，但也没有排查出问题，这些教程我都记不得太多了，因为用户拔出主要涉及用户的本地存储sessionStorage的清理，但总是调用 VUE的 sessionStorage出现问题。Ukey 的js代码与项目的整合，如果原来就是纯原生的JS就相对较方便整合。
Vue+RPC服务实现用户登录UKEY认证
weixin_44600358的博客
01-29 4275
什么是RPC服务： 全名Remote Procedure Call，远程过程调用， RPC与http的区别： RPC主要是基于TCP/IP协议的，而HTTP服务主要是基于HTTP协议的，我们都知道HTTP协议是在传输层协议TCP之上的，所以效率来看的话，RPC当然是要更胜一筹 RPC架构里面包含了四个核心的组件： 客户端（Client），服务的调用方。 服务端（Server），真正的服务提供者。 客户端存根，存放服务端的地址消息，再将客户端的请求参数打包成网络消息，然后通过网络远程发送给服务方
UKEY开发，vue+websocket实现用户登录UKEY认证
热门推荐
qq_41756580的博客
04-24 1万+
首先，在开始开发之前，先了解一下UKEY的用户登录流程，我前面整理了一些登录的流程： 点这里查看登录流程：传送门 OK，了解了登录流程，我们来开始看看在vue中是怎么样进行实际的开发的。 首先你需要在导航收尾中初始化websocket的连接: router.beforeEach((to, from, next) => { // 初始化后后能够监听UKEY拔插事件 ...
简单一个VUE 集成USB READER 读卡器
Zihuatanjo
01-15 4412
后台管理 vue-elment-admin 表格库vxe-table2.9表格操作区域=>点击取卡=>弹框=>刷卡=>赋值弹框内的input这个东西演示(虚假数据,演示用途)
vue2前端监听usb
fxshy的博客
08-02 867
在 Vue2 前端应用中监听 USB 设备的插入和拔出事件，可以使用浏览器提供的 WebUSB API。这需要运行在支持 WebUSB API 的浏览器上，并且用户需要授予相应的权限。以下是一个示例，展示如何在 Vue2 项目中监听 USB 设备的插入和拔出事件。
SpringBoot+Vue开发的USB KEY管理系统源码及文档
Vue.js的核心库只关注视图层，易于上手，同时它也能够驱动与单文件组件和Vue生态系统中的其他库一起使用。 4. ASP：ASP(Active Server Pages)是一种用于创建动态交互式网页的服务端脚本环境，可以用来创建交互式、...
Vue项目集成UKEY3000D实现加解密与接口交互
本demo提供了一个使用Vue框架搭建的前端环境，演示了如何通过该环境与UKEY设备进行交互，包括获取UKEY的唯一编码、设置账号密码以及使用SM2算法进行安全操作。此外，该UKEY提供了接口交互和websocket两种通信方式。...
使用vue写一个使用USB key 和 密码的登陆页面前端代码
04-14
好的，让我来帮您解答这个问题。下面是一个简单的使用vue实现USB key和密码登陆的前端代码示例： ```vue ... ...此外，根据您的具体需求，您可能需要使用一些javascript库来与USB key进行交互。
UKey-开源
05-13
UKey是开源加密工具TrueCrypt的扩展。 使用UKey，您可以将USB密钥用作TrueCrypt的替换密码。 目前，该项目处于“概念验证”状态，这意味着它确实可以工作，但并不意味着日常使用。
加密锁驱动UKEY3000D
11-17
加密锁驱动UKEY3000 兼容chrome，IE，火狐等浏览器,，支持c#,c++引用,包含全部手册
vue项目使用ukey，可操作ukey，实现需要的功能
03-20
使用vue的架子，可以获取ukey的唯一编码； 可以设置ukey的账号密码，自动获取账号密码。 可以设置加密密钥，使用加密密钥进行加解密。 UKEY3000D内置了国密SM2算法，可以生成密钥对，使用密钥对进行加解密，签名验签...
使用vue写一个使用USB key 和 密码的登陆页面
04-14
要实现USB key和密码的登录页面，您需要使用一个vue插件，该插件可以访问用户计算机上的USB驱动器并与其进行交互。您还可以利用JavaScript的Crypto API来生成并验证用户密码的哈希值。最后，您可以使用vue路由器来...
前端获取usb串口，实现电子秤的对接
weixin_46166771的博客
05-30 5276
纯vue 获取usb串口，实现电子秤的对接
Vue中监听USB扫码枪触发操作
acheng
03-31 2865
/ docNum 查询单据号对应的审批信息并弹出，如果没有找到信息或者单号不符合规则 则不弹出。//console.log('触发时间', lastScanTime,now);console.log('扫描到的内容是：', scanContent);// 如果最后更新时间与上次时间一致则说明没有再此更新。console.log('扫描到的内容是：', docNum);// 查询单号在不在代办任务中，不在则提示没有权限。// 扫描事件已经结束。// 正常的键盘输入。// 扫描事件正在进行中。
vue2.0和3.0区别_USB2.0和USB3.0的区别和优点
weixin_39798497的博客
12-11 309
前几天有粉丝问我USB2.0和USB3.0有哪些区别和优点，下面做下介绍。USB 2.0：2000年发布的USB接口标准，理论上，usb2.0的传输速率为480Mbps，即60MB/s，最大输出电流0.5A。usb2.0一般是白色或者黑色接口，usb2.0接口线为5根。USB 2.0是最常见的USB接口，基本上所有的电脑上都有USB 2.0接口，大部分的USB设备都支持USB 2.0。USB 3....
vue3 i18n 动态获取key的方法
ana_9717的博客
02-09 1034
vue3 使用i18n
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值