ich habe einen base64 codierten string und möchte ihn decodieren,
Hier in der suche bin ich leider nicht fündig geworden, vieleicht habt Ihr einen Tip wo ich nachschauen könnte...

MfG T1c4L

habe gerade mal gesucht. Gehört zu ATL -> brauchst als include "atlenc.h". In der MSDN unter Base64Decode / Base64Encode mal nachschauen. Habs persönlich noch nie getestet. Aber vielleicht auch mal nach den Begriffen googeln....

*winke*
Hellsgore

ich schau mal in Google....

Danke schonmal trotzdem

MfG T1c4L

Allerdings benutze ich VS 2003.

Guck mal da:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/vclrfbase64decode.asp

Gibt aber auch bei Codeproject Beispiele zum Ent- und Verschlüsseln.

*winke*
Hellsgore

cpp

/*
Module : Base64Coder.CPP
Purpose: Implementation for the Base64 encoder / decoder class
Created: PJN / 20-06-2000
History: None

Copyright (c) 1998 - 2004 by PJ Naughter.  
All rights reserved.

*/

//////////////// Includes ////////////////////////////////////////////

#include "Base64Coder.h"

//////////////// Macros / Locals /////////////////////////////////////

static char	Base64Digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
BOOL CBase64Coder::m_Init		= FALSE;
char CBase64Coder::m_DecodeTable[256];

#ifndef PAGESIZE
#define PAGESIZE					4096
#endif

#ifndef ROUNDTOPAGE
#define ROUNDTOPAGE(a)			(((a/4096)+1)*4096)
#endif

////////////////// Implementation ////////////////////////////////////

CBase64Coder::CBase64Coder() : m_pDBuffer(NULL), m_pEBuffer(NULL),
	                           m_nDBufLen(0),	m_nEBufLen(0)
{
}

CBase64Coder::~CBase64Coder()
{
	if (m_pDBuffer != NULL)
  {
		delete [] m_pDBuffer;
    m_pDBuffer = NULL;
  }

	if (m_pEBuffer != NULL)
  {
		delete [] m_pEBuffer;
    m_pEBuffer = NULL;
  }
}

char* CBase64Coder::DecodedMessage() const 
{ 
	return (char*) m_pDBuffer;
}

char* CBase64Coder::EncodedMessage() const
{ 
	return (char*) m_pEBuffer;
}

LONG CBase64Coder::DecodedMessageSize() const 
{ 
	return m_nDDataLen;
}

LONG CBase64Coder::EncodedMessageSize() const
{ 
	return m_nEDataLen;
}

void CBase64Coder::AllocEncode(DWORD nSize)
{
	if (m_nEBufLen < nSize)
	{
		if (m_pEBuffer != NULL)
			delete [] m_pEBuffer;

		m_nEBufLen = ROUNDTOPAGE(nSize);
		m_pEBuffer = new BYTE[m_nEBufLen];
	}

	::memset(m_pEBuffer,0, m_nEBufLen);
	m_nEDataLen = 0;
}

void CBase64Coder::AllocDecode(DWORD nSize)
{
	if (m_nDBufLen < nSize)
	{
		if (m_pDBuffer != NULL)
			delete [] m_pDBuffer;

		m_nDBufLen = ROUNDTOPAGE(nSize);
		m_pDBuffer = new BYTE[m_nDBufLen];
	}

	::memset(m_pDBuffer, 0 ,m_nDBufLen);  // ersetzen mit memset
	m_nDDataLen = 0;
}

void CBase64Coder::SetEncodeBuffer(const unsigned char* pBuffer, DWORD nBufLen)
{
	DWORD	i = 0;

	AllocEncode(nBufLen);
	while(i < nBufLen)
	{
		if (!_IsBadMimeChar(pBuffer[i]))
		{
			m_pEBuffer[m_nEDataLen] = pBuffer[i];
			m_nEDataLen++;
		}
		i++;
	}
}

void CBase64Coder::SetDecodeBuffer(const unsigned char* pBuffer, DWORD nBufLen)
{
	AllocDecode(nBufLen);
	::memcpy(m_pDBuffer, pBuffer, nBufLen);
	m_nDDataLen = nBufLen;
}

void CBase64Coder::Encode(const unsigned char* pBuffer, DWORD nBufLen)
{
	SetDecodeBuffer(pBuffer, nBufLen);
	AllocEncode(nBufLen * 2);

	TempBucket Raw;
	DWORD	nIndex	= 0;
	while ((nIndex + 3) <= nBufLen)
	{
		Raw.Clear();
		::memcpy(&Raw, m_pDBuffer + nIndex, 3);   // Kann ersetzt werden mit memcpy
		Raw.nSize = 3;
		_EncodeToBuffer(Raw, m_pEBuffer + m_nEDataLen);
		nIndex += 3;
		m_nEDataLen	+= 4;
	}

	if (nBufLen > nIndex)
	{
		Raw.Clear();
		Raw.nSize = (BYTE) (nBufLen - nIndex);
		::memcpy(&Raw, m_pDBuffer + nIndex, nBufLen - nIndex);
		_EncodeToBuffer(Raw, m_pEBuffer + m_nEDataLen);
		m_nEDataLen += 4;
	}
}

void CBase64Coder::Encode(const char *szMessage)
{
	if (szMessage != NULL)
		Encode((const unsigned char*)szMessage, strlen(szMessage));
}

void CBase64Coder::Decode(const unsigned char* pBuffer, DWORD dwBufLen)
{
	if (!CBase64Coder::m_Init)
		_Init();

	SetEncodeBuffer(pBuffer, dwBufLen);
	AllocDecode(dwBufLen);

	TempBucket Raw;
	DWORD	nIndex = 0;
	while((nIndex + 4) <= m_nEDataLen)
	{
		Raw.Clear();
		Raw.nData[0] = CBase64Coder::m_DecodeTable[m_pEBuffer[nIndex]];
		Raw.nData[1] = CBase64Coder::m_DecodeTable[m_pEBuffer[nIndex + 1]];
		Raw.nData[2] = CBase64Coder::m_DecodeTable[m_pEBuffer[nIndex + 2]];
		Raw.nData[3] = CBase64Coder::m_DecodeTable[m_pEBuffer[nIndex + 3]];

		if (Raw.nData[2] == 255)
			Raw.nData[2] = 0;
		if (Raw.nData[3] == 255)
			Raw.nData[3] = 0;

		Raw.nSize = 4;
		_DecodeToBuffer(Raw, m_pDBuffer + m_nDDataLen);
		nIndex += 4;
		m_nDDataLen += 3;
	}

   // If nIndex < m_nEDataLen, then we got a decode message without padding.
   // We may want to throw some kind of warning here, but we are still required
   // to handle the decoding as if it was properly padded.
	if (nIndex < m_nEDataLen)
	{
		Raw.Clear();
		for (DWORD i=nIndex; i<m_nEDataLen; i++)
		{
			Raw.nData[i - nIndex] = CBase64Coder::m_DecodeTable[m_pEBuffer[i]];
			Raw.nSize++;
			if(Raw.nData[i - nIndex] == 255)
				Raw.nData[i - nIndex] = 0;
		}

		_DecodeToBuffer(Raw, m_pDBuffer + m_nDDataLen);
		m_nDDataLen += (m_nEDataLen - nIndex);
	}
}

void CBase64Coder::Decode(const char * szMessage)
{
	if (szMessage != NULL)
		Decode((const unsigned char*)szMessage, strlen(szMessage));
}

DWORD CBase64Coder::_DecodeToBuffer(const TempBucket &Decode, unsigned char* pBuffer)
{
	TempBucket	Data;
	DWORD	nCount = 0;

	_DecodeRaw(Data, Decode);

	for (int i=0; i<3; i++)
	{
		pBuffer[i] = Data.nData[i];
		if(pBuffer[i] != 255)
			nCount++;
	}

	return nCount;
}

void CBase64Coder::_EncodeToBuffer(const TempBucket &Decode, unsigned char* pBuffer)
{
	TempBucket Data;

	_EncodeRaw(Data, Decode);

	for (int i=0; i<4; i++)
		pBuffer[i] = Base64Digits[Data.nData[i]];

	switch (Decode.nSize)
	{
	  case 1:
		  pBuffer[2] = '=';
	  case 2:
		  pBuffer[3] = '=';
	}
}

void CBase64Coder::_DecodeRaw(TempBucket &Data, const TempBucket &Decode)
{
	BYTE nTemp;

	Data.nData[0] = Decode.nData[0];
	Data.nData[0] <<= 2;

	nTemp = Decode.nData[1];
	nTemp >>= 4;
	nTemp &= 0x03;
	Data.nData[0] |= nTemp;

	Data.nData[1] = Decode.nData[1];
	Data.nData[1] <<= 4;

	nTemp = Decode.nData[2];
	nTemp >>= 2;
	nTemp &= 0x0F;
	Data.nData[1] |= nTemp;

	Data.nData[2] = Decode.nData[2];
	Data.nData[2] <<= 6;
	nTemp = Decode.nData[3];
	nTemp &= 0x3F;
	Data.nData[2] |= nTemp;
}

void CBase64Coder::_EncodeRaw(TempBucket &Data, const TempBucket &Decode)
{
	BYTE nTemp;

	Data.nData[0] = Decode.nData[0];
	Data.nData[0] >>= 2;

	Data.nData[1] = Decode.nData[0];
	Data.nData[1] <<= 4;
	nTemp = Decode.nData[1];
	nTemp >>= 4;
	Data.nData[1] |= nTemp;
	Data.nData[1] &= 0x3F;

	Data.nData[2] = Decode.nData[1];
	Data.nData[2] <<= 2;

	nTemp = Decode.nData[2];
	nTemp >>= 6;

	Data.nData[2] |= nTemp;
	Data.nData[2] &= 0x3F;

	Data.nData[3] = Decode.nData[2];
	Data.nData[3] &= 0x3F;
}

BOOL CBase64Coder::_IsBadMimeChar(BYTE nData)
{
	switch(nData)
	{
		case '\r': case '\n': case '\t': case ' ' :
		case '\b': case '\a': case '\f': case '\v':
			return TRUE;
		default:
			return FALSE;
	}
}

void CBase64Coder::_Init()
{  
  // Initialize Decoding table.
	int	i;
	for (i=0; i<256; i++)
		CBase64Coder::m_DecodeTable[i] = -2;

	for (i=0; i<64; i++)
	{
		CBase64Coder::m_DecodeTable[Base64Digits[i]]	= (char) i;
		CBase64Coder::m_DecodeTable[Base64Digits[i]|0x80] = (char) i;
	}

	CBase64Coder::m_DecodeTable['=']	= -1;
	CBase64Coder::m_DecodeTable['='|0x80] = -1;
	CBase64Coder::m_Init = TRUE;
}

Header

/*
Module : Base64Coder.CPP
Purpose: Definition for the Base64 encoder / decoder class
Created: PJN / 20-06-2000
History: None

Copyright (c) 1998 - 2004 by PJ Naughter.  
All rights reserved.

*/

/////////////////////////////// Defines ///////////////////////////////////////
#ifndef __BASE64CODER_H__
#define __BASE64CODER_H__

#include <string>
#include <cctype>

typedef unsigned long 	ULONG;
typedef long 	LONG;
typedef unsigned long 	DWORD;
typedef int 		BOOL;
typedef unsigned char	BYTE;
typedef unsigned short	WORD;
#define FALSE 0
#define TRUE 1

/////////////////////////////// Classes ///////////////////////////////////////

class CBase64Coder  
{
public:
//Constructors / Destructors
	CBase64Coder();
	virtual ~CBase64Coder();

//Methods
	virtual void	 Encode(const unsigned char*, unsigned long);
	virtual void	 Decode(const unsigned char*, unsigned long);
	virtual void	 Encode(const char* sMessage);
	virtual void	 Decode(const char* sMessage);
	virtual char*  DecodedMessage() const;
	virtual char*  EncodedMessage() const;
	virtual long	 DecodedMessageSize() const;
	virtual long	 EncodedMessageSize() const;

  /** Encodes a character of the default charset into the hexadecimal format
    * %XX.
    * <a name="CSE-hexEncode"></a>
    * @param c The character to be encoded.
    * @return The encoded string.
    * @deffunc static&nbsp; std::string hexEncode(const unsigned char& c)
    */
   std::string hexEncode(
      const unsigned char& c)
    throw ()
  {
    std::string result("%");
    unsigned char v[2]= { c/16, c%16 };
    if (v[0] <= 9) result+= (v[0] + '0');
    else result+= (v[0] - 10 + 'A');
    if (v[1] <= 9) result+= (v[1] + '0');
    else result+= (v[1] - 10 + 'A');
    return result;
  }

  /** Encodes a string into the URL-encoded format.
    * Such strings can be found e.g. in raw HTTP request parameters.
    * This function has been implemented after RFC2068.
    * <a name="CSE-urlEncode"></a>
    * @param s The string to be encoded.
    * @return The encoded string.
    * @deffunc static&nbsp; std::string urlEncode(const std::string& s)
    */
  std::string urlEncode(  // as defined in RFC2068
      const std::string&s)
    throw ()
  {
    std::string result;
    unsigned char c;
    for (unsigned int p= 0; p < s.size(); ++p) {
      c= s[p];
      if ((c <= 31) || (c >= 127))  // CTL, >127
        result+= hexEncode(c);
      else switch (c) {
      case ';':
      case '/':
      case '?':
      case ':':
      case '@':
      case '&':
      case '=':
      case '+':  // until here: reserved
      case '"':
      case '#':
      case '%':
      case '<':
      case '>':  // until here: unsafe
        result+= hexEncode(c);
        break;
      case ' ':  // SP
        result+= '+';
        break;
      default:  // no need to encode
        result+= c;
        break;
      }
    }
    return result;
  }

protected:
// Internal bucket class.
	class TempBucket
	{
	public:
		unsigned char 		nData[4];
		unsigned char 		nSize;
		void		Clear() { memset(nData, 0,4); nSize = 0; };
	};

//Variables
	unsigned char*	m_pDBuffer;
	unsigned char*	m_pEBuffer;
	DWORD	m_nDBufLen;
	DWORD	m_nEBufLen;
	DWORD	m_nDDataLen;
	DWORD	m_nEDataLen;
	static char m_DecodeTable[256];
	static BOOL m_Init;

//Methods
	virtual void	 AllocEncode(DWORD);
	virtual void	 AllocDecode(DWORD);
	virtual void	 SetEncodeBuffer(const unsigned char* pBuffer, DWORD nBufLen);
	virtual void	 SetDecodeBuffer(const unsigned char* pBuffer, DWORD nBufLen);
	virtual void	_EncodeToBuffer(const TempBucket &Decode, unsigned char* pBuffer);
	virtual ULONG	_DecodeToBuffer(const TempBucket &Decode, unsigned char* pBuffer);
	virtual void	_EncodeRaw(TempBucket &, const TempBucket &);
	virtual void	_DecodeRaw(TempBucket &, const TempBucket &);
	virtual BOOL	_IsBadMimeChar(unsigned char );
	void					_Init();

};

#endif //__BASE64CODER_H__

auf meinem "privat" notebook hier auf der Arbeit habe ich auch das VC .Net 2003 und hier gibts in der MSDN auch ne tolle methode zum decodieren.

Auf dem "Arbeitspc" ist leider nur VC6 drauf mit MSDN July 2001 (gerade am installieren) hoffe das ich die methode dort finde...

Danke euch allen nochmals ihr habt mir viel geholfen,
bin aber fuer mehr hilfe immer offen!!!

MfG
euer T1c4L