/******************************************************************************
* The MIT License
* Copyright (c) 2003 Novell Inc. www.novell.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the Software), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*******************************************************************************/
//
// Novell.Directory.Ldap.Utilclass.Base64.cs
//
// Author:
// Sunil Kumar (Sunilk@novell.com)
//
// (C) 2003 Novell, Inc (http://www.novell.com)
//
using System;
namespace Novell.Directory.Ldap.Utilclass
{
/// <summary> The Base64 utility class performs base64 encoding and decoding.
///
/// The Base64 Content-Transfer-Encoding is designed to represent
/// arbitrary sequences of octets in a form that need not be humanly
/// readable. The encoding and decoding algorithms are simple, but the
/// encoded data are consistently only about 33 percent larger than the
/// unencoded data. The base64 encoding algorithm is defined by
/// RFC 2045.
/// </summary>
public class Base64
{
/// <summary> Encodes the specified bytes into a base64 array of bytes.
/// Each byte in the return array represents a base64 character.
///
/// </summary>
/// <param name="inputBytes"> the byte array to be encoded.
///
/// </param>
/// <returns> a String containing the base64 encoded data
/// </returns>
[CLSCompliantAttribute(false)]
public static System.String encode(sbyte[] inputBytes)
{
/// <summary>Conversion table for encoding to base64.
///
/// emap is a six-bit value to base64 (8-bit) converstion table.
/// For example, the value of the 6-bit value 15
/// is mapped to 0x50 which is the ASCII letter 'P', i.e. the letter P
/// is the base64 encoded character that represents the 6-bit value 15.
/// </summary>
/*
* 8-bit base64 encoded character base64 6-bit
* encoded original
* character binary value
*/
char[] emap = new char[]{'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', '+', '/'}; // 4-9, + /; 56-63
int i, j, k;
int t, t1, t2;
int ntb; // number of three-bytes in inputBytes
bool onePadding = false, twoPaddings = false;
char[] encodedChars; // base64 encoded chars
int len = inputBytes.Length;
if (len == 0)
{
// No data, return no data.
return new System.Text.StringBuilder("").ToString();
}
// every three bytes will be encoded into four bytes
if (len % 3 == 0)
{
ntb = len / 3;
}
// the last one or two bytes will be encoded into
// four bytes with one or two paddings
else
{
ntb = len / 3 + 1;
}
// need two paddings
if ((len % 3) == 1)
{
twoPaddings = true;
}
// need one padding
else if ((len % 3) == 2)
{
onePadding = true;
}
encodedChars = new char[ntb * 4];
// map of decoded and encoded bits
// bits in 3 decoded bytes: 765432 107654 321076 543210
// bits in 4 encoded bytes: 76543210765432107654321076543210
// plain "AAA": 010000 010100 000101 000001
// base64 encoded "QUFB": 00010000000101000000010100000001
// one padding:
// bits in 2 decoded bytes: 765432 10 7654 3210
// bits in 4 encoded bytes: 765432107654 321076543210 '='
// plain "AA": 010000 010100 0001
// base64 encoded "QUE=": 00010000000101000000010000111101
// two paddings:
// bits in 1 decoded bytes: 765432 10
// bits in 4 encoded bytes: 7654321076543210 '=' '='
// plain "A": 010000 01
// base64 encoded "QQ==": 00010000000100000011110100111101
//
// note: the encoded bits which have no corresponding decoded bits
// are filled with zeros; '=' = 00111101.
for (i = 0, j = 0, k = 1; i < len; i += 3, j += 4, k++)
{
// build encodedChars[j]
t = 0x00ff & inputBytes[i];
encodedChars[j] = emap[t >> 2];
// build encodedChars[j+1]
if ((k == ntb) && twoPaddings)
{
encodedChars[j + 1] = emap[(t & 0x03) << 4];
encodedChars[j + 2] = '=';
encodedChars[j + 3] = '=';
break;
}
else
{
t1 = 0x00ff & inputBytes[i + 1];
encodedChars[j + 1] = emap[((t & 0x03) << 4) + ((t1 & 0xf0) >> 4)];
}
// build encodedChars[j+2]
if ((k == ntb) && onePadding)
{
encodedChars[j + 2] = emap[(t1 & 0x0f) << 2];
encodedChars[j + 3] = '=';
break;
}
else
{
t2 = 0x00ff & inputBytes[i + 2];
encodedChars[j + 2] = (emap[(t1 & 0x0f) << 2 | (t2 & 0xc0) >> 6]);
}
// build encodedChars[j+3]
encodedChars[j + 3] = (emap[(t2 & 0x3f)]);
}
return new System.String(encodedChars);
}
}
}