base 64 加密解密 for test demo

#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