package org.metricshub.ipmi.core.coding.security;
   
   /*-
    * ╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲
    * IPMI Java Client
    * ჻჻჻჻჻჻
    * Copyright 2023 Verax Systems, MetricsHub
    * ჻჻჻჻჻჻
    * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation, either version 3 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 Lesser Public License for more details.
   *
   * You should have received a copy of the GNU General Lesser Public
   * License along with this program.  If not, see
   * <http://www.gnu.org/licenses/lgpl-3.0.html>.
   * ╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱
   */
  
  import org.metricshub.ipmi.core.coding.commands.session.Rakp1;
  import org.metricshub.ipmi.core.common.TypeConverter;
  
  import java.security.InvalidKeyException;
  import java.util.Arrays;
  
  import javax.crypto.Mac;
  import javax.crypto.spec.SecretKeySpec;
  
  /**
   * Interface for Integrity Algorithms. All classes extending this one must
   * implement constructor(byte[]).
   */
  public abstract class IntegrityAlgorithm {
  
  	private static final byte[] CONST1 = new byte[20];
  	static {
  		Arrays.fill(CONST1, (byte) 1);
  	}
  
  	private byte[] sik;
  	private final Mac mac;
  
  	/**
  	 * Constructs an integrity algorithm.
  	 */
  	protected IntegrityAlgorithm(String algorithmName) {
  		this(CipherSuite.newMacInstance(algorithmName));
  	}
  
  	/**
  	 * Constructs an integrity algorithm with the provided MAC.
  	 *
  	 * @param mac the MAC instance to use
  	 */
  	private IntegrityAlgorithm(Mac mac) {
  		this.mac = mac;
  	}
  
  	/**
  	 * Initializes Integrity Algorithm
  	 *
  	 * @param key - Session Integrity Key calculated during the opening of the
  	 *        session or user password if 'one-key' logins are enabled.
  	 */
  	public synchronized void initialize(byte[] key) throws InvalidKeyException {
  		this.sik = key;
  		final String algorithmName = getAlgorithmName();
  
  		SecretKeySpec k1 = new SecretKeySpec(key, algorithmName);
  
  		mac.init(k1);
  		k1 = new SecretKeySpec(mac.doFinal(CONST1), algorithmName);
  
  		mac.init(k1);
  	}
  
  	/**
  	 * Returns the Session Integrity Key passed to {@link #initialize(byte[])}.
  	 *
  	 * @return the Session Integrity Key, or null if not initialized
  	 */
  	protected synchronized byte[] getSik() {
  		return sik;
  	}
  
  	/**
  	 * Stores the Session Integrity Key without initializing the MAC, for algorithms that do not use one.
  	 *
  	 * @param sik the Session Integrity Key
  	 */
  	protected synchronized void setSik(byte[] sik) {
  		this.sik = sik;
  	}
  
 	/**
 	 * Wipes the key passed to {@link #initialize(byte[])} (the password for MD5-128 integrity) once the session is
 	 * over, and keys the MAC with the wiped key: the codes the algorithm generates no longer match the session.
 	 */
 	public synchronized void wipeKey() {
 		if (sik == null) {
 			return;
 		}
 		Arrays.fill(sik, (byte) 0);
 		if (mac != null && sik.length > 0) {
 			try {
 				mac.init(new SecretKeySpec(sik, getAlgorithmName()));
 			} catch (InvalidKeyException e) {
 				// Cannot happen: HMAC takes a key of any non-zero length, and the session is over anyway
 			}
 		}
 	}
 
 	/**
 	 * Returns the algorithm's ID.
 	 */
 	public abstract byte getCode();
 
 	/**
 	 * Creates AuthCode field for message. Synchronized: the sending, receiving and keep-alive threads share this
 	 * instance and its {@link Mac}.
 	 *
 	 * @param base - data starting with the AuthType/Format field up to and
 	 *        including the field that immediately precedes the AuthCode field
 	 * @return AuthCode field. Might be null if empty AuthCOde field is generated.
 	 * @see Rakp1#calculateSik(org.metricshub.ipmi.core.coding.commands.session.Rakp1ResponseData)
 	 */
 	public synchronized byte[] generateAuthCode(final byte[] base) {
 
 		if (sik == null) {
 			throw new NullPointerException("Algorithm not initialized.");
 		}
 
 		final int authCodeLength = getAuthCodeLength();
 		final byte[] result = new byte[authCodeLength];
 		byte[] updatedBase;
 
 		if (base[base.length - 2] == 0) { // No padding
 			updatedBase = injectIntegrityPad(base, authCodeLength);
 		} else {
 			updatedBase = base;
 		}
 
 		System.arraycopy(mac.doFinal(updatedBase), 0, result, 0, authCodeLength);
 
 		return result;
 	}
 
 	/**
 	 * Modifies the algorithm base since with null Auth Code during encoding
 	 * Integrity Pad isn't calculated.
 	 *
 	 * @param base - integrity algorithm base without Integrity Pad.
 	 * @param authCodeLength - expected length of the Auth Code field.
 	 * @return - integrity algorithm base with Integrity Pad and updated Pad Length
 	 *         field.
 	 */
 	protected byte[] injectIntegrityPad(byte[] base, int authCodeLength) {
 		int pad = 0;
 		if ((base.length + authCodeLength) % 4 != 0) {
 			pad = 4 - (base.length + authCodeLength) % 4;
 		}
 
 		if (pad != 0) {
 			byte[] newBase = new byte[base.length + pad];
 
 			System.arraycopy(base, 0, newBase, 0, base.length - 2);
 
 			for (int i = base.length - 2; i < base.length - 2 + pad; ++i) {
 				newBase[i] = TypeConverter.intToByte(0xff);
 			}
 
 			newBase[newBase.length - 2] = TypeConverter.intToByte(pad);
 
 			newBase[newBase.length - 1] = base[base.length - 1];
 
 			return newBase;
 		} else {
 			return base;
 		}
 	}
 
 	/**
 	 * Returns the name of the algorithm.
 	 *
 	 * @return The algorithm name as a {@code String}.
 	 */
 	public abstract String getAlgorithmName();
 
 	/**
 	 * Returns the length of the authentication code
 	 *
 	 * @return The length of the authentication code in bytes.
 	 */
 	public abstract int getAuthCodeLength();
 
 }