Urgent help! does anyone has sample code to do encry in c & decry in java

Question

Does anyone has a very simple code to encrypt a string in c (openssl for example) and then decrypt the same string in java?
it should be very simple but i just can get the ball rolling. i always get different data (even in hex string representation) using the same key and plain text (all in hex) to even just do encryption (not even decryption yet). To my understanding, DES is just bits manipulation. So the output bit pattern should be the same regardless C or Java, right?
for example, in openssl, when i do ecb:
the key:
0123456789ABCDEF
the plain text:
0101010101010101
the in:
0101010101010101
the out:
B4FD231647A5BEC0
but doing the same in java i got
3A2EAD12F475D82C as the encryption output
It is very strange.
Hope someone could help me.
Thanks
-- Jin

Answer 1

whew! i finally get the base64 working. Here is my data from openssl run using DES with ECB mode and no padding: (the des_ecb_encrypt function is des/ecb/nopadding, right?)
thanks alot
-- jin
0123456789ABCDEF
the key in base64 encoding is:ASNFZ4mrze8=
the plaintext in hex:
0101010101010101
the plaintext in base64 encoding is:AQEBAQEBAQE=
the encrypted output in hex:
B4FD231647A5BEC0
the encrypted output in base64 encoding is:tP0jFkelvsA=
the decrypted text in hex:
0101010101010101
the decrypted text in base64 encoding is:AQEBAQEBAQE=
here is the code. see if you see the same thing. it works fine alone but just not the same result i use the SUN JCE ... that is the frustration part.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <ctype.h>
#include <openssl/des.h>
#define Assert(Cond) if (!(Cond)) abort()
static const char Base64[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static const char Pad64 = '=';
int main(int argc, char *argv[])
        int i;
        des_cblock in,out,outin;
        unsigned char base64EncodedText[255];
        unsigned char temp[255];
        size_t targsize;
        size_t srclength;
        des_key_schedule keySchedule;
        unsigned char plainText[8] = {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
        unsigned char key[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
        // now create the key schedule
        if(DES_set_key(&key, &keySchedule) != 0) {
          // something is wrong, unable to create key schedule
          printf("Unable to create the key schedule.");
          return 1;
        // now the key schedule is created, encrypte the data
        // in block contains the plain text, the out block contains the encrypted cyphertext,
        // and outin contains the decrypted plain text (should be the same value as in)
        memcpy(in,plainText,8);
        memset(out,0,8);
        memset(outin,0,8);
        // ecb mode is the simplest mode, takes in only 8 bytes (a cblock) and output a cblock
        des_ecb_encrypt(&in, &out, keySchedule, DES_ENCRYPT);
        des_ecb_encrypt(&out, &outin, keySchedule, DES_DECRYPT);
        printf("\nthe key in hex:\n");
  for(i = 0; i < 8; i++) {
    printf("%02X", key);
printf("\nthe key in base64 encoding is:");
memcpy(temp, key, 8);
temp[8] ='\0';
targsize = base64encode(temp, 8, base64EncodedText, targsize);
printf("%s", base64EncodedText);
printf("\nthe plaintext in hex:\n");
for(i = 0; i < 8; i++) {
printf("%02X", in[i]);
printf("\nthe plaintext in base64 encoding is:");
memcpy(temp, in, 8);
temp[8] ='\0';
targsize = base64encode(temp, 8, base64EncodedText, targsize);
printf("%s", base64EncodedText);
printf("targsize is %d", targsize);
printf("\nthe encrypted output in hex:\n");
for(i=0; i<8; i++) {
printf("%02X", out[i]);
printf("\nthe encrypted output in base64 encoding is:");
memcpy(temp, out, 8);
temp[8] ='\0';
targsize = base64encode(temp, 8, base64EncodedText, targsize);
printf("%s", base64EncodedText);
printf("\nthe decrypted text in hex:\n");
for(i = 0; i < 8; i++) {
printf("%02X", outin[i]);
printf("\nthe decrypted text in base64 encoding is:");
memcpy(temp, outin, 8);
temp[8] ='\0';
targsize= base64encode(temp, 8, base64EncodedText, targsize);
printf("%s", base64EncodedText);
printf("\n");
return 1;
int base64encode(unsigned char *src, size_t srclength,
char *target, size_t targsize)
size_t datalength = 0;
unsigned char input[3];
unsigned char output[4];
size_t i;
while (2 < srclength) {
input[0] = *src++;
input[1] = *src++;
input[2] = *src++;
srclength -= 3;
output[0] = input[0] >> 2;
output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
output[3] = input[2] & 0x3f;
Assert(output[0] < 64);
Assert(output[1] < 64);
Assert(output[2] < 64);
Assert(output[3] < 64);
if (datalength + 4 > targsize)
return (-1);
target[datalength++] = Base64[output[0]];
target[datalength++] = Base64[output[1]];
target[datalength++] = Base64[output[2]];
target[datalength++] = Base64[output[3]];
/* Now we worry about padding. */
if (0 != srclength) {
/* Get what's left. */
input[0] = input[1] = input[2] = '\0';
for (i = 0; i < srclength; i++)
input[i] = *src++;
output[0] = input[0] >> 2;
output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
Assert(output[0] < 64);
Assert(output[1] < 64);
Assert(output[2] < 64);
if (datalength + 4 > targsize)
return (-1);
target[datalength++] = Base64[output[0]];
target[datalength++] = Base64[output[1]];
if (srclength == 1)
target[datalength++] = Pad64;
else
target[datalength++] = Base64[output[2]];
target[datalength++] = Pad64;
if (datalength >= targsize)
return (-1);
target[datalength] = '\0'; /* Returned value doesn't count \0. */
return (datalength);
[code