717 lines
27 KiB
C#
717 lines
27 KiB
C#
/******************************************************************************
|
|
* 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>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
|
|
*/
|
|
private static readonly 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
|
|
|
|
/// <summary>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.
|
|
/// </summary>
|
|
/*
|
|
* 6-bit decoded value base64 base64
|
|
* encoded character
|
|
* value
|
|
*
|
|
* Note: about half of the values in the table are only place holders
|
|
*/
|
|
private static readonly 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 '
|
|
|
|
/// <summary> Default constructor, don't allow instances of the
|
|
/// utility class to be created.
|
|
/// </summary>
|
|
private Base64()
|
|
{
|
|
return ;
|
|
}
|
|
|
|
|
|
/// <summary> Encodes the specified String into a base64 encoded String object.
|
|
///
|
|
/// </summary>
|
|
/// <param name="inputString"> The String object to be encoded.
|
|
///
|
|
/// </param>
|
|
/// <returns> a String containing the encoded value of the input.
|
|
/// </returns>
|
|
public static System.String encode(System.String inputString)
|
|
{
|
|
try
|
|
{
|
|
System.Text.Encoding encoder = System.Text.Encoding.GetEncoding("utf-8");
|
|
byte[] ibytes = encoder.GetBytes(inputString);
|
|
sbyte[] sbytes=SupportClass.ToSByteArray(ibytes);
|
|
return encode(sbytes);
|
|
}
|
|
catch (System.IO.IOException ue)
|
|
{
|
|
throw new System.SystemException("US-ASCII String encoding not supported by JVM");
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
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);
|
|
}
|
|
|
|
|
|
/// <summary> Decodes the input base64 encoded String.
|
|
/// The resulting binary data is returned as an array of bytes.
|
|
///
|
|
/// </summary>
|
|
/// <param name="encodedString">The base64 encoded String object.
|
|
///
|
|
/// </param>
|
|
/// <returns> The decoded byte array.
|
|
/// </returns>
|
|
[CLSCompliantAttribute(false)]
|
|
public static sbyte[] decode(System.String encodedString)
|
|
{
|
|
char[] c = new char[encodedString.Length];
|
|
SupportClass.GetCharsFromString(encodedString, 0, encodedString.Length, ref c, 0);
|
|
return decode(c);
|
|
}
|
|
|
|
/// <summary> Decodes the input base64 encoded array of characters.
|
|
/// The resulting binary data is returned as an array of bytes.
|
|
///
|
|
/// </summary>
|
|
/// <param name="encodedChars">The character array containing the base64 encoded data.
|
|
///
|
|
/// </param>
|
|
/// <returns> A byte array object containing decoded bytes.
|
|
/// </returns>
|
|
[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;
|
|
}
|
|
|
|
/// <summary> 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.
|
|
///
|
|
/// </summary>
|
|
/// <param name="encodedSBuf">The StringBuffer object that contains base64
|
|
/// encoded data.
|
|
/// </param>
|
|
/// <param name="start"> The start index of the base64 encoded data.
|
|
/// </param>
|
|
/// <param name="end"> The end index + 1 of the base64 encoded data.
|
|
///
|
|
/// </param>
|
|
/// <returns> The decoded byte array
|
|
/// </returns>
|
|
[CLSCompliantAttribute(false)]
|
|
public static sbyte[] decode(System.Text.StringBuilder encodedSBuf, int start, int end)
|
|
{
|
|
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
|
|
// '**==' or '***=' ( can't be '*===' or '===='), will be decoded into
|
|
// 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;
|
|
}
|
|
|
|
/// <summary> Checks if the input byte array contains only safe values, that is,
|
|
/// the data does not need to be encoded for use with LDIF.
|
|
/// The rules for checking safety are based on the rules for LDIF
|
|
/// (Ldap Data Interchange Format) per RFC 2849. The data does
|
|
/// not need to be encoded if all the following are true:
|
|
///
|
|
/// The data cannot start with the following byte values:
|
|
/// <pre>
|
|
/// 00 (NUL)
|
|
/// 10 (LF)
|
|
/// 13 (CR)
|
|
/// 32 (SPACE)
|
|
/// 58 (:)
|
|
/// 60 (LESSTHAN)
|
|
/// Any character with value greater than 127
|
|
/// (Negative for a byte value)
|
|
/// </pre>
|
|
/// The data cannot contain any of the following byte values:
|
|
/// <pre>
|
|
/// 00 (NUL)
|
|
/// 10 (LF)
|
|
/// 13 (CR)
|
|
/// Any character with value greater than 127
|
|
/// (Negative for a byte value)
|
|
/// </pre>
|
|
/// The data cannot end with a space.
|
|
///
|
|
/// </summary>
|
|
/// <param name="bytes">the bytes to be checked.
|
|
///
|
|
/// </param>
|
|
/// <returns> true if encoding not required for LDIF
|
|
/// </returns>
|
|
[CLSCompliantAttribute(false)]
|
|
public static bool isLDIFSafe(sbyte[] bytes)
|
|
{
|
|
int len = bytes.Length;
|
|
if (len > 0)
|
|
{
|
|
int testChar = bytes[0];
|
|
// unsafe if first character is a NON-SAFE-INIT-CHAR
|
|
if ((testChar == 0x00) || (testChar == 0x0A) || (testChar == 0x0D) || (testChar == 0x20) || (testChar == 0x3A) || (testChar == 0x3C) || (testChar < 0))
|
|
{
|
|
// non ascii (>127 is negative)
|
|
return false;
|
|
}
|
|
// unsafe if last character is a space
|
|
if (bytes[len - 1] == ' ')
|
|
{
|
|
return false;
|
|
}
|
|
// unsafe if contains any non safe character
|
|
if (len > 1)
|
|
{
|
|
for (int i = 1; i < bytes.Length; i++)
|
|
{
|
|
testChar = bytes[i];
|
|
if ((testChar == 0x00) || (testChar == 0x0A) || (testChar == 0x0D) || (testChar < 0))
|
|
{
|
|
// non ascii (>127 is negative)
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/// <summary> Checks if the input String contains only safe values, that is,
|
|
/// the data does not need to be encoded for use with LDIF.
|
|
/// The rules for checking safety are based on the rules for LDIF
|
|
/// (Ldap Data Interchange Format) per RFC 2849. The data does
|
|
/// not need to be encoded if all the following are true:
|
|
///
|
|
/// The data cannot start with the following char values:
|
|
/// <pre>
|
|
/// 00 (NUL)
|
|
/// 10 (LF)
|
|
/// 13 (CR)
|
|
/// 32 (SPACE)
|
|
/// 58 (:)
|
|
/// 60 (LESSTHAN)
|
|
/// Any character with value greater than 127
|
|
/// </pre>
|
|
/// The data cannot contain any of the following char values:
|
|
/// <pre>
|
|
/// 00 (NUL)
|
|
/// 10 (LF)
|
|
/// 13 (CR)
|
|
/// Any character with value greater than 127
|
|
/// </pre>
|
|
/// The data cannot end with a space.
|
|
///
|
|
/// </summary>
|
|
/// <param name="str">the String to be checked.
|
|
///
|
|
/// </param>
|
|
/// <returns> true if encoding not required for LDIF
|
|
/// </returns>
|
|
public static bool isLDIFSafe(System.String str)
|
|
{
|
|
try
|
|
{
|
|
System.Text.Encoding encoder = System.Text.Encoding.GetEncoding("utf-8");
|
|
byte[] ibytes = encoder.GetBytes(str);
|
|
sbyte[] sbytes=SupportClass.ToSByteArray(ibytes); return (isLDIFSafe(sbytes));
|
|
}
|
|
catch (System.IO.IOException ue)
|
|
{
|
|
throw new System.SystemException("UTF-8 String encoding not supported by JVM");
|
|
}
|
|
}
|
|
|
|
/* **************UTF-8 Validation methods and members*******************
|
|
* The following text is taken from draft-yergeau-rfc2279bis-02 and explains
|
|
* UTF-8 encoding:
|
|
*
|
|
*In UTF-8, characters are encoded using sequences of 1 to 6 octets.
|
|
* If the range of character numbers is restricted to U+0000..U+10FFFF
|
|
* (the UTF-16 accessible range), then only sequences of one to four
|
|
* octets will occur. The only octet of a "sequence" of one has the
|
|
* higher-order bit set to 0, the remaining 7 bits being used to encode
|
|
* the character number. In a sequence of n octets, n>1, the initial
|
|
* octet has the n higher-order bits set to 1, followed by a bit set to
|
|
* 0. The remaining bit(s) of that octet contain bits from the number
|
|
* of the character to be encoded. The following octet(s) all have the
|
|
* higher-order bit set to 1 and the following bit set to 0, leaving 6
|
|
* bits in each to contain bits from the character to be encoded.
|
|
*
|
|
* The table below summarizes the format of these different octet types.
|
|
* The letter x indicates bits available for encoding bits of the
|
|
* character number.
|
|
*
|
|
* <pre>
|
|
* Char. number range | UTF-8 octet sequence
|
|
* (hexadecimal) | (binary)
|
|
* --------------------+---------------------------------------------
|
|
* 0000 0000-0000 007F | 0xxxxxxx
|
|
* 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
|
|
* 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
|
|
* 0001 0000-001F FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
* 0020 0000-03FF FFFF | 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
* 0400 0000-7FFF FFFF | 1111110x 10xxxxxx ... 10xxxxxx
|
|
* </pre>
|
|
*/
|
|
|
|
/// <summary> Given the first byte in a sequence, getByteCount returns the number of
|
|
/// additional bytes in a UTF-8 character sequence (not including the first
|
|
/// byte).
|
|
///
|
|
/// </summary>
|
|
/// <param name="b"> The first byte in a UTF-8 character sequence.
|
|
///
|
|
/// </param>
|
|
/// <returns> the number of additional bytes in a UTF-8 character sequence.
|
|
/// </returns>
|
|
private static int getByteCount(sbyte b)
|
|
{
|
|
if (b > 0)
|
|
return 0;
|
|
if ((b & 0xE0) == 0xC0)
|
|
{
|
|
return 1; //one additional byte (2 bytes total)
|
|
}
|
|
if ((b & 0xF0) == 0xE0)
|
|
{
|
|
return 2; //two additional bytes (3 bytes total)
|
|
}
|
|
if ((b & 0xF8) == 0xF0)
|
|
{
|
|
return 3; //three additional bytes (4 bytes total)
|
|
}
|
|
if ((b & 0xFC) == 0xF8)
|
|
{
|
|
return 4; //four additional bytes (5 bytes total)
|
|
}
|
|
if ((b & 0xFF) == 0xFC)
|
|
{
|
|
return 5; //five additional bytes (6 bytes total)
|
|
}
|
|
return - 1;
|
|
}
|
|
|
|
/// <summary> Bit masks used to determine if a the value of UTF-8 byte sequence
|
|
/// is less than the minimum value.
|
|
///
|
|
/// If the value of a byte sequence is less than the minimum value then
|
|
/// the number should be encoded in fewer bytes and is invalid. For example
|
|
/// If the first byte indicates that a sequence has three bytes in a
|
|
/// sequence. Then the top five bits cannot be zero. Notice the index into
|
|
/// the array is one less than the number of bytes in a sequence.
|
|
/// A validity test for this could be:
|
|
/// </summary>
|
|
private static readonly sbyte[][] lowerBoundMask = {new sbyte[]{0, 0}, new sbyte[]{(sbyte) (0x1E), (sbyte) (0x00)}, new sbyte[]{(sbyte) (0x0F), (sbyte) (0x20)}, new sbyte[]{(sbyte) (0x07), (sbyte) (0x30)}, new sbyte[]{(sbyte) (0x02), (sbyte) (0x38)}, new sbyte[]{(sbyte) (0x01), (sbyte) (0x3C)}};
|
|
|
|
/// <summary>mask to AND with a continuation byte: should equal continuationResult </summary>
|
|
private static sbyte continuationMask = (sbyte) SupportClass.Identity(0xC0);
|
|
|
|
/// <summary>expected result of ANDing a continuation byte with continuationMask </summary>
|
|
private static sbyte continuationResult = (sbyte) SupportClass.Identity(0x80);
|
|
|
|
/// <summary> Determines if an array of bytes contains only valid UTF-8 characters.
|
|
///
|
|
/// UTF-8 is the standard encoding for Ldap strings. If a value contains
|
|
/// data that is not valid UTF-8 then data is lost converting the
|
|
/// value to a Java String.
|
|
///
|
|
///
|
|
/// In addition, Java Strings currently use UCS2 (Unicode Code Standard
|
|
/// 2-byte characters). UTF-8 can be encoded as USC2 and UCS4 (4-byte
|
|
/// characters). Some valid UTF-8 characters cannot be represented as UCS2
|
|
/// characters. To determine if all UTF-8 sequences can be encoded into
|
|
/// UCS2 characters (a Java String), specify the <code>isUCS2Only</code>
|
|
/// parameter as <code>true</code>.
|
|
///
|
|
/// </summary>
|
|
/// <param name="array"> An array of bytes that are to be tested for valid UTF-8
|
|
/// encoding.
|
|
///
|
|
/// </param>
|
|
/// <param name="isUCS2Only">true if the UTF-8 values must be restricted to fit
|
|
/// within UCS2 encoding (2 bytes)
|
|
/// </param>
|
|
/// <returns> true if all values in the byte array are valid UTF-8
|
|
/// sequences. If <code>isUCS2Only</code> is
|
|
/// <code>true</code>, the method returns false if a UTF-8
|
|
/// sequence generates any character that cannot be
|
|
/// represented as a UCS2 character (Java String)
|
|
/// </returns>
|
|
[CLSCompliantAttribute(false)]
|
|
public static bool isValidUTF8(sbyte[] array, bool isUCS2Only)
|
|
{
|
|
int index = 0;
|
|
while (index < array.Length)
|
|
{
|
|
int count = getByteCount(array[index]);
|
|
if (count == 0)
|
|
{
|
|
//anything that qualifies as count=0 is valid UTF-8
|
|
index++;
|
|
continue;
|
|
}
|
|
|
|
if (count == - 1 || index + count >= array.Length || (isUCS2Only && count >= 3))
|
|
{
|
|
/* Any count that puts us out of bounds for the index is
|
|
* invalid. Valid UCS2 characters can only have 2 additional
|
|
* bytes. (three total) */
|
|
return false;
|
|
}
|
|
|
|
/* Tests if the first and second byte are below the minimum bound */
|
|
if ((lowerBoundMask[count][0] & array[index]) == 0 && (lowerBoundMask[count][1] & array[index + 1]) == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/* testing continuation on the second and following bytes */
|
|
for (int i = 1; i <= count; i++)
|
|
{
|
|
if ((array[index + i] & continuationMask) != continuationResult)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
index += count + 1;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|