/*
 * Created on 15 Jun 2006
 * Created by Aaron Grunthal and Paul Gardner
 * Copyright (C) 2006 Aelitis, All Rights Reserved.
 *
 * 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; either version 2
 * of the License, or (at your option) any later version.
 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 * 
 * AELITIS, SAS au capital de 46,603.30 euros
 * 8 Allee Lenotre, La Grille Royale, 78600 Le Mesnil le Roi, France.
 *
 */

package com.aelitis.azureus.core.security.impl;

import java.nio.ByteBuffer;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;

import org.bouncycastle.jce.provider.JCEECDHKeyAgreement;

import com.aelitis.azureus.core.security.CryptoManagerException;
import com.aelitis.azureus.core.security.CryptoSTSEngine;



/**
 * STS authentication protocol using a symmetric 4 message ECDH/ECDSA handshake  
 */
final class 
CryptoSTSEngineImpl 
	implements CryptoSTSEngine
{
	public static final int	VERSION	= 1;

	private CryptoHandlerECC	handler;

	private KeyPair 	ephemeralKeyPair;
	
	private PublicKey	myPublicKey;
	private PrivateKey	myPrivateKey;
	private PublicKey 	remotePubKey;
	private byte[] 		sharedSecret;
	
	private InternalDH	ecDH;
	
	/**
	 * 
	 * @param myIdent keypair representing our current identity
	 */
	
	CryptoSTSEngineImpl(
		CryptoHandlerECC	_handler,
		PublicKey			_myPub,
		PrivateKey			_myPriv )
		
		throws CryptoManagerException
	{
		handler			= _handler;
		myPublicKey		= _myPub;
		myPrivateKey	= _myPriv;
				
		ephemeralKeyPair = handler.createKeys();
		
		try{
			ecDH = new InternalDH();
			
			//ecDH = KeyAgreement.getInstance("ECDH", "BC");
			
			ecDH.init(ephemeralKeyPair.getPrivate());
			
		}catch (Exception e){
			
			throw new CryptoManagerException("Couldn't initialize crypto handshake", e);
		}
	}

	public void 
	getKeys(
		ByteBuffer		message )
	
		throws CryptoManagerException
	{
		getMessage( message, true );
	}
	
	public void 
	putKeys(
		ByteBuffer		message )
	
		throws CryptoManagerException
	{
		putMessage( message, true );
	}

	public void 
	getAuth(
		ByteBuffer		message )
	
		throws CryptoManagerException
	{
		getMessage( message, false );
	}
	
	public void 
	putAuth(
		ByteBuffer		message )
	
		throws CryptoManagerException
	{
		putMessage( message, false );
	}
	
	public void 
	putMessage(
		ByteBuffer		message,
		boolean			keys )
	
		throws CryptoManagerException
	{
		// System.out.println( "put( " + keys + ") " + this );
		
		try{
			int	version = getInt( message, 255 );
			
			if ( version != VERSION ){
				
				throw( new CryptoManagerException( "invalid version (" + version + ")" ));
			}
							
			if ( keys ){
			
				if ( sharedSecret != null ){
					
					throw( new CryptoManagerException( "phase error: keys already received" ));
				}
				
				final byte[] rawRemoteOtherPubkey = getBytes( message, 65535 );
				
				final byte[] rawRemoteEphemeralPubkey = getBytes( message, 65535 );
	
				final byte[] remoteSig = getBytes( message, 65535 );
				
				final byte[] pad = getBytes( message, 65535 );
				
				remotePubKey = handler.rawdataToPubkey(rawRemoteOtherPubkey);
				
				Signature check = handler.getSignature(remotePubKey);
	
				check.update(rawRemoteOtherPubkey);
				
				check.update(rawRemoteEphemeralPubkey);
				
				if ( check.verify(remoteSig)){
										
					ecDH.doPhase(handler.rawdataToPubkey(rawRemoteEphemeralPubkey), true);
					
					sharedSecret = ecDH.generateSecret();
					
				}else{
												
					throw( new CryptoManagerException( "Signature check failed" ));
				}
				
			}else{
				
				if ( sharedSecret == null ){
					
					throw( new CryptoManagerException( "phase error: keys not received" ));
				}
				
				final byte[] IV = getBytes( message, 65535 );
				
				final byte[] remoteSig = getBytes( message, 65535);
							
				Signature check = handler.getSignature( remotePubKey );
				
				check.update(IV);
					
				check.update(sharedSecret);
					
				if ( !check.verify(remoteSig)){
	
					throw( new CryptoManagerException( "Signature check failed" ));
				}
			}
		}catch( CryptoManagerException	e ){
						
			throw( e );
			
		}catch( Throwable e ){
						
			throw( new CryptoManagerException( "Failed to generate message" ));
		}
	}
	
	public void 
	getMessage(
		ByteBuffer	buffer,
		boolean		keys )
	
		throws CryptoManagerException
	{
		// System.out.println( "get( " + keys + ") " + this );

		try{
			putInt( buffer, VERSION, 255 );
						
			SecureRandom random = SecureRandom.getInstance("SHA1PRNG");

			Signature sig = handler.getSignature(myPrivateKey);
			
			if ( keys ){
								
				final byte[] rawMyPubkey = handler.keyToRawdata(myPublicKey);
				
				final byte[] rawEphemeralPubkey = handler.keyToRawdata(ephemeralKeyPair.getPublic());
				
				sig.update(rawMyPubkey);
					
				sig.update(rawEphemeralPubkey);
					
				final byte[] rawSign = sig.sign();
				
				final byte[] pad = new byte[random.nextInt(32)];
				
				random.nextBytes(pad);
				
				putBytes( buffer, rawMyPubkey, 65535 );
				
				putBytes( buffer, rawEphemeralPubkey, 65535 );
				
				putBytes( buffer, rawSign, 65535 );
				
				putBytes( buffer, pad, 65535 );
	
			}else{
					
				if ( sharedSecret == null ){
					
					throw( new CryptoManagerException( "phase error: keys not received" ));
				}
				
				final byte[] IV = new byte[20 + random.nextInt(32)];
				
				random.nextBytes(IV);

				sig.update(IV);
				
				sig.update(sharedSecret);
				
				final byte[] rawSig = sig.sign();

				putBytes( buffer, IV, 65535 );

				putBytes( buffer, rawSig, 65535 );
			}
		}catch( CryptoManagerException	e ){
						
			throw( e );
			
		}catch( Throwable e ){
						
			throw( new CryptoManagerException( "Failed to generate message" ));
		}
	}
	
	public byte[] 
	getSharedSecret()
	
		throws CryptoManagerException
	{
		if ( sharedSecret == null ){
			
			throw( new CryptoManagerException( "secret not yet available" ));
		}
		
		return sharedSecret;
	}
	
	public byte[] 
	getRemotePublicKey()
	
		throws CryptoManagerException
	{
		if ( remotePubKey == null ){
			
			throw( new CryptoManagerException( "key not yet available" ));
		}
		
		return( handler.keyToRawdata( remotePubKey ));
	}
	
	protected int
	getInt(
		ByteBuffer	buffer,
		int			max_size )
	
		throws CryptoManagerException
	{
		try{
			if ( max_size < 256 ){
				
				return( buffer.get() & 0xff);
				
			}else if ( max_size < 65536 ){
				
				return( buffer.getShort() & 0xffff);
				
			}else{
				
				return( buffer.getInt());
			}
		}catch( Throwable e ){
			
			throw( new CryptoManagerException( "Failed to get int", e ));
		}
	}
	
	protected byte[]
	getBytes(
		ByteBuffer	buffer,
		int			max_size )
	
		throws CryptoManagerException
	{
		int	len = getInt( buffer, max_size );
		
		if ( len > max_size ){
			
			throw( new CryptoManagerException( "Invalid length" ));
		}
		
		try{
			byte[]	res = new byte[len];
			
			buffer.get( res );
			
			return( res );
			
		}catch( Throwable e ){
			
			throw( new CryptoManagerException( "Failed to get byte[]", e ));
		}
	}
	
	protected void
	putInt(
		ByteBuffer	buffer,
		int			value,
		int			max_size )
	
		throws CryptoManagerException
	{
		try{
			if ( max_size < 256 ){
				
				buffer.put((byte)value);
				
			}else if ( max_size < 65536 ){
				
				buffer.putShort((short)value );
				
			}else{
				
				buffer.putInt( value );
			}
		}catch( Throwable e ){
			
			throw( new CryptoManagerException( "Failed to put int", e ));
		}
	}
	
	protected void
	putBytes(
		ByteBuffer	buffer,
		byte[]		value,
		int			max_size )
	
		throws CryptoManagerException
	{
		putInt( buffer, value.length, max_size );
		
		try{
			buffer.put( value );
			
		}catch( Throwable e ){
			
			throw( new CryptoManagerException( "Failed to put byte[]", e ));
		}
	}
	
	class 
	InternalDH 
		extends JCEECDHKeyAgreement.DH
	{
			// we use this class to obtain compatability with BC
		
		public void
		init(
			Key		key )

			throws InvalidKeyException, InvalidAlgorithmParameterException
		{
			engineInit( key, null );
		}

		public Key
		doPhase(
			Key		key,
			boolean	lastPhase )

			throws InvalidKeyException, IllegalStateException
		{
			return( engineDoPhase( key, lastPhase ));
		}

		public byte[] 
		generateSecret() 
		
			throws IllegalStateException
		{
			return( engineGenerateSecret());
		}
	}
}