IDEA密码算法 + C++代码

最新推荐文章于 2024-05-13 08:05:36 发布
最新推荐文章于 2024-05-13 08:05:36 发布
阅读量598 收藏 6
点赞数 10
文章标签： 算法 c++ 密码学 网络安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qinnb/article/details/134617453
版权

IDEA密码算法

文章目录

IDEA加密流程

国际数据加密算法 (International Data Encryption Algorithm，IDEA) 是最强大的加密算法之一。

IDEA的明文长度为 64 位，而密钥长度为 128 位。

IDEA 加密流程：

在这里插入图片描述

IDEA 每轮的加密过程

在这里插入图片描述

末轮后的输出变换：

在这里插入图片描述

IDEA 密钥的产生：

在这里插入图片描述

代码部分：

#include<iostream>
#include<bitset>
#include<math.h>
using namespace std;
//定义简单的别名
typedef bitset<16> code; //16位
typedef bitset<128> key; //128位秘钥
//定义一些变量
bitset<16> sub_key[52]; //52个子秘钥
bitset<16> inv_sub_key[52]; //52个逆子秘钥
bitset<64> plaint_txt;
异或运算
code XOR(code code_1, code code_2)
{
    return code_1 ^ code_2;
}
加法运算
code Plus(code code_1, code code_2)
{
    int tmp = 0;
    code result;
    for (int i = 0; i < 16; i++) //二进制转换成十进制
    {
        tmp += code_1[i] * pow(2, i) + code_2[i] * pow(2, i);
    }
    tmp %= 65536;
    bitset<16> binary(tmp); //转换成二进制
    for (int i = 0; i < 16; i++)
        result[i] = binary[i];

    return result;
}
逆加法
code invPlus(code code_in)
{
    int tmp = 0;
    code result;
    for (int i = 0; i < 16; i++) //二进制转换成十进制
        tmp += code_in[i] * pow(2, i);
    tmp = 65536 - tmp;
    bitset<16> binary(tmp); //转换成二进制
    for (int i = 0; i < 16; i++)
        result[i] = binary[i];

    return result;
}
乘法运算
code Times(code code_1, code code_2)
{
    code result;
    long long tmp;
    long long tmp_1 = 0, tmp_2 = 0;
    for (int i = 0; i < 16; i++)  //二进制转换成十进制
    {
        tmp_1 += code_1[i] * pow(2, i);
        tmp_2 += code_2[i] * pow(2, i);
    }
    if (code_1 == 0)
        tmp_1 = 65536;
    if (code_2 == 0)
        tmp_2 = 65536;

    tmp = (tmp_1 * tmp_2) % 65537;
    if (tmp == 65536)  //如果得到最大值即等价于0x0000
        result = 0x0000;
    else
    {
        bitset<16> binary(tmp); //转换成二进制
        for (int i = 0; i < 16; i++)
            result[i] = binary[i];
    }
    return result;
}
拓展欧几里得算法
void Exgcd(int a, int b, int& x, int& y) 
{
    if (!b)
        x = 1, y = 0;
    else
        Exgcd(b, a % b, y, x), y -= a / b * x;
}
利用欧几里得扩展算法求乘法的逆
code invTimes(code code_in)
{
    code result;
    int tmp = 0;
    for (int i = 0; i < 16; i++)  //首先转换成十进制
        tmp += code_in[i] * pow(2, i);

    int x, y;
    int p = 65537;
    Exgcd(tmp, p, x, y);
    x = (x % p + p) % p;  //x即为tmp在 (mod65537) 的乘法逆
    bitset<16> binary(x); //转换成二进制
    for (int j = 0; j < 16; j++)
        result[j] = binary[j];

    return result;
}
全部代码：
#include<iostream>
#include<bitset>
#include<math.h>
using namespace std;
typedef bitset<16> code; //16位
typedef bitset<128> key; //128位秘钥

bitset<16> sub_key[52]; //52个子秘钥
bitset<16> inv_sub_key[52]; //52个逆子秘钥
bitset<64> plaint_txt; 

//异或运算
code XOR(code code_1, code code_2)
{
    return code_1 ^ code_2;
}

//加法运算
code Plus(code code_1, code code_2)
{
    int tmp = 0;
    code result;
    for (int i = 0; i < 16; i++) //二进制转换成十进制
    {
        tmp += code_1[i] * pow(2, i) + code_2[i] * pow(2, i);
    }
    tmp %= 65536;
    bitset<16> binary(tmp); //转换成二进制
    for (int i = 0; i < 16; i++)
        result[i] = binary[i];

    return result;
}

//逆加法
code invPlus(code code_in)
{
    int tmp = 0;
    code result;
    for (int i = 0; i < 16; i++) //二进制转换成十进制
        tmp += code_in[i] * pow(2, i);
    tmp = 65536 - tmp;
    bitset<16> binary(tmp); //转换成二进制
    for (int i = 0; i < 16; i++)
        result[i] = binary[i];

    return result;

}
//乘法运算
code Times(code code_1, code code_2)
{
    code result;
    long long tmp;
    long long tmp_1 = 0, tmp_2 = 0;
    for (int i = 0; i < 16; i++)  //二进制转换成十进制
    {
        tmp_1 += code_1[i] * pow(2, i);
        tmp_2 += code_2[i] * pow(2, i);
    }
    if (code_1 == 0)
        tmp_1 = 65536;
    if (code_2 == 0)
        tmp_2 = 65536;

    tmp = (tmp_1 * tmp_2) % 65537;
    if (tmp == 65536)  //如果得到最大值即等价于0x0000
        result = 0x0000;
    else
    {
        bitset<16> binary(tmp); //转换成二进制
        for (int i = 0; i < 16; i++)
            result[i] = binary[i];
    }
    return result;
}

void Exgcd(int a, int b, int& x, int& y) //拓展欧几里得算法
{
    if (!b)
        x = 1, y = 0;
    else
        Exgcd(b, a % b, y, x), y -= a / b * x;
}
//利用欧几里得扩展算法求乘法的逆
code invTimes(code code_in)
{
    code result;
    int tmp = 0;
    for (int i = 0; i < 16; i++)  //首先转换成十进制
        tmp += code_in[i] * pow(2, i);

    int x, y;
    int p = 65537;
    Exgcd(tmp, p, x, y);
    x = (x % p + p) % p;  //x即为tmp在 (mod65537) 的乘法逆
    bitset<16> binary(x); //转换成二进制
    for (int j = 0; j < 16; j++)
        result[j] = binary[j];

    return result;
}
//子秘钥生成
void subkeys_get(code keys_input[8])//输入8个16bit组
{
    key keys;
    for (int i = 0; i < 8; i++)  //转化成128位
    {
        for (int j = 0; j < 16; j++)
        {
            keys[j + 16 * i] = keys_input[7 - i][j];
        }
    }
    for (int i = 0; i < 8; i++)  //前8个子秘钥（不移动）
    {
        for (int j = 0; j < 16; j++)
            sub_key[i][15 - j] = keys[127 - (j + 16 * i)];
    }
    for (int i = 0; i < 5; i++)  //中间40个子秘钥（）每次循环左移25位
    {
        key tmp_keys = keys >> 103;
        keys = (keys << 25) | (tmp_keys);
        for (int j = (8 + 8 * i); j < (8 * (i + 2)); j++)
        {
            for (int k = 0; k < 16; k++)
                sub_key[j][15 - k] = keys[127 - (k + 16 * (j - 8 - 8 * i))];
        }
    }
    key tmp_keys = keys >> 103;   //最后一次循环左移取前四个
    keys = (keys << 25) | (tmp_keys);
    for (int i = 48; i < 52; i++)
    {
        for (int j = 0; j < 16; j++)
            sub_key[i][15 - j] = keys[127 - (j + 16 * (i - 48))];
    }
}
void inv_subkeys_get(code sub_key[52])  //将52个子秘钥调用
{
    //生成逆子秘钥
    for (int i = 6; i < 48; i = i + 6)   //U_1, U_2, U_3, U_4   (2 <= i <= 8)
    {
        inv_sub_key[i] = invTimes(sub_key[48 - i]);
        inv_sub_key[i + 1] = invPlus(sub_key[50 - i]);
        inv_sub_key[i + 2] = invPlus(sub_key[49 - i]);
        inv_sub_key[i + 3] = invTimes(sub_key[51 - i]);
    }
    for (int i = 0; i < 48; i = i + 6)    //U_5, U_6   (1 <= i <= 8)
    {
        inv_sub_key[i + 4] = sub_key[46 - i];
        inv_sub_key[i + 5] = sub_key[47 - i];
    }
    //U_1, U_2, U_3, U_4   (i = 1, 9)
    inv_sub_key[0] = invTimes(sub_key[48]);
    inv_sub_key[1] = invPlus(sub_key[49]);
    inv_sub_key[2] = invPlus(sub_key[50]);
    inv_sub_key[3] = invTimes(sub_key[51]);

    inv_sub_key[48] = invTimes(sub_key[0]);
    inv_sub_key[49] = invPlus(sub_key[1]);
    inv_sub_key[50] = invPlus(sub_key[2]);
    inv_sub_key[51] = invTimes(sub_key[3]);

}
//加密
bitset<64> encrypt(bitset<64> plaint)
{
    bitset<16> I_1, I_2, I_3, I_4;
    bitset<64> cipher;
    for (int i = 0; i < 16; i++) //明文分成4个16位(I_1, I_2, I_3, I_4)
    {
        I_1[15 - i] = plaint[63 - i];
        I_2[15 - i] = plaint[47 - i];
        I_3[15 - i] = plaint[31 - i];
        I_4[15 - i] = plaint[15 - i];
    }
    for (int i = 0, j = 1; i < 48, j <= 8; i = i + 6, j++)  //轮结构运算
    {
        bitset<16> tmp_1 = Times(sub_key[i], I_1);
        bitset<16> tmp_2 = Plus(sub_key[i + 1], I_2);
        bitset<16> tmp_3 = Plus(sub_key[i + 2], I_3);
        bitset<16> tmp_4 = Times(sub_key[i + 3], I_4);
        bitset<16> tmp_5 = XOR(tmp_1, tmp_3);
        bitset<16> tmp_6 = XOR(tmp_2, tmp_4);
        bitset<16> tmp_7 = Times(sub_key[i + 4], tmp_5);
        bitset<16> tmp_8 = Plus(tmp_6, tmp_7);
        bitset<16> tmp_9 = Times(tmp_8, sub_key[i + 5]);
        bitset<16> tmp_10 = Plus(tmp_7, tmp_9);
        I_1 = XOR(tmp_1, tmp_9);
        I_2 = XOR(tmp_3, tmp_9);
        I_3 = XOR(tmp_2, tmp_10);
        I_4 = XOR(tmp_4, tmp_10);
        //cout << "第" << j << "轮tmp_1： " << tmp_1 << endl;
        //cout << "第" << j << "轮tmp_2： " << tmp_2 << endl;
        //cout << "第" << j << "轮tmp_3： " << tmp_3 << endl;
        //cout << "第" << j << "轮tmp_4： " << tmp_4 << endl;
        //cout << "第" << j << "轮tmp_5： " << tmp_5 << endl;
        //cout << "第" << j << "轮tmp_6： " << tmp_6 << endl;
        //cout << "第" << j << "轮tmp_7： " << tmp_7 << endl;
        //cout << "第" << j << "轮tmp_8： " << tmp_8 << endl;
        //cout << "第" << j << "轮tmp_9： " << tmp_9 << endl;
        //cout << "第" << j << "轮tmp_10：" << tmp_10 << endl;
        //cout << "第" << j << "轮I_1：   " << I_1 << endl;
        //cout << "第" << j << "轮I_2：   " << I_2 << endl;
        //cout << "第" << j << "轮I_3：   " << I_3 << endl;
        //cout << "第" << j << "轮I_4：   " << I_4 << endl;
        //cout << endl;
    }
    //输出变换
    bitset<16> Y_1 = Times(I_1, sub_key[48]);
    bitset<16> Y_2 = Plus(I_3, sub_key[49]);
    bitset<16> Y_3 = Plus(I_2, sub_key[50]);
    bitset<16> Y_4 = Times(I_4, sub_key[51]);
    cout << endl;
    cout << "输出变换Y_1：" << Y_1 << endl;
    cout << "输出变换Y_2：" << Y_2 << endl;
    cout << "输出变换Y_3：" << Y_3 << endl;
    cout << "输出变换Y_4：" << Y_4 << endl;
    cout << endl;

    for (int i = 0; i < 16; i++) //整合4个输出成密文
    {
        cipher[i] = Y_4[i];
        cipher[i + 16] = Y_3[i];
        cipher[i + 32] = Y_2[i];
        cipher[i + 48] = Y_1[i];
    }
    return cipher;
}
//解密（过程与加密一致，子秘钥变成逆子秘钥）
bitset<64> dencrypt(bitset<64> cipher)
{
    //解密
    bitset<16> I_1, I_2, I_3, I_4;
    bitset<64> plaint;
    for (int i = 0; i < 16; i++)
    {
        I_1[15 - i] = cipher[63 - i];
        I_2[15 - i] = cipher[47 - i];
        I_3[15 - i] = cipher[31 - i];
        I_4[i] = cipher[i];
    }
    for (int i = 0; i < 48; i = i + 6)
    {
        bitset<16> tmp_1 = Times(inv_sub_key[i], I_1);
        bitset<16> tmp_2 = Plus(inv_sub_key[i + 1], I_2);
        bitset<16> tmp_3 = Plus(inv_sub_key[i + 2], I_3);
        bitset<16> tmp_4 = Times(inv_sub_key[i + 3], I_4);
        bitset<16> tmp_5 = XOR(tmp_1, tmp_3);
        bitset<16> tmp_6 = XOR(tmp_2, tmp_4);
        bitset<16> tmp_7 = Times(inv_sub_key[i + 4], tmp_5);
        bitset<16> tmp_8 = Plus(tmp_6, tmp_7);
        bitset<16> tmp_9 = Times(tmp_8, inv_sub_key[i + 5]);
        bitset<16> tmp_10 = Plus(tmp_7, tmp_9);
        I_1 = XOR(tmp_1, tmp_9);
        I_2 = XOR(tmp_3, tmp_9);
        I_3 = XOR(tmp_2, tmp_10);
        I_4 = XOR(tmp_4, tmp_10);
    }
    bitset<16> Y_1 = Times(I_1, inv_sub_key[48]);
    bitset<16> Y_2 = Plus(I_3, inv_sub_key[49]);
    bitset<16> Y_3 = Plus(I_2, inv_sub_key[50]);
    bitset<16> Y_4 = Times(I_4, inv_sub_key[51]);

    for (int i = 0; i < 16; i++)
    {
        plaint[i] = Y_4[i];
        plaint[i + 16] = Y_3[i];
        plaint[i + 32] = Y_2[i];
        plaint[i + 48] = Y_1[i];
    }
    return  plaint;

}
int main()
{
    plaint_txt = 0xa6224adf2f28df73;//64位明文
    //plaint_txt = 0xa79587231f2c6d73 ;
    cout << "明文：" << endl << plaint_txt << endl;
    code keys_input[8] = { 0xada1, 0x048b, 0x71a1, 0xf9c7, 0x5266, 0xbfd6, 0x24a2, 0xdff1 };//128位秘钥

    subkeys_get(keys_input); //生成子秘钥
    inv_subkeys_get(sub_key);//生成逆子秘钥

    cout << "\n*轮结构运算过程在注释状态，可关闭注释展示*\n" << endl;

    bitset<64> cipher = encrypt(plaint_txt); //加密得到密文cipher
    cout << "加密得到的密文为：" << endl << cipher << endl;

    bitset<64> plaint = dencrypt(cipher);   //解密得到明文plaint
    cout << "解密密文为：" << endl << plaint << endl;

    return 0;
}
运行结果：

在这里插入图片描述
个人博客：qinquanquan.com

Qinquanquan_
关注
  • 10
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
密码学加密算法分类_密码学中的国际数据加密算法（IDEA）
cumtb2002的博客
06-28 1335
密码学加密算法分类Introduction 介绍 International Data Encryption Algorithm (IDEA) is a type of cryptography as a block cipher algorithm designed by "Xuejia Lai" and "James L.Massey" of ETH-Zürich and was firs...
IDEA-密码学复习用（如侵则删）
qq_47632786的博客
02-07 338
IDEA的抗强力攻击能力比DES强，IDEA是近年来提出用来取代DES的加密算法之一 IDEA 异或、模加、模乘结合起来使用 明文分组和密文分组：64位 密钥长128位，产生52个子密钥，子密钥长16位 进行8轮循环 IDEA采用了Feitel结构，同一算法即可加密也可解密 IDEA属于“强”加密算法，能抗差分分析和相关分析 IDEA的“混淆”和“扩散”设计原则来自三种运算 按位异或，表示为⊕ 模加 2^16 ，表示为，2^16=65536 模乘2^16 +1，表示为...
4_idea.rar_IDEA c++_idea_idea算法
09-23
IDEA算法，用C++实现的。对然不是界面的。但是对于理解这个算法很有用
最完整的IDEA算法加解密详解
qq_61971570的博客
03-07 810
K1-K6都是密钥,因此一共需要6*8+4 = 52组密钥,密钥是128bit,先取得第一组6个(96bit),然后每次循环左移25位,再取下一组的96bit,再循环左移25bit,最后一次取4个(64bit)· 当轮数为 2，...，8 时，取相应的第 3 个和第 2 个的子密钥的2^16的加密逆元。第 i(1-9) 轮的解密的密钥的前 4 个子密钥由加密过程中第 10-i 轮的前 4 个子密钥得出。· 第 5 和第 6 个密钥是第9-i轮的第5和第6个密钥。p1 是最高16bit位。
2024年C C++最新【开发工具 idea】值得推荐的15款idea插件_idea 扫雷插件(1)，2024年最新你值得拥有
最新发布
2401_84976219的博客
05-13 1082
idea的插件安装可以分为两种，第一种就是直接在idea里面下载、安装。第二种可以将压缩包先下载好，然后再在idea中导入，即可完成安装。下面所有的安装都可以通过这两种安装方式来安装。注：插件安装重启idea生效。
IDEA最新安装方式（2024年3月30日）
可乐要加冰！！！
03-25 1万+
IDEA最新安装方式（2024年3月30日）
idea破解码激活码2024
qq_42365218的博客
03-29 3244
省去一些废话，直接关注之后带走工具和教程。
【0325】分组密码
weixin_44164249的博客
03-22 1831
分组密码 体制概述 分组密码体制（Block cipher）是在密钥k控制下一次变换一个明文数据块（又称分组）的密码体制。 特点：速度快，易于标准化和便于软硬件实现等特点 设计原则和评估 针对安全性的两个基本原则：扩散和混淆（对抗统计分析） 扩散原则：将明文的统计规律和结构规律散射到相当长的一段统计中去。 混淆原则:将明文，密文，密钥三者统计关系尽可能复杂。 使用复杂的非线性代替变换效果较好，迭代和乘积效果较好。 针对实现的设计原则：【软件实现】使用子块和简单的运算。【硬件实现】加密和解密的相似性，尽量使用
IDEA对称密码算法剖析
05-23
IDEA算法是一种 典型的对称密钥密码算法。是一种密钥长度为128位的分组密码算法，这种算法既可以用于 加密，也可以用于解密，具有代码量少、运行速度快...IDEA算法原理，然后对基于Vc++的IDEA算法的c++实例进行了解析。
IDEA-password.rar_IDEA算法c++_c++实现idea算法_idea password_idea2016 p
09-20
使用C++实现IDEA密码的加密算法，对于初级学习C++的使用者比较合适！
idea 加密算法C语言源程序
12-28
idae 加密算法的C源程序，可以在各种UNIX平台编译使用
IDEA密码算法 IDEA密码算法
05-29
IDEA密码算法 IDEA密码算法 IDEA密码算法
idea加密算法--经典分组加密
01-23
idea加密算法 idea加密算法 idea加密算法 idea加密算法
IDEA ECC MD5 算法c++实现及报告
09-15
本资源包含密码学IDEA ECC MD5三个加/解密算法的c++实现，以及每个算法的报告，开发工具vc++6。
互联网搞钱
小码哥AI、互联网副业项目
02-23 1万+
从事互联网行业近10余年，现在成为了自由职业者，全职投入互联网，主要从事互联网副业、信息差、创业、赚钱思路等方面研究、实战和经验分享。
对称加密——IDEA
lwhaaaa的博客
06-21 1304
文章目录0x01 IDEA 简介0x02 IDEA 加解密过程一、子密匙生成二、明文加密三、解密0x03 参考 0x01 IDEA 简介 ​ IDEA（International Data Encryption Algorithm，国际数据加密算法），于1991年由XueJia Lai（来学嘉）和L. Massey提出。 ​ 这种算法是在 DES 算法的基础上发展出来的，类似于三重 DES。发展 IDEA 也是因为感到 DES 具有密钥太短等缺点，已经过时。IDEA 的密钥为 128 位，这么长的密钥在
IDEA git SSH配置
Eric的博客
11-20 4865
Git安装完之后，需要做最后一步配置，如果你没有做这项配置，是没有git公钥和私钥的，而上传代码到远程仓库的时候需要秘钥进行验证是否本人上传的，想要创建可以使用下面的方法： 打开git bash，分别执行以下两句命令: git config --global user.name “用户名” git config --global user.email “邮箱” SSH配置 1、打开git...
IDEA官方激活码获取教程及常用命令
热门推荐
欢迎阅读程序猿小张的博客~
03-15 5万+
1.说明： 仅适用于学生群体 一年激活权限 2.申请过程： 官方申请网址点击Apply now按照流程一步步申请即可 没有校园个人邮箱的可以使用官方文件，然后上传学信网的成绩单或者学生证即可 3 已经参加工作的同学也可以立即获取最新激活码 ............
idea加密算法 php,IDEA块加密
weixin_39835117的博客
04-05 523
概述国际数据加密算法(International Data Encryption Algorithm，IDEA)，最早称为改良建议加密标准(Improved Proposed Encryption Standard，IPES)，是密码学上一种对称密钥分组密码，由 James Massey 与来学嘉设计，在1991年首次提出。这个算法的提出，是为了取代旧有的数据加密标准 DES。(来自维基百科)基本...
idea加密算法c++
11-18
idea加密算法是一种对称密钥加密算法，使用128位的密钥和64位的分块大小。这种算法采用迭代加密方法，将明文分成不同的部分，然后对每个部分进行加密。idea使用了一系列复杂的运算，包括模运算、异或运算和乘法运算等，以实现对明文的高强度加密。idea算法具有高度的安全性，对于常见的密码攻击技术有很好的抵抗能力。 idea算法的主要特点包括加密速度快、密钥长度长、安全性高等。它适合于对大量数据进行高强度加密的场景，比如网络传输、数据存储等。在实际应用中，idea算法被广泛使用在金融、电子商务等领域，保护重要数据的安全性。 然而，随着计算机技术的发展，idea算法也逐渐显露出一些不足，比如密钥长度较短、对抗量子计算能力较弱等。因此，在一些对安全性要求更高的场景下，需要使用更复杂、更安全的加密算法来代替idea算法。 总的来说，idea加密算法是一种优秀的对称密钥加密算法，具有高度的安全性和快速的加密速度，适合于一些对安全性要求较低的应用场景。但在一些对安全性要求极高的场景下，可能需要考虑使用其他更加安全的加密算法来替代idea算法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Qinquanquan_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值