2017-2018-1 20155334 20155319 实验二——固件程序设计

实验二——固件程序设计

本次的实验共有五个重要的部分：

MDK安装破解

LED跑马灯实验

UART发送与中断接收实验

国密算法

SM1加密实验

设备归还

一、MDK安装破解

实验步骤简介：
安装 MDK4.74

运行mdk.exe准备安装 MDK-ARM，并点下一步。

首先在要安装的磁盘目录下面新建文件夹，并命名，然后点击Browse选择安装目录。

填写用户信息。

安装ULINK驱动

若系统提示是否想安装这个设备软件，点击安装。

Ulink安装结束后自动退出，安装结束。

破解 MDK4.74

运行uVision4，点 File>>License Management，复制 CID。

再运行keil-MDK注册机

粘贴CID至注册机

最后点击 generate 生成 LIC。

将注册机生成的 LIC 复制到 keil4中的 LIC 输入框中，点击 Add LIC，破

解完成。

实验截图：





遇到的问题：
在破解的过程中出现破解失败的显示，将uVision4和keil-MDK注册机分别用管理员权限运行之后成功破解。

二、LED实验

实验步骤简介：
KEIL-MDK 中添加 Z32 SC-000 芯片库

在安装了 keil uVision mdk4.74 的前提下，我们安装 SC000 库。

运行MDK-ARM_AddOn_SC000_Support.exe。打开之后，点击 NEXT。

在许可证这一步，点击同意，用户信息这一步输入基本信息，点下一步。

安装完成，点击 Finish 按钮完成库的添加。

在 keil MDK 工程选择 SC000 库

运行keil uVision4 MDK。新建工程选择 Project——>New uVision Project。

在弹出的安装路径窗口选择安装路径文件夹，并为工程命名。

在芯片库选择框选择库 Generic SC000 Device Database，点击OK，选择具体的 CPU 型号。

点开 ARM 结构目录，选择 SC000，点击 OK。

这样，Z32 工程的基础编程环境搭建就完成了。

程序分析：

GPIO_PuPdSel(0,0);  //设置 GPIO0 为上拉
GPIO_InOutSet(0,0); //设置 GPIO0 为输出

while(1)
{
delay(100);
GPIO_SetVal(0,0);   //输出低电平，点亮 LED
delay(100);
GPIO_SetVal(0,1);   //输出高电平，熄灭 LED
}//延时函数，当系统时钟为内部 OSC 时钟时，延时 1ms

主函数代码的执行过程为：

系统初始化，中断设置，使能所有中断；

判断按键，返回 boot 条件，确认是否进行程序下载；

设置 GPIO0 状态为上拉输出；

进入循环程序，LED 灯间隔 100ms 闪烁；

实验开始

打开“实验1-LED闪烁”目录的工程文件。编译工程，产生后缀名为.bin的可执行代码。

下载程序：将实验箱接入电源，用USB公对公线将实验箱的USB接口连接到电脑的USB接口上，在电脑上运行Z32下载调试工具NZDownloadTool.exe。

打开 Z32 的电源开关前，按住 Reboot 按键不放，两次打开电源开关，Z32 即可被电脑识别，进行下载调试。当左边框出现“1设备已连接”,设备选择中显示芯片型号，此时就可以下载程序了。点击窗口右下方“确认下载”一栏的“浏览”，选择程序路径为“Z32 开发指南\实验 1-LED闪烁\bin\Z32HUA.bin”并打开，最后点击下载。

左边状态提示框更新显示“程序下载成功！”此时程序就下载进Z32的实验板上了。

对LED灯的操作：关闭Z32电源开关，再打开，程序自动运行，此时可以看到实验现象：Z32核心板上L2灯开始闪烁。

实验截图：











遇到的问题：
在刚刚开始时调试工具始终识别不了设备，后来发现是操作方式出现问题。

三、UART发送与中断接受实验

程序分析

int main(void)
{
UART_Init();      //初始化 Uart
UART_SendByte('A');//Uart 发送一个字符 A
UART_SendByte('\r');
UART_SendByte('\n');//换行
UART_SendString("Welcome to Z32HUA!");   //Uart 发送字符串
UART_SendByte('\r');
UART_SendByte('\n');//换行
UART_SendNum(1234567890);//Uart 发送一个十进制数
UART_SendByte('\r');
UART_SendByte('\n');//换行
UART_SendHex(0xAA);//Uart 发送一个十六进制数
}

UART_SendByte('\r');
UART_SendByte('\n');//换行

while(1)
{
if(uart_rx_end)
{
uart_rx_end=0;
uart_SendString(shuju,shuju_lens);
}
}    //等待接收中断。

//延时函数，当系统时钟为内部 OSC 时钟时，延时 1ms
void delay(int ms)
{
int i;
while(ms--)
{
for(i=0; i<950; i++) ;
}
}

void UART_SendByte(UINT8 dat)是发送单字节函数，使用此函数一次发

送一个字节数据；

void UART_SendString(UINT8 * str)是发送字符串函数，使用此函数发送

字符串数据；

void uart_SendString(UINT8 buf[],UINT8 length)是发送某一长度的字符

串函数，实现发送一定长度的字符串数据。

void UART_SendNum(INT32 num)是发送单个十进制整数函数，使用此函数发送一个十进制整数；

代码的执行过程为：

系统初始化，中断设置，使能所有中断；

判断按键，返回 boot 条件，确认是否进行程序下载；

初始化 Uart，使能 Uart 接口，配置 Uart 中断并使能；

先发送单个字符“A”，换行，再发送字符串“Welcome to Z32HUA!”，换行，发送数字串“1234567890”，换行，再发送 16 位数“0xAA”，换行。

进入 while 循环程序，等待串口中断到来并判断数据是否接收完毕，若中断到来，转入执行串口中断服务程序，待接收数据完毕，Z32 将数据发回串口助手。

实验步骤简介：

打开“实验2-UART发送与中断接收”目录的工程文件。编译工程，产生后缀名为.bin的可执行代码。

下载程序（过程与上一个实验相似，只是bin的路径不同，下同）

使用串口调试助手来观察串口通信收发的数据：用9针串口线将Z32模块的串口与电脑USB接口连接。在电脑上运行串口助手，选择对应的串口号，设置波特率为115200，偶校验（Even），选中“发送新行”，然后打开串口。

关闭z32电源开关，再打开，程序自动运行，可以在串口调试助手看到如下实验现象：显示“A Welcome to Z32HUA!12345678900xAA”，证明PC机串口已经接收到z32串口发送来的信息。我们在串口调试助手的字符串输入框输入字符串“abcdefgh”，然后点击发送按钮。这时，可以看到串口调试助手接收到我们发送输入的字符串“abcdefgh”，并显示在串口助手上。

实验截图：



遇到的问题：
没有遇到问题

四、国密算法

简介：
国密即国家密码局认定的国产密码算法，即商用密码。

国密算法由国家密码局发布，包含SM1 SM2 SM3 SM4 SSF33算法：

SM1对称密码：该算法保密，不公开。SM1 算法是分组密码算法，广泛应用于电子政务、电子商务及国民经济的各个应用领域（包括国家政务通、警务通等重要领域）。

SM2算法：SM2椭圆曲线公钥密码算法是我国自主设计的公钥密码算法，包括SM2-1椭圆曲线数字签名算法，SM2-2椭圆曲线密钥交换协议，SM2-3椭圆曲线公钥加密算法，分别用于实现数字签名密钥协商和数据加密等功能。

SM3算法：SM3杂凑算法是我国自主设计的密码杂凑算法，适用于商用密码应用中的数字签名和验证消息认证码的生成与验证以及随机数的生成，可满足多种密码应用的安全需求。

SM4算法：SM4分组密码算法是我国自主设计的分组对称密码算法，用于实现数据的加密/解密运算，以保证数据和信息的机密性。

代码（使用的是SM3算法）
代码链接

#ifndef GET_ULONG_BE
#define GET_ULONG_BE(n,b,i)                             \
{                                                       \
(n) = ( (unsigned long) (b)[(i)    ] << 24 )        \
| ( (unsigned long) (b)[(i) + 1] << 16 )        \
| ( (unsigned long) (b)[(i) + 2] <<  8 )        \
| ( (unsigned long) (b)[(i) + 3]       );       \
}
#endif

#ifndef PUT_ULONG_BE
#define PUT_ULONG_BE(n,b,i)                             \
{                                                       \
(b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
(b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
(b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
(b)[(i) + 3] = (unsigned char) ( (n)       );       \
}
#endif

/*
* SM3 context setup
*/
void sm3_starts( sm3_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;

ctx->state[0] = 0x7380166F;
ctx->state[1] = 0x4914B2B9;
ctx->state[2] = 0x172442D7;
ctx->state[3] = 0xDA8A0600;
ctx->state[4] = 0xA96F30BC;
ctx->state[5] = 0x163138AA;
ctx->state[6] = 0xE38DEE4D;
ctx->state[7] = 0xB0FB0E4E;

}

static void sm3_process( sm3_context *ctx, unsigned char data[64] )
{
unsigned long SS1, SS2, TT1, TT2, W[68],W1[64];
unsigned long A, B, C, D, E, F, G, H;
unsigned long T[64];
unsigned long Temp1,Temp2,Temp3,Temp4,Temp5;
int j;
#ifdef _DEBUG
int i;
#endif

//  for(j=0; j < 68; j++)
//      W[j] = 0;
//  for(j=0; j < 64; j++)
//      W1[j] = 0;

for(j = 0; j < 16; j++)
T[j] = 0x79CC4519;
for(j =16; j < 64; j++)
T[j] = 0x7A879D8A;

GET_ULONG_BE( W[ 0], data,  0 );
GET_ULONG_BE( W[ 1], data,  4 );
GET_ULONG_BE( W[ 2], data,  8 );
GET_ULONG_BE( W[ 3], data, 12 );
GET_ULONG_BE( W[ 4], data, 16 );
GET_ULONG_BE( W[ 5], data, 20 );
GET_ULONG_BE( W[ 6], data, 24 );
GET_ULONG_BE( W[ 7], data, 28 );
GET_ULONG_BE( W[ 8], data, 32 );
GET_ULONG_BE( W[ 9], data, 36 );
GET_ULONG_BE( W[10], data, 40 );
GET_ULONG_BE( W[11], data, 44 );
GET_ULONG_BE( W[12], data, 48 );
GET_ULONG_BE( W[13], data, 52 );
GET_ULONG_BE( W[14], data, 56 );
GET_ULONG_BE( W[15], data, 60 );

#ifdef _DEBUG
printf("Message with padding:\n");
for(i=0; i< 8; i++)
printf("%08x ",W[i]);
printf("\n");
for(i=8; i< 16; i++)
printf("%08x ",W[i]);
printf("\n");
#endif

#define FF0(x,y,z) ( (x) ^ (y) ^ (z))
#define FF1(x,y,z) (((x) & (y)) | ( (x) & (z)) | ( (y) & (z)))

#define GG0(x,y,z) ( (x) ^ (y) ^ (z))
#define GG1(x,y,z) (((x) & (y)) | ( (~(x)) & (z)) )

#define  SHL(x,n) (((x) & 0xFFFFFFFF) << n)
#define ROTL(x,n) (SHL((x),n) | ((x) >> (32 - n)))

#define P0(x) ((x) ^  ROTL((x),9) ^ ROTL((x),17))
#define P1(x) ((x) ^  ROTL((x),15) ^ ROTL((x),23))

for(j = 16; j < 68; j++ )
{
//W[j] = P1( W[j-16] ^ W[j-9] ^ ROTL(W[j-3],15)) ^ ROTL(W[j - 13],7 ) ^ W[j-6];
//Why thd release's result is different with the debug's ?
//Below is okay. Interesting, Perhaps VC6 has a bug of Optimizaiton.

Temp1 = W[j-16] ^ W[j-9];
Temp2 = ROTL(W[j-3],15);
Temp3 = Temp1 ^ Temp2;
Temp4 = P1(Temp3);
Temp5 =  ROTL(W[j - 13],7 ) ^ W[j-6];
W[j] = Temp4 ^ Temp5;
}

#ifdef _DEBUG
printf("Expanding message W0-67:\n");
for(i=0; i<68; i++)
{
printf("%08x ",W[i]);
if(((i+1) % 8) == 0) printf("\n");
}
printf("\n");
#endif

for(j =  0; j < 64; j++)
{
W1[j] = W[j] ^ W[j+4];
}

#ifdef _DEBUG
printf("Expanding message W'0-63:\n");
for(i=0; i<64; i++)
{
printf("%08x ",W1[i]);
if(((i+1) % 8) == 0) printf("\n");
}
printf("\n");
#endif

A = ctx->state[0];
B = ctx->state[1];
C = ctx->state[2];
D = ctx->state[3];
E = ctx->state[4];
F = ctx->state[5];
G = ctx->state[6];
H = ctx->state[7];
#ifdef _DEBUG
printf("j     A       B        C         D         E        F        G       H\n");
printf("   %08x %08x %08x %08x %08x %08x %08x %08x\n",A,B,C,D,E,F,G,H);
#endif

for(j =0; j < 16; j++)
{
SS1 = ROTL((ROTL(A,12) + E + ROTL(T[j],j)), 7);
SS2 = SS1 ^ ROTL(A,12);
TT1 = FF0(A,B,C) + D + SS2 + W1[j];
TT2 = GG0(E,F,G) + H + SS1 + W[j];
D = C;
C = ROTL(B,9);
B = A;
A = TT1;
H = G;
G = ROTL(F,19);
F = E;
E = P0(TT2);
#ifdef _DEBUG
printf("%02d %08x %08x %08x %08x %08x %08x %08x %08x\n",j,A,B,C,D,E,F,G,H);
#endif
}

for(j =16; j < 64; j++)
{
SS1 = ROTL((ROTL(A,12) + E + ROTL(T[j],j)), 7);
SS2 = SS1 ^ ROTL(A,12);
TT1 = FF1(A,B,C) + D + SS2 + W1[j];
TT2 = GG1(E,F,G) + H + SS1 + W[j];
D = C;
C = ROTL(B,9);
B = A;
A = TT1;
H = G;
G = ROTL(F,19);
F = E;
E = P0(TT2);
#ifdef _DEBUG
printf("%02d %08x %08x %08x %08x %08x %08x %08x %08x\n",j,A,B,C,D,E,F,G,H);
#endif
}

ctx->state[0] ^= A;
ctx->state[1] ^= B;
ctx->state[2] ^= C;
ctx->state[3] ^= D;
ctx->state[4] ^= E;
ctx->state[5] ^= F;
ctx->state[6] ^= G;
ctx->state[7] ^= H;
#ifdef _DEBUG
printf("   %08x %08x %08x %08x %08x %08x %08x %08x\n",ctx->state[0],ctx->state[1],ctx->state[2],
ctx->state[3],ctx->state[4],ctx->state[5],ctx->state[6],ctx->state[7]);
#endif
}

/*
* SM3 process buffer
*/
void sm3_update( sm3_context *ctx, unsigned char *input, int ilen )
{
int fill;
unsigned long left;

if( ilen <= 0 )
return;

left = ctx->total[0] & 0x3F;
fill = 64 - left;

ctx->total[0] += ilen;
ctx->total[0] &= 0xFFFFFFFF;

if( ctx->total[0] < (unsigned long) ilen )
ctx->total[1]++;

if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left),
(void *) input, fill );
sm3_process( ctx, ctx->buffer );
input += fill;
ilen  -= fill;
left = 0;
}

while( ilen >= 64 )
{
sm3_process( ctx, input );
input += 64;
ilen  -= 64;
}

if( ilen > 0 )
{
memcpy( (void *) (ctx->buffer + left),
(void *) input, ilen );
}
}

static const unsigned char sm3_padding[64] =
{
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

/*
* SM3 final digest
*/
void sm3_finish( sm3_context *ctx, unsigned char output[32] )
{
unsigned long last, padn;
unsigned long high, low;
unsigned char msglen[8];

high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] <<  3 );
low  = ( ctx->total[0] <<  3 );

PUT_ULONG_BE( high, msglen, 0 );
PUT_ULONG_BE( low,  msglen, 4 );

last = ctx->total[0] & 0x3F;
padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );

sm3_update( ctx, (unsigned char *) sm3_padding, padn );
sm3_update( ctx, msglen, 8 );

PUT_ULONG_BE( ctx->state[0], output,  0 );
PUT_ULONG_BE( ctx->state[1], output,  4 );
PUT_ULONG_BE( ctx->state[2], output,  8 );
PUT_ULONG_BE( ctx->state[3], output, 12 );
PUT_ULONG_BE( ctx->state[4], output, 16 );
PUT_ULONG_BE( ctx->state[5], output, 20 );
PUT_ULONG_BE( ctx->state[6], output, 24 );
PUT_ULONG_BE( ctx->state[7], output, 28 );
}

/*
* output = SM3( input buffer )
*/
void sm3( unsigned char *input, int ilen,
unsigned char output[32] )
{
sm3_context ctx;

sm3_starts( &ctx );
sm3_update( &ctx, input, ilen );
sm3_finish( &ctx, output );

memset( &ctx, 0, sizeof( sm3_context ) );
}

/*
* output = SM3( file contents )
*/
int sm3_file( char *path, unsigned char output[32] )
{
FILE *f;
size_t n;
sm3_context ctx;
unsigned char buf[1024];

if( ( f = fopen( path, "rb" ) ) == NULL )
return( 1 );

sm3_starts( &ctx );

while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
sm3_update( &ctx, buf, (int) n );

sm3_finish( &ctx, output );

memset( &ctx, 0, sizeof( sm3_context ) );

if( ferror( f ) != 0 )
{
fclose( f );
return( 2 );
}

fclose( f );
return( 0 );
}

/*
* SM3 HMAC context setup
*/
void sm3_hmac_starts( sm3_context *ctx, unsigned char *key, int keylen )
{
int i;
unsigned char sum[32];

if( keylen > 64 )
{
sm3( key, keylen, sum );
keylen = 32;
//keylen = ( is224 ) ? 28 : 32;
key = sum;
}

memset( ctx->ipad, 0x36, 64 );
memset( ctx->opad, 0x5C, 64 );

for( i = 0; i < keylen; i++ )
{
ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
}

sm3_starts( ctx);
sm3_update( ctx, ctx->ipad, 64 );

memset( sum, 0, sizeof( sum ) );
}

/*
* SM3 HMAC process buffer
*/
void sm3_hmac_update( sm3_context *ctx, unsigned char *input, int ilen )
{
sm3_update( ctx, input, ilen );
}

/*
* SM3 HMAC final digest
*/
void sm3_hmac_finish( sm3_context *ctx, unsigned char output[32] )
{
int hlen;
unsigned char tmpbuf[32];

//is224 = ctx->is224;
hlen =  32;

sm3_finish( ctx, tmpbuf );
sm3_starts( ctx );
sm3_update( ctx, ctx->opad, 64 );
sm3_update( ctx, tmpbuf, hlen );
sm3_finish( ctx, output );

memset( tmpbuf, 0, sizeof( tmpbuf ) );
}

/*
* output = HMAC-SM#( hmac key, input buffer )
*/
void sm3_hmac( unsigned char *key, int keylen,
unsigned char *input, int ilen,
unsigned char output[32] )
{
sm3_context ctx;

sm3_hmac_starts( &ctx, key, keylen);
sm3_hmac_update( &ctx, input, ilen );
sm3_hmac_finish( &ctx, output );

memset( &ctx, 0, sizeof( sm3_context ) );
}

运行截图

五、SM1加密实验

代码分析

jiami:
lcd_pos(0,0);//定位第一行
lcd_string("观看串口调试助手");
lcd_pos(1,0);//定位第二行
lcd_string("A 键确认加密");
UART_SendString("将加密以下数据:\r\n");
for(UINT8 i=0;i<16;i++)
{
UART_SendHex(jiamiqian[i]);
}
UART_SendString("\r\n");
UART_SendString("加密密钥:\r\n");
for(UINT8 i=0;i<16;i++)
{
UART_SendHex(jiamimiyue[i]);
}
UART_SendString("\r\n");
while(KEY_ReadValue()!='A'); //等待A键按下

SM1_Init(jiamimiyue);        //SM1初始化
SM1_Crypto(jiamiqian, 16, 0, 0, 0,jiamihou); //进行加密
SM1_Close(); //关闭安全模块
UART_SendString("加密后的数据:\r\n");
for(UINT8 i=0;i<16;i++)
{
UART_SendHex(jiamihou[i]);
}
UART_SendString("\r\n");
lcd_pos(2,0);//定位第三行
lcd_string("加密完成");
lcd_pos(3,0);//定位第四行
lcd_string("A 键存入IC卡");
while(KEY_ReadValue()!='A'); //等待A键按下
for(UINT8 i=0;i<16;i++)
{
SLE4428_Write_Byte(0x20+i,jiamihou[i]); //设置IC卡 0x20地址为存储加密数据的地址
}
UART_SendString("已将数据写入IC卡。\r\n");
UART_SendString("\r\n");
goto B;

jiemi:
lcd_pos(0,0);//定位第一行
lcd_string("观看串口调试助手");
lcd_pos(1,0);//定位第二行
lcd_string(" A键读取IC卡数据");
while(KEY_ReadValue()!='A'); //等待A键按下
SLE4428_ReadData(0x20,jiemiqian,16);
UART_SendString("读取的数据为：\r\n");
for(UINT8 i=0;i<16;i++)
{
UART_SendHex(jiemiqian[i]);
}
UART_SendString("\r\n");
lcd_wcmd(0x01);//清屏
lcd_pos(0,0);//定位第一行
lcd_string("读取成功");
lcd_pos(1,0);//定位第二行
lcd_string("选择密钥解密：");
lcd_pos(2,0);//定位第三行
lcd_string("1.正确密钥");
lcd_pos(3,0);//定位第四行
lcd_string("2.错误密钥");

//延时函数，当系统时钟为内部OSC时钟时，延时1ms
void delay(int ms)
{
int i;
while(ms--)
{
for(i=0;i<950;i++) ;
}
}

实验步骤简介：

打开“实验8-SM1”目录的工程文件。编译工程，产生后缀名为.bin的可执行代码。

下载程序

首先用9针串口线将Z32模块的串口与电脑USB接口连接。接着在电脑上打开串口助手，选择对应的串口号，设置波特率为115200，偶校验，然后打开串口。

关闭Z32电源开关，再打开，程序自动运行，此时可以看到实验现象：显示屏显示“SLE4428实验！请插入IC卡．．．”。插入SLE4428IC卡，显示屏第三行显示：“用户代码为：”，第四行显示用户代码“D27600000400”。

再按下矩阵键盘的“A”键，屏幕第一行显示提示“按-A键校验密码”并在第二行显示两个字节的校验密码按下矩阵键盘的“A”键，屏幕第三行显示“校验成功”，第四行显示校验

再按下矩阵键盘的“A”键，则屏幕显示“加密解密实验”

首先进行加密实验： 按“1”键选择加密，此时，串口调试助手显示原始数据和加密密钥。按下“A”键确认加密后，屏幕第三行显示“加密完成”，第四行显示提示“A键存入 IC 卡”。串口调试助手显示加密后的数据。

按“A”键，将加密数据存入 IC 卡，此时串口显示“已将数据写入IC卡”。屏幕回到加密解密实验选择菜单。

接着是解密实验：按“2”键选择解密实验后屏幕显示“观看串口调试助按“A”键后，此时屏幕显示“读取成功选择密钥解密：1.正确密钥2.错误密钥”。串口显示读取的数据。按“1”键选择正确的密钥后，屏幕提示“A键确认解密”，此时串口显示“将使用以下密钥进行解密”按“A”键确认解密后，屏幕提示“解密完成A键返回”，此时串口显示“解密后的数据为”。按“A”键返回加/解密选择菜单。

最后是使用错误秘钥进行解密： 在加/解密选择菜单中按“2”进行解密实验，用错误的秘钥解密。屏幕提示“观看串口调”按“A”键后，此时屏幕显示“读取成功选择密钥解密：1.正确密钥 2.错误密钥”。串口显示读取的数据，按“2”键选择错误的密钥后，屏幕提示“A键确认解密”，此时串口显示“将

使用以下密钥进行解密”按“A”键确认解密后，屏幕提示“解密完成A键返回”，此时串口显示“解密后的数据为”，这段数据与之前使用正确密钥解密和加密前的数据不同，所以解密失败。

实验截图：





遇到的问题：
同上

六、设备归还

实验步骤简介：

实验结束后，将实验室原来的网线插回，

将实验箱的数据线放入规定的袋子里。

[b]截图见蓝墨云班课[/b]