BasicSSL.c

Go to the documentation of this file.

/* This source file is part of the ATMEL AVR32-SoftwareFramework-1.3.0-AT32UC3A Release */

/*This file has been prepared for Doxygen automatic documentation generation.*/
/* Copyright (c) 2009 Atmel Corporation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. The name of Atmel may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * 4. This software may only be redistributed and used in connection with an Atmel
 * AVR product.
 *
 * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
 * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
 *
 */
/*
 Implements a simplistic WEB server.  Every time a connection is made and
 data is received a dynamic page that shows the current FreeRTOS.org kernel
 statistics is generated and returned.  The connection is then closed.

 This file was adapted from a FreeRTOS lwIP slip demo supplied by a third
 party.
 */

#if (SSL_USED == 1)

/* Standard includes. */
#include <stdio.h>
#include <string.h>

#include "print_funcs.h"
#include "gpio.h"

#include "conf_eth.h"

/* Scheduler includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "partest.h"
#include "serial.h"

/* Demo includes. */
/* Demo app includes. */
#include "portmacro.h"

#include "BasicSSL.h"

/* lwIP includes. */
#include "lwip/api.h"
#include "lwip/tcpip.h"
#include "lwip/memp.h"
#include "lwip/stats.h"
#include "lwip/netdb.h"
#include "netif/loopif.h"

/* ethernet includes */
#include "ethernet.h"
#include "conf_eth.h"

//polarssl includes
#include "polarssl/net.h"
#include "polarssl/ssl.h"
#include "polarssl/havege.h"

#define BUF_SIZE 200

#define GET_REQUEST \
    "GET /hello/ HTTP/1.1\r\n" \
    "Host: MyServerName\r\n\r\n"

#define DEBUG_LEVEL 1

//#include "debug_ssl.h"

char tmpbuf[100];
#define PRINTF_DBG(...) {  \
                      sprintf(tmpbuf,__VA_ARGS__); \
                      print_dbg(tmpbuf); \
                      }\

#define PRINTF_MALLOC(x) print_dbg("Malloc addr: 0x"); \
                         print_dbg_hex((int) x); \
                         print_dbg("\n"); \

void my_debug(void *ctx, int level, char *str) {
    if (level < DEBUG_LEVEL) {
        PRINTF_DBG( "%s", str );
    }
}

portTASK_FUNCTION( vBasicSSLClient, pvParameters )
{
    int ret =0;
    int len =0;
    int server_fd =0;
    unsigned char *buf;
    havege_state  *hs;
    ssl_context  *ssl;
    ssl_session  *ssn;

    //Allocate all Memory   
    buf = malloc(sizeof(unsigned char)*BUF_SIZE);
    memset( buf, 0, sizeof( unsigned char )*BUF_SIZE );

    /*
     * 0. Initialize the RNG and the session data
     */
    print_dbg(( "SSL: ! init havedge\n" )); 
    hs = malloc(sizeof(havege_state));
    havege_init( hs );
        
    ssl = malloc(sizeof(ssl_context));
    memset( ssl, 0, sizeof( ssl_context ) );
    
    ssn = malloc(sizeof(ssl_session));
    memset( ssn, 0, sizeof( ssl_session ) );
    

    /*
     * 1. Start the connection
     */

    do {
        print_dbg(( "SSL: net_connect to server\n" ));
        PRINTF_DBG( "SSL: Connecting to tcp/%s/%4d...\n", SSL_SERVER_NAME, SSL_SERVER_PORT );
        if( ( ret = net_connect( &server_fd, SSL_SERVER_NAME, SSL_SERVER_PORT ) ) != 0 )
        {
            print_dbg(( "SSL: ! net_connect Fail\n" ));
            PRINTF_DBG( "SSL: ! net_connect returned 0x%4x\n", -ret );
        }
        // Wait 1s until next retry
        vTaskDelay(1000);
    }
    while(ret!=0);

    print_dbg(( "SSL: net_connect Pass\n" ));

    /*
     * 2. Setup stuff
     */
    PRINTF_DBG("SSL: Setting up the SSL/TLS structure...");

    if( ( ret = ssl_init( ssl ) ) != 0 )
    {
        PRINTF_DBG( " failed\n");
        PRINTF_DBG( "SSL: ! ssl_init returned 0x%4.4x\n\n", -ret );
        goto exit;
    }

    print_dbg(( " ok\n" ));

    ssl_set_endpoint( ssl, SSL_IS_CLIENT );
    ssl_set_authmode( ssl, SSL_VERIFY_NONE );

    ssl_set_rng( ssl, havege_rand, hs );
    ssl_set_dbg( ssl, my_debug, stdout );
    ssl_set_bio( ssl, net_recv, &server_fd, net_send, &server_fd );

    ssl_set_ciphers( ssl, ssl_default_ciphers );
    ssl_set_session( ssl, 1, 600, ssn );

    /*
     * 3. Write the GET request
     */
    PRINTF_DBG( "SSL: Write ...\n" );
    len = sprintf( (char *) buf, GET_REQUEST );

    while( ( ret = ssl_write( ssl, buf, len ) ) <= 0 )
    {
        if( ret != POLARSSL_ERR_NET_TRY_AGAIN )
        {
            PRINTF_DBG( " failed\n");
            PRINTF_DBG( "SSL : ! ssl_write returned %x(%x)\n\n", ret,-ret );
            goto exit;
        }
    }

    len = ret;
    print_dbg("\n--------------------------------------------------------------------\n");
    PRINTF_DBG( "SSL %s\n", (char *) buf );
    print_dbg("\n--------------------------------------------------------------------\n");
    PRINTF_DBG( "SSL: Successfully write %d bytes to server\n", len);

    /*
     * 7. Read the HTTP response
     */
    print_dbg( "SSL: Read from server:" );
    do
    {
        len = BUF_SIZE - 1;
        memset( buf, 0, sizeof( unsigned char )*BUF_SIZE );
        ret = ssl_read( ssl, buf, len );        
        if( ret == POLARSSL_ERR_NET_TRY_AGAIN ) {
            print_dbg("SSL: POLARSSL_ERR_NET_TRY_AGAIN\n");
            continue;
        }

        if( ret == POLARSSL_ERR_SSL_PEER_CLOSE_NOTIFY ) {
            print_dbg("SSL: POLARSSL_ERR_SSL_PEER_CLOSE_NOTIFY\n");
            break;
        }
        
        if( ret <= 0 )
        {
            
            break;
        }

        len = ret;              
        print_dbg("\n--------------------------------------------------------------------\n");
        PRINTF_DBG( "%s", (char *) buf );
        print_dbg("\n--------------------------------------------------------------------\n");
        PRINTF_DBG("SSL: Successfully read %d bytes from server\n",len);
    }
    while( 0 );

    exit:
    print_dbg("SSL: END \n");
        vTaskDelay(1000);

    /* Loop forever */
    net_close( server_fd );

    //This function Cleanup all Memory 
    ssl_free( ssl );
    memset( ssl, 0, sizeof( ssl ) );
    for(;; ) {gpio_clr_gpio_pin(LED3_GPIO);vTaskDelay(250);}

}

#endif

---