`
zzc1684
  • 浏览: 1228252 次
  • 性别: Icon_minigender_1
  • 来自: 广州
文章分类
社区版块
存档分类
最新评论

关于使用JS前台加密、JAVA后台解密的RSA实现,RSA加密和签名

阅读更多

实现:

用RSA非对称加密方式实现。后台生成rsa密钥对,然后在登陆页面设置rsa公钥,提交时用公钥加密密码,生成的密文传到后台,用私钥解密,获取密码明文。

这样客户端只需要知道rsa加密方式和公钥,前台不知道私钥是无法解密的,此解决方案还是相对比较安全的。

附件是参照网友资料的java+JS的实现,放在这里供大家下载。访问方式/RSA/login.jsp。

需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar文件。

因为后台要转换成bigint,所以对明文长度有些限制:

总长度不超过126(1汉字长度为9),如下两个字符串:

阿送大法散得阿送大法散得阿送
1232132131231231232131232K1232132131231231232131232K1232132131231231232131232K1232132131231231232131232K1234567890123456789012

 

 

RSA速度 
 * 由于进行的都是大数计算,使得RSA最快的情况也比DES慢上100倍,无论 是软件还是硬件实现。 
 * 速度一直是RSA的缺陷。一般来说只用于少量数据 加密。

 

 

Util.java

    package RSA;  
      
    /** 
     *  
     */  
      
    import java.io.ByteArrayOutputStream;  
    import java.io.FileInputStream;  
    import java.io.FileOutputStream;  
    import java.io.ObjectInputStream;  
    import java.io.ObjectOutputStream;  
    import java.math.BigInteger;  
    import java.security.KeyFactory;  
    import java.security.KeyPair;  
    import java.security.KeyPairGenerator;  
    import java.security.NoSuchAlgorithmException;  
    import java.security.PrivateKey;  
    import java.security.PublicKey;  
    import java.security.SecureRandom;  
    import java.security.interfaces.RSAPrivateKey;  
    import java.security.interfaces.RSAPublicKey;  
    import java.security.spec.InvalidKeySpecException;  
    import java.security.spec.RSAPrivateKeySpec;  
    import java.security.spec.RSAPublicKeySpec;  
      
    import javax.crypto.Cipher;  
      
    /** 
     * RSA 工具类。提供加密,解密,生成密钥对等方法。 
     * 需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar。 
     *  
     */  
    public class RSAUtil {  
          
        private static String RSAKeyStore = "C:/RSAKey.txt";  
        /** 
         * * 生成密钥对 * 
         *  
         * @return KeyPair * 
         * @throws EncryptException 
         */  
        public static KeyPair generateKeyPair() throws Exception {  
            try {  
                KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",  
                        new org.bouncycastle.jce.provider.BouncyCastleProvider());  
                final int KEY_SIZE = 1024;// 没什么好说的了,这个值关系到块加密的大小,可以更改,但是不要太大,否则效率会低  
                keyPairGen.initialize(KEY_SIZE, new SecureRandom());  
                KeyPair keyPair = keyPairGen.generateKeyPair();  
                  
                System.out.println(keyPair.getPrivate());  
                System.out.println(keyPair.getPublic());  
                  
                saveKeyPair(keyPair);  
                return keyPair;  
            } catch (Exception e) {  
                throw new Exception(e.getMessage());  
            }  
        }  
      
        public static KeyPair getKeyPair() throws Exception {  
            FileInputStream fis = new FileInputStream(RSAKeyStore);  
            ObjectInputStream oos = new ObjectInputStream(fis);  
            KeyPair kp = (KeyPair) oos.readObject();  
            oos.close();  
            fis.close();  
            return kp;  
        }  
      
        public static void saveKeyPair(KeyPair kp) throws Exception {  
      
            FileOutputStream fos = new FileOutputStream(RSAKeyStore);  
            ObjectOutputStream oos = new ObjectOutputStream(fos);  
            // 生成密钥  
            oos.writeObject(kp);  
            oos.close();  
            fos.close();  
        }  
      
        /** 
         * * 生成公钥 * 
         *  
         * @param modulus * 
         * @param publicExponent * 
         * @return RSAPublicKey * 
         * @throws Exception 
         */  
        public static RSAPublicKey generateRSAPublicKey(byte[] modulus,  
                byte[] publicExponent) throws Exception {  
            KeyFactory keyFac = null;  
            try {  
                keyFac = KeyFactory.getInstance("RSA",  
                        new org.bouncycastle.jce.provider.BouncyCastleProvider());  
            } catch (NoSuchAlgorithmException ex) {  
                throw new Exception(ex.getMessage());  
            }  
      
            RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(  
                    modulus), new BigInteger(publicExponent));  
            try {  
                return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);  
            } catch (InvalidKeySpecException ex) {  
                throw new Exception(ex.getMessage());  
            }  
        }  
      
        /** 
         * * 生成私钥 * 
         *  
         * @param modulus * 
         * @param privateExponent * 
         * @return RSAPrivateKey * 
         * @throws Exception 
         */  
        public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus,  
                byte[] privateExponent) throws Exception {  
            KeyFactory keyFac = null;  
            try {  
                keyFac = KeyFactory.getInstance("RSA",  
                        new org.bouncycastle.jce.provider.BouncyCastleProvider());  
            } catch (NoSuchAlgorithmException ex) {  
                throw new Exception(ex.getMessage());  
            }  
      
            RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(  
                    modulus), new BigInteger(privateExponent));  
            try {  
                return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);  
            } catch (InvalidKeySpecException ex) {  
                throw new Exception(ex.getMessage());  
            }  
        }  
      
        /** 
         * * 加密 * 
         *  
         * @param key 
         *            加密的密钥 * 
         * @param data 
         *            待加密的明文数据 * 
         * @return 加密后的数据 * 
         * @throws Exception 
         */  
        public static byte[] encrypt(PublicKey pk, byte[] data) throws Exception {  
            try {  
                Cipher cipher = Cipher.getInstance("RSA",  
                        new org.bouncycastle.jce.provider.BouncyCastleProvider());  
                cipher.init(Cipher.ENCRYPT_MODE, pk);  
                int blockSize = cipher.getBlockSize();// 获得加密块大小,如:加密前数据为128个byte,而key_size=1024  
                // 加密块大小为127  
                // byte,加密后为128个byte;因此共有2个加密块,第一个127  
                // byte第二个为1个byte  
                int outputSize = cipher.getOutputSize(data.length);// 获得加密块加密后块大小  
                int leavedSize = data.length % blockSize;  
                int blocksSize = leavedSize != 0 ? data.length / blockSize + 1  
                        : data.length / blockSize;  
                byte[] raw = new byte[outputSize * blocksSize];  
                int i = 0;  
                while (data.length - i * blockSize > 0) {  
                    if (data.length - i * blockSize > blockSize)  
                        cipher.doFinal(data, i * blockSize, blockSize, raw, i  
                                * outputSize);  
                    else  
                        cipher.doFinal(data, i * blockSize, data.length - i  
                                * blockSize, raw, i * outputSize);  
                    // 这里面doUpdate方法不可用,查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到  
                    // ByteArrayOutputStream中,而最后doFinal的时候才将所有的byte[]进行加密,可是到了此时加密块大小很可能已经超出了  
                    // OutputSize所以只好用dofinal方法。  
      
                    i++;  
                }  
                return raw;  
            } catch (Exception e) {  
                throw new Exception(e.getMessage());  
            }  
        }  
      
        /** 
         * * 解密 * 
         *  
         * @param key 
         *            解密的密钥 * 
         * @param raw 
         *            已经加密的数据 * 
         * @return 解密后的明文 * 
         * @throws Exception 
         */  
        public static byte[] decrypt(PrivateKey pk, byte[] raw) throws Exception {  
            try {  
                Cipher cipher = Cipher.getInstance("RSA",  
                        new org.bouncycastle.jce.provider.BouncyCastleProvider());  
                cipher.init(cipher.DECRYPT_MODE, pk);  
                int blockSize = cipher.getBlockSize();  
                ByteArrayOutputStream bout = new ByteArrayOutputStream(64);  
                int j = 0;  
      
                while (raw.length - j * blockSize > 0) {  
                    bout.write(cipher.doFinal(raw, j * blockSize, blockSize));  
                    j++;  
                }  
                return bout.toByteArray();  
            } catch (Exception e) {  
                throw new Exception(e.getMessage());  
            }  
        }  
      
        /** 
         * * * 
         *  
         * @param args * 
         * @throws Exception 
         */  
        public static void main(String[] args) throws Exception {  
            RSAPublicKey rsap = (RSAPublicKey) RSAUtil.generateKeyPair().getPublic();  
            String test = "hello world";  
            byte[] en_test = encrypt(getKeyPair().getPublic(), test.getBytes());  
            byte[] de_test = decrypt(getKeyPair().getPrivate(), en_test);  
            System.out.println(new String(de_test));  
        }  
    }  

 

LoginAction.java

    package RSA;  
      
    //login  
    /* 
     * Generated by MyEclipse Struts 
     * Template path: templates/java/JavaClass.vtl 
     */  
    import java.math.BigInteger;  
    import java.net.URLDecoder;  
    import java.net.URLEncoder;  
      
    import javax.servlet.http.HttpServletRequest;  
    import javax.servlet.http.HttpServletResponse;  
      
    import RSA.RSAUtil;  
      
    /** 
     * MyEclipse Struts Creation date: 06-28-2008 
     *  
     * XDoclet definition: 
     *  
     * @struts.action path="/login" name="loginForm" input="/login.jsp" 
     *                scope="request" validate="true" 
     * @struts.action-forward name="error" path="/error.jsp" 
     * @struts.action-forward name="success" path="/success.jsp" 
     */  
    public class LoginAction {  
        /* 
         * Generated Methods 
         */  
      
        /** 
         * Method execute 
         *  
         * @param mapping 
         * @param form 
         * @param request 
         * @param response 
         * @return ActionForward 
         */  
        public boolean execute(HttpServletRequest request,  
                HttpServletResponse response) throws Exception {  
            String pwd ;  
            String result = request.getParameter("result");  
            System.out.println("原文加密后为:");  
            System.out.println(result);  
            byte[] en_result = new BigInteger(result, 16).toByteArray();  
            //System.out.println("转成byte[]" + new String(en_result));  
            byte[] de_result = RSAUtil.decrypt(RSAUtil.getKeyPair().getPrivate(),  
                    en_result);  
            System.out.println("还原密文:");  
            System.out.println(new String(de_result));  
            StringBuffer sb = new StringBuffer();  
            sb.append(new String(de_result));  
            pwd = sb.reverse().toString();  
            System.out.println(sb);  
            System.out.println("=================================");  
            pwd = URLDecoder.decode(pwd,"UTF-8");//  
            System.out.println(pwd);  
            request.setAttribute("pwd", pwd);  
            return true;  
        }  
    }  

 

登陆login.jsp

    <%@ page language="java" pageEncoding="UTF-8" contentType="text/html; charset=UTF-8"%>  
      
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
    <html:html lang="true">  
    <head>  
        <title>login</title>  
      
        <script type="text/javascript" src="js/RSA.js"></script>  
        <script type="text/javascript" src="js/BigInt.js"></script>  
        <script type="text/javascript" src="js/Barrett.js"></script>  
          
        <script type="text/javascript">  
    function rsalogin(){  
        var thisPwd = document.getElementById("password").value;  
        bodyRSA();  
        var result = encryptedString(key, encodeURIComponent(thisPwd));  
        //alert(encodeURIComponent(thisPwd)+"\r\n"+result);  
        loginForm.action="loginCHK.jsp?result="+result;  
        loginForm.submit();  
    }  
    var key ;  
    function bodyRSA(){  
        setMaxDigits(130);  
        key = new RSAKeyPair("10001","","8246a46f44fc4d961e139fd70f4787d272d374532f4d2d9b7cbaad6a15a8c1301319aa6b3f30413b859351c71938aec516fa7147b69168b195e81df46b6bed7950cf3a1c719d42175f73d7c97a85d7d20a9e83688b92f05b3059bb2ff75cd7190a042cd2db97ebc2ab4da366f2a7085556ed613b5a39c9fdd2bb2595d1dc23b5");   
    }  
    </script>  
    </head>  
      
    <body>  
        <form method="post" name="loginForm" target=_blank>  
            <table border="0">  
                <tr>  
                    <td>  
                        Password:  
                    </td>  
                    <td>  
                        <input type='text' name="password" id=password style='width:400px' value="my passwd"/>  
                    </td>  
                </tr>  
                <tr>  
                    <td colspan="2" align="center">  
                        <input type="button" value="SUBMIT" onclick="rsalogin();" />  
                    </td>  
                </tr>  
            </table>  
        </form>  
    </body>  
    </html:html>  

 

登陆校验loginCHK.jsp

    <%@ page language="java" pageEncoding="UTF-8" contentType="text/html; charset=UTF-8"%>  
      
    <jsp:directive.page import="RSA.LoginAction"/>  
      
    <%  
    LoginAction la = new LoginAction();  
    la.execute(request ,response);  
    %>  
    pwd is [<%=request.getAttribute("pwd")%>]  

 

另外,通过RSA还可以实现数字签名 :用私钥签名、公钥验证即可。具体可以看代码:

    package encode;  
      
    import java.security.KeyPair;  
    import java.security.KeyPairGenerator;  
    import java.security.Signature;  
      
    public class DigitalSignature2Example {  
        public static void main(String[] args) {  
            args = new String[] { "中国" };  
              
            if (args.length != 1) {  
                System.err.println("Usage:java DigitalSignature2Example ");  
                System.exit(1);  
            }  
      
            try {  
                byte[] plainText = args[0].getBytes("UTF-8");  
                System.out.println("\nStart generating RSA key.");  
                // 生成RSA密钥对  
                KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");  
                // 初始化密钥长度  
                keyGen.initialize(1024);  
                // 生成密钥对  
                KeyPair pair = keyGen.generateKeyPair();  
                System.out.println("\nFinish generating RSA key.");  
                // 使用私钥签名  
                Signature sig = Signature.getInstance("SHA1WithRSA");  
                // 用指定的私钥进行初始化  
                sig.initSign(pair.getPrivate());  
                // 添加要签名的信息  
                sig.update(plainText);  
                // 返回签名的字节数组  
                byte[] signature = sig.sign();  
                System.out.println(sig.getProvider().getInfo());  
                System.out.println("\nSignature: ");  
                System.out.println(new String(signature, "UTF-8"));  
      
                // 使用公钥验证  
                System.out.println("\nStart signature verification.");  
                sig.initVerify(pair.getPublic());  
                // 添加要验证的信息  
                sig.update(plainText);  
                if (sig.verify(signature)) {  
                    System.out.println("Signature verificated.");  
                } else {  
                    System.out.println("Signature failed.");  
                }  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    }  

 

 

 

 

分享到:
评论

相关推荐

    JS前台加密,java后台解密实现

    在网络安全领域,数据加密是保障信息安全的重要手段。...综上所述,JS前台加密与Java后台解密是实现用户信息安全传输的一种有效策略。正确实施加密和解密流程,结合其他安全实践,能够大大提高网络应用的安全性。

    传输密码加密:rsa实现js前台加密java后台解密

    源码的应用场景: ...这样客户端只需要知道rsa加密方式和公钥,前台不知道私钥是无法解密的,此解决方案还是相对比较安全的。 使用源码的注意事项: http://blog.csdn.net/wu_jia123/article/details/50553128

    RSA前台加密java后台解密项目

    这个项目“RSA前台加密...前端使用JavaScript实现RSA加密,后端使用Java进行解密,两者的配合确保了数据的机密性。在实际开发中,还需要考虑密钥管理、错误处理和性能优化等多个方面,以确保整个系统的安全性和稳定性。

    C#RSA加密与JAVA解密,实现相互通信

    "C# RSA加密与JAVA解密,实现相互通信"的主题聚焦于如何利用RSA公钥/私钥加密算法在C#和Java两个不同的编程环境中实现安全的数据交换。RSA是一种非对称加密算法,它使用一对密钥——公钥和私钥,公钥用于加密,私钥...

    Java实现的RSA加密解密算法示例

    Java实现的RSA加密解密算法示例 本文主要介绍了Java实现的RSA加密解密算法,结合实例形式分析了Java RSA加密解密算法的相关...这些知识点对于Java开发者来说非常重要,可以帮助他们更好地理解和实现RSA加密解密算法。

    前端使用jsencrypt加密后端使用java RSA解密功能实现源码

    本文将详细介绍一个实际案例:如何在前端使用JavaScript库`jsencrypt`进行RSA加密,并在后端使用Java进行解密。这个功能实现的核心知识点包括RSA算法、`jsencrypt`库的使用以及前后端的交互。 首先,RSA是一种非...

    js前台通过RSA,DES加解密,java后台解密、加密

    在标题和描述中提到的"js前台通过RSA,DES加解密,java后台解密、加密",这是一个关于在Web应用程序中实现安全通信的常见实践。这里涉及到两个主要的加密算法:RSA和DES,以及它们在前端JavaScript和后端Java中的...

    与上传的另一篇资源JS前端加密所对应的.NET版本的加密解密,可实现js加密,后台解密,后台加密,js端解密

    本资源是对另一篇资源js端加密,后台解密/JS端解密,后台加密的后台版本,已亲测可用,并且加密和解密都可正常执行,注意:本资源中包含AES加密解密,RSA加密解密,以及生成PEM格式的RSA公私秘钥,但是有点没做好的...

    RSA加密解密 JS加密 JAVA解密 【完美版】

    经过本人修改,简化并完善了别人的代码,使其更加的容易理解和学习! 此为一个完整的项目,...功能:服务端随机生成密钥,JS用公钥加密,服务端用私钥解密。用到的JS加密文件是从官网下载的最新版,速度快,稳定性好!

    javaRSA加密C++RSA解密

    JAVA也是通过包来实现加密和解密的,那么我的C++是通过OPENSSL的库来实现的。 重点来到了:RSA使用过程 1、C++随机生成一对公钥和私钥 2、JAVA用公钥给明文打包形成密文 3、C++用私钥解密密文

    Java实现文件的RSA和DES加密

    Java 实现文件的 RSA 和 DES 加密 在现代密码技术中,根据密钥类型的不同,可以将其分为两类:对称加密算法(秘密钥匙加密)和非对称加密算法(公开密钥加密)。对称加密算法用来对敏感数据等信息进行加密,常用的...

    Rsa加密解密.rar_RSA 加密解密_java rsa_rsa加密_rsa加密java_加密 解密

    在Java中实现RSA加密解密,需要使用Java Cryptography Extension (JCE)库。以下是使用RSA加密解密的基本步骤: 1. **生成密钥对**:首先,我们需要生成一对公钥和私钥。在Java中,`java.security.KeyPairGenerator`...

    Java与.NET RSA加密解密(签名,验签)实例代码

    在IT行业中,安全是至关重要的,特别是在涉及到敏感数据...这个实例代码集合提供了一个实用的跨平台RSA加密解密和签名验证解决方案,对于理解不同编程环境下的RSA应用以及在实际项目中实现安全通信具有很高的参考价值。

    C# .net 使用Java公钥实现RSA加密

    C# .net 使用Java公钥实现RSA加密

    python Django RSA 前台加密 后端解密。

    在Python中,我们可以使用`PyCryptodome`库来实现RSA加密和解密。这个库提供了完整的密码学服务,包括RSA算法。`Cryptodome_demo`可能是一个包含示例代码的文件,我们可以通过它了解如何在Django中使用RSA。 下面是...

    C# 实现与JAVA互通 加签/验签,RSA加密/解密

    * RSA加密解密:私钥解密,公钥加密。 * RSA数字签名-俗称加签验签:私钥加签,公钥验签。  * RSA加密解密:私钥解密,公钥加密。 * RSA数字签名-俗称加签验签:私钥加签,公钥验签。  * RSA加密解密:私钥...

    C#与java平台RSA加密解密签名验签互通案例

    本案例聚焦于"C#与Java平台RSA加密解密签名验签互通"的问题,这涉及到两个主要的技术点:RSA加密算法和跨平台兼容性。下面将详细阐述这两个知识点。 首先,RSA是一种非对称加密算法,由Ron Rivest、Adi Shamir和...

Global site tag (gtag.js) - Google Analytics