dtls.h

Go to the documentation of this file.

/* dtls -- a very basic DTLS implementation
 *
 * Copyright (C) 2011--2013 Olaf Bergmann <bergmann@tzi.org>
 * Copyright (C) 2013 Hauke Mehrtens <hauke@hauke-m.de>
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef _DTLS_DTLS_H_
#define _DTLS_DTLS_H_

#include <stdint.h>

#include "t_list.h"
#include "state.h"
#include "peer.h"

#ifndef WITH_CONTIKI
#include "uthash.h"
#include "t_list.h"
#endif /* WITH_CONTIKI */

#include "alert.h"
#include "crypto.h"
#include "hmac.h"

#include "global.h"
#include "dtls_time.h"

#ifndef DTLSv12
#define DTLS_VERSION 0xfeff /* DTLS v1.1 */
#else
#define DTLS_VERSION 0xfefd /* DTLS v1.2 */
#endif

typedef enum dtls_credentials_type_t {
  DTLS_PSK_HINT, DTLS_PSK_IDENTITY, DTLS_PSK_KEY
} dtls_credentials_type_t;

typedef struct dtls_ecdsa_key_t {
  dtls_ecdh_curve curve;
  const unsigned char *priv_key;    
  const unsigned char *pub_key_x;   
  const unsigned char *pub_key_y;   
} dtls_ecdsa_key_t;

#define DTLS_COOKIE_SECRET_LENGTH 12

struct dtls_context_t;

typedef struct {
  int (*write)(struct dtls_context_t *ctx, 
           session_t *session, uint8 *buf, size_t len);

  int (*read)(struct dtls_context_t *ctx, 
           session_t *session, uint8 *buf, size_t len);

  int (*event)(struct dtls_context_t *ctx, session_t *session, 
        dtls_alert_level_t level, unsigned short code);

#ifdef DTLS_PSK

  int (*get_psk_info)(struct dtls_context_t *ctx,
              const session_t *session,
              dtls_credentials_type_t type,
              const unsigned char *desc, size_t desc_len,
              unsigned char *result, size_t result_length);

#endif /* DTLS_PSK */

#ifdef DTLS_ECC

  int (*get_ecdsa_key)(struct dtls_context_t *ctx, 
               const session_t *session,
               const dtls_ecdsa_key_t **result);

  int (*verify_ecdsa_key)(struct dtls_context_t *ctx, 
              const session_t *session,
              const unsigned char *other_pub_x,
              const unsigned char *other_pub_y,
              size_t key_size);
#endif /* DTLS_ECC */
} dtls_handler_t;

typedef struct dtls_context_t {
  unsigned char cookie_secret[DTLS_COOKIE_SECRET_LENGTH];
  clock_time_t cookie_secret_age; 
#ifndef WITH_CONTIKI
  dtls_peer_t *peers;       
#else /* WITH_CONTIKI */
  LIST_STRUCT(peers);

  struct etimer retransmit_timer; 
#endif /* WITH_CONTIKI */

  LIST_STRUCT(sendqueue);   
  void *app;            
  dtls_handler_t *h;        
  unsigned char readbuf[DTLS_MAX_BUF];
} dtls_context_t;

void dtls_init();

dtls_context_t *dtls_new_context(void *app_data);

void dtls_free_context(dtls_context_t *ctx);

#define dtls_set_app_data(CTX,DATA) ((CTX)->app = (DATA))
#define dtls_get_app_data(CTX) ((CTX)->app)

static inline void dtls_set_handler(dtls_context_t *ctx, dtls_handler_t *h) {
  ctx->h = h;
}

int dtls_connect(dtls_context_t *ctx, const session_t *dst);

int dtls_connect_peer(dtls_context_t *ctx, dtls_peer_t *peer);

int dtls_close(dtls_context_t *ctx, const session_t *remote);

int dtls_renegotiate(dtls_context_t *ctx, const session_t *dst);

int dtls_write(struct dtls_context_t *ctx, session_t *session, 
           uint8 *buf, size_t len);

void dtls_check_retransmit(dtls_context_t *context, clock_time_t *next);

#define DTLS_COOKIE_LENGTH 16

#define DTLS_CT_CHANGE_CIPHER_SPEC 20
#define DTLS_CT_ALERT              21
#define DTLS_CT_HANDSHAKE          22
#define DTLS_CT_APPLICATION_DATA   23

typedef struct __attribute__((__packed__)) {
  uint8 content_type;       
  uint16 version;       
  uint16 epoch;             
  uint48 sequence_number;       
  uint16 length;        
  /* fragment */
} dtls_record_header_t;

/* Handshake types */

#define DTLS_HT_HELLO_REQUEST        0
#define DTLS_HT_CLIENT_HELLO         1
#define DTLS_HT_SERVER_HELLO         2
#define DTLS_HT_HELLO_VERIFY_REQUEST 3
#define DTLS_HT_CERTIFICATE         11
#define DTLS_HT_SERVER_KEY_EXCHANGE 12
#define DTLS_HT_CERTIFICATE_REQUEST 13
#define DTLS_HT_SERVER_HELLO_DONE   14
#define DTLS_HT_CERTIFICATE_VERIFY  15
#define DTLS_HT_CLIENT_KEY_EXCHANGE 16
#define DTLS_HT_FINISHED            20

typedef struct __attribute__((__packed__)) {
  uint8 msg_type; 
  uint24 length;  
  uint16 message_seq;   
  uint24 fragment_offset;   
  uint24 fragment_length;   
  /* body */
} dtls_handshake_header_t;

typedef struct __attribute__((__packed__)) {
  uint16 version;     
  uint32 gmt_random;      
  unsigned char random[28]; 
  /* session id (up to 32 bytes) */
  /* cookie (up to 32 bytes) */
  /* cipher suite (2 to 2^16 -1 bytes) */
  /* compression method */
} dtls_client_hello_t;

typedef struct __attribute__((__packed__)) {
  uint16 version;       
  uint8 cookie_length;  
  uint8 cookie[];       
} dtls_hello_verify_t;  

#if 0

int dtls_record_read(dtls_state_t *state, uint8 *msg, int msglen);
#endif

int dtls_handle_message(dtls_context_t *ctx, session_t *session,
            uint8 *msg, int msglen);

dtls_peer_t *dtls_get_peer(const dtls_context_t *context,
               const session_t *session);


#endif /* _DTLS_DTLS_H_ */