#ifndef BASE64_H_
#define BASE64_H_
//=============================================================================
// Base64 Encoding and Decoding
//
//
//=============================================================================
int base64encode_binary(char *encoded, const unsigned char *string, int len);
char *base64decode(const char *in, char *out, int *size);
#endif
//=============================================================================
// Base64 Encoding and Decoding//
//
//=============================================================================
#include <stdio.h>
#include <string.h>
#include "base64.h"
typedef unsigned char uint8_t;
static void sprintf_hexa( char *s, uint8_t *p_data, int i_data )
{
static const char hex[16] = "0123456789abcdef";
int i;
for( i = 0; i < i_data; i++ ){
s[2*i+0] = hex[(p_data[i]>>4)&0xf];
s[2*i+1] = hex[(p_data[i] )&0xf];
}
s[2*i_data] = '\0';
}
static const char basis_64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
int base64encode_len(int len)
{
return ((len + 2) / 3 * 4) + 1;
}
int base64encode_binary(char *encoded, const unsigned char *string, int len)
{
int i;
char *p;
p = encoded;
for (i = 0; i < len - 2; i += 3) {
*p++ = basis_64[(string[i] >> 2) & 0x3F];
*p++ = basis_64[((string[i] & 0x3) << 4) |
((int) (string[i + 1] & 0xF0) >> 4)];
*p++ = basis_64[((string[i + 1] & 0xF) << 2) |
((int) (string[i + 2] & 0xC0) >> 6)];
*p++ = basis_64[string[i + 2] & 0x3F];
}
if (i < len) {
*p++ = basis_64[(string[i] >> 2) & 0x3F];
if (i == (len - 1)) {
*p++ = basis_64[((string[i] & 0x3) << 4)];
*p++ = '=';
}
else {
*p++ = basis_64[((string[i] & 0x3) << 4) |
((int) (string[i + 1] & 0xF0) >> 4)];
*p++ = basis_64[((string[i + 1] & 0xF) << 2)];
}
*p++ = '=';
}
*p++ = '\0';
return p - encoded;
}
int base64encode(char *encoded, const char *string, int len)
{
return base64encode_binary(encoded, (const unsigned char *) string, len);
}
/*
* Decodes base64 strings (based upon b64 package)
*
* return pointer of out, NULL if error while decoding
*
*/
char *base64decode(const char *in, char *out, int *size) {
static char dtable[256]; /* Encode / decode table */
static int is_init = 0;
int i,k;
unsigned int j;
unsigned int inlen;
// input check, (need to have enough length of size
if(in == NULL || out == NULL || *size < 0){
return NULL;
}
// Initialize D(ecoding)Table
if(is_init == 0){
is_init = 1; // inited
for (i = 0; i < 255; i++) {
dtable[i] = (char)0x80;
}
for (i = 'A'; i <= 'Z'; i++) {
dtable[i] = 0 + (i - 'A');
}
for (i = 'a'; i <= 'z'; i++) {
dtable[i] = 26 + (i - 'a');
}
for (i = '0'; i <= '9'; i++) {
dtable[i] = 52 + (i - '0');
}
dtable['+'] = 62;
dtable['/'] = 63;
dtable['='] = 0;
}
//
// decoding
//
k=0; // output char index
inlen = strlen(in);
if(inlen >= (unsigned) base64encode_len(*size)){ // check output size is enough
return NULL;
}
for (j=0; j<inlen; j+=4) {
char a[4], b[4];
for (i = 0; i < 4; i++) {
int c = in[i+j];
if (dtable[c] & 0x80) {
fprintf(stderr, "Illegal character '%c' in input.\n", c);
return NULL;
}
a[i] = (char) c;
b[i] = (char) dtable[c];
}
//xine_buffer_ensure_size(out, k+3);
out[k++] = (b[0] << 2) | (b[1] >> 4);
out[k++] = (b[1] << 4) | (b[2] >> 2);
out[k++] = (b[2] << 6) | b[3];
i = a[2] == '=' ? 1 : (a[3] == '=' ? 2 : 3);
if (i < 3) {
out[k]=0;
*size=k;
return out;
}
}
out[k]=0;
*size=k;
return out;
}
#ifdef BASE64_MODULE_TEST
int main(int argc, char *argv[])
{
char *idpass = "admin:admin";
char encoded[128];
char decoded[128];
int len = strlen(idpass);
int enlen = base64encode_len(len);
base64encode_binary(encoded, idpass, len);
printf("BASE64enc \"%s\"=>\"%s\":%d\n", idpass, encoded, len);
len = 128;
if(base64decode(encoded, decoded, &len)){
printf("BASE64dec \"%s\"=>\"%s\"\n", encoded, decoded);
}
return 0;
}
#endif