Android移动开发-Android数据加密与解密的实现

最新推荐文章于 2024-03-19 18:38:26 发布
最新推荐文章于 2024-03-19 18:38:26 发布
阅读量1w 收藏 42
点赞数 8
分类专栏： Android开发随笔 文章标签： 移动开发 android 加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fukaimei/article/details/78290750
版权

数据的安全是非常重要的，现在无论干什么都要账号和密码，一旦账号与密码泄露出去必将造成财产的损失，所以做好数据保密是非常重要的。
Android加密算法有多种多样，常见的有MD5、RSA、AES、3DES四种。

  • MD5加密：

MD5是不可逆的加密算法，也就是无法解密，主要用于客户端的用户密码加密。MD5算法加密代码如下：

  • 定义工具类MD5Util.java逻辑代码如下：
package com.fukaimei.encryptiontest.util;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MD5Util {

    //首先初始化一个MessageDigest对象，该对象通过update方法获取原始数据，
    //并调用digest方法完成哈希计算，然后把字节数组逐位转换为十六进制数，最后拼装加密字符串
    public static String encrypBy(String raw) {
        String md5Str = raw;
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(raw.getBytes());
            byte[] encryContext = md.digest();

            int i;
            StringBuffer buf = new StringBuffer("");
            for (int offset = 0; offset < encryContext.length; offset++) {
                i = encryContext[offset];
                if (i < 0) {
                    i += 256;
                }
                if (i < 16) {
                    buf.append("0");
                }
                buf.append(Integer.toHexString(i));
            }
            md5Str = buf.toString();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return md5Str;
    }
}

无论原始字符串是什么，MD5算法的加密串都是32位的十六进制字符串。

  • RSA加密：

RSA算法在客户端使用公钥加密，在服务端使用私钥解密。这样一来，即使加密的公钥被泄露，没有私钥仍然无法解密。（注意：使用RSA加密之前必须在AndroidStudio的libs目录下导入bcprov-jdk的jar包）RSA算法的加密代码如下：

  • 定义工具类RSAUtil.java逻辑代码如下：
package com.fukaimei.encryptiontest.util;

import com.fukaimei.encryptiontest.util.tool.ConvertBytesToBase64;

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.net.URLDecoder;
import java.net.URLEncoder;
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.PKCS8EncodedKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

//RSA 工具类。提供加密，解密，生成密钥对等方法。
public class RSAUtil {
    private static final String TAG = "RSAUtil";
    private static final String Algorithm = "RSA";
//  private static String RSAKeyStore = "E:/RSAKey.txt";
//
//  //生成密钥对
//  private static KeyPair generateKeyPair() throws Exception {
//      try {
//          KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(Algorithm,
//                  new org.bouncycastle.jce.provider.BouncyCastleProvider());
//          // 这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会降低
//          final int KEY_SIZE = 1024;
//          keyPairGen.initialize(KEY_SIZE, new SecureRandom());
//          KeyPair keyPair = keyPairGen.generateKeyPair();
//          saveKeyPair(keyPair);
//          return keyPair;
//      } catch (Exception e) {
//          throw new Exception(e.getMessage());
//      }
//  }
//
//  private 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;
//  }
//
//  private static void saveKeyPair(KeyPair kp) throws Exception {
//      FileOutputStream fos = new FileOutputStream(RSAKeyStore);
//      ObjectOutputStream oos = new ObjectOutputStream(fos);
//      oos.writeObject(kp);
//      oos.close();
//      fos.close();
//  }
//
//  //生成公钥
//  private static RSAPublicKey generateRSAPublicKey(byte[] modulus,
//          byte[] publicExponent) throws Exception {
//      KeyFactory keyFac = null;
//      try {
//          keyFac = KeyFactory.getInstance(Algorithm,
//                  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());
//      }
//  }
//
//  //生成私钥
//  private static RSAPrivateKey generateRSAPrivateKey(byte[] modulus,
//          byte[] privateExponent) throws Exception {
//      KeyFactory keyFac = null;
//      try {
//          keyFac = KeyFactory.getInstance(Algorithm,
//                  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());
//      }
//  }
//
//  // 通过公钥byte[]将公钥还原，适用于RSA算法
//  private static PublicKey getPublicKey(byte[] keyBytes)
//          throws NoSuchAlgorithmException, InvalidKeySpecException {
//      X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
//      KeyFactory keyFactory = KeyFactory.getInstance(Algorithm);
//      PublicKey publicKey = keyFactory.generatePublic(keySpec);
//      return publicKey;
//  }
//
//  // 通过私钥byte[]将公钥还原，适用于RSA算法
//  private static PrivateKey getPrivateKey(byte[] keyBytes)
//          throws NoSuchAlgorithmException, InvalidKeySpecException {
//      PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
//      KeyFactory keyFactory = KeyFactory.getInstance(Algorithm);
//      PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
//      return privateKey;
//  }

    //加密
    private static byte[] encrypt(PublicKey pk, byte[] data) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance(Algorithm,
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());
            cipher.init(Cipher.ENCRYPT_MODE, pk);
            int blockSize = cipher.getBlockSize();
            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);
                }
                i++;
            }
            return raw;
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }

    //解密
    private static byte[] decrypt(PrivateKey pk, byte[] raw) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance(Algorithm,
                    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());
        }
    }

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

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

    //加密函数
    public static String encodeRSA(RSAKeyData key_data, String src) {
        if (key_data == null) {
            //默认的密钥对
            key_data = new RSAKeyData();
            key_data.public_key = "10001";
            key_data.private_key = "";
            key_data.modulus = "c7f668eccc579bb75527424c21be31c104bb44c921b4788ebc82cddab5042909eaea2dd706431531392d79890f9091e13714285a7e79e9d1836397f847046ef2519c9b65022b48bf157fe409f8a42155734e65467d04ac844dfa0c2ae512517102986ba9b62d67d4c920eae40b2f11c363b218a703467d342faa81719f57e2c3";
            key_data.radix = 16;
        }
        try {
            PublicKey key = getPublicKey(key_data.modulus, key_data.public_key, key_data.radix);
            String rev = encodeURL(new StringBuilder(src).reverse().toString());
            byte[] en_byte = encrypt(key, rev.getBytes());
            String base64 = encodeURL(ConvertBytesToBase64.BytesToBase64String(en_byte));
            return base64;
        } catch (Exception e) {
            e.printStackTrace();
            return "RSA加密失败";
        }
    }

    //URL编码
    private static String encodeURL(String str) {
        String encode_str = str;
        try {
            encode_str = URLEncoder.encode(str, "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return encode_str;
    }

    //URL解码
    private static String decodeURL(String str) {
        String decode_str = str;
        try {
            decode_str = URLDecoder.decode(str, "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return decode_str;
    }

    public static class RSAKeyData {
        public String modulus;
        public String public_key;
        public String private_key;
        public int radix;

        public RSAKeyData() {
            modulus = "";
            public_key = "";
            private_key = "";
            radix = 0;
        }
    }
}

RSA算法加密结果是经过URL编码的字符串。

  • AES加密：

AES是设计用来替换DES的高级加密算法。下面是AES算法加密和解密的代码：

  • 定义工具类AesUtil.java逻辑代码如下：
package com.fukaimei.encryptiontest.util;

import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class AesUtil {

    private static final String Algorithm = "AES";
    private final static String HEX = "0123456789ABCDEF";

    //加密函数，key为密钥
    public static String encrypt(String key, String src) throws Exception {
        byte[] rawKey = getRawKey(key.getBytes());
        byte[] result = encrypt(rawKey, src.getBytes());
        return toHex(result);
    }

    //解密函数。key值必须和加密时的key一致
    public static String decrypt(String key, String encrypted) throws Exception {
        byte[] rawKey = getRawKey(key.getBytes());
        byte[] enc = toByte(encrypted);
        byte[] result = decrypt(rawKey, enc);
        return new String(result);
    }

    private static void appendHex(StringBuffer sb, byte b) {
        sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
    }

    private static byte[] getRawKey(byte[] seed) throws Exception {
        KeyGenerator kgen = KeyGenerator.getInstance(Algorithm);
        // SHA1PRNG 强随机种子算法, 要区别Android 4.2.2以上版本的调用方法
        SecureRandom sr = null;
        if (android.os.Build.VERSION.SDK_INT >= 17) {
            sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");
        } else {
            sr = SecureRandom.getInstance("SHA1PRNG");
        }
        sr.setSeed(seed);
        kgen.init(256, sr); // 256位或128位或192位
        SecretKey skey = kgen.generateKey();
        byte[] raw = skey.getEncoded();
        return raw;
    }

    private static byte[] encrypt(byte[] key, byte[] src) throws Exception {
        SecretKeySpec skeySpec = new SecretKeySpec(key, Algorithm);
        Cipher cipher = Cipher.getInstance(Algorithm);
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
        byte[] encrypted = cipher.doFinal(src);
        return encrypted;
    }

    private static byte[] decrypt(byte[] key, byte[] encrypted) throws Exception {
        SecretKeySpec skeySpec = new SecretKeySpec(key, Algorithm);
        Cipher cipher = Cipher.getInstance(Algorithm);
        cipher.init(Cipher.DECRYPT_MODE, skeySpec);
        byte[] decrypted = cipher.doFinal(encrypted);
        return decrypted;
    }

    private static byte[] toByte(String hexString) {
        int len = hexString.length() / 2;
        byte[] result = new byte[len];
        for (int i = 0; i < len; i++) {
            result[i] = Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 16).byteValue();
        }
        return result;
    }

    private static String toHex(byte[] buf) {
        if (buf == null) {
            return "";
        }
        StringBuffer result = new StringBuffer(2 * buf.length);
        for (int i = 0; i < buf.length; i++) {
            appendHex(result, buf[i]);
        }
        return result.toString();
    }
}

AES算法是可逆算法，支持对加密字符串进行解密，前提是解密时密钥必须与加密时一致。

  • 3DES加密：

3DES（Triple DES）是三重数据加密算法，相当于对每个数据块应用3次DES加密算法。因为原先DES算法的密钥长度过短，容易遭到暴力破解，所以3DES算法通过增加密钥的长度防范加密数据被破解。该算法的加密和解密代码如下：

  • 定义工具类Des3Util.java逻辑代码如下：
package com.fukaimei.encryptiontest.util;

import com.fukaimei.encryptiontest.util.base64.BASE64Decoder;
import com.fukaimei.encryptiontest.util.base64.BASE64Encoder;

import java.io.IOException;
import java.io.UnsupportedEncodingException;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class Des3Util {

    // 定义加密算法，DESede即3DES  
    private static final String Algorithm = "DESede";

    //加密函数。key为密钥
    public static String encrypt(String key, String raw) {
        byte[] enBytes = encryptMode(key, raw.getBytes());
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(enBytes);
    }

    //解密函数。key值必须和加密时的key一致
    public static String decrypt(String key, String enc) {
        try {
            BASE64Decoder decoder = new BASE64Decoder();
            byte[] enBytes = decoder.decodeBuffer(enc);
            byte[] deBytes = decryptMode(key, enBytes);
            return new String(deBytes);
        } catch (IOException e) {
            e.printStackTrace();
            return enc;
        }
    }

    private static byte[] encryptMode(String key, byte[] src) {
        try {
            SecretKey deskey = new SecretKeySpec(build3DesKey(key), Algorithm);
            Cipher cipher = Cipher.getInstance(Algorithm);
            cipher.init(Cipher.ENCRYPT_MODE, deskey);
            return cipher.doFinal(src);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private static byte[] decryptMode(String key, byte[] src) {
        try {
            SecretKey deskey = new SecretKeySpec(build3DesKey(key), Algorithm);
            Cipher cipher = Cipher.getInstance(Algorithm);
            cipher.init(Cipher.DECRYPT_MODE, deskey);
            return cipher.doFinal(src);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    //根据字符串生成密钥24位的字节数组
    private static byte[] build3DesKey(String keyStr) throws UnsupportedEncodingException {
        byte[] key = new byte[24];
        byte[] temp = keyStr.getBytes("UTF-8");

        if (key.length > temp.length) {
            System.arraycopy(temp, 0, key, 0, temp.length);
        } else {
            System.arraycopy(temp, 0, key, 0, key.length);
        }
        return key;
    }
}

3DES算法与AES一样是可逆算法，支持对加密字符串进行解密，前提是解密时密钥必须与加密时一致。

  • layout/activity_main.xml界面布局代码如下：
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:focusable="true"
    android:focusableInTouchMode="true"
    android:orientation="vertical"
    android:padding="5dp">

    <ScrollView
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical">

            <LinearLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:orientation="horizontal">

                <TextView
                    android:layout_width="0dp"
                    android:layout_height="wrap_content"
                    android:layout_weight="2"
                    android:gravity="right"
                    android:text="加密字符串："
                    android:textColor="#000000"
                    android:textSize="16sp" />

                <EditText
                    android:id="@+id/et_raw"
                    android:layout_width="0dp"
                    android:layout_height="wrap_content"
                    android:layout_weight="3"
                    android:hint="请输入要加密的字符串"
                    android:text=""
                    android:textColor="#000000"
                    android:textSize="16sp" />
            </LinearLayout>

            <LinearLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:orientation="horizontal">

                <Button
                    android:id="@+id/btn_md5"
                    android:layout_width="0dp"
                    android:layout_height="wrap_content"
                    android:layout_weight="1"
                    android:gravity="center"
                    android:text="MD5加密"
                    android:textColor="#000000"
                    android:textSize="14sp" />

                <Button
                    android:id="@+id/btn_rsa"
                    android:layout_width="0dp"
                    android:layout_height="wrap_content"
                    android:layout_weight="1"
                    android:gravity="center"
                    android:text="RSA加密"
                    android:textColor="#000000"
                    android:textSize="14sp" />

                <Button
                    android:id="@+id/btn_aes"
                    android:layout_width="0dp"
                    android:layout_height="wrap_content"
                    android:layout_weight="1"
                    android:gravity="center"
                    android:text="AES加密"
                    android:textColor="#000000"
                    android:textSize="14sp" />

                <Button
                    android:id="@+id/btn_3des"
                    android:layout_width="0dp"
                    android:layout_height="wrap_content"
                    android:layout_weight="1"
                    android:gravity="center"
                    android:text="3DES加密"
                    android:textColor="#000000"
                    android:textSize="14sp" />
            </LinearLayout>

            <TextView
                android:id="@+id/tv_des"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:gravity="left"
                android:text=""
                android:textColor="#000000"
                android:textSize="18sp" />
        </LinearLayout>
    </ScrollView>

</LinearLayout>
  • MainActivity.java逻辑代码如下：
package com.fukaimei.encryptiontest;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import com.fukaimei.encryptiontest.util.AesUtil;
import com.fukaimei.encryptiontest.util.Des3Util;
import com.fukaimei.encryptiontest.util.MD5Util;
import com.fukaimei.encryptiontest.util.RSAUtil;

public class MainActivity extends AppCompatActivity implements OnClickListener {

    private final static String TAG = "MainActivity";
    private EditText et_raw;
    private TextView tv_des;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        et_raw = (EditText) findViewById(R.id.et_raw);
        tv_des = (TextView) findViewById(R.id.tv_des);
        findViewById(R.id.btn_md5).setOnClickListener(this);
        findViewById(R.id.btn_rsa).setOnClickListener(this);
        findViewById(R.id.btn_aes).setOnClickListener(this);
        findViewById(R.id.btn_3des).setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        String raw = et_raw.getText().toString();
        if (raw == null || raw.length() <= 0) {
            Toast.makeText(this, "请输入待加密字符串", Toast.LENGTH_LONG).show();
            return;
        }
        if (v.getId() == R.id.btn_md5) {
            String enStr = MD5Util.encrypBy(raw);
            tv_des.setText("MD5的加密结果是:" + enStr);
        } else if (v.getId() == R.id.btn_rsa) {
            String enStr = RSAUtil.encodeRSA(null, raw);
            tv_des.setText("RSA加密结果是:" + enStr);
        } else if (v.getId() == R.id.btn_aes) {
            try {
                String seed = "a";
                String enStr = AesUtil.encrypt(seed, raw);
                String deStr = AesUtil.decrypt(seed, enStr);
                String desc = String.format("AES加密结果是:%s\nAES解密结果是:%s", enStr, deStr);
                tv_des.setText(desc);
            } catch (Exception e) {
                e.printStackTrace();
                tv_des.setText("AES加密/解密失败");
            }
        } else if (v.getId() == R.id.btn_3des) {
            String key = "a";
            String enStr = Des3Util.encrypt(key, raw);
            String deStr = Des3Util.decrypt(key, enStr);
            String desc = String.format("3DES加密结果是:%s\n3DES解密结果是:%s", enStr, new String(deStr));
            tv_des.setText(desc);
        }
    }
}
  • Demo程序运行效果界面截图如下：

MD5加密截图RSA加密截图AES加密/解密截图3DES加密/解密截图

Demo程序源码下载地址一（GitHub）
Demo程序源码下载地址二（Gitee）

_彼岸雨敲窗_
关注
  • 8
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
aes解密需要的BouncyCastleProvider
06-25
应用场景如，微信小程序获取用户详细信息需要aes解密，这个时候就需要这个jar包
provider.BouncyCastleProvider库导入用于算法和生成证书
热门推荐
heng615975867的专栏
04-06 2万+
关于使用算法找不到类org.bouncycastle.jce.provider.BouncyCastleProvider的问题，本人尝试了网上N多方法都不行后，自己尝试解决了问题，以分享出来。没有JAVA_HOME的需要配置环境，JDK环境变量的配置 1、网上搜索的方法基本都是这种，本人没有解决问题 找到JAVA_HOME路径 将bcprov-jdk14-145.jar放入JAVA_HOME...
RSA加密解密签名加签验签RsaUtils工具类
最新发布
gongjin28_csdn的博客
03-19 1136
RSA基于数学上的大整数因子分解难题，只要密钥足够大（通常建议至少2048位），在现有的计算机技术和算法条件下，破解RSA加密的数据所需的时间极其漫长，从而确保了高度的安全性。RSA算法基于大数因子分解难题，提供了公钥加密和私钥解密的能力。：除了加密外，RSA还可用于数字签名，通过私钥对数据进行签名，然后接收方可以用公钥验证签名的真实性，确保数据完整性并确认发送者的身份。：虽然实际运算复杂，但RSA算法本身是公开的，这增强了人们对算法安全性的信任，因为任何潜在的漏洞都可以经过全球专家的审查和改进。
Android库可将android utils与注释一起使用。-Android开发
05-26
UReflection库一个轻量级的android库，可以快速集成到任何应用程序中以使用android utils。 示例使用Check gps已启用。 检查互联网连接。 检查互联网是否可用。 Check UReflection库一个轻量级的android库，可以快速集成到任何应用程序中以使用android utils。 示例使用Check gps已启用。 检查互联网连接。 检查互联网是否可用。 检查是wifi。 检查是否是快速的移动网络连接。 获取wifi扫描。 获取网络类型名称。 获取当前的wifi网络信息。 Md5哈希。 Sha1哈希。 Base64加密。 Base64解密。 在Play商店上获取应用网址。 获取国家代码。 获取当前日期。 获取当前时间。 获取应用哈希键。 取得装置
Android金融支付常见加解密算法及安全防护
liminwu_6的博客
10-31 1831
引言 因为本人从事的金融 IC 卡和移动支付相关的开发工作，在日常研发过程中，对 APP 信息安全防护方面尤为重视，所以现总结下金融支付相关的加解密算法以及常见的安全防范措施。 Android 端常见的加解密算法 加密算法根据内容是否可以还原分为可逆加密和非可逆加密 。 可逆加密根据其加密解密是否使用的同一个密钥而可以分为对称加密和非对称加密。 对称加密即是指在加密和解密时使用
移动端的加解密
weixin_67553250的博客
06-07 840
今天给大家分享一篇有关移动端加解密的文章。随着移动设备的普及，加密技术在保护用户数据方面变得越来越重要。 本文将为您介绍Android加解密算法的分类、优缺点特性及应用，帮助您了解和选择适合自己的加解密算法。我们还会提供算法的关键代码，让您更好地理解和使用，快来跟我一起学习学习。
BouncyCastleProvider找不到问题解决
qq_31433709的博客
10-10 2107
Android Studio解决BouncyCastleProvider找不到的问题 //AES256加密 private byte[] AESEncrypt(String content, byte[] key, byte[] iv){ byte[] byteContent = content.getBytes("utf-8"); // Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider()
android加密报错java.security.NoSuchAlgorithmException: Provider BC does not provide SM4/ECB/PKCS5Padding
geniushorse的博客
04-03 1422
需要调用removeProvider方法后再调用addProvider。打印BC版本号，会发现没有调用成功。避免内存泄漏，复用provider。build.gradle需要引入。
Android 数据SM4传输加解密
beautifulYuan的博客
03-14 3461
甲方要求，数据在传输过程中要加密。
Android密钥证书管理相关介绍
doomvsjing的博客
06-09 1万+
深入理解Android之Java Security第一部分 http://blog.csdn.net/innost/article/details/44081147 Android的数字证书安装过程概述 http://blog.chinaunix.net/uid-26017891-id-4115659.html Android导入.cer数字证书 http://blog.sina.co
Android org.bouncycastle:bcprov-jdk15to18:1.64依赖，还是no such algorithm: EdDSA for provider BC
06-03 5725
no such algorithm: EdDSA for provider BC 打印日志 Provider:AndroidKeyStoreBCWorkaround: version:1.0, Provider:CertPathProvider: version:1.0, url: http://z.kungfualumni.com/1/, Provider:HarmonyJSSE: version:1.0, Provider:AndroidOpenSSL: version:1.0, Provi...
Android对称加密与非对称加密
01-20
凯撒密码作为一种最为古老的对称加密体制，在古罗马的时候都已经很流行，他的基本思想是：通过把字母移动一定的位数来实现加密和解密。明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换...
serket:用于加密解密的 Gem 和 Android 客户端
07-09
设想的用例是在使用公钥将数据保存到服务器或移动设备之前对数据进行加密，并且仅在将数据发送到具有私钥的另一台服务器时才解密该数据。 它的工作原理是生成一个随机 AES 密钥，使用该生成的密钥加密文本，使用 ...
Android开发资料合集-World版！
12-11
9.79、一个很好的加密解密字符串 316 9.80、DRAWABLE、BITMAP、BYTE[]之间的转换 318 9.81、高循环效率的代码 320 9.82、给模拟器打电话发短信 321 9.83、加快模拟器速度 321 9.83.1、模拟器 “尚未注册网络” 322 ...
基于Android的自主可控即时通信系统的设计与实现
01-28
目前，移动通信软件得到较快发展，但是...本文基于Android移动终端系统，设计并实现了基于自组网技术和可更换服务器的自主可控即时通信系统。经测试，该系统简单易用，在实际通信中安全程度较高，具有良好的应用效果。
Android开发-使用MD5 AES RSA BASE64 加密解密 比如登录通信Token加密
Mango先生的博客
05-30 2111
在平时的Android开发中使用到加密的地方很多，比如： 1.登陆请求的加密 一般我们客户端登陆会带上服务器生成的Sessionid，如果服务器的Redis中存在这个Sessionid，就判断是合法的客户端；但是如果这个Sessionid被第三方截获，模拟请求，就会产生很大的风险。如果这时候引入Token，客户端对Token加一些其它参数组合，然后使用MD5进行加密生成签名，然后将Sessio...
Android常用加解密算法
笔沫拾光
09-07 3010
数据安全，不管是对于企业还是个人都是十分重要。而作为一个移动开发者，我们更需要去考虑数据传输的安全性，去保护企业及个人信息安全。在Java,Android语言中，有许多的常用加解密算法，例如：对称加密算法AES,DES,3DES，非对称加密算法RSA,经典哈希算法MD5,SHA. 对称加密算法：加密秘钥和解密秘钥相同 例：AES,DES,3DES 非对称加密算法：有公钥和秘钥，公钥加密
Android加密和解密（DES，AES，MD5）
gongzhiyao37390814的博客
10-13 1万+
加密是通过加密算法和加密密钥将明文转变为密文的过程，解密是其逆过程。加密算法有很多种，一般可以分为对称加密（如DES、AES等）、非对称加密（如RSA等）和单向加密（如MD5等）3类算法。 1）在对称加密算法中，双方使用的密钥相同，要求解密方事先必须知道加密密钥。这类加密算法技术较为成熟，加密效率高。 2）在非对称加密算法中，收发双方使用不同的密钥，发方使用公开密钥对消息进行加密，收发使用
OTA升级功能系列三（MD5加密）
Top0_0lll的博客
01-31 1868
前言 在前面的两个章节中，我们简单介绍了在OTA升级过程中，如何对文件进行解压缩和加解密的操作。今天，就讲讲这个系列最后的内容，MD5加密。 一、MD5加密是什么？ MD5加密，是一种开源的加密算法。由于其不可逆性，被广泛应用于密码管理，电子签名等领域。这里我们可以看下百度百科对于MD5加密应用于电子签名的介绍。 电子签名 MD5 算法还可以作为一种电子签名的方法来使用，使用 MD5算法就可以为任何文件（不管其大小、格式、数量）产生一个独一无二的“数字指纹”，借助这个“数字指纹”，通过检查文件前后 MD
android rsa 与 web rsa
07-13
### 回答1： Android RSA 和 Web RSA 都是使用RSA算法进行数据加密和解密的方式，只是在不同的平台上实现。下面分别对两者进行简要说明。 Android RSA: 在Android系统中，可以通过Java的标准库`java.security`来使用RSA算法。在Android中使用RSA算法，首先需要生成RSA密钥对，包括公钥和私钥。然后可以使用公钥对数据进行加密，私钥对数据进行解密。在Android平台上，可以使用RSA算法对用户敏感信息进行加密，例如用户登录密码等，以保证信息的安全性。 Web RSA: 在Web开发中，RSA算法也广泛应用于数据的加密和解密。Web开发中的RSA通常使用JavaScript来实现。通过使用 JavaScript 的RSA库，可以在网页上进行数据的加密和解密操作。同时，也需要生成RSA密钥对，并将公钥嵌入到网页中，以供前端JavaScript代码使用。在Web应用中，RSA算法常用于保护用户的敏感信息，例如在用户密码传输、支付信息等场景中，使用RSA算法加密数据，以确保数据的安全性。 综上所述，Android RSA和Web RSA均是基于RSA算法实现的数据加密和解密方式。Android RSA主要适用于Android系统及相关应用的开发中，而Web RSA则适用于Web开发中对用户信息进行加密保护的场景。两者都能够保障数据的安全性，但具体的实现方式和使用方式会有所不同。 ### 回答2： Android RSA和Web RSA是两种使用RSA算法的应用领域。 Android RSA是指在Android操作系统上使用RSA算法进行数据加密和解密的处理。Android提供了RSA算法的相关API，开发者可以通过这些API实现对数据的加密和解密操作。在Android RSA中，首先需要生成RSA密钥对，包括公钥和私钥。公钥可以分享给其他人用于加密数据，私钥则用于解密。Android RSA可以用于加密敏感数据、保护用户隐私等场景。 Web RSA是指在Web应用中使用RSA算法进行数据加密和解密的处理。在Web开发中，常常使用RSA算法来对用户的敏感信息进行加密传输，确保数据的安全性。Web RSA采用了与Android RSA类似的加密和解密流程，首先生成RSA密钥对，然后使用公钥加密数据，并通过网络传输给服务端，服务端再使用私钥进行解密。 Android RSA和Web RSA在实现上有一些差异。首先，Android RSA是在移动设备上进行加密和解密的，而Web RSA是在服务器端和客户端之间进行传输的。其次，Android RSA需要使用Android提供的API进行密钥生成和加解密操作，而Web RSA可以使用其他语言和库来实现。 综上所述，Android RSA和Web RSA都是使用RSA算法进行数据加密和解密的应用领域。它们的实现方式略有差异，但都可以有效地保护数据的安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值