Blowfish floating point - c

Question

I have some floating point data e.g. "3.9389005e-01" which I want to cipher with Blowfish.
strtod is used to get a float from the string.
But Blowfish only encrypts integers.
So my plan is to encrypt each FP value as two integers, a mantisaa and an exponent. Then store as two separate encrypted values.
Decryption will return the mantissa and exponent enabling re-constitution of the original FP number.
is there a neater solution ?
Some demo code for blowfish is here.

Answer 1

You can access any pointer as any other pointer. The data may not be meaningful as another data-type, but it's possible:
double value = 123.456;
int *ptr = (int *) &value;
Now you have a pointer to a memory area of sizeof(double) bytes (or sizeof(double) / sizeof(int) integers) that can be encrypted.
To get back the double after decryption, you can do e.g.:
double new_value = *((double *) ptr);

Answer 2

Declare an union between the double you need to encrypt, and a uint8_t array of the same size.
To encrypt, fill in the double, encrypt the bytes. To decrypt, decrypt the bytes and read off the double.
This approach can be extended to any non-byte data type, provided the cypher you use outputs same-size messages.
In case of padding, the faster approach of "get a uint8_t * to whatever your data iswill sometimes work, sometimes not; AES-256 will work with adoubleof size 8, but block implementations are liable to crash or corrupt data when working with afloatof size 4 (they will attempt to read 8 bytes, and write 8 bytes; where only four are actually available). Due to platform and compiler quirks, this may *still* work because after thefloat` there might be some "memory padding" available.
To be safe, if for example the cypher is padded to 256 bits (32 bytes), you will have to fix the length of the byte array to be likewise padded. One not-so-clean way of doing this is to increase byte count by a whole padding count:
#include <stdio.h>
typedef struct {
double a;
long v;
// Whatever else.
// ...
} payload_t;
union {
payload_t payload;
unsigned char bytes[sizeof(payload_t)+32]; // 256 bits of margin
} data;
int main(void)
{
data.payload.a = 3.14159;
data.payload.v = 123456789;
...
// Encrypt data.bytes, for a length integer multiple of 32 bytes
size_t length = ((sizeof(payload_t)+31)/32)*32;

Answer 3

Should code want to convert the FP value to a string, then encrypt the string and later want to get the exact FP value back, then the FP number needs to be converted with sufficient precision. Use "%.*e" and DBL_DECIMAL_DIG (or DBL_DIG + 3 if unavailable).
#include <float.h>
// sign digit . fraction e sign expo \0 CYA
#define FP_BUF_SIZE (1+1+1+ (DBL_DECIMAL_DIG-1) + 1 + 1 + 4 + 1 + 10)
double x;
char buf[FP_BUF_SIZE];
sprintf(buf, "%.*e", DBL_DECIMAL_DIG - 1, x);
Encode(buf);
Ref Printf width specifier to maintain precision of floating-point value
Alternatively, code could use sprintf(buf, "%a", x);