Welcome to MDGSF's Blog!

This is my github blog

[FreeRTOS] Queue Create

2017-01-13

mdgsf

FreeRTOS

Freertos

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "list.h"
#include "supporting_functions.h"


static void vSenderTask(void * pvParameters);
static void vReceiverTask(void * pvParameters);

QueueHandle_t xQueue;

int main()
{
    xQueue = xQueueCreate(5, sizeof(int32_t));

    if (xQueue != NULL)
    {
        xTaskCreate(vSenderTask, "Sender1", 1000, (void*)100, 1, NULL);
        xTaskCreate(vSenderTask, "Sender2", 1000, (void*)200, 1, NULL);

        xTaskCreate(vReceiverTask, "Receiver", 1000, NULL, 2, NULL);

        vTaskStartScheduler();
    }
    else
    {

    }

    for (;;);

    return 0;
}


static void vSenderTask(void * pvParameters)
{
    int32_t lValueToSend;
    BaseType_t xStatus;

    lValueToSend = (int32_t)pvParameters;

    for (;;)
    {
        xStatus = xQueueSendToBack(xQueue, &lValueToSend, 0);
        if (xStatus != pdPASS)
        {
            vPrintString("Could not send to the queue.\n");
        }
    }
}

static void vReceiverTask(void * pvParameters)
{
    int32_t lReceivedValue;
    BaseType_t xStatus;
    const TickType_t xTicksToWait = pdMS_TO_TICKS(100UL);

    for (;;)
    {
        UBaseType_t xItemNum = uxQueueMessagesWaiting(xQueue);
        printf("Queue item number = %d\n", xItemNum);

        xStatus = xQueueReceive(xQueue, &lReceivedValue, xTicksToWait);

        if (xStatus == pdPASS)
        {
            vPrintStringAndNumber("Received = ", lReceivedValue);
        }
        else
        {
            vPrintString("Could not receive from the queue.\n");
        }
    }
}

Read All

[openssl] Simple tcp server

2017-01-11

mdgsf

openssl

Openssl Server

Generate private key and cacert.pem

To generate RSA private key, 2048 bit. openssl genrsa -out privatekey.pem

To generate RSA public key openssl rsa -in privatekey.pem -pubout -out publickey.pem

chage private key to pkcs8 format: openssl pkcs8 -topk8 -inform PEM -in privatekey.pem -outform PEM -nocrypt

To create a hex-encoded message digest of a file: openssl dgst -md5 -hex file.txt

To sign a file using SHA-256 with binary file output: openssl dgst -sha256 -sign privatekey.pem -out signature.sign file.txt

To verify a signature: openssl dgst -sha256 -verify publickey.pem -signature signature.sign file.txt

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <arpa/inet.h>
#include "openssl/bio.h"
#include "openssl/ssl.h"
#include "openssl/err.h"

#define IP "127.0.0.1"
#define PORT 8383
#define FILE_CACERT "cacert.pem"
#define FILE_PRIVATE_KEY "privatekey.pem"

int main()
{
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    SSL_load_error_strings();

    SSL_CTX * ctx = SSL_CTX_new(SSLv23_server_method());
    if(NULL == ctx) {
        ERR_print_errors_fp(stdout);
        exit(1);
    }

    if(SSL_CTX_use_certificate_file(ctx, FILE_CACERT,  SSL_FILETYPE_PEM) <= 0) {
        ERR_print_errors_fp(stdout);
        exit(1);
    }

    if(SSL_CTX_use_PrivateKey_file(ctx, FILE_PRIVATE_KEY, SSL_FILETYPE_PEM) <= 0) {
        ERR_print_errors_fp(stdout);
        exit(1);
    }

    if(!SSL_CTX_check_private_key(ctx)) {
        ERR_print_errors_fp(stdout);
        exit(1);
    }

    int iSockFD = socket(AF_INET, SOCK_STREAM, 0);
    if(iSockFD == -1) {
        perror("socket");
        exit(1);
    }

    struct sockaddr_in stServerAddr;
    memset(&stServerAddr, 0, sizeof(stServerAddr));
    stServerAddr.sin_family = AF_INET;
    stServerAddr.sin_port = htons(PORT);
    stServerAddr.sin_addr.s_addr = inet_addr(IP);

    if(bind(iSockFD, (struct sockaddr*)&stServerAddr, sizeof(struct sockaddr)) == -1) {
        perror("bind");
        exit(1);
    }

    if(listen(iSockFD, 5) == -1) {
        perror("listen");
        exit(1);
    }

    while (1)
    {
        socklen_t iLen = sizeof(struct sockaddr);
        struct sockaddr_in stClientAddr;
        int iNewFD = accept(iSockFD, (struct sockaddr*)&stClientAddr, &iLen);
        if(iNewFD == -1) {
            perror("accept");
            exit(1);
        }
        printf("%s:%d, socket %d\n",
                inet_ntoa(stClientAddr.sin_addr),
                ntohs(stClientAddr.sin_port),
                iNewFD);

        SSL * ssl = SSL_new(ctx);
        SSL_set_fd(ssl, iNewFD);
        if(SSL_accept(ssl) == -1) {
            perror("SSL_accept");
            close(iNewFD);
            break;
        }

        char acBuf[BUFSIZ] = {0};
        strcpy(acBuf, "server->client");

        sleep(2);

        iLen = SSL_write(ssl, acBuf, strlen(acBuf));
        if(iLen <= 0) {
            printf("SSL_write failed\n");
            goto finish;
        }

        memset(acBuf, 0, sizeof(acBuf));
        iLen = SSL_read(ssl, acBuf, sizeof(acBuf));
        if(iLen <= 0) {
            printf("SSL_read failed\n");
        } else {
            printf("SSL_read success, acBuf = %s\n", acBuf);
        }


finish:
        SSL_shutdown(ssl);
        SSL_free(ssl);
        close(iNewFD);
    }

    close(iSockFD);
    SSL_CTX_free(ctx);

    return 0;
}

Read All

[openssl] Simple tcp client--Block and NonBlock read

2017-01-11

mdgsf

openssl

Openssl Sslclient

Block read

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <arpa/inet.h>
#include "openssl/bio.h"
#include "openssl/ssl.h"
#include "openssl/err.h"

#define IP "127.0.0.1"
#define PORT 8383

void ShowCerts(SSL * ssl)
{
    X509 * cert = SSL_get_peer_certificate(ssl);
    if(NULL == cert) {
        printf("no cert\n");
        return ;
    }

    printf("cert information:\n");
    char * line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
    printf("%s\n", line);
    free(line);

    line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
    printf("%s\n", line);
    free(line);

    X509_free(cert);
}

int main()
{
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    SSL_load_error_strings();

    SSL_CTX * ctx = SSL_CTX_new(SSLv23_client_method());
    if(NULL == ctx) {
        ERR_print_errors_fp(stdout);
        exit(1);
    }

    int iSockFD = socket(AF_INET, SOCK_STREAM, 0);
    if(iSockFD <= 0) {
        perror("socket");
        exit(1);
    }

    struct sockaddr_in stServerAddr;
    stServerAddr.sin_family = AF_INET;
    stServerAddr.sin_port = htons(PORT);
    if(inet_aton(IP, (struct in_addr*)&stServerAddr.sin_addr.s_addr) == 0) {
        perror("inet_aton");
        exit(1);
    }

    if(connect(iSockFD, (struct sockaddr*)&stServerAddr, sizeof(stServerAddr)) != 0) {
        perror("connect");
        exit(1);
    }

    SSL * ssl = SSL_new(ctx);
    SSL_set_fd(ssl, iSockFD);

    if(SSL_connect(ssl) == -1)
    {
        ERR_print_errors_fp(stderr);
    }
    else
    {
        ShowCerts(ssl);
    }

    char acBuf[BUFSIZ] = {0};
    socklen_t iLen = SSL_read(ssl, acBuf, sizeof(acBuf));
    if(iLen <= 0) {
        printf("SSL_read failed\n");
        goto finish;
    } else {
        printf("SSL_read success, acBuf = %s\n", acBuf);
    }

    memset(acBuf, 0, sizeof(acBuf));
    strcpy(acBuf, "from client->server");
    iLen = SSL_write(ssl, acBuf, strlen(acBuf));
    if(iLen <= 0) {
        printf("SSL_write failed\n");
    } else {
        printf("SSL_write success\n");
    }

finish:
    SSL_shutdown(ssl);
    SSL_free(ssl);
    close(iSockFD);
    SSL_CTX_free(ctx);

    return 0;
}

Non-block read

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <sys/select.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include "openssl/bio.h"
#include "openssl/ssl.h"
#include "openssl/err.h"

#define IP "127.0.0.1"
#define PORT 8383

#define TCP_TIMEOUT 2

static inline void itimeofday(long *sec, long *usec)
{
    #if defined(__unix)
    struct timeval time;
    gettimeofday(&time, NULL);
    if (sec) *sec = time.tv_sec;
    if (usec) *usec = time.tv_usec;
    #else
    static long mode = 0, addsec = 0;
    BOOL retval;
    static unsigned long long freq = 1;
    unsigned long long qpc;
    if (mode == 0) {
        retval = QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
        freq = (freq == 0)? 1 : freq;
        retval = QueryPerformanceCounter((LARGE_INTEGER*)&qpc);
        addsec = (long)time(NULL);
        addsec = addsec - (long)((qpc / freq) & 0x7fffffff);
        mode = 1;
    }
    retval = QueryPerformanceCounter((LARGE_INTEGER*)&qpc);
    retval = retval * 2;
    if (sec) *sec = (long)(qpc / freq) + addsec;
    if (usec) *usec = (long)((qpc % freq) * 1000000 / freq);
    #endif
}

unsigned long long iclock64(void)
{
    long s, u;
    unsigned long long value;
    itimeofday(&s, &u);
    value = ((unsigned long long)s) * 1000 + (u / 1000);
    return value;
}

unsigned int iclock()
{
    return (unsigned int)(iclock64() & 0xfffffffful);
}

void vTcpSetNonBlock(int iSocket)
{
    int opts;
    opts = fcntl(iSocket, F_GETFL);
    if(opts < 0) {
        exit(1);
    }

    opts = (opts | O_NONBLOCK);
    if(fcntl(iSocket, F_SETFL, opts) < 0) {
        exit(1);
    }
}

int iReadTimeout(
    SSL * ssl,
    int iSocket,
    char * pcBuf,
    int * piBufLen,
    int iTimeout)
{
    if(NULL == ssl || iSocket <= 0 || NULL == pcBuf || NULL == piBufLen) {
        printf("iReadTimeout invlaid parameters\n");
        return EXIT_FAILURE;
    }

    struct timeval stTimeInterval;
    struct timeval stTimeIntervalTemp;
    stTimeInterval.tv_sec = 0;
    stTimeInterval.tv_usec = 10 * 1000;

    int iOnce = 0;
    int iError = 0;

    unsigned int uiCurrentTime = iclock();
    unsigned int uiEndTime;
    if(iTimeout <= 0) uiEndTime = uiCurrentTime + 10 * 1000; //10 seconds
    else uiEndTime = uiCurrentTime + iTimeout;

    while ( (uiCurrentTime = iclock()) < uiEndTime )
    {
        stTimeIntervalTemp = stTimeInterval;
        fd_set stReadSet;
        FD_ZERO(&stReadSet);
        FD_SET(iSocket, &stReadSet);
        iOnce = select(iSocket+1, &stReadSet, NULL, NULL, &stTimeIntervalTemp);
        if(1 == iOnce && FD_ISSET(iSocket, &stReadSet))
        {
            do {
                iOnce = SSL_read(ssl, pcBuf, *piBufLen);
                iError = SSL_get_error(ssl, iOnce);
                switch(iError)
                {
                case SSL_ERROR_NONE:
                    {
                        return EXIT_SUCCESS;
                    }
                    break;
                case SSL_ERROR_ZERO_RETURN:
                    {
                        //peer close the socket.
                        SSL_shutdown(ssl);
                        SSL_free(ssl);
                        close(iSocket);
                        return EXIT_FAILURE;
                    }
                    break;
                case SSL_ERROR_WANT_READ:
                    {
                        //continue to read.
                    }
                    break;
                default:
                    {
                        printf("SSL_read unknown error = %d\n", iError);
                        return EXIT_FAILURE;
                    }
                    break;
                }
            } while(SSL_pending(ssl) && (uiCurrentTime = iclock()) < uiEndTime );
        }
        else if(iOnce == 0)
        {
            continue;
        }
        return EXIT_FAILURE;
    }

    return TCP_TIMEOUT;
}

void ShowCerts(SSL * ssl)
{
    X509 * cert = SSL_get_peer_certificate(ssl);
    if(NULL == cert) {
        printf("no cert\n");
        return ;
    }

    printf("cert information:\n");
    char * line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
    printf("%s\n", line);
    free(line);

    line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
    printf("%s\n", line);
    free(line);

    X509_free(cert);
}

int main()
{
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    SSL_load_error_strings();

    SSL_CTX * ctx = SSL_CTX_new(SSLv23_client_method());
    if(NULL == ctx) {
        ERR_print_errors_fp(stdout);
        exit(1);
    }

    int iSockFD = socket(AF_INET, SOCK_STREAM, 0);
    if(iSockFD <= 0) {
        perror("socket");
        exit(1);
    }

    struct sockaddr_in stServerAddr;
    stServerAddr.sin_family = AF_INET;
    stServerAddr.sin_port = htons(PORT);
    if(inet_aton(IP, (struct in_addr*)&stServerAddr.sin_addr.s_addr) == 0) {
        perror("inet_aton");
        exit(1);
    }

    if(connect(iSockFD, (struct sockaddr*)&stServerAddr, sizeof(stServerAddr)) != 0) {
        perror("connect");
        exit(1);
    }

    SSL * ssl = SSL_new(ctx);
    SSL_set_fd(ssl, iSockFD);

    if(SSL_connect(ssl) == -1)
    {
        ERR_print_errors_fp(stderr);
    }
    else
    {
        ShowCerts(ssl);
    }

    char acBuf[BUFSIZ] = {0};
    socklen_t iLen = 0;

    //socklen_t iLen = SSL_read(ssl, acBuf, sizeof(acBuf));
    //if(iLen <= 0) {
    //  printf("SSL_read failed\n");
    //  goto finish;
    //} else {
    //  printf("SSL_read success, acBuf = %s\n", acBuf);
    //}


    vTcpSetNonBlock(iSockFD);

    int iBufLen = sizeof(acBuf);
    int iRet = iReadTimeout(ssl, iSockFD, acBuf, &iBufLen, 1000);
    if(iRet != EXIT_SUCCESS) {
        printf("iReadTimeout failed, iRet = %d\n", iRet);
        return -1;
    }
    printf("read success, acBuf = %s\n", acBuf);


    memset(acBuf, 0, sizeof(acBuf));
    strcpy(acBuf, "from client->server");
    iLen = SSL_write(ssl, acBuf, strlen(acBuf));
    if(iLen <= 0) {
        printf("SSL_write failed\n");
    } else {
        printf("SSL_write success\n");
    }


    SSL_shutdown(ssl);
    SSL_free(ssl);
    close(iSockFD);
    SSL_CTX_free(ctx);

    return 0;
}

Read All

[openssl] sha1,sha256,sha512

2017-01-11

mdgsf

openssl

Openssl Sha

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "openssl/sha.h"
#include "openssl/crypto.h"

const char * str = "hello";

void printHash(unsigned char * md, int iLen)
{
    for (int i = 0; i < iLen; i++)
    {
        printf("%02x", md[i]);
    }
    printf("\n");
}

void myHash1()
{
    unsigned char md[SHA_DIGEST_LENGTH] = {0};
    SHA1((unsigned char *)str, strlen(str), md);
    printHash(md, SHA_DIGEST_LENGTH);

    SHA_CTX c;
    SHA1_Init(&c);
    SHA1_Update(&c, str, strlen(str));
    SHA1_Final(md, &c);
    OPENSSL_cleanse(&c, sizeof(c));
    printHash(md, SHA_DIGEST_LENGTH);
    printf("\n");
}

void myHash224()
{
    unsigned char md[SHA224_DIGEST_LENGTH] = {0};
    SHA224((unsigned char *)str, strlen(str), md);
    printHash(md, SHA224_DIGEST_LENGTH);

    SHA256_CTX c;
    SHA224_Init(&c);
    SHA224_Update(&c, str, strlen(str));
    SHA224_Final(md, &c);
    OPENSSL_cleanse(&c, sizeof(c));
    printHash(md, SHA224_DIGEST_LENGTH);
    printf("\n");
}

void myHash256()
{
    unsigned char md[SHA256_DIGEST_LENGTH] = {0};
    SHA256((unsigned char *)str, strlen(str), md);
    printHash(md, SHA256_DIGEST_LENGTH);

    SHA256_CTX c;
    SHA256_Init(&c);
    SHA256_Update(&c, str, strlen(str));
    SHA256_Final(md, &c);
    OPENSSL_cleanse(&c, sizeof(c));
    printHash(md, SHA256_DIGEST_LENGTH);
    printf("\n");
}

void myHash384()
{
    unsigned char md[SHA384_DIGEST_LENGTH] = {0};
    SHA384((unsigned char *)str, strlen(str), md);
    printHash(md, SHA384_DIGEST_LENGTH);

    SHA512_CTX c;
    SHA384_Init(&c);
    SHA384_Update(&c, str, strlen(str));
    SHA384_Final(md, &c);
    OPENSSL_cleanse(&c, sizeof(c));
    printHash(md, SHA384_DIGEST_LENGTH);
    printf("\n");
}

void myHash512()
{
    unsigned char md[SHA512_DIGEST_LENGTH] = {0};
    SHA512((unsigned char *)str, strlen(str), md);
    printHash(md, SHA512_DIGEST_LENGTH);

    SHA512_CTX c;
    SHA512_Init(&c);
    SHA512_Update(&c, str, strlen(str));
    SHA512_Final(md, &c);
    OPENSSL_cleanse(&c, sizeof(c));
    printHash(md, SHA512_DIGEST_LENGTH);
    printf("\n");
}

int main()
{
    myHash1();
    myHash224();
    myHash256();
    myHash384();
    myHash512();
    return 0;
}

Read All

[openssl] MD5

2017-01-11

mdgsf

openssl

Openssl Md5

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "openssl/bio.h"
#include "openssl/ssl.h"
#include "openssl/err.h"
#include "openssl/evp.h"
#include "openssl/buffer.h"
#include "openssl/md5.h"

//openssl dgst -md5 -hex Makefile

int main()
{
    MD5_CTX ctx;
    MD5_Init(&ctx);

    FILE * file = fopen("Makefile", "rb");
    if(NULL == file) {
        return -1;
    }

    int iLen = 0;
    unsigned char aucBuffer[1024] = {0};
    while ( (iLen = fread(aucBuffer, 1, 1024, file)) > 0 )
    {
        MD5_Update(&ctx, aucBuffer, iLen);
    }

    unsigned char aucDigest[16] = {0};
    MD5_Final(aucDigest, &ctx);
    fclose(file);


    char acMd5[33] = {0};
    for (int i = 0; i < 16; i++)
    {
        char acTemp[3] = {0};
        sprintf(acTemp, "%02x", aucDigest[i]);
        strcat(acMd5, acTemp);
    }
    printf("acMd5 = %s\n", acMd5);

    return 0;
}

Read All

[openssl] base64编码

2017-01-11

mdgsf

openssl

Openssl Base64

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "openssl/bio.h"
#include "openssl/ssl.h"
#include "openssl/err.h"
#include "openssl/evp.h"
#include "openssl/buffer.h"

int main()
{
    char acInput[BUFSIZ] = {0};
    char acOutput[BUFSIZ] = {0};
    char acDecOut[BUFSIZ] = {0};
    strcpy(acInput, "hello");

    EVP_EncodeBlock((unsigned char*)acOutput, (const unsigned char*)acInput, strlen(acInput));

    EVP_DecodeBlock((unsigned char*)acDecOut, (const unsigned char*)acOutput, strlen(acOutput));

    printf("acInput = %s\n", acInput);
    printf("acOutput = %s\n", acOutput);
    printf("acDecOut = %s\n", acDecOut);

    return 0;
}

Read All

67/97