X-Git-Url: https://oss.titaniummirror.com/gitweb/?a=blobdiff_plain;f=tos%2Fchips%2Fcc2420%2Ftransmit%2FCC2420TransmitP.nc;h=7e12cec89ae136f5c2b5496975083e72528f2cb7;hb=e9bfab607e051bae6afb47b44892ce37541d1b44;hp=cd640b1e7f29336bdbcef0a65e8a46bf238496cd;hpb=adf1de6c009d13b7b52e68535c63b28f59c97400;p=tinyos-2.x.git diff --git a/tos/chips/cc2420/transmit/CC2420TransmitP.nc b/tos/chips/cc2420/transmit/CC2420TransmitP.nc index cd640b1e..7e12cec8 100644 --- a/tos/chips/cc2420/transmit/CC2420TransmitP.nc +++ b/tos/chips/cc2420/transmit/CC2420TransmitP.nc @@ -33,6 +33,8 @@ * @author Jonathan Hui * @author David Moss * @author Jung Il Choi Initial SACK implementation + * @author JeongGil Ko + * @author Razvan Musaloiu-E * @version $Revision$ $Date$ */ @@ -71,6 +73,13 @@ module CC2420TransmitP @safe() { uses interface CC2420Strobe as SFLUSHTX; uses interface CC2420Register as MDMCTRL1; + uses interface CC2420Strobe as STXENC; + uses interface CC2420Register as SECCTRL0; + uses interface CC2420Register as SECCTRL1; + uses interface CC2420Ram as KEY0; + uses interface CC2420Ram as KEY1; + uses interface CC2420Ram as TXNONCE; + uses interface CC2420Receive; uses interface Leds; } @@ -96,6 +105,17 @@ implementation { enum { CC2420_ABORT_PERIOD = 320 }; + +#ifdef CC2420_HW_SECURITY + uint16_t startTime = 0; + norace uint8_t secCtrlMode = 0; + norace uint8_t nonceValue[16] = {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}; + norace uint8_t skip; + norace uint16_t CTR_SECCTRL0, CTR_SECCTRL1; + uint8_t securityChecked = 0; + + void securityCheck(); +#endif norace message_t * ONE_NOK m_msg; @@ -104,7 +124,7 @@ implementation { norace uint8_t m_tx_power; cc2420_transmit_state_t m_state = S_STOPPED; - + bool m_receiving = FALSE; uint16_t m_prev_time; @@ -375,7 +395,6 @@ implementation { if ( type == IEEE154_TYPE_ACK && m_msg) { ack_header = call CC2420PacketBody.getHeader( ack_msg ); msg_header = call CC2420PacketBody.getHeader( m_msg ); - if ( m_state == S_ACK_WAIT && msg_header->dsn == ack_header->dsn ) { call BackoffTimer.stop(); @@ -534,6 +553,9 @@ implementation { return FAIL; } +#ifdef CC2420_HW_SECURITY + securityChecked = 0; +#endif m_state = S_LOAD; m_cca = cca; m_msg = p_msg; @@ -578,7 +600,123 @@ implementation { return SUCCESS; } - +#ifdef CC2420_HW_SECURITY + + task void waitTask(){ + call Leds.led2Toggle(); + if(SECURITYLOCK == 1){ + post waitTask(); + }else{ + securityCheck(); + } + } + + void securityCheck(){ + + cc2420_header_t* msg_header; + cc2420_status_t status; + security_header_t* secHdr; + uint8_t mode; + uint8_t key; + uint8_t micLength; + + msg_header = call CC2420PacketBody.getHeader( m_msg ); + + if(!(msg_header->fcf & (1 << IEEE154_FCF_SECURITY_ENABLED))){ + // Security is not used for this packet + // Make sure to set mode to 0 and the others to the default values + CTR_SECCTRL0 = ((0 << CC2420_SECCTRL0_SEC_MODE) | + (1 << CC2420_SECCTRL0_SEC_M) | + (1 << CC2420_SECCTRL0_SEC_TXKEYSEL) | + (1 << CC2420_SECCTRL0_SEC_CBC_HEAD)) ; + + call CSN.clr(); + call SECCTRL0.write(CTR_SECCTRL0); + call CSN.set(); + + return; + } + + if(SECURITYLOCK == 1){ + post waitTask(); + }else { + //Will perform encryption lock registers + atomic SECURITYLOCK = 1; + + secHdr = (security_header_t*) &msg_header->secHdr; + memcpy(&nonceValue[3], &(secHdr->frameCounter), 4); + + skip = secHdr->reserved; + key = secHdr->keyID[0]; // For now this is the only key selection mode. + + if (secHdr->secLevel == NO_SEC){ + mode = CC2420_NO_SEC; + micLength = 4; + }else if (secHdr->secLevel == CBC_MAC_4){ + mode = CC2420_CBC_MAC; + micLength = 4; + }else if (secHdr->secLevel == CBC_MAC_8){ + mode = CC2420_CBC_MAC; + micLength = 8; + }else if (secHdr->secLevel == CBC_MAC_16){ + mode = CC2420_CBC_MAC; + micLength = 16; + }else if (secHdr->secLevel == CTR){ + mode = CC2420_CTR; + micLength = 4; + }else if (secHdr->secLevel == CCM_4){ + mode = CC2420_CCM; + micLength = 4; + }else if (secHdr->secLevel == CCM_8){ + mode = CC2420_CCM; + micLength = 8; + }else if (secHdr->secLevel == CCM_16){ + mode = CC2420_CCM; + micLength = 16; + }else{ + return; + } + + CTR_SECCTRL0 = ((mode << CC2420_SECCTRL0_SEC_MODE) | + ((micLength-2)/2 << CC2420_SECCTRL0_SEC_M) | + (key << CC2420_SECCTRL0_SEC_TXKEYSEL) | + (1 << CC2420_SECCTRL0_SEC_CBC_HEAD)) ; +#ifndef TFRAMES_ENABLED + CTR_SECCTRL1 = (skip+11+sizeof(security_header_t)+((skip+11+sizeof(security_header_t))<<8)); +#else + CTR_SECCTRL1 = (skip+10+sizeof(security_header_t)+((skip+10+sizeof(security_header_t))<<8)); +#endif + + call CSN.clr(); + call SECCTRL0.write(CTR_SECCTRL0); + call CSN.set(); + + call CSN.clr(); + call SECCTRL1.write(CTR_SECCTRL1); + call CSN.set(); + + call CSN.clr(); + call TXNONCE.write(0, nonceValue, 16); + call CSN.set(); + + call CSN.clr(); + status = call SNOP.strobe(); + call CSN.set(); + + while(status & CC2420_STATUS_ENC_BUSY){ + call CSN.clr(); + status = call SNOP.strobe(); + call CSN.set(); + } + + // Inline security will be activated by STXON or STXONCCA strobes + + atomic SECURITYLOCK = 0; + + } + } +#endif + /** * Attempt to send the packet we have loaded into the tx buffer on * the radio chip. The STXONCCA will send the packet immediately if @@ -591,6 +729,9 @@ implementation { * * If the packet got sent, we should expect an SFD interrupt to take * over, signifying the packet is getting sent. + * + * If security is enabled, STXONCCA or STXON will perform inline security + * options before transmitting the packet. */ void attemptSend() { uint8_t status; @@ -605,10 +746,13 @@ implementation { signal Send.sendDone( m_msg, ECANCEL ); return; } - - +#ifdef CC2420_HW_SECURITY + if(securityChecked != 1){ + securityCheck(); + } + securityChecked = 1; +#endif call CSN.clr(); - status = m_cca ? call STXONCCA.strobe() : call STXON.strobe(); if ( !( status & CC2420_STATUS_TX_ACTIVE ) ) { status = call SNOP.strobe(); @@ -616,11 +760,11 @@ implementation { congestion = FALSE; } } - + m_state = congestion ? S_SAMPLE_CCA : S_SFD; call CSN.set(); } - + if ( congestion ) { totalCcaChecks = 0; releaseSpiResource(); @@ -702,5 +846,6 @@ implementation { call ChipSpiResource.attemptRelease(); signal Send.sendDone( m_msg, err ); } + }