Codificacion en Base64

[Jorge Jaurena]

Hola a todos.
Estoy buscando alguna funcion que me permita codificar y decodificar archivos xml en base64 para Harbour y no la encuentro, quizas alguien lo tenga y me lo pueda facilitar.
Muchas gracias

Jorge Jaurena

[Antonio Linares]

Jorge,

Prueba con las funciones hb_base64decode() y hb_base64encode() de Harbour

[JmGarcia]

Estoy buscando alguna funcion que me permita codificar y decodificar archivos xml...

Perdón por la pregunta: ¿ Por que hay que codificar/decodificar archivos xml ?
Gracias por la respuesta.

[Jorge Jaurena]

Estoy usando Harbour 1.0.1 y me parece que no estan, ¿como puedo incorporarlas? Gracias.

Jorge Jaurena

PD JmGarcia: necesito codificarlos en base64 porque el web server al que debo comunicarme asi me lo pide, solo por eso. Saludos

[Antonio Linares]

Jorge,

Lo mas sencillo es que actualices Harbour

[Jorge Jaurena]

Si, eso pense de entrada, pero tengo temor de que no me empiece a compilar algunas cosas bien, intento, y si no puedo lograr que ande bien tendre
que volver a molestar por aqui.
Muchas Gracias.

Jorge Jaurena

[Antonio Linares]

Jorge,

La versión actual suele ser la más completa y probada. Especialmente en desarrollos de código abierto.

Asi que todo debería compilar bien, salvo que tengas que hacer algún cambio pequeño y aqui te ayudaremos a solucionarlo en caso de ser necesario.

[jponce]

Esta me funciona a mi excelente

Pones una variable
cXml := Base64toStr(oNodo:CData)


y aca el codigo


// otras
* BASE64.PRG
* Creation le 30/12/2008
* Auteur Badara Thiam
* Derniere modification le 25/09/2009 à 16:35:37

* Modification du 25/09/2009 effectuée dans StrToBase64()
* Résout une erreur de conversion apparaissant lorsque :
* ( le nombre de caractères dans la chaine multiplié par n'est pas un multiple de 6

*******************
FUNCTION StrToBase64( cTexte )
*******************
* Conversion en base 64 de la chaine cTexte

* Un alphabet de 65 caractères est utilisé pour permettre la représentation de 6 bits par caractère :
* "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

* Le '=' (65e caractère) est utilisé dans le processus de codage pour les caractères finaux.

LOCAL cTexte64 := ""
LOCAL X
LOCAL cHex
DO WHILE !( cTexte == "" )
cHex := ""

* Le processus de codage représente des groupes de 24 bits de données en entrée par une chaîne en sortie de 4 caractères codés.
* En procédant de gauche à droite, un groupe de 24 bits est créé en concaténant 3 octets (8 bits par octet).
FOR X := 1 TO 3
* Conversion de chaque caractère en chaine binaire de 8 octets
cHex += CarToBin( LEFT(cTexte, 1) )
IF LEN(cTexte) > 1
cTexte := SUBSTR(cTexte, 2)
ELSE
cTexte := ""
EXIT
ENDIF
NEXT X

* Ces 24 bits (ici contenus dans cHex, ou au moins un multiple) sont traités comme 4 groupes concaténés de 6 bits chacun convertis
* en un unique caractère dans l'alphabet de la base 64.

* Chaque groupe de 6 bits est utilisé comme index dans la table des caractères de la base 64.
* Le caractère référencé par l'index correspondant est utilisé comme codage de ce groupe de 6 bits.

FOR X := 1 TO 4

IF SUBSTR(cHex, ( (X - 1) * 6) + 1 ) == ""
cTexte64 += REPLICATE("=", 4 - X + 1)
EXIT
ELSE

* Un traitement spécial est effectué si moins de 24 bits sont disponibles à la fin des données
* à coder. Aucun bit ne restant non-codé,
* si moins de 24 bits sont disponibles alors des bits à zéro sont ajoutés à la droite des données
* pour former un nombre entier de groupes de 6 bits.
IF LEN( cHex ) % 6 > 0
* Ajout des bits à zéro
cHex += REPLICATE("0", 6 - ( LEN( cHex ) % 6 ) )
ENDIF


cTexte64 += Carac64( "00" + SUBSTR(cHex, ( (X - 1) * 6) + 1, 6 ) )
ENDIF
NEXT X
ENDDO
RETURN cTexte64

*********************
FUNCTION Base64ToStr( cTexte64 )
*********************
* décodage d'un texte codé en base 64
LOCAL cTexte := ""
LOCAL X
LOCAL cHex
LOCAL cCar
DO WHILE !( cTexte64 == "" )
try
cCar := LEFT(cTexte64,4)
catch
end
cHex := ""
try
FOR X := 1 TO 4
IF SUBSTR(cCar, X, 1 ) != "="
cHex += Hex64( SUBSTR(cCar, X, 1 ) )
ELSE
EXIT
ENDIF
NEXT X
catch
end

FOR X := 1 TO 3
IF SUBSTR(cHex, ( (X - 1) * + 1 ) == ""
EXIT
ELSE
cTexte += BinToCar( SUBSTR(cHex, ( (X - 1) * + 1, 8 ) )
ENDIF
NEXT X

IF LEN(cTexte64) > 4
cTexte64 := SUBSTR(cTexte64, 5)
ELSE
cTexte64 := ""
ENDIF
ENDDO
RETURN cTexte

****************
FUNCTION Carac64( cBin )
****************
* Renvoie le caractère correspondant en base 64
LOCAL nPos := ASC( BinToCar( @cBin ) ) + 1
RETURN SUBSTR( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", nPos, 1)

**************
FUNCTION Hex64( carac64 )
**************
* Renvoie le caractère correspondant en base 64
LOCAL cCodeAsc := CHR( AT(carac64, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ) -1 )
RETURN SUBSTR( CarToBin( @cCodeAsc ) , 3, 6)

*****************
FUNCTION CarToBin( carac, lInverse )
*****************
* Renvoie le caractère correspondant dans une chaine binaire (composée de 0 et 1) de 8 bits

#define cHexa "0123456789ABCDEF"
#define aBin {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", ;
"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" }
LOCAL cToHex

IF EMPTY( lInverse )
* Retourne la chaine binaire en ayant reçu le caractère ASCII
cToHex := str2Hex( carac )
RETURN aBin[ AT( LEFT(cToHex,1), cHexa ) ] + aBin[ AT( SUBSTR(cToHex,2), cHexa ) ]
ELSE
* Retourne le caractère ASCII en ayant reçu la chaine binaire
cToHex := SUBSTR(cHexa, ASCAN(aBin, LEFT(carac,4 ) ), 1 ) ;
+ SUBSTR(cHexa, ASCAN(aBin, SUBSTR(carac,5,4 ) ), 1 )
RETURN Hex2str( cToHex )
ENDIF
RETURN NIL

*****************
FUNCTION BinToCar( cBin )
*****************
RETURN CarToBin( @cBin, .T. )

[Jorge Jaurena]

Muchas gracias jponce por tu aporte, pero a pesar de que estas funciones anden correctamente estoy convencido de que Antonio tiene razon en la necesidad de mantener el lenguaje actualizado, y asi debe ser ya que por lo menos en mi caso Yo vivo de esto y mis clientes me pagan por el software que les instalo y el soporte que recibo aqui siempre ha sido excelente.
Gracias nuevamente.

Jorge Jaurena

[jponce]

A la orden .

Este codigo fuente que puse funciona perfectamente para decodificar XML, cuando quieres decodificar un PDF ya no funciona o Quieres decodificar un Word, etc, funciona practicamente para XML.

Pero de que funciona para lo que necesitas te funciona.

Atentamente
Julio Ponce

[jbrita]

Hola Jorge:
coma sacarias el valor base64 a abc123
ya que en este link http://hash.online-convert.com/es/generador-sha1
da este resultado:
base64: Y2fEjdGT1W6nsLqtJbGUVeUp9e4=

y con tu funcion da otro valor

saludos

[QAZWSX2K]

no sirve en el texto hay "ñ"

[LuisPonce]

Buenas noches

Yo vengo usando estas funciones que las bajé del Foro:

Code: Select all

* BASE64.PRG
* Creation le 30/12/2008
* Auteur Badara Thiam
* Derniere modification le 25/09/2009 à 16:35:37

* Cambio 25/09/2009 realizado en StrToBase64 ( )
* Resuelve un error de conversión se produce cuando :
* ( El número de caracteres de la cadena multiplicado por 8 ) no es un múltiplo de 6


*******************
FUNCTION StrToBase64( cTexte )
*******************
* Conversión de base 64 de la cadena de ctext

* Un alfabeto de 65 caracteres se utiliza para permitir la representación de 6 bits por carácter :
* "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

* El '=' ( carácter 65a ) se utiliza en el proceso de codificación para _ finales.

LOCAL cTexte64 := ""
LOCAL X
LOCAL cHex
DO WHILE !( cTexte == "" )
cHex := ""

* El proceso de codificación representa grupos de datos de entrada de 24 bits por una cadena de salida de 4 caracteres codificados .
* Procediendo de izquierda a derecha , un grupo de 24 bits se crea mediante la concatenación de tres bytes ( 8 bits por byte ) .
FOR X := 1 TO 3
* Convertir cada cadena de caracteres binarios de 8 bytes
cHex += CarToBin( LEFT(cTexte, 1) )
IF LEN(cTexte) > 1
cTexte := SUBSTR(cTexte, 2)
ELSE
cTexte := ""
EXIT
ENDIF
NEXT X

* Estos 24 bits (en este caso contenía en cHex , o al menos un múltiple) se tratan como 4 grupos concatenados de 6 bits cada convertidos
* En un solo carácter en el alfabeto de la base 64 .

* Cada grupo de 6 bits se utiliza como un índice en la tabla de caracteres de la base 64 .
* El carácter referencia el índice correspondiente se utiliza como la codificación de este grupo de 6 bits.

FOR X := 1 TO 4

IF SUBSTR(cHex, ( (X - 1) * 6) + 1 ) == ""
cTexte64 += REPLICATE("=", 4 - X + 1)
EXIT
ELSE

* Procesamiento especial se lleva a cabo si hay menos de 24 bits están disponibles al final de los datos
* Codificación . Sin bits restantes no codificado ,
* Menos de 24 bits están disponibles a continuación, los bits de cero se añaden a la derecha de los datos
* Para formar un número entero de 6 grupos de bits .

IF LEN( cHex ) % 6 > 0
* La adición de bits cero
cHex += REPLICATE("0", 6 - ( LEN( cHex ) % 6 ) )
ENDIF

cTexte64 += Carac64( "00" + SUBSTR(cHex, ( (X - 1) * 6) + 1, 6 ) )
ENDIF
NEXT X
ENDDO
RETURN cTexte64

*********************
FUNCTION Base64ToStr( cTexte64 )
*********************
* La decodificación de un texto codificado de base 64
LOCAL cTexte := ""
LOCAL X
LOCAL cHex
LOCAL cCar
DO WHILE !( cTexte64 == "" )
try
cCar := LEFT(cTexte64,4)
catch
end
cHex := ""
try
FOR X := 1 TO 4
IF SUBSTR(cCar, X, 1 ) != "="
cHex += Hex64( SUBSTR(cCar, X, 1 ) )
ELSE
EXIT
ENDIF
NEXT X
catch
end

FOR X := 1 TO 3
IF SUBSTR(cHex, ( (X - 1) * 8) + 1 ) == ""
EXIT
ELSE
cTexte += BinToCar( SUBSTR(cHex, ( (X - 1) * 8) + 1, 8 ) )
ENDIF
NEXT X

IF LEN(cTexte64) > 4
cTexte64 := SUBSTR(cTexte64, 5)
ELSE
cTexte64 := ""
ENDIF
ENDDO
RETURN cTexte

****************
FUNCTION Carac64( cBin )
****************
* Devuelve el carácter de base 64 que corresponde
LOCAL nPos := ASC( BinToCar( @cBin ) ) + 1
RETURN SUBSTR( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", nPos, 1)

**************
FUNCTION Hex64( carac64 )
**************

* Devuelve el carácter de base 64 que corresponde
LOCAL cCodeAsc := CHR( AT(carac64, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ) -1 )
RETURN SUBSTR( CarToBin( @cCodeAsc ) , 3, 6)

*****************
FUNCTION CarToBin( carac, lInverse )
*****************
* Devuelve el carácter que corresponde a una cadena binaria ( que consiste en 0 y 1 )8 -bit

#define cHexa "0123456789ABCDEF"
#define aBin {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", ;
"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" }
LOCAL cToHex

IF EMPTY( lInverse )
* Devuelve la cadena binaria de haber recibido el carácter ASCII
cToHex := str2Hex( carac )
RETURN aBin[ AT( LEFT(cToHex,1), cHexa ) ] + aBin[ AT( SUBSTR(cToHex,2), cHexa ) ]
ELSE
* Devuelve el carácter ASCII de haber recibido la cadena binaria
cToHex := SUBSTR(cHexa, ASCAN(aBin, LEFT(carac,4 ) ), 1 ) ;
+ SUBSTR(cHexa, ASCAN(aBin, SUBSTR(carac,5,4 ) ), 1 )
RETURN Hex2str( cToHex )
ENDIF
RETURN NIL

*****************
FUNCTION BinToCar( cBin )
*****************
RETURN CarToBin( @cBin, .T. )

Me parece que es la misma publicada lineas arriba por JPonce

Alex:

No tengo problemas con caracteres especiales por que en _ donde se pueden generar las "ñ","Ñ" al momento de construir el XML utilizo
![CDATA] es para que analizador semantico lo intreprete como una cadena:

https://es.wikipedia.org/wiki/CDATA

Saludos