密码学知识入门

最新推荐文章于 2024-03-17 15:32:25 发布
最新推荐文章于 2024-03-17 15:32:25 发布
阅读量2.4k 收藏 7
点赞数
分类专栏： 技术总结 文章标签： 密码学 RSA 数据安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lenyusun/article/details/79369857
版权

一、安全问题出现

现在越来越多的人利用互联网支付，转账等功能，方便之余，难免会心生疑问，账号会不会被人盗取？这就对数据安全提出了挑战，为了解决这个问题，数据的加密就显得异常重要了。

二、基本概念

加解密的过程就是发送方将明文通过密钥计算变成密文，接收方再将密文通过密钥计算变成可明文，从而保证在信息传输过程中的具备：可鉴别，完整，防泄漏。

  1. 可鉴别：通过验证签名的方式，可以知道发送消息的人是否是可信赖的对方
  2. 完整：通过算法不完整的数据和被串改的数据无法被解密
  3. 防泄漏：只要没有掌握密钥算法，即使内容被抓取到也无法得到真实的信息。

针对以上特性我们要着重介绍一下：对称算法、非对称算法，数字签名

对称算法

加解密使用同一个密钥，所以如何安全的传递密钥成了最头疼的问题。
这里写图片描述

(1) 甲方将明文使用密钥加密，密文传输给乙方。
(2) 乙方收到密文后，用同一个密钥，解密得到明文。

由于双方采用统一密钥规则，在传递和保持中如何保证密钥的安全，就成了头疼的问题。
### 非对称算法
加解密采用不同密钥，称为公钥和私钥，公私钥成对出现，采用公钥加密，只能用配对的私钥解密。
绿色表示公钥，棕色表示私钥

(1) 乙方生成一对公私钥，并将公钥给甲方
(2) 甲方利用乙方给的公钥将明文加密，生成密文，传输给乙方
(3) 乙方接收到密文，用配对的私钥解密，解出明文

这种方式私钥严格保密，公钥可以对外公布，解决了密钥传递和保存中的安全性问题。
在密码学中还有一个比较重要的概念就是确认发送方身份，也就是签名验证。

数字签名

数字签名，就是只有信息的发送者才能产生的别人无法伪造的一段数字串，这段数字串同时也是对信息的发送者发送信息真实性的一个有效证明。提到数字签名一定绕不开非对称算法和散列函数，数字签名有两个过程：签名和验证，具体的过程如下
这里写图片描述

(1) 乙方生成一对公私钥，并将公钥给甲方
(2) 乙方用其私钥对文件做加密，并签名
(3) 甲方对文件解密，并验证签名

由于文件内容做加解密算法比较费时，所以一般签名都是采用文件内容通过散列算法得出的字符串（图里的摘要可以认为就是这样的一串字符串）做私钥加密，从而得到一串签名数据，这样验签的效率就大大提升了。

算法举例

密码学发展到现在，涌现出来的算法有很多，比如对称算法中的des，aes，非对称算法中的RSA等，下面就以RSA做个实例解析。RSA的算法原理这里就不介绍了，请开wiki，直接上代码吧。本例子中的算法通过openssl的相关接口实现的。

RSA加密实现

// filename:密钥文件名 
// plain_text:明文内容
// is_pubkey: true->公钥加密 false->私钥加密
// encrypt_txt:返回密文
 int OpensslRSAUtil::encrypt(std::string filename, std::string plain_text, bool is_pubkey, std::string& encrypt_txt)
{
                if (plain_text.empty())
                {
                        return eAuthCryptResult_PARAM_ERROR;
                }

                RSA* rsa = RSA_new(); 
                if (!create_rsa(filename, is_pubkey, &rsa)) {
                        if (rsa != NULL) RSA_free(rsa);
                        return eAuthCryptResult_CREATE_RSA_ERROR;
                }

                // 分段加密 每段117个字节
                int data_len = plain_text.length();
                int offset = 0;
                int block_value = 0;
                std::string encrypt_data = "";
                int code = eAuthCryptResult_SUCCESS;
                while(data_len > 0) {
                        char encode[MAX_ENCRYPT_BLOCK_VALUE] = {0};
                        if (data_len >= MAX_ENCRYPT_BLOCK_VALUE) {
                                block_value = MAX_ENCRYPT_BLOCK_VALUE; 
                        } else {
                                block_value = data_len; 
                        } 

                        std::string ming = plain_text.substr(offset, block_value);
                        int ret = 0;
                        if (is_pubkey) {
                                ret = RSA_public_encrypt(block_value, (const unsigned char*)ming.c_str(), (unsigned char*)encode, rsa, RSA_PKCS1_PADDING);
                        } else {
                                ret = RSA_private_encrypt(block_value, (const unsigned char*)ming.c_str(), (unsigned char*)encode, rsa, RSA_PKCS1_PADDING);
                        }
                        if (ret >= 0) {
                                std::string encrypt_tmp(encode, ret);
                                encrypt_data += encrypt_tmp;
                                offset += block_value;
                                data_len = data_len - block_value;
                        } else {
                                code = eAuthCryptResult_ENCRYPT_ERROR; 
                                break;
                        }
                }

                if (code == eAuthCryptResult_SUCCESS) {
                        // base64 加密
                        char* base64Text = NULL;
                        int len = 0;
                        cout << "len:" << encrypt_data.length()<<endl; 
                        base64_encode((const unsigned char*)encrypt_data.c_str(), encrypt_data.length(), &base64Text, len);
                        if (base64Text == NULL) { 
                                code = eAuthCryptResult_BASE64_ENCODE_ERROR;
                        } else {
                                std::string tmp(base64Text, len);
                                encrypt_txt = tmp;
                                replaceString(encrypt_txt, "\n", "");
                                free(base64Text);
                        }
                }
                RSA_free(rsa);
                CRYPTO_cleanup_all_ex_data(); 
                return code;
        }

RSA解密实现

// filename:密钥文件名 
// plain_text:密文内容
// is_pubkey: true->公钥解密 false->私钥解密
// decrypt_txt:返回明文
 int OpensslRSAUtil::decrypt(std::string filename, std::string plain_text, bool is_pubkey, std::string& decrypt_txt)
{
                if (plain_text.empty())
                {
                        return eAuthCryptResult_PARAM_ERROR;
                }

                RSA* rsa = RSA_new(); 
                if (!create_rsa(filename, is_pubkey, &rsa)) {
                        if (rsa != NULL) RSA_free(rsa);
                        return eAuthCryptResult_CREATE_RSA_ERROR;
                }

                // base64解密
                unsigned char* decode_data = NULL;
                size_t data_len = 0;
                base64_decode(plain_text.c_str(), &decode_data, &data_len);
                if (decode_data == NULL) {
                        RSA_free(rsa);
                        return eAuthCryptResult_BASE64_ENCODE_ERROR; 
                }

                // 分段解密 每段128个字节
                int offset = 0;
                int block_value = 0;
                int code = eAuthCryptResult_SUCCESS;
                while(data_len > 0) {
                        char decode[MAX_DECRYPT_BLOCK_VALUE];
                        if (data_len >= MAX_DECRYPT_BLOCK_VALUE) {
                                block_value = MAX_DECRYPT_BLOCK_VALUE; 
                        } else {
                                block_value = data_len; 
                        } 

                        unsigned char* mi = decode_data + offset;
                        int ret = 0;
                        if (is_pubkey) {
                                ret = RSA_public_decrypt(block_value, mi, (unsigned char*)decode, rsa, RSA_PKCS1_PADDING);
                        } else {
                                ret = RSA_private_decrypt(block_value, mi, (unsigned char*)decode, rsa, RSA_PKCS1_PADDING);
                        }
                        if (ret >= 0) {
                                string tmp(decode, ret);
                                decrypt_txt += tmp;
                                offset += block_value;
                                data_len = data_len - block_value;
                        } else {
                                code = eAuthCryptResult_DECRYPT_ERROR; 
                                char msg[1024];
                                print_last_error(msg);
                                break;
                        }
                }

                if (decode_data != NULL) {
                        free(decode_data);
                }
                RSA_free(rsa);
                CRYPTO_cleanup_all_ex_data(); 
                return code;
        }

RSA签名实现

// privkey_filename:私钥文件名 
// plain_text:明文内容
// signature:返回签名字符串
int OpensslRSAUtil::sign(std::string privkey_filename, std::string plain_text, std::string& signature)
{
                if (plain_text.empty())
                {
                        return eAuthCryptResult_PARAM_ERROR;
                }

                RSA* rsa = RSA_new(); 
                if (!create_rsa(privkey_filename, false, &rsa)) {
                        if (rsa != NULL) RSA_free(rsa);
                        return eAuthCryptResult_CREATE_RSA_ERROR;
                }

                unsigned char* encMessage = NULL;
                char* base64Text = NULL;
                int len = 0;
                size_t encMessageLength;
                int code = eAuthCryptResult_SUCCESS;
                if (rsa_sign(rsa, (unsigned char*)plain_text.c_str(), plain_text.length(), &encMessage, &encMessageLength)) {
                        base64_encode(encMessage, encMessageLength, &base64Text, len);
                        std::string tmp(base64Text, len);
                        signature = tmp;
                        replaceString(signature, "\n", "");
                } else {
                        code = eAuthCryptResult_SIGN_ERROR; 
                }
                if (encMessage != NULL) {
                        free(encMessage);
                }
                if (base64Text != NULL) {
                        free(base64Text);
                }

                RSA_free(rsa);
                CRYPTO_cleanup_all_ex_data(); 
                return code;
        }

RSA验签实现

// pubkey_filename:私钥文件名 
// plain_text:密文内容
// signature:签名字符串
// verify_result:返回验签结果
 int OpensslRSAUtil::verify(std::string pubkey_filename, std::string plain_text, std::string signature, bool& verify_result) 
{
                if (plain_text.empty())
                {
                        return eAuthCryptResult_PARAM_ERROR;
                }

                RSA* rsa = RSA_new(); 
                if (!create_rsa(pubkey_filename, true, &rsa)) {
                        if (rsa != NULL) RSA_free(rsa);
                        return eAuthCryptResult_CREATE_RSA_ERROR;
                }

                unsigned char* encMessage = NULL;
                size_t encMessageLength;
                bool authentic = false;
                base64_decode(signature.c_str(), &encMessage, &encMessageLength);
                bool result = rsa_verify_signature(rsa, encMessage, encMessageLength, plain_text.c_str(), plain_text.length(), authentic);
                int code = eAuthCryptResult_SUCCESS;
                if (result) {
                        verify_result = authentic;
                } else {
                        code = eAuthCryptResult_VERIFY_ERROR;
                }
                if (encMessage != NULL) {
                        free(encMessage);
                }
                RSA_free(rsa);
                CRYPTO_cleanup_all_ex_data(); 
                return code;
        }

结束

简单的介绍了一下，密码学的相关知识，偏实用，淡算法理论，有兴趣自己扩展，对实现代码有疑问，可以留言。

参考文献

  1. 密码学基础
  2. RSA原理介绍

大朝书房
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
现代密码学-密码学概论与基本知识
关注网络安全、云原生安全
05-30 3万+
密码学发展简史 1949年，Shannon发表了“保密系统的通信理论（Communication Theory of Secrecy Systems)”一文，为密码学的发展奠定了坚实的理论基础，于是，密码技术的研究迈上了科学的轨道，因而从严格的意义上讲，此后的密码技术才真正称得上密码学。 ...
密码学基础
一个普普通通的博客
06-21 4682
文章目录**密码学基础****一·古典密码**1、栅栏密码（置换，代换）变形2、换位密码（代换密码）2.1、单表替换密码**凯撒密码****仿射密码**2.2、多表替换密码**维吉尼亚密码****希尔密码****猪圈秘密****培根密码****二·现代密码**1、对称密码1.1、分组加密**DES****AES**（CTF中，不知秘钥无法破解）**TEA**1.2、流加密（序列密码）2、**加密模式**（分组模式）ECBCBC3、非对称密码**RSA****攻击**RSA衍生算法--Rabin算法 密码学基
密码学知识点梳理
weixin_43245971的博客
03-17 1153
深入浅出了解密码学，知识导图+习题案例
密码学简单入门
小旺的博客
05-19 2086
密码学简单入门 对称密码学 对称密码学的核心是对称加密算法。对称加密算法是应用较早的加密算法，技术成熟。在对称加密算法中，数据发送方将明文（原始数据）和加密密钥一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。接收方收到密文后，若想解读原文，则需要使用加密过程中用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。在对称加密算法中，使用的密钥只有一个，发、收双方都使用这个密钥对数据进行加密和解密，这就要求解密方事先必须知道加密密钥。 原理与特点 对称加密算法的特点是算法公开、计算量
{“code“:“PARAM_ERROR“,“detail“:{“location“:“body“,“value“:“9200“},“message“:“无法将 JSON 输入源...
qq_38410795冰淇淋的博客
12-27 5138
{"code":"PARAM_ERROR","detail":{"location":"body","value":"9200"},"message":"无法将 JSON 输入源“/body/amount/total”映射到目标字段“总金额”中，此字段需要一个合法的 64 位有符号整数"}查询接口文档发现 参数金额 total为int类型。解决：PARAM_ERROR错误是指参数错误。
PKI基础知识入门，密码学，CA基础
10-13
【PKI基础知识入门，密码学，CA基础】 PKI（Public Key Infrastructure，公共密钥基础设施）是基于密码学原理，用于保障网络通信安全的一套体系。它为用户提供了一种安全的方式来验证信息的真实性和完整性，同时...
密码学入门知识点.pdf
最新发布
06-08
但随着密码学的运用，密码还被用于身份认证、防止否认等功能上。密码是通信双方按约定的法则进行信息特殊变换的一种重要保密手段。依照这些法则，变明文为密文，称为加密变换；变密文为明文，称为脱密变换。密码在...
密码学入门
11-24
### 密码学入门 #### 一、基础知识与数论基础 **1.1 基础知识** **1.1.1 密码学的起源** 密码学是一门研究如何安全地存储和通信信息的学科。其历史可以追溯到古埃及时代，在那时人们就开始使用简单的符号来隐藏...
密码学入门与基本知识1
07-13
在这个密码学入门课程中，你将学习到这些基础知识的理论和实践，包括加密和解密过程、密钥管理、安全性的考量以及实际应用中的案例。掌握这些知识对于理解网络安全的基础和应对现代社会中的信息安全挑战至关重要。...
关键路径计算
03-28
关键路径计算方法，讲解的比较详细，看完后此类型的题可以迎刃而解！
Syclover密码学入门1
08-03
【密码学基础】 密码学是一门融合数学与计算机科学的学科，对于信息安全专业人士而言，它是不可或缺的核心课程...通过不断实践和学习，初学者可以逐步建立起自己的密码学知识体系，为网络安全领域的工作打下坚实基础。
密码学重要知识点
weixin_43211186的博客
03-11 2164
0x01 密码学定义 密码学（Cryptograghy）是研究编制密码和破译密码的技术科学，是研究如何隐密地传递信息的学科。研究密码变化的客观规律，应用于编制密码以保守通信秘密的，称为编码学；应用于破译密码以获取通信情报的，称为破译学，总称密码学。 在现代特别指对信息以及其传输的数学性研究，常被认为是数学和计算机科学的分支，和信息论也密切相关。 著名的密码学者 Ron Rivest 解释道：“密码学是关于如何在敌人存在的环境中通讯”，自工程学的角度，这相当于密码学与纯数学的异同。 密码是通信双
密码学01--密码学常识
FengziTianYu的专栏
12-15 1035
目录 1.为什么要加密 2.加密三要素 2.1 数据 2.2 密钥 2.3 密码算法 3.加密方式 4.最早的加密--凯撒密码 5.密码信息安全常识与威胁 6.对称加密算法 6.1 编解码 6.2 对称加密算法常见三种方式 6.2.1 DES（data encryption stardards） 6.2.2 三DES（triple-data encryption star...
【学习笔记】密码学入门(1)
weixin_43598739的博客
05-09 877
【学习笔记】密码学入门(1) 学习笔记 1 --密码学入门 密码学是研究编制密码和破译密码的技术科学。最初的目的是用于对信息加密，计算机领域的密码技术种类繁多。但随着密码学的运用，密码还被用于身份认证、防止否认等功能上。 密码算法是用于加密和解密的数学函数，密码算法是密码协议的基础。现行的密码算法主要包括序列密码、分组密码、公钥密码、散列函数等，用于保证信息的安全，提供鉴别、完整性、抗抵赖等服务。 计算机安全研究所（Computer Security Institute）报告说，在2007年，接受调查的公司
密码学复习知识点
rocsoft
01-15 4604
密码学密码学1 密码学的基本概念1.1 密码学的基本原理及流程1.2 两类重要密码体制1.3 流密码的基本思想2 分组密码体制2.1 DES2.2 AES2.3 SM42.3 DES、AES、SM4的优缺点及安全强度3 公钥密码体制3.1 公钥密码体系3.2 公钥加密算法步骤3.3 RSA公钥加密体制3.3.1 密钥的产生3.3.2 加密3.3.3 解密3.4 ElGamal公钥加密体制3.4.1 密钥的产生3.4.2 加密3.4.3 解密3.5 ECC公钥加密体制3.5.1 密钥的产生3.5.2 加密3.
密码学总结
Ni9htMar3的博客
03-18 5499
根据网上资料总结而成！~密码学总结作业要求 根据本学期学习过的密码学知识，利用openssl,自己设计一套加密通讯的方案，实现客户端和服务端之间的安全的可靠的加密通讯，形式不限，提供实现代码和实验结果，最终形成实验报告 设计思路首先，任何一套安全的通讯系统在数据传输过程中至少具备以下三个特性： 验证来源的合法性 保证数据的完整性 保证数据的私密性 根据所有加密传输的方法，总共有这几种加密方式对数据的
如何安全存储密码都不知道，难怪我被面试官吊打呢...学完这个一定打回去！...
架构师小秘圈
04-05 700
来自：后端技术指南针1.写在前面网络安全是一个非常重要的领域，今天和大家一起来学习和密码相关的话题。说到密码大家肯定都不陌生，我们每个人都有一些列的密码：邮箱密码、社交网站密码、各种a...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值