desmac.java

面向应用的智能安全代理平台和工具包是一个综合网络应用的安全共性需求而设计和实现的一个通用性的网络信息安全应用支撑平台

package au.net.aba.crypto.provider;

/*
 * $Id: DESMac.java,v 1.1 1999/02/11 04:32:51 leachbj Exp $
 * $Author: leachbj $
 *
 * Copyright (C) 1996-1998 Australian Business Access Pty Ltd.
 * All rights reserved.
 * 
 * Use, modification, copying and distribution of this software is subject the
 * terms and conditions of the ABA Public Licence. See the file
 * "PUBLIC_LICENCE" for additional information.
 *
 * If you have not received a copy of the Public Licence, you must destroy all
 * copies of this file immediately. 
 *
 * $Source: /aba/CVSROOT/jdk1.1/src/au.net.aba/crypto/provider/DESMac.java,v $
 * $Revision: 1.1 $
 * $Date: 1999/02/11 04:32:51 $
 * $State: Exp $
 */

import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;

import java.security.*;
import java.security.spec.*;

/**
 * This class implements the DES based MAC algorithm as defined in
 * <a href="http://www.itl.nist.gov/div897/pubs/fip113.htm">FIPS PUB 113</a>.
 * <p>
 * This algorithm produces a 4 byte MAC value.
 * <p>
 * Currently this class will not work correctly unless the input data
 * size is an exact multiple of 8.  Data that isnt of this length
 * should be padded with zeros.  Eventually the DES cipher class
 * will be modified to perform this function.
 */
public class DESMac extends MacSpi
{
	private static final int MAC_LENGTH = 4;
	private static final int MAC_BUFFER = 8;

	// private static final String MAC_ALG = "DES/CBC/Zeroes";
	private static final String MAC_ALG = "DES/CBC/NoPadding";
	private static final String MAC_PROV = "ABA";

	private Cipher desCipher;
	private byte[] inbuf;
	private byte[] mac;

	/**
	 * Default constructor, initialises the instance.
	 */
	public DESMac()
	{
		inbuf = new byte[1];
		mac = new byte[MAC_BUFFER];
	}
	/**
	 * Completes the MAC computation and resets the MAC for further
	 * use, maintaining the secret key that the MAC was initialised with.
	 *
	 * @return the MAC result.
	 */
	protected byte[] engineDoFinal()
	{
		try
		{
			byte[] out = desCipher.doFinal();
			updateMac(out);
		}
		catch (BadPaddingException bpe)
		{
			bpe.printStackTrace();
		}
		catch (IllegalBlockSizeException ibse)
		{
			ibse.printStackTrace();
		}

		byte[] result = new byte[MAC_LENGTH];
		System.arraycopy(mac, 0, result, 0, MAC_LENGTH);

		return result;
	}
	/**
	 * Returns the length of the MAC in bytes.
	 *
	 * @return the MAC length in bytes.
	 */
	protected int engineGetMacLength()
	{
		return MAC_LENGTH;
	}
	/**
	 * Initialises the MAC with the given (secret) key and algorithm
	 * parameters.  The <code>key</code> parameter should be a
	 * type that is compatible with the DES <code>Cipher</code>.
	 *
	 * @param key the (secret) key. 
	 * @param params the algorithm parameters. 
	 *
	 * @exception InvalidKeyException if the given key is inappropriate for
	 *     initialising this MAC.
	 * @exception InvalidAlgorithmParameterException if the given algorithm
	 *     parameters are inappropriate for this MAC.
	 */
	protected void engineInit(Key key, AlgorithmParameterSpec params)
		throws InvalidKeyException, InvalidAlgorithmParameterException
	{
		try
		{
			desCipher = Cipher.getInstance(MAC_ALG, MAC_PROV);
		}
		catch (Exception e)
		{
			throw new ExceptionInInitializerError(e);
		}

		byte[] iv = new byte[desCipher.getBlockSize()];
		IvParameterSpec ivParam = new IvParameterSpec(iv);

		desCipher.init(Cipher.ENCRYPT_MODE, key, ivParam);
		mac = new byte[MAC_BUFFER];
	}
	/**
	 * Resets the MAC for further use, maintaining the secret key that
	 * the MAC was initialised with.
	 */
	protected void engineReset()
	{
		mac = new byte[MAC_BUFFER];
		if (desCipher != null)
		{
			try
			{
				desCipher.doFinal();
			}
			catch (Exception e)
			{
				// ignore it
			}
		}
	}
	/**
	 * Processes the first len bytes in input, starting at offset.
	 *
	 * @param input the input buffer.
	 * @param offset the offset in input where the input starts. 
	 * @param len the number of bytes to process. 
	 */
	protected void engineUpdate(byte[] input, int offset, int len)
	{
		byte[] out = desCipher.update(input, offset, len);
		updateMac(out);
	}
	/**
	 * Processes the given byte.
	 *
	 * @param input the input byte to be processed.
	 */
	protected void engineUpdate(byte input)
	{
		inbuf[0] = input;
		byte[] out = desCipher.update(inbuf);
		updateMac(out);
	}
	/**
	 * This method will add the newbuf bytes on the the mac.  The
	 * MAC result is stored in a circular type buffer, as new data
	 * arrives it is appended to the buffer and old data is shifted
	 * out so that the last 4 bytes of the cipher are saved.
	 */
	private void updateMac(byte[] newbuf)
	{
		if (newbuf == null || newbuf.length == 0)
		{
			return;
		}

		if (newbuf.length == MAC_BUFFER)
		{
			System.arraycopy(newbuf, 0, mac, 0, MAC_BUFFER);
		}
		else if (newbuf.length > MAC_BUFFER)
		{
			System.arraycopy(newbuf, newbuf.length - MAC_BUFFER,
				mac, 0, MAC_BUFFER);
		}
		else
		{
			System.arraycopy(mac, newbuf.length, mac, 0,
				MAC_BUFFER - newbuf.length);
			System.arraycopy(newbuf, 0, mac,
				MAC_BUFFER - newbuf.length, newbuf.length);
		}
	}
}