static const char *codes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

static const unsigned char map[256] = {
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255,  62, 255, 255, 255,  63,
 52,  53,  54,  55,  56,  57,  58,  59,  60,  61, 255, 255,
255, 254, 255, 255, 255,   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, 255, 255, 255, 255, 255,
255,  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, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255 };

bool base64_encode(char *in, int inlen, char *out, int outlen)
{
   int i, len2, leven;
   char *p;

 // valid output size ? 
   len2 = 4 * ((inlen + 2) / 3);
   if (outlen < len2 + 1) {
      outlen = len2 + 1;
      return false;
   }
   p = out;
   leven = 3*(inlen / 3);
   for (i = 0; i < leven; i += 3) {
       *p++ = codes[(in[0] >> 2) & 0x3F];
       *p++ = codes[(((in[0] & 3) << 4) + (in[1] >> 4)) & 0x3F];
       *p++ = codes[(((in[1] & 0xf) << 2) + (in[2] >> 6)) & 0x3F];
       *p++ = codes[in[2] & 0x3F];
       in += 3;
   }
   // Pad it if necessary...  
   if (i < inlen) {
       unsigned a = in[0];
       unsigned b = (i+1 < inlen) ? in[1] : 0;

       *p++ = codes[(a >> 2) & 0x3F];
       *p++ = codes[(((a & 3) << 4) + (b >> 4)) & 0x3F];
       *p++ = (i+1 < inlen) ? codes[(((b & 0xf) << 2)) & 0x3F] : '=';
       *p++ = '=';
   }

   // append a NULL byte 
   *p = '\0';

   // return ok 
   outlen = p - out;
   return true;
}

void base64_decode(const unsigned char *in,  unsigned long inlen, unsigned char *out, unsigned long outlen)
{
   unsigned long t, x, y, z;
   unsigned char c;
   int g = 3;

   for (x = y = z = t = 0; x < inlen; x++) {
       c = map[in[x]&0xFF];
       if (c == 255) continue;
       /* the final = symbols are read and used to trim the remaining bytes */
       if (c == 254) { 
          c = 0; 
          /* prevent g < 0 which would potentially allow an overflow later */
          if (--g < 0) {
             return;
          }
       } else if (g != 3) {
          /* we only allow = to be at the end */
          return;
       }

       t = (t<<6)|c;

       if (++y == 4) {
          if (z + g > outlen) { 
             return; 
          }
          out[z++] = (unsigned char)((t>>16)&255);
          if (g > 1) out[z++] = (unsigned char)((t>>8)&255);
          if (g > 2) out[z++] = (unsigned char)(t&255);
          y = t = 0;
       }
   }
   if (y != 0) {
       return;
   }
   outlen = z;
   return ;
}

void base64_decodeW(const wchar_t *in,  unsigned long inlen, wchar_t *out, unsigned long outlen)
{
   unsigned long t, x, y, z;
   wchar_t c;
   int g = 3;

   for (x = y = z = t = 0; x < inlen; x++) {
       c = map[in[x]&0xFF];
       if (c == 255) continue;
       /* the final = symbols are read and used to trim the remaining bytes */
       if (c == 254) { 
          c = 0; 
          /* prevent g < 0 which would potentially allow an overflow later */
          if (--g < 0) {
             return;
          }
       } else if (g != 3) {
          /* we only allow = to be at the end */
          return;
       }

       t = (t<<6)|c;

       if (++y == 4) {
          if (z + g > outlen) { 
             return; 
          }
          out[z++] = (wchar_t)((t>>16)&255);
          if (g > 1) out[z++] = (wchar_t)((t>>8)&255);
          if (g > 2) out[z++] = (wchar_t)(t&255);
          y = t = 0;
       }
   }
   if (y != 0) {
       return;
   }
   outlen = z;
   return ;
}

/*

Example program
----------------

void main(int argc, char* argv[])
{
	char *to_decode = argv[1];
	char *to_encode = argv[2];
	char decode[MAX_PATH] = {0};
	char encode[MAX_PATH] = {0};

	if(argc < 3)
	{
		printf("\n\t Usage: progname.exe <data to decode> <data to encode>\n");
		return;
	}

	base64_encode((char *)to_encode,lstrlen(to_encode),encode,sizeof(encode));
	base64_decode((const unsigned char *)to_decode,lstrlen(to_decode),(unsigned char *)decode,sizeof(decode));

	if(lstrcmp(encode,to_decode)==0)
	{
		printf("\n\tEncoded data: %s <---> equal decoded data\n",encode);
	} else printf("\n\tEncoded data: %s <---> not equal decoded data\n",encode);

	if(lstrcmp(decode,to_encode)==0)
	{
		printf("\n\tDecoded data: %s <---> equal encoded data\n",decode);
	} else printf("\n\tDecoded data: %s <---> not equal encoded data\n",decode);

	return;
}*/

maslo
bWF bG6=
ma[

test
dGV dA==
te]

//
// Base64Encode
//
// Encodes string in base64
//

static char charBase64[] = {
	'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
	'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
	'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
	'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/'
};

ULONG
Base64Encode (
  LPTSTR lpszInputString,
  LPTSTR lpOutputBuffer,
  SIZE_T nMaxLength
  )
{
	char chr[3], enc[4];

	int outpos = 0;

	for( int i=0; i<lstrlen(lpszInputString); i+=3 )
	{
		if( outpos+4 >= nMaxLength )
			break;

		chr[0] = lpszInputString[i];
		chr[1] = lpszInputString[i+1];
		chr[2] = lpszInputString[i+2];

		enc[0] = chr[0] >> 2;
		enc[1] = ((chr[0] & 0x03) << 4) | (chr[1] >> 4);
		enc[2] = ((chr[1] & 0x0F) << 2) | (chr[2] >> 6);
		enc[3] = chr[2] & 0x3F;

		lpOutputBuffer[outpos++] = charBase64[enc[0]];
		lpOutputBuffer[outpos++] = charBase64[enc[1]];

		if( i+1 >= lstrlen(lpszInputString) )
		{
			lpOutputBuffer[outpos++] = '=';
			lpOutputBuffer[outpos++] = '=';
		}
		else if( i+2 >= lstrlen(lpszInputString) )
		{
			lpOutputBuffer[outpos++] = charBase64[enc[2]];
			lpOutputBuffer[outpos++] = '=';
		}
		else
		{
			lpOutputBuffer[outpos++] = charBase64[enc[2]];
			lpOutputBuffer[outpos++] = charBase64[enc[3]];
		}
	}

	lpOutputBuffer[outpos] = 0;
	return outpos;
}


//
// Base64Decode
//
// Decodes string from base64
//

static int indexBase64[] = {
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
	52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,-1,-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,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
	-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1
};


ULONG
Base64Decode (
  LPTSTR lpszInputString,
  LPTSTR lpOutputBuffer,
  SIZE_T nMaxLength
  )
{
	char chr[3], enc[4];

	int outpos = 0;

	for( int i=0; i<lstrlen(lpszInputString); i+=4 )
	{
		if( outpos+3 >= nMaxLength )
			break;

		enc[0] = indexBase64[lpszInputString[i]];
		enc[1] = indexBase64[lpszInputString[i+1]];
		enc[2] = indexBase64[lpszInputString[i+2]];
		enc[3] = indexBase64[lpszInputString[i+3]];

		if( enc[0] == -1 || enc[1] == -1 )
			break;

		chr[0] = (enc[0] << 2) | (enc[1] >> 4);
		chr[1] = ((enc[1] & 15) << 4) | (enc[2] >> 2);
		chr[2] = ((enc[2] & 3) << 6) | enc[3];

		lpOutputBuffer[outpos++] = chr[0];

		if( enc[2] != -1 )
		{
			lpOutputBuffer[outpos++] = chr[1];
		}

		if( enc[3] != -1 )
		{
			lpOutputBuffer[outpos++] = chr[2];
		}
	}

	lpOutputBuffer[outpos] = 0;
	return outpos;
}