Foro de elhacker.net

var Base64_chars="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

var Base64_nostd="9ryoAuwh4RvMDPYKNltWUTaEqnBmbcSZFxfGg7iJj6QsVkOXzdH0C1p2e35L8I+/=";

/*****************************************************************************
Base64: My_btoa y My_atob

 2012-07-02


Implementación de Base64 en javascript.

http://devel.cable-modem.org/

Este código es de dominio público (sin derechos de autor).
Puedes hacer lo que desees con él.


*****************************************************************************/



function My_atob(base64_data, table)
{
 var binary64="";
 var binary="";

 if(typeof(base64_data)!="string")return "";
 if(!(base64_data.length>0))return "";


 var tmp="";
 var c="";
 for(var x=0;x<base64_data.length;x++)
 {
  c=base64_data.charAt(x);

  //These padding characters should be ignored:
  ///
    if(c=="=" || c==" " || c=="\t" || c=="\r" || c=="\n")continue;

  //Otherwise, look for the index in which the specified character is.
  //That will be the value of the Base64 current character.
  else
   c=table.indexOf(c);

  binary64+=StrPad(str=c.toString(2),padchar="0",paddedstrlen=6,direction="l");
  
  if(binary64.length>=8)
  {
   binary+=String.fromCharCode(parseInt(binary64.substring(0,8),2));

   binary64=binary64.substring(8,binary64.length);
  }
 }

 return binary;
}






//Converts a raw "binary" data string into Base64 data:
///
function My_btoa(binary_data, table)
{
 var Base64_TBL=table.split("");

 //This will contain our resulting converted data
 ///
  var base64="";

 //Check that the data is a string and that its length is not 0:
 ///
  if(typeof(binary_data)!="string")return "";
  if(!(binary_data.length>0))return "";


 //Temporary 32-bit DWORD:
 ///
  var tmp="";


 //4-byte temporary Base64 chunk for each 3 bytes of data, and/or plus padding if necessary:
 ///
  var tm2="";

 //Number of '=' padding characters, to avoid generating Base64 charactes that should be padding to begin with:
 //Number of '=' characters if there is no further data in size divisible exactly by 3:
 ///
  var padcount="";


 //This loop advances in groups of 3 because 3 "binary" letters
 //produce 4 Base64 letters:
 ///
  for(var x=0;x<binary_data.length;x+=3)
  {
   //INIT: Read a DWORD safely byte by byte, with "memory boundary checking"
   //INIT: Read a DWORD safely byte by byte, with "memory boundary checking"
   //INIT: Read a DWORD safely byte by byte, with "memory boundary checking"
   //INIT: Read a DWORD safely byte by byte, with "memory boundary checking"
   ///
    tmp=binary_data.charCodeAt(x)<<24;         //bits 31-24

    if(x+1<binary_data.length)
    tmp|=binary_data.charCodeAt(x+1)<<16;   //bits 23-16
    else padcount++;                    //If there's no data, increase padding and this bit group is 0 automatically

    if(x+2<binary_data.length)
    tmp|=binary_data.charCodeAt(x+2)<<8;    //bits 15-8
    else padcount++;                    //If there's no data, increase padding and this bit group is 0 automatically

                                               //bits 7-0 are 0 always

                                              
   //END:  Read a DWORD safely byte by byte, with "memory boundary checking"
   //END:  Read a DWORD safely byte by byte, with "memory boundary checking"
   //END:  Read a DWORD safely byte by byte, with "memory boundary checking"
   //END:  Read a DWORD safely byte by byte, with "memory boundary checking"


    //Shift 8 bits left to re-align all bit values in an order
    //proper for the 6 bits of Base64.
    //
    //This will NOT discard the first 2 bits of the DWORD, but anyway
    //the bits of the next byte of data, if present (byte 4),
    //belong to the next group of 3 bytes and are useless for the
    //current 32-bit run:
    ///
     tmp>>=8;   //tmp is a 32-bit DWORD here


    //"Flush" past, now useless data, before using the buffer again (might not be necessary
    //in C or assembly since the data in those languages will always be overwritten either by
    //data or padding; but it is required in javascript because the string cannot be handled
    //so freely in such language).
    ///
     tm2="";


     var sshl=6;  //I thought that this bit shifting was going to be dynamic, but after the adjusting above
                  //and the bit masking below inside the loop, it isn't necessary at all.


     for(var y=0;y<4;y++)
     {
      //Get bits 31-24, then 23-16 and 15-8 and use them as index for the third, second
      //and first Base64 characters, respectively:
      ///

      //Save the corresponding Base64 character, backwards, or if we are in a range in which
      //we previously detected that there was no data available for bytes 2 of 3 and/or 3 of 3,
      //just add padding.
      //
      //In other words, if the count of required padding characters is 0 (3 original bytes were
      //present for this loop run), or if the count of padding characters is not 0 and y is
      //in a range above/outside that of the padding characters to generate, then save a Base64
      //indexed character.
      //
      //Otherwise, we are in a byte range for padding, and we must generate and save a padding character
      //(it could and should only happen at the very end of the whole data buffer):
      ///
       if(padcount==0 || (padcount!=0 && y>padcount-1))
       {
        tm2=Base64_TBL[tmp&63]+tm2;
       }
        else tm2=tm2+"=";


      //Keep shifting bits. We have saved backwards because in this way we
      //reduce the amount of bit shifting and bit masking required to get
      //the 6 bits required for each Base64 character, and still we can get
      //each Base64 character as soon as possible, as soon as its offset
      //is available to us.
      ///
       tmp>>=6;
     }

   //Save this chunk of Base64 characters:
   ///
    base64+=tm2;
  }

 return base64;
}






function StrPad(str,padchar,paddedstrlen,direction)
{
 //If no direction was specified, the default action is
 //to pad leftmost:
 ///
  if(!direction)direction="l";

 
 //Don't allow empty padding character variable or a bad final padded length
 //because it would cause an infinite loop:
 ///
  if(typeof(paddedstrlen)!="number" || typeof(padchar)!="string")return str;
  if(!(padchar.length>0) || paddedstrlen<=0)return str;


 if(direction.toLowerCase()=="r")
 {
   while(str.length<paddedstrlen)
   {
    str=str+padchar.charAt(0);
   }
 }
  else
  {
    while(str.length<paddedstrlen)
    {
     str=padchar.charAt(0)+str;
    }
  }


 return str;
}