【CTF解题】密码学中的加密算法

简介

在日常生活中，很多人的账号密码、银行卡、app上登录的密码，按人的习惯都会设置成让自己好记一些的密码，如出生年月日、生日加名字、手机号、等等，公共场合的WIF也是如此，安全意识不够强就会存在弱密码。

假如你的QQ密码泄露了，那么坏人会拿着你的账号和密码去登录游戏，和一些不需验证的平台，又或是假冒你的身份，给你的朋友发送诈骗的信息。
有一种叫做撞库，得到你的账号和密码时，就会根据你注册过的网站，进行登录往往都会成功，一般来说人对密码的记忆总是会忘的，记那么多还不如记住一个就够了，这样密码都是一致的了那么撞库的可能性就很大了。

在日常的暴力破解中，采用纯数字的密码是最容易破解的，我会结合以下的几点给大家讲解下。

纯数密码

纯3位数字的密码，在日常生活中很常见，如行李箱它会有密码也有锁，两个都可以打开行李箱的。
是纯数字的话，那么就从 0 1 2 3 4 5 6 7 8 9 有十个数，要计算那么就是 10 的 3次方，也就等于 1000 种可能。

计算1秒执行次数

import datetime

startTick = datetime.datetime.now()
i = 0
while True:
    i = i + 1
    endTick = datetime.datetime.now()
    if (endTick - startTick).seconds == 1:
        break
print(i)

在Python中运行了下代码，我的电脑跑了下理论上一秒一百四十多万左右，这个都说不定的只是大概上，这个还得看电脑性能了，可以发现破解三位数的密码都花不上1秒时间。

计算时间差

import time
import datetime

start = datetime.datetime.now()
time.sleep(5)
end = datetime.datetime.now()
print((end - start).seconds)

计算公式

10 ^ 3 = 1000 次 # 因为从0到9是10个数字 密码有三位那就用 10 ^ 3 = 1000 种可能性
10 ^ 8  ÷ 1000000 ÷ 60 = 1 分钟 # 密码 ^ 位数 ÷ 1秒次数 ÷ 60 = 1分钟
10 ^ 8  ÷ 1000 ÷ 60 ÷ 60 = 27 小时
10 ^ 8  ÷ 1000 ÷ 60 ÷ 60 ÷ 24 = 1 天 
10 ^ 8 ÷ 10 ÷ 60 ÷ 60 ÷ 365 = 7 年

同理密码长度可以更改一下，得到了电脑1秒运算的次数，直接可以利用这个公式可以计算出，以上可以看出8位数字的纯密码破解只需要1分钟，就可以试完密码范围所有的可能性，以下这张表可以很明显的看出来。

总结

大小写加符号作为密码不用纯数字，可以减少暴力破解的成功率。
密码最好准备几个，不要用同一个密码，避免被撞库登录。

加密思想

置换：按照规则替换文明信息。
移位：打乱字母的排列顺序。
移位和置换都是可逆操作，容易恢复信息。
移位 置换应用于现代算法中。

加密实现 不只是依赖以上基本思想 同时依赖很多巧妙的设计。
如军事应用的加密电报 除了使用安全性很高的编码规则以外，解密还涉及到发报文双方的约定。

凯撒密码 Caesar cipher

由Julius Caesar发明
英语：Caesar cipher

明文字母: A B C D E F G H I K L M N O P Q R S T V X Y Z
密文字母: D E F G H I K L M N O P Q R S T V X Y Z A B C
注意: 共23个字母 而 J U W 拉丁文不用

明文: meet me after the toga party
密文: PHHW PH DIWHU WKH WRJD SDUWB

单表代替密码不能掩盖明文语言所有统计特性。

对称加密 Symmetric encryption

对称加密：使用同一密钥进行加密和解密
传统密码加密
私钥算法加密

优势：加解密速度快，密文是紧凑，安全
对称加密密钥长度从40bits到168bits
著名加密算法:
DES 3DES AES RC系列（RC2 RC4 RC5）
IDEA CAST Blowfish

DES（Data Encryption Standard）

DES是一种分组加密算法 20世纪70年代 由IBM公司发明
1976年11月纳为美国家标准
DES密钥是固定56bit，不安全
DES以块模式对64bit的密文进行操作

3DES（Triple DES）

密钥长度放大3倍，168位。
暴力破解几乎不可能实现。
安全但会增加延迟，语言视频不适用。

AES （Advanced Encryption Standard）

1997年被发布取代DES加密算法
适用于高速网络，适合的硬件上实现
使用128位 192位或256位密钥块（还能扩展32bit）
3DES替代加密技术，软硬件运行效率高，可用于无限/语音视频加密

RC4（Rivest Cipher 4）

Rivest设计
密钥长度可变
流模式加密算法，面向bit操作
算法基于随机置换
RC4应用广泛 (https/WEP/WPA) WPA2-AES

非对称加密 Asymmetric Cryptography

公钥加密比私钥加密出现的晚
私钥加密使用同一个密钥来加密和解密信息
公钥加密使用两个密钥，一个密钥用于加密信息，另一个用来解密信息。

公钥加密，私钥解密
公钥加密，公钥不能解密
私钥加密，私钥不能解密

应用: 公钥加密，保密性 私钥加密：数字签名

私钥需要安全保存（不通过网络传送）
密钥公开
加密速度慢，密文非紧凑
可以与对称加密相结合

RSA（Rivest-Shamir-Adleman）

1977年由Ron Rivest、Adi Shamir和Len Adelman开发专利于2000年9月到期
密钥长度在512~4096bit之间
安全性基于大素数因子分解的困难性
RSA比用软件实现的DES慢100倍.RSA比用硬件实现的DES慢1000倍
RSA的主要功能∶加密、数字签名和密钥交换（加密散列、密钥)

数字签名过程

数字证书与CA

简：主要用来证明这个公钥是不是你的，由CA权威机构通过数字证书去证明。

MD5 Hash

将一段数据（任意长度)经过一道计算，转换为一段定长的数据。
不可逆性: 几乎无法通过Hash结果推导出原文，即无法通过x的Hash值推导出x。
无碰撞性: 几乎没有可能找到一个y，使得y的Hash值等于x的Hash值。
雪崩效应: 输入轻微变化，Hash输出值产生巨大变化 单向不可能从散列值推出原始数据。

有的加密算法是可以被逆向破解而有的是破解不了的，就会有可逆和不可逆的说法，它们分为对称加密和非对称加密。

不可逆加密

• 不可逆向的最大特点就是不需要密钥，HMAC是需要的但还是不可逆
• 常见的不可逆加密算法有 MD5、HMAC、SHA1
• SHA-224、SHA-256、SHA-384、SHA-512 统称SHA2加密算法
• SHA加密算法安全性比MD5的还要高

可逆加密

• 可逆加密算法有 DES、3DES、AES128、AES192、AES256 属于对称加密
• RSA、SM2、RS256 （采用SHA-256 RSA的签名）属于非对称加密
• Base64编码 不属于加密算法 只是一种编码

MD5加密算法

MD5 信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。

压缩性：无论数据长度是多少，计算出来的MD5值长度相同
容易计算性：由原数据容易计算出MD5值
抗修改性：即便修改一个字节，计算出来的MD5值也会巨大差异
抗碰撞性：知道数据和MD5值，很小概率找到相同MD5值相同的原数据

package main

import (
    "crypto/md5"
    "fmt"
)

func Calcmd5(cont string) string {
    data := []byte(cont)
    has := md5.Sum(data)
    md5str := fmt.Sprintf("%x", has)
    return md5str
}

func main() {
    sum := Calcmd5("go")
    fmt.Println(sum)
}

HMAC算法

HMAC是密钥相关的哈希运算消息认证码（Hash-based Message Authentication Code）的缩写，由H.Krawezyk，M.Bellare，R.Canetti于1996年提出的一种基于Hash函数和密钥进行消息认证的方法，并于1997年作为RFC2104被公布，并在IPSec和其他网络协议（如SSL）中得以广泛应用，现在已经成为事实上的Internet安全标准。它可以与任何迭代散列函数捆绑使用。

package main

import (
    "crypto/hmac"
    "crypto/sha512"
    "encoding/base64"
    "fmt"
)

func ComputHmacSha512(message string, secret string) string {
    data := []byte(secret)
    hmacd := hmac.New(sha512.New, data)
    hmacd.Write([]byte(message))
    return base64.StdEncoding.EncodeToString([]byte(hmacd.Sum(nil)))
}

func main() {
    ret := ComputHmacSha512("123", "dGhpcyBpcyBhIGtleQ==")
    fmt.Println(ret)
}

SHA系列

安全散列算法（英语：Secure Hash Algorithm，缩写为SHA）是一个密码散列函数家族，是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。且若输入的消息不同，它们对应到不同字符串的机率很高。SHA-1加密算法有碰撞的可能性，虽然很小。

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

func GetSha256(str string) string {
    srcByte := []byte(str)
    sha256New := sha256.New()
    sha256Bytes := sha256New.Sum(srcByte)
    sha256String := hex.EncodeToString(sha256Bytes)
    return sha256String
}
func main() {
    ret := GetSha256("123")
    fmt.Println(ret)
}

Base64编码

package main

import (
    "encoding/base64"
    "fmt"
)

func Base64Encoding(str string) string {
    src := []byte(str)
    res := base64.StdEncoding.EncodeToString(src)
    return res
}

func Base64Decoding(str string) string {
    res, _ := base64.StdEncoding.DecodeString(str)
    return string(res)
}

func main() {
    src := "FanOne"
    res := Base64Encoding(src)
    fmt.Println("FanOne 编码成为：", res)
    ret := Base64Decoding(res)
    fmt.Println(res, "解码成为：", ret)
}

TEA加密

#include <stdio.h>

void encrypt(unsigned int *v, unsigned int *k)
{
    unsigned int v0 = v[0], v1 = v[1], sum = 0;
    unsigned int delta = 0x9e3779b9;
    for (int i = 0; i < 32; i++)
    {
        sum += delta;
        v0 += ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1]);
        v1 += ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3]);
    }
    v[0] = v0;
    v[1] = v1;
}

void decrypt(unsigned int *v, unsigned int *k)
{
    unsigned int v0 = v[0], v1 = v[1], sum = 0xC6EF3720;
    unsigned int delta = 0x9e3779b9;
    for (int i = 0; i < 32; i++)
    {
        v1 -= ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3]);
        v0 -= ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1]);
        sum -= delta;
    }
    v[0] = v0;
    v[1] = v1;
}

int main()
{
    unsigned int v[2] = {6, 9}, k[4] = {1, 2, 3, 4};
    printf("Original data: %u %u\n", v[0], v[1]);
    encrypt(v, k);
    printf("Encrypted data: %u %u\n", v[0], v[1]);
    decrypt(v, k);
    printf("Decrypted data: %u %u\n", v[0], v[1]);
    return 0;
}