提交内容

whychdw

2021-08-10 7faa0d850e70a22c4191a231fa5be446e284e678

提交内容

 nfdw_stand/WebRoot/classes/WEB-INF/lib/Linux-SO/64λµÄʹÓÃ˵Ã÷.txt

New file
@@ -0,0 +1,2 @@
1、将libJsyunew3_64.so æ‹·åˆ°LIB64下就可以了


 nfdw_stand/WebRoot/classes/WEB-INF/lib/Linux-SO/LinuxȨÏÞ˵Ã÷.txt

New file
@@ -0,0 +1,13 @@
加密狗需要在SU权限下运行才可以识别，如果在普通用户权限下使用加密狗，需要进行以下操作：
放一个相应的规则文件到以下文件夹下： /etc/udev/rules.d.
文件内容如下：
SUBSYSTEM=="input", GROUP="input", MODE="0666"
SUBSYSTEM=="usb", ATTRS{idVendor}=="3689", ATTRS{idProduct}=="8762", MODE:="666", GROUP="plugdev"
KERNEL=="hidraw*", ATTRS{idVendor}=="3689", ATTRS{idProduct}=="8762", MODE="0666", GROUP="plugdev"

将以上的内容保存为一个新的文件例如：
 /etc/udev/rules.d/51-blink1.rules
然后拨出设备，运行以下命令就可以了：
sudo udevadm control --reload-rules

注意，加密狗设备的PID及VID一定要是16进制及小写，

 nfdw_stand/WebRoot/classes/WEB-INF/lib/Linux-SO/libJsyunew3.so

Binary files differ

 nfdw_stand/WebRoot/classes/WEB-INF/lib/Linux-SO/libJsyunew3_64.so

Binary files differ

 nfdw_stand/WebRoot/classes/WEB-INF/lib/Linux-SO/ʹÓÃ˵Ã÷.txt

New file
@@ -0,0 +1,6 @@
1、将libJsyunew3.so拷到库目录下，库目录可以用如下命令打印出来 ï¼šSystem.out.println(System.getProperty("java.library.path"));
2、在com->softkey目录下，有对应的jsyunew3.java
3、包名必须为com.softkey，这点一定要注意




 nfdw_stand/WebRoot/classes/WEB-INF/lib/dll/Jsyunew3.dll

Binary files differ

 nfdw_stand/WebRoot/classes/WEB-INF/lib/dll/Jsyunew3_64.dll

Binary files differ

 nfdw_stand/WebRoot/classes/com/fgkj/actions/LoginAction.class

Binary files differ

 nfdw_stand/WebRoot/classes/com/fgkj/dao/impl/User_infImpl$19.class

Binary files differ

 nfdw_stand/WebRoot/classes/com/fgkj/dao/impl/User_infImpl.class

Binary files differ

 nfdw_stand/WebRoot/classes/com/fgkj/dto/SignDTO.class

Binary files differ

 nfdw_stand/WebRoot/classes/com/softkey/jsyunew3.class

Binary files differ

 nfdw_stand/WebRoot/classes/js/SoftUKey.js

New file
@@ -0,0 +1,282 @@
function SoftUKey(SoftKey3W) {
    this.SoftKey3W = SoftKey3W;
}

/**
 * uKey写入用户名
 * @param userName ç”¨æˆ·å
 * @param callback å›žè°ƒå‡½æ•°
 */
SoftUKey.prototype.setUserName = function (userName, callback) {
    try {
        let s_simnew1 = new this.SoftKey3W();     //创建UKç±»
        let DevicePath, PriKey, PubKeyX, PubKeyY;
        // å¼€å¯ç›‘听
        s_simnew1.Socket_UK.onopen = function() {
            s_simnew1.ResetOrder();//这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
        }

        // ç›‘听获取到的信息
        s_simnew1.Socket_UK.onmessage = function(Msg) {
            let UK_Data = JSON.parse(Msg.data);
            if(UK_Data.type!="Process")return ;//如果不是流程处理消息，则跳过

            // æ ¹æ®æ”¶åˆ°çš„序号执行函数
            switch(UK_Data.order) {
                case 0:
                    s_simnew1.FindPort(0); //发送命令取UK的路径
                    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.StarGenKeyPair(DevicePath);
                    break;
                case 2:
                    if(UK_Data.LastError!=0){
                        window.alert("产生密钥对出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }

                    //获取生成的私钥
                    s_simnew1.GenPriKey();
                    break;
                case 3:
                    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 4:
                    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 5:
                    if(UK_Data.LastError!=0){
                        window.alert("获取生成的公钥Y时错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    PubKeyY = UK_Data.return_value;

                    //设置密钥对及用户身份到锁中
                    s_simnew1.Set_SM2_KeyPair(PriKey,PubKeyX,PubKeyY,userName,DevicePath);
                    break;
                case 6:
                    if(UK_Data.LastError!=0){
                        window.alert("设置密钥对及用户身份时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    // æ‰§è¡Œå›žè°ƒå‡½æ•°
                    if(typeof callback == 'function') {
                        callback({
                            PriKey,
                            PubKeyX,
                            PubKeyY,
                            userName,
                            DevicePath
                        });
                    }

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

        // å…³é—­ç›‘听
        s_simnew1.Socket_UK.onclose = function() {
            console.log("关闭设置用户名称")
        }
        return true;
    }catch(e) {
        console.log("设置用户名称异常："+e);
    }
}

/**
 * è¯»å–uKey中的用户名
 * @param callback
 * @return {boolean}
 */
SoftUKey.prototype.getUserName = function(callback) {
    try {
        let s_simnew1 = new this.SoftKey3W();     //创建UKç±»
        let DevicePath, userName;
        // å¼€å¯ç›‘听
        s_simnew1.Socket_UK.onopen = function() {
            s_simnew1.ResetOrder();//这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
        }

        // ç›‘听获取到的信息
        s_simnew1.Socket_UK.onmessage = function(Msg) {
            let UK_Data = JSON.parse(Msg.data);
            if(UK_Data.type!="Process")return ;//如果不是流程处理消息，则跳过

            // æ ¹æ®æ”¶åˆ°çš„序号执行函数
            switch(UK_Data.order) {
                case 0:
                    s_simnew1.FindPort(0); //发送命令取UK的路径
                    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.GetSm2UserName(DevicePath);
                    break;
                case 2:
                    if(UK_Data.LastError!=0){
                        window.alert("返回设置在锁中的用户身份时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    userName = UK_Data.return_value;

                    // æ‰§è¡Œå›žè°ƒå‡½æ•°
                    if(typeof callback == 'function') {
                        callback({
                            userName,
                        });
                    }

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

        // å…³é—­ç›‘听
        s_simnew1.Socket_UK.onclose = function() {
            console.log("关闭读取用户名称")
        }
        return true;
    }catch (e) {
        console.log("读取用户名称异常："+e);
    }
}
/**
 * èŽ·å–ukey的签名
 * @param randomNumber
 * @param callback
 */
SoftUKey.prototype.getSign = function(randomNumber, callback) {
    try {
        let s_simnew1 = new this.SoftKey3W();     //创建UKç±»
        let inPath, sign, uKeyId, publicX, publicY;
        // å¼€å¯ç›‘听
        s_simnew1.Socket_UK.onopen = function() {
            s_simnew1.ResetOrder();//这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
        }

        // ç›‘听获取到的信息
        s_simnew1.Socket_UK.onmessage = function(Msg) {
            let UK_Data = JSON.parse(Msg.data);
            if(UK_Data.type!="Process")return ;//如果不是流程处理消息，则跳过

            // æ ¹æ®æ”¶åˆ°çš„序号执行函数
            switch(UK_Data.order) {
                case 0:
                    s_simnew1.FindPort(0); //发送命令取UK的路径
                    break;
                case 1:
                    if(UK_Data.LastError!=0) {
                        window.alert ( "未发现加密锁，请插入加密锁");
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    // è®¾ç½®è·¯å¾„
                    inPath=UK_Data.return_value;//获得返回的UK的路径

                    s_simnew1.GetChipID(inPath);//返回芯片唯一ID
                    break;
                case 2:
                    if(UK_Data.LastError!=0){
                        window.alert("返回芯片唯一ID时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    uKeyId = UK_Data.return_value;

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

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

                    // å¯¹æ•°æ®è¿›è¡Œç­¾å
                    s_simnew1.YtSign(randomNumber,"123", inPath);
                    break;
                case 5:
                    if(UK_Data.LastError!=0){
                        window.alert("对数据进行签名时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    sign = UK_Data.return_value;

                    // æ‰§è¡Œå›žè°ƒå‡½æ•°
                    if(typeof callback == 'function') {
                        callback({
                            inPath,
                            sign,
                            uKeyId,
                            publicX,
                            publicY,
                        });
                    }

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

        // å…³é—­ç›‘听
        s_simnew1.Socket_UK.onclose = function() {
            console.log("关闭获取签名")
        }
    }catch (e) {
        console.log("获取签名异常："+e)
    }
}

 nfdw_stand/WebRoot/classes/login.jsp

@@ -213,6 +213,7 @@
<script type="text/javascript" src="js/MD5.js"></script>
<script type="text/javascript" src="iview/js/common.js"></script>
<script type="text/javascript" src="ukey/Syunew3.js"></script>
<script type="text/javascript" src="js/SoftUKey.js"></script>
<script type="text/javascript">
    // èŽ·å–历史记录的登陆用户信息
    var uname = '<%=uname%>';
@@ -236,7 +237,8 @@
                UPubKeyX:'',
                UPubKeyY: '',
                UKey_ID: '',
                UName: ''
                UName: '',
                UPriKey: '',
            },
            guest: {
                UName: 'guest',
@@ -268,9 +270,10 @@
                timer02: new Timeout(),
                hCookie: new HCookie(),
                stream: '',
            }
            },
      // ukey对应的用户的登录方式 1为用户名密码 2为人脸
      ,login_type: 1
            login_type: 1,
            softUKey: new SoftUKey(SoftKey3W)
        },
        watch: {
            userfocus: function() {
@@ -284,7 +287,7 @@
            },
            bConnect: function(value) {
                this.bindingUkey.current = value?1:0;
            }
            },
        },
        methods: {
            initDBpool: function(){
@@ -312,11 +315,56 @@
                // è¿›å…¥é¦–页
                window.location.href = page;
            },
            getRandomFromServer() {
                let self = this;
                $.ajax({
                    type: 'post',
                    url: 'LoginAction_getRandom',
                    data: null,
                    success: function(res) {
                        console.log(res);
                        let rs = JSON.parse(res.result);
                        if(rs.code == 1) {
                            let randomNumber = rs.data;
                            console.log(self.softUKey);
                            self.softUKey.getSign(randomNumber, self.checkUKeySign);
                        }else {
                            self.$message.error("服务器连接异常！");
                        }
                    },
                    error: function(error) {
                        console.log(error);
                    },
                });
            },
            checkUKeySign(result) {
                let reg = new RegExp("&", "g");
                result.inPath = result.inPath.replace(reg, "%26");
                result.inPath = result.inPath.replace(/\\/g, "huodongwei");
                let self = this;
                $.ajax({
                    type: 'post',
                    url: 'LoginAction_verify',
                    data: 'json='+JSON.stringify(result),
                    success: function(res) {
                        let rs = JSON.parse(res.result);
                        if(rs.code == 1) {
                            self.checkUser();
                        }else {
                            self.msg = rs.msg;
                        }
                    },
                    error: function(error) {
                        self.msg = "uKey验签校验失败！";
                        console.log(error);
                    },
                });
            },
            showVerify: function() {
                if(this.info.name.trim() && this.info.password.trim()
                        && this.bConnect) {     // æ£€æµ‹ç”¨æˆ·å,密码,ukey状态
                    // æ˜¾ç¤ºéªŒè¯å›¾æ¡ˆ
                    this.checkUser();
                    this.getRandomFromServer();
                }else if(!this.bConnect) {
                    this.msg = 'ukey未插入';
                }else if(!this.info.UKey_ID.trim()){
@@ -343,6 +391,10 @@
                            // è¿›å…¥é¦–页
                            //self.toIndex(rs.msg);
                            self.login_type = 2;
                            self.$Message.message('success', {
                                content: '静态密码验证成功',
                                duration: 3
                            });
                        }else {
                            self.msg = rs.msg;
                            if (rs.data) {
@@ -889,7 +941,87 @@
                        self.face.detect = "网络连接失败！";
                    }
                });
            },
            getPriKey() {
                var self = this;
                //判断是否安装了服务程序，如果没有安装提示用户安装
                if(this.bConnect==0)
                {
                    window.alert ("未能连接服务程序，请确定服务程序是否安装。");return false;
            }
                try{
                    var DevicePath;
                    var s_simnew1=new SoftKey3W(); //创建UKç±»
                    s_simnew1.Socket_UK.onopen = function() {
                        s_simnew1.ResetOrder(); //这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
                    }
                    s_simnew1.Socket_UK.onmessage =function got_packet(Msg) {
                        var UK_Data = JSON.parse(Msg.data);
                        if(UK_Data.type!="Process") return ;//如果不是流程处理消息，则跳过
                        switch(UK_Data.order)
                        {
                            case 0: {
                                s_simnew1.FindPort(0); //发送命令取UK的路径
                            }
                                break;//!!!!!重要提示，如果在调试中，发现代码不对，一定要注意，是不是少了break,这个少了是很常见的错误
                            case 1: {
                                if(UK_Data.LastError!=0){self.bConnect=false;s_simnew1.Socket_UK.close();return false;}
                                DevicePath=UK_Data.return_value;//获得返回的UK的路径
                                console.log(DevicePath)
                                s_simnew1.GetChipID(DevicePath); //发送命令取UK的版本
                            }
                                break;
                            case 2: {
                                if( UK_Data.LastError!=0){window.alert ("获取加密锁ID失败");s_simnew1.Socket_UK.close();return false;}
                                console.log(UK_Data);
                                self.info.UKey_ID = UK_Data.return_value;
                                // ukey的信息
                                self.ukey.UKey_ID = UK_Data.return_value;
                                s_simnew1.StarGenKeyPair(DevicePath);
                            }
                                break;
                            case 3:
                            {
                                if( UK_Data.LastError!=0){window.alert ("获取加密锁ID失败");s_simnew1.Socket_UK.close();return false;}
                                s_simnew1.GetPubKeyX(DevicePath);
                            }
                                break;
                            case 4:
                            {
                                if( UK_Data.LastError!=0){window.alert ( "获取加密锁X失败");s_simnew1.Socket_UK.close();return false;}
                                console.log(UK_Data);
                                self.ukey.UPubKeyX = UK_Data.return_value;
                                s_simnew1.GetPubKeyY(DevicePath);
                            }
                                break;
                            case 5:
                            {
                                if( UK_Data.LastError!=0){window.alert ( "获取加密锁Y失败");s_simnew1.Socket_UK.close();return false;}
                                console.log(UK_Data);
                                self.ukey.UPubKeyY = UK_Data.return_value;
                                s_simnew1.GenPriKey();
                            }
                                break;
                            case 6:
                            {
                                if( UK_Data.LastError!=0){window.alert ( "获取加密锁私钥失败");s_simnew1.Socket_UK.close();return false;}
                                console.log(UK_Data);
                                //self.ukey.UPriKey =
                                //所有工作处理完成后，关掉Socket
                                s_simnew1.Socket_UK.close();
                            }
                                break;
                        }
                    }
                    s_simnew1.Socket_UK.onclose = function(){
                        console.log("结束获取uKey私钥");
                    }
                    return true;
                }catch(e) {

                }

            },
        },
        computed: {
            userColor: function() {

 nfdw_stand/WebRoot/js/SoftUKey.js

New file
@@ -0,0 +1,282 @@
function SoftUKey(SoftKey3W) {
    this.SoftKey3W = SoftKey3W;
}

/**
 * uKey写入用户名
 * @param userName ç”¨æˆ·å
 * @param callback å›žè°ƒå‡½æ•°
 */
SoftUKey.prototype.setUserName = function (userName, callback) {
    try {
        let s_simnew1 = new this.SoftKey3W();     //创建UKç±»
        let DevicePath, PriKey, PubKeyX, PubKeyY;
        // å¼€å¯ç›‘听
        s_simnew1.Socket_UK.onopen = function() {
            s_simnew1.ResetOrder();//这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
        }

        // ç›‘听获取到的信息
        s_simnew1.Socket_UK.onmessage = function(Msg) {
            let UK_Data = JSON.parse(Msg.data);
            if(UK_Data.type!="Process")return ;//如果不是流程处理消息，则跳过

            // æ ¹æ®æ”¶åˆ°çš„序号执行函数
            switch(UK_Data.order) {
                case 0:
                    s_simnew1.FindPort(0); //发送命令取UK的路径
                    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.StarGenKeyPair(DevicePath);
                    break;
                case 2:
                    if(UK_Data.LastError!=0){
                        window.alert("产生密钥对出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }

                    //获取生成的私钥
                    s_simnew1.GenPriKey();
                    break;
                case 3:
                    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 4:
                    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 5:
                    if(UK_Data.LastError!=0){
                        window.alert("获取生成的公钥Y时错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    PubKeyY = UK_Data.return_value;

                    //设置密钥对及用户身份到锁中
                    s_simnew1.Set_SM2_KeyPair(PriKey,PubKeyX,PubKeyY,userName,DevicePath);
                    break;
                case 6:
                    if(UK_Data.LastError!=0){
                        window.alert("设置密钥对及用户身份时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    // æ‰§è¡Œå›žè°ƒå‡½æ•°
                    if(typeof callback == 'function') {
                        callback({
                            PriKey,
                            PubKeyX,
                            PubKeyY,
                            userName,
                            DevicePath
                        });
                    }

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

        // å…³é—­ç›‘听
        s_simnew1.Socket_UK.onclose = function() {
            console.log("关闭设置用户名称")
        }
        return true;
    }catch(e) {
        console.log("设置用户名称异常："+e);
    }
}

/**
 * è¯»å–uKey中的用户名
 * @param callback
 * @return {boolean}
 */
SoftUKey.prototype.getUserName = function(callback) {
    try {
        let s_simnew1 = new this.SoftKey3W();     //创建UKç±»
        let DevicePath, userName;
        // å¼€å¯ç›‘听
        s_simnew1.Socket_UK.onopen = function() {
            s_simnew1.ResetOrder();//这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
        }

        // ç›‘听获取到的信息
        s_simnew1.Socket_UK.onmessage = function(Msg) {
            let UK_Data = JSON.parse(Msg.data);
            if(UK_Data.type!="Process")return ;//如果不是流程处理消息，则跳过

            // æ ¹æ®æ”¶åˆ°çš„序号执行函数
            switch(UK_Data.order) {
                case 0:
                    s_simnew1.FindPort(0); //发送命令取UK的路径
                    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.GetSm2UserName(DevicePath);
                    break;
                case 2:
                    if(UK_Data.LastError!=0){
                        window.alert("返回设置在锁中的用户身份时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    userName = UK_Data.return_value;

                    // æ‰§è¡Œå›žè°ƒå‡½æ•°
                    if(typeof callback == 'function') {
                        callback({
                            userName,
                        });
                    }

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

        // å…³é—­ç›‘听
        s_simnew1.Socket_UK.onclose = function() {
            console.log("关闭读取用户名称")
        }
        return true;
    }catch (e) {
        console.log("读取用户名称异常："+e);
    }
}
/**
 * èŽ·å–ukey的签名
 * @param randomNumber
 * @param callback
 */
SoftUKey.prototype.getSign = function(randomNumber, callback) {
    try {
        let s_simnew1 = new this.SoftKey3W();     //创建UKç±»
        let inPath, sign, uKeyId, publicX, publicY;
        // å¼€å¯ç›‘听
        s_simnew1.Socket_UK.onopen = function() {
            s_simnew1.ResetOrder();//这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
        }

        // ç›‘听获取到的信息
        s_simnew1.Socket_UK.onmessage = function(Msg) {
            let UK_Data = JSON.parse(Msg.data);
            if(UK_Data.type!="Process")return ;//如果不是流程处理消息，则跳过

            // æ ¹æ®æ”¶åˆ°çš„序号执行函数
            switch(UK_Data.order) {
                case 0:
                    s_simnew1.FindPort(0); //发送命令取UK的路径
                    break;
                case 1:
                    if(UK_Data.LastError!=0) {
                        window.alert ( "未发现加密锁，请插入加密锁");
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    // è®¾ç½®è·¯å¾„
                    inPath=UK_Data.return_value;//获得返回的UK的路径

                    s_simnew1.GetChipID(inPath);//返回芯片唯一ID
                    break;
                case 2:
                    if(UK_Data.LastError!=0){
                        window.alert("返回芯片唯一ID时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    uKeyId = UK_Data.return_value;

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

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

                    // å¯¹æ•°æ®è¿›è¡Œç­¾å
                    s_simnew1.YtSign(randomNumber,"123", inPath);
                    break;
                case 5:
                    if(UK_Data.LastError!=0){
                        window.alert("对数据进行签名时出现错误，错误码为："+UK_Data.LastError.toString());
                        s_simnew1.Socket_UK.close();
                        return false;
                    }
                    sign = UK_Data.return_value;

                    // æ‰§è¡Œå›žè°ƒå‡½æ•°
                    if(typeof callback == 'function') {
                        callback({
                            inPath,
                            sign,
                            uKeyId,
                            publicX,
                            publicY,
                        });
                    }

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

        // å…³é—­ç›‘听
        s_simnew1.Socket_UK.onclose = function() {
            console.log("关闭获取签名")
        }
    }catch (e) {
        console.log("获取签名异常："+e)
    }
}

 nfdw_stand/WebRoot/login.jsp

@@ -213,6 +213,7 @@
<script type="text/javascript" src="js/MD5.js"></script>
<script type="text/javascript" src="iview/js/common.js"></script>
<script type="text/javascript" src="ukey/Syunew3.js"></script>
<script type="text/javascript" src="js/SoftUKey.js"></script>
<script type="text/javascript">
    // èŽ·å–历史记录的登陆用户信息
    var uname = '<%=uname%>';
@@ -236,7 +237,8 @@
                UPubKeyX:'',
                UPubKeyY: '',
                UKey_ID: '',
                UName: ''
                UName: '',
                UPriKey: '',
            },
            guest: {
                UName: 'guest',
@@ -268,9 +270,10 @@
                timer02: new Timeout(),
                hCookie: new HCookie(),
                stream: '',
            }
            },
      // ukey对应的用户的登录方式 1为用户名密码 2为人脸
      ,login_type: 1
            login_type: 1,
            softUKey: new SoftUKey(SoftKey3W)
        },
        watch: {
            userfocus: function() {
@@ -284,7 +287,7 @@
            },
            bConnect: function(value) {
                this.bindingUkey.current = value?1:0;
            }
            },
        },
        methods: {
            initDBpool: function(){
@@ -312,11 +315,56 @@
                // è¿›å…¥é¦–页
                window.location.href = page;
            },
            getRandomFromServer() {
                let self = this;
                $.ajax({
                    type: 'post',
                    url: 'LoginAction_getRandom',
                    data: null,
                    success: function(res) {
                        console.log(res);
                        let rs = JSON.parse(res.result);
                        if(rs.code == 1) {
                            let randomNumber = rs.data;
                            console.log(self.softUKey);
                            self.softUKey.getSign(randomNumber, self.checkUKeySign);
                        }else {
                            self.$message.error("服务器连接异常！");
                        }
                    },
                    error: function(error) {
                        console.log(error);
                    },
                });
            },
            checkUKeySign(result) {
                let reg = new RegExp("&", "g");
                result.inPath = result.inPath.replace(reg, "%26");
                result.inPath = result.inPath.replace(/\\/g, "huodongwei");
                let self = this;
                $.ajax({
                    type: 'post',
                    url: 'LoginAction_verify',
                    data: 'json='+JSON.stringify(result),
                    success: function(res) {
                        let rs = JSON.parse(res.result);
                        if(rs.code == 1) {
                            self.checkUser();
                        }else {
                            self.msg = rs.msg;
                        }
                    },
                    error: function(error) {
                        self.msg = "uKey验签校验失败！";
                        console.log(error);
                    },
                });
            },
            showVerify: function() {
                if(this.info.name.trim() && this.info.password.trim()
                        && this.bConnect) {     // æ£€æµ‹ç”¨æˆ·å,密码,ukey状态
                    // æ˜¾ç¤ºéªŒè¯å›¾æ¡ˆ
                    this.checkUser();
                    this.getRandomFromServer();
                }else if(!this.bConnect) {
                    this.msg = 'ukey未插入';
                }else if(!this.info.UKey_ID.trim()){
@@ -893,7 +941,87 @@
                        self.face.detect = "网络连接失败！";
                    }
                });
            },
            getPriKey() {
                var self = this;
                //判断是否安装了服务程序，如果没有安装提示用户安装
                if(this.bConnect==0)
                {
                    window.alert ("未能连接服务程序，请确定服务程序是否安装。");return false;
            }
                try{
                    var DevicePath;
                    var s_simnew1=new SoftKey3W(); //创建UKç±»
                    s_simnew1.Socket_UK.onopen = function() {
                        s_simnew1.ResetOrder(); //这里调用ResetOrder将计数清零，这样，消息处理处就会收到0序号的消息，通过计数及序号的方式，从而生产流程
                    }
                    s_simnew1.Socket_UK.onmessage =function got_packet(Msg) {
                        var UK_Data = JSON.parse(Msg.data);
                        if(UK_Data.type!="Process") return ;//如果不是流程处理消息，则跳过
                        switch(UK_Data.order)
                        {
                            case 0: {
                                s_simnew1.FindPort(0); //发送命令取UK的路径
                            }
                                break;//!!!!!重要提示，如果在调试中，发现代码不对，一定要注意，是不是少了break,这个少了是很常见的错误
                            case 1: {
                                if(UK_Data.LastError!=0){self.bConnect=false;s_simnew1.Socket_UK.close();return false;}
                                DevicePath=UK_Data.return_value;//获得返回的UK的路径
                                console.log(DevicePath)
                                s_simnew1.GetChipID(DevicePath); //发送命令取UK的版本
                            }
                                break;
                            case 2: {
                                if( UK_Data.LastError!=0){window.alert ("获取加密锁ID失败");s_simnew1.Socket_UK.close();return false;}
                                console.log(UK_Data);
                                self.info.UKey_ID = UK_Data.return_value;
                                // ukey的信息
                                self.ukey.UKey_ID = UK_Data.return_value;
                                s_simnew1.StarGenKeyPair(DevicePath);
                            }
                                break;
                            case 3:
                            {
                                if( UK_Data.LastError!=0){window.alert ("获取加密锁ID失败");s_simnew1.Socket_UK.close();return false;}
                                s_simnew1.GetPubKeyX(DevicePath);
                            }
                                break;
                            case 4:
                            {
                                if( UK_Data.LastError!=0){window.alert ( "获取加密锁X失败");s_simnew1.Socket_UK.close();return false;}
                                console.log(UK_Data);
                                self.ukey.UPubKeyX = UK_Data.return_value;
                                s_simnew1.GetPubKeyY(DevicePath);
                            }
                                break;
                            case 5:
                            {
                                if( UK_Data.LastError!=0){window.alert ( "获取加密锁Y失败");s_simnew1.Socket_UK.close();return false;}
                                console.log(UK_Data);
                                self.ukey.UPubKeyY = UK_Data.return_value;
                                s_simnew1.GenPriKey();
                            }
                                break;
                            case 6:
                            {
                                if( UK_Data.LastError!=0){window.alert ( "获取加密锁私钥失败");s_simnew1.Socket_UK.close();return false;}
                                console.log(UK_Data);
                                //self.ukey.UPriKey =
                                //所有工作处理完成后，关掉Socket
                                s_simnew1.Socket_UK.close();
                            }
                                break;
                        }
                    }
                    s_simnew1.Socket_UK.onclose = function(){
                        console.log("结束获取uKey私钥");
                    }
                    return true;
                }catch(e) {

                }

            },
        },
        computed: {
            userColor: function() {