Decodes all or part of the input base64 encoded StringBuffer

Posted on February 11, 2011June 27, 2015 by coder

/******************************************************************************
* 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
{

///

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.
///

public class Base64
{
///

Decodes a base64 encoded StringBuffer.
/// Decodes all or part of the input base64 encoded StringBuffer, each
/// Character value representing a base64 character. The resulting
/// binary data is returned as an array of bytes.
///
///

/// The StringBuffer object that contains base64
/// encoded data.
/// /// The start index of the base64 encoded data.
/// /// The end index + 1 of the base64 encoded data.
///
/// /// The decoded byte array
///
public static sbyte[] decode(System.Text.StringBuilder encodedSBuf, int start, int end)
{
///

conversion table for decoding from base64.
///
/// dmap is a base64 (8-bit) to six-bit value converstion table.
/// For example the ASCII character 'P' has a value of 80.
/// The value in the 80th position of the table is 0x0f or 15.
/// 15 is the original 6-bit value that the letter 'P' represents.
///

/*
* 6-bit decoded value base64 base64
* encoded character
* value
*
* Note: about half of the values in the table are only place holders
*/
sbyte[] dmap = new sbyte[]{(sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x3e), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x3f), (sbyte) (0x34), (sbyte) (0x35), (sbyte) (0x36), (sbyte) (0x37), (sbyte) (0x38), (sbyte) (0x39), (sbyte) (0x3a), (sbyte) (0x3b), (sbyte) (0x3c), (sbyte) (0x3d), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x01), (sbyte) (0x02), (sbyte) (0x03), (sbyte) (0x04), (sbyte) (0x05), (sbyte) (0x06), (sbyte) (0x07), (sbyte) (0x08), (sbyte) (0x09), (sbyte) (0x0a), (sbyte) (0x0b), (sbyte) (0x0c), (sbyte) (0x0d), (sbyte) (0x0e), (sbyte) (0x0f), (sbyte) (0x10), (sbyte) (0x11), (sbyte) (0x12), (sbyte) (0x13), (sbyte) (0x14), (sbyte) (0x15), (sbyte) (0x16), (sbyte) (0x17), (sbyte) (0x18), (sbyte) (0x19), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x1a), (sbyte) (0x1b), (sbyte) (0x1c), (sbyte) (0x1d), (sbyte) (0x1e), (sbyte) (0x1f), (sbyte) (0x20), (sbyte) (0x21), (sbyte) (0x22), (sbyte) (0x23), (sbyte) (0x24), (sbyte) (0x25), (sbyte) (0x26), (sbyte) (0x27), (sbyte) (0x28), (sbyte) (0x29), (sbyte) (0x2a), (sbyte) (0x2b), (sbyte) (0x2c), (sbyte) (0x2d), (sbyte) (0x2e), (sbyte) (0x2f), (sbyte) (0x30), (sbyte) (0x31), (sbyte) (0x32), (sbyte) (0x33), (sbyte) (0x00), (
sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00), (sbyte) (0x00)}; // 120-127 'xyz '

int i, j, k;
int esbLen = end – start; // length of the encoded part
int gn = esbLen / 4; // number of four-bytes group in ebs
int dByteLen; // length of dbs, default is '0'
bool onePad = false, twoPads = false;
sbyte[] decodedBytes; // decoded bytes

if (encodedSBuf.Length == 0)
{
return new sbyte[0];
}
// the number of encoded bytes should be multiple of number 4
if ((esbLen % 4) != 0)
{
throw new System.SystemException(“Novell.Directory.Ldap.ldif_dsml.” + “Base64Decoder: decode error: mal-formatted encode value”);
}

// every four-bytes in ebs, except the last one if it in the form of
// three bytes.
if ((encodedSBuf[end – 1] == (int)'=') && (encodedSBuf[end – 2] == (int)'='))
{
// the last four bytes of ebs is in the form of '**=='
twoPads = true;
// the first two bytes of the last four-bytes of ebs will be
// decoded into one byte.
dByteLen = gn * 3 – 2;
decodedBytes = new sbyte[dByteLen];
}
else if (encodedSBuf[end – 1] == (int)'=')
{
// the last four bytes of ebs is in the form of '***='
onePad = true;
// the first two bytes of the last four-bytes of ebs will be
// decoded into two bytes.
dByteLen = gn * 3 – 1;
decodedBytes = new sbyte[dByteLen];
}
else
{
// the last four bytes of ebs is in the form of '****', eg. no pad.
dByteLen = gn * 3;
decodedBytes = new sbyte[dByteLen];
}

// map of encoded and decoded bits
// no padding:
// bits in 4 encoded bytes: 76543210 76543210 76543210 76543210
// bits in 3 decoded bytes: 765432 107654 321076 543210
// base64 string “QUFB”:00010000 00010100 000001010 0000001
// plain string “AAA”: 010000 010100 000101 000001
// one padding:
// bits in 4 encoded bytes: 76543210 76543210 76543210 76543210
// bits in 2 decoded bytes: 765432 107654 3210
// base64 string “QUE=”: 00010000 000101000 0000100 00111101
// plain string “AA”: 010000 010100 0001
// two paddings:
// bits in 4 encoded bytes: 76543210 76543210 76543210 76543210
// bits in 1 decoded bytes: 765432 10
// base64 string “QQ==”: 00010000 00010000 00111101 00111101
// plain string “A”: 010000 01
for (i = 0, j = 0, k = 1; i < esbLen; i += 4, j += 3, k++) { // build decodedBytes[j]. decodedBytes[j] = (sbyte)(dmap[encodedSBuf[start + i]] << 2 | (dmap[encodedSBuf[start + i + 1]] & 0x30) >> 4);

// build decodedBytes[j+1]
if ((k == gn) && twoPads)
{
break;
}
else
{
decodedBytes[j + 1] = (sbyte)((dmap[encodedSBuf[start + i + 1]] & 0x0f) << 4 | (dmap[encodedSBuf[start + i + 2]] & 0x3c) >> 2);
}

// build decodedBytes[j+2]
if ((k == gn) && onePad)
{
break;
}
else
{
decodedBytes[j + 2] = (sbyte)((dmap[encodedSBuf[start + i + 2]] & 0x03) << 6 | dmap[encodedSBuf[start + i + 3]] & 0x3f); } } return decodedBytes; } } } [/csharp]

The Base64 utility class performs base64 encoding and decoding. The resulting binary data is returned as an array of bytes.

Posted on February 11, 2011June 27, 2015 by coder

using System;

namespace Novell.Directory.Ldap.Utilclass
{

///

public class Base64
{
///

Decodes the input base64 encoded array of characters.
/// The resulting binary data is returned as an array of bytes.
///
///

/// The character array containing the base64 encoded data.
///
/// /// A byte array object containing decoded bytes.
///
[CLSCompliantAttribute(false)]
public static sbyte[] decode(char[] encodedChars)
{
///

int i, j, k;
int ecLen = encodedChars.Length; // length of encodedChars
int gn = ecLen / 4; // number of four-byte groups in encodedChars
int dByteLen; // length of decoded bytes, default is '0'
bool onePad = false, twoPads = false;
sbyte[] decodedBytes; // decoded bytes

if (encodedChars.Length == 0)
{
return new sbyte[0];
}
// the number of encoded bytes should be multiple of 4
if ((ecLen % 4) != 0)
{
throw new System.SystemException(“Novell.Directory.Ldap.ldif_dsml.” + “Base64Decoder: decode: mal-formatted encode value”);
}

// every four-bytes in encodedString, except the last one if it in the
// form of '**==' or '***=' ( can't be '*' or ''), will be
// decoded into three bytes.
if ((encodedChars[ecLen – 1] == (int) '=') && (encodedChars[ecLen – 2] == (int) '='))
{
// the last four bytes of encodedChars is in the form of '**=='
twoPads = true;
// the first two bytes of the last four-bytes of encodedChars will
// be decoded into one byte.
dByteLen = gn * 3 – 2;
decodedBytes = new sbyte[dByteLen];
}
else if (encodedChars[ecLen – 1] == '=')
{
// the last four bytes of encodedChars is in the form of '***='
onePad = true;
// the first two bytes of the last four-bytes of encodedChars will
// be decoded into two bytes.
dByteLen = gn * 3 – 1;
decodedBytes = new sbyte[dByteLen];
}
else
{
// the last four bytes of encodedChars is in the form of '****',
// e.g. no pad.
dByteLen = gn * 3;
decodedBytes = new sbyte[dByteLen];
}

// map of encoded and decoded bits
// no padding:
// bits in 4 encoded bytes: 76543210 76543210 76543210 76543210
// bits in 3 decoded bytes: 765432 107654 321076 543210
// base64 string “QUFB”:00010000 00010100 000001010 0000001
// plain string “AAA”: 010000 010100 000101 000001
// one padding:
// bits in 4 encoded bytes: 76543210 76543210 76543210 76543210
// bits in 2 decoded bytes: 765432 107654 3210
// base64 string “QUE=”: 00010000 000101000 0000100 00111101
// plain string “AA”: 010000 010100 0001
// two paddings:
// bits in 4 encoded bytes: 76543210 76543210 76543210 76543210
// bits in 1 decoded bytes: 765432 10
// base64 string “QQ==”: 00010000 00010000 00111101 00111101
// plain string “A”: 010000 01
for (i = 0, j = 0, k = 1; i < ecLen; i += 4, j += 3, k++) { // build decodedBytes[j]. decodedBytes[j] = (sbyte) (dmap[encodedChars[i]] << 2 | (dmap[encodedChars[i + 1]] & 0x30) >> 4);

// build decodedBytes[j+1]
if ((k == gn) && twoPads)
{
break;
}
else
{
decodedBytes[j + 1] = (sbyte) ((dmap[encodedChars[i + 1]] & 0x0f) << 4 | (dmap[encodedChars[i + 2]] & 0x3c) >> 2);
}

// build decodedBytes[j+2]
if ((k == gn) && onePad)
{
break;
}
else
{
decodedBytes[j + 2] = (sbyte) ((dmap[encodedChars[i + 2]] & 0x03) << 6 | dmap[encodedChars[i + 3]] & 0x3f); } } return decodedBytes; } } } [/csharp]

The Base64 utility class performs base64 encoding and decoding.

Posted on February 11, 2011June 27, 2015 by coder

   
 

/******************************************************************************
* 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 &#039;P&#039;, 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[]{&#039;A&#039;, &#039;B&#039;, &#039;C&#039;, &#039;D&#039;, &#039;E&#039;, &#039;F&#039;, &#039;G&#039;, &#039;H&#039;, &#039;I&#039;, &#039;J&#039;, &#039;K&#039;, &#039;L&#039;, &#039;M&#039;, &#039;N&#039;, &#039;O&#039;, &#039;P&#039;, &#039;Q&#039;, &#039;R&#039;, &#039;S&#039;, &#039;T&#039;, &#039;U&#039;, &#039;V&#039;, &#039;W&#039;, &#039;X&#039;, &#039;Y&#039;, &#039;Z&#039;, &#039;a&#039;, &#039;b&#039;, &#039;c&#039;, &#039;d&#039;, &#039;e&#039;, &#039;f&#039;, &#039;g&#039;, &#039;h&#039;, &#039;i&#039;, &#039;j&#039;, &#039;k&#039;, &#039;l&#039;, &#039;m&#039;, &#039;n&#039;, &#039;o&#039;, &#039;p&#039;, &#039;q&#039;, &#039;r&#039;, &#039;s&#039;, &#039;t&#039;, &#039;u&#039;, &#039;v&#039;, &#039;w&#039;, &#039;x&#039;, &#039;y&#039;, &#039;z&#039;, &#039;0&#039;, &#039;1&#039;, &#039;2&#039;, &#039;3&#039;, &#039;4&#039;, &#039;5&#039;, &#039;6&#039;, &#039;7&#039;, &#039;8&#039;, &#039;9&#039;, &#039;+&#039;, &#039;/&#039;}; // 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 &#039;=&#039;
      //       plain            "AA":   010000  010100  0001
      //       base64 encoded "QUE=": 00010000000101000000010000111101
      // two paddings:
      //     bits in 1 decoded bytes:   765432  10
      //     bits in 4 encoded bytes: 7654321076543210 &#039;=&#039; &#039;=&#039;
      //       plain             "A":   010000  01
      //       base64 encoded "QQ==": 00010000000100000011110100111101
      //
      // note: the encoded bits which have no corresponding decoded bits
      // are filled with zeros; &#039;=&#039; = 00111101.
      for (i = 0, j = 0, k = 1; i < len; i += 3, j += 4, k++)
      {
        
        // build encodedChars&#91;j&#93;
        t = 0x00ff &amp; inputBytes&#91;i&#93;;
        encodedChars&#91;j&#93; = emap&#91;t >> 2];
        
        // build encodedChars[j+1]
        if ((k == ntb) &amp;&amp; twoPaddings)
        {
          encodedChars[j + 1] = emap[(t &amp; 0x03) << 4&#93;;
          encodedChars&#91;j + 2&#93; = &#039;=&#039;;
          encodedChars&#91;j + 3&#93; = &#039;=&#039;;
          break;
        }
        else
        {
          t1 = 0x00ff &amp; inputBytes&#91;i + 1&#93;;
          encodedChars&#91;j + 1&#93; = emap&#91;((t &amp; 0x03) << 4) + ((t1 &amp; 0xf0) >> 4)];
        }
        
        // build encodedChars[j+2]
        if ((k == ntb) &amp;&amp; onePadding)
        {
          encodedChars[j + 2] = emap[(t1 &amp; 0x0f) << 2&#93;;
          encodedChars&#91;j + 3&#93; = &#039;=&#039;;
          break;
        }
        else
        {
          t2 = 0x00ff &amp; inputBytes&#91;i + 2&#93;;
          encodedChars&#91;j + 2&#93; = (emap&#91;(t1 &amp; 0x0f) << 2 | (t2 &amp; 0xc0) >> 6]);
        }
        
        // build encodedChars[j+3]
        encodedChars[j + 3] = (emap[(t2 &amp; 0x3f)]);
      }
      return new System.String(encodedChars);
    }
   }
}

Url Encode Base 64

Posted on February 11, 2011June 27, 2015 by coder

#region License
// Copyright (c) 2007 James Newton-King
//
// 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.
#endregion

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections.Specialized;
using System.Web;

namespace Newtonsoft.Utilities.Web
{
public static class UrlUtils
{
public static string GetSchemeHostPort(Uri uri)
{
if (uri == null)
throw new ArgumentNullException(“uri”);

return uri.Scheme + “://” + uri.Host + “:” + uri.Port + “/”;
}

public static string UrlEncodeBase64(string base64Data)
{
return new string(UrlEncodeBase64(base64Data.ToCharArray()));
}

public static char[] UrlEncodeBase64(char[] base64Data)
{
for (int i = 0; i < base64Data.Length; i++) { switch (base64Data[i]) { case '+': base64Data[i] = '@'; break; case '/': base64Data[i] = '$'; break; } } return base64Data; } public static string UrlDecodeBase64(string base64Data) { return new string(UrlDecodeBase64(base64Data.ToCharArray())); } public static char[] UrlDecodeBase64(char[] base64Data) { for (int i = 0; i < base64Data.Length; i++) { switch (base64Data[i]) { case '@': base64Data[i] = '+'; break; case '$': base64Data[i] = '/'; break; } } return base64Data; } } } [/csharp]

Base64 Encoder

Posted on February 11, 2011June 27, 2015 by coder

//http://www.bouncycastle.org/
//MIT X11 License
using System;
using System.IO;

namespace Org.BouncyCastle.Utilities.Encoders
{
public class Base64Encoder

{
protected readonly byte[] encodingTable =
{
(byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',
(byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',
(byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',
(byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',
(byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',
(byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',
(byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',
(byte)'v',
(byte)'w', (byte)'x', (byte)'y', (byte)'z',
(byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5', (byte)'6',
(byte)'7', (byte)'8', (byte)'9',
(byte)'+', (byte)'/'
};

protected byte padding = (byte)'=';

/*
* set up the decoding table.
*/
protected readonly byte[] decodingTable = new byte[128];

protected void InitialiseDecodingTable()
{
for (int i = 0; i < encodingTable.Length; i++) { decodingTable[encodingTable[i]] = (byte)i; } } public Base64Encoder() { InitialiseDecodingTable(); } /** * encode the input data producing a base 64 output stream. * * @return the number of bytes produced. */ public int Encode( byte[] data, int off, int length, Stream outStream) { int modulus = length % 3; int dataLength = (length - modulus); int a1, a2, a3; for (int i = off; i < off + dataLength; i += 3) { a1 = data[i] & 0xff; a2 = data[i + 1] & 0xff; a3 = data[i + 2] & 0xff; outStream.WriteByte(encodingTable[(int) ((uint) a1 >> 2) & 0x3f]);
outStream.WriteByte(encodingTable[((a1 << 4) | (int) ((uint) a2 >> 4)) & 0x3f]);
outStream.WriteByte(encodingTable[((a2 << 2) | (int) ((uint) a3 >> 6)) & 0x3f]);
outStream.WriteByte(encodingTable[a3 & 0x3f]);
}

/*
* process the tail end.
*/
int b1, b2, b3;
int d1, d2;

switch (modulus)
{
case 0: /* nothing left to do */
break;
case 1:
d1 = data[off + dataLength] & 0xff;
b1 = (d1 >> 2) & 0x3f;
b2 = (d1 << 4) & 0x3f; outStream.WriteByte(encodingTable[b1]); outStream.WriteByte(encodingTable[b2]); outStream.WriteByte(padding); outStream.WriteByte(padding); break; case 2: d1 = data[off + dataLength] & 0xff; d2 = data[off + dataLength + 1] & 0xff; b1 = (d1 >> 2) & 0x3f;
b2 = ((d1 << 4) | (d2 >> 4)) & 0x3f;
b3 = (d2 << 2) & 0x3f; outStream.WriteByte(encodingTable[b1]); outStream.WriteByte(encodingTable[b2]); outStream.WriteByte(encodingTable[b3]); outStream.WriteByte(padding); break; } return (dataLength / 3) * 4 + ((modulus == 0) ? 0 : 4); } private bool ignore( char c) { return (c == ' ' || c ==' ' || c == ' ' || c == ' '); } /** * decode the base 64 encoded byte data writing it to the given output stream, * whitespace characters will be ignored. * * @return the number of bytes produced. */ public int Decode( byte[] data, int off, int length, Stream outStream) { byte b1, b2, b3, b4; int outLen = 0; int end = off + length; while (end > off)
{
if (!ignore((char)data[end – 1]))
{
break;
}

end–;
}

int i = off;
int finish = end – 4;

i = nextI(data, i, finish);

while (i < finish) { b1 = decodingTable[data[i++]]; i = nextI(data, i, finish); b2 = decodingTable[data[i++]]; i = nextI(data, i, finish); b3 = decodingTable[data[i++]]; i = nextI(data, i, finish); b4 = decodingTable[data[i++]]; outStream.WriteByte((byte)((b1 << 2) | (b2 >> 4)));
outStream.WriteByte((byte)((b2 << 4) | (b3 >> 2)));
outStream.WriteByte((byte)((b3 << 6) | b4)); outLen += 3; i = nextI(data, i, finish); } outLen += decodeLastBlock(outStream, (char)data[end - 4], (char)data[end - 3], (char)data[end - 2], (char)data[end - 1]); return outLen; } private int nextI( byte[] data, int i, int finish) { while ((i < finish) && ignore((char)data[i])) { i++; } return i; } /** * decode the base 64 encoded string data writing it to the given output stream, * whitespace characters will be ignored. * * @return the number of bytes produced. */ public int DecodeString( string data, Stream outStream) { // Platform Implementation // byte[] bytes = Convert.FromBase64String(data); // outStream.Write(bytes, 0, bytes.Length); // return bytes.Length; byte b1, b2, b3, b4; int length = 0; int end = data.Length; while (end > 0)
{
if (!ignore(data[end – 1]))
{
break;
}

end–;
}

int i = 0;
int finish = end – 4;

i = nextI(data, i, finish);

return 1;
}

if (c4 == padding)
{
byte b1 = decodingTable[c1];
byte b2 = decodingTable[c2];
byte b3 = decodingTable[c3];

outStream.WriteByte((byte)((b1 << 2) | (b2 >> 4)));
outStream.WriteByte((byte)((b2 << 4) | (b3 >> 2)));

return 2;
}

{
byte b1 = decodingTable[c1];
byte b2 = decodingTable[c2];
byte b3 = decodingTable[c3];
byte b4 = decodingTable[c4];

outStream.WriteByte((byte)((b1 << 2) | (b2 >> 4)));
outStream.WriteByte((byte)((b2 << 4) | (b3 >> 2)));
outStream.WriteByte((byte)((b3 << 6) | b4)); return 3; } } private int nextI(string data, int i, int finish) { while ((i < finish) && ignore(data[i])) { i++; } return i; } } } [/csharp]

Base 64 encode

Posted on February 11, 2011June 27, 2015 by coder

   
 
//http://www.bouncycastle.org/
//MIT X11 License


using System;
using System.IO;
using System.Text;

namespace Org.BouncyCastle.Utilities.Encoders
{
  public sealed class Base64
  {
//    private static readonly IEncoder encoder = new Base64Encoder();

    private Base64()
    {
    }

    /**
     * encode the input data producing a base 64 encoded byte array.
     *
     * @return a byte array containing the base 64 encoded data.
     */
    public static byte[] Encode(
      byte[] data)
    {
      string s = Convert.ToBase64String(data, 0, data.Length);
      return Encoding.ASCII.GetBytes(s);

//      MemoryStream bOut = new MemoryStream();
//      encoder.Encode(data, 0, data.Length, bOut);
//      return bOut.ToArray();
    }

    /**
     * Encode the byte data to base 64 writing it to the given output stream.
     *
     * @return the number of bytes produced.
     */
    public static int Encode(
      byte[]  data,
      Stream  outStream)
    {
      string s = Convert.ToBase64String(data, 0, data.Length);
      byte[] encoded = Encoding.ASCII.GetBytes(s);
      outStream.Write(encoded, 0, encoded.Length);
      return encoded.Length;

//      return encoder.Encode(data, 0, data.Length, outStream);
    }

    /**
     * Encode the byte data to base 64 writing it to the given output stream.
     *
     * @return the number of bytes produced.
     */
    public static int Encode(
      byte[]  data,
      int    off,
      int    length,
      Stream  outStream)
    {
      string s = Convert.ToBase64String(data, off, length);
      byte[] encoded = Encoding.ASCII.GetBytes(s);
      outStream.Write(encoded, 0, encoded.Length);
      return encoded.Length;

//      return encoder.Encode(data, off, length, outStream);
    }

    /**
     * decode the base 64 encoded input data. It is assumed the input data is valid.
     *
     * @return a byte array representing the decoded data.
     */
    public static byte[] Decode(
      byte[] data)
    {
      string s = Encoding.ASCII.GetString(data, 0, data.Length);
      return Convert.FromBase64String(s);

//      MemoryStream bOut = new MemoryStream();
//      encoder.Decode(data, 0, data.Length, bOut);
//      return bOut.ToArray();
    }

    /**
     * decode the base 64 encoded string data - whitespace will be ignored.
     *
     * @return a byte array representing the decoded data.
     */
    public static byte[] Decode(
      string data)
    {
      return Convert.FromBase64String(data);

//      MemoryStream bOut = new MemoryStream();
//      encoder.DecodeString(data, bOut);
//      return bOut.ToArray();
    }

    /**
     * decode the base 64 encoded string data writing it to the given output stream,
     * whitespace characters will be ignored.
     *
     * @return the number of bytes produced.
     */
    public static int Decode(
      string  data,
      Stream  outStream)
    {
      byte[] decoded = Decode(data);
      outStream.Write(decoded, 0, decoded.Length);
      return decoded.Length;

//      return encoder.DecodeString(data, outStream);
    }
  }
}

Double To Int 64 Bits, Int 64 Bits To Double

Posted on February 11, 2011June 27, 2015 by coder

   
 
// Portions copyright 2005 - 2007: Diego Guidi
// Portions copyright 2006 - 2008: Rory Plaire (codekaizen@gmail.com)
//
// This file is part of GeoAPI.
// GeoAPI is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// GeoAPI is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License
// along with GeoAPI; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 

#if NETCF
using System;

namespace GeoAPI.DataStructures
{
    /// <summary>
    /// A supoort class: the purpose is to integrate System.BitConverter 
    /// methods not presents in .NET Compact Framework.
    /// </summary>
    public class BitConverter
    {
        public static Int64 DoubleToInt64Bits(Double x)
        {
#if UNSAFE
            unsafe
            {
                return *(Int64*)&amp;x;
            }
#else
            Byte[] bytes = System.BitConverter.GetBytes(x);
            Int64 value = System.BitConverter.ToInt64(bytes, 0);
            return value;
#endif
        }

        public static Double Int64BitsToDouble(Int64 x)
        {
#if UNSAFE
            unsafe
            {
                return *(Double*)&amp;x;
            }
#else
            Byte[] bytes = System.BitConverter.GetBytes(x);
            Double value = System.BitConverter.ToDouble(bytes, 0);
            return value;
#endif
        }
    }
}
#endif

Page 61 of 65

« 1 … 59 60 61 62 63 … 65 »