| /*************************************************************************************************** |
| * 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; |
| } |
| } |