¿Que es base64?

Base64 no es en principio otra cosa mas que un sistema numérico, el cual debido a sus características se emplea en muchos ámbitos de la informática para representar información binaria.

Todos los sistemas de numeración tienen una lista de símbolos que utilizan para representar valores, por ejemplo:

Binario: ‘01′
Decimal: ‘0123456789′
Hexadecimal: ‘0123456789ABCDEF’
y para base64 el conjunto es:
‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/’

Como vemos, es un subconjunto de ASCII, y tiene como particularidad que todos sus caracteres son imprimibles, de hecho 64 es la mayor potencia de 2 que permite ser representada por un subconjunto de caracteres ASCII imprimibles, por eso, si pasamos cualquier información a su representación de base64, tenemos la seguridad de que no tendremos problemas al transmitirla, almacenarla o leerla, incluso aunque esta contega los más remotos caracteres unicode, una imagen o un mp3, ya que para convertir algo a base64 trataremos directamente con los bits.

¿Como codificamos en base64?

Veamos (en este ejemplo flagrantemente robado de Wikipedia) como se codifica la palabra “Man”.

Tenemos que la M es en ASCII el caracter 77 (01001101 en binario), y como el primer paso para nuestra tarea es convertir la información de origen en bits (más sobre esto en un momento), transformamos toda la cadena en una secuencia de unos y ceros, los cuales tomamos en grupos de a seis.

El primero de estos grupos (010011) representa 19, y si tomamos la posición 19 en la lista de símbolos de base64 (empezando a contar desde cero, claro) obtenemos la T, y continuando con este algoritmo llegamos al resultado “TWFu”.

Caracteres de Relleno

base64 se codifica tomando los bytes de tres como entrada en cuatro sextetos, o sea de a 24 bits. Cuando esta cantidad no coincide, completamos con el caracter de relleno “=” los sextetos restantes.

Por ejemplo, si hubiéramos codificado solamente el texto “Ma”, veríamos que no coincide la cantidad de octetos con la de sextetos, luego de “TW” me quedaría 0001, por lo que completo con ocho ceros y obtengo “TWE”. El sexteto vacío que queda se completa con el caraceter “=” quedando como resultado: “TWE=”

Hasta aquí como se codifica. De la misma manera, podría codificar un archivo ejecutable, una imagen, archivos de sonido o simplemente como en este caso, Texto Plano.

Ooops, acabo de decir “texto plano”, pero como bien dice Joel Spolsky (parafraseando a famoso economista que parafraseaba a conocido escritor de ciencia ficción): “No existe tal cosa como el texto plano”. Y acá es donde entra a fastidiarnos la palabra “Encoding”.

Encoding

La representación lógica de una cadena de texto, como puede serlo un String de .net, se puede convertir a bits de muchas maneras. No es lo mismo la representación binaria de texto en ASCII que en Unicode, al respecto recomiendo encarecidamente leer el citado post de Joel Spolsky, pero lo que quiero destacar ahora a los efectos prácticos de comprender el código es que, cuando trabamos con texto, este es para nosotros la representación lógica de la información, la cual se perderá al momento de trabajar directramente con los bits, y como la conversión de esta información lógica a bits puede realizarse de muchas maneras distintas, debemos tener control de este paso al momento de codificar y decodificar texto en y desde base64.

Base64 en .net

Para convertir texto a bytes .net nos ofrece la clase abstracta Encoding y sus derivados concretos, en el ejemplo utilizaremos UTF8Encoding. Si no necesitamos usarlas en grandes iteraciones, podemos obtener instancias de estas clases desde las propiedades estáticas que nos da la clase Encoding, (.UTF8, .UTF7, .ASCII).

Y para obtener los bytes utilizamos el método GetBytes, dado un string “s”:

Encoding.UTF8.GetBytes(s)

Estos bytes se los pasamos a Convert.ToBase64String:

String b64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(s));

y a la inversa, mediante el método GetString de la misma clase de Encoding que hayamos utilizado en la conversión:

String s = Encoding.UTF8.GetString(Convert.FromBase64String(b64));

URLTokenEncode, base64 en ASP.NET

Utilizar parámetros codificados en base64 en un query string nos aporta la seguridad de que no tendremos problemas con los caracteres reservados por HTML, así como la ofuscación de la información ante los usuarios, pero nos encontramos ante el problema de los símbolos “+”, “/” y “=” que tienen un significado dentro de una URI.

Ante esta limitación .net nos da una alternativa a la codificación clásica mediante el método estático UrlTokenEncode de la clase HttpServerUtility, en System.Web:

String b64=HttpServerUtility.UrlTokenEncode(Encoding.UTF8.GetBytes(s));
String s=Encoding.UTF8.GetString(HttpServerUtility.UrlTokenDecode(b64));

Con este método, los caracteres “+” y “/” son reemplazados por “-“ y “_” respectivamente y los simbolos “=” de complemento se reemplazan por un dígito numérico indicando la cantidad de los mismos, de esta manera la cadena “ûï¾x%óaxz” se códifica (en UTF8) como: “w7vDr8K+eCXDs2F4eg==” según el método estándar y con UrlTokenEncode “w7vDr8K-eCXDs2F4eg2”, donde el “2” final representa los “==” al final del resultado estándar y el “-“ reemplaza al “+”.

De esta manera obtenemos una cadena totalmente segura para utilizar en el ámbito web.

Algunos hechos sobre base64

• Base64 no es un método de encriptación. Si bien ofusca la información ante la simple vista no hace falta mucho conocimiento ni pericia para recuperar la información original.
• Base64 “pesa” un 33% más que la información original. Esta ralación está dada por la relación 8 a 6 bits por caracter, (o sea, un caracter de base64 representa menos información que un caracter normal).
• Aparte del nombrado Issue en su utilización en Web, en otros ámbitos también hay caracteres que se tornan problemáticos, por ejemplo en regular expressions, se suelen reemplazar “+” y “/” por “[“ y “]”. Observesé que la codificación que utiliza UrlTokenEncode no serviría en este caso ya que los “+” tienen significado propio en Regular Expression, por lo que habría que escaparlos.
• Insisto: No sirve para encriptar información. No utiliza claves ni certificados, la conversión a la información original es prácticamente directa y no está pensado para este fin.
• Si podemos, en cambio, utilizarlo para guardar o transmitir información previamente cifrada que suele presentar caracteres problemáticos para ser transmitidos o almacenados.

Recently I had the need to decode a Base64 string received from a server and in the process I created an include file that contains both Encode and Decode functions for base64. Use & Abuse as you see fit! Enjoy!
Below is an example of how to use the base64.h include file

# include "base64.h"
vuser_init()
{
 int res;
 // ENCODE
 lr_save_string("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789","plain");
 b64_encode_string( lr_eval_string("{plain}"), "b64str" );
 lr_output_message("Encoded: %s", lr_eval_string("{b64str}") );

 // DECODE
 b64_decode_string( lr_eval_string("{b64str}"), "plain2" );
 lr_output_message("Decoded: %s", lr_eval_string("{plain2}") );

 // Verify decoded matches original plain text
 res = strcmp( lr_eval_string("{plain}"), lr_eval_string("{plain2}") );
 if (res==0) lr_output_message("Decoded matches original plain text");

 return 0;
}

And here’s the actual base64.h include file

/*
Base 64 Encode and Decode functions for LoadRunner
==================================================
This include file provides functions to Encode and Decode
LoadRunner variables. It's based on source codes found on the
internet and has been modified to work in LoadRunner.

Created by Kim Sandell / Celarius - www.celarius.com
*/
// Encoding lookup table
char base64encode_lut[] = {
'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','+','/','='};

// Decode lookup table
char base64decode_lut[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0,62, 0, 0, 0,63,52,53,54,55,56,57,58,59,60,61, 0, 0,
0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0,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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };

void base64encode(char *src, char *dest, int len)
// Encodes a buffer to base64
{
  int i=0, slen=strlen(src);
  for(i=0;i<slen && i<len;i+=3,src+=3)
  { // Enc next 4 characters
    *(dest++)=base64encode_lut[(*src&0xFC)>>0x2];
    *(dest++)=base64encode_lut[(*src&0x3)<<0x4|(*(src+1)&0xF0)>>0x4];
    *(dest++)=((i+1)<slen)?base64encode_lut[(*(src+1)&0xF)<<0x2|(*(src+2)&0xC0)>>0x6]:'=';
    *(dest++)=((i+2)<slen)?base64encode_lut[*(src+2)&0x3F]:'=';
  }
  *dest=#0; // Append terminator
}

void base64decode(char *src, char *dest, int len)
// Encodes a buffer to base64
{
  int i=0, slen=strlen(src);
  for(i=0;i<slen&&i<len;i+=4,src+=4)
  { // Store next 4 chars in vars for faster access
    char c1=base64decode_lut[*src], c2=base64decode_lut[*(src+1)], c3=base64decode_lut[*(src+2)], c4=base64decode_lut[*(src+3)];
    // Decode to 3 chars
    *(dest++)=(c1&0x3F)<<0x2|(c2&0x30)>>0x4;
    *(dest++)=(c3!=64)?((c2&0xF)<<0x4|(c3&0x3C)>>0x2):'';
    *(dest++)=(c4!=64)?((c3&0x3)<<0x6|c4&0x3F):'';
  }
  *dest=#0; // Append terminator
}

int b64_encode_string( char *source, char *lrvar )
// ----------------------------------------------------------------------------
// Encodes a string to base64 format
//
// Parameters:
//		source    Pointer to source string to encode
//		lrvar     LR variable where base64 encoded string is stored
//
// Example:
//
//		b64_encode_string( "Encode Me!", "b64" )
// ----------------------------------------------------------------------------
{
	int dest_size;
	int res;
	char *dest;
	// Allocate dest buffer
	dest_size = 1 + ((strlen(source)+2)/3*4);
	dest = (char *)malloc(dest_size);
	memset(dest,0,dest_size);
	// Encode & Save
	base64encode(source, dest, dest_size);
	lr_save_string( dest, lrvar );
	// Free dest buffer
	res = strlen(dest);
	free(dest);
	// Return length of dest string
	return res;
}

int b64_decode_string( char *source, char *lrvar )
// ----------------------------------------------------------------------------
// Decodes a base64 string to plaintext
//
// Parameters:
//		source    Pointer to source base64 encoded string
//		lrvar     LR variable where decoded string is stored
//
// Example:
//
//		b64_decode_string( lr_eval_string("{b64}"), "Plain" )
// ----------------------------------------------------------------------------
{
	int dest_size;
	int res;
	char *dest;
	// Allocate dest buffer
	dest_size = strlen(source);
	dest = (char *)malloc(dest_size);
	memset(dest,0,dest_size);
	// Encode & Save
	base64decode(source, dest, dest_size);
	lr_save_string( dest, lrvar );
	// Free dest buffer
	res = strlen(dest);
	free(dest);
	// Return length of dest string
	return res;
}

One guy asked me if there is way to insert image in internal HTML code without links in html code. In first moment i answered now and where had many arguments that it is imposible. Then he after some hours of googling havent found any thing. After chating with other guy he told about base64 and img.

Here is example Insert this code in <img src='base64-code'/> and all will work

It is way how to insert base64 converted image in your html code without external links or files.

Q2FuJ3QgcmVhZCB0aGUgdGl0bGU/IE5vIHByb2JsZW0hIElmIHlvdSBoYWQgYW4gYXV0b21h
dGljIGJhc2U2NCBlbmNvZGVyL2RlY29kZXIgdGhlbiBsdWNreSB5b3UgYmVjdWFzZSB0aGUg
bGFuZ3VhZ2Ugb2YgdGhpcyBibG9nIHBvc3QgaXMgZXhhY3RseSB0aGF0OiBiYXNlNjQuIEkg
dGhpbmsgYmFzZTY0IGlzIGEgbGFuZ3VhZ2UgdXNlZCBieSB0aG9zZSBjb21wdXRlciBwcm9n
cmFtbWluZyBuZXJkcywgYnV0IEknbSBub3Qgc3VyZS4gVGhlIHByb2dyYW0gSSdtIHVzaW5n
IHRvIGVuY3J5cHQgdGhlc2UgbWVzc2FnZXMgaXMgY2FsbGVkIExpbmdvZXMuIEl0J3MgcnVu
bmluZyBvbiBteSBmbGFzaCBkcml2ZSB0aHJvdWdoIFBvcnRhYmxlQXBwcy5jb20gbWVudS4g
WWVhaCwgYW5kIHRoYXQncyBvbmx5IGF2YWlsYWJsZSBmb3IgV2luZG93cywgeW91IG1hY3Rh
cmRzLiBTbyBxdWl0IGJlaW5nIGEgbWFjdGFyZCBhbmQgc3dpdGNoIChiYWNrKSB0byBXaW5k
b3dzIGJlY2F1c2UgaXQncyB3YXkgYmV0dGVyIHRoYW4gTWFjcy4gQydtb24hIFlvdSBjYW4n
dCBldmVuIHByZXNzIHRoZSAiZGVsZXRlIiBidXR0b24gdG8gZGVsZXRlIGZpbGVzIG9uIGEg
TWFjISBUaGVuIHdoYXQncyB0aGUgZGVsZXRlIGJ1dHRvbiBmb3I/IEFuZCB5b3UgY2FuJ3Qg
aG9sZCBkb3duIEN0cmwrbW91c2UgY2xpY2sgdG8gc2VsZWN0IGZpbGVzLiBXVEYgQXBwbGU/
IElmIHlvdSd2ZSBub3RpY2VkLCB0aGlzIHBvc3QgY29udGFpbnMgcGVyZmVjdCBncmFtbWFy
IHNvIHlvdSBjYW4gc3RpbGwgcmVhZCBpdC4gSSdtIG5vdCBzdXJlIGlmIEknbGwgZG8gYW55
bW9yZSBiYXNlNjQgcmFudHMsIGJ1dCB0aGF0J3MgYWxsLg==

Hola a todos…..

Tuve la necesidad de encriptar unos datos en base64…. aquí les dejo un ejemplo, para esto yo utilizé una librería llamada base64 , la cual pueden descargarse aquí.

Hecho esto, agregar esta librería a su proyecto y lixto!!!

Este es el código de las clase:

//Clase BAse64Ejemplo

import com.mindprod.base64.Base64u;

public class Base64Ejemplo
{
public Base64Ejemplo()
{
}

public String datoCodificado(String datoCodificar)
{
String encoded=new String();
try
{
byte[] sendBytes = datoCodificar.getBytes( “8859_1″/* encoding */ );
Base64u base64 = new Base64u();
base64.setLineLength( 72 );
encoded = base64.encode( sendBytes );
}
catch(java.io.UnsupportedEncodingException e)
{

}
return encoded;
}

public String datoDecodificado(String datoDecodificar)
{
String decoded=new String();
try
{
Base64u base64 = new Base64u();
base64.setLineLength( 72 );
byte[] reconstitutedBytes = base64.decode(datoDecodificar);
decoded =new String( reconstitutedBytes, “8859_1″/* encoding */ );
}
catch(java.io.UnsupportedEncodingException e)
{

}
return decoded;
}

}

Considering using Base64Encoding() in Java ME for your mobile application? Read this:

http://forums.sun.com/thread.jspa?threadID=5231025

In a nutshell, it may work flawlessly in emulators, but not on actual device!

You have been warned.

Recently I have a big f*cking bug because I forgot this LAW.

Please developers, I saw in my search many and many examples in especial regarding base64 conversions and other stuffs using sun.* packages. AVOID this !

Please read the article below:
Why Developers Should Not Write Programs That Call ’sun’ Packages

You will find some warnings like:

• Different across OS platforms
• One release to another, these classes may be removed
• No documentation available for the sun.* classes
• Java program that directly calls into sun.* packages is not guaranteed to work
• Programs that contain direct calls to the sun.* packages are not 100% Pure Java

and etc…

I’ll put here some easy example using apache libs to do a base64 conversion!

จำไว้ ถ้าจะส่งเมล์ผ่านเว็บ แม้จะ Encoding ด้วย UTF-8  แล้ว แต่มีตัวหนังสือบางตัว ยังจะโผล่ตัวอักษรแปลกๆมาอีกล่ะก็ ไปหาที่เปลี่ยน Content-Transfer-Encoding จาก 8bit เป็น quoted-printable, base64 ซะนะ

The simplest way to convert a byte array into a String in Java is to call the latter’s class constructor. For example:

byte[] theByteArray = new byte {1,2,3};

String theString = new String(theByteArray);

However, a lot of byte data will not form a meaningful string unless encoded. Encoding and decoding is not provided in the standard Java packages. Encoding is provided in the sun.misc.* package but these should not be used as classes under this package can be modified or disappear without warning in new releases of Java. Fortunately, Apache have provided a solution in their commons library. See http://commons.apache.org/index.html.

We will use Base64 encoding as an example. Base64 encodes every 3 bytes of input into 4 bytes of output. It is used to encode photos or audio sent in emails and for usernames and passwords used for webpage authentication. The following code snippet illustrates how we convert a byte array into a Base 64 string:

// Apache commons Import.

import org.apache.commons.codec.binary.Base64;

public class Base64Encoding {

// The Base 64 Encoder.

private Base64 base64Encoder = new Base64();

public void doEncoding(byte[] byteArray)

{

// Using the Base 64 Encoder format the byte array as a Base64 String.

byte[] base64ByteArray = this.base64Encoder.encode(byteArray);

String theString = new String(base64ByteArray);

System.out.println(“The String is ” + theString);

}

}

On OS X you can easily decode base64 strings with the openssl command

openssl base64 -d -in <(echo “dGhpcyBpcyBhIHRlc3QKCg==”)

just drop the ‘-d’ if you want to encode things.

I found this here

*duh, dah lama nggak update blog saking sibuknya (cari alesan)*

Beberapa waktu yang lalu ada permintaan untuk melakukan encoding/decoding ke format base64. karena waktu yang mendesak dan jumlah item requirement yang banyak maka alternatif pertama adalah mencari kode public domain di internet. ternyata tidak satupun yang bisa dipakai (pada saat yang sempit itu). hambatannya bermacam-macam, mulai dari hasil encoding yang tidak sesuai, atau hasil decoding yang beda dengan acuan. setelah duduk sebentar sambil melototin lagi halaman wikipedia yang mendeskripsikan aturan pengkodean basis64 akhirnya langkah terakhir malah bikin sendiri fungsi yang sesuai dengan spek (teks dari/ke base64, binary(variabel bertipe ataupun byte stream) dari/ke base64).

bagi yang berminat menggunakan, dipersilakan menggunakan kode berikut sebebas-bebasnya (pubdom as no warranty for using).

(*
 * auth : Peb Ruswono Aryan
 * desc : base64 encoding/decoding for delphi
 *)
type
  tbytearr = array of byte;

{
	encode64 : Pointer x Nat --> string
	desc: encode binary data to base64 message
}
function encode64( const v: Pointer; vsize: cardinal ): string;
const
  lut64             = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
var
  tribyte           : array[0..2] of byte;
  p                 : PByteArray;
  ci, i             : cardinal;

  function enc3byteto4char( len: integer ): string;
  begin
    result := lut64[1 + tribyte[0] shr 2];
    result := result + lut64[1 + ( ( tribyte[0] and $03 ) shl 4 ) + ( tribyte[1] shr 4 )];
    if len > 1 then
      result := result + lut64[1 + ( tribyte[1] and $0F ) shl 2 + ( tribyte[2] shr 6 )]
    else
      result := result + '=';
    if len > 2 then
      result := result + lut64[1 + tribyte[2] and $3F]
    else
      result := result + '=';
  end;
begin
  p := PByteArray( v );
  ci := 0;
  repeat
    i := 0;
    while i < 3 do begin
      if ci >= vsize then break;
      tribyte[i] := p[ci];
      inc( ci );
      inc( i );
    end;
    result := result + enc3byteto4char( i );
  until ci >= vsize;
end;

{
	decode64 : String --> DynamicArray of byte
	desc: decode base64message to binary data (array of byte)
}
function decode64( msg: string ): TbyteArr;
var
  pb                : array of byte;
  lm, pi            : integer;
  len               : integer;

  function decodechar( c: char; var code: byte ): boolean;
  begin
    result := true;
    case c of
      'A'..'Z': code := ord( c ) - ord( 'A' );
      'a'..'z': code := ord( c ) - ord( 'a' ) + 26;
      '0'..'9': code := ord( c ) - ord( '0' ) + 52;
      '+': code := 62;
      '/': code := 63;
    else
      result := false;
    end;
  end;

  procedure decodeblock( blk: string );
  var
    t, i            : byte;
    w               : dword;
  begin
    w := 0;
    i := 0;
    while i < 4 do begin
      if not decodechar( blk[i + 1], t ) then break;
      w := w shl 6 + t;
      inc( i );
    end;
    result[pi] := ( w shr 16 ) and $FF;
    inc( pi );
    if pi >= len then exit;
    result[pi] := ( w shr 8 ) and $FF;
    inc( pi );
    if pi >= len then exit;
    result[pi] := ( w and $FF );
    inc( pi );
  end;
begin
  len := length( msg ) * 3 div 4;
  lm := length( msg );
  if msg[lm] = '=' then dec( len );
  if msg[lm - 1] = '=' then dec( len );
  setlength( result, len );
  pi := 0;
  repeat
    decodeblock( copy( msg, 1, 4 ) );
    delete( msg, 1, 4 );
  until length( msg ) <= 0;
end;

{
	encode64str : string --> string
	desc: encode text string into base64 message
}
function encode64str( msg: string ): string;
var
  p                 : TByteArr;
  i                 : integer;
begin
  setlength( p, length( msg ) );
  for i := 0 to high( p ) do
    p[i] := ord( msg[i + 1] );
  result := encode64( @p[0], length( p ) );
end;

{
	decode64str : string --> string
	desc: decode base64 message containing text
}
function decode64str( msg: string ): string;
var
  p                 : TByteArr;
  i                 : integer;
begin
  result := '';
  p := decode64( msg );
  for i := 0 to length( p ) do
    result := result + chr( p[i] );
end;

Nunca t haz preguntado como se veria una palabra en codigo binario o hexadecimal, o haz querido acortarte los pasos en esos problemas del flag register en ensamblador….. yo si, palschou tiene una herramienta online que te permite convertir texto o numero a binario y visceversa.

kamikazikid en

binario

01101011 01100001 01101101 01101001 01101011 01100001 01111010 01101001 01101011 01101001

01100100

VISITA binary translator

For all the really nice stuff Objective-C lets you do on the iPhone, there are many, many holes left for very common tasks.

One of those tasks is Base64 encoding.

Base64 encoding is used to convert binary data into text that can be transmitted using HTTP (like, say, for embedding images in email) or for somewhat obfuscating user ids and passwords to be sent “in the clear” over HTTP (like for Basic Authentication).

Without much further ado, I present one of a gagillion implementations of Base64 encoding in C:

static char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789"
"+/";

int encode(unsigned s_len, char *src, unsigned d_len, char *dst)
{
unsigned triad;

for (triad = 0; triad < s_len; triad += 3)
{
unsigned long int sr;
unsigned byte;

for (byte = 0; (byte<3)&&(triad+byte<s_len); ++byte)
{
sr <<= 8;
sr |= (*(src+triad+byte) & 0xff);
}

sr <<= (6-((8*byte)%6))%6; /*shift left to next 6bit alignment*/

if (d_len < 4) return 1; /* error - dest too short */

*(dst+0) = *(dst+1) = *(dst+2) = *(dst+3) = '=';
switch(byte)
{
case 3:
*(dst+3) = base64[sr&0x3f];
sr >>= 6;
case 2:
*(dst+2) = base64[sr&0x3f];
sr >>= 6;
case 1:
*(dst+1) = base64[sr&0x3f];
sr >>= 6;
*(dst+0) = base64[sr&0x3f];
}
dst += 4; d_len -= 4;
}

return 0;

}

And here is how one may transmit a user id and password (using NSURLConnection) to establish a connection using Basic Authentication:

myApp.loginString    = (NSMutableString*)[[NSUserDefaults standardUserDefaults] stringForKey:kloginKey];
myApp.passwordString = (NSMutableString*)[[NSUserDefaults standardUserDefaults] stringForKey:kpasswordKey];

NSMutableString *dataStr = (NSMutableString*)[@"" stringByAppendingFormat:@"%@:%@", myApp.loginString, myApp.passwordString];

NSData *encodeData = [dataStr dataUsingEncoding:NSUTF8StringEncoding];
char encodeArray[512];

memset(encodeArray, '\0', sizeof(encodeArray));

// Base64 Encode username and password
encode([encodeData length], (char *)[encodeData bytes], sizeof(encodeArray), encodeArray);

dataStr = [NSString stringWithCString:encodeArray length:strlen(encodeArray)];
myApp.authenticationString = [@"" stringByAppendingFormat:@"Basic %@", dataStr];

// Create asynchronous request
NSMutableURLRequest * theRequest=(NSMutableURLRequest*)[NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://www.somewebdomain.com"] cachePolicy:NSURLRequestUseProtocolCachePolicy timeoutInterval:60.0];
[theRequest addValue:myApp.authenticationString forHTTPHeaderField:@"Authorization"];

NSURLConnection * theConnection=[[NSURLConnection alloc] initWithRequest:theRequest delegate:self];

[UIApplication sharedApplication].networkActivityIndicatorVisible = YES;
if (theConnection) {
receivedData = [[NSMutableData data] retain];
}
else {
[myApp addTextToLog:@"Could not connect to the network" withCaption:@"MyApp"];
}

Hopefully, this will help people get cracking that were having a hard time getting a handle on the fact that Objective-C is really C – albeit with funky class extensions.

Hi friends,

Lot of us already know howto send attachments in mails using shellscript. Lot of us already wrote these kind of script. Here is one more script to do the same thing. I already added all the details in the script itself. It is self explainable. If somebody wants, take it.

#!/bin/sh
# generatemail.sh - script to send mail with multiple attachments.
# Wrote By: me! mohan43u.
# Date: Thu Mar 06 11:56:12 IST 2009
# License: Its in public domain. Use it whatever way you can.

USAGE="USAGE:

	generatemail.sh [-t tolist] [-s subject] [-e encodetype]
		[-h] ATTACH_FILE1 ATTACH_FILE2 ...
"
HELP="${USAGE}
OPTIONS:
	-t tolist	comma seperated e-mail addresses
				(Default: current userid).

	-s subject	Subject line (Default: 'test mail from generatemail.sh
				 script')

	-e encodetype	Encoding type (x-uuencode/base64). only GNU uuencode
			can encode in base64. If you are using this script
			in Old school unixes(solaris, HP-UX, AIX, etc) use
			only 'x-uuencode'. Linux can handle both types
			(Default: x-uuencode).

	-h		Print this Help text

This script will read standard input as a mail body and takes filenames as
arguments to generate a preformatted mail content in satndard output. you can
simply pipe the output to any MTA (sendmail, postfix etc.,) to send a mail
with attachments.

Eg:
	$ generatemail.sh -t foo@bar.com -s 'mail with attachments' file1 \
		file2 | /usr/sbin/sendmail -v -i -t
	hi foo,
		I attached file1 and file2 with this mail. Take a look at it.

	Thanks,
	ben.
	[CTRL-D]
	$

	This above command line will attach file1 and file2 and send a mail
	to foo@bar.com. The files file1 and file2 will be encoded in
	'x-uuencode' and attached with this mail.
"

TO="${USER}"
SUBJECT="testmail from generatemail.sh script"
BOUNDARY="`date +'%G%m%d%H%M%S'`"
ENCODE_TYPE="x-uuencode"

while getopts 't:s:e:h' OPTIONS
do
	case "${OPTIONS}" in
	t) TO="${OPTARG}";;
	s) SUBJECT="${OPTARG}";;
	e) ENCODE_TYPE="${OPTARG}";;
	h) echo "${HELP}" && exit 0;;
	\?) echo "${USAGE}" && exit 1;;
	esac
done

SHIFT_COUNT=`expr "${OPTIND}" - 1`
shift "${SHIFT_COUNT}"

header()
{
	echo "To: ${TO}"
	echo "Subject: ${SUBJECT}"
	echo "Mime-Version: 1.0"
	echo "Content-Type: multipart/mixed; boundary=\"${BOUNDARY}\""
	echo "Content-Disposition: inline"
	echo "User-Agent: generatemail.sh 0.1"
}
create_octet_part()
{
	BASENAME=`basename "${1}"`
	FILE="${1}"

	if test "${ENCODE_TYPE}" = "base64"
	then
		ENCODED_MESSAGE=`uuencode -m "${FILE}" "${BASENAME}" \
		| egrep -v '^begin|^='`
	else
		ENCODED_MESSAGE=`uuencode "${FILE}" "${BASENAME}"`
	fi

	echo "Content-Type: application/octet-stream"
	echo "Content-Disposition: attachment; filename=\"${BASENAME}\""
	echo "Content-Transfer-Encoding: ${ENCODE_TYPE}"
	echo
	echo "${ENCODED_MESSAGE}"
	echo
}
create_text_part()
{
	echo "Content-type: text/plain; charset=utf-8"
	echo "Content-Disposition: inline"
}

# Main

BODY="`cat`"
header
echo
echo "--${BOUNDARY}"
create_text_part
echo
echo "${BODY}"
echo
for FILENAME
do
	echo "--${BOUNDARY}"
	create_octet_part "${FILENAME}"
done
echo "--${BOUNDARY}--"

It turned out that it didn’t need this after all, but thought I’d post it here anyway …

The use case was to base64-encode a URL so that it could be passed as a query parameter to a login page.  The login routes through a third page and returns to the logn page, which redirects the client back to the original URL which was base64-encoded.  Without the encoding, the third page could mangle the original URL.

#!/usr/bin/python

while sys.stdin:
    print binascii.b2a_base64(sys.stdin.readline().rstrip()) ,
    sys.stdout.flush()

Just a simple implementation of the base64 encryption algorithm in C. I haven’t implemented the decryption, because I was bored :p , but it’s easy you could do that by yourself.
Code follows ,

/*******************************************
        |base64 testcase|
        -----------------
          tes -- > dGVz
*******************************************/

#include <stdio.h>
#include <stdlib.h>
#define BITMASK(n) ((1u << n) - 1)      /* bit mask of n ones ex. 1111, 11111 ... */

/* function prototypes */
void encode( char *buffer, int len);
void Usage(void);

static const char charset[]=
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

int main(int argc, char *argv[]) {

        FILE *input;
        char temp[3];
        int number = 0;
        int c;

        if ( argc != 2) {
                Usage();
                exit(EXIT_FAILURE);
        }

        if ( (input = fopen(argv[1], "r")) == NULL) {
                fprintf(stderr, "Couldn't open file %s\n", argv[1]);
                exit(EXIT_FAILURE);
        }

        printf("\n----------------------------------------------");
        printf("\nThe base64 encrypted text is the following: \n");
	printf("----------------------------------------------\n");

	while( (c = fgetc(input) )!=EOF) {

		temp[number] = c;
		++number;
		if ( number == 3) {
			encode( temp, 3);
			number = 0;
		}
	}
	if (number != 0) {
		if ( number == 1)
			temp[1] = 0;

		temp[2] = 0;
		encode( temp, number);
	}

	fclose(input);
	printf("\n\n\n\n\n");
	printf("****************************************************\n");
	printf("\tThanks for using our base64 algo !!!\n");
	printf("****************************************************\n");
	printf("\n\n");

	exit(EXIT_SUCCESS);
}

void encode( char *buffer, int len) {

	char output[4] = {0,0,0,0};
	int i;

	output[0] = charset[buffer[0] >> 2];
	output[1] = charset[(buffer[0] & BITMASK(2)) << 4 | (buffer[1] >> 4)];
	output[2] = (len > 1) ? charset[ (buffer[1] & BITMASK(4)) << 2 | (buffer[2] >> 6)] : '=';
	output[3] = (len > 2) ? charset[  buffer[2] & BITMASK(6)] : '=';					

	for ( i=0; i<4; i++)
		printf("%c", output[i]);
}

void Usage(void) {

	puts("Usage: ./base64 <input_file>");
	puts("Quitting ... \n");
}

Save it with a .c extension and compile it like:
Command: gcc -Wall -pedantic -std=c99 -o <my_file> <my_file>.c

If no errors occur, run it giving a text file as a parameter:
Command: ./<my_file> <to_be_encrypted_file>

Encode yourelves people :p !!
Comment if you have any questions or fixes!

I’m zooming in the process of converting plaintext to a point in elliptic curve. And from the examples of Crypto++ usage, the plaintext is encoded to a base64 after it’s being encrypted, and decoded before it’s being decrypted.

The inheritance diagram for Base64Decoder:

From Research

The encoding process:

From Research

The codes:

// Encryption
Encryptor.Encrypt( rng, reinterpret_cast( PlainText.c_str() ), PlainTextLength, CipherText );

// Base 64 Encoding
CryptoPP::Base64Encoder Encoder;
Encoder.Put( CipherText, CipherTextLength );
Encoder.MessageEnd();

// Scratch for Base 64 Encoded Ciphertext
unsigned int EncodedTextLength = Encoder.MaxRetrievable();
byte* EncodedText = new byte[ EncodedTextLength + 1 ]; /* + 1 for NULL termination */
if( NULL == EncodedText ) { throw std::string( “Base64 EncodedText Allocation Failure” ); }
::memset( EncodedText, 0xFB, EncodedTextLength );
EncodedText[ EncodedTextLength ] = ”;

// Base 64 Ciphertext
Encoder.Get( EncodedText, EncodedTextLength );

// Diagnostics
std::cout << “Base 64 Encoded Ciphertext (” << EncodedTextLength << ” bytes):”;
std::cout << std::endl << EncodedText << std::endl;

// Base 64 Decoding
CryptoPP::Base64Decoder Decoder;
Decoder.Put( EncodedText, EncodedTextLength );
Decoder.MessageEnd();

// Scratch for Base 64 Decoded Ciphertext
unsigned int DecodedTextLength = Decoder.MaxRetrievable();
byte* DecodedText = new byte[ DecodedTextLength ];
if( NULL == DecodedText ) { throw std::string( “Base64 DecodedText Allocation Failure” ); }
::memset( DecodedText, 0xFB, DecodedTextLength );

// Ciphertext is no longer Encoded
Decoder.Get( DecodedText, DecodedTextLength );

//
// At this point, RecoveredText64 = CipherText
//
assert( DecodedTextLength == CipherTextLength );
assert( 0 == ::memcmp( DecodedText, CipherText, CipherTextLength ) );

// Scratch for Decryption
unsigned int RecoveredTextLength = Decryptor.MaxPlaintextLength( CipherTextLength );
if( 0 == RecoveredTextLength ) { throw std::string(“ciphertextLength is not valid (too long or too short)”); }

// Decryption Buffer
char* RecoveredText = new char[ RecoveredTextLength ];
if( NULL == RecoveredText ) { throw std::string( “RecoveredText CipherText Allocation Failure” ); }
::memset( RecoveredText, 0xFB, RecoveredTextLength );

// Decryption
Decryptor.Decrypt( rng, CipherText, CipherTextLength, reinterpret_cast( RecoveredText ) );

// Diagnostics
std::cout << “Recovered text (” << RecoveredTextLength << ” bytes):” << std::endl;
std::cout << “‘” << RecoveredText << “‘” << std::endl;

Questions:

1. Why should the plaintext be encoded to base64?
2. Why the plaintext is encoded after it’s encrypted not the vice versa?

I’m zooming in the process of converting plaintext to a point in elliptic curve. And from the examples of Crypto++ usage, the plaintext is encoded to a base64 after it’s being encrypted, and decoded before it’s being decrypted.

The inheritance diagram for Base64Decoder:

From Research

The encoding process:

From Research

The codes:

// Encryption
Encryptor.Encrypt( rng, reinterpret_cast( PlainText.c_str() ), PlainTextLength, CipherText );

// Base 64 Encoding
CryptoPP::Base64Encoder Encoder;
Encoder.Put( CipherText, CipherTextLength );
Encoder.MessageEnd();

// Scratch for Base 64 Encoded Ciphertext
unsigned int EncodedTextLength = Encoder.MaxRetrievable();
byte* EncodedText = new byte[ EncodedTextLength + 1 ]; /* + 1 for NULL termination */
if( NULL == EncodedText ) { throw std::string( “Base64 EncodedText Allocation Failure” ); }
::memset( EncodedText, 0xFB, EncodedTextLength );
EncodedText[ EncodedTextLength ] = ”;

// Base 64 Ciphertext
Encoder.Get( EncodedText, EncodedTextLength );

// Diagnostics
std::cout << “Base 64 Encoded Ciphertext (” << EncodedTextLength << ” bytes):”;
std::cout << std::endl << EncodedText << std::endl;

// Base 64 Decoding
CryptoPP::Base64Decoder Decoder;
Decoder.Put( EncodedText, EncodedTextLength );
Decoder.MessageEnd();

// Scratch for Base 64 Decoded Ciphertext
unsigned int DecodedTextLength = Decoder.MaxRetrievable();
byte* DecodedText = new byte[ DecodedTextLength ];
if( NULL == DecodedText ) { throw std::string( “Base64 DecodedText Allocation Failure” ); }
::memset( DecodedText, 0xFB, DecodedTextLength );

// Ciphertext is no longer Encoded
Decoder.Get( DecodedText, DecodedTextLength );

//
// At this point, RecoveredText64 = CipherText
//
assert( DecodedTextLength == CipherTextLength );
assert( 0 == ::memcmp( DecodedText, CipherText, CipherTextLength ) );

// Scratch for Decryption
unsigned int RecoveredTextLength = Decryptor.MaxPlaintextLength( CipherTextLength );
if( 0 == RecoveredTextLength ) { throw std::string(“ciphertextLength is not valid (too long or too short)”); }

// Decryption Buffer
char* RecoveredText = new char[ RecoveredTextLength ];
if( NULL == RecoveredText ) { throw std::string( “RecoveredText CipherText Allocation Failure” ); }
::memset( RecoveredText, 0xFB, RecoveredTextLength );

// Decryption
Decryptor.Decrypt( rng, CipherText, CipherTextLength, reinterpret_cast( RecoveredText ) );

// Diagnostics
std::cout << “Recovered text (” << RecoveredTextLength << ” bytes):” << std::endl;
std::cout << “‘” << RecoveredText << “‘” << std::endl;

Questions:

1. Why should the plaintext be encoded to base64?
2. Why the plaintext is encoded after it’s encrypted not the vice versa?

I’m zooming in the process of converting plaintext to a point in elliptic curve. And from the examples of Crypto++ usage, the plaintext is encoded to a base64 after it’s being encrypted, and decoded before it’s being decrypted.

The inheritance diagram for Base64Decoder:

From Research

The encoding process:

From Research

The codes:

// Encryption
Encryptor.Encrypt( rng, reinterpret_cast( PlainText.c_str() ), PlainTextLength, CipherText );

// Base 64 Encoding
CryptoPP::Base64Encoder Encoder;
Encoder.Put( CipherText, CipherTextLength );
Encoder.MessageEnd();

// Scratch for Base 64 Encoded Ciphertext
unsigned int EncodedTextLength = Encoder.MaxRetrievable();
byte* EncodedText = new byte[ EncodedTextLength + 1 ]; /* + 1 for NULL termination */
if( NULL == EncodedText ) { throw std::string( “Base64 EncodedText Allocation Failure” ); }
::memset( EncodedText, 0xFB, EncodedTextLength );
EncodedText[ EncodedTextLength ] = ”;

// Base 64 Ciphertext
Encoder.Get( EncodedText, EncodedTextLength );

// Diagnostics
std::cout << “Base 64 Encoded Ciphertext (” << EncodedTextLength << ” bytes):”;
std::cout << std::endl << EncodedText << std::endl;

// Base 64 Decoding
CryptoPP::Base64Decoder Decoder;
Decoder.Put( EncodedText, EncodedTextLength );
Decoder.MessageEnd();

// Scratch for Base 64 Decoded Ciphertext
unsigned int DecodedTextLength = Decoder.MaxRetrievable();
byte* DecodedText = new byte[ DecodedTextLength ];
if( NULL == DecodedText ) { throw std::string( “Base64 DecodedText Allocation Failure” ); }
::memset( DecodedText, 0xFB, DecodedTextLength );

// Ciphertext is no longer Encoded
Decoder.Get( DecodedText, DecodedTextLength );

//
// At this point, RecoveredText64 = CipherText
//
assert( DecodedTextLength == CipherTextLength );
assert( 0 == ::memcmp( DecodedText, CipherText, CipherTextLength ) );

// Scratch for Decryption
unsigned int RecoveredTextLength = Decryptor.MaxPlaintextLength( CipherTextLength );
if( 0 == RecoveredTextLength ) { throw std::string(“ciphertextLength is not valid (too long or too short)”); }

// Decryption Buffer
char* RecoveredText = new char[ RecoveredTextLength ];
if( NULL == RecoveredText ) { throw std::string( “RecoveredText CipherText Allocation Failure” ); }
::memset( RecoveredText, 0xFB, RecoveredTextLength );

// Decryption
Decryptor.Decrypt( rng, CipherText, CipherTextLength, reinterpret_cast( RecoveredText ) );

// Diagnostics
std::cout << “Recovered text (” << RecoveredTextLength << ” bytes):” << std::endl;
std::cout << “‘” << RecoveredText << “‘” << std::endl;

Questions:

1. Why should the plaintext be encoded to base64?
2. Why the plaintext is encoded after it’s encrypted not the vice versa?

I’m zooming in the process of converting plaintext to a point in elliptic curve. And from the examples of Crypto++ usage, the plaintext is encoded to a base64 after it’s being encrypted, and decoded before it’s being decrypted.

The inheritance diagram for Base64Decoder:

From Research

The encoding process:

From Research

The codes:

// Encryption
Encryptor.Encrypt( rng, reinterpret_cast( PlainText.c_str() ), PlainTextLength, CipherText );

// Base 64 Encoding
CryptoPP::Base64Encoder Encoder;
Encoder.Put( CipherText, CipherTextLength );
Encoder.MessageEnd();

// Scratch for Base 64 Encoded Ciphertext
unsigned int EncodedTextLength = Encoder.MaxRetrievable();
byte* EncodedText = new byte[ EncodedTextLength + 1 ]; /* + 1 for NULL termination */
if( NULL == EncodedText ) { throw std::string( “Base64 EncodedText Allocation Failure” ); }
::memset( EncodedText, 0xFB, EncodedTextLength );
EncodedText[ EncodedTextLength ] = ”;

// Base 64 Ciphertext
Encoder.Get( EncodedText, EncodedTextLength );

// Diagnostics
std::cout << “Base 64 Encoded Ciphertext (” << EncodedTextLength << ” bytes):”;
std::cout << std::endl << EncodedText << std::endl;

// Base 64 Decoding
CryptoPP::Base64Decoder Decoder;
Decoder.Put( EncodedText, EncodedTextLength );
Decoder.MessageEnd();

// Scratch for Base 64 Decoded Ciphertext
unsigned int DecodedTextLength = Decoder.MaxRetrievable();
byte* DecodedText = new byte[ DecodedTextLength ];
if( NULL == DecodedText ) { throw std::string( “Base64 DecodedText Allocation Failure” ); }
::memset( DecodedText, 0xFB, DecodedTextLength );

// Ciphertext is no longer Encoded
Decoder.Get( DecodedText, DecodedTextLength );

//
// At this point, RecoveredText64 = CipherText
//
assert( DecodedTextLength == CipherTextLength );
assert( 0 == ::memcmp( DecodedText, CipherText, CipherTextLength ) );

// Scratch for Decryption
unsigned int RecoveredTextLength = Decryptor.MaxPlaintextLength( CipherTextLength );
if( 0 == RecoveredTextLength ) { throw std::string(“ciphertextLength is not valid (too long or too short)”); }

// Decryption Buffer
char* RecoveredText = new char[ RecoveredTextLength ];
if( NULL == RecoveredText ) { throw std::string( “RecoveredText CipherText Allocation Failure” ); }
::memset( RecoveredText, 0xFB, RecoveredTextLength );

// Decryption
Decryptor.Decrypt( rng, CipherText, CipherTextLength, reinterpret_cast( RecoveredText ) );

// Diagnostics
std::cout << “Recovered text (” << RecoveredTextLength << ” bytes):” << std::endl;
std::cout << “‘” << RecoveredText << “‘” << std::endl;

Questions:

1. Why should the plaintext be encoded to base64?
2. Why the plaintext is encoded after it’s encrypted not the vice versa?