Android对称加密与非对称加密

凯撒密码
1. 介绍
凯撒密码作为一种最为古老的对称加密体制，在古罗马的时候都已经很流行，他的基本思想是：通过把字母移动一定的位数来实现加密和解密。明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。例如，当偏移量是3 的时候，所有的字母A 将被替换成D，B 变成E，由此可见，位数就是凯撒密码加密和解密的密钥。
例如：字符串”ABC”的每个字符都右移3 位则变成”DEF”，解密的时候”DEF”的每个字符左移3 位即能还原，如下图所示：

这里写图片描述
2. 准备知识

 //字符转换成ASCII 码数值 char charA = "a"; int intA = charA; //char 强转为int 即得到对应的ASCII 码值，"a"的值为97//ASCII 码值转成charint intA = 97;//97 对应的ASCII 码"a"char charA = （char） intA; //int 值强转为char 即得到对应的ASCII 字符，即"a"

3. 凯撒密码的简单代码实现

 /** * 加密 * @param input 数据源（需要加密的数据） * @param key 秘钥，即偏移量 * @return 返回加密后的数据 */public static String encrypt（String input, int key） {//得到字符串里的每一个字符char[] array = input.toCharArray（）;for （int i = 0; i < array.length; ++i） {//字符转换成ASCII 码值int ascii = array[i];//字符偏移，例如a->bascii = ascii + key;//ASCII 码值转换为charchar newChar = （char） ascii;//替换原有字符array[i] = newChar;//以上4 行代码可以简写为一行//array[i] = （char） （array[i] + key）;}//字符数组转换成Stringreturn new String（array）;}/** * 解密 * @param input 数据源（被加密后的数据） * @param key 秘钥，即偏移量 * @return 返回解密后的数据 */public static String decrypt（String input, int key） {//得到字符串里的每一个字符char[] array = input.toCharArray（）;for （int i = 0; i < array.length; ++i） {//字符转换成ASCII 码值int ascii = array[i];//恢复字符偏移，例如b->aascii = ascii - key;//ASCII 码值转换为charchar newChar = （char） ascii;//替换原有字符array[i] = newChar;//以上4 行代码可以简写为一行//array[i] = （char） （array[i] - key）;}//字符数组转换成Stringreturn new String（array）;}

代码输出结果：

4. 破解凯撒密码：频率分析法
凯撒密码加密强度太低，只需要用频度分析法即可破解。
在任何一种书面语言中，不同的字母或字母组合出现的频率各不相同。而且，对于以这种语言书写的任意一段文本，都具有大致相同的特征字母分布。比如，在英语中，字母E 出现的频率很高，而X 则出现得较少。
英语文本中典型的字母分布情况如下图所示：

这里写图片描述
5. 破解流程
统计密文里出现次数最多的字符，例如出现次数最多的字符是是"h"。
计算字符"h"到"e"的偏移量，值为3，则表示原文偏移了3 个位置。
将密文所有字符恢复偏移3 个位置。
注意点：统计密文里出现次数最多的字符时，需多统计几个备选，因为最多的可能是空格或者其他字符，例如下图出现次数最多的字符"#"是空格加密后的字符，"h"才是"e"偏移后的值。
这里写图片描述
解密时要多几次尝试，因为不一定出现次数最多的字符就是我们想要的目标字符，如下图，第二次解密的结果才是正确的。

/** * 频率分析法破解凯撒密码 */public class FrequencyAnalysis {//英文里出现次数最多的字符private static final char MAGIC_CHAR = "e";//破解生成的最大文件数private static final int DE_MAX_FILE = 4;public static void main（String[] args） throws Exception {//测试1，统计字符个数//printCharCount（"article1_en.txt"）;//加密文件//int key = 3;//encryptFile（"article1.txt", "article1_en.txt", key）;//读取加密后的文件String artile = file2String（"article1_en.txt"）;//解密（会生成多个备选文件）decryptCaesarCode（artile, "article1_de.txt"）;}public static void printCharCount（String path） throws IOException{String data = file2String（path）;List<Entry<Character, Integer>> mapList = getMaxCountChar（data）;for （Entry<Character, Integer> entry : mapList） {//输出前几位的统计信息System.out.println（"字符"" + entry.getKey（） + ""出现" + entry.getValue（） + "次"）;}}public static void encryptFile（String srcFile, String destFile, int key） throws IOException {String artile = file2String（srcFile）;//加密文件String encryptData = MyEncrypt.encrypt（artile, key）;//保存加密后的文件string2File（encryptData, destFile）;}/** * 破解凯撒密码 * @param input 数据源 * @return 返回解密后的数据 */public static void decryptCaesarCode（String input, String destPath） {int deCount = 0;//当前解密生成的备选文件数//获取出现频率最高的字符信息（出现次数越多越靠前）List<Entry<Character, Integer>> mapList = getMaxCountChar（input）;for （Entry<Character, Integer> entry : mapList） {//限制解密文件备选数if （deCount >= DE_MAX_FILE） {break;}//输出前几位的统计信息System.out.println（"字符"" + entry.getKey（） + ""出现" + entry.getValue（） + "次"）;++deCount;//出现次数最高的字符跟MAGIC_CHAR的偏移量即为秘钥int key = entry.getKey（） - MAGIC_CHAR;System.out.println（"猜测key = " + key + "， 解密生成第" + deCount + "个备选文件" + "
"）;String decrypt = MyEncrypt.decrypt（input, key）;String fileName = "de_" + deCount + destPath;string2File（decrypt, fileName）;}}//统计String里出现最多的字符public static List<Entry<Character, Integer>> getMaxCountChar（String data） {Map<Character, Integer> map = new HashMap<Character, Integer>（）;char[] array = data.toCharArray（）;for （char c : array） {if（！map.containsKey（c）） {map.put（c, 1）;}else{Integer count = map.get（c）;map.put（c, count + 1）;}}//输出统计信息/*for （Entry<Character, Integer> entry : map.entrySet（）） {System.out.println（entry.getKey（） + "出现" + entry.getValue（） + "次"）;}*///获取获取最大值int maxCount = 0;for （Entry<Character, Integer> entry : map.entrySet（）） {//不统计空格if （/*entry.getKey（） ！= " " && */entry.getValue（） > maxCount） { maxCount = entry.getValue（）;}}//map转换成list便于排序List<Entry<Character, Integer>> mapList = new ArrayList<Map.Entry<Character,Integer>>（map.entrySet（））;//根据字符出现次数排序Collections.sort（mapList, new Comparator<Entry<Character, Integer>>（）{@Overridepublic int compare（Entry<Character, Integer> o1,Entry<Character, Integer> o2） {return o2.getValue（）.compareTo（o1.getValue（））;}}）;return mapList;}public static String file2String（String path） throws IOException {FileReader reader = new FileReader（new File（path））;char[] buffer = new char[1024];int len = -1;StringBuffer sb = new StringBuffer（）;while （（len = reader.read（buffer）） ！= -1） {sb.append（buffer, 0, len）;}return sb.toString（）;}public static void string2File（String data, String path）{FileWriter writer = null;try {writer = new FileWriter（new File（path））;writer.write（data）;} catch （Exception e） {e.printStackTrace（）;}finally {if （writer ！= null） {try {writer.close（）;} catch （IOException e） {e.printStackTrace（）;}}}}}

对称加密
介绍
加密和解密都使用同一把秘钥，这种加密方法称为对称加密，也称为单密钥加密。
简单理解为：加密解密都是同一把钥匙。
凯撒密码就属于对称加密，他的字符偏移量即为秘钥。
对称加密常用算法
AES、DES、3DES、TDEA、Blowfish、RC2、RC4、RC5、IDEA、SKIPJACK 等。
DES：全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法，1976 年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），随后在国际上广泛流传开来。
3DES：也叫Triple DES，是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。
它相当于是对每个数据块应用三次DES 加密算法。由于计算机运算能力的增强，原版DES 密码的密钥长度变得容易被暴力破解；3DES 即是设计用来提供一种相对简单的方法，即通过增加DES 的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法。
AES: 高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael 加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001 年11 月26 日发布于FIPS PUB 197，并在2002 年5 月26 日成为有效的标准。2006 年，高级加密标准已然成为对称密钥加密中最流行的算法之一。
DES 算法简介
DES 加密原理（对比特位进行操作，交换位置，异或等等，无需详细了解）
准备知识
Bit 是计算机最小的传输单位。以0 或1 来表示比特位的值
例如数字3 对应的二进制数据为：00000011
代码示例

 int i = 97; String bit = Integer.toBinaryString（i）; //输出：97 对应的二进制数据为： 1100001 System.out.println（i + "对应的二进制数据为： " + bit）;

Byte 与Bit 区别
数据存储是以“字节”（Byte）为单位，数据传输是以大多是以“位”（bit，又名“比特”）为单位，一个位就代表一个0 或1（即二进制），每8 个位（bit，简写为b）组成一个字节（Byte，简写为B），是最小一级的信息单位。
Byte 的取值范围：

//byte 的取值范围：-128 到127System.out.println（Byte.MIN_VALUE + "到" + Byte.MAX_VALUE）;

即10000000 到01111111 之间，一个字节占8 个比特位
二进制转十进制图示：

这里写图片描述
任何字符串都可以转换为字节数组

String data = "1234abcd";byte[] bytes = data.getBytes（）;//内容为：49 50 51 52 97 98 99 100

上面数据49 50 51 52 97 98 99 100 对应的二进制数据（即比特位为）：

00110001
00110010
00110011
00110100
01100001
01100010
01100011
01100100
将他们间距调大一点，可看做一个矩阵：

0 0 1 1 0 0 0 1
0 0 1 1 0 0 1 0
0 0 1 1 0 0 1 1
0 0 1 1 0 1 0 0
0 1 1 0 0 0 0 1
0 1 1 0 0 0 1 0
0 1 1 0 0 0 1 1
0 1 1 0 0 1 0 0
之后可对他们进行各种操作，例如交换位置、分割、异或运算等，常见的加密方式就是这样操作比特位的。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。