/*
 Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
 

  The MySQL Connector/J is licensed under the terms of the GPLv2
  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most MySQL Connectors.
  There are special exceptions to the terms and conditions of the GPLv2 as it is applied to
  this software, see the FLOSS License Exception
  <http://www.mysql.com/about/legal/licensing/foss-exception.html>.

  This program is free software; you can redistribute it and/or modify it under the terms
  of the GNU General Public License as published by the Free Software Foundation; version 2
  of the License.

  This program 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 General Public License for more details.

  You should have received a copy of the GNU General Public License along with this
  program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth
  Floor, Boston, MA 02110-1301  USA



 */
package com.mysql.jdbc;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * Methods for doing secure authentication with MySQL-4.1 and newer.
 * 
 * @author Mark Matthews
 * 
 * @version $Id$
 */
public class Security {
	private static final char PVERSION41_CHAR = '*';

	private static final int SHA1_HASH_SIZE = 20;

	/**
	 * Returns hex value for given char
	 */
	private static int charVal(char c) {
		return ((c >= '0') && (c <= '9')) ? (c - '0')
				: (((c >= 'A') && (c <= 'Z')) ? (c - 'A' + 10) : (c - 'a' + 10));
	}

	/*
	 * Convert password in salted form to binary string password and hash-salt
	 * For old password this involes one more hashing
	 * 
	 * SYNOPSIS get_hash_and_password() salt IN Salt to convert from pversion IN
	 * Password version to use hash OUT Store zero ended hash here bin_password
	 * OUT Store binary password here (no zero at the end)
	 * 
	 * RETURN 0 for pre 4.1 passwords !0 password version char for newer
	 * passwords
	 */

	/**
	 * Creates key from old password to decode scramble Used in 4.1
	 * authentication with passwords stored pre-4.1 hashing.
	 * 
	 * @param passwd
	 *            the password to create the key from
	 * 
	 * @return 20 byte generated key
	 * 
	 * @throws NoSuchAlgorithmException
	 *             if the message digest 'SHA-1' is not available.
	 */
	static byte[] createKeyFromOldPassword(String passwd)
			throws NoSuchAlgorithmException {
		/* At first hash password to the string stored in password */
		passwd = makeScrambledPassword(passwd);

		/* Now convert it to the salt form */
		int[] salt = getSaltFromPassword(passwd);

		/* Finally get hash and bin password from salt */
		return getBinaryPassword(salt, false);
	}

	/**
	 * DOCUMENT ME!
	 * 
	 * @param salt
	 *            DOCUMENT ME!
	 * @param usingNewPasswords
	 *            DOCUMENT ME!
	 * 
	 * @return DOCUMENT ME!
	 * 
	 * @throws NoSuchAlgorithmException
	 *             if the message digest 'SHA-1' is not available.
	 */
	static byte[] getBinaryPassword(int[] salt, boolean usingNewPasswords)
			throws NoSuchAlgorithmException {
		int val = 0;

		byte[] binaryPassword = new byte[SHA1_HASH_SIZE]; /*
															 * Binary password
															 * loop pointer
															 */

		if (usingNewPasswords) /* New password version assumed */{
			int pos = 0;

			for (int i = 0; i < 4; i++) /* Iterate over these elements */{
				val = salt[i];

				for (int t = 3; t >= 0; t--) {
					binaryPassword[pos++] = (byte) (val & 255);
					val >>= 8; /* Scroll 8 bits to get next part */
				}
			}

			return binaryPassword;
		}

		int offset = 0;

		for (int i = 0; i < 2; i++) /* Iterate over these elements */{
			val = salt[i];

			for (int t = 3; t >= 0; t--) {
				binaryPassword[t + offset] = (byte) (val % 256);
				val >>= 8; /* Scroll 8 bits to get next part */
			}

			offset += 4;
		}

		MessageDigest md = MessageDigest.getInstance("SHA-1"); //$NON-NLS-1$

		md.update(binaryPassword, 0, 8);

		return md.digest();
	}

	private static int[] getSaltFromPassword(String password) {
		int[] result = new int[6];

		if ((password == null) || (password.length() == 0)) {
			return result;
		}

		if (password.charAt(0) == PVERSION41_CHAR) {
			// new password
			String saltInHex = password.substring(1, 5);

			int val = 0;

			for (int i = 0; i < 4; i++) {
				val = (val << 4) + charVal(saltInHex.charAt(i));
			}

			return result;
		}

		int resultPos = 0;
		int pos = 0;
		int length = password.length();

		while (pos < length) {
			int val = 0;

			for (int i = 0; i < 8; i++) {
				val = (val << 4) + charVal(password.charAt(pos++));
			}

			result[resultPos++] = val;
		}

		return result;
	}

	private static String longToHex(long val) {
		String longHex = Long.toHexString(val);

		int length = longHex.length();

		if (length < 8) {
			int padding = 8 - length;
			StringBuffer buf = new StringBuffer();

			for (int i = 0; i < padding; i++) {
				buf.append("0"); //$NON-NLS-1$
			}

			buf.append(longHex);

			return buf.toString();
		}

		return longHex.substring(0, 8);
	}

	/**
	 * Creates password to be stored in user database from raw string.
	 * 
	 * Handles Pre-MySQL 4.1 passwords.
	 * 
	 * @param password
	 *            plaintext password
	 * 
	 * @return scrambled password
	 * 
	 * @throws NoSuchAlgorithmException
	 *             if the message digest 'SHA-1' is not available.
	 */
	static String makeScrambledPassword(String password)
			throws NoSuchAlgorithmException {
		long[] passwordHash = Util.newHash(password);
		StringBuffer scramble = new StringBuffer();

		scramble.append(longToHex(passwordHash[0]));
		scramble.append(longToHex(passwordHash[1]));

		return scramble.toString();
	}

	/**
	 * Encrypt/Decrypt function used for password encryption in authentication
	 * 
	 * Simple XOR is used here but it is OK as we crypt random strings
	 * 
	 * @param from
	 *            IN Data for encryption
	 * @param to
	 *            OUT Encrypt data to the buffer (may be the same)
	 * @param password
	 *            IN Password used for encryption (same length)
	 * @param length
	 *            IN Length of data to encrypt
	 */
	static void passwordCrypt(byte[] from, byte[] to, byte[] password,
			int length) {
		int pos = 0;

		while ((pos < from.length) && (pos < length)) {
			to[pos] = (byte) (from[pos] ^ password[pos]);
			pos++;
		}
	}

	/**
	 * Stage one password hashing, used in MySQL 4.1 password handling
	 * 
	 * @param password
	 *            plaintext password
	 * 
	 * @return stage one hash of password
	 * 
	 * @throws NoSuchAlgorithmException
	 *             if the message digest 'SHA-1' is not available.
	 */
	static byte[] passwordHashStage1(String password)
			throws NoSuchAlgorithmException {
		MessageDigest md = MessageDigest.getInstance("SHA-1"); //$NON-NLS-1$
		StringBuffer cleansedPassword = new StringBuffer();

		int passwordLength = password.length();

		for (int i = 0; i < passwordLength; i++) {
			char c = password.charAt(i);

			if ((c == ' ') || (c == '\t')) {
				continue; /* skip space in password */
			}

			cleansedPassword.append(c);
		}

		return md.digest(StringUtils.getBytes(cleansedPassword.toString()));
	}

	/**
	 * Stage two password hashing used in MySQL 4.1 password handling
	 * 
	 * @param hash
	 *            from passwordHashStage1
	 * @param salt
	 *            salt used for stage two hashing
	 * 
	 * @return result of stage two password hash
	 * 
	 * @throws NoSuchAlgorithmException
	 *             if the message digest 'SHA-1' is not available.
	 */
	static byte[] passwordHashStage2(byte[] hashedPassword, byte[] salt)
			throws NoSuchAlgorithmException {
		MessageDigest md = MessageDigest.getInstance("SHA-1"); //$NON-NLS-1$

		// hash 4 bytes of salt
		md.update(salt, 0, 4);

		md.update(hashedPassword, 0, SHA1_HASH_SIZE);

		return md.digest();
	}

	// SERVER: public_seed=create_random_string()
	// send(public_seed)
	//
	// CLIENT: recv(public_seed)
	// hash_stage1=sha1("password")
	// hash_stage2=sha1(hash_stage1)
	// reply=xor(hash_stage1, sha1(public_seed,hash_stage2)
	//
	// // this three steps are done in scramble()
	//
	// send(reply)
	//
	//
	// SERVER: recv(reply)
	// hash_stage1=xor(reply, sha1(public_seed,hash_stage2))
	// candidate_hash2=sha1(hash_stage1)
	// check(candidate_hash2==hash_stage2)
	public static byte[] scramble411(String password, String seed, Connection conn)
			throws NoSuchAlgorithmException, UnsupportedEncodingException {
		MessageDigest md = MessageDigest.getInstance("SHA-1"); //$NON-NLS-1$
		String passwordEncoding = conn.getPasswordCharacterEncoding();
		
		byte[] passwordHashStage1 = md
				.digest((passwordEncoding == null || passwordEncoding.length() == 0) ? 
						StringUtils.getBytes(password)
						: StringUtils.getBytes(password, passwordEncoding));
		md.reset();

		byte[] passwordHashStage2 = md.digest(passwordHashStage1);
		md.reset();

		byte[] seedAsBytes = StringUtils.getBytes(seed, "ASCII"); // for debugging
		md.update(seedAsBytes);
		md.update(passwordHashStage2);

		byte[] toBeXord = md.digest();

		int numToXor = toBeXord.length;

		for (int i = 0; i < numToXor; i++) {
			toBeXord[i] = (byte) (toBeXord[i] ^ passwordHashStage1[i]);
		}

		return toBeXord;
	}

	/**
	 * Prevent construction.
	 */
	private Security() {
		super();
	}
}