2019-2020-2-20175332 20175323 20175228-实验二固件程序设计

实验二固件程序设计

实验二固件程序设计-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．实验报告中分析代码
程序分析主函数代码的执行过程为：

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++)
}
}

实验截图

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

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

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]=='\r'||shuju[ua
rt_rx_num]=='\n')    
{ 
     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； void
3、UART_Init(void)是串口初始化函数，实现配置串口时钟、使能中断；
4、void UART_SendByte(UINT8 dat)是发送单字节函数，使用此函数一次发送一个字节数据；
5、void UART_SendString(UINT8str)是发送字符串函数，使用此函数发送字符串数据；
6、void uart_SendString(UINT8buf[],UINT8length)是发送某一长度的字符串函数，实现发送一定长度的字符串数据。
7、void UART_SendNum(INT32num)是发送单个十进制整数函数，使用此函数发送一个十进制整数；
8、void UART_SendHex(UINT8dat)是发送单个十六进制整数函数，使用此函数发送一个十六进制整数；
9、UINT8 UART_GetByte(UINT8data)是接收单字节函数，使用此函数接收单字节数据；
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('\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++) ;  
} 
}

代码执行顺序

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

实验截图

红框内为实验结果，一开始出现乱码，经调试后出现正确结果

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

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

国密算法标准的用途
国密算法是国家密码局制定标准的一系列算法。其中包括了对称加密算法，椭圆曲线非对称加密算法，杂凑算法。具体包括SM1,SM2,SM3等，其中：
1.SM2为国家密码管理局公布的公钥算法，其加密强度为256位。其它几个重要的商用密码算法包括：
2.SM1，对称加密算法，加密强度为128位，采用硬件实现；
3.SM3，密码杂凑算法，杂凑值长度为32字节，和SM2算法同期公布，参见《国家密码管理局公告（第 22 号）》；
4.SMS4，对称加密算法，随WAPI标准一起公布，可使用软件实现，加密强度为128位。
-密码学课程
公钥密码算法——SM4
实验截图

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

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

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("将加密以下数据:\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.错误密钥");   
 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("将使用以下密钥进行解密：\r\n");  
 for(UINT8 i=0;i<16;i++) 
 {  
 UART_SendHex(jiemimiyue[i]);  
 }  
 UART_SendString("\r\n");  
 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("解密后的数据为：\r\
 n");  for(UINT8 i=0;i<16;i++)  {   
 UART_SendHex(jiemihou[i]);  }  
 UART_SendString("\r\n");  
 UART_SendString("\r\n");  
 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 段程序：**

1、第二行显示“请插入 IC 卡”，等待卡片插入；
2、SLE4428 IC 卡正确插入，第二行显示“已插入 SLE4428”，卡片插入错误则第二行显示“卡不正确 ”；
3、IC 卡正确插入，则显示“用户代码为：XXXXXXXXXX”（ XXXXXXXXXX 代表用户的代码），等待按下键盘的“A”键；
4、按下“A”键，显示屏第一行显示“按-A 键校验密码”，第二行显示“校验 0xFF,0xFF”，等待“A”键按下。
5、按下“A”键，若校验密码正确，显示屏第三行显示“校验成功”，否则显示“校验失败”，第四行显示剩余密码验证机会次数“剩余机会： X 次”（X 初始最大为 8，最小 0，当校验密码错误验证一次后，X 减 1），等待“A”键按下；
B 段程序

按下“A”键，显示屏第一行显示“加密解密试验”，第二、三行分别显示“1.加密”、“2.解密”两个选项。等待按键按下：如果“1”按下，跳转至加密程序段，如果“2”按下，跳转至解密程序段；
加密程序段：
第一行显示“观看串口调试助手”，第二行显示“A 键确认加密”，通过串口发送字符串“将加密以下数据：”并将加密前的数据发送至 PC 机，发送换行，串口继续发送“加密密钥：”并将加密密钥数组发送至 PC 机，发送完毕等待“A”键按下；
1、按下“A”键后，SM1 初始化；
2、进行 SM1 加密；
3、关闭 SM1 加密安全模块；
通过串口发送字符串“加密后的数据：”并将加密后的数据发送至 PC 机，换行，在液晶屏第三行显示“加密完成”，第四行显示“A 键存入 IC 卡”，等待“A”键按下。当“A”键按下后，向 SLE4428 IC 卡加密后的数据，通过串口向 PC 发送“已将数据写入 IC 卡。”跳转至 B 段程序。
解密程序段：
屏幕第一行显示“观看串口调试助手”，第二行显示“A 键读取 IC 卡数据”，当“A”键按下，读取 SLE4428 IC 卡解密前数据，通过串口发送 “读取的数据为：”至 PC 机并发送解密前的数据至 PC 机。在显示屏的四行分别显示“读取成功”，“选择密钥解密”，“1.正确密钥”，“错误密钥”，等待按键“1”或“2”按下。如果“1”按下，解密密钥为正确的密钥，“2”按下，解密密钥为错误的密钥，然后通过串口发送“将使用以下密钥进行解密：”并将相应的解密密钥数据发送至 PC 机。发送完毕，第一行显示“A 键确认解密”，等待“A”键按下。
1、按下“A”键后，SM1 初始化；
2、进行 SM1 解密；
3、关闭 SM1 解密安全模块；
显示屏第二行显示“解密完成”，第三行显示“A 键返回”，通过串口将 “解密后的数据为：”和解密后的数据发送至 PC 机，发送完毕等待“A” 键按下，若“A”键按下，跳转至 B 段程序。
断电，去除 IC 卡激活，实验结束。
实验截图
加密

解密
蓝框正确解密，红框错误解密

posted @ 2019-11-11 14:13 20175332张苗阅读(215) 评论(0) 编辑收藏举报

刷新页面返回顶部

20175332张苗

2019-2020-2-20175332 20175323 20175228-实验二固件程序设计

实验二 固件程序设计

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

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

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

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

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

公告