Skip to content
Snippets Groups Projects
Commit 7d0e086f authored by clohr's avatar clohr
Browse files

passe du codage base64 à hexa pour les bytestrings

git-svn-id: https://redmine.imt-atlantique.fr/svn/xaal/code/C/branches/version-0.7@2313 b32b6428-25c9-4566-ad07-03861ab6144f
parent c0acfd87
No related branches found
No related tags found
No related merge requests found
......@@ -15,7 +15,7 @@ all: lib$(LIB).a lib$(LIB).so $(DEMO)
lib$(LIB).a: lib$(LIB).o
$(AR) rc $@ $^
lib$(LIB).so: lib$(LIB).c cencode.c cdecode.c
lib$(LIB).so: lib$(LIB).c
$(CC) $(CFLAGS) $^ $(LDFLAGS) -fPIC -shared -o $@
clean:
......
libxaal_jc.o: libxaal_jc.c cencode.h cdecode.h xaal.h xaal_jc.h
libxaal_jc.o: libxaal_jc.c xaal.h xaal_jc.h
xaal_jc.o: xaal_jc.c xaal_jc.h
/*
cdecoder.c - c source to a base64 decoding algorithm implementation
This is part of the libb64 project, and has been placed in the public domain.
For details, see http://sourceforge.net/projects/libb64
*/
#include "cdecode.h"
int base64_decode_value(char value_in)
{
static const char decoding[] = {62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-2,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51};
static const char decoding_size = sizeof(decoding);
value_in -= 43;
if (value_in < 0 || value_in > decoding_size) return -1;
return decoding[(int)value_in];
}
void base64_init_decodestate(base64_decodestate* state_in)
{
state_in->step = step_a;
state_in->plainchar = 0;
}
int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in)
{
const char* codechar = code_in;
char* plainchar = plaintext_out;
char fragment;
*plainchar = state_in->plainchar;
switch (state_in->step)
{
while (1)
{
case step_a:
do {
if (codechar == code_in+length_in)
{
state_in->step = step_a;
state_in->plainchar = *plainchar;
return plainchar - plaintext_out;
}
fragment = (char)base64_decode_value(*codechar++);
} while (fragment < 0);
*plainchar = (fragment & 0x03f) << 2;
case step_b:
do {
if (codechar == code_in+length_in)
{
state_in->step = step_b;
state_in->plainchar = *plainchar;
return plainchar - plaintext_out;
}
fragment = (char)base64_decode_value(*codechar++);
} while (fragment < 0);
*plainchar++ |= (fragment & 0x030) >> 4;
*plainchar = (fragment & 0x00f) << 4;
case step_c:
do {
if (codechar == code_in+length_in)
{
state_in->step = step_c;
state_in->plainchar = *plainchar;
return plainchar - plaintext_out;
}
fragment = (char)base64_decode_value(*codechar++);
} while (fragment < 0);
*plainchar++ |= (fragment & 0x03c) >> 2;
*plainchar = (fragment & 0x003) << 6;
case step_d:
do {
if (codechar == code_in+length_in)
{
state_in->step = step_d;
state_in->plainchar = *plainchar;
return plainchar - plaintext_out;
}
fragment = (char)base64_decode_value(*codechar++);
} while (fragment < 0);
*plainchar++ |= (fragment & 0x03f);
}
}
/* control should not reach here */
return plainchar - plaintext_out;
}
/*
cdecode.h - c header for a base64 decoding algorithm
This is part of the libb64 project, and has been placed in the public domain.
For details, see http://sourceforge.net/projects/libb64
*/
#ifndef BASE64_CDECODE_H
#define BASE64_CDECODE_H
typedef enum
{
step_a, step_b, step_c, step_d
} base64_decodestep;
typedef struct
{
base64_decodestep step;
char plainchar;
} base64_decodestate;
void base64_init_decodestate(base64_decodestate* state_in);
int base64_decode_value(char value_in);
int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in);
#endif /* BASE64_CDECODE_H */
/*
Note: Modifications to avoid line break
*/
/*
cencoder.c - c source to a base64 encoding algorithm implementation
This is part of the libb64 project, and has been placed in the public domain.
For details, see http://sourceforge.net/projects/libb64
*/
#include "cencode.h"
//const int CHARS_PER_LINE = 72;
void base64_init_encodestate(base64_encodestate* state_in)
{
state_in->step = step_A;
state_in->result = 0;
//state_in->stepcount = 0;
}
char base64_encode_value(char value_in)
{
static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
if (value_in > 63) return '=';
return encoding[(int)value_in];
}
int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
{
const char* plainchar = plaintext_in;
const char* const plaintextend = plaintext_in + length_in;
char* codechar = code_out;
char result;
char fragment;
result = state_in->result;
switch (state_in->step)
{
while (1)
{
case step_A:
if (plainchar == plaintextend)
{
state_in->result = result;
state_in->step = step_A;
return codechar - code_out;
}
fragment = *plainchar++;
result = (fragment & 0x0fc) >> 2;
*codechar++ = base64_encode_value(result);
result = (fragment & 0x003) << 4;
case step_B:
if (plainchar == plaintextend)
{
state_in->result = result;
state_in->step = step_B;
return codechar - code_out;
}
fragment = *plainchar++;
result |= (fragment & 0x0f0) >> 4;
*codechar++ = base64_encode_value(result);
result = (fragment & 0x00f) << 2;
case step_C:
if (plainchar == plaintextend)
{
state_in->result = result;
state_in->step = step_C;
return codechar - code_out;
}
fragment = *plainchar++;
result |= (fragment & 0x0c0) >> 6;
*codechar++ = base64_encode_value(result);
result = (fragment & 0x03f) >> 0;
*codechar++ = base64_encode_value(result);
//++(state_in->stepcount);
//if (state_in->stepcount == CHARS_PER_LINE/4)
//{
// *codechar++ = '\n';
// state_in->stepcount = 0;
//}
}
}
/* control should not reach here */
return codechar - code_out;
}
int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
{
char* codechar = code_out;
switch (state_in->step)
{
case step_B:
*codechar++ = base64_encode_value(state_in->result);
*codechar++ = '=';
*codechar++ = '=';
break;
case step_C:
*codechar++ = base64_encode_value(state_in->result);
*codechar++ = '=';
break;
case step_A:
break;
}
//*codechar++ = '\n';
*codechar++ = '\0';
return codechar - code_out;
}
/*
cencode.h - c header for a base64 encoding algorithm
This is part of the libb64 project, and has been placed in the public domain.
For details, see http://sourceforge.net/projects/libb64
*/
#ifndef BASE64_CENCODE_H
#define BASE64_CENCODE_H
typedef enum
{
step_A, step_B, step_C
} base64_encodestep;
typedef struct
{
base64_encodestep step;
char result;
int stepcount;
} base64_encodestate;
void base64_init_encodestate(base64_encodestate* state_in);
char base64_encode_value(char value_in);
int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in);
int base64_encode_blockend(char* code_out, base64_encodestate* state_in);
#endif /* BASE64_CENCODE_H */
/* libxaal_jc
* Auxiliary json2cbor & cbor2json transcoders for xAAL
*
* (c) 2017 Christophe Lohr <christophe.lohr@imt-atlantique.fr>
* (c) 2019 Christophe Lohr <christophe.lohr@imt-atlantique.fr>
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
......@@ -22,8 +22,6 @@
#include <cbor.h>
#include <json-c/json.h>
#include <uuid/uuid.h>
#include "cencode.h"
#include "cdecode.h"
#include <xaal.h>
#include <xaal_jc.h>
......@@ -50,20 +48,11 @@ json_object *xAAL_bytestring2json(cbor_item_t *item) {
return json_object_new_string(uuid);
} else {
json_object *jobj;
base64_encodestate b64_state;
char *b64;
int b64_len;
b64_len = ((len+2)/3)*4+1;
b64 = malloc(b64_len);
base64_init_encodestate(&b64_state);
b64_len = base64_encode_block((const char *)bstr, len, b64, &b64_state);
b64_len += base64_encode_blockend(b64+b64_len, &b64_state);
char hex[len*2];
for (size_t i = 0; i<len; i++)
sprintf(&(hex[2*i]), "%02x", bstr[i]);
free(bstr);
jobj = json_object_new_string_len(b64, b64_len);
free(b64);
return jobj;
return json_object_new_string_len(hex, len*2);;
}
}
......@@ -152,18 +141,6 @@ cbor_item_t *xAAL_jsonstring2cbor(json_object *jobj) {
}
cbor_item_t *xAAL_jsonb64_to_bytestring(json_object *jobj) {
const char *str = json_object_get_string(jobj);
int sz, len = json_object_get_string_len(jobj);
base64_decodestate b64_state;
char b64[ ((len+1)*6)/8 ];
base64_init_decodestate(&b64_state);
sz = base64_decode_block(str, len, b64, &b64_state);
return cbor_build_stringn(b64, sz);
}
cbor_item_t *xAAL_json2cbor_ex(json_object *jobj, unsigned maxdepth) {
if (!maxdepth--)
return cbor_new_undef();
......
......@@ -21,7 +21,7 @@
#ifndef LIBXAAL_JC
#define LIBXAAL_JC
#define xAAL_JC_VERSION "0.1"
#define xAAL_JC_VERSION "0.2"
#include <cbor.h>
#include <json-c/json.h>
......@@ -30,9 +30,8 @@
* cbor2json
*/
/* Transcode a cbor bytestring into json string
* Note: bytestring[16] are encoded as uuid,
* other data are base64 encoded */
/* Transcode a cbor bytestring into json string, with hexadecimal notation
* Except bytestring[16] that are encoded as uuid (i.e. hexa with dash) */
json_object *xAAL_bytestring2json(cbor_item_t *item);
/* Do its best to transcode cbor data into json
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment