/** * Calculates number of hashes from stdin or from files * * Expected input ./gethash [-md5] [-c16] [-c32] [-xor] [-hex] [-f file] */ int main( int argc, char *argv[] ) { unsigned char hash = 0; FILE *file = stdin; parse_args(argc, argv, &hash, &file); unsigned int length; unsigned char *data = read_file(file, &length); printf("Length: %i bytes\n", length); if(hash & XOR){ printf("XOR: "); if(hash & HEX) printf("0x%02x\n", xor_compute(data, length)); else printf("%u\n", xor_compute(data, length)); } if(hash & C16){ printf("CRC-16: "); if(hash & HEX) printf("0x%04x\n", crc16_compute(data, length)); else printf("%u\n", crc16_compute(data, length)); } if(hash & C32){ printf("CRC-32: "); if(hash & HEX) printf("0x%08x\n", crc32_compute(data, length)); else printf("%u\n", crc32_compute(data, length)); } if(hash & MD5){ unsigned char result[16]; md5_compute(data, length, result); printf("MD5: "); for (int i = 0; i < 16; i++){ printf("%02x", result[i]); } printf("\n"); } free(data); fclose(file); return 0; }
bool bootloader_app_is_valid(uint32_t app_addr) { const bootloader_settings_t * p_bootloader_settings; // There exists an application in CODE region 1. if (*((uint32_t *)app_addr) == EMPTY_FLASH_MASK) { return false; } bool success = false; bootloader_util_settings_get(&p_bootloader_settings); // The application in CODE region 1 is flagged as valid during update. if (p_bootloader_settings->bank_0 == BANK_VALID_APP) { uint16_t image_crc = 0; // A stored crc value of 0 indicates that CRC checking is not used. if (p_bootloader_settings->bank_0_crc != 0) { image_crc = crc16_compute((uint8_t *)DFU_BANK_0_REGION_START, p_bootloader_settings->bank_0_size, NULL); } success = (image_crc == p_bootloader_settings->bank_0_crc); } return success; }
uint32_t dfu_init_postvalidate(uint8_t * p_image, uint32_t image_len) { #if NEED_CRC_CHECK /* disabled for now */ uint16_t image_crc; uint16_t received_crc; // In order to support hashing (and signing) then the (decrypted) hash should be fetched and // the corresponding hash should be calculated over the image at this location. // If hashing (or signing) is added to the system then the CRC validation should be removed. // calculate CRC from active block. image_crc = crc16_compute(p_image, image_len, NULL); // Decode the received CRC from extended data. received_crc = uint16_decode((uint8_t *)&m_extended_packet[0]); // Compare the received and calculated CRC. if (image_crc != received_crc) { return NRF_ERROR_INVALID_DATA; } #endif /* NEED_CRC_CHECK */ return NRF_SUCCESS; }
void BLE_init() { ble_stack_init(); gap_params_init(); services_init(); sec_params_init(); ble_gap_addr_t MAC; sd_ble_gap_address_get(&MAC); debug_log("MAC address: %.2X:%.2X:%.2X:%.2X:%.2X:%.2X", MAC.addr[5],MAC.addr[4],MAC.addr[3], MAC.addr[2],MAC.addr[1],MAC.addr[0]); defaultID = crc16_compute(MAC.addr,6,NULL); // compute default badge ID from MAC address debug_log("-->default ID: 0x%hX\r\n",defaultID); badgeAssignment.ID = defaultID; badgeAssignment.group = NO_GROUP; // Copy MAC address into custom advertising data struct. for(int i = 0; i <= 5; i++) { customAdvData.MAC[i] = MAC.addr[i]; } //advertising_init(); //uint32_t err_code = ble_advertising_start(BLE_ADV_MODE_FAST); //BLE_ERROR_CHECK(err_code); }
bool bridge_create_tx_packet(uint8_t command, uint8_t len, uint8_t * data) { bridge.tx.packet.command = command; bridge.tx.packet.payload_length = len; memcpy((uint8_t *)bridge.tx.packet.payload, data, len); bridge.tx.packet.crc16 = crc16_compute((uint8_t *)&bridge.tx.packet, bridge.tx.packet.payload_length + BRIDGE_HEDER_SIZE, NULL); return true; }
static uint32_t s_hal_crc16_sw_compute(hal_crc_info_t *info, const void *data, uint32_t size) { uint8_t tailsize = size%4; uint32_t size4 = size-tailsize; info->initialvalue = crc16_compute(info->cfg.crctblram, info->initialvalue, (uint8_t*)data, size4); if(0 != (tailsize)) { uint8_t tail[4]; memset(tail, 0, 4); memcpy(tail, ((uint8_t*)data) + size-tailsize, tailsize); info->initialvalue = crc16_compute(info->cfg.crctblram, info->initialvalue, tail, 4); } return(info->initialvalue); }
uint32_t dfu_image_validate() { uint32_t err_code; uint16_t received_crc; switch (m_dfu_state) { case DFU_STATE_RX_DATA_PKT: m_dfu_state = DFU_STATE_VALIDATE; // Check if the application image write has finished. if (m_app_data_received != m_image_size) { // Image not yet fully transfered by the peer or the peer has attempted to write // too much data. Hence the validation should fail. err_code = NRF_ERROR_INVALID_STATE; } else { // Valid peer activity detected. Hence restart the DFU timer. err_code = dfu_timer_restart(); if (err_code == NRF_SUCCESS) { // calculate CRC from DFU_BANK_1_REGION_START to mp_app_write_address. m_image_crc = crc16_compute((uint8_t*)DFU_BANK_1_REGION_START, m_image_size, NULL); received_crc = uint16_decode((uint8_t*)&m_init_packet[0]); if ((m_init_packet_length != 0) && (m_image_crc != received_crc)) { return NRF_ERROR_INVALID_DATA; } m_dfu_state = DFU_STATE_WAIT_4_ACTIVATE; } } break; default: err_code = NRF_ERROR_INVALID_STATE; break; } return err_code; }
/**@brief Function for validating a received packet. * * @param[in] p_buffer Pointer to the packet data. * @param[in] length Length of packet data in bytes. * * @return true if received packet is valid, false in other case. */ static bool is_rx_pkt_valid(const uint8_t * p_buffer, uint32_t length) { // Executed packet filtering algorithm order: // - verify packet overall length // - verify data integrity bit set // - verify reliable packet bit set // - verify supported packet type // - verify header checksum // - verify payload length field // - verify CRC if (length <= PKT_HDR_SIZE) { return false; } if (!(p_buffer[0] & DATA_INTEGRITY_MASK)) { return false; } if (!(p_buffer[0] & RELIABLE_PKT_MASK)) { return false; } if ((p_buffer[1] & 0x0Fu) != PKT_TYPE_VENDOR_SPECIFIC) { return false; } const uint32_t expected_checksum = ((p_buffer[0] + p_buffer[1] + p_buffer[2] + p_buffer[3])) & 0xFFu; if (expected_checksum != 0) { return false; } const uint16_t crc_calculated = crc16_compute(p_buffer, (length - PKT_CRC_SIZE), NULL); const uint16_t crc_received = uint16_decode(&p_buffer[length - PKT_CRC_SIZE]); if (crc_calculated != crc_received) { return false; } return true; }
bool bootloader_app_is_valid(uint32_t app_addr) { // There exists an application in CODE region 1. if (DFU_BANK_0_REGION_START == EMPTY_FLASH_MASK) { return false; } #if 0 const bootloader_settings_t * p_bootloader_settings; bool success = false; switch (app_addr) { case DFU_BANK_0_REGION_START: bootloader_util_settings_get(&p_bootloader_settings); // The application in CODE region 1 is flagged as valid during update. if (p_bootloader_settings->bank_0 == BANK_VALID_APP) { uint16_t image_crc = 0; // A stored crc value of 0 indicates that CRC checking is not used. if (p_bootloader_settings->bank_0_crc != 0) { image_crc = crc16_compute((uint8_t*)DFU_BANK_0_REGION_START, p_bootloader_settings->bank_0_size, NULL); } success = (image_crc == p_bootloader_settings->bank_0_crc); } break; case DFU_BANK_1_REGION_START: default: // No implementation needed. break; } return success; #else return true; #endif }
static void send_single_packet() { uint16_t crc; uint32_t data_offset; // Include the length spim_com_tx_transaction.fields.len_lsb = (uint8_t)m_spim_com_tx_packet_length; spim_com_tx_transaction.fields.len_msb = (uint8_t)(m_spim_com_tx_packet_length >> 8); data_offset = (uint32_t)m_spim_com_tx_packet_fragment_num * SPI_COM_PCK_DATA_SIZE; if((m_spim_com_tx_packet_length - data_offset) > SPI_COM_PCK_DATA_SIZE) { memcpy(spim_com_tx_transaction.fields.data, m_spim_com_tx_packet + data_offset, SPI_COM_PCK_DATA_SIZE); } else { memcpy(spim_com_tx_transaction.fields.data, m_spim_com_tx_packet + data_offset, m_spim_com_tx_packet_length - data_offset); memset(spim_com_tx_transaction.fields.data + (m_spim_com_tx_packet_length - data_offset), 0, SPI_COM_PCK_DATA_SIZE - (m_spim_com_tx_packet_length - data_offset)); } // Calculate and include the CRC spim_com_tx_transaction.fields.crc_lsb = 0; spim_com_tx_transaction.fields.crc_msb = 0; crc = crc16_compute(spim_com_tx_transaction.data, SPI_COM_MAX_TRANSACTION_SIZE, 0); spim_com_tx_transaction.fields.crc_lsb = (uint8_t)crc; spim_com_tx_transaction.fields.crc_msb = (uint8_t)(crc >> 8); // Assert the RDY signal nrf_gpio_pin_clear(m_spim_com_pin_reqn); // Wait for the REQ line to be asserted by the slave while(nrf_gpio_pin_read(m_spim_com_pin_rdyn) != 0); // De-assert the RDY signal nrf_gpio_pin_set(m_spim_com_pin_reqn); m_spim_com_tx_packet_fragment_num++; spi_master_send_recv(SPI_MASTER_0, spim_com_tx_transaction.data, SPI_COM_MAX_TRANSACTION_SIZE, spim_com_rx_transaction.data, SPI_COM_MAX_TRANSACTION_SIZE); }
uint32_t dfu_image_validate() { uint32_t err_code; uint16_t received_crc; switch (m_dfu_state) { case DFU_STATE_RX_DATA_PKT: m_dfu_state = DFU_STATE_VALIDATE; // Check if the application image write has finished. if (m_received_data != m_image_size) { // Image not yet fully transferred by the peer. err_code = NRF_ERROR_INVALID_STATE; } else { // Calculate CRC from DFU_BANK_0_REGION_START to mp_app_write_address. m_image_crc = crc16_compute((uint8_t*)DFU_BANK_0_REGION_START, m_image_size, NULL); received_crc = uint16_decode((uint8_t*)&m_init_packet[0]); if ((m_init_packet_length != 0) && (m_image_crc != received_crc)) { return NRF_ERROR_INVALID_DATA; } m_dfu_state = DFU_STATE_WAIT_4_ACTIVATE; err_code = NRF_SUCCESS; } break; default: err_code = NRF_ERROR_INVALID_STATE; break; } return err_code; }
bool bootloader_app_is_valid(uint32_t app_addr) { const bootloader_settings_t * p_bootloader_settings; // There exists an application in CODE region 1. if (*((uint32_t *)app_addr) == EMPTY_FLASH_MASK) { return false; } bool success = false; bootloader_util_settings_get(&p_bootloader_settings); #if DEBUG_BOOTLOADER_EN //simple_uart_init(); DbgPrintf_str("\r\ncheck bootloader_app_is_valid,bank_0:"); DbgPrintf_hex(p_bootloader_settings->bank_0); DbgPrintf_str("crc:"); DbgPrintf_hex(p_bootloader_settings->bank_0_crc); DbgPrintf_str("size:"); DbgPrintf_hex(p_bootloader_settings->bank_0_size); #endif // The application in CODE region 1 is flagged as valid during update. if (p_bootloader_settings->bank_0 == BANK_VALID_APP) { uint16_t image_crc = 0; // A stored crc value of 0 indicates that CRC checking is not used. if (p_bootloader_settings->bank_0_crc != 0) { image_crc = crc16_compute((uint8_t *)DFU_BANK_0_REGION_START, p_bootloader_settings->bank_0_size, NULL); } success = (image_crc == p_bootloader_settings->bank_0_crc); } return success; }
/**@brief Function for handling the application packet write request in tx-idle state. */ static uint32_t pkt_write_handle(void) { uint32_t err_code; // Set packet header fields. mp_tx_buffer -= PKT_HDR_SIZE; mp_tx_buffer[0] = tx_packet_byte_zero_construct(); const uint16_t type_and_length_fields = ((m_tx_buffer_length << 4u) | PKT_TYPE_VENDOR_SPECIFIC); // @note: no use case for uint16_encode(...) return value. UNUSED_VARIABLE(uint16_encode(type_and_length_fields, &(mp_tx_buffer[1]))); mp_tx_buffer[3] = header_checksum_calculate(mp_tx_buffer); // Calculate, append CRC to the packet and write it. const uint16_t crc = crc16_compute(mp_tx_buffer, (PKT_HDR_SIZE + m_tx_buffer_length), NULL); // @note: no use case for uint16_encode(...) return value. UNUSED_VARIABLE(uint16_encode(crc, &(mp_tx_buffer[PKT_HDR_SIZE + m_tx_buffer_length]))); err_code = hci_slip_write(mp_tx_buffer, (m_tx_buffer_length + PKT_HDR_SIZE + PKT_CRC_SIZE)); switch (err_code) { case NRF_SUCCESS: tx_sm_state_change(TX_STATE_ACTIVE); break; case NRF_ERROR_NO_MEM: tx_sm_state_change(TX_STATE_PENDING); err_code = NRF_SUCCESS; break; default: // No implementation needed. break; } return err_code; }
buf32_t* malloc_HciPacket(buf32_t* pFrame) { uint16_t crc; buf32_t *pEncoded_STATIC; buf32_t *pSlipPkt; buf32_t *pTemp; static uint8_t _temp_buffer[4 + 4+512 + 2]; static buf32_t _temp; _temp.buffer = _temp_buffer; _temp.capacity = sizeof(_temp_buffer ); //4 + 4+512 + 2; pTemp = &_temp; //---------------------- // Add HCI Header //---------------------- HciPacket.sequence_number = (HciPacket.sequence_number+1) % 8; buf32_zero(pTemp); buf32_join(pTemp, buf32_parts_to_four_bytes( HciPacket.sequence_number, DATA_INTEGRITY_CHECK_PRESENT, RELIABLE_PACKET, HCI_PACKET_TYPE, pFrame->length) ); //buf32_print("## 0", pTemp); //------------------- // Add payload //------------------- buf32_join(pTemp, pFrame); //// Add escape caracters //buf32_print("## 1", pTemp); //--------------- // Add CRC //--------------- crc = 0xFFFF; crc = crc16_compute(pTemp->buffer, pTemp->length, &crc); pTemp->buffer[pTemp->length] = (uint8_t)(crc & 0xFF); pTemp->length++; //chr(crc & 0xFF) pTemp->buffer[pTemp->length] = (uint8_t)((crc & 0xFF00) >> 8); pTemp->length++; //chr((crc & 0xFF00) >> 8) //buf32_print("## 2", pTemp); //------------------------ // Do SLIP encoding //------------------------ pEncoded_STATIC = buf32_slip_encode_packet(pTemp); //buf32_print("## pEncoded_STATIC", pEncoded_STATIC); //--------------------------------- // Add 0xC0 to start and end //--------------------------------- pSlipPkt = buf32_Create(1 + pEncoded_STATIC->length + 1); //buf32_zero(pSlipPkt); pSlipPkt->length = 0; pSlipPkt->buffer[pSlipPkt->length] = 0xC0; //self->buffer = chr(0xc0) pSlipPkt->length++; //buf32_print("## pSlipPkt", pSlipPkt); buf32_join(pSlipPkt, pEncoded_STATIC); //self->buffer += self.temp_data //buf32_print("## pSlipPkt", pSlipPkt); pSlipPkt->buffer[pSlipPkt->length] = 0xC0; //self->buffer += chr(0xc0) pSlipPkt->length++; //buf32_print("## pSlipPkt", pSlipPkt); return(pSlipPkt); }
//#include "memory.h" //#include "stdlib.h" //malloc int32_t make_HciPacket_cb16(uint8_t* pDin, uint16_t lenDin, cb16_t* cbOut, uint16_t* plenDout ) { uint16_t totalLength; uint16_t crc; uint16_t i; uint8_t* pdata4; uint8_t len12; uint8_t b0; uint8_t b1; uint8_t crc01[2]; if( cbOut != 0) W_HciPacket.sequence_number = (W_HciPacket.sequence_number+1) % 8; pdata4 = bytePtr_parts_to_four_bytes( W_HciPacket.sequence_number, DATA_INTEGRITY_CHECK_PRESENT, RELIABLE_PACKET, HCI_PACKET_TYPE, lenDin ); crc = 0xFFFF; crc = crc16_compute( pdata4, 4 , &crc); crc = crc16_compute( pDin , lenDin, &crc); crc01[0] = (uint8_t)( crc & 0xFF); crc01[1] = (uint8_t)((crc & 0xFF00) >> 8); totalLength = 0; if( cbOut != 0) cb16_push( cbOut, 0xC0 ); totalLength += 1; for( i=0 ; i<4; i++ ) { len12 = slip_encode_byte( pdata4[i], &b0, &b1 ); if( cbOut != 0) cb16_push( cbOut, b0 ); totalLength += 1; if(len12 == 2) { if( cbOut != 0) cb16_push( cbOut, b0 ); totalLength += 1; } } for( i=0 ; i<lenDin; i++ ) { len12 = slip_encode_byte( pDin[i], &b0, &b1 ); if( cbOut != 0) cb16_push( cbOut, b0 ); totalLength += 1; if(len12 == 2) { if( cbOut != 0) cb16_push( cbOut, b0 ); totalLength += 1; } } for( i=0 ; i<2; i++ ) { len12 = slip_encode_byte( crc01[i], &b0, &b1 ); if( cbOut != 0) cb16_push( cbOut, b0 ); totalLength += 1; if(len12 == 2) { if( cbOut != 0) cb16_push( cbOut, b0 ); totalLength += 1; } } if( cbOut != 0) cb16_push( cbOut, b0 ); totalLength += 1; *plenDout = totalLength; return(totalLength); }
void bridge_uart_event_handler(app_uart_evt_t *p_app_uart_event) { uint8_t uart_rx; // Check if UART data has been received. if(p_app_uart_event->evt_type == APP_UART_DATA_READY) { // Getting a byte from the UART. if(app_uart_get(&uart_rx) != NRF_SUCCESS) { return; } switch(bridge.rx.state) { static uint8_t payload_count; static uint16_t crc16; // Start of next packet detected. case BRIDGE_STATE_COMMAND_WAIT: { bridge_check_command_rcv((bridge_commands_t)uart_rx); break; } // Length byte received. case BRIDGE_STATE_LENGTH_WAIT: { bridge.rx.packet.payload_length = uart_rx; payload_count = 0; bridge.rx.state = BRIDGE_STATE_PAYLOAD_WAIT; break; } // Reading payload. case BRIDGE_STATE_PAYLOAD_WAIT: { bridge.rx.packet.payload[payload_count] = uart_rx; payload_count++; if(payload_count >= bridge.rx.packet.payload_length) { bridge.rx.state = BRIDGE_STATE_CRC16_LOW_WAIT; } break; } // Get first crc16 byte. case BRIDGE_STATE_CRC16_LOW_WAIT: { crc16 = uart_rx; bridge.rx.state = BRIDGE_STATE_CRC16_HIGH_WAIT; break; } // Get second crc16 byte. case BRIDGE_STATE_CRC16_HIGH_WAIT: { // If device is not connected of notification/indication is not enabled send BRIDGE_COMM_NCONN byte. if( !ble_is_device_connected() || ( ((characteristic_sensorData_up_info.state & BLE_CHARACTERISTIC_IS_NOTIFYING) == 0)&& ((characteristic_sensorData_up_info.state & BLE_CHARACTERISTIC_IS_INDICATING) == 0) ) ) { app_uart_put(BRIDGE_COMM_NCONN); } else { crc16 += ((uint16_t)uart_rx << 8); crc16_1 = crc16_compute((uint8_t *)&bridge.rx.packet, bridge.rx.packet.payload_length + BRIDGE_HEDER_SIZE, NULL); // Compare received crc16 with calculated value. if( (crc16 == crc16_compute((uint8_t *)&bridge.rx.packet, bridge.rx.packet.payload_length + BRIDGE_HEDER_SIZE, NULL)) && (bridge.rx.packet.payload_length <= BRIDGE_PAYLOAD_SIZE) ) { // Send data over ble and ACK over uart. memset((uint8_t*)&sensor_bridge.data_up, 0, sizeof(sensor_bridge.data_up)); sensor_bridge.data_up.payload_length = bridge.rx.packet.payload_length; memcpy((uint8_t*)&sensor_bridge.data_up.payload, (uint8_t*)&bridge.rx.packet.payload, bridge.rx.packet.payload_length); ble_update_characteristic_value(&characteristic_sensorData_up_info, (uint8_t *)(&sensor_bridge.data_up), sizeof(sensor_bridge.data_up)); app_uart_put(BRIDGE_COMM_ACK); } // Send BRIDGE_COMM_NACK byte. else { app_uart_put(BRIDGE_COMM_NACK); } } // Go to BRIDGE_STATE_COMMAND_WAIT state (wait to next packet). bridge.rx.state = BRIDGE_STATE_COMMAND_WAIT; break; } // ACK wait state. case BRIDGE_STATE_ACK_WAIT: { // If ACK received reset resend counter and go to BRIDGE_STATE_COMMAND_WAIT state. if(uart_rx == BRIDGE_COMM_ACK) { bridge.tx.resend_counter = 0; bridge.rx.state = BRIDGE_STATE_COMMAND_WAIT; } // If NACK received? else if(uart_rx == BRIDGE_COMM_NACK) { // If there is need to do more resends? if(bridge.tx.resend_counter < NUMBER_OF_RESEND) { // Resend last packet, and increment resend_counter. bridge_send_packet(); bridge.tx.resend_counter++; } else { // Reset resend counter and go to BRIDGE_STATE_COMMAND_WAIT state. bridge.tx.resend_counter = 0; bridge.rx.state = BRIDGE_STATE_COMMAND_WAIT; } } // Can be considered to have received the beginning of a new package. else { bridge_check_command_rcv((bridge_commands_t)uart_rx); } break; } } } }