/********************************************************************* * INCLUDES */ #include "ppsp_impl.h" #include "ppsp_serv.h" #include "error.h" #include "OSAL.h" #include "core_queu.h" #include "log.h" #include "tinycrypt/aes.h" //#include "ali_genie_profile.h" //#include "tbrsh_motr_pwms.h" //#include "tbrsh_leds_pwms.h" #define PPSP_IMPL_CFGS_BUSY_STAT_BITS 0x00000001 #define PPSP_IMPL_CFGS_AUTH_STAT_BITS 0x00000002 #define PPSP_IMPL_CFGS_OTAS_STAT_BITS 0x00000004 // ota bgns #define PPSP_IMPL_CFGS_OTAE_STAT_BITS 0x00000008 // ota ends #define PPSP_IMPL_CFGS_ALIS_PIDS_COUN 4 #define PPSP_IMPL_CFGS_ALIS_MACS_COUN 6 #define PPSP_IMPL_CFGS_ALIS_SCRT_COUN 16 #define PPSP_IMPL_CFGS_MSGS_HDER_SIZE 4 #define PPSP_IMPL_CFGS_OPCO_MISN_ISSU 0x02 // issu by master, resp by slave #define PPSP_IMPL_CFGS_OPCO_MISR_RESP 0x03 // resp by slave, issu by master #define PPSP_IMPL_CFGS_OPCO_MNSI_ISSU 0x04 // issu by slave, resp by master #define PPSP_IMPL_CFGS_OPCO_MRSI_RESP 0x05 // resp by master, issu by slave #define PPSP_IMPL_CFGS_OPCO_NRSP_ISSU 0x06 // issu W/O resp #define PPSP_IMPL_CFGS_OPCO_RAND_ISSU 0x10 // issu RAND by master, resp by slave #define PPSP_IMPL_CFGS_OPCO_CIPR_RESP 0x11 // resp RAND by slave, issu by master. CIPR = ENCR(RAND, BKEY(RAND,MACS,SCRT)) #define PPSP_IMPL_CFGS_OPCO_VERF_ISSU 0x12 // issu VERF by master, resp by slave. verify result of encryption #define PPSP_IMPL_CFGS_OPCO_BKEY_RESP 0x13 // resp VERF by slave, issu by master #define PPSP_IMPL_CFGS_OPCO_NWRK_ISSU 0x14 // issu NWRK by master, resp by slave. networking rsult, unprov/proved #define PPSP_IMPL_CFGS_OPCO_NWRK_RESP 0x15 // resp NWRK by slave, issu by master. confirm of networking rsult #define PPSP_IMPL_CFGS_OPCO_VERS_ISSU 0x20 // issu VERS by master, resp by slave #define PPSP_IMPL_CFGS_OPCO_VERS_RESP 0x21 // resp VERS by slave, issu by master #define PPSP_IMPL_CFGS_OPCO_UPDA_ISSU 0x22 // issu UPDA by master, resp by slave #define PPSP_IMPL_CFGS_OPCO_UPDA_RESP 0x23 // resp UPDA by slave, issu by master. confirm, rcvd size, fast mode #define PPSP_IMPL_CFGS_OPCO_PACK_ISSU 0x2F // issu PACK by master, issu W/O resp. #define PPSP_IMPL_CFGS_OPCO_PACK_RESP 0x24 // issu PACK by slave, issu W/O resp. confirm of total frame #define PPSP_IMPL_CFGS_OPCO_COMP_ISSU 0x25 // issu COMP by master, resp by slave. complete of transfer #define PPSP_IMPL_CFGS_OPCO_COMP_RESP 0x26 // resp COMP by slave, issu by master. reply with crc #define PPSP_IMPL_CFGS_OPCO_USER_ISSU 0xFE // issu USER, resp by slave #define PPSP_IMPL_CFGS_OPCO_USER_RESP 0xFF // issu USER, resp by slave #define PPSP_IMPL_CFGS_PROG_ADDR_BASE (0x11000000) #define PPSP_IMPL_CFGS_PROG_SCTR_SIZE (0x1000) // program sector size in byte #define PPSP_IMPL_CFGS_PROG_ADDR_BGNS (0x50000) // program data bgn address of flash #define PPSP_IMPL_CFGS_PROG_FLSH_SIZE (0x30000) // program total size in byte #define PPSP_IMPL_CFGS_PROG_ADDR_ENDS (PPSP_IMPL_CFGS_PROG_ADDR_BGNS+PPSP_IMPL_CFGS_PROG_FLSH_SIZE) // program data end address of flash #define PPSP_IMPL_CFGS_PROG_VERS_REVI (1) #define PPSP_IMPL_CFGS_PROG_VERS_MINR (0) #define PPSP_IMPL_CFGS_PROG_VERS_MAJR (1) extern void ppsp_impl_serv_rcvd_hdlr(uint8 para, uint8 coun); static ppsp_serv_appl_CBs_t __ppsp_impl_hdlr_serv = { ppsp_impl_serv_rcvd_hdlr, }; static uint32 __ppsp_impl_stat_bits_flag = 0x00; static uint32 __ppsp_impl_proc_tout_coun = 0x00; static core_sque_t* __ppsp_impl_msgs_queu_rcvd = NULL; // received msgs queue static core_sque_t* __ppsp_impl_msgs_queu_xfer = NULL; // transfer msgs queue static const uint8 __ppsp_impl_opco_prim_list[] = { PPSP_IMPL_CFGS_OPCO_MISN_ISSU, PPSP_IMPL_CFGS_OPCO_MNSI_ISSU, PPSP_IMPL_CFGS_OPCO_MISR_RESP, PPSP_IMPL_CFGS_OPCO_MRSI_RESP, PPSP_IMPL_CFGS_OPCO_NRSP_ISSU, PPSP_IMPL_CFGS_OPCO_RAND_ISSU, PPSP_IMPL_CFGS_OPCO_CIPR_RESP, PPSP_IMPL_CFGS_OPCO_VERF_ISSU, PPSP_IMPL_CFGS_OPCO_BKEY_RESP, PPSP_IMPL_CFGS_OPCO_NWRK_ISSU, PPSP_IMPL_CFGS_OPCO_NWRK_RESP, PPSP_IMPL_CFGS_OPCO_VERS_ISSU, PPSP_IMPL_CFGS_OPCO_VERS_RESP, PPSP_IMPL_CFGS_OPCO_UPDA_ISSU, PPSP_IMPL_CFGS_OPCO_UPDA_RESP, PPSP_IMPL_CFGS_OPCO_PACK_ISSU, PPSP_IMPL_CFGS_OPCO_PACK_RESP, PPSP_IMPL_CFGS_OPCO_COMP_ISSU, PPSP_IMPL_CFGS_OPCO_COMP_RESP, PPSP_IMPL_CFGS_OPCO_USER_ISSU, PPSP_IMPL_CFGS_OPCO_USER_RESP, }; static uint8 __ppsp_impl_opco_prim_coun = sizeof(__ppsp_impl_opco_prim_list); static uint8 __ppsp_impl_opco_user_coun = 0; static uint8* __ppsp_impl_opco_user_list = 0; static uint8 __ppsp_impl_auth_keys_data[16]; /* * private function prototype */ // static uint8 // ppsp_impl_psh_msgs_xfer(const uint8* data, uint16 leng); /* * private function implimentation */ #define ppsp_impl_get_auth_rslt(rslt) \ { \ (rslt) = ((__ppsp_impl_stat_bits_flag & PPSP_IMPL_CFGS_AUTH_STAT_BITS)?1:0); \ } #define ppsp_impl_set_auth_rslt(flag) \ { \ if ( 0 == (flag) ) \ __ppsp_impl_stat_bits_flag &= ~PPSP_IMPL_CFGS_AUTH_STAT_BITS; \ else \ __ppsp_impl_stat_bits_flag |= PPSP_IMPL_CFGS_AUTH_STAT_BITS; \ } #define ppsp_impl_get_msgs_numb(msgs, numb) \ { \ if ( 0 != msgs ) \ (numb) = msgs[0]&0x0F; \ } #define ppsp_impl_set_msgs_numb(msgs, numb) \ { \ if ( 0 != msgs ) \ msgs[0] |= (numb)&0x0F; \ } #define ppsp_impl_get_msgs_encr(msgs, numb) \ { \ if ( 0 != msgs ) \ (numb) = ((msgs[0]&0x10)>>4); \ } #define ppsp_impl_set_msgs_encr(msgs, flag) \ { \ if ( 0 != msgs ) \ msgs[0] |= (((flag)&0x01)<<4); \ } #define ppsp_impl_get_msgs_opco(msgs, opco) \ { \ if ( 0 != msgs ) \ (opco) = msgs[1]&0xFF; \ } #define ppsp_impl_set_msgs_opco(msgs, opco) \ { \ if ( 0 != msgs ) \ msgs[1] = (opco)&0xFF; \ } #define ppsp_impl_get_msgs_seqn(msgs, alln, seqn) \ { \ if ( 0 != msgs ) { \ alln = (msgs[2]&0xF0)>>4; \ seqn = (msgs[2]&0x0F)>>0; \ } \ } #define ppsp_impl_set_msgs_seqn(msgs, alln, seqn) \ { \ if ( 0 != msgs ) \ msgs[2] = ((alln&0x0F))<<4 | ((seqn&0x0F)<<0); \ } /* * desc: get msg payload length, byte 3 of header */ #define ppsp_impl_get_msgs_frsz(msgs, frsz) \ { \ if ( 0 != msgs ) \ (frsz) = msgs[3]&0xFF; \ } #define ppsp_impl_set_msgs_frsz(msgs, frsz) \ { \ if ( 0 != msgs ) \ msgs[3] = (frsz)&0xFF; \ } /* * desc: get msg payload */ #define ppsp_impl_get_msgs_plds(msgs, data) \ { \ if ( 0 != msgs ) \ ((uint8*)(data)) = (((uint8*)(msgs))+PPSP_IMPL_CFGS_MSGS_HDER_SIZE); \ } /* * desc: set msg payload */ #define ppsp_impl_set_msgs_plds(msgs, data, coun) \ { \ if ( 0 != (uint8*)(msgs) ) \ osal_memcpy(((uint8*)(msgs))+PPSP_IMPL_CFGS_MSGS_HDER_SIZE, (uint8*)(data), coun); \ } /* * desc: PKCS#7 padding */ #define ppsp_impl_get_pkcs_7pad(bksz, dasz, pval) \ { \ pval = bksz - (dasz % bksz); \ } /* * desc: chk mesg package size */ static uint8 ppsp_impl_chk_msgs_leng(const uint8* mesg, uint16 coun) { return ( NULL != mesg && PPSP_IMPL_CFGS_MSGS_HDER_SIZE <= coun ); } /* * desc: chk mesg id */ static uint8 ppsp_impl_chk_msgs_numb(const uint8* mesg, uint16 coun) { uint8 rslt = 0; if ( 0 != mesg ) { uint8 numb; ppsp_impl_get_msgs_numb(mesg, numb); rslt = ((0 <= numb) && (15 >= numb)); } else { rslt = 0; } return ( rslt ); } /* * desc: chk mesg opcode */ static uint8 ppsp_impl_chk_msgs_opco(const uint8* mesg, uint16 coun) { uint8 rslt = 0; if ( NULL != mesg ) { uint8 opco; opco = mesg[1] & 0xFF; for ( int itr0 = 0; itr0 < __ppsp_impl_opco_prim_coun; itr0 += 1 ) { if ( rslt = (opco == __ppsp_impl_opco_prim_list[itr0]) ) { break; } } if ( !rslt ) for ( int itr0 = 0; itr0 < __ppsp_impl_opco_user_coun; itr0 += 1 ) { if ( rslt = (opco == __ppsp_impl_opco_user_list[itr0]) ) { break; } } } return ( rslt ); } /* * desc: chk mesg segment number + total segment number */ static uint8 ppsp_impl_chk_msgs_seqn(const uint8* mesg, uint16 coun) { uint8 rslt = 1; if ( NULL != mesg ) { uint8 numb; /* numb of segment sequence */ numb = (mesg[2] & 0x0F) >> 0; rslt = (0 <= numb && 15 >= numb); } if ( 1 == rslt ) { uint8 numb; /* numb of total segments */ numb = (mesg[2] & 0xF0) >> 4; rslt = (0 <= numb && 15 >= numb); } return ( rslt ); } /* * desc: create response message */ static void* ppsp_impl_new_msgs_resp(uint8 numb, uint8 opco, uint8* data, uint16 leng) { uint8* msgs = 0; /* only consider unsegmented case */ msgs = osal_mem_alloc(PPSP_IMPL_CFGS_MSGS_HDER_SIZE+leng); if ( 0 != msgs ) { osal_memset(msgs, 0, PPSP_IMPL_CFGS_MSGS_HDER_SIZE+leng); ppsp_impl_set_msgs_numb(msgs, numb); // ppsp_impl_set_msgs_encr(msgs, numb); // ppsp_impl_set_msgs_vers(msgs, numb); ppsp_impl_set_msgs_opco(msgs, opco); ppsp_impl_set_msgs_seqn(msgs, 0, 0); // frame numb, frame sequ ppsp_impl_set_msgs_frsz(msgs, leng); // frame size ppsp_impl_set_msgs_plds(msgs, data, leng); // payload // LOG("\r\nmsgs: >>> "); // for ( uint8 itr0 = 0; itr0 < PPSP_IMPL_CFGS_MSGS_HDER_SIZE+leng; itr0 += 1 ) { // LOG("%02x,", msgs[itr0]); // } // LOG("msgs: <<< \r\n"); } return ( msgs ); } static uint8 ppsp_impl_psh_msgs_rcvd(const uint8* mesg, uint16 coun) { uint8 rslt = 1; if ( 0 == mesg ) { LOG("[PANDA][ERR] NULL POINTER !!!"); rslt = 0; } // for (uint8 itr0 = 0; itr0 < coun; itr0 += 1) // LOG("[PANDA][INF] rcvd msg: data[%d]=%02x", itr0, mesg[itr0]); /* */ if ( 1 == rslt ) { rslt = ppsp_impl_chk_msgs_leng(mesg, coun); // LOG("[PANDA][INF] ppsp_impl_chk_msgs_leng: %s\n\r", rslt ? "OK" :"NG"); // printf("[PANDA][INF] ppsp_impl_chk_msgs_leng: %s\n\r", rslt ? "OK" :"NG"); } /* */ if ( 1 == rslt ) { rslt = ppsp_impl_chk_msgs_numb(mesg, coun); // LOG("[PANDA][ERR] ppsp_impl_chk_msgs_numb: %s\n\r", rslt ? "OK" :"NG"); // printf("[PANDA][ERR] ppsp_impl_chk_msgs_numb: %s\n\r", rslt ? "OK" :"NG"); } /* */ if ( 1 == rslt ) { rslt = ppsp_impl_chk_msgs_opco(mesg, coun); // LOG("[PANDA][ERR] ppsp_impl_chk_msgs_opco: %s\n\r", rslt ? "OK" :"NG"); // printf("[PANDA][ERR] ppsp_impl_chk_msgs_opco: %s\n\r", rslt ? "OK" :"NG"); } /* */ if ( 1 == rslt ) { rslt = ppsp_impl_chk_msgs_seqn(mesg, coun); // LOG("[PANDA][ERR] ppsp_impl_chk_msgs_seqn: %s\n\r", rslt ? "OK" :"NG"); // printf("[PANDA][ERR] ppsp_impl_chk_msgs_seqn: %s\n\r", rslt ? "OK" :"NG"); } /* */ if ( 1 == rslt ) { uint8* vmsg = osal_mem_alloc(coun); osal_memcpy(vmsg, mesg, coun); core_sque_psh(__ppsp_impl_msgs_queu_rcvd, &vmsg); // if segment msg, enqueue(); // else notify upper layer new msgs // __ppsp_impl_msgs_rcvd = (uint8*)data; } return ( rslt ); } static uint8 ppsp_impl_psh_msgs_xfer(const uint8* data, uint16 leng) { core_sque_psh(__ppsp_impl_msgs_queu_xfer, &data); } static void ppsp_impl_cvt_hex2Str(const unsigned char* const srcs, unsigned char* dest, int coun, int revs) { } static void ppsp_impl_prc_msgs_rand(uint8* msgs_rcvd) { uint8 itr0; uint8 msgn; uint8 rsiz; uint8* rand; ppsp_impl_get_msgs_numb(msgs_rcvd, msgn); // mesg id ppsp_impl_get_msgs_frsz(msgs_rcvd, rsiz); // rand size ppsp_impl_get_msgs_plds(msgs_rcvd, rand); // rand pointer uint8 pids[PPSP_IMPL_CFGS_ALIS_PIDS_COUN]; uint8 macs[PPSP_IMPL_CFGS_ALIS_MACS_COUN]; uint8 scrt[PPSP_IMPL_CFGS_ALIS_SCRT_COUN]; //load PID ppsp_impl_get_pids(pids); //load MAC ppsp_impl_get_macs(macs); ppsp_impl_get_scrt(scrt); if ( 1 == ppsp_impl_cal_keys(rand, rsiz, pids, sizeof(pids), macs, sizeof(macs), scrt, sizeof(scrt)) ) { LOG("\n\rKEY:>>> "); for ( itr0 = 0; itr0 < sizeof(__ppsp_impl_auth_keys_data); itr0 ++ ) LOG("%02x,", __ppsp_impl_auth_keys_data[itr0]); LOG("KEY:<<< \n\r"); uint8* msgs_xfer = 0; uint8 cipr[16] = { 0x00, }; // ciper ppsp_impl_enc_text(rand, cipr); LOG("\n\rCIP:>>> "); for ( itr0 = 0; itr0 < sizeof(cipr); itr0 ++ ) LOG("%02x,", cipr[itr0]); LOG("KEY:<<< \n\r"); msgs_xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_CIPR_RESP, cipr, sizeof(cipr)); if ( 0 != msgs_xfer ) ppsp_impl_psh_msgs_xfer(msgs_xfer, 20); } else { LOG("[PANDA][ERR] gen_aligenie_auth_key FAIL !!!"); } } static void ppsp_impl_prc_msgs_verf(uint8* msgs_rcvd) { uint8 msgn; uint8 frsz; uint8* plds; ppsp_impl_get_msgs_numb(msgs_rcvd, msgn); ppsp_impl_get_msgs_frsz(msgs_rcvd, frsz); ppsp_impl_get_msgs_plds(msgs_rcvd, plds); if ( NULL != plds && 0 == plds[0] ) { uint8* msgs_xfer = 0; /* Auth Success */ ppsp_impl_set_auth_rslt(1); msgs_xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_BKEY_RESP, plds, frsz); if ( 0 != msgs_xfer ) ppsp_impl_psh_msgs_xfer(msgs_xfer, 20); } } static void ppsp_impl_prc_msgs_nwrk(uint8* msgs_rcvd) { uint8 msgn; uint8 encr; uint8 frsz; uint8* plds; ppsp_impl_get_msgs_numb(msgs_rcvd, msgn); ppsp_impl_get_msgs_encr(msgs_rcvd, encr); ppsp_impl_get_msgs_frsz(msgs_rcvd, frsz); ppsp_impl_get_msgs_plds(msgs_rcvd, plds); uint8 text[16]; if ( 0x01 == encr ) { ppsp_impl_dec_cipr(text, plds); } if ( 0 == text[0] ) { LOG("NETW EXIT DONE"); } else if ( 1 == text[0] ) { LOG("NETW CFGS DONE"); } uint8 padd; ppsp_impl_get_pkcs_7pad(16, 1, padd); osal_memset(text, padd, sizeof(text)); text[0] = 0x01; uint8 cipr[16]; if ( 0x01 == encr ) { ppsp_impl_enc_text(text, cipr); } uint8* xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_NWRK_RESP, cipr, sizeof(cipr)); ppsp_impl_set_msgs_encr(xfer, encr); if ( 0 != xfer ) ppsp_impl_psh_msgs_xfer(xfer, 20); } /*****************************************************************************/ // ota relative uint8 __ppsp_impl_upda_type; uint32 __ppsp_impl_upda_vers; uint32 __ppsp_impl_upda_fwsz; uint16 __ppsp_impl_upda_crcs; // crc from upstream uint8 __ppsp_impl_upda_flag; uint8 __ppsp_impl_upda_buff[256]; uint16 __ppsp_impl_upda_offs; // offset of filled posi uint32 __ppsp_impl_upda_wrsz; uint16 __ppsp_impl_upda_crcd; // crc calc on local uint32 __ppsp_impl_upda_dnsz; static uint8 ppsp_impl_era_prog_data(uint32 addr) { uint8 rslt = PPlus_ERR_FATAL; // flash address range check if ( PPSP_IMPL_CFGS_PROG_ADDR_BGNS > addr || PPSP_IMPL_CFGS_PROG_ADDR_ENDS <= addr ) { rslt = PPlus_ERR_INVALID_ADDR; goto RSLT_FAIL_ADDR; } flash_sector_erase(PPSP_IMPL_CFGS_PROG_ADDR_BASE + (addr&0xFFF000)); rslt = PPlus_SUCCESS; RSLT_FAIL_ADDR: return ( rslt ); } static uint8 ppsp_impl_pul_prog_data(uint32 addr, uint32* valu) { uint8 rslt = PPlus_ERR_FATAL; // flash address range check if ( PPSP_IMPL_CFGS_PROG_ADDR_BGNS > addr || PPSP_IMPL_CFGS_PROG_ADDR_ENDS <= addr ) { rslt = PPlus_ERR_INVALID_ADDR; goto RSLT_FAIL_ADDR; } // 4 bytes aligned if ( addr & 0x000003 ) { rslt = PPlus_ERR_DATA_ALIGN; goto RSLT_FAIL_ADDR; } *valu = read_reg(PPSP_IMPL_CFGS_PROG_ADDR_BASE + addr); rslt = PPlus_SUCCESS; RSLT_FAIL_ADDR: return ( rslt ); } static uint8 ppsp_impl_psh_prog_data(uint32 addr, uint32 valu) { uint8 rslt = PPlus_ERR_FATAL; // flash address range check if ( PPSP_IMPL_CFGS_PROG_ADDR_BGNS > addr || PPSP_IMPL_CFGS_PROG_ADDR_ENDS <= addr ) { rslt = PPlus_ERR_INVALID_ADDR; goto RSLT_FAIL_ADDR; } // 4 bytes aligned if ( addr & 0x000003 ) { rslt = PPlus_ERR_DATA_ALIGN; goto RSLT_FAIL_ADDR; } if ( 0 == ProgramWord(PPSP_IMPL_CFGS_PROG_ADDR_BASE + addr, (uint8*)&valu, sizeof(valu)) ) { rslt = PPlus_ERR_FATAL; goto RSLT_FAIL_PROG; } rslt = PPlus_SUCCESS; RSLT_FAIL_PROG: RSLT_FAIL_ADDR: return ( rslt ); } static uint16 ppsp_impl_cal_crc16_CCITT_FALSE(uint16 crci, uint8* data, uint32 coun) { uint16 wCRCin = crci; uint16 wCPoly = 0x1021; while (coun--) { wCRCin ^= (*(data++) << 8); for (int i = 0; i < 8; i++) { if (wCRCin & 0x8000) wCRCin = (wCRCin << 1) ^ wCPoly; else wCRCin = wCRCin << 1; } } return (wCRCin); } static void ppsp_impl_prc_msgs_vers(uint8* msgs) { uint8 msgn; uint8 encr; uint8 frsz; uint8* plds; ppsp_impl_get_msgs_numb(msgs, msgn); ppsp_impl_get_msgs_encr(msgs, encr); ppsp_impl_get_msgs_frsz(msgs, frsz); ppsp_impl_get_msgs_plds(msgs, plds); if ( (0x01 == encr && 0x10 != frsz) || (0x00 == encr && 0x01 != frsz) ) { LOG("%s, !! INVALID MESG CONTENT !!"); goto RSLT_FAIL_MESG; } uint8 text[16], size, offs, padd; // plain text, text size, offset, padding byte; if ( 0x01 == encr ) { ppsp_impl_dec_cipr(text, plds); } else { osal_memcpy(text, plds, frsz); } text[0] = (0x00==text[0]) ? 0x00 : 0xFF; // type text[1] = PPSP_IMPL_CFGS_PROG_VERS_REVI; // revision text[2] = PPSP_IMPL_CFGS_PROG_VERS_MINR; // minor text[3] = PPSP_IMPL_CFGS_PROG_VERS_MAJR; // major text[4] = 0x00; // reserved size = sizeof(text); offs = 5; uint8 cipr[16]; // ciper if ( 0x01 == encr ) { ppsp_impl_get_pkcs_7pad(size, offs, padd); osal_memset(text+offs, padd, size-offs); ppsp_impl_enc_text(text, cipr); } uint8* xfer; if ( 0x01 == encr ) { xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_VERS_RESP, cipr, sizeof(cipr)); } else { xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_VERS_RESP, text, offs); } ppsp_impl_set_msgs_encr(xfer, encr); if ( 0 != xfer ) ppsp_impl_psh_msgs_xfer(xfer, 20); // if ( __ppsp_impl_stat_bits_flag & PPSP_IMPL_CFGS_OTAE_STAT_BITS ) { // __ppsp_impl_stat_bits_flag &= ~PPSP_IMPL_CFGS_OTAE_STAT_BITS; // write_reg(0x4000f034, 0); // flag as an OTAs auto reset // } RSLT_FAIL_MESG: } static void ppsp_impl_prc_msgs_upda(uint8* msgs) { uint8 msgn; uint8 encr; uint8 frsz; uint8* plds; ppsp_impl_get_msgs_numb(msgs, msgn); ppsp_impl_get_msgs_encr(msgs, encr); ppsp_impl_get_msgs_frsz(msgs, frsz); ppsp_impl_get_msgs_plds(msgs, plds); if ( (0x01 == encr && 0x10 != frsz) || (0x00 == encr && 0x0C != frsz) ) { LOG("%s, !! INVALID MESG CONTENT !! \r\n"); goto RSLT_FAIL_MESG; } // plain text, text size, offset, padding byte uint8 cipr_text[16], text_size, padd_offs, padd_valu; if ( 0x01 == encr ) { ppsp_impl_dec_cipr(cipr_text, plds); } else { osal_memcpy(cipr_text, plds, frsz); } uint8 copy_offs = 0; osal_memcpy(&__ppsp_impl_upda_type, cipr_text+copy_offs, sizeof(__ppsp_impl_upda_type)); // fw type copy_offs += sizeof(__ppsp_impl_upda_type); osal_memcpy(&__ppsp_impl_upda_vers, cipr_text+copy_offs, sizeof(__ppsp_impl_upda_vers)); // fw version copy_offs += sizeof(__ppsp_impl_upda_vers); osal_memcpy(&__ppsp_impl_upda_fwsz, cipr_text+copy_offs, sizeof(__ppsp_impl_upda_fwsz)); // fw size in byte copy_offs += sizeof(__ppsp_impl_upda_fwsz); osal_memcpy(&__ppsp_impl_upda_crcs, cipr_text+copy_offs, sizeof(__ppsp_impl_upda_crcs)); // crc16 copy_offs += sizeof(__ppsp_impl_upda_crcs); osal_memcpy(&__ppsp_impl_upda_flag, cipr_text+copy_offs, sizeof(__ppsp_impl_upda_flag)); // flag: 0:full update, 1:incr update LOG("%s, type:%x,vers:%x,size:%x,crcs:%x,flag:%x \r\n", __func__, __ppsp_impl_upda_type, __ppsp_impl_upda_vers, __ppsp_impl_upda_fwsz, __ppsp_impl_upda_crcs, __ppsp_impl_upda_flag); if ( PPSP_IMPL_CFGS_PROG_FLSH_SIZE < __ppsp_impl_upda_fwsz ) { LOG("%s, !! FIRMWARE SIZE EXCEED LIMIT OF %d BYTES !! \r\n", __func__, PPSP_IMPL_CFGS_PROG_FLSH_SIZE); goto RSLT_FAIL_FWSZ; } uint32 sctr = (__ppsp_impl_upda_fwsz/PPSP_IMPL_CFGS_PROG_SCTR_SIZE) + (__ppsp_impl_upda_fwsz%PPSP_IMPL_CFGS_PROG_SCTR_SIZE?1:0); for ( uint8 itr0 = 0; itr0 < sctr; itr0 += 1 ) { // PPSP_IMPL_CFGS_PROG_ADDR_BGNS + sctr * 0x1000 ppsp_impl_era_prog_data(PPSP_IMPL_CFGS_PROG_ADDR_BGNS + (itr0<<12)); } LOG("%s, total sctr:%x@size:%x erased!! \r\n", __func__, sctr, __ppsp_impl_upda_fwsz); /* resume of last trans point is not supported */ // reset to initial __ppsp_impl_upda_offs = 0; __ppsp_impl_upda_wrsz = 0; __ppsp_impl_upda_dnsz = 0; __ppsp_impl_upda_crcd = 0xFFFF; // LOG("%s, pkcs#7=%x\n", __func__, padd); cipr_text[0] = 0x01; // 1: upda allow, 0: upda deny osal_memcpy(cipr_text+1, &__ppsp_impl_upda_dnsz, sizeof(__ppsp_impl_upda_dnsz)); // text[1] = 0x00; // last upda posi // text[2] = 0x00; // last upda posi // text[3] = 0x00; // last upda posi // text[4] = 0x00; // last upda posi cipr_text[5] = 0x0F; // maxi frame in pack(0x00~0x0f:1~16) text_size = sizeof(cipr_text); padd_offs = 6; uint8 cipr[16]; if ( 0x01 == encr ) { ppsp_impl_get_pkcs_7pad(text_size, padd_offs, padd_valu); osal_memset(cipr_text+padd_offs, padd_valu, text_size-padd_offs); ppsp_impl_enc_text(cipr_text, cipr); } uint8* xfer; if ( 0x01 == encr ) { xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_UPDA_RESP, cipr, sizeof(cipr)); } else { xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_UPDA_RESP, cipr_text, padd_offs); } ppsp_impl_set_msgs_encr(xfer, encr); if ( 0 != xfer ) ppsp_impl_psh_msgs_xfer(xfer, 20); RSLT_FAIL_FWSZ: RSLT_FAIL_MESG: } static void ppsp_impl_prc_msgs_pack(uint8* msgs) { uint8 msgn; uint8 encr; uint8 alln; uint8 seqn; uint8 frsz; // payload size in byte uint8* plds; // payloads ppsp_impl_get_msgs_numb(msgs, msgn); ppsp_impl_get_msgs_encr(msgs, encr); ppsp_impl_get_msgs_seqn(msgs, alln, seqn); ppsp_impl_get_msgs_frsz(msgs, frsz); ppsp_impl_get_msgs_plds(msgs, plds); // if ( 0x01 == encr || 0x10 != frsz ) { // LOG("%s, !! INVALID MESG CONTENT !!"); // goto RSLT_FAIL_MESG; // } // TODO: HANDLE EXCEPTION OF FRAME LOSS, IN THAT CASE, LAST FRAME NUMB SHOULD RESP FOR RETRANSMITION /* * copy offset of this received frame, data copy upto the offset would be copied to a buffer. * when the buffer is full, data in this buffer should write into flash right a way. * above procedure could repeat untill all data of the frame, being write into flash. */ uint16 offs = 0; while ( offs < frsz ) { uint16 size = MIN(sizeof(__ppsp_impl_upda_buff)-__ppsp_impl_upda_offs, frsz-offs); osal_memcpy(__ppsp_impl_upda_buff+__ppsp_impl_upda_offs, plds+offs, size); __ppsp_impl_upda_offs += size; offs += size; if ( sizeof(__ppsp_impl_upda_buff) == __ppsp_impl_upda_offs ) { // flsh pack uint32 dwrd = (__ppsp_impl_upda_offs/sizeof(uint32)) + (__ppsp_impl_upda_offs%sizeof(uint32)?1:0); for ( int itr0 = 0; itr0 < dwrd; itr0 += 1 ) { uint32 valw, valr; // push for write ppsp_impl_psh_prog_data( PPSP_IMPL_CFGS_PROG_ADDR_BGNS + __ppsp_impl_upda_wrsz + (itr0 * sizeof(uint32)), valw = *((uint32*)__ppsp_impl_upda_buff + itr0)); } // __ppsp_impl_upda_crcd = ppsp_impl_cal_crc16_CCITT_FALSE(__ppsp_impl_upda_crcd, __ppsp_impl_upda_buff, __ppsp_impl_upda_offs); __ppsp_impl_upda_wrsz += __ppsp_impl_upda_offs; __ppsp_impl_upda_offs = 0; } } __ppsp_impl_upda_dnsz += frsz; LOG("%s, crci:%04x, dnsz:%08x \r\n", __func__, __ppsp_impl_upda_crcd, __ppsp_impl_upda_dnsz); if ( alln != seqn ) { goto RSLT_SKIP_MESG; } /* complete of a package, should resp rcvd seqn, rcvd size */ uint8 cipr_text[16], text_size, padd_offs, padd_valu; // plain text, text size, offset, padding byte; cipr_text[0] = ((alln&0x0F)<<4)|((seqn&0x0F)<<0); // osal_memcpy(cipr_text+1, &__ppsp_impl_upda_dnsz, sizeof(__ppsp_impl_upda_dnsz)); // text[1] = 0x00; // last upda posi // text[2] = 0x20; // last upda posi // text[3] = 0x00; // last upda posi // text[4] = 0x00; // last upda posi text_size = sizeof(cipr_text); padd_offs = 5; uint8 cipr_data[16]; uint8 auth; ppsp_impl_get_auth_rslt(auth); if ( auth ) { ppsp_impl_get_pkcs_7pad(text_size, padd_offs, padd_valu); osal_memset(cipr_text, padd_valu, text_size-padd_offs); ppsp_impl_enc_text(cipr_text, cipr_data); } uint8* xfer; if ( auth ) { xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_PACK_RESP, cipr_data, sizeof(cipr_data)); } else { xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_PACK_RESP, cipr_text, padd_offs); } ppsp_impl_set_msgs_encr(xfer, auth); if ( 0 != xfer ) ppsp_impl_psh_msgs_xfer(xfer, 20); RSLT_FAIL_MESG: RSLT_SKIP_MESG: } static void ppsp_impl_prc_msgs_comp(uint8* msgs) { uint8 msgn; uint8 encr; uint8 frsz; uint8* plds; ppsp_impl_get_msgs_numb(msgs, msgn); ppsp_impl_get_msgs_encr(msgs, encr); ppsp_impl_get_msgs_frsz(msgs, frsz); ppsp_impl_get_msgs_plds(msgs, plds); if ( (0x01 == encr && 0x10 != frsz) || (0x00 == encr && 0x01 != frsz) ) { LOG("%s, !! INVALID MESG CONTENT !! \r\n", __func__); goto RSLT_FAIL_MESG; } uint8 cipr_text[16], text_size, padd_offs, padd_valu; // plain text, text size, offset, padding byte; if ( 0x01 == encr ) { ppsp_impl_dec_cipr(cipr_text, plds); } else { osal_memcpy(cipr_text, plds, frsz); } if ( 0x01 != cipr_text[0] ) { LOG("%s, !! INVALID MESG CONTENT !! \r\n", __func__); goto RSLT_FAIL_MESG; } // flsh remains in buffer if ( 0 < __ppsp_impl_upda_offs ) { // flsh pack uint32 dwrd = (__ppsp_impl_upda_offs/sizeof(uint32)) + (__ppsp_impl_upda_offs%sizeof(uint32)?1:0); for ( int itr0 = 0; itr0 < dwrd; itr0 += 1 ) { uint32 valw, valr; // push for write ppsp_impl_psh_prog_data( PPSP_IMPL_CFGS_PROG_ADDR_BGNS + __ppsp_impl_upda_wrsz + (itr0 * sizeof(uint32)), valw = *((uint32*)__ppsp_impl_upda_buff + itr0)); } // __ppsp_impl_upda_crcd = ppsp_impl_cal_crc16_CCITT_FALSE(__ppsp_impl_upda_crcd, __ppsp_impl_upda_buff, __ppsp_impl_upda_offs); __ppsp_impl_upda_wrsz += __ppsp_impl_upda_offs; __ppsp_impl_upda_offs = 0; } /* complete of bins, should calc crc16 */ __ppsp_impl_upda_crcd = 0xffff; for ( int itr0 = 0; itr0 < __ppsp_impl_upda_fwsz; itr0++ ) { uint8 valu; memcpy(&valu, (uint8_t*)(PPSP_IMPL_CFGS_PROG_ADDR_BASE+PPSP_IMPL_CFGS_PROG_ADDR_BGNS+itr0), 1); __ppsp_impl_upda_crcd = ppsp_impl_cal_crc16_CCITT_FALSE(__ppsp_impl_upda_crcd, &valu, 1); } LOG("%s, crci:%04x, dnsz:%08x, fwsz:%08x \r\n", __func__, __ppsp_impl_upda_crcd, __ppsp_impl_upda_dnsz, __ppsp_impl_upda_fwsz); //printf("%s, crci:%04x, dnsz:%08x, fwsz:%08x \n", __func__, __ppsp_impl_upda_crcd, __ppsp_impl_upda_dnsz, __ppsp_impl_upda_fwsz); /* complete of bins, should write tags for bldr */ // uint32 tags; // osal_memcpy(&tags, "OTAF", 4); ppsp_impl_psh_prog_data(PPSP_IMPL_CFGS_PROG_ADDR_BGNS, 0x4641544f); // tag:"OTAF" // printf("%s, tags:%x \r\n", __func__, tags); // osal_memset(&tags, 0xFF, 4); // ppsp_impl_pul_prog_data(PPSP_IMPL_CFGS_PROG_ADDR_BGNS,&tags); // printf("%s, tags:%x \r\n", __func__, tags); /* complete of bins, should resp crcs chck */ cipr_text[0] = ((__ppsp_impl_upda_crcd == __ppsp_impl_upda_crcs) ? 0x01 : 0x00); //1:succ, 0:fail LOG("%s, complete of bins: crcs comp:%s \r\n", __func__, cipr_text[0]?"SUCC": "FAIL"); //printf("%s, complete of bins: crcs comp:%s \n", __func__, cipr_text[0]?"SUCC": "FAIL"); text_size = sizeof(cipr_text); padd_offs = 1; uint8 cipr_data[16]; if ( 0x01 == encr ) { ppsp_impl_get_pkcs_7pad(text_size, padd_offs, padd_valu); osal_memset(cipr_text, padd_valu, text_size-padd_offs); ppsp_impl_enc_text(cipr_text, cipr_data); } uint8* xfer; if ( 0x01 == encr ) { xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_COMP_RESP, cipr_data, sizeof(cipr_data)); } else { xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_COMP_RESP, cipr_text, padd_offs); } ppsp_impl_set_msgs_encr(xfer, encr); if ( 0 != xfer ) ppsp_impl_psh_msgs_xfer(xfer, 20); __ppsp_impl_stat_bits_flag |= PPSP_IMPL_CFGS_OTAS_STAT_BITS; __ppsp_impl_proc_tout_coun = 10; // 1secs RSLT_FAIL_MESG: } static void ppsp_impl_prc_msgs_user(uint8* msgs_rcvd) { uint8 msgn; uint8 frsz; uint8* plds; ppsp_impl_get_msgs_numb(msgs_rcvd, msgn); ppsp_impl_get_msgs_frsz(msgs_rcvd, frsz); ppsp_impl_get_msgs_plds(msgs_rcvd, plds); if ( NULL == plds || 0 >= frsz ) goto RSLT_FAIL_NULL; /* do whatever user wants */ //tbrsh_leds_gpio_set_mode(TBRSH_LEDS_ENUM_LED1, plds[0]); //tbrsh_leds_gpio_set_mode(TBRSH_LEDS_ENUM_LED2, plds[0]); //tbrsh_leds_gpio_set_mode(TBRSH_LEDS_ENUM_LED3, plds[0]); //tbrsh_motr_pwms_set_valu(30); //tbrsh_motr_pwms_set_mode(plds[0]); /* do whatever user wants */ uint8* xfer = 0; plds[0] = 0x01; // set resp of true xfer = ppsp_impl_new_msgs_resp(msgn, PPSP_IMPL_CFGS_OPCO_BKEY_RESP, plds, frsz); if ( NULL == xfer ) goto RSLT_FAIL_NMEM; ppsp_impl_psh_msgs_xfer(xfer, 20); RSLT_FAIL_NMEM: RSLT_FAIL_NULL: } static uint8 ppsp_impl_pop_msgs_rcvd(void) { uint8 rslt = 0; uint8* mesg = NULL; rslt = core_sque_pop(__ppsp_impl_msgs_queu_rcvd, &mesg); /* */ if ( 1 == rslt ) { uint8 opco; ppsp_impl_get_msgs_opco(mesg, opco); LOG("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco); if ( PPSP_IMPL_CFGS_OPCO_RAND_ISSU == opco ) { //printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco); ppsp_impl_prc_msgs_rand(mesg); } else if ( PPSP_IMPL_CFGS_OPCO_VERF_ISSU == opco ) { //printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco); ppsp_impl_prc_msgs_verf(mesg); } else if ( PPSP_IMPL_CFGS_OPCO_NWRK_ISSU == opco ) { //printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco); ppsp_impl_prc_msgs_nwrk(mesg); } else if ( PPSP_IMPL_CFGS_OPCO_VERS_ISSU == opco ) { //printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco); ppsp_impl_prc_msgs_vers(mesg); } else if ( PPSP_IMPL_CFGS_OPCO_UPDA_ISSU == opco ) { //printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco); ppsp_impl_prc_msgs_upda(mesg); } else if ( PPSP_IMPL_CFGS_OPCO_PACK_ISSU == opco ) { ppsp_impl_prc_msgs_pack(mesg); } else if ( PPSP_IMPL_CFGS_OPCO_COMP_ISSU == opco ) { //printf("[PANDA][ERR] ppsp_impl_get_msgs_opco: %02x\n\r", opco); ppsp_impl_prc_msgs_comp(mesg); } else if ( PPSP_IMPL_CFGS_OPCO_USER_ISSU == opco ) { ppsp_impl_prc_msgs_user(mesg); } osal_mem_free(mesg); } return ( rslt ); } static void ppsp_impl_serv_rcvd_hdlr(uint8 para, uint8 coun) { // LOG("[PANDA][ENT] %s para:%d, coun:%d \r\n", __func__, para, coun); if ( PPSP_SERV_CFGS_CHAR_FFD5_INDX == para || PPSP_SERV_CFGS_CHAR_FFD7_INDX == para ) { void* data = NULL; if ( NULL == (data = osal_mem_alloc(coun)) ) return; ppsp_serv_get_para(para, data, coun); ppsp_impl_psh_msgs_rcvd(data, coun); ppsp_impl_pop_msgs_rcvd(); if ( NULL != data ) osal_mem_free(data); } } /* alia: ppsp_impl_pop_msgs_xfer */ static void ppsp_impl_serv_xfer_hdlr(void) { // LOG("[PANDA][ENT] %s \r\n", __func__); uint8 rslt = 1; uint8* mesg = NULL; uint8 opco = 0; uint8 frsz = 0; rslt = core_sque_pop(__ppsp_impl_msgs_queu_xfer, &mesg); if ( 1 == rslt ) { ppsp_impl_get_msgs_opco(mesg, opco); ppsp_impl_get_msgs_frsz(mesg, frsz); if ( PPSP_IMPL_CFGS_OPCO_VERS_ISSU <= opco && PPSP_IMPL_CFGS_OPCO_COMP_RESP >= opco ) ppsp_serv_set_para(PPSP_SERV_CFGS_CHAR_FFD8_INDX, frsz + PPSP_IMPL_CFGS_MSGS_HDER_SIZE, (void*)mesg); else ppsp_serv_set_para(PPSP_SERV_CFGS_CHAR_FFD6_INDX, frsz + PPSP_IMPL_CFGS_MSGS_HDER_SIZE, (void*)mesg); osal_mem_free(mesg); } } void ppsp_impl_appl_timr_hdlr(void) { ppsp_impl_serv_xfer_hdlr(); if ( __ppsp_impl_stat_bits_flag & PPSP_IMPL_CFGS_OTAS_STAT_BITS ) { if ( 0 < __ppsp_impl_proc_tout_coun ) { __ppsp_impl_proc_tout_coun --; if ( 0 == __ppsp_impl_proc_tout_coun ) { //printf("%s, hal_system_soft_reset for bgns of otas \r\n"); write_reg(0x4000f034, 'O'); // flag as an OTAs auto reset hal_system_soft_reset(); } } }/* else if ( __ppsp_impl_stat_bits_flag & PPSP_IMPL_CFGS_OTAE_STAT_BITS ) { if ( 0 < __ppsp_impl_proc_tout_coun ) { __ppsp_impl_proc_tout_coun --; if ( 0 == __ppsp_impl_proc_tout_coun ) { printf("%s, hal_system_soft_reset for ends of otas \r\n"); // write_reg(0x4000f034, 'O'); // flag as an OTAs auto reset hal_system_soft_reset(); } } } */ } uint8 ppsp_impl_ini(void) { __ppsp_impl_stat_bits_flag = 0x00; uint32 regs = read_reg(0x4000f034); if ( 'O' == regs ) { write_reg(0x4000f034, 0); // flag as an OTAs auto reset __ppsp_impl_stat_bits_flag |= PPSP_IMPL_CFGS_OTAE_STAT_BITS; // __ppsp_impl_proc_tout_coun = 300; // 30secs } __ppsp_impl_msgs_queu_rcvd = core_sque_new(sizeof(uint8*), 32); __ppsp_impl_msgs_queu_xfer = core_sque_new(sizeof(uint8*), 32); ppsp_serv_add_serv(PPSP_SERV_CFGS_SERV_FEB3_MASK); ppsp_serv_reg_appl(&__ppsp_impl_hdlr_serv); LOG("\r\n %s, ALIS VERS NUMB: %02d.%02d.%02d \r\n", __func__, PPSP_IMPL_CFGS_PROG_VERS_MAJR, PPSP_IMPL_CFGS_PROG_VERS_MINR, PPSP_IMPL_CFGS_PROG_VERS_REVI); } uint32 ppsp_impl_get_stat(void) { return ( __ppsp_impl_stat_bits_flag ); } uint8 ppsp_impl_get_pids(uint8* pids) { uint8 rslt = 1; if ( NULL != pids ) { // load PID for ( uint8 itr0 = 0; itr0 < PPSP_IMPL_CFGS_ALIS_PIDS_COUN; itr0 += 1 ) { pids[PPSP_IMPL_CFGS_ALIS_PIDS_COUN-itr0-1] = (uint8_t)ReadFlash(0x4030+itr0); } } return ( rslt ); } uint8 ppsp_impl_get_macs(uint8* macs) { uint8 rslt = 1; uint32 addr = 0x4000; if ( NULL != macs ) { // load MAC macs [3] = (uint8)ReadFlash(addr ++); macs [2] = (uint8)ReadFlash(addr ++); macs [1] = (uint8)ReadFlash(addr ++); macs [0] = (uint8)ReadFlash(addr ++); macs [5] = (uint8)ReadFlash(addr ++); macs [4] = (uint8)ReadFlash(addr); } return ( rslt ); } uint8 ppsp_impl_get_scrt(uint8* scrt) { uint8 rslt = 1; if ( NULL != scrt ) { for ( uint8 itr0 = 0; itr0 < PPSP_IMPL_CFGS_ALIS_SCRT_COUN; itr0 ++ ) { scrt[itr0] = (uint8_t)ReadFlash(0x4010+itr0); } } return ( rslt ); } /* calc auth keys */ uint8 ppsp_impl_cal_keys(const uint8* rand, uint8 rsiz, const uint8* pids, uint8 psiz, const uint8* macs, uint8 msiz, const uint8* scrt, uint8 ssiz) { uint8 rslt = 1; #if 0 gen_aligenie_auth_key((uint8*)rand, rsiz, (uint8*)pids, psiz, (uint8*)macs, msiz, (uint8*)scrt, ssiz); cpy_aligenie_auth_key(__ppsp_impl_auth_keys_data); #endif return ( rslt ); } uint8 ppsp_impl_get_keys(uint8* keys) { uint8 rslt = 0; if ( NULL == keys ) { rslt = 0; goto RSLT_FAIL_NULL; } osal_memcpy(keys, __ppsp_impl_auth_keys_data, sizeof(__ppsp_impl_auth_keys_data)); rslt = 1; RSLT_FAIL_NULL: return ( rslt ); } uint8 ppsp_impl_enc_text(uint8* text, uint8* cipr) { uint8 rslt = 1; uint8 iv[16] = { 0x31, 0x32, 0x33, 0x61, 0x71, 0x77, 0x65, 0x64, 0x23, 0x2a, 0x24, 0x21, 0x28, 0x34, 0x6a, 0x75, }; uint8 data[16]; uint8 itr0 = 0; osal_memcpy(data, text, 16); while ( itr0 < 16 ) { data[itr0] ^= iv[itr0]; itr0 += 1; } struct tc_aes_key_sched_struct s; if ( 0 == tc_aes128_set_encrypt_key(&s, __ppsp_impl_auth_keys_data) ) { LOG("AES128 %s (NIST encr test) failed.\n", __func__); rslt = 0; goto RSLT_FAIL_ENCR; } if (tc_aes_encrypt(cipr, data, &s) == 0) { LOG("AES128 %s (NIST encr test) failed.\n", __func__); rslt = 0; goto RSLT_FAIL_ENCR; } rslt = 1; RSLT_FAIL_ENCR: return ( rslt ); } uint8 ppsp_impl_dec_cipr(uint8* text, uint8* cipr) { uint8 rslt = 1; struct tc_aes_key_sched_struct s; if (0 == tc_aes128_set_decrypt_key(&s, __ppsp_impl_auth_keys_data) ) { LOG("AES128 %s (NIST decr test) failed.\n", __func__); rslt = 0; goto RSLT_FAIL_ENCR; } if (tc_aes_decrypt(text, cipr, &s) == 0) { LOG("AES128 %s (NIST decr test) failed.\n", __func__); rslt = 0; goto RSLT_FAIL_ENCR; } uint8 aesiv[16] = { 0x31, 0x32, 0x33, 0x61, 0x71, 0x77, 0x65, 0x64, 0x23, 0x2a, 0x24, 0x21, 0x28, 0x34, 0x6a, 0x75, }; uint8 itr0 = 0; while ( itr0 < 16 ) { text[itr0] ^= aesiv[itr0]; itr0 += 1; } rslt = 1; RSLT_FAIL_ENCR: return ( rslt ); } /* * callback of connection stat changes */ void ppsp_impl_ack_conn(uint8 flag) { // /* this likely a disconnection after OTAs, reset is required for complete */ // if ( __ppsp_impl_stat_bits_flag & PPSP_IMPL_CFGS_OTAS_STAT_BITS ) { // write_reg(0x4000f034, 'O'); // flag as an OTAs auto reset // hal_system_soft_reset(); // } // // connection loss, shold reset all status // __ppsp_impl_stat_bits_flag = 0x00; }