password_study

密码学的基本概念

信息安全的基本属性

1. 机密性

• 保证信息为授权者使用而不泄漏给未经授权者
• 别人“看不到”或“看不懂”

2. 认证

• 消息认证：保证消息来源的真实性
• 身份认证：确保通信实体的真实性
• 证明“你就是你”

3. 完整性

• 数据完整性：未被未授权篡改或损坏
• 系统完整性：系统未被非授权操纵，按既定的功能运行
• 信息没有被动过

4. 不可否认性

• 要求无论发送方还是接收方都不能抵赖所进行的传输

5.可靠性

• 特定行为和结果的一致性

6. 可用性

• 保证信息和信息系统随时为授权者提供服务，而不要出现非授权者滥用却对授权者拒绝服务的情况

7. 可控性

• 授权实体可以控制信息系统和信息使用的特性

8. 审计

• 确保实体的活动可被跟踪

什么是密码学

1.密码学能做什么？

• 机密性：如何使得某个数据自己能看懂，别人看不懂
• 认证：如何确保数据的正确来源，如何保证通信实体的真实性
• 完整性：如何确保数据在传输过程中没有被删改
• 不可否认性：如何确保用户行为的不可否认性

2. 功能如何实现？

• 算法
• 协议

密码算法的分类

1. 基本概念

• 明文——要处理的数据（Message）
• 密文——处理后的数据（Ciphertext）
• 密钥——秘密参数（Key）
• 加密函数/解密函数

2. 密码算法需求

• 需求1:可逆——算法的使用者可以将密文恢复成明文
• 需求2:不可逆——敌手无法将密文恢复成明文
• 秘密参数——密钥

密码算法实际上是一个带有秘密参数的函数

• 知道秘密参数，求逆非常容易
• 不知道秘密参数，求逆是不可行的

3. 按功能分类

• 加密算法：用于机密性解决方案
• 杂凑函数：用于完整性解决方案
• 数字签名：用于认证和不可否认性

4. 按密钥的使用方式分类

• 对称密钥密码算法：加密密钥与解密密钥
  • 分组密码
  • 流密码
• 非对称密钥密码算法：加密密钥与解密密钥不同
  • 公钥加密
  • 数字签名

密码学的作用和地位

密码分析学

安全的定义

1. 密码分析学的前提

Kerckhoffs假设:假定密码分析者和敌手知道所使用的密码系统。即密码体制的安全性仅依赖于对密钥的保密，而不应依赖于算法的保密。

假设敌手知道 ：

• 所需使用的加密算法
• 知道明文的概率分布规律
• 知道密钥的概率分布规律
• 知道所有可能的破译方法
• 敌手能够拿到加密装置，可以对其进行能量消耗分析等

2. 密码分析学的目标

• 恢复合法密文相应的明文
• 恢复密钥

密码分析方法的分类

1. 密码体制的攻击方法

• 穷举攻击：通过试遍所有的密钥来进行破译
  • 对抗：可增大密钥的数量
• 统计分析攻击：通过分析密文和明文的统计规律来破译
  • 对抗：设法使明文和密文的统计规律不一样
• 解密变换工具：针对加密变换的数学基础，通过数学求解设法找到解密变换
  • 对抗：选用具有坚实的数学基础和足够复杂的加密算法

2. 密码体制的攻击

即密码破译，目的在于破译出密钥或密文

攻击强度自上而下越来越强

• 唯密文攻击
  • 密码分析者仅知道一些密文
  • 最困难，一般是穷搜索，对截获密文用所有可能密钥去试
  • 唯密文攻击是敌手知道的信息量最少，最容易抵抗的
  • 只要有足够的计算时间和存储容量，原则上是可以成功的
• 已知明文攻击
  • 密码分析者知道一些明文和相应密文
  • 在很多情况下，敌手很有可能有更多的信息，也许能截获一个或多个明文及其对应的密文，或消息中将出现某种明文格式，这时的攻击称为已知明文攻击，敌手也许能从已知的明文被变换成密文的方式得到密钥。
• 选择明文攻击
  • 密码分析者可以选择一些明文，并得到相应的密文
  • 如果攻击者能在加密系统中插入自己选择的明文消息，则通过该明文消息对应的密文有可能确定出密钥的结构
  • 明文可以是精心选择的
• 选择密文攻击
  • 密码分析者可以选择一些密文，并得到相应的明文
  • 攻击者利用解密算法，对自己所选的密文解密出相应的明文，又可能确定出密钥的信息
  • 选择的密文可以与要破解的密文相关

无条件安全和计算上安全

1.无条件安全(不可破译的)

无论截获多少密文，都没有足够信息来唯一确定明文，则该密码是无条件安全的，即算法的的破译不比猜测有优势。

2. 计算上安全的

使用有效资源对一个密码系统进行分析而未能破译，则该密码是强的或计算上安全的。

3. 密码算法要满足的的准则

密码算法只要满足以下两条准则之一就行：

• 破译密文的代价超过被加密信息的价值
• 破译密文所花的时间超过信息的有用期

古典密码学

替换法

就是使用固定的信息，将原文替换成密文。

替换法的加密方式有两种：第一种，单表替换；第二种，多表替换

例如: bee ,将 b 替换成 w , e 替换 p , 单词变成wpp

1. 单表替换

原文和密文使用的是同一张表

例如： abcde —–> swtrp

2. 多表替换

表示有多张表，原文和密文进行对比

例如：

表1:abcde-swtrp 表2:abcde-chfhk 表3:abcde-jftou

原文： bee

密钥：312

密文：fpk

移位法

按照字母，在字母表上面的位置，进行位移

• 凯撒加密

  例如： abcde往后移2位cdefg

古典密码学的破解方式

频率分析法

原理是在不知道密钥的情况下想破解密钥

主要使用“概率论”的数学方法破解古典密码。

频率分析：主要是指研究字母或字母组合在文本中出现的频率。

英文单词中字母出现的频率是不同的，e以12.702%的百分比占最高，z只占到0.074%，如果密文数量足够大，仅采用频率分析法就可以破解单表的替换法或位移法。

举例：

当我们拿到密文的时候，密文里面也会出现一个频率最高的字母，假设密文里面出现频率最高的是j，可以假设密文里面的j，就是明文里面的e，假设密文里面出现频率第二个高的字母，假设在明文当中的t。(随便找一篇英文文章)

There are moments in life when you miss someone so much that you just want to pick them from your dreams and hug them for real! Dream what you want to dream;go where you want to go;be what you want to be,because you have only one life and one chance to do all the things you want to do.

　　May you have enough happiness to make you sweet,enough trials to make you strong,enough sorrow to keep you human,enough hope to make you happy? Always put yourself in others’shoes.If you feel that it hurts you,it probably hurts the other person, too.

　　The happiest of people don’t necessarily have the best of everything;they just make the most of everything that comes along their way.Happiness lies for those who cry,those who hurt, those who have searched,and those who have tried,for only they can appreciate the importance of people

　　who have touched their lives.Love begins with a smile,grows with a kiss and ends with a tear.The brightest future will always be based on a forgotten past, you can’t go on well in lifeuntil you let go of your past failures and heartaches.

　　When you were born,you were crying and everyone around you was smiling.Live your life so that when you die,you're the one who is smiling and everyone around you is crying.

　　Please send this message to those people who mean something to you,to those who have touched your life in one way or another,to those who make you smile when you really need it,to those that make you see the brighter side of things when you are really down,to those who you want to let them know that you appreciate their friendship.And if you don’t, don’t worry,nothing bad will happen to you,you will just miss out on the opportunity to brighten someone’s day with this message.

工具类

public class Util {
    public static void print(byte[] bytes){
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < bytes.length; i++) {
            stringBuffer.append(bytes[i]).append(" ");
        }
        System.out.println(stringBuffer);
    }
    public static String file2String(String path) throws IOException{
        FileReader reader = new FileReader(new File(path));
        char[] buffer = new char[1024];
        int len = -1;
        StringBuffer stringBuffer = new StringBuffer();
        while ((len = reader.read(buffer)) != -1) {
            stringBuffer.append(buffer, 0, len);
        }
        return stringBuffer.toString();
    }
    public static void string2File(String data, String path){
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(new File(path));
            fileWriter.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fileWriter !=null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static String inputStream2String(InputStream in)throws IOException{
        int len = -1;
        byte[] buffer = new byte[1024];
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        while((len = in.read(buffer)) != -1){
            byteArrayOutputStream.write(buffer, 0, len);
        }
        byteArrayOutputStream.close();
        return byteArrayOutputStream.toString("UTF-8");
    }
}

分析法破解凯撒密码

public class FrequencyDemo {
    //英文里出现次数最多的字符
    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("/Users/xingyuchen/Downloads/password-study/password-study/frequency/src/main/java/frequency/article/article.txt");

        //加密文件
      int key = 3;
      encryptFile("/Users/xingyuchen/Downloads/password-study/password-study/frequency/src/main/java/frequency/article/article.txt", "/Users/xingyuchen/Downloads/password-study/password-study/frequency/src/main/java/frequency/article/article_en.txt", key);

        System.out.println("111111");
        //读取加密后的文件
        String artile = Util.file2String("/Users/xingyuchen/Downloads/password-study/password-study/frequency/src/main/java/frequency/article/article_en.txt");
        //解密（会生成多个备选文件）
        decryptCaesarCode(artile, "/Users/xingyuchen/Downloads/password-study/password-study/frequency/src/main/java/frequency/article/article");
    }

    public static void printCharCount(String path) throws IOException {
        String data = Util.file2String(path);
        List<Map.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 = Util.file2String(srcFile);
        //加密文件
        String encryptData = KaiserDemo.encryptKaiser(artile, key);
        //保存加密后的文件
        Util.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 = KaiserDemo.decryptKaiser(input, key);

            String fileName = destPath + "_de" + deCount + ".txt";
            Util.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<Entry<Character,Integer>>(map.entrySet());
        //根据字符出现次数排序
        Collections.sort(mapList, new Comparator<Entry<Character, Integer>>(){

            public int compare(Entry<Character, Integer> o1,
                               Entry<Character, Integer> o2) {
                return o2.getValue().compareTo(o1.getValue());
            }
        });
        return mapList;
    }
}

结果

现代密码学

散列函数

也叫做哈希函数

常见的加密方式：MD5、SHA-1、SHA-256

对称加密

加密和解密方式使用的是同一把密钥。

对称加密分成：序列密码(流密码)、分组密码(块密码)两种

流密码是对信息流中的每一个元素(字母或比特)作为基本的处理单元进行加密，块密码是先对信息流分块，再对每一块分别加密。

例如：

原文为1234567890，流加密先对1进行加密，再对2进行加密，再对3进行加密…最后拼成密文；块加密先分成不同的块，如1234成块，5678成块，90XX成块，再分别对不同的块进行加密，最后拼接成密文。

常见加密算法

DES

是一种使用密钥加密的块算法。

加密

如果使用DES加密，密钥key必须是8个字节

//创建加密对象
Cipher des = Cipher.getInstance("DES");
//创建加密规则
//第一个参数：密钥的字节
//第二个参数：加密的类型!=加密算法
SecretKeySpec secretKeySpec = new SecretKeySpec(DESDemo.KEY.getBytes(),"DES");

//进行加密初始化
//第一个参数表示 模式，加密/解密模式
//第二个参数表示 加密规则

des.init(Cipher.ENCRYPT_MODE, secretKeySpec);
//调用加密方法
//参数：原文的字节数组
byte[] bytes = des.doFinal(DESDemo.INPUT.getBytes());
System.out.println(new String(bytes));
//创建Base64对象
String encode = Base64.encode(bytes);
System.out.println(encode);

出现乱码ɼ�d��c的原因，是因为对应的字节出现负数，但负数在ASCII码中没有，需要用Base64转码，转码后就出现ybz/ZIEclmM=

解密

//获取解密对象
Cipher des = Cipher.getInstance("DES");
//创建解密规则
SecretKeySpec secretKey = new SecretKeySpec(DESDemo.KEY.getBytes(), "DES");
//进行解密初始化
des.init(Cipher.DECRYPT_MODE,secretKey);
//解密,传入密文
byte[] bytes = des.doFinal(Base64.decode(DESDemo.OUTPUT));
System.out.println(new String(bytes));
//结果：算法

注意

• 密钥Key必须是8个字节

Base64

由64个字符组成，大写A-Z,小写a-z，数字0-9，+和/

Base64不是加密算法，是可读性算法。

Base64算法原理：

把3个8位字节(3*8=24)转化为4个6位的字节(4*6=24),之后在每个6位的前面补两个0，形成8位，即一个字节。再根据每个字节的值，用下表中的值替换，不足4个字节的，补”=”

• 人工手算Base64的编码结果，用程序验证（升职）

  第一步：找到中文字符在操作系统中对应字符编码表代码(chcp) GB2312

  第二步 ：中文找到字符编码中的十进制数

  升(C9F0+D=十六进制转十进制=>51696 + 13 = 51709)

  职(D6B0+0=十六进制转十进制=>54960 + 0 = 54960)

  第三步 ：把十进制转换为二进制

  升 11001001 11111101

  职 11010110 10110000

  第四步 ：对二进制进行分组，每6个一组，不齐的后面补0补齐

  升职(110010 01111 111011 101011 010110 000000)

  第五步 ：将分组完的二进制转十进制，去Base64中查找对应的编码

  (50 31 55 22 44 11 51 19 52 11 52)==>对应Base64编码表(y f 3 W s L z T 0 L 0 =)[=是Base64的结束符]

• Base64三个字节为一组，如果不足三个字节就补=号

  • MQ==(1表示一个字节)
  • MTI=(12表示两个字节)
  • MTIz(123表示三个字节)

问题：

Base64到底能做什么？

• Base64是一种编码格式，是为了换一种体现形式，以便于传输提高可读性。
• 在什么情况下使用Base64？
  • URL特殊字符，空格等的转码转义
  • 嵌入图片 src=”base64编码后的内容”
  • 语言文字，底层都是用二进制来存储的，但是二进制不能直接传播，所以可以将二进制转换成Base64

Base58

一般用在比特币里面的一种编码方式

没有数字0，也没有字母o，没有大写字母I，没有小写字母i，也没有+和/

AES

采用一种区块加密标准，加解密代码用这个标准替代原先的DES。

特点

• 加密速度快，可以加密大文件
• 密文可逆，一旦密钥文件泄漏，就会导致数据暴露
• 加密后编码表找不到对应字符，出现乱码
• 一般结合Base64使用

非对称加密

有两把密钥，使用公钥加密，使用私钥解密/使用私钥加密，使用公钥解密

ASCII编码

ASCII是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是现金最通用的单子接编码系统，并等同于国际ISO/IEC 646.

添加pom文件

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

创建Demo类，将字符转换成ASCII码

1.字符转换成ASCII码

public static void main(String[] args) {
    char a =  'A';//65
    char c =  'a';//97
    int b = a;
    int d = c;
    //打印b，在ASCII当中十进制的数字对应是多少
    System.out.println(d);
}

2.字符串转换成ASCII码

public static void main(String[] args) {
    //定义字符串
    String a = "AaZ";
    //需要拆开字符串
    char[] chars = a.toCharArray();
    for (char aChar : chars) {
        int asciiCode = aChar;
        //打印单个字符，在ASCII当中十进制的数字对应是多少
        System.out.println(asciiCode);
    }
}

凯撒加密

原理：是把26个字母，进行位移，往左边或者往右边进行位移，在位移的时候，需要注意，最多只能移动25位

加密

//定义原文
String input = "Hello World";
//定义密文
StringBuilder output = new StringBuilder();
//使用凯撒加密将原文往右移动三位
//定义一个密钥
int key = 3;
//把字符串变成字节数组
char[] chars = input.toCharArray();
for (char aChar : chars) {
    //拿到字节数组的ASCII
    int b = aChar;
    //往右移动三位
    b = b+3;
    char newb = (char)b;
    output.append(newb);
}
System.out.println("密文:" + output.toString());

解密

//定义密文
String output = "Khoor#Zruog";
//初始化明文
StringBuilder input = new StringBuilder();
//定义密钥
int key = 3;
char[] chars = output.toCharArray();
for (char aChar : chars) {
    int b = aChar;
    b = b - key;
    input.append((char)b);
}
System.out.println("原文为:" + input.toString());

Byte和bit

Byte：字节。数据存储的基本单位，比如移动硬盘1T，单位是byte

bit：比特，又叫位。一位要么是0要么是1.数据传输的单位，比如家里的宽带100MB，下载速度并没有达到100MB，一般都是12-13MB，那么是因为需要100/8

关系：1Byte = 8bit

获取字符串byte

英文

String s = "abc";
byte[] bytes = s.getBytes();
for (byte aByte : bytes) {
    int b = aByte;
    //打印发现byte实际就是ASCII码
    System.out.println(b);
    //查看该Byte字节对应的bit是多少
    String bit = Integer.toBinaryString(b);
    System.out.println(bit);
}
/*
97
1100001
98
1100010
99
1100011
*/

中文

根据编码的格式不一样，对应的字节也不一样

如果是UTF-8:一个中文对应的是三个字节

如果是GBK：一个中文对应的是两个字节

如果是英文，就无所谓编码格式

String s = "这个";
byte[] bytes = s.getBytes();
//将字节数组转换回字符串
System.out.println(new String(bytes,"UTF-8"));
for (byte aByte : bytes) {
    int b = aByte;
    //打印发现byte实际就是ASCII码
    System.out.println(b);
    //查看该Byte字节对应的bit是多少
    String bit = Integer.toBinaryString(b);
    System.out.println(bit);
}

赏

谢谢你请我吃糖果

支付宝

微信