亲宝软件园·资讯

展开

Android对称加密与非对称加密 Android对称加密与非对称加密

axi295309066 人气:0
想了解Android对称加密与非对称加密的相关内容吗,axi295309066在本文为您仔细讲解Android对称加密与非对称加密 的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点: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 码值转成char
int 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->b
      ascii = ascii + key;
      //ASCII 码值转换为char
      char newChar = (char) ascii;
      //替换原有字符
      array[i] = newChar;

      //以上4 行代码可以简写为一行
      //array[i] = (char) (array[i] + key);
    }

    //字符数组转换成String
    return 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->a
      ascii = ascii - key;
      //ASCII 码值转换为char
      char newChar = (char) ascii;
      //替换原有字符
      array[i] = newChar;

      //以上4 行代码可以简写为一行
      //array[i] = (char) (array[i] - key);
    }

    //字符数组转换成String
    return 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 + "个备选文件" + "\n");
      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>>(){
      @Override
      public 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 到127
System.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

之后可对他们进行各种操作,例如交换位置、分割、异或运算等,常见的加密方式就是这样操作比特位的。

加载全部内容

相关教程
猜你喜欢
用户评论