romulus/Romulus-M/encrypt_wrapper.c

#include "encrypt_wrapper.h"
#include <stdio.h>
#include <string.h>

#ifdef _MSC_VER
#define _CRT_RAND_S
#define __bswap_16 _byteswap_ushort
#define __bswap_32 _byteswap_ulong
#else
#include <byteswap.h>
#include <sys/random.h>
#endif

#include <stdlib.h>
#include "romulus_m.h"
#include "api.h"



int encrypt(packet *packet, unsigned char* outBuf, UINT16 *len, unsigned char* key){
    if(sizeof(UINT16) + sizeof(UINT16) + packet->Size > *len){
        return 1;
    }

    int packetSize = packet->Size; 
    // enc
    // ciphertext - out, MAX 16 bytes larger than plaintext - defined as CRYPTO_ABYTES
    unsigned long long clen = packetSize + CRYPTO_ABYTES;
    unsigned char* c = (unsigned char*) calloc(clen, 1);
        
    // plaintext - in
    int mlen = packetSize;
    unsigned char* m = packet->Data;
   
    // additional text
    int adlen = sizeof(packet->DataType);
    unsigned char* ad = (unsigned char*)&packet->DataType;

    // n = nonce, CRYPTO_NPUBBYTES size 16
    unsigned char npub[CRYPTO_NPUBBYTES];
    #ifdef _MSC_VER
    UINT32 secRandom;
    for (size_t i = 0; i < CRYPTO_NPUBBYTES; i+=sizeof(UINT32))
    {
        rand_s(&secRandom);
        memcpy(&npub[i], &secRandom, sizeof(UINT32));
    }
    #else
    getrandom(&npub[0], sizeof(npub), 0);
    #endif

    int ret = romulus_m_encrypt(c, &clen, m, mlen, ad, adlen, 0, &npub[0], key);
      
    if(clen > *len + CRYPTO_NPUBBYTES || ret != 0){
        free(c);
        return 1;
    }
    
    // type 0 1
    // Swap after adding it as additional data
    packet->DataType = __bswap_16(packet->DataType);  
    int loc = 0;
    memcpy(&outBuf[loc], &packet->DataType,sizeof(UINT16));
    loc += sizeof(UINT16);

    // data size 2 3
    UINT16 clen16 = (UINT16)clen;
    // we copy data and nonce
    clen16 += CRYPTO_NPUBBYTES;
    clen16 = __bswap_16(clen16);
    memcpy(&outBuf[loc], &clen16, sizeof(UINT16));
    loc += sizeof(UINT16);

    memcpy(&outBuf[loc], npub, CRYPTO_NPUBBYTES);
    loc += CRYPTO_NPUBBYTES;

    memcpy(&outBuf[loc], c, clen);
    loc += clen;

    *len = loc;

    free(c);

    return 0;
}

int decrypt(packetEx *packet, unsigned char* inBuf, UINT16 len, unsigned char* key){
    int loc = 0;
    if(inBuf == 0 ){
        return 1;
    }
    memcpy(&packet->DataType, &inBuf[loc], sizeof(UINT16));
    loc += sizeof(UINT16);
    memcpy(&packet->Id, &inBuf[loc], sizeof(UINT32));
    loc += sizeof(UINT32);
    memcpy(&packet->Size, &inBuf[loc], sizeof(UINT16));
    loc += sizeof(UINT16);

    packet->DataType = __bswap_16(packet->DataType);
    packet->Size = __bswap_16(packet->Size);
    packet->Id = __bswap_32(packet->Id);

    if(packet->Size < CRYPTO_NPUBBYTES){
        return 1;
    }

    // Data
    // Nonce|Data
    // dec
     // n = nonce, CRYPTO_NPUBBYTES size 16
    unsigned char* npub = &inBuf[loc];
    loc += CRYPTO_NPUBBYTES;

    // ciphertext - out, MAX 16 bytes larger than plaintext - defined as CRYPTO_ABYTES
    int clen = packet->Size - CRYPTO_NPUBBYTES;
    unsigned char* c = &inBuf[loc];
        
    // plaintext - in
    unsigned long long mlen = clen;
    unsigned char* m = (unsigned char*)calloc(mlen, 1);
    
    // additional text
    int adlen = sizeof(packet->DataType);
    unsigned char* ad = (unsigned char*)&packet->DataType;

    int ret = romulus_m_decrypt(m, &mlen, 0, c, clen, ad, adlen, npub, key);   
    if(mlen <= 1000 && ret == 0){
        memcpy(packet->Data, m, mlen);
        packet->Size = (UINT16)mlen;
    }
    else{
        free(m);
        return -1;
    }
    free(m);
    return 0;
}