int dtls_handle_read(struct dtls_context_t *ctx) { int fd; session_t session; #define MAX_READ_BUF 2000 static uint8 buf[MAX_READ_BUF]; int len; fd = *(int *)dtls_get_app_data(ctx); if (!fd) return -1; memset(&session, 0, sizeof(session_t)); session.size = sizeof(session.addr); len = recvfrom(fd, buf, MAX_READ_BUF, 0, &session.addr.sa, &session.size); if (len < 0) { perror("recvfrom"); return -1; } else { unsigned char addrbuf[72]; dsrv_print_addr(&session, addrbuf, sizeof(addrbuf)); dsrv_log(LOG_DEBUG, "got %d bytes from %s\n", len, (char *)addrbuf); dump((unsigned char *)&session, sizeof(session_t)); PRINTF("\n"); dump(buf, len); PRINTF("\n"); } return dtls_handle_message(ctx, &session, buf, len); }
static eDtlsRet_t CAAdapterNetDtlsDecryptInternal(const stCADtlsAddrInfo_t *srcSession, uint8_t *buf, uint32_t bufLen) { OIC_LOG(DEBUG, NET_DTLS_TAG, "IN"); VERIFY_NON_NULL_RET(srcSession, NET_DTLS_TAG, "Param srcSession is NULL", DTLS_FAIL); VERIFY_NON_NULL_RET(buf, NET_DTLS_TAG, "Param buf is NULL", DTLS_FAIL); if (0 == bufLen) { OIC_LOG(ERROR, NET_DTLS_TAG, "Given Packet length is equal to zero."); return DTLS_FAIL; } eDtlsRet_t ret = DTLS_FAIL; if (dtls_handle_message(g_caDtlsContext->dtlsContext, (session_t *)srcSession, buf, bufLen) == 0) { OIC_LOG(DEBUG, NET_DTLS_TAG, "dtls_handle_message success"); ret = DTLS_OK; } OIC_LOG(DEBUG, NET_DTLS_TAG, "OUT"); return ret; }
static int dtls_handle_read(struct dtls_context_t *ctx) { int *fd; session_t session; static uint8 buf[DTLS_MAX_BUF]; int len; fd = dtls_get_app_data(ctx); assert(fd); memset(&session, 0, sizeof(session_t)); session.size = sizeof(session.addr); len = recvfrom(*fd, buf, sizeof(buf), MSG_TRUNC, &session.addr.sa, &session.size); if (len < 0) { perror("recvfrom"); return -1; } else { dtls_debug("got %d bytes from port %d\n", len, ntohs(session.addr.sin6.sin6_port)); if (sizeof(buf) < len) { dtls_warn("packet was truncated (%d bytes lost)\n", len - sizeof(buf)); } } return dtls_handle_message(ctx, &session, buf, len); }
int get_psk_key(struct dtls_context_t *ctx, const session_t *session, const unsigned char *id, size_t id_len, const dtls_psk_key_t **result) { static const dtls_psk_key_t psk = { .id = (unsigned char *)"Client_identity", .id_length = 15, .key = (unsigned char *)"secretPSK", .key_length = 9 }; *result = &psk; return 0; } PROCESS(udp_server_process, "UDP server process"); AUTOSTART_PROCESSES(&udp_server_process); /*---------------------------------------------------------------------------*/ static void dtls_handle_read(dtls_context_t *ctx) { session_t session; if(uip_newdata()) { uip_ipaddr_copy(&session.addr, &UIP_IP_BUF->srcipaddr); session.port = UIP_UDP_BUF->srcport; session.size = sizeof(session.addr) + sizeof(session.port); dtls_handle_message(ctx, &session, uip_appdata, uip_datalen()); } }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udp_server_process, ev, data) { PROCESS_BEGIN(); print_local_addresses(); dtls_init(); init_dtls(); if (!dtls_context) { dsrv_log(LOG_EMERG, "cannot create context\n"); PROCESS_EXIT(); } while(1) { PROCESS_WAIT_EVENT(); if(ev == tcpip_event) { dtls_handle_read(dtls_context); } #if 0 if (bytes_read > 0) { /* dtls_handle_message(dtls_context, &the_session, readbuf, bytes_read); */ read_from_peer(dtls_context, &the_session, readbuf, bytes_read); } dtls_handle_message(ctx, &session, uip_appdata, bytes_read); #endif } PROCESS_END(); }
int get_key(struct dtls_context_t *ctx, const session_t *session, const unsigned char *id, size_t id_len, const dtls_key_t **result) { static const dtls_key_t psk = { .type = DTLS_KEY_PSK, .key.psk.id = (unsigned char *)"Client_identity", .key.psk.id_length = 15, .key.psk.key = (unsigned char *)"secretPSK", .key.psk.key_length = 9 }; *result = &psk; return 0; } PROCESS(udp_server_process, "UDP server process"); AUTOSTART_PROCESSES(&udp_server_process); /*---------------------------------------------------------------------------*/ static void dtls_handle_read(dtls_context_t *ctx) { static session_t session; if(uip_newdata()) { uip_ipaddr_copy(&session.addr, &UIP_IP_BUF->srcipaddr); session.port = UIP_UDP_BUF->srcport; session.size = sizeof(session.addr) + sizeof(session.port); ((char *)uip_appdata)[uip_datalen()] = 0; PRINTF("Client received message from "); PRINT6ADDR(&session.addr); PRINTF(":%d\n", uip_ntohs(session.port)); dtls_handle_message(ctx, &session, uip_appdata, uip_datalen()); } } /*---------------------------------------------------------------------------*/ static void print_local_addresses(void) { int i; uint8_t state; PRINTF("Client IPv6 addresses: "); for(i = 0; i < UIP_DS6_ADDR_NB; i++) { state = uip_ds6_if.addr_list[i].state; if(uip_ds6_if.addr_list[i].isused && (state == ADDR_TENTATIVE || state == ADDR_PREFERRED)) { PRINT6ADDR(&uip_ds6_if.addr_list[i].ipaddr); PRINTF("\n"); } } }
/*---------------------------------------------------------------------------*/ static void dtls_handle_read(dtls_context_t *ctx) { session_t session; if(uip_newdata()) { dtls_session_init(&session); uip_ipaddr_copy(&session.addr, &UIP_IP_BUF->srcipaddr); session.port = UIP_UDP_BUF->srcport; dtls_handle_message(ctx, &session, uip_appdata, uip_datalen()); } }
int connection_handle_packet(dtls_connection_t *connP, uint8_t * buffer, size_t numBytes){ if (connP->dtlsSession != NULL) { // Let liblwm2m respond to the query depending on the context int result = dtls_handle_message(connP->dtlsContext, connP->dtlsSession, buffer, numBytes); if (result !=0) { printf("error dtls handling message %d\n",result); } return result; } else { // no security, just give the plaintext buffer to liblwm2m lwm2m_handle_packet(connP->lwm2mH, buffer, numBytes, (void*)connP); return 0; } }
/*---------------------------------------------------------------------------*/ static void dtls_handle_read(dtls_context_t *ctx) { static session_t session; if(uip_newdata()) { uip_ipaddr_copy(&session.addr, &UIP_IP_BUF->srcipaddr); session.port = UIP_UDP_BUF->srcport; session.size = sizeof(session.addr) + sizeof(session.port); ((char *)uip_appdata)[uip_datalen()] = 0; PRINTF("Client received message from "); PRINT6ADDR(&session.addr); PRINTF(":%d\n", uip_ntohs(session.port)); dtls_handle_message(ctx, &session, uip_appdata, uip_datalen()); } }
/*---------------------------------------------------------------------------*/ int coap_context_wait_data(coap_context_t *coap_ctx, int32_t ticks) { struct net_buf *buf; buf = net_receive(coap_ctx->net_ctx, ticks); if (buf) { session_t session; int ret; uip_ipaddr_copy(&session.addr.ipaddr, &UIP_IP_BUF(buf)->srcipaddr); session.addr.port = UIP_UDP_BUF(buf)->srcport; session.size = sizeof(session.addr); session.ifindex = 1; PRINTF("coap-context: got dtls message from "); PRINT6ADDR(&session.addr.ipaddr); PRINTF(":%d %u bytes\n", uip_ntohs(session.addr.port), uip_appdatalen(buf)); PRINTF("Received appdata %p appdatalen %d\n", ip_buf_appdata(buf), ip_buf_appdatalen(buf)); coap_ctx->buf = buf; ret = dtls_handle_message(coap_ctx->dtls_context, &session, ip_buf_appdata(buf), ip_buf_appdatalen(buf)); /* We always release the buffer here as this buffer is never sent * to network anyway. */ if (coap_ctx->buf) { ip_buf_unref(coap_ctx->buf); coap_ctx->buf = NULL; } return ret; } return 0; }
int main() { int result; lwm2m_object_t * objArray[4]; printf("Start\n"); ethSetup(); printf("Initializing tinydtls\n"); // fake loading of PSK.. psk_id_length = strlen(PSK_DEFAULT_IDENTITY); psk_key_length = strlen(PSK_DEFAULT_KEY); memcpy(psk_id, PSK_DEFAULT_IDENTITY, psk_id_length); memcpy(psk_key, PSK_DEFAULT_KEY, psk_key_length); printf("Init\n"); dtls_init(); printf("New context\n"); dtls_context = dtls_new_context(&lwm2mH); if (dtls_context == NULL) { printf("error creating the dtls context\n"); } printf("Setting handlers\n"); dtls_set_handler(dtls_context, &cb); if (!dtls_context) { printf("can't create dtls_context\n"); exit(-1); } printf("Initialazing Wakaama\n"); // create objects objArray[0] = get_security_object(123, "coaps://5.39.83.206:5684", false); securityObjP = objArray[0]; objArray[1] = get_server_object(123, "U", 20, false); serverObject = objArray[1]; objArray[2] = get_object_device(); objArray[3] = get_object_firmware(); /* * The liblwm2m library is now initialized with the functions that will be in * charge of communication */ lwm2mH = lwm2m_init(prv_connect_server, prv_buffer_send, NULL); if (NULL == lwm2mH) { fprintf(stderr, "lwm2m_init() failed\r\n"); return -1; } // configure the liblwm2m lib result = lwm2m_configure(lwm2mH, "julien", NULL, 4, objArray); if (result != 0) { printf("lwm2m_configure() failed: 0x%X\n", result); return -1; } // start result = lwm2m_start(lwm2mH); if (result != 0) { printf("lwm2m_start() failed: 0x%X\n", result); return -1; } // main loop while (true) { char buffer[1024]; Endpoint server; printf("loop...\n"); struct timeval timeout; timeout.tv_sec = 10; timeout.tv_usec = 0; result = lwm2m_step(lwm2mH, &timeout); if (result != 0) { printf("lwm2m_step error %d\n", result); } int n = udp.receiveFrom(server, buffer, sizeof(buffer)); printf("Received packet from: %s of size %d\n", server.get_address(), n); if (n>0) { // TODO: find connection connection_t * connP = connList; while(connP != NULL) { if (strcmp(connP->host, server.get_address()) == 0) { printf("found connection\n"); // is it a secure connection? if (connP->dtlsSession != NULL) { printf("dtls session\n"); result = dtls_handle_message(dtls_context, connP->dtlsSession, buffer, n); printf("dtls handle message %d\n",result); } else { printf("nosec session\n"); lwm2m_handle_packet(lwm2mH, (uint8_t*)buffer, n, (void*)connP); } break; } } if (connP == NULL) printf("no connection\n"); } } }
static int get_key(struct dtls_context_t *ctx, const session_t *session, const unsigned char *id, size_t id_len, const dtls_key_t **result) { static const dtls_key_t psk = { .type = DTLS_KEY_PSK, .key.psk.id = (unsigned char *)DTLS_IDENTITY_HINT, .key.psk.id_length = DTLS_IDENTITY_HINT_LENGTH, .key.psk.key = (unsigned char *)DTLS_PSK_KEY, .key.psk.key_length = DTLS_PSK_KEY_LENGTH }; *result = &psk; return 0; } #else static int get_psk_key(struct dtls_context_t *ctx, const session_t *session, const unsigned char *id, size_t id_len, const dtls_psk_key_t **result) { static const dtls_psk_key_t psk = { .id = (unsigned char *)DTLS_IDENTITY_HINT, .id_length = DTLS_IDENTITY_HINT_LENGTH, .key = (unsigned char *)DTLS_PSK_KEY, .key_length = DTLS_PSK_KEY_LENGTH }; *result = &psk; return 0; } #endif /*-----------------------------------------------------------------------------------*/ void coap_init_communication_layer(uint16_t port) { static dtls_handler_t cb = { .write = send_to_peer, .read = read_from_peer, .event = NULL, #if DTLS_VERSION_0_4_0 .get_key = get_key #else .get_psk_key = get_psk_key, .get_ecdsa_key = NULL, .verify_ecdsa_key = NULL #endif }; server_conn = udp_new(NULL, 0, NULL); udp_bind(server_conn, port); dtls_set_log_level(LOG_DEBUG); dtls_context = dtls_new_context(server_conn); if (dtls_context) dtls_set_handler(dtls_context, &cb); /* new connection with remote host */ printf("COAP-DTLS listening on port %u\n", uip_ntohs(server_conn->lport)); } /*-----------------------------------------------------------------------------------*/ static int send_to_peer(struct dtls_context_t *ctx, session_t *session, uint8 *data, size_t len) { struct uip_udp_conn *conn = (struct uip_udp_conn *)dtls_get_app_data(ctx); uip_ipaddr_copy(&conn->ripaddr, &session->addr); conn->rport = session->port; uip_udp_packet_send(conn, data, len); /* Restore server connection to allow data from any node */ memset(&conn->ripaddr, 0, sizeof(conn->ripaddr)); memset(&conn->rport, 0, sizeof(conn->rport)); return len; } /*-----------------------------------------------------------------------------------*/ void coap_send_message(context_t * ctx, uip_ipaddr_t *addr, uint16_t port, uint8_t *data, uint16_t length) { session_t session; dtls_session_init(&session); uip_ipaddr_copy(&session.addr, addr); session.port = port; dtls_write(ctx, &session, data, length); } /*-----------------------------------------------------------------------------------*/ static int read_from_peer(struct dtls_context_t *ctx, session_t *session, uint8 *data, size_t len) { uip_len = len; memmove(uip_appdata, data, len); coap_receive(ctx); return 0; } /*-----------------------------------------------------------------------------------*/ void coap_handle_receive() { session_t session; if(uip_newdata()) { dtls_session_init(&session); uip_ipaddr_copy(&session.addr, &UIP_IP_BUF->srcipaddr); session.port = UIP_UDP_BUF->srcport; dtls_handle_message(dtls_context, &session, uip_appdata, uip_datalen()); } }