2017-2018-1 20155333 20155328 实验二 固件程序设计

2017-2018-1 20155333 20155328 《信息安全系统设计基础》实验二 固件程序设计

实验二 固件程序设计-1-MDK

0. 注意不经老师允许不准烧写自己修改的代码
1. 两人（个别三人）一组
2. 参考云班课资源中“信息安全系统实验箱指导书.pdf “第一章，1.1-1.5安装MDK，JLink驱动，注意，要用系统管理员身分运行uVision4，破解MDK（破解程序中target一定选ARM）
3. 提交破解程序中产生LIC的截图
4. 提交破解成功的截图

• 截图：

实验二 固件程序设计-2-LED

0. 注意不经老师允许不准烧写自己修改的代码
1. 参考云班课资源中“信息安全系统实验箱指导书.pdf “第一章，1.4” KEIL-MDK 中添加 Z32 SC-000 芯片库，提交安装截图
2. 参考云班课资源中“信息安全系统实验箱指导书.pdf “第一章，1.9”完成LED实验，注意“打开Z32的电源开关前，按住Reboot按键不放，两次打开电源开关，Z32即可被电脑识别，进行下载调试。提交运行结果截图
3. 实验报告中分析代码

• 实验目的
• 学习GPIO原理
• 掌握Z32安全模块驱动LED的工程原理
• 实验内容
  学习GPIO原理，阅读《ARM cortex-m0权威手册》，参考Z32HUA_DEMO工程函数库，通过设置GPIO0来控制核心板上L2灯的亮灭。
• 程序分析
  主函数代码的执行过程为：

1. 系统初始化，中断设置使能所有；
2. 判断按键，返回 boot 条件，确认是否进行程序下载；
3. 设置 GPIO0 状态为上拉输出；
4. 进入循环程序， LED 灯间隔 100ms 闪烁。

int main(void)
{
    //系统中断向量设置，使能所有中断
SystemInit ();
//返回boot条件
 if(0 == GPIO_GetVal(0))
{
    BtApiBack(0x55555555, 0xAAAAAAAA);
}
GPIO_PuPdSel(0,0); //设置 GPIO0 为上拉
GPIO_InOutSet(0,0); //设置 GPIO0为输出
while(1) 
{
delay(100);
GPIO_SetVal(0,0); // 输出低电平，点亮 LEDLED
delay(100);
GPIO_SetVal(0,1); // 输出高电平，熄灭 LEDLED
}
}
//延时函数，当系统时钟为内部OSC时钟时，延时1ms
void delay(int ms)
{
    int i;
while(ms--)
{
    for(i=0;i<950;i++)
}
}

• 实验步骤
• 打开“exp2LED闪烁”目录下的Z32.uvproj工程文件，然后编译，生成后缀名为.bin的可执行代码；
• 用USB公对公线连接电脑和试验箱；
  打开“exp2软件资料32下载调试工具”目录下的NZDloadTool.exe；
• 按住Reboot按钮的同时两次开关试验箱左上角部分的电源开关；
• 左侧显示“1设备已连接”后，下载LED项目编译后生成的Z32HUA.bin文件，目录是“exp2LED闪烁in”；
• 下载成功后关闭-打开电源开关，即可看到LED灯L2闪烁的实验现象。
• 运行结果截图：

实验二 固件程序设计-3-UART

0. 注意不经老师允许不准烧写自己修改的代码
1. 参考云班课资源中“信息安全系统实验箱指导书.pdf “第一章，1.4” KEIL-MDK 中添加 Z32 SC-000 芯片库，提交安装截图
2. 参考云班课资源中“信息安全系统实验箱指导书.pdf “第一章，1.0”完成UART发送与中断接收实验，注意“打开Z32的电源开关前，按住Reboot按键不放，两次打开电源开关，Z32即可被电脑识别，进行下载调试。提交运行结果截图
3. 实验报告中分析代码

• 实验目的
• 学习串口通信原理
• 掌握 SP3232 芯片的使用方法
• 掌握 Z32 的串行口工作原理
• 实验内容
  学习串口通信原理，阅读 SP3232 芯片文档，掌握其使用方法，参考 Z32HUA_DEMO 工程函数库 ，熟练掌握 Z32 系统硬件的UART使用方法，编程实现串口通信的基本收发功能，利用上位机上的串口调试助手观测发送和收到的数据。
• 程序分析
• 串口相关函数：

extern UINT8 shuju[64];
extern UINT8 shuju_lens; 
extern UINT8 uart_rx_num; 
extern UINT8 uart_rx_end;  
void UART_IrqService(void) 
{  //*****your code*****/  
UARTCR &= ~TRS_EN;  
{   
do{       
shuju[uart_rx_num] = UARTDR;     
if(shuju[uart_rx_num]=='
'||shuju[ua
rt_rx_num]=='
')    
{ 
     shuju_lens = uart_rx_num;      
     uart_rx_num=0;      
     uart_rx_end=1;     
    }     
    else uart_rx_num++;      
    }      
    while(FIFO_NE & UARTISR);      
    }  
UARTCR |= TRS_EN; 
}  
/**   * @函数：波特率设置  * @set： 
0-默认波特率 
115200，其他：需根据时钟源和分频计算
出 set = 时 钟(hz)/波特率  * @返回: 
none  */ 
void UART_BrpSet(UINT16 set) 
{  
UINT16 brp=0;     
UINT8 fd=0;      
if(0 == set)     
{      
//uartband@115200bps       
fd = SCU->UARTCLKCR & 0x80;        
switch(fd)         
{          
case 0x80:    
/*外部时钟 12M 晶振*/              
brp = 0x0068;              
break;             
case 0x00:    
/*内部时钟*/     
brp = 0x00AD;                   
break;                 
default:                 
brp = 0x00AD; 
break;        
}    
fd = SCU->UARTCLKCR & 0x7f ;       
brp = brp/(fd+1);     
}     
else     
{      
brp = set;     
}  
UARTBRPH = (UINT8)((brp >> 8) & 
0xFF);     
UARTBRPL = (UINT8)((brp) & 0xFF); 
}    
/**   * @函数：初始化  * @返回：none 
*/ 
void UART_Init(void) 
{  
IOM->CRA |= (1<<0); 
//使能 Uart 接口  
SCU->MCGR2 |= (1<<3); 
//使能 Uart 总线时钟  
 /******配置Uart时钟（建议使用外部晶
 振）******/  
 SCU->SCFGOR |= (1<<6);
 // 使能外部晶振  
 SCU->UARTCLKCR |= (1<<7);
 //使用外部时钟 // 
 SCU->UARTCLKCR &= ~(1<<7);
 //使用内部 OSC 时钟  
 UART_BrpSet(0);  
 //设置波特率为默认 115200  
 UARTISR = 0xFF;  
 //状态寄存器全部清除  
 UARTCR |= FLUSH; 
 //清除接收 fifo  
 UARTCR = 0;   //偶校验   
 /******配置中断使能******/ 
 UARTIER |= FIFO_NE; 
 // UARTIER |= FIFO_HF; 
 // UARTIER |= FIFO_FU; 
 // UARTIER |= FIFO_OV; 
 // UARTIER |= TXEND; 
 // UARTIER |= TRE;   
 ModuleIrqRegister(Uart_Exception,UAT
 _IrqService); 
 //挂载中断号
}       
/**   * @函数：Uart 发送一个字节  * 
@dat:  要发送的数据字节  * 
@返回：None  */ 
void UART_SendByte(UINT8 dat) 
{    
UARTCR |= TRS_EN;  
UARTDR = dat;     
do{     
if(UARTISR & TXEND)         
{                        
UARTISR |= TXEND;
//清除发送完成标志，写 1 清除        
break;         
}     
}     
while (1);     
UARTCR &= (~TRS_EN);  
}  
/**   * @函数：Uart 发送一个字符串  *
@str:  要发送的字符串 
 * @返回：None  */ 
 void UART_SendString(UINT8 * str) 
 {  
 UINT8 *p ; 
 p=str;  
 while(*p!=0){   
 UART_SendByte(*p++);  
 } 
 }   
/**   * @函数：Uart 
发送某一长度的字符串  * @buf:  
要发送的字符串  * @length:  
要发送的长度  * @返回：None  */  
void uart_SendString(UINT8buf[],UINT8
length) 
{  
UINT8 i=0;  
while(length>i){      
UART_SendByte(buf[i]);   
i=i+1;  
} 
}   
/**   * @函数：Uart 
发送一个十进制整数  * @num:  
要发送的整数 
 * @返回：None  */ 
 void UART_SendNum(INT32 num) 
 {  
 INT32 cnt = num,k;  
 UINT8 i,j;  
 if(num<0) {
 UART_SendByte('-');
 num=-num;}  
 //计算出 i 为所发数据的位数  
 for(i=1;;i++)  
 {   
 cnt = cnt/10;   
 if(cnt == 0) 
 break;  
 }  
 //算出最大被除数从高位分离  
 k = 1;  
 for(j=0;j<i-1;j++)  
 {   
 k = k*10;  
 }  
 //分离并发送各个位  
 cnt = num;  
 for(j=0;j<i;j++)  
 {   
 cnt = num/k;   
 num = num%k;   
 UART_SendByte(0x30+cnt);   
 k /= 10;  
 } 
 }   
/**   * @函数：Uart 发送一个 16 
进制整数  * @dat:  要发送的 16 进制数
* @返回：None */ 
void UART_SendHex(UINT8 dat) 
{  
UINT8 ge,shi;   
UART_SendByte('0');  
UART_SendByte('x');  
ge = dat%16;  
shi = dat/16;  
if(ge>9) ge+=7;    
//转换成大写字母  
if(shi>9) 
shi+=7;  
UART_SendByte(0x30+shi);  
UART_SendByte(0x30+ge);  
UART_SendByte(' '); 
}   
/**   * @函数：Uart 接收一个字节  * 
@param receive addsress  * @返回： 
flag  */ 
UINT8 UART_GetByte(UINT8 *data) 
{  
    UINT8 ret= 0;      
    if(0 != (UARTISR & FIFO_NE))     
    {         
    *data = UARTDR;         
    ret = 1;     
    }      
    return ret; 
}  
/**   * @函数：Uart 接收多个字节 
 * @param receive addsress  * @len： 
 长度   * @返回：none  */ 
 void UART_Receive(UINT8 *receive, 
 UINT8 len) 
 {    
 while(len != 0){   
 if(len >= 4)   
 {    
 while (!(UARTISR & FIFO_FU));    
 *receive++ = UARTDR;        
 *receive++ = UARTDR;    
 *receive++ = UARTDR;        
 *receive++ = UARTDR;           
 len -= 4;       
 }    
 else if(len >= 2)   
 {    
 while (!(UARTISR & FIFO_HF));      
 *receive++ = UARTDR;      
 *receive++ = UARTDR;         
 len -= 2;   
 }          
 else   
 {     
 while (!(UARTISR & FIFO_NE));       
 *receive++ = UARTDR;     
 len--;   
 }  
 } 
 } 

串口相关函数包括串口中断服务、波特率
设置、串口初始化、发送/接收单
字节、发送字符串、发送单个十进制整数
、发送单个十六进制整数、发送某一长度
的字符串、接收多字节函数：

1. void UART_IrqService(void)是串口
   中断服务函数，本实验中实现串口中
   断执行子程序，从 PC
   端串口调试助手发送数据至 Z32，Z32
   再经串口 发送给 PC 机；
2. void
   UART_BrpSet(UINT16
   set)是波特率设置函数，串口实验波特率
   设置 为 115200；
3. void
   UART_Init(void)是串口初始化函数，实
   现配置串口时钟、使能中断；
4. void
   UART_SendByte(UINT8
   dat)是发送单字节函数，使用此函数一次
   发 送一个字节数据； 5) void
   UART_SendString(UINT8 *
   str)是发送字符串函数，使用此函数发送
   字符串数据；
5. void uart_SendString(UINT8
   buf[],UINT8
   length)是发送某一长度的字符
   串函数，实现发送一定长度的字符串数据
   。
6. void UART_SendNum(INT32
   num)是发送单个十进制整数函数，使用此
   函数发送一个十进制整数；
7. void UART_SendHex(UINT8
   dat)是发送单个十六进制整数函数，使用
   此 函数发送一个十六进制整数；

UINT8 UART_GetByte(UINT8
*data)是接收单字节函数，使用此函数接
收单字节数据；
10) void UART_Receive(UINT8 *receive,
UINT8 len) 是接收多字节函数，使
用此函数接收多个字节数据；

• 主函数：

UINT8 shuju_lens; 
UINT8 shuju[64]; 
UINT8 uart_rx_num; 
UINT8 uart_rx_end;  
int main(void) 
{ /*********************此段代码勿动*
**********************/  
//系统中断向量设置，使能所有中断  
SystemInit ();     
// 返回 boot 条件  
if(0 == GPIO_GetVal(0))  
{   
BtApiBack(0x55555555, 0xAAAAAAAA);  
} 
/*********************此段代码勿动***
********************/    
UART_Init();    
//初始化 Uart  
 UART_SendByte('A');                 
//Uart 发送一个字符 A  
UART_SendByte('
');
UART_SendByte('
');
//换行  
UART_SendString("Welcome to 
Z32HUA!");  //Uart 发送字符串  
UART_SendByte('
');UART_SendByte('

');
//换行  
UART_SendNum(1234567890);            
//Uart 发送一个十进制数  
UART_SendByte('
');UART_SendByte('

');
//换行  
 UART_SendHex(0xAA);
//Uart 发送一个十六进制数  
UART_SendByte('
');UART_SendByte('

');
//换行  
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++) ;  
} 
}  

代码的执行过程为：

1. 系统初始化，中断设置，使能所有中
   ；
2. 判断按键，返回 boot
   条件，确认是否进行程序下载；
3. 初始化 Uart，使能 Uart 接口，配置
   Uart 中断并使能；
4. 先发送单个字符“A”，换行，再发送字
   符串“Welcome to Z32HUA!”，
   换行，发送数字串“1234567890”，换行，
   再发送 16 位数“0xAA”，换 行。
5. 进入 while
   循环程序，等待串口中断到来并判断数据
   是否接收完毕，若
   中断到来，转入执行串口中断服务程序，
   待接收数据完毕，Z32 将数据
   发回串口助手。

• 实验步骤

1. 打开“exp2UART发送与中断接收”目录下的Z32HUA.uvproj工程文件。 编译工程，产生后缀名为.bin 的可执行代码。
2. 下载程序 将实验箱接入电源，用 USB 公对公线将实验箱的 USB 接口连接到电脑的 USB 接口上，在电脑上找到“exp2软件资料串口调试助手”目录,打开“sscom42.exe”,即串口助手。打开 Z32 的电源开关前， 按住 Reboot按键不放，两次打开电源开关，Z32 即可被电脑识别，进行下 载调试。当左边框出现“1 设备已连接”，设备选择中显示芯片型号，打开“exp2/UART 发送与中断接收in32HUA.bin”，点击下载。左边状态提示框更新显示“程序下载成功！”
3. 用 9 针串口线将 Z32 模块的串口与电脑 USB 接口连接。 在电脑上打开串口助手，选择对应的串口号，设置波特率为 115200， 偶校验（Even），选中“发送新行”，然后打开串口。如果串口号未知的情况下，可以查看串口连接线所占用的 PC 端口。方法如 下（以 Windows 7 系统为例）：控制面板——设备管理器——端口，查看该 串口线所占用的PC端口。
4. 关闭 Z32 电源开关，再打开，程序自动运行，可以在串口调试助手看到如下 实验现象：显示“A Welcome to Z32HUA! 1234567890 0xAA”，证明 PC 机 串口已经接收到 Z32 串口发送来的信息。
5. 在串口调试助手的字符串输入框输入字符串“abcdefgh”，然后点击发 送按钮。 这时，可以看到串口调试助手接收到发送输入的字符串“abcdefgh”， 并显示在串口助手上。

• 运行结果截图：

实验二 固件程序设计-4-国密算法

0. 网上搜集国密算法标准SM1,SM2,SM3,SM4
1. 网上找一下相应的代码和标准测试代码，在Ubuntu中分别用gcc和gcc-arm编译
2. 四个算法的用途？
3. 《密码学》课程中分别有哪些对应的算法？
4. 提交2，3两个问题的答案
5. 提交在Ubuntu中运行国密算法测试程序的截图

国密即国家密码局认定的国产密码算法。主要有SM1，SM2，SM3，SM4。密钥长度和分组长度均为128位。

SM1 为对称加密。其加密强度与AES相当。该算法不公开，调用该算法时，需要通过加密芯片的接口进行调用。

SM2为非对称加密，基于ECC。该算法已公开。由于该算法基于ECC，故其签名速度与秘钥生成速度都快于RSA。ECC 256位（SM2采用的就是ECC 256位的一种）安全强度比RSA 2048位高，但运算速度快于RSA。

SM3 消息摘要。可以用MD5作为对比理解。该算法已公开。校验结果为256位。

SM4 无线局域网标准的分组数据算法。对称加密，密钥长度和分组长度均为128位。

由于SM1、SM4加解密的分组大小为128bit，故对消息进行加解密时，若消息长度过长，需要进行分组，要消息长度不足，则要进行填充。

C语言代码

国产密码算法（国密算法）是指国家密码局认定的国产商用密码算法，在金融领域目前主要使用公开的SM2、SM3、SM4三类算法，分别是非对称算法、哈希算法和对称算法。

SM2算法：SM2椭圆曲线公钥密码算法是我国自主设计的公钥密码算法，包括SM2-1椭圆曲线数字签名算法，SM2-2椭圆曲线密钥交换协议，SM2-3椭圆曲线公钥加密算法，分别用于实现数字签名密钥协商和数据加密等功能。SM2算法与RSA算法不同的是，SM2算法是基于椭圆曲线上点群离散对数难题，相对于RSA算法，256位的SM2密码强度已经比2048位的RSA密码强度要高。

SM3算法：SM3杂凑算法是我国自主设计的密码杂凑算法，适用于商用密码应用中的数字签名和验证消息认证码的生成与验证以及随机数的生成，可满足多种密码应用的安全需求。为了保证杂凑算法的安全性，其产生的杂凑值的长度不应太短，例如MD5输出128比特杂凑值，输出长度太短，影响其安全性SHA-1算法的输出长度为160比特，SM3算法的输出长度为256比特，因此SM3算法的安全性要高于MD5算法和SHA-1算法。

SM4算法：SM4分组密码算法是我国自主设计的分组对称密码算法，用于实现数据的加密/解密运算，以保证数据和信息的机密性。要保证一个对称密码算法的安全性的基本条件是其具备足够的密钥长度，SM4算法与AES算法具有相同的密钥长度分组长度128比特，因此在安全性上高于3DES算法。

• 运行结果截图：

实验二 固件程序设计-5-SM1

0. 注意不经老师允许不准烧写自己修改的代码
1. 参考云班课资源中“信息安全系统实验箱指导书.pdf “第一章，1.4” KEIL-MDK 中添加 Z32 SC-000 芯片库，提交安装截图
2. 参考云班课资源中“信息安全系统实验箱指导书.pdf “第一章，1.16”完成SM1加密实验，注意“打开Z32的电源开关前，按住Reboot按键不放，两次打开电源开关，Z32即可被电脑识别，进行下载调试。提交运行结果截图
3. 实验报告中分析代码

• 实验目的
• 学习 SM1 加解密算法原理
• 掌握 SM1 加、解密算法用法
• 实验内容
  学习 SM1 加密原理，阅读《ARM cortex-m0 权威手册》和《Z32HUA 国密 算法库用户手册》，参考 Z32HUA_DEMO 工程函数库，调用 SM1 加解密函数，实现对 SLE4428 IC 的数据加解密操作。
• 程序分析

UINT8
jiamiqian[16]={0x00,0x01,0x02,0x03,0x
04,0x05,0x06,0x07,0x08,0x09,0x0A,0x 
0B,0x0C,0x0D,0x0E,0x0F}; 
UINT8 
jiamimiyue[16]={0x00,0x01,0x02,0x03,0
x04,0x05,0x06,0x07,0x08,0x09,0x0A, 
0x0B,0x0C,0x0D,0x0E,0x0F}; 
UINT8 
jiamihou[16];  
UINT8 
jiemiqian[16],jiemimiyue[16],jiemihou
[16]; 
UINT8 
cuowumiyue[16]={0x00,0x00,0x00,0x00,0
x00,0x00,0x00,0x00,0x00,0x00,0x00 
,0x00,0x00,0x00,0x00,0x00}; 
UINT8 
UserCode[5];
UINT8 C;   
int main(void) 
{  
/*********************此段代码勿动***
********************/  
//系统中断向量设置，使能所有中断  
SystemInit ();     
// 返回 boot 条件 
if(0 == GPIO_GetVal(0)) 
{   
BtApiBack(0x55555555, 0xAAAAAAAA);  
} 
/*********************此段代码勿动***********************/     
/*初始化 IC 卡插入检测 IO 口 GPIO6*/ 
GPIO_Config(6);    
PIO_PuPdSel(6,0); //上拉  
GPIO_InOutSet(6,1); //输入      
 UART_Init();  
 lcd_init();  
 KEY_Init();  
 lcd_pos(0,0);//定位第一行  
 lcd_string("SLE4428 实验！");  

A: while(1){   
lcd_pos(1,0);//定位第二行   
lcd_string("请插入 IC 卡.  ");   
delay(1000); 
   if(GPIO_GetVal(6)==0) 
   break;      
   lcd_pos(1,0);//定位第二行   
   lcd_string("请插入 IC 卡.. ");   
   delay(1000);   
   if(GPIO_GetVal(6)==0) 
   break;      
   lcd_pos(1,0);//定位第二行   
   lcd_string("请插入 IC 卡...");   
   delay(1000);   
   if(GPIO_GetVal(6)==0) 
   break;     
}  
 if(SLE4428_InitAndRST(2)!=0xFFFFFFFF
 )  
 //收到 ATR  
 {   
 lcd_pos(1,0);//定位第二行   
 lcd_string("已插入 SLE4428");  }  
 else  
 {   
 lcd_pos(1,0);//定位第二行   
 lcd_string("卡不正确     ");   
 SLE4428_Deactivation(); 
 //下电，去激活   
 delay(1000);   
 goto A;   
 }  
 lcd_pos(2,0);//定位第三行  
 lcd_string("用户代码为：");  
 SLE4428_ReadData(0x15,UserCode,6); 
 //读取用户代码  
 lcd_pos(3,0);//定位第四行  
 for(UINT8 i=0;i<6;i++) 
 
  lcd_Hex(UserCode[i]) ;  
 while(KEY_ReadValue()!='A'); 
 //等待 A 键按下  
 lcd_wcmd(0x01);
 //清屏    
 lcd_pos(0,0);//定位第一行  
 lcd_string("按-A 键校验密码");  
 lcd_pos(1,0);//定位第二行  
 lcd_string("校验 0xFF,0xFF");  
 while(KEY_ReadValue()!='A'); 
 //等待 A 键按下  
 lcd_pos(2,0);//定位第三行  
 if(SLE4428_PassWord(0xFF,0xFF)==1)  
 lcd_string("校验成功"); 
 else   
 {
 lcd_string("校验失败"); return 0;}  
 lcd_pos(3,0);//定位第四行    
 switch(SLE4428_ReadByte(0x03fd))   
 //查看剩余密码验证机会 
 {   
 case 0xff: 
 lcd_string("剩余机会： 8 次");
 break;   
 case 0x7f: 
 lcd_string("剩余机会： 7 次");
 break;   case 0x3f: 
 lcd_string("剩余机会： 6 次");
 break;   
 case 0x1f: 
 lcd_string("剩余机会： 5 次");
 break;   
 case 0x0f: 
 lcd_string("剩余机会： 4 次");
 break;   
 case 0x07: 
 lcd_string("剩余机会： 3 次");
 break;   
 case 0x03: 
 lcd_string("剩余机会： 2 次");
 break;   
 case 0x01: 
 lcd_string("剩余机会： 1 次");
 break;   
 case 0x00: 
 lcd_string("剩余机会： 0 次");
 break;   
 default: 
 break;  
     
 } 
 
   while(KEY_ReadValue()!='A'); 
   //等待 A 键按下 B: 
   lcd_wcmd(0x01);//清屏  
   lcd_pos(0,0);//定位第一行  
   lcd_string("加密解密实验");  
   lcd_pos(1,0);//定位第二行  
   lcd_string("1.加密");  
   lcd_pos(2,0);//定位第三行  
   lcd_string("2.解密");  
 do{   
 C=KEY_ReadValue();  
 }  while(C!='1'&&C!='2'); 
 //等待 1 或 2 键按下  
 lcd_wcmd(0x01);//清屏  
 if(C=='1') 
 goto jiami;  
 else if(C=='2') goto jiemi;  
 else ;   
jiami:  
lcd_pos(0,0);//定位第一行  
lcd_string("观看串口调试助手");  
lcd_pos(1,0);//定位第二行  
lcd_string("A 键确认加密");  
UART_SendString("将加密以下数据:
");  
for(UINT8 i=0;i<16;i++) 
{   
UART_SendHex(jiamiqian[i]);  
}  
UART_SendString("
");  
UART_SendString("加密密钥:
");  
for(UINT8 i=0;i<16;i++) 
 {   
 UART_SendHex(jiamimiyue[i]);  
 }  
 UART_SendString("
");  
 while(KEY_ReadValue()!='A'); 
 //等待 A 键按下  
 SM1_Init(jiamimiyue);   //SM1 初始化
 SM1_Crypto(jiamiqian, 16, 0, 0,  0,jiamihou); //进行加密  
 SM1_Close(); //关闭安全模块  
 UART_SendString("加密后的数据:
");  
 for(UINT8 i=0;i<16;i++) 
 {   
 UART_SendHex(jiamihou[i]);  
 }  
 UART_SendString("
");  
 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 卡。
");  
 UART_SendString("
");  
 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("读取的数据为：
");  
 for(UINT8 i=0;i<16;i++)  
 {  
 UART_SendHex(jiemiqian[i]);  
 }  
 UART_SendString("
");  
 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.错误密钥");   
 do{   
 C=KEY_ReadValue();  
 } while(C!='1'&&C!='2'); 
 //等待 1 或 2 键按下  
 lcd_wcmd(0x01);//清屏 
 if(C=='1')   
 { 
 for(UINT8 i=0;i<16;i++)   jiemimiyue[i] = jiamimiyue[i];   
 }  
 else if(C=='2')  
 {  
 for(UINT8 i=0;i<16;i++) 
  jiemimiyue[i] = cuowumiyue[i];  
 }  
  else ;  
 UART_SendString("将使用以下密钥进行解密：
");  
 for(UINT8 i=0;i<16;i++) 
 {  
 UART_SendHex(jiemimiyue[i]);  
 }  
 UART_SendString("
");  
 lcd_pos(0,0);//定位第一行  
 lcd_string("A 键确认解密");  
 while(KEY_ReadValue()!='A'); 
 //等待 A 键按下  
 SM1_Init(jiemimiyue);   
 //SM1 初始化  
 SM1_Crypto(jiemiqian, 16, 1, 0, 0,jiemihou); 
 //进行解密  
 SM1_Close(); //关闭安全模块  
 lcd_pos(1,0);//定位第二行  
 lcd_string("解密完成");  
 lcd_pos(2,0);//定位第三行  
 lcd_string("A 键返回");  
 UART_SendString("解密后的数据为：
 n");  for(UINT8 i=0;i<16;i++)  {   
 UART_SendHex(jiemihou[i]);  }  
 UART_SendString("
");  
 UART_SendString("
");  
 while(KEY_ReadValue()!='A');
 //等待 A 键按下  
 goto B;   
 SLE4428_Deactivation(); //下电，去激活,实验结束   
 while(1) { 
 }   
}  
//延时函数，当系统时钟为内部 OSC 时钟时，延时 1ms 
void delay(int ms)
{  
int i; 
while(ms--)  
{  
for(i=0;i<950;i++) ;  
} 
}  

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

1. 系统初始化，中断设置，使能所有中断；
2. 判断按键，返回 boot 条件，确认是否进行程序下载；
3. 初始化 IC 卡插入检测端口 GPIO6；
4. 串口初始化；
5. LCD12864 初始化；
6. 矩阵键盘初始化；
7. 液晶屏第一行显示字符串“SLE4428 实验！”。

A 段程序：

8. 第二行显示“请插入 IC 卡”，等待卡片插入；

9. SLE4428 IC 卡正确插入，第二行显示“已插入 SLE4428”，卡片插入错 误则第二行显示“卡不正确 ”；

10. IC 卡正确插入，则显示“用户代码为：XXXXXXXXXX”（ XXXXXXXXXX 代表 用户的代码），等待按下键盘的“A”键；

11. 按下“A”键，显示屏第一行显示“按-A 键校验密码”，第二行显示“校 验 0xFF,0xFF”，等待“A”键按下。

12. 按下“A”键，若校验密码正确，显示屏第三行显示“校验成功”，否则 显示“校验失败”，第四行显示剩余密码验证机会次数“剩余机会： X 次”（X 初始最大为 8，最小 0，当校验密码错误验证一次后，X 减 1）， 等待“A”键按下；

B 段程序：

13. 按下“A”键，显示屏第一行显示“加密解密试验”，第二、三行分别显 示“1.加密”、“2.解密”两个选项。等待按键按下：如果“1”按下， 跳转至加密程序段，如果“2”按下，跳转至解密程序段；

加密程序段：

14. 第一行显示“观看串口调试助手”，第二行显示“A 键确认加密”，通过 串口发送字符串“将加密以下数据：”并将加密前的数据发送至 PC 机， 发送换行，串口继续发送“加密密钥：”并将加密密钥数组发送至 PC 机， 发送完毕等待“A”键按下；

15. 按下“A”键后，SM1 初始化；

16. 进行 SM1 加密；

17. 关闭 SM1 加密安全模块；

18. 通过串口发送字符串“加密后的数据：”并将加密后的数据发送至 PC 机， 换行，在液晶屏第三行显示“加密完成”，第四行显示“A 键存入 IC 卡”， 等待“A”键按下。当“A”键按下后，向 SLE4428 IC 卡加密后的数据， 通过串口向 PC 发送“已将数据写入 IC 卡。”跳转至 B 段程序。

解密程序段：

19. 屏幕第一行显示“观看串口调试助手”，第二行显示“A 键读取 IC 卡数 据”，当“A”键按下，读取 SLE4428 IC 卡解密前数据，通过串口发送 “读取的数据为：”至 PC 机并发送解密前的数据至 PC 机。在显示屏的 四行分别显示“读取成功”，“选择密钥解密”，“1.正确密钥”，“错误密 钥”，等待按键“1”或“2”按下。如果“1”按下，解密密钥为正确的 密钥，“2”按下，解密密钥为错误的密钥，然后通过串口发送“将使用 以下密钥进行解密：”并将相应的解密密钥数据发送至 PC 机。发送完毕， 第一行显示“A 键确认解密”，等待“A”键按下。

20. 按下“A”键后，SM1 初始化；

21. 进行 SM1 解密；

22. 关闭 SM1 解密安全模块；

23. 显示屏第二行显示“解密完成”，第三行显示“A 键返回”，通过串口将 “解密后的数据为：”和解密后的数据发送至 PC 机，发送完毕等待“A” 键按下，若“A”键按下，跳转至 B 段程序。

24. 断电，去除 IC 卡激活，实验结束。

• 实验步骤

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

• 关闭 Z32 电源开关，再打开，程序自动运行，此时可以看到实验现象：显示屏显示“SLE4428 实验！请插入 IC 卡．．．”。

• 插入 SLE4428 IC 卡，显示屏第三行显示：“用户代码为：”，第四行显示用户 代码“D27600000400”。 如果插入错误的卡片，则显示屏第二行显示：“卡不正确”。

  若插入了正确的卡片，显示出用户代码，再按下矩阵键盘的“A”键，屏幕 第一行显示提示“按-A 键校验密码”并在第二行显示两个字节的校验密码 “校验 0xFF，0xFF”。

• 按下矩阵键盘的“A”键，屏幕第三行显示“校验成功”，第四行显示校验 剩余机会“剩余机会：8 次”。

• 再按下矩阵键盘的“A”键，则屏幕第一行显示“加密解密实验”，第二、 三行分别显示选项“1.加密”，“2.解密”。 首先进行加密实验。按“1”键选择加密，屏幕第一行显示“观看串口调试 助手”，第二行显示“A 键确认加密”。此时，串口调试助手显示原始数据和 加密密钥。

• 按下“A”键确认加密后，屏幕第三行显示“加密完成”，第四行显示提示 “A 键存入 IC 卡”。串口调试助手显示加密后的数据。

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

• 下面进行解密实验。按“2”键选择解密实验后屏幕显示“观看串口调试助手 A 键读取 IC 卡数据”。

• 按“A”键后，此时屏幕显示“读取成功 选择密钥解密：1.正确密钥 2.错 误密钥”。串口显示“读取的数据：为：0x7E 0xDC 0xA3 0x7B 0xBA 0x53 0x84 0xAC 0x0B 0x75 0x50 0x45 0x2E 0xEC 0x4F 0x4F”。

  按“ 1”键选择正确的密钥后，屏幕提示“A 键确认解密”，此时串口显示“将 使用以下密钥进行解密：0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F”。

  按“A” 键确认解密后，屏幕提示“解密完成 A 键返回”，此时串口显示 “解密后的数据为：0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F”。

• 按“A”键返回加/解密选择菜单。
  如果使用错误秘钥进行解密，解密后将不能得到原始数据，在加/解密选择
  菜单中按“2”进行解密实验，用错误的秘钥解密。屏幕提示“观看串口调试助手 A 键读取 IC 卡数据”。

• 按“A”键后，此时屏幕显示“读取成功 选择密钥解密：1.正确密钥 2.错 误密钥”。串口显示“读取的数据：为：0x7E 0xDC 0xA3 0x7B 0xBA 0x53 0x84 0xAC 0x0B 0x75 0x50 0x45 0x2E 0xEC 0x4F 0x4F”。

  按“ 2”键选择错误的密钥后，屏幕提示“A 键确认解密”，此时串口显示“将 使用以下密钥进行解密：0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00”。

  按“A” 键确认解密后，屏幕提示“解密完成 A 键返回”，此时串口显示 “解密后的数据为：0xB9 0x8C 0xB6 0x40 0xA2 0xD2 0x83 0xD0 0x64 0x6E 0x54 0x26 0x86 0x6D 0x5A 0xF5”。而正确的原始数据为：“0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F”，所 以解密失败。

• 运行结果截图：

实验二 固件程序设计-6-清理

实验结束后，把实验室原来的网线插回，否则以后做实验的同学无法开机
0. 只有用实验室机器的小组做

1. 提交你们小组使用的计算机的编号照片
2. 提交插好网线的照片
3. 提交盖好后盖的照片

• 截图：