plugins/org.eclipse.wst.common.emf/wtpemf/org/eclipse/wst/common/internal/emf/utilities/PasswordUtil.java - webtools-common/webtools.common - Git at Google

 /***************************************************************************************************
  * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
  * accompanying materials are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors: IBM Corporation - initial API and implementation
  **************************************************************************************************/
 package org.eclipse.wst.common.internal.emf.utilities;


 import java.io.UnsupportedEncodingException;

 public class PasswordUtil {
 	public static final String STRING_CONVERSION_CODE = "UTF8"; //$NON-NLS-1$
 	public static final String EMPTY_STRING = ""; //$NON-NLS-1$
 	public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
 	public static final String DEFAULT_CRYPTO_ALGORITHM;
 	private static final String SUPPORTED_CRYPTO_ALGORITHMS[];
 	private static final byte BASE64_ENCODE_MAP[];
 	private static final byte BASE64_DECODE_MAP[];

 	public PasswordUtil() {
 	}

 	public static String decode(String s) throws InvalidPasswordDecodingException, UnsupportedCryptoAlgorithmException {
 		if (s == null)
 			throw new InvalidPasswordDecodingException();
 		String s1 = getCryptoAlgorithm(s);
 		if (s1 == null)
 			throw new InvalidPasswordDecodingException();

 		if (!isValidCryptoAlgorithm(s1))
 			throw new UnsupportedCryptoAlgorithmException();

 		String s2 = decode_password(removeCryptoAlgorithmTag(s), s1);
 		if (s2 == null)
 			throw new InvalidPasswordDecodingException();
 		return s2;
 	}

 	public static String encode(String s) throws InvalidPasswordEncodingException, UnsupportedCryptoAlgorithmException {
 		return encode(s, DEFAULT_CRYPTO_ALGORITHM);
 	}

 	public static String encode(String s, String s1) throws InvalidPasswordEncodingException, UnsupportedCryptoAlgorithmException {
 		if (!isValidCryptoAlgorithm(s1))
 			throw new UnsupportedCryptoAlgorithmException();
 		if (s == null)
 			throw new InvalidPasswordEncodingException();

 		if (getCryptoAlgorithm(s) != null)
 			throw new InvalidPasswordEncodingException();

 		String s2 = encode_password(s.trim(), s1.trim());
 		if (s2 == null)
 			throw new InvalidPasswordEncodingException();
 		return s2;
 	}

 	public static String getCryptoAlgorithm(String s) {
 		String s1 = null;
 		if (s != null) {
 			s = s.trim();
 			if (s.length() >= 2) {
 				int i = s.indexOf("{"); //$NON-NLS-1$
 				if (i == 0) {
 					int j = s.indexOf("}", ++i); //$NON-NLS-1$
 					if (j > 0)
 						if (i < j)
 							s1 = s.substring(i, j).trim();
 						else
 							s1 = EMPTY_STRING;
 				}
 			}
 		}
 		return s1;
 	}

 	public static String getCryptoAlgorithmTag(String s) {
 		String s1 = null;
 		String s2 = getCryptoAlgorithm(s);
 		if (s2 != null) {
 			StringBuffer stringbuffer = new StringBuffer("{"); //$NON-NLS-1$
 			if (s2.length() > 0)
 				stringbuffer.append(s2);
 			stringbuffer.append("}"); //$NON-NLS-1$
 			s1 = stringbuffer.toString();
 		}
 		return s1;
 	}

 	public static boolean isValidCryptoAlgorithm(String s) {
 		if (s != null) {
 			s = s.trim();
 			if (s.length() == 0)
 				return true;
 			for (int i = 0; i < SUPPORTED_CRYPTO_ALGORITHMS.length; i++)
 				if (s.equalsIgnoreCase(SUPPORTED_CRYPTO_ALGORITHMS[i]))
 					return true;
 		}
 		return false;
 	}

 	public static boolean isValidCryptoAlgorithmTag(String s) {
 		return isValidCryptoAlgorithm(getCryptoAlgorithm(s));
 	}

 	public static String passwordDecode(String s) {
 		if (s == null)
 			return null;
 		String s1 = getCryptoAlgorithm(s);
 		if (s1 == null)
 			return s;
 		if (!isValidCryptoAlgorithm(s1))
 			return null;
 		return decode_password(removeCryptoAlgorithmTag(s), s1);
 	}

 	public static String passwordEncode(String s) {
 		return passwordEncode(s, DEFAULT_CRYPTO_ALGORITHM);
 	}

 	public static String passwordEncode(String s, String s1) {
 		if (!isValidCryptoAlgorithm(s1))
 			return null;
 		if (s == null)
 			return null;
 		String s2 = getCryptoAlgorithm(s);
 		if (s2 != null) {
 			if (s2.equalsIgnoreCase(s1.trim()))
 				return s.trim();
 			return null;
 		}
 		return encode_password(s.trim(), s1.trim());
 	}

 	public static String removeCryptoAlgorithmTag(String s) {
 		String s1 = null;
 		if (s != null) {
 			s = s.trim();
 			if (s.length() >= 2) {
 				int i = s.indexOf("{"); //$NON-NLS-1$
 				if (i == 0) {
 					int j = s.indexOf("}", ++i); //$NON-NLS-1$
 					if (j > 0)
 						if (++j < s.length())
 							s1 = s.substring(j).trim();
 						else
 							s1 = EMPTY_STRING;
 				}
 			}
 		}
 		return s1;
 	}

 	private static byte[] convert_to_bytes(String s) {
 		byte abyte0[] = null;
 		if (s != null)
 			if (s.length() == 0)
 				abyte0 = EMPTY_BYTE_ARRAY;
 			else
 				try {
 					abyte0 = s.getBytes(STRING_CONVERSION_CODE);
 				} catch (UnsupportedEncodingException unsupportedencodingexception) {
 					abyte0 = null;
 				}
 		return abyte0;
 	}

 	private static String convert_to_string(byte abyte0[]) {
 		String s = null;
 		if (abyte0 != null)
 			if (abyte0.length == 0)
 				s = EMPTY_STRING;
 			else
 				try {
 					s = new String(abyte0, STRING_CONVERSION_CODE);
 				} catch (UnsupportedEncodingException unsupportedencodingexception) {
 					s = null;
 				}
 		return s;
 	}

 	private static byte[] convert_viewable_to_bytes(String s) {
 		byte abyte0[] = null;
 		if (s != null)
 			if (s.length() == 0)
 				abyte0 = EMPTY_BYTE_ARRAY;
 			else
 				try {
 					abyte0 = base64Decode(convert_to_bytes(s));
 				} catch (Exception exception) {
 					abyte0 = null;
 				}
 		return abyte0;
 	}

 	private static byte[] base64Decode(byte abyte0[]) {
 		int i;
 		for (i = abyte0.length; abyte0[--i] == 61;);
 		byte abyte1[] = new byte[(i + 1) - abyte0.length / 4];
 		for (int j = 0; j < abyte0.length; j++)
 			abyte0[j] = BASE64_DECODE_MAP[abyte0[j]];
 		int k = abyte1.length - 2;
 		int l = 0;
 		int i1;
 		for (i1 = 0; l < k; i1 += 4) {
 			abyte1[l] = (byte) (abyte0[i1] << 2 & 0xff | abyte0[i1 + 1] >>> 4 & 0x3);
 			abyte1[l + 1] = (byte) (abyte0[i1 + 1] << 4 & 0xff | abyte0[i1 + 2] >>> 2 & 0xf);
 			abyte1[l + 2] = (byte) (abyte0[i1 + 2] << 6 & 0xff | abyte0[i1 + 3] & 0x3f);
 			l += 3;
 		}
 		if (l < abyte1.length) {
 			abyte1[l++] = (byte) (abyte0[i1] << 2 & 0xff | abyte0[i1 + 1] >>> 4 & 0x3);
 			if (l < abyte1.length)
 				abyte1[l] = (byte) (abyte0[i1 + 1] << 4 & 0xff | abyte0[i1 + 2] >>> 2 & 0xf);
 		}
 		return abyte1;
 	}

 	private static String convert_viewable_to_string(byte abyte0[]) {
 		String s = null;
 		if (abyte0 != null)
 			if (abyte0.length == 0)
 				s = EMPTY_STRING;
 			else
 				try {
 					s = convert_to_string(base64Encode(abyte0));
 				} catch (Exception exception) {
 					s = null;
 				}
 		return s;
 	}

 	private static byte[] base64Encode(byte abyte0[]) {
 		byte abyte1[] = new byte[((abyte0.length + 2) / 3) * 4];
 		int i = 0;
 		int j = 0;
 		for (; i < abyte0.length - 2; i += 3) {
 			abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i] >>> 2 & 0x3f];
 			abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i + 1] >>> 4 & 0xf | abyte0[i] << 4 & 0x3f];
 			abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i + 2] >>> 6 & 0x3 | abyte0[i + 1] << 2 & 0x3f];
 			abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i + 2] & 0x3f];
 		}
 		if (i < abyte0.length) {
 			abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i] >>> 2 & 0x3f];
 			if (i < abyte0.length - 1) {
 				abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i + 1] >>> 4 & 0xf | abyte0[i] << 4 & 0x3f];
 				abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i + 1] << 2 & 0x3f];
 			} else {
 				abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i] << 4 & 0x3f];
 			}
 		}
 		for (; j < abyte1.length; j++)
 			abyte1[j] = 61;
 		return abyte1;
 	}

 	private static String decode_password(String s, String s1) {
 		StringBuffer stringbuffer = new StringBuffer();
 		if (s1.length() == 0) {
 			stringbuffer.append(s);
 		} else {
 			String s2 = null;
 			if (s.length() > 0) {
 				byte abyte0[] = convert_viewable_to_bytes(s);
 				if (abyte0 == null)
 					return null;
 				if (abyte0.length > 0) {
 					byte abyte1[] = null;
 					try {
 						abyte1 = PasswordCipherUtil.decipher(abyte0, s1);
 					} catch (InvalidPasswordCipherException invalidpasswordcipherexception) {
 						return null;
 					} catch (UnsupportedCryptoAlgorithmException unsupportedcryptoalgorithmexception) {
 						return null;
 					}
 					if (abyte1 != null && abyte1.length > 0)
 						s2 = convert_to_string(abyte1);
 				}
 			}
 			if (s2 != null && s2.length() > 0)
 				stringbuffer.append(s2);
 		}
 		return stringbuffer.toString();
 	}

 	private static String encode_password(String s, String s1) {
 		StringBuffer stringbuffer = new StringBuffer("{"); //$NON-NLS-1$
 		if (s1.length() == 0) {
 			stringbuffer.append("}").append(s); //$NON-NLS-1$
 		} else {
 			stringbuffer.append(s1).append("}"); //$NON-NLS-1$
 			String s2 = null;
 			if (s.length() > 0) {
 				byte abyte0[] = convert_to_bytes(s);
 				if (abyte0.length > 0) {
 					byte abyte1[] = null;
 					try {
 						abyte1 = PasswordCipherUtil.encipher(abyte0, s1);
 					} catch (InvalidPasswordCipherException invalidpasswordcipherexception) {
 						return null;
 					} catch (UnsupportedCryptoAlgorithmException unsupportedcryptoalgorithmexception) {
 						return null;
 					}
 					if (abyte1 != null && abyte1.length > 0) {
 						s2 = convert_viewable_to_string(abyte1);
 						if (s2 == null)
 							return null;
 					}
 				}
 			}
 			if (s2 != null && s2.length() > 0)
 				stringbuffer.append(s2);
 		}
 		return stringbuffer.toString();
 	}

 	static {
 		SUPPORTED_CRYPTO_ALGORITHMS = PasswordCipherUtil.getSupportedCryptoAlgorithms();
 		DEFAULT_CRYPTO_ALGORITHM = SUPPORTED_CRYPTO_ALGORITHMS[0];
 		byte abyte0[] = {65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47};
 		BASE64_ENCODE_MAP = abyte0;
 		BASE64_DECODE_MAP = new byte[128];
 		for (int i = 0; i < BASE64_DECODE_MAP.length; i++)
 			BASE64_DECODE_MAP[i] = -1;
 		for (int j = 0; j < BASE64_ENCODE_MAP.length; j++)
 			BASE64_DECODE_MAP[BASE64_ENCODE_MAP[j]] = (byte) j;
 	}
 }
	/***************************************************************************************************
	* Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
	* accompanying materials are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors: IBM Corporation - initial API and implementation
	**************************************************************************************************/
	package org.eclipse.wst.common.internal.emf.utilities;


	import java.io.UnsupportedEncodingException;

	public class PasswordUtil {
	public static final String STRING_CONVERSION_CODE = "UTF8"; //$NON-NLS-1$
	public static final String EMPTY_STRING = ""; //$NON-NLS-1$
	public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
	public static final String DEFAULT_CRYPTO_ALGORITHM;
	private static final String SUPPORTED_CRYPTO_ALGORITHMS[];
	private static final byte BASE64_ENCODE_MAP[];
	private static final byte BASE64_DECODE_MAP[];

	public PasswordUtil() {
	}

	public static String decode(String s) throws InvalidPasswordDecodingException, UnsupportedCryptoAlgorithmException {
	if (s == null)
	throw new InvalidPasswordDecodingException();
	String s1 = getCryptoAlgorithm(s);
	if (s1 == null)
	throw new InvalidPasswordDecodingException();

	if (!isValidCryptoAlgorithm(s1))
	throw new UnsupportedCryptoAlgorithmException();

	String s2 = decode_password(removeCryptoAlgorithmTag(s), s1);
	if (s2 == null)
	throw new InvalidPasswordDecodingException();
	return s2;
	}

	public static String encode(String s) throws InvalidPasswordEncodingException, UnsupportedCryptoAlgorithmException {
	return encode(s, DEFAULT_CRYPTO_ALGORITHM);
	}

	public static String encode(String s, String s1) throws InvalidPasswordEncodingException, UnsupportedCryptoAlgorithmException {
	if (!isValidCryptoAlgorithm(s1))
	throw new UnsupportedCryptoAlgorithmException();
	if (s == null)
	throw new InvalidPasswordEncodingException();

	if (getCryptoAlgorithm(s) != null)
	throw new InvalidPasswordEncodingException();

	String s2 = encode_password(s.trim(), s1.trim());
	if (s2 == null)
	throw new InvalidPasswordEncodingException();
	return s2;
	}

	public static String getCryptoAlgorithm(String s) {
	String s1 = null;
	if (s != null) {
	s = s.trim();
	if (s.length() >= 2) {
	int i = s.indexOf("{"); //$NON-NLS-1$
	if (i == 0) {
	int j = s.indexOf("}", ++i); //$NON-NLS-1$
	if (j > 0)
	if (i < j)
	s1 = s.substring(i, j).trim();
	else
	s1 = EMPTY_STRING;
	}
	}
	}
	return s1;
	}

	public static String getCryptoAlgorithmTag(String s) {
	String s1 = null;
	String s2 = getCryptoAlgorithm(s);
	if (s2 != null) {
	StringBuffer stringbuffer = new StringBuffer("{"); //$NON-NLS-1$
	if (s2.length() > 0)
	stringbuffer.append(s2);
	stringbuffer.append("}"); //$NON-NLS-1$
	s1 = stringbuffer.toString();
	}
	return s1;
	}

	public static boolean isValidCryptoAlgorithm(String s) {
	if (s != null) {
	s = s.trim();
	if (s.length() == 0)
	return true;
	for (int i = 0; i < SUPPORTED_CRYPTO_ALGORITHMS.length; i++)
	if (s.equalsIgnoreCase(SUPPORTED_CRYPTO_ALGORITHMS[i]))
	return true;
	}
	return false;
	}

	public static boolean isValidCryptoAlgorithmTag(String s) {
	return isValidCryptoAlgorithm(getCryptoAlgorithm(s));
	}

	public static String passwordDecode(String s) {
	if (s == null)
	return null;
	String s1 = getCryptoAlgorithm(s);
	if (s1 == null)
	return s;
	if (!isValidCryptoAlgorithm(s1))
	return null;
	return decode_password(removeCryptoAlgorithmTag(s), s1);
	}

	public static String passwordEncode(String s) {
	return passwordEncode(s, DEFAULT_CRYPTO_ALGORITHM);
	}

	public static String passwordEncode(String s, String s1) {
	if (!isValidCryptoAlgorithm(s1))
	return null;
	if (s == null)
	return null;
	String s2 = getCryptoAlgorithm(s);
	if (s2 != null) {
	if (s2.equalsIgnoreCase(s1.trim()))
	return s.trim();
	return null;
	}
	return encode_password(s.trim(), s1.trim());
	}

	public static String removeCryptoAlgorithmTag(String s) {
	String s1 = null;
	if (s != null) {
	s = s.trim();
	if (s.length() >= 2) {
	int i = s.indexOf("{"); //$NON-NLS-1$
	if (i == 0) {
	int j = s.indexOf("}", ++i); //$NON-NLS-1$
	if (j > 0)
	if (++j < s.length())
	s1 = s.substring(j).trim();
	else
	s1 = EMPTY_STRING;
	}
	}
	}
	return s1;
	}

	private static byte[] convert_to_bytes(String s) {
	byte abyte0[] = null;
	if (s != null)
	if (s.length() == 0)
	abyte0 = EMPTY_BYTE_ARRAY;
	else
	try {
	abyte0 = s.getBytes(STRING_CONVERSION_CODE);
	} catch (UnsupportedEncodingException unsupportedencodingexception) {
	abyte0 = null;
	}
	return abyte0;
	}

	private static String convert_to_string(byte abyte0[]) {
	String s = null;
	if (abyte0 != null)
	if (abyte0.length == 0)
	s = EMPTY_STRING;
	else
	try {
	s = new String(abyte0, STRING_CONVERSION_CODE);
	} catch (UnsupportedEncodingException unsupportedencodingexception) {
	s = null;
	}
	return s;
	}

	private static byte[] convert_viewable_to_bytes(String s) {
	byte abyte0[] = null;
	if (s != null)
	if (s.length() == 0)
	abyte0 = EMPTY_BYTE_ARRAY;
	else
	try {
	abyte0 = base64Decode(convert_to_bytes(s));
	} catch (Exception exception) {
	abyte0 = null;
	}
	return abyte0;
	}

	private static byte[] base64Decode(byte abyte0[]) {
	int i;
	for (i = abyte0.length; abyte0[--i] == 61;);
	byte abyte1[] = new byte[(i + 1) - abyte0.length / 4];
	for (int j = 0; j < abyte0.length; j++)
	abyte0[j] = BASE64_DECODE_MAP[abyte0[j]];
	int k = abyte1.length - 2;
	int l = 0;
	int i1;
	for (i1 = 0; l < k; i1 += 4) {
	abyte1[l] = (byte) (abyte0[i1] << 2 & 0xff \| abyte0[i1 + 1] >>> 4 & 0x3);
	abyte1[l + 1] = (byte) (abyte0[i1 + 1] << 4 & 0xff \| abyte0[i1 + 2] >>> 2 & 0xf);
	abyte1[l + 2] = (byte) (abyte0[i1 + 2] << 6 & 0xff \| abyte0[i1 + 3] & 0x3f);
	l += 3;
	}
	if (l < abyte1.length) {
	abyte1[l++] = (byte) (abyte0[i1] << 2 & 0xff \| abyte0[i1 + 1] >>> 4 & 0x3);
	if (l < abyte1.length)
	abyte1[l] = (byte) (abyte0[i1 + 1] << 4 & 0xff \| abyte0[i1 + 2] >>> 2 & 0xf);
	}
	return abyte1;
	}

	private static String convert_viewable_to_string(byte abyte0[]) {
	String s = null;
	if (abyte0 != null)
	if (abyte0.length == 0)
	s = EMPTY_STRING;
	else
	try {
	s = convert_to_string(base64Encode(abyte0));
	} catch (Exception exception) {
	s = null;
	}
	return s;
	}

	private static byte[] base64Encode(byte abyte0[]) {
	byte abyte1[] = new byte[((abyte0.length + 2) / 3) * 4];
	int i = 0;
	int j = 0;
	for (; i < abyte0.length - 2; i += 3) {
	abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i] >>> 2 & 0x3f];
	abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i + 1] >>> 4 & 0xf \| abyte0[i] << 4 & 0x3f];
	abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i + 2] >>> 6 & 0x3 \| abyte0[i + 1] << 2 & 0x3f];
	abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i + 2] & 0x3f];
	}
	if (i < abyte0.length) {
	abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i] >>> 2 & 0x3f];
	if (i < abyte0.length - 1) {
	abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i + 1] >>> 4 & 0xf \| abyte0[i] << 4 & 0x3f];
	abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i + 1] << 2 & 0x3f];
	} else {
	abyte1[j++] = BASE64_ENCODE_MAP[abyte0[i] << 4 & 0x3f];
	}
	}
	for (; j < abyte1.length; j++)
	abyte1[j] = 61;
	return abyte1;
	}

	private static String decode_password(String s, String s1) {
	StringBuffer stringbuffer = new StringBuffer();
	if (s1.length() == 0) {
	stringbuffer.append(s);
	} else {
	String s2 = null;
	if (s.length() > 0) {
	byte abyte0[] = convert_viewable_to_bytes(s);
	if (abyte0 == null)
	return null;
	if (abyte0.length > 0) {
	byte abyte1[] = null;
	try {
	abyte1 = PasswordCipherUtil.decipher(abyte0, s1);
	} catch (InvalidPasswordCipherException invalidpasswordcipherexception) {
	return null;
	} catch (UnsupportedCryptoAlgorithmException unsupportedcryptoalgorithmexception) {
	return null;
	}
	if (abyte1 != null && abyte1.length > 0)
	s2 = convert_to_string(abyte1);
	}
	}
	if (s2 != null && s2.length() > 0)
	stringbuffer.append(s2);
	}
	return stringbuffer.toString();
	}

	private static String encode_password(String s, String s1) {
	StringBuffer stringbuffer = new StringBuffer("{"); //$NON-NLS-1$
	if (s1.length() == 0) {
	stringbuffer.append("}").append(s); //$NON-NLS-1$
	} else {
	stringbuffer.append(s1).append("}"); //$NON-NLS-1$
	String s2 = null;
	if (s.length() > 0) {
	byte abyte0[] = convert_to_bytes(s);
	if (abyte0.length > 0) {
	byte abyte1[] = null;
	try {
	abyte1 = PasswordCipherUtil.encipher(abyte0, s1);
	} catch (InvalidPasswordCipherException invalidpasswordcipherexception) {
	return null;
	} catch (UnsupportedCryptoAlgorithmException unsupportedcryptoalgorithmexception) {
	return null;
	}
	if (abyte1 != null && abyte1.length > 0) {
	s2 = convert_viewable_to_string(abyte1);
	if (s2 == null)
	return null;
	}
	}
	}
	if (s2 != null && s2.length() > 0)
	stringbuffer.append(s2);
	}
	return stringbuffer.toString();
	}

	static {
	SUPPORTED_CRYPTO_ALGORITHMS = PasswordCipherUtil.getSupportedCryptoAlgorithms();
	DEFAULT_CRYPTO_ALGORITHM = SUPPORTED_CRYPTO_ALGORITHMS[0];
	byte abyte0[] = {65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47};
	BASE64_ENCODE_MAP = abyte0;
	BASE64_DECODE_MAP = new byte[128];
	for (int i = 0; i < BASE64_DECODE_MAP.length; i++)
	BASE64_DECODE_MAP[i] = -1;
	for (int j = 0; j < BASE64_ENCODE_MAP.length; j++)
	BASE64_DECODE_MAP[BASE64_ENCODE_MAP[j]] = (byte) j;
	}
	}