Android Java层中各类常用算法简介

最新推荐文章于 2021-05-26 02:17:44 发布

乡村隐士

最新推荐文章于 2021-05-26 02:17:44 发布

阅读量345

点赞数

分类专栏：安卓逆向_算法

本文链接：https://blog.csdn.net/qq_34108752/article/details/101122515

版权

安卓逆向_算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1.MD5算法简介

  项目中无论是密码的存储或者说判断文件是否是同一文件，都会用到MD5算法，它是由MD2、MD3、MD4演变过来的，是一种单向加密算法，同时也是不可逆的一种的加密方式。

MD5加密算法实现：

1.）计算字符串MD5值

public static String md5(String string) {
if (TextUtils.isEmpty(string)) {
return “”;
}
MessageDigest md5 = null;
try {
md5 = MessageDigest.getInstance(“MD5”);
byte[] bytes = md5.digest(string.getBytes());
String result = “”;
for (byte b : bytes) {
String temp = Integer.toHexString(b & 0xff);
if (temp.length() == 1) {
temp = “0” + temp;
}
result += temp;
}
return result;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return “”;
}
2.）计算文件的MD5值
// 计算文件的 MD5 值
public static String md5(File file) {
if (file == null || !file.isFile() || !file.exists()) {
return “”;
}
FileInputStream in = null;
String result = “”;
byte buffer[] = new byte[8192];
int len;
try {
MessageDigest md5 = MessageDigest.getInstance(“MD5”);
in = new FileInputStream(file);
while ((len = in.read(buffer)) != -1) {
md5.update(buffer, 0, len);
}
byte[] bytes = md5.digest();

        for (byte b : bytes) {
            String temp = Integer.toHexString(b & 0xff);
            if (temp.length() == 1) {
                temp = "0" + temp;
            }
            result += temp;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        if(null!=in){
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return result;
}

增加md5的安全性
3.）对字符串多次MD5加密
4.）MD5加盐

加盐的方式也是多种多样

string+key（盐值key）然后进行MD5加密

用string明文的hashcode作为盐，然后进行MD5加密
随机生成一串字符串作为盐，然后进行MD5加密

public static String md5(String string, String slat) {
if (TextUtils.isEmpty(string)) {
return “”;
}
MessageDigest md5 = null;
try {
md5 = MessageDigest.getInstance(“MD5”);
byte[] bytes = md5.digest((string + slat).getBytes());
String result = “”;
for (byte b : bytes) {
String temp = Integer.toHexString(b & 0xff);
if (temp.length() == 1) {
temp = “0” + temp;
}
result += temp;
}
return result;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return “”;
}

2.Base64编码算法简介

什么Base64编码？

 Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，Base64并不是安全领域的加密算法，其实Base64只能算是一个编码算法，对数据内容进行编码来适合传输。标准Base64编码解码无需额外信息即完全可逆，即使你自己自定义字符集设计一种类Base64的编码方式用于数据加密，在多数场景下也较容易破解。Base64编码本质上是一种将二进制数据转成文本数据的方案。对于非二进制数据，是先将其转换成二进制形式，然后每连续6比特（2的6次方=64）计算其十进制值，根据该值在A--Z,a--z,0--9,+,/ 这64个字符中找到对应的字符，最终得到一个文本字符串。基本规则如下几点：

标准Base64只有64个字符（英文大小写、数字和+、/）以及用作后缀等号；
Base64是把3个字节变成4个可打印字符，所以Base64编码后的字符串一定能被4整除（不算用作后缀的等号）；
等号一定用作后缀，且数目一定是0个、1个或2个。这是因为如果原文长度不能被3整除，Base64要在后面添加\0凑齐3n位。为了正确还原，添加了几个\0就加上几个等号。显然添加等号的数目只能是0、1或2；
严格来说Base64不能算是一种加密，只能说是编码转换。

1.）字符串进行Base64编码

String encodedString = Base64.encodeToString(“whoislcj”.getBytes(), Base64.DEFAULT);
Log.e(“Base64”, “Base64---->” + encodedString);
2.）字符串进行Base64解码

String decodedString =new String(Base64.decode(encodedString,Base64.DEFAULT));
Log.e(“Base64”, “Base64---->” + decodedString);
3.）对文件进行Base64编码

File file = new File("/storage/emulated/0/pimsecure_debug.txt");
FileInputStream inputFile = null;
try {
inputFile = new FileInputStream(file);
byte[] buffer = new byte[(int) file.length()];
inputFile.read(buffer);
inputFile.close();
encodedString = Base64.encodeToString(buffer, Base64.DEFAULT);
Log.e(“Base64”, “Base64---->” + encodedString);
} catch (Exception e) {
e.printStackTrace();
}
4.）对文件进行Base64解码

File desFile = new File("/storage/emulated/0/pimsecure_debug_1.txt");
FileOutputStream fos = null;
try {
byte[] decodeBytes = Base64.decode(encodedString.getBytes(), Base64.DEFAULT);
fos = new FileOutputStream(desFile);
fos.write(decodeBytes);
fos.close();
} catch (Exception e) {
e.printStackTrace();
}

3.DES算法简介

DES加密介绍：

 DES是一种对称加密算法，所谓对称加密算法即：加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究，

后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为DES使用56位密钥，以现代计算能力，24小时内即可被破解。
DES加密使用方式：

1.）DesUtil常量类介绍

private final static String HEX = "0123456789ABCDEF";
private final static String TRANSFORMATION = "DES/CBC/PKCS5Padding";//DES是加密方式 CBC是工作模式 PKCS5Padding是填充模式
private final static String IVPARAMETERSPEC = "01020304";初始化向量参数，AES 为16bytes. DES 为8bytes.
private final static String ALGORITHM = "DES";//DES是加密方式
private static final String SHA1PRNG = "SHA1PRNG"; SHA1PRNG 强随机种子算法, 要区别4.2以上版本的调用方法

2.）动态生成秘钥

长度不能够小于8位字节因为DES固定格式为128bits，即8bytes。

/*

生成随机数，可以当做动态的密钥加密和解密的密钥必须一致，不然将不能解密
*/
public static String generateKey() {
try {
SecureRandom localSecureRandom = SecureRandom.getInstance(SHA1PRNG);
byte[] bytes_key = new byte[20];
localSecureRandom.nextBytes(bytes_key);
String str_key = toHex(bytes_key);
return str_key;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

//二进制转字符
public 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();
}

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

3.）处理秘钥Key的两种方式

第一种：

// 对密钥进行处理
private static Key getRawKey(String key) throws Exception {
    KeyGenerator kgen = KeyGenerator.getInstance(ALGORITHM);
    //for android
    SecureRandom sr = null;
    // 在4.2以上版本中，SecureRandom获取方式发生了改变
    if (android.os.Build.VERSION.SDK_INT >= 17) {
        sr = SecureRandom.getInstance(SHA1PRNG, "Crypto");
    } else {
        sr = SecureRandom.getInstance(SHA1PRNG);
    }
    // for Java
    // secureRandom = SecureRandom.getInstance(SHA1PRNG);
    sr.setSeed(key.getBytes());
    kgen.init(64, sr); //DES固定格式为64bits，即8bytes。
    SecretKey skey = kgen.generateKey();
    byte[] raw = skey.getEncoded();
    return new SecretKeySpec(raw, ALGORITHM);
}

第二种：

// 对密钥进行处理
private static Key getRawKey(String key) throws Exception {
DESKeySpec dks = new DESKeySpec(key.getBytes());
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
return keyFactory.generateSecret(dks);
}
4.）加密实现

/**
* DES算法，加密
*
* @param data 待加密字符串
* @param key 加密私钥，长度不能够小于8位
* @return 加密后的字节数组，一般结合Base64编码使用
*/
public static String encode(String key, String data) {
return encode(key, data.getBytes());
}

/**
 * DES算法，加密
 *
 * @param data 待加密字符串
 * @param key  加密私钥，长度不能够小于8位
 * @return 加密后的字节数组，一般结合Base64编码使用
 */
public static String encode(String key, byte[] data) {
    try {
        Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
        IvParameterSpec iv = new IvParameterSpec(IVPARAMETERSPEC.getBytes());
        cipher.init(Cipher.ENCRYPT_MODE, getRawKey(key), iv);
        byte[] bytes = cipher.doFinal(data);
        return Base64.encodeToString(bytes, Base64.DEFAULT);
    } catch (Exception e) {
        return null;
    }
}

5.）解密实现

/**
 * 获取编码后的值
 *
 * @param key
 * @param data
 * @return
 */
public static String decode(String key, String data) {
    return decode(key, Base64.decode(data, Base64.DEFAULT));
}

/**
 * DES算法，解密
 *
 * @param data 待解密字符串
 * @param key  解密私钥，长度不能够小于8位
 * @return 解密后的字节数组
 */
public static String decode(String key, byte[] data) {
    try {
        Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
        IvParameterSpec iv = new IvParameterSpec(IVPARAMETERSPEC.getBytes());
        cipher.init(Cipher.DECRYPT_MODE, getRawKey(key), iv);
        byte[] original = cipher.doFinal(data);
        String originalString = new String(original);
        return originalString;
    } catch (Exception e) {
        return null;
    }
}

DES知识扩展：3DES

 3DES是DES加密算法的一种模式，它使用3条64位的密钥对数据进行三次加密。数据加密标准（DES）是美国的一种由来已久的加密标准，它使用对称密钥加密法。3DES（即Triple DES）是DES向AES过渡的加密算法（1999年，NIST将3-DES指定为过渡的加密标准），是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法。

DES与AES比较：

  当时被问起采用DES加密内心深处我是拒绝的。单纯从名字上看AES(Advanced Encryption Standard)高级加密标准，安全性要高于DES，其实AES的出现本身就是为了取代DES的，AES具有比DES更好的安全性、效率、灵活性，所以对称加密优先采用AES。

4.AES算法简介

什么是aes加密？

 高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。

接下来我们来实际看下具体怎么实现：

对于AesUtils类常量简介：

private final static String HEX = "0123456789ABCDEF";
private  static final String CBC_PKCS5_PADDING = "AES/CBC/PKCS5Padding";//AES是加密方式 CBC是工作模式 PKCS5Padding是填充模式
private  static final String AES = "AES";//AES 加密
private  static final String  SHA1PRNG="SHA1PRNG"; SHA1PRNG 强随机种子算法, 要区别4.2以上版本的调用方法

如何生成一个随机Key？

/*
* 生成随机数，可以当做动态的密钥加密和解密的密钥必须一致，不然将不能解密
*/
public static String generateKey() {
try {
SecureRandom localSecureRandom = SecureRandom.getInstance(SHA1PRNG);
byte[] bytes_key = new byte[20];
localSecureRandom.nextBytes(bytes_key);
String str_key = toHex(bytes_key);
return str_key;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

Aes密钥处理
// 对密钥进行处理
private static byte[] getRawKey(byte[] seed) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance(AES);
//for android
SecureRandom sr = null;
// 在4.2以上版本中，SecureRandom获取方式发生了改变
if (android.os.Build.VERSION.SDK_INT >= 17) {
sr = SecureRandom.getInstance(SHA1PRNG, “Crypto”);
} else {
sr = SecureRandom.getInstance(SHA1PRNG);
}
// for Java
// secureRandom = SecureRandom.getInstance(SHA1PRNG);
sr.setSeed(seed);
kgen.init(128, sr); //256 bits or 128 bits,192bits
//AES中128位密钥版本有10个加密循环，192比特密钥版本有12个加密循环，256比特密钥版本则有14个加密循环。
SecretKey skey = kgen.generateKey();
byte[] raw = skey.getEncoded();
return raw;
}
Aes加密过程
/*
* 加密
*/
public static String encrypt(String key, String cleartext) {
if (TextUtils.isEmpty(cleartext)) {
return cleartext;
}
try {
byte[] result = encrypt(key, cleartext.getBytes());
return Base64Encoder.encode(result);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

/*
* 加密
*/
private static byte[] encrypt(String key, byte[] clear) throws Exception {
    byte[] raw = getRawKey(key.getBytes());
    SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    cipher.init(Cipher.ENCRYPT_MODE, skeySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
    byte[] encrypted = cipher.doFinal(clear);
    return encrypted;
}

Aes解密过程
/*
* 解密
*/
public static String decrypt(String key, String encrypted) {
if (TextUtils.isEmpty(encrypted)) {
return encrypted;
}
try {
byte[] enc = Base64Decoder.decodeToBytes(encrypted);
byte[] result = decrypt(key, enc);
return new String(result);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

/*
 * 解密
 */
private static byte[] decrypt(String key, byte[] encrypted) throws Exception {
    byte[] raw = getRawKey(key.getBytes());
    SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    cipher.init(Cipher.DECRYPT_MODE, skeySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
    byte[] decrypted = cipher.doFinal(encrypted);
    return decrypted;
}

5.RSA算法简介

什么是Rsa加密？

RSA算法是最流行的公钥密码算法，使用长度可以变化的密钥。RSA是第一个既能用于数据加密也能用于数字签名的算法。

RSA算法原理如下：

1.随机选择两个大质数p和q，p不等于q，计算N=pq；
2.选择一个大于1小于N的自然数e，e必须与(p-1)(q-1)互素。
3.用公式计算出d：d×e = 1 (mod (p-1)(q-1)) 。
4.销毁p和q。

最终得到的N和e就是“公钥”，d就是“私钥”，发送方使用N去加密数据，接收方只有使用d才能解开数据内容。

RSA的安全性依赖于大数分解，小于1024位的N已经被证明是不安全的，而且由于RSA算法进行的都是大数计算，使得RSA最快的情况也比DES慢上很多倍，这是RSA最大的缺陷，因此通常只能用于加密少量数据或者加密密钥，但RSA仍然不失为一种高强度的算法。

几个全局变量解说：

public static final String RSA = "RSA";// 非对称加密密钥算法
public static final String ECB_PKCS1_PADDING = "RSA/ECB/PKCS1Padding";//加密填充方式
public static final int DEFAULT_KEY_SIZE = 2048;//秘钥默认长度
public static final byte[] DEFAULT_SPLIT = "#PART#".getBytes();    // 当要加密的内容超过bufferSize，则采用partSplit进行分块加密
public static final int DEFAULT_BUFFERSIZE = (DEFAULT_KEY_SIZE / 8) - 11;// 当前秘钥支持加密的最大字节数

使用方式
1.首先生成秘钥对
/**
* 随机生成RSA密钥对
*
* @param keyLength 密钥长度，范围：512～2048
* 一般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;
}
}
具体加密实现：
公钥加密：
/*
* 用公钥对字符串进行加密
*
* @param data 原文
*/
public static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
// 得到公钥
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PublicKey keyPublic = kf.generatePublic(keySpec);
// 加密数据
Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
cp.init(Cipher.ENCRYPT_MODE, keyPublic);
return cp.doFinal(data);
}
私钥加密：

/**
* 私钥加密
*
* @param data 待加密数据
* @param privateKey 密钥
* @return byte[] 加密数据
*/
public static byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
// 得到私钥
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PrivateKey keyPrivate = kf.generatePrivate(keySpec);
// 数据加密
Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
cipher.init(Cipher.ENCRYPT_MODE, keyPrivate);
return cipher.doFinal(data);
}

6.异或加密算法简介

什么是异或加密？

  异或运算中，如果某个字符（或数值）x 与 一个数值m 进行异或运算得到y，则再用y 与 m 进行异或运算就可以还原为 x ，因此应用这个原理可以实现数据的加密解密功能。

异或运算使用场景？

两个变量的互换（不借助第三个变量），效率要求较高的场景。

数据的简单加密解密

异或加密解密实现？

这种方式加密解密算法一样

public byte[] encrypt(byte[] bytes) {
    if (bytes == null) {
        return null;
    }
    int len = bytes.length;
    int key = 0x12;
    for (int i = 0; i < len; i++) {
        bytes[i] ^= key;
    }
    return bytes;
}

测试加密解密

byte[] bytes = encrypt(“whoislcj”.getBytes());//加密
String str1 = new String(encrypt(bytes));//解密

乡村隐士

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android Java层中各类常用算法简介

1.MD5算法简介项目中无论是密码的存储或者说判断文件是否是同一文件，都会用到MD5算法，它是由MD2、MD3、MD4演变过来的，是一种单向加密算法，同时也是不可逆的一种的加密方式。MD5加密算法实现：1.）计算字符串MD5值public static String md5(String string) {if (TextUtils.isEmpty(string)) {retur...
复制链接

扫一扫