2008-10-22 09:13 AES128加密算法与实现2

2024-01-15 16:18
文章标签 加密算法 实现 13 22 2008 09 aes128

本文主要是介绍2008-10-22 09:13 AES128加密算法与实现2，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

/*F*****************************************************************************
* PARAMS:   state       4*4的状态表首指针
*
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 列混合操作。事实上是一种替代操作，用 State 字节列的值进行数学域加
*           和域乘的结果代替每个字节。
*           包括S-box变换，行变换，列变换
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:     MixColumns 使用特殊的加法和乘法，是基于近代数学的域论的有限域GF(28).
*           GF(28)由一组从 0x00 到 0xff 的256个值组成，加上加法和乘法。 GF代表
*           伽罗瓦域，以发明这一理论的数学家的名字命名。GF(28) 的一个特性是一个
*           加法或乘法的操作的结果必须是在{0x00 ... 0xff}这组数中。虽然域论是相
*           当深奥的，但GF(28)加法的最终结果却很简单。GF(28) 加法就是异或（XOR）
*           操作。
*
*       　　GF(28)的乘法有点繁难。AES的加密和解密例程需要知道怎样只用七个常量
*           0x01、0x02、0x03、0x09、0x0b、0x0d 和 0x0e 来相乘。只是针对这七种特殊
*           情况进行说明。
*
*       　　在GF(28)中用0x01的乘法是特殊的；它相当于普通算术中用1做乘法并且结果
*           也同样—任何值乘0x01等于其自身。
*
*       　　用0x02做乘法。和加法的情况相同，理论是深奥的，但最终结果十分简单。只要
*           被乘的值小于0x80，这时乘法的结果就是该值左移1比特位。如果被乘的值大于
*           或等于0x80，这时乘法的结果就是左移1比特位再用值0x1b异或。它防止了“域溢
*           出”并保持乘法的乘积在范围以内。
*
*           清楚在GF(28)中用0x02建立了加法和乘法，就可以用任何常量去定义乘法。用
*           0x03做乘法时，你可以将0x03分解为2的幂之和。为了用0x03乘以任意字节b，
*           因为 0x03 = 0x02 + 0x01，因此：
*               b * 0x03 = b * (0x02 + 0x01) = (b * 0x02) + (b * 0x01)
*******************************************************************************/
static void MixSubColumns(AES_U8 *state)
{
AES_U8 newstate[4 * Nc];    //用于缓存新的"state"数组

    // mixing column 0
    newstate[0] = Xtime2Sbox[state[0]] ^ Xtime3Sbox[state[5]] ^ Sbox[state[10]] ^ Sbox[state[15]];
    newstate[1] = Sbox[state[0]] ^ Xtime2Sbox[state[5]] ^ Xtime3Sbox[state[10]] ^ Sbox[state[15]];
    newstate[2] = Sbox[state[0]] ^ Sbox[state[5]] ^ Xtime2Sbox[state[10]] ^ Xtime3Sbox[state[15]];
    newstate[3] = Xtime3Sbox[state[0]] ^ Sbox[state[5]] ^ Sbox[state[10]] ^ Xtime2Sbox[state[15]];

    // mixing column 1
    newstate[4] = Xtime2Sbox[state[4]] ^ Xtime3Sbox[state[9]] ^ Sbox[state[14]] ^ Sbox[state[3]];
    newstate[5] = Sbox[state[4]] ^ Xtime2Sbox[state[9]] ^ Xtime3Sbox[state[14]] ^ Sbox[state[3]];
    newstate[6] = Sbox[state[4]] ^ Sbox[state[9]] ^ Xtime2Sbox[state[14]] ^ Xtime3Sbox[state[3]];
    newstate[7] = Xtime3Sbox[state[4]] ^ Sbox[state[9]] ^ Sbox[state[14]] ^ Xtime2Sbox[state[3]];

    // mixing column 2
    newstate[8] = Xtime2Sbox[state[8]] ^ Xtime3Sbox[state[13]] ^ Sbox[state[2]] ^ Sbox[state[7]];
    newstate[9] = Sbox[state[8]] ^ Xtime2Sbox[state[13]] ^ Xtime3Sbox[state[2]] ^ Sbox[state[7]];
    newstate[10] = Sbox[state[8]] ^ Sbox[state[13]] ^ Xtime2Sbox[state[2]] ^ Xtime3Sbox[state[7]];
    newstate[11] = Xtime3Sbox[state[8]] ^ Sbox[state[13]] ^ Sbox[state[2]] ^ Xtime2Sbox[state[7]];

    // mixing column 3
newstate[12] = Xtime2Sbox[state[12]] ^ Xtime3Sbox[state[1]] ^ Sbox[state[6]] ^ Sbox[state[11]];
    newstate[13] = Sbox[state[12]] ^ Xtime2Sbox[state[1]] ^ Xtime3Sbox[state[6]] ^ Sbox[state[11]];
    newstate[14] = Sbox[state[12]] ^ Sbox[state[1]] ^ Xtime2Sbox[state[6]] ^ Xtime3Sbox[state[11]];
    newstate[15] = Xtime3Sbox[state[12]] ^ Sbox[state[1]] ^ Sbox[state[6]] ^ Xtime2Sbox[state[11]];

    memcpy (state, newstate, sizeof(newstate));
}


/*F*****************************************************************************
* PARAMS:   state       4*4的状态表首指针
*
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 反列混合运算
*           包括
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:    
*******************************************************************************/
static void InvMixSubColumns(AES_U8 *state)
{
AES_U8 newstate[4 * Nc];   //用于缓存新的"state"数组
AES_U16 i;                

    // restore column 0
    newstate[0] = XtimeE[state[0]] ^ XtimeB[state[1]] ^ XtimeD[state[2]] ^ Xtime9[state[3]];
    newstate[5] = Xtime9[state[0]] ^ XtimeE[state[1]] ^ XtimeB[state[2]] ^ XtimeD[state[3]];
    newstate[10] = XtimeD[state[0]] ^ Xtime9[state[1]] ^ XtimeE[state[2]] ^ XtimeB[state[3]];
    newstate[15] = XtimeB[state[0]] ^ XtimeD[state[1]] ^ Xtime9[state[2]] ^ XtimeE[state[3]];

    // restore column 1
    newstate[4] = XtimeE[state[4]] ^ XtimeB[state[5]] ^ XtimeD[state[6]] ^ Xtime9[state[7]];
    newstate[9] = Xtime9[state[4]] ^ XtimeE[state[5]] ^ XtimeB[state[6]] ^ XtimeD[state[7]];
    newstate[14] = XtimeD[state[4]] ^ Xtime9[state[5]] ^ XtimeE[state[6]] ^ XtimeB[state[7]];
    newstate[3] = XtimeB[state[4]] ^ XtimeD[state[5]] ^ Xtime9[state[6]] ^ XtimeE[state[7]];

    // restore column 2
    newstate[8] = XtimeE[state[8]] ^ XtimeB[state[9]] ^ XtimeD[state[10]] ^ Xtime9[state[11]];
    newstate[13] = Xtime9[state[8]] ^ XtimeE[state[9]] ^ XtimeB[state[10]] ^ XtimeD[state[11]];
    newstate[2] = XtimeD[state[8]] ^ Xtime9[state[9]] ^ XtimeE[state[10]] ^ XtimeB[state[11]];
    newstate[7] = XtimeB[state[8]] ^ XtimeD[state[9]] ^ Xtime9[state[10]] ^ XtimeE[state[11]];

    // restore column 3
    newstate[12] = XtimeE[state[12]] ^ XtimeB[state[13]] ^ XtimeD[state[14]] ^ Xtime9[state[15]];
    newstate[1] = Xtime9[state[12]] ^ XtimeE[state[13]] ^ XtimeB[state[14]] ^ XtimeD[state[15]];
    newstate[6] = XtimeD[state[12]] ^ Xtime9[state[13]] ^ XtimeE[state[14]] ^ XtimeB[state[15]];
    newstate[11] = XtimeB[state[12]] ^ XtimeD[state[13]] ^ Xtime9[state[14]] ^ XtimeE[state[15]];

    for (i=0; i<(4 * Nc); i++)
    {
        state[i] = InvSbox[newstate[i]];
    }
}


/*F*****************************************************************************
* PARAMS:   state       4*4的状态表首指针
*           key         密钥表首指针
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 轮密钥加操作
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:     在加密和解密过程中均用到
*******************************************************************************/
static void AddRoundKey(AES_U8 *state, AES_U8 *key)
{
AES_U16 idx;    //索引

    for (idx=0; idx<4; idx++)
    {
        state[idx] ^= key[idx];
    }
}


/*F*****************************************************************************
* PARAMS:   key         密钥表首指针
*           expKey      扩展密钥表首指针
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 扩展密钥加操作，相当于初始化AES算法
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:     在加密和解密过程中均用到，每轮扩展Nk字节
*******************************************************************************/
void AES_ExpandKey(AES_U8 *key, AES_U8 *expKey)
{
AES_U8 tmp0, tmp1, tmp2, tmp3, tmp4;
AES_U16 idx;    //索引

    for (idx=0; idx<Nk; idx++) //把数组key中的每个元素复制到数组expKey相对应中的位置，Nk=4
    {
        expKey[4*idx+0] = key[4 * idx + 0];
        expKey[4*idx+1] = key[4 * idx + 1];
        expKey[4*idx+2] = key[4 * idx + 2];
        expKey[4*idx+3] = key[4 * idx + 3];
    }

    for (idx=Nk; idx<(Nc * (Nr + 1)); idx++) //
    {
        tmp0 = expKey[4*idx - 4];
        tmp1 = expKey[4*idx - 3];
        tmp2 = expKey[4*idx - 2];
        tmp3 = expKey[4*idx - 1];
       
        if ( !(idx % Nk) )
        {
            tmp4 = tmp3;
            tmp3 = Sbox[tmp0];
            tmp0 = Sbox[tmp1] ^ Rcon[idx/Nk];
            tmp1 = Sbox[tmp2];
            tmp2 = Sbox[tmp4];
        } //End of if

        //convert from longs to bytes
        expKey[4*idx+0] = expKey[4*idx - 4*Nk + 0] ^ tmp0;
        expKey[4*idx+1] = expKey[4*idx - 4*Nk + 1] ^ tmp1;
        expKey[4*idx+2] = expKey[4*idx - 4*Nk + 2] ^ tmp2;
        expKey[4*idx+3] = expKey[4*idx - 4*Nk + 3] ^ tmp3;
    } //End of for
}


/*F*****************************************************************************
* PARAMS:   in          输入缓冲区指针
*           expKey      扩展密钥表首指针
*           out         输出缓冲区指针
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 128Bit加密函数
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:     每次仅限于128Bit数据块
*******************************************************************************/
void AES_Encrypt(AES_U8 *in, AES_U8 *expKey, AES_U8 *out)
{
AES_U8 state[Nc * 4]; //state数组，用于数据分组
AES_U16 round;          //加密轮数计数器
AES_U16 idx;            //索引

    //128位数据分组，把输入缓冲区中的数据放到4*4state数组中
    for (idx=0; idx<Nc; idx++ )
    {
        state[4*idx+0] = *in++;
        state[4*idx+1] = *in++;
        state[4*idx+2] = *in++;
        state[4*idx+3] = *in++;
    }

    //与扩展密钥进行“异或”操作
    AddRoundKey ((AES_U8 *)state, (AES_U8 *)expKey);

    //Nr轮加密操作
    for (round=1; round<(Nr + 1); round++)
    {
        if (round < Nr)
        {
            MixSubColumns(state);   //包含S-box变换，行变换，列变换
        }
        else
        {
            ShiftRows (state);      //S-box变换，行变换，最后一轮不进行列变换
        } //End of if
       
        //与扩展密钥进行“异或”操作
        AddRoundKey ((AES_U8 *)state, (AES_U8 *)expKey + round * Nc);
    } //End of for

    //输出128位加密后的数据
    for (idx=0; idx<Nc; idx++)
    {
        *out++ = state[4*idx+0];
        *out++ = state[4*idx+1];
        *out++ = state[4*idx+2];
        *out++ = state[4*idx+3];
    }
}


/*F*****************************************************************************
* PARAMS:   in          输入缓冲区指针
*           expKey      扩展密钥表首指针
*           out         输出缓冲区指针
* RETURN:   None
*-------------------------------------------------------------------------------
* PURPOSE: 128Bit解密函数
*-------------------------------------------------------------------------------
* EXAMPLE:
*-------------------------------------------------------------------------------
* NOTE:     每次仅限于128Bit数据块
*******************************************************************************/
void AES_Decrypt(AES_U8 *in, AES_U8 *expKey, AES_U8 *out)
{
AES_U8 state[Nc * 4]; //state数组，用于加密数据分组
AES_U16 round;          //加密轮数计数器
AES_U16 idx;            //索引

    //128位加密数据分组
    for (idx=0; idx<Nc; idx++)
    {
        state[4*idx+0] = *in++;
        state[4*idx+1] = *in++;
        state[4*idx+2] = *in++;
        state[4*idx+3] = *in++;
    }

    //与扩展密钥进行“异或”操作
    AddRoundKey ((AES_U8 *)state, (AES_U8 *)expKey + Nr * Nc);
    round = Nr;

    //反S-box变换，反行变换
    InvShiftRows(state);

    while (round--)
    {
        //与扩展密钥进行“异或”操作
        AddRoundKey((AES_U8 *)state, (AES_U8 *)expKey + round * Nc);
       
        if (round)
        {
            //反S-box变换，反行变换，反列变换
            InvMixSubColumns (state);
        } //End of if
    } //End of while

    //输出128位解密数据
    for (idx=0; idx<Nc; idx++ )
    {
        *out++ = state[4*idx+0];
        *out++ = state[4*idx+1];
        *out++ = state[4*idx+2];
        *out++ = state[4*idx+3];
    }
}

这篇关于2008-10-22 09:13 AES128加密算法与实现2的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/609475。

相关文章

Python实现精准提取 PDF中的文本,表格与图片

Python实现精准提取 PDF中的文本,表格与图片

《Python实现精准提取PDF中的文本,表格与图片》在实际的系统开发中,处理PDF文件不仅限于读取整页文本,还有提取文档中的表格数据,图片或特定区域的内容,下面我们来看看如何使用Python实... 目录安装 python 库提取 PDF 文本内容：获取整页文本与指定区域内容获取页面上的所有文本内容获取
阅读更多...
基于Python实现一个Windows Tree命令工具

基于Python实现一个Windows Tree命令工具

《基于Python实现一个WindowsTree命令工具》今天想要在Windows平台的CMD命令终端窗口中使用像Linux下的tree命令,打印一下目录结构层级树,然而还真有tree命令,但是发现... 目录引言实现代码使用说明可用选项示例用法功能特点添加到环境变量方法一：创建批处理文件并添加到PATH1
阅读更多...
Java使用HttpClient实现图片下载与本地保存功能

Java使用HttpClient实现图片下载与本地保存功能

《Java使用HttpClient实现图片下载与本地保存功能》在当今数字化时代,网络资源的获取与处理已成为软件开发中的常见需求,其中,图片作为网络上最常见的资源之一,其下载与保存功能在许多应用场景中都... 目录引言一、Apache HttpClient简介二、技术栈与环境准备三、实现图片下载与保存功能1.
阅读更多...
canal实现mysql数据同步的详细过程

canal实现mysql数据同步的详细过程

《canal实现mysql数据同步的详细过程》：本文主要介绍canal实现mysql数据同步的详细过程,本文通过实例图文相结合给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的... 目录1、canal下载2、mysql同步用户创建和授权3、canal admin安装和启动4、canal
阅读更多...
Nexus安装和启动的实现教程

Nexus安装和启动的实现教程

《Nexus安装和启动的实现教程》：本文主要介绍Nexus安装和启动的实现教程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、Nexus下载二、Nexus安装和启动三、关闭Nexus总结一、Nexus下载官方下载链接：DownloadWindows系统根
阅读更多...
SpringBoot集成LiteFlow实现轻量级工作流引擎的详细过程

SpringBoot集成LiteFlow实现轻量级工作流引擎的详细过程

《SpringBoot集成LiteFlow实现轻量级工作流引擎的详细过程》LiteFlow是一款专注于逻辑驱动流程编排的轻量级框架,它以组件化方式快速构建和执行业务流程,有效解耦复杂业务逻辑,下面给大... 目录一、基础概念1.1 组件（Component）1.2 规则（Rule）1.3 上下文（Conte
阅读更多...
MySQL 横向衍生表(Lateral Derived Tables)的实现

MySQL 横向衍生表(Lateral Derived Tables)的实现

《MySQL横向衍生表(LateralDerivedTables)的实现》横向衍生表适用于在需要通过子查询获取中间结果集的场景,相对于普通衍生表,横向衍生表可以引用在其之前出现过的表名,本文就来... 目录一、横向衍生表用法示例1.1 用法示例1.2 使用建议前面我们介绍过mysql中的衍生表（From子句
阅读更多...
Mybatis的分页实现方式

Mybatis的分页实现方式

《Mybatis的分页实现方式》MyBatis的分页实现方式主要有以下几种,每种方式适用于不同的场景,且在性能、灵活性和代码侵入性上有所差异,对Mybatis的分页实现方式感兴趣的朋友一起看看吧... 目录​1. 原生 SQL 分页（物理分页）​​2. RowBounds 分页（逻辑分页）​​3. Page
阅读更多...
Python基于微信OCR引擎实现高效图片文字识别

Python基于微信OCR引擎实现高效图片文字识别

《Python基于微信OCR引擎实现高效图片文字识别》这篇文章主要为大家详细介绍了一款基于微信OCR引擎的图片文字识别桌面应用开发全过程,可以实现从图片拖拽识别到文字提取,感兴趣的小伙伴可以跟随小编一... 目录一、项目概述1.1 开发背景1.2 技术选型1.3 核心优势二、功能详解2.1 核心功能模块2.
阅读更多...
MYSQL查询结果实现发送给客户端

MYSQL查询结果实现发送给客户端

《MYSQL查询结果实现发送给客户端》：本文主要介绍MYSQL查询结果实现发送给客户端方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录mysql取数据和发数据的流程（边读边发）Sending to clientSending DataLRU(Least Rec
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2