Android实现公共公钥加密私钥解密（可分段加密分段解密）

最新推荐文章于 2024-08-05 10:16:39 发布
最新推荐文章于 2024-08-05 10:16:39 发布
阅读量985 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43117800/article/details/108410507
版权

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

公私钥在线生成在线生成公钥私钥

public class MainActivity extends AppCompatActivity {

    @BindView(R.id.tv_name)
    TextView tvName;
    //公钥和私钥的格式不能变，否则会影响加密解密，直接粘贴复制不可自己改动
    private static String PUCLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC7SzXRRsqP3HBOvyunB9V45cVV\n" +
            "uuAMoRuYfSpi2VQAuB26D789fjntjjMjofByKU2S9idELLpzuyHge31Oa7GjLZ98\n" +
            "La3PA8DtouOfuKaq9eBtZOgd/ZTevVQoJQ4WTdJTVlry5MI1PihJSqDA+Y8Wfdwm\n" +
            "hfMFQcBbmKgp1GqGQwIDAQABAA";

    private static String PRIVATE_KEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBALtLNdFGyo/ccE6/\n" +
            "K6cH1XjlxVW64AyhG5h9KmLZVAC4HboPvz1+Oe2OMyOh8HIpTZL2J0QsunO7IeB7\n" +
            "fU5rsaMtn3wtrc8DwO2i45+4pqr14G1k6B39lN69VCglDhZN0lNWWvLkwjU+KElK\n" +
            "oMD5jxZ93CaF8wVBwFuYqCnUaoZDAgMBAAECgYBhLApGA+aAcSxLjt/FD0lwKjYR\n" +
            "3pzzsHqyyO2+z2bH4L57lEPyUZUYbRiXOiOX91nqD5AbzOEHvmU7JJbEoxdL3/by\n" +
            "aNzen32irrw9X4XDQ4cxPFv1ya449TJGbnzHF7Rc4RHtMQ8ZgthxOaBaW8YhZkaP\n" +
            "S4BfaiFAGHtZISGv4QJBAO9p++m3z2kMJOwozOT8ZkTe28Y+f5uuCmnmJrDTI3R9\n" +
            "5XuctYgH0rr0mhC3+W+fMl8/svazalst6uifsIG+QzsCQQDIRN9T4fH1iKIDGMEP\n" +
            "a+hQ+mz1AsaPSUX80n13KE9gV+cyErZ3Pi7CP/THPwvmoUt9QCZERwlsEhmE7Slo\n" +
            "J4iZAkBPGr+ni5o2ZVLVzO1WQ6cu3kvThtb3A1xhfTAPgNPYK7jlTPQWDC+uoh89AA\n" +
            "ouwB26HzIsLpDIL5uYRCdHEHjWv9AkAWIua8kuD3zt55kSbl2XuYV9XrTx87f1Hp\n" +
            "HCsaHK6Ja632bvMUQx9QAVnBHErodzOs6IZSTbfQ5j9D3iMRjC0hAkEAvJdM4lHU\n" +
            "I2HJC4/WRhuQCGd2yTi0jCJqmwAogtxJVjDw1hs5D72CBb6phZ7E/RH1tNOL0clA\n" +
            "GG0UVY2IOT4YtQ==";
    private String mAfterencrypt;
    private JSONObject mJsonObject;
    private String mS;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);
        mS = "hahhahhahah";

        tvName.setText(mS);
    }


    @OnClick({R.id.button1, R.id.button2})
    public void onViewClicked(View view) {
        switch (view.getId()) {
            case R.id.button1:
                try {
                    // 从字符串中得到公钥
                    PublicKey publicKey = RSAUtils.loadPublicKey(PUCLIC_KEY);
                    // 从文件中得到公钥
//                    InputStream inPublic = getResources().getAssets().open("rsa_public_key.pem");
//                    PublicKey publicKey = RSAUtils.loadPublicKey(inPublic);
                    // 加密
                    byte[] encryptByte = RSAUtils.encryptData(mS.getBytes(), publicKey);
                    // 为了方便观察吧加密后的数据用base64加密转一下，要不然看起来是乱码,所以解密是也是要用Base64先转换
                    mAfterencrypt = Base64Util.encode(encryptByte);
                    tvName.setText(mAfterencrypt);
                    System.out.println("加密前：" + mS);
                    System.out.println("加密后：" + mAfterencrypt);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                break;
            case R.id.button2:
                try {
                    // 从字符串中得到私钥
                    PrivateKey privateKey = RSAUtils.loadPrivateKey(PRIVATE_KEY);
                    // 从文件中得到私钥
//                    InputStream inPrivate = getResources().getAssets().open("pkcs8_rsa_private_key.pem");
//                    PrivateKey privateKey = RSAUtils.loadPrivateKey(inPrivate);
                    // 因为RSA加密后的内容经Base64再加密转换了一下，所以先Base64解密回来再给RSA解密
                    byte[] decryptByte = RSAUtils.decryptData(Base64Util.decode(mAfterencrypt), privateKey);
                    String decryptStr = new String(decryptByte);
                    Log.d("RSA", "解密后的数据：" + decryptStr);
                    tvName.setText(decryptStr);
                } catch (Exception e) {
                    e.printStackTrace();
                }

                break;
            default:
        }
    }
}

RSA工具类

/**
 * date:2020/9/4 0004
 * author:wsm (Administrator)
 * funcation:
 */

public class RSAUtils {
    private static String RSA = "RSA";
    /**
     * **
     * RSA最大加密大小
     */
    private final static int MAX_ENCRYPT_BLOCK = 117;

    /**
     * **
     * RSA最大解密大小
     */
    private final static int MAX_DECRYPT_BLOCK = 128;

    /**
     * 随机生成RSA密钥对(默认密钥长度为1024)
     *
     * @return
     */
    public static KeyPair generateRSAKeyPair() {
        return generateRSAKeyPair(1024);
    }

    /**
     * 随机生成RSA密钥对
     *
     * @param keyLength 密钥长度，范围：512～2048<br>
     *                  一般1024
     * @return
     */
    public static KeyPair generateRSAKeyPair(int keyLength) {
        try {
            KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);
            kpg.initialize(keyLength);
            return kpg.genKeyPair();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 用公钥加密 <br>
     * 每次加密的字节数，不能超过密钥的长度值减去11
     *
     * @param data   需加密数据的byte数据
     * @param pubKey 公钥
     * @return 加密后的byte型数据
     */
    public static byte[] encryptData(byte[] data, PublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            // 编码前设定编码方式及密钥
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            // 传入编码数据并返回编码结果
            return cipher.doFinal(data);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 用私钥解密
     *
     * @param encryptedData 经过encryptedData()加密返回的byte数据
     * @param privateKey    私钥
     * @return
     */
    public static byte[] decryptData(byte[] encryptedData, PrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return cipher.doFinal(encryptedData);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 通过公钥byte[](publicKey.getEncoded())将公钥还原，适用于RSA算法
     *
     * @param keyBytes
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    public static PublicKey getPublicKey(byte[] keyBytes) throws NoSuchAlgorithmException,
            InvalidKeySpecException {
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    /**
     * 通过私钥byte[]将公钥还原，适用于RSA算法
     *
     * @param keyBytes
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    public static PrivateKey getPrivateKey(byte[] keyBytes) throws NoSuchAlgorithmException,
            InvalidKeySpecException {
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

    /**
     * 使用N、e值还原公钥
     *
     * @param modulus
     * @param publicExponent
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    public static PublicKey getPublicKey(String modulus, String publicExponent)
            throws NoSuchAlgorithmException, InvalidKeySpecException {
        BigInteger bigIntModulus = new BigInteger(modulus);
        BigInteger bigIntPrivateExponent = new BigInteger(publicExponent);
        RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    /**
     * 使用N、d值还原私钥
     *
     * @param modulus
     * @param privateExponent
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    public static PrivateKey getPrivateKey(String modulus, String privateExponent)
            throws NoSuchAlgorithmException, InvalidKeySpecException {
        BigInteger bigIntModulus = new BigInteger(modulus);
        BigInteger bigIntPrivateExponent = new BigInteger(privateExponent);
        RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

    /**
     * 从字符串中加载公钥
     *
     * @param publicKeyStr 公钥数据字符串
     * @throws Exception 加载公钥时产生的异常
     */
    public static PublicKey loadPublicKey(String publicKeyStr) throws Exception {
        try {
            byte[] buffer = Base64Util.decode(publicKeyStr);
            KeyFactory keyFactory = KeyFactory.getInstance(RSA);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
            return (RSAPublicKey) keyFactory.generatePublic(keySpec);
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException e) {
            throw new Exception("公钥非法");
        } catch (NullPointerException e) {
            throw new Exception("公钥数据为空");
        }
    }

    /**
     * 从字符串中加载私钥<br>
     * 加载时使用的是PKCS8EncodedKeySpec（PKCS#8编码的Key指令）。
     *
     * @param privateKeyStr
     * @return
     * @throws Exception
     */
    public static PrivateKey loadPrivateKey(String privateKeyStr) throws Exception {
        try {
            byte[] buffer = Base64Util.decode(privateKeyStr);
            // X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
            KeyFactory keyFactory = KeyFactory.getInstance(RSA);
            return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException e) {
            throw new Exception("私钥非法");
        } catch (NullPointerException e) {
            throw new Exception("私钥数据为空");
        }
    }
    /**
     * 用公钥分段加密 <br>
     * 每次加密的字节数，不能超过密钥的长度值减去11
     *
     * @param data 需加密数据的byte数据
     * @param publicKey 公钥
     * @return 加密后的byte型数据
     */
    public static byte[] PublicSubData(byte[] data, PublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            // 编码前设定编码方式及密钥
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            // 传入编码数据并返回编码结果
//            return cipher.doFinal(data);
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0)
            {
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK)
                {
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else
                {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return decryptedData;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 用私钥分段解密
     *
     * @param encryptedData 经过encryptedData()加密返回的byte数据
     * @param privateKey    私钥
     * @return
     */
    public static byte[] PrivateSubData(byte[] encryptedData, PrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
//            return cipher.doFinal(encryptedData);
            // 返回UTF-8编码的解密信息
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0)
            {
                if (inputLen - offSet > MAX_DECRYPT_BLOCK)
                {
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else
                {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return decryptedData;
        } catch (Exception e) {
            return null;
        }
    }
    /**
     * 从文件中输入流中加载公钥
     *
     * @param in 公钥输入流
     * @throws Exception 加载公钥时产生的异常
     */
    public static PublicKey loadPublicKey(InputStream in) throws Exception {
        try {
            return loadPublicKey(readKey(in));
        } catch (IOException e) {
            throw new Exception("公钥数据流读取错误");
        } catch (NullPointerException e) {
            throw new Exception("公钥输入流为空");
        }
    }

    /**
     * 从文件中加载私钥
     *
     * @param keyFileName 私钥文件名
     * @return 是否成功
     * @throws Exception
     */
    public static PrivateKey loadPrivateKey(InputStream in) throws Exception {
        try {
            return loadPrivateKey(readKey(in));
        } catch (IOException e) {
            throw new Exception("私钥数据读取错误");
        } catch (NullPointerException e) {
            throw new Exception("私钥输入流为空");
        }
    }

    /**
     * 读取密钥信息
     *
     * @param in
     * @return
     * @throws IOException
     */
    private static String readKey(InputStream in) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        String readLine = null;
        StringBuilder sb = new StringBuilder();
        while ((readLine = br.readLine()) != null) {
            if (readLine.charAt(0) == '-') {
                continue;
            } else {
                sb.append(readLine);
                sb.append('\r');
            }
        }

        return sb.toString();
    }

    /**
     * 打印公钥信息
     *
     * @param publicKey
     */
    public static void printPublicKeyInfo(PublicKey publicKey) {
        RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;
        System.out.println("----------RSAPublicKey----------");
        System.out.println("Modulus.length=" + rsaPublicKey.getModulus().bitLength());
        System.out.println("Modulus=" + rsaPublicKey.getModulus().toString());
        System.out.println("PublicExponent.length=" + rsaPublicKey.getPublicExponent().bitLength());
        System.out.println("PublicExponent=" + rsaPublicKey.getPublicExponent().toString());
    }

    public static void printPrivateKeyInfo(PrivateKey privateKey) {
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;
        System.out.println("----------RSAPrivateKey ----------");
        System.out.println("Modulus.length=" + rsaPrivateKey.getModulus().bitLength());
        System.out.println("Modulus=" + rsaPrivateKey.getModulus().toString());
        System.out.println("PrivateExponent.length=" + rsaPrivateKey.getPrivateExponent().bitLength());
        System.out.println("PrivatecExponent=" + rsaPrivateKey.getPrivateExponent().toString());

    }
}

Base64

/**
 * date:2020/9/4 0004
 * author:wsm (Administrator)
 * funcation:
 */
public final class Base64Util {
    private static char[] base64EncodeChars = new char[]
            { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
                    'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
                    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5',
                    '6', '7', '8', '9', '+', '/' };
    private static byte[] base64DecodeChars = new byte[]
            { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53,
                    54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 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, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,
                    30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1,
                    -1, -1, -1 };

    /**
     * 加密
     *
     * @param data
     * @return
     */
    public static String encode(byte[] data)
    {
        StringBuffer sb = new StringBuffer();
        int len = data.length;
        int i = 0;
        int b1, b2, b3;
        while (i < len)
        {
            b1 = data[i++] & 0xff;
            if (i == len)
            {
                sb.append(base64EncodeChars[b1 >>> 2]);
                sb.append(base64EncodeChars[(b1 & 0x3) << 4]);
                sb.append("==");
                break;
            }
            b2 = data[i++] & 0xff;
            if (i == len)
            {
                sb.append(base64EncodeChars[b1 >>> 2]);
                sb.append(base64EncodeChars[((b1 & 0x03) << 4) | ((b2 & 0xf0) >>> 4)]);
                sb.append(base64EncodeChars[(b2 & 0x0f) << 2]);
                sb.append("=");
                break;
            }
            b3 = data[i++] & 0xff;
            sb.append(base64EncodeChars[b1 >>> 2]);
            sb.append(base64EncodeChars[((b1 & 0x03) << 4) | ((b2 & 0xf0) >>> 4)]);
            sb.append(base64EncodeChars[((b2 & 0x0f) << 2) | ((b3 & 0xc0) >>> 6)]);
            sb.append(base64EncodeChars[b3 & 0x3f]);
        }
        return sb.toString();
    }

    /**
     * 解密
     *
     * @param str
     * @return
     */
    public static byte[] decode(String str)
    {
        try
        {
            return decodePrivate(str);
        } catch (UnsupportedEncodingException e)
        {
            e.printStackTrace();
        }
        return new byte[]
                {};
    }

    private static byte[] decodePrivate(String str) throws UnsupportedEncodingException
    {
        StringBuffer sb = new StringBuffer();
        byte[] data = null;
        data = str.getBytes("US-ASCII");
        int len = data.length;
        int i = 0;
        int b1, b2, b3, b4;
        while (i < len)
        {

            do
            {
                b1 = base64DecodeChars[data[i++]];
            } while (i < len && b1 == -1);
            if (b1 == -1)
                break;

            do
            {
                b2 = base64DecodeChars[data[i++]];
            } while (i < len && b2 == -1);
            if (b2 == -1)
                break;
            sb.append((char) ((b1 << 2) | ((b2 & 0x30) >>> 4)));

            do
            {
                b3 = data[i++];
                if (b3 == 61)
                    return sb.toString().getBytes("iso8859-1");
                b3 = base64DecodeChars[b3];
            } while (i < len && b3 == -1);
            if (b3 == -1)
                break;
            sb.append((char) (((b2 & 0x0f) << 4) | ((b3 & 0x3c) >>> 2)));

            do
            {
                b4 = data[i++];
                if (b4 == 61)
                    return sb.toString().getBytes("iso8859-1");
                b4 = base64DecodeChars[b4];
            } while (i < len && b4 == -1);
            if (b4 == -1)
                break;
            sb.append((char) (((b3 & 0x03) << 6) | b4));
        }
        return sb.toString().getBytes("iso8859-1");
    }
}

demo下载地址链接：
链接：https://pan.baidu.com/s/1eJubvnLkG4qzkwlKCjsRBg
提取码：jryi

“嗯哈
关注
Android RSA加密解密demo
08-23
Android RSA加密解密demo，详情请参看博客：http://blog.csdn.net/bbld_/article/details/38777491
Android publickey获取
thorzdf的博客
09-21 1071
  有些时候我们需要比对apk包的publickey，获取没有安装的APK包中的publickey可以使用如下的方式：   1      public String collectCertificates(String filePath) {   2         String result = "";   3         try {   4                 Jar...
APP备案(Android) - 获取签名证书公钥、MD5
最新发布
weixin_42504805的博客
08-05 1705
公钥和MD5公钥和MD5。
android之Rsa加密，分段公钥加密解密
qq_35661441的博客
09-20 1264
使用RSA算法加密 老规矩先说流程： 公钥私钥，一般由服务器生成，有512位的，1024位，2048位的，前面两个已经有破解的方法，建议使用2048位的，记住这个位数。在下面分段加解密有用。公钥可以解密和加密，公钥加密私钥解密，私钥加密公钥解密，有点绕，哈哈哈，客服端放置公钥，私钥放在服务端。我们第一步也是先加载公钥。如下是服务端的人员给的公钥，很重要，去掉头和尾（-----BEGIN PUBL...
Android 获取签名公钥
zamitwhj
01-12 770
[1].[代码] [Java]代码 跳至 [1] ? 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
Android产品研发（二十三）-->Android中保存静态秘钥实践
一片枫叶的专栏
07-21 1万+
本文我们将讲解一个android产品研发中可能会碰到的一个问题：如何在App中保存静态秘钥以及保证其安全性。许多的移动app需要在app端保存一些静态字符串常量，其可能是静态秘钥、第三方appId等。在保存这些字符串常量的时候就涉及到了如何保证秘钥的安全性问题。如何保证在App中静态秘钥唯一且正确安全，这是一个很重要的问题，公司的产品中就存在着静态字符串常量类型的秘钥，所以一个明显的问题就是如何生成秘钥，保证秘钥的安
QT RSA 公钥加密 公钥解密 私钥加密 私钥解密 分段加密 分段解密
05-25
推荐在线完成RSA加密解密的网站：https://the-x.cn/cryptography/Rsa.aspx 可以用VS打开.sln文件也可以用QT编辑器打开.pro文件 文件中虽然有RSATool.cpp的文件，但是程序中使用动态库的形式引入的 如果你想分步调试...
C# .net版 RSA 公钥加密私钥解密 私钥加密公钥解密
02-15
总的来说，RSA算法在C# .NET中的实现涉及到了密钥对的生成、公钥加密、私钥解密等核心操作，理解这些概念对于开发安全的应用程序至关重要。在实际应用中，还需要考虑数据完整性校验、密钥管理等额外的安全措施。通过...
Java 公钥和私钥加密解密代码
02-09
Java中实现公钥和私钥加密解密主要依赖于Java Cryptography Extension (JCE) 提供的API，特别是`java.security`和`javax.crypto`这两个包。以下是关键类和接口： 1. KeyPairGenerator：用于生成公钥和私钥对。 2. ...
Java公钥加密私钥解密.rar
11-08
这个名为"Java公钥加密私钥解密.rar"的压缩包文件包含了一个使用Java实现的公钥/私钥加密解密的示例。在这个案例中，开发者可能使用了Java的Java Cryptography Extension (JCE) 来实现RSA算法，这是一种非对称加密...
支持rsa公钥加密私钥解密；支持rsa公钥解密私钥加密
05-13
这个库可能提供了公钥加密、私钥解密、数字签名以及密钥生成等接口，使得开发者能够轻松地在Go程序中实现RSA算法，增强应用的安全性。使用这样的库，开发者可以遵循上述描述中的模式，灵活地处理加密和解密任务，...
Android 获取签名公钥和公钥私钥加解密的方法(推荐)
08-31
下面小编就为大家带来一篇Android 获取签名公钥和公钥私钥加解密的方法(推荐)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Android使用RSA分段加解密
dongaddxing的博客
04-23 1015
RSA为非对称加密，加解密用一对秘钥（公钥，私钥） 公钥和私钥成对出现，是相对的，没有规定哪个必须是公钥哪个必须是私钥 用公钥加密的数据只有对应的私钥可以解密 用私钥加密的数据只有对应的公钥可以解密 如果可以用公钥解密，则必然是对应的私钥加的密 如果可以用私钥解密，则必然是对应的公钥加的密 1、RSA工具类 /** * RSA 非对称加密算法，加解密工具类， * 加密长度 不能超过 128 个字节。 */ @RequiresApi(api = Build.VERSION_CODES.KI
android 公钥pem编码,从公钥.pem格式加密rsa android
weixin_31043555的博客
05-26 451
我已经在许多stackoverflows帖子中徘徊，但仍然无法弄清楚我的代码有什么问题。public class KripAsim {String hasil;public String encrypt(String text) {try {String PUBLIC_KEY="MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvCNqSslgCndo8vfN...
Android/Java中解析.crt证书文件的公钥（public key）---Android拓展篇
热门推荐
Promise Sun special column
11-02 1万+
Android/Java中解析.crt证书文件的公钥（public key） ——读取.crt文件证书（获取key） 1.问题描述 2.解决问题
android ios java rsa加密解密,RSA 利用分段加解密 解决IOS、Android、JAVA后台服务器 加解密数据交互安全问题...
weixin_34431283的博客
03-18 391
之前用的对称加密，安全方面欠妥。后来换成了RSA非对称加密，走了很多弯路。比如：1、利用JAVA代码生成出来的秘钥对不能正确解密和加密；2、密文加解密长度限制等等；网上找了好多资料后终于调通了，现总结如下：1、运用SSL工具生成IOS和JAVA能识别的证书，不懂的可以问问度娘；2、Windows环境搭建SSL麻烦点，但是mac自带有这个，可以让有mac的兄dei生成哈就可以了；3、生成好之后，有两...
android 公钥pem编码,在Android中将PEM转换为PublicKey
weixin_36444881的博客
05-26 859
我已经看到了许多类似的问题，但对我而言，没有任何效果。我只是想将从服务器检索到的PEM格式的RSA公钥转换为PublicKeyAndroid中的。谁能指出我正确的方向？编辑：我已经成功使用以下代码将PEM转换为PublicKey，但是在编码消息后，我得到了意外的输出…public PublicKey getFromString(String keystr) throws Exception{// ...
Android网络数据传输安全——实现RSA公钥加密私钥解密
程龙的博客
03-13 1839
一，整体流程 后台生成一个RSA秘钥对，包括公钥和私钥 后台将公钥字符串下发给客户端， 然后客户端用此公钥生成一个RSAPublicKey对象，再将手机号密码等数据用此对象加密， 客户端将加密的数据发送给后台， 后台将加密的数据用私钥解密。 二，公私钥 你可以利用工具一键生成密钥对 访问支付宝官网，进入如下页面，该页面的URL：https://docs.open.alipay.com/291/1...
Android RSA 加密(分段加密)
王人冉的博客
05-17 1694
package com.dhh.easy.wahu.utils; import android.util.*; import android.util.Base64; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java....
java实现公钥加密私钥解密
05-25
在Java中，可以使用Java加密扩展（JCE）库中的RSA算法实现公钥加密私钥解密。下面是一个简单的示例代码： ```java import java.security.*; import javax.crypto.*; import java.util.Base64; public class RSA...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值