package org.metricshub.ipmi.core.coding.commands.session;
   
   /*-
    * ╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲
    * 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.IpmiCommandCoder;
  import org.metricshub.ipmi.core.coding.commands.IpmiVersion;
  import org.metricshub.ipmi.core.coding.commands.PrivilegeLevel;
  import org.metricshub.ipmi.core.coding.payload.IpmiPayload;
  import org.metricshub.ipmi.core.coding.payload.PlainMessage;
  import org.metricshub.ipmi.core.coding.payload.lan.IPMIException;
  import org.metricshub.ipmi.core.coding.payload.lan.NetworkFunction;
  import org.metricshub.ipmi.core.coding.protocol.AuthenticationType;
  import org.metricshub.ipmi.core.coding.protocol.IpmiMessage;
  import org.metricshub.ipmi.core.coding.protocol.Ipmiv20Message;
  import org.metricshub.ipmi.core.coding.protocol.PayloadType;
  import org.metricshub.ipmi.core.coding.security.CipherSuite;
  import org.metricshub.ipmi.core.coding.security.ConfidentialityNone;
  import org.metricshub.ipmi.core.common.Randomizer;
  import org.metricshub.ipmi.core.common.TypeConverter;
  
  import java.nio.charset.StandardCharsets;
  import java.security.InvalidKeyException;
  import java.security.NoSuchAlgorithmException;
  import java.util.Arrays;
  
  /**
   * <p>
   * A wrapper for RMCP+ RAKP1 message and it's response - RAKP2 message. The same
   * instance of this class that was used to prepare RAKP Message 1 should be also
   * used to decode matching RAKP Message 2 since the generated random number is
   * used in encryption process.
   * </p>
   * <p>
   * Capable of calculating SIK (Session Integrity Key) when RAKP Message 2 is
   * given ({@link #calculateSik(Rakp1ResponseData)}).
   * </p>
   */
  public class Rakp1 extends IpmiCommandCoder<Rakp1ResponseData> {
  
  	/**
  	 * Maximum length of the password and of the BMC key (Kg) in IPMI v2.0, in bytes (IPMI 2.0 tables 22-30 and
  	 * 22-35).
  	 */
  	private static final int MAX_KEY_LENGTH = 20;
  
  	/**
  	 * Maximum length of the user name, in bytes (IPMI 2.0 table 13-11).
  	 */
  	private static final int MAX_USERNAME_LENGTH = 16;
  
  	/**
  	 * The Managed System's Session ID for this session. Must be as returned by
  	 * the Managed System in the Open Session Response message.
  	 */
  	private int managedSystemSessionId;
  
  	/**
  	 * The random number generated by console.
  	 */
  	private byte[] consoleRandomNumber;
  
  	private PrivilegeLevel requestedMaximumPrivilegeLevel;
  
  	/**
  	 * ASCII character Name that the user at the Remote Console wishes to assume
  	 * for this session. It's length cannot exceed 16.
  	 */
  	private String username;
  
  	/**
  	 * Password matching username, as sent to the BMC (at most 20 bytes).
  	 */
  	private byte[] password;
  
  	/**
  	 * Kg key associated with the target BMC. Should be null if Get Channel
  	 * Authentication Capabilities Response indicated that Kg is disabled which
  	 * means that 'one-key' logins are being used (
  	 * {@link GetChannelAuthenticationCapabilitiesResponseData#isKgEnabled()} ==
 	 * false)
 	 */
 	private byte[] bmcKey;
 
 	public void setManagedSystemSessionId(int managedSystemSessionId) {
 		this.managedSystemSessionId = managedSystemSessionId;
 	}
 
 	public int getManagedSystemSessionId() {
 		return managedSystemSessionId;
 	}
 
 	public void setRequestedMaximumPrivilegeLevel(PrivilegeLevel requestedMaximumPrivilegeLevel) {
 		this.requestedMaximumPrivilegeLevel = requestedMaximumPrivilegeLevel;
 	}
 
 	public PrivilegeLevel getRequestedMaximumPrivilegeLevel() {
 		return requestedMaximumPrivilegeLevel;
 	}
 
 	public void setUsername(String username) {
 		checkLength("Username", username.getBytes(StandardCharsets.UTF_8), MAX_USERNAME_LENGTH);
 		this.username = username;
 	}
 
 	/**
 	 * Checks the credentials of a session against what a BMC stores: a user name of at most 16 bytes in UTF-8, a
 	 * password and a BMC key (Kg) of at most 20 bytes.
 	 *
 	 * @param username the user name
 	 * @param password the password as sent to the BMC, or null
 	 * @param bmcKey the BMC key, or null
 	 * @throws IllegalArgumentException when one of them is too long
 	 */
 	public static void checkCredentials(String username, byte[] password, byte[] bmcKey) {
 		checkLength("Username", username.getBytes(StandardCharsets.UTF_8), MAX_USERNAME_LENGTH);
 		checkLength("Password", password, MAX_KEY_LENGTH);
 		checkLength("BMC key", bmcKey, MAX_KEY_LENGTH);
 	}
 
 	private static void checkLength(String name, byte[] value, int maxLength) {
 		if (value != null && value.length > maxLength) {
 			throw new IllegalArgumentException(name + " is too long. Its length cannot exceed " + maxLength + " bytes");
 		}
 	}
 
 	public String getUsername() {
 		return username;
 	}
 
 	/**
 	 * @return the user name as sent to the BMC, encoded in UTF-8
 	 */
 	byte[] getUsernameBytes() {
 		return username.getBytes(StandardCharsets.UTF_8);
 	}
 
 	private void setPassword(byte[] password) {
 		checkLength("Password", password, MAX_KEY_LENGTH);
 		this.password = password;
 	}
 
 	/**
 	 * @return the password as the key of the authentication algorithm (Kuid): the array of the caller, not a copy,
 	 *         since the HMAC zero-pads its key as the BMC stores it (20 bytes); an empty array for no password
 	 */
 	byte[] getPasswordBytes() {
 		return password == null ? new byte[0] : password;
 	}
 
 	private void setConsoleRandomNumber(byte[] randomNumber) {
 		this.consoleRandomNumber = randomNumber;
 	}
 
 	public byte[] getConsoleRandomNumber() {
 		return consoleRandomNumber;
 	}
 
 	private void setBmcKey(byte[] bmcKey) {
 		checkLength("BMC key", bmcKey, MAX_KEY_LENGTH);
 		this.bmcKey = bmcKey;
 	}
 
 	public byte[] getBmcKey() {
 		return bmcKey;
 	}
 
 	/**
 	 * Initiates class for encoding and decoding. Sets IPMI version to
 	 * {@link IpmiVersion#V20} since RAKP1 is a RMCP+ command. Sets
 	 * Authentication Type to RMCP+.
 	 *
 	 * @param managedSystemSessionId
 	 *        - The Managed System's Session ID for this session. Must be as
 	 *        returned by the Managed System in the Open Session Response
 	 *        message.
 	 * @param privilegeLevel
 	 *        - Requested Maximum {@link PrivilegeLevel}
 	 * @param username
 	 *        - ASCII character Name that the user at the Remote Console
 	 *        wishes to assume for this session. It's length cannot exceed
 	 *        16.
 	 * @param password
 	 *        - password matching username, as sent to the BMC (UTF-8 for a text password), at most 20 bytes
 	 * @param bmcKey
 	 *        - BMC specific key. Should be null if Get Channel
 	 *        Authentication Capabilities Response indicated that Kg is
 	 *        disabled which means that 'one-key' logins are being used (
 	 *        {@link GetChannelAuthenticationCapabilitiesResponseData#isKgEnabled()}
 	 *        == false)
 	 * @param cipherSuite
 	 *        - {@link CipherSuite} containing authentication,
 	 *        confidentiality and integrity algorithms for this session.
 	 */
 	public Rakp1(int managedSystemSessionId, PrivilegeLevel privilegeLevel, String username, byte[] password,
 			byte[] bmcKey, CipherSuite cipherSuite) {
 		setSessionParameters(IpmiVersion.V20, cipherSuite, AuthenticationType.RMCPPlus);
 		setManagedSystemSessionId(managedSystemSessionId);
 		setRequestedMaximumPrivilegeLevel(privilegeLevel);
 		setUsername(username);
 		setPassword(password);
 		this.setBmcKey(bmcKey);
 
 		setConsoleRandomNumber(Randomizer.getBytes(16));
 	}
 
 	@Override
 	public IpmiMessage encodePayload(int messageSequenceNumber, int sessionSequenceNumber, int sessionId) {
 		if (sessionId != 0) {
 			throw new IllegalArgumentException("Session ID must be 0");
 		}
 		Ipmiv20Message message = new Ipmiv20Message(new ConfidentialityNone());
 
 		message.setPayloadType(PayloadType.Rakp1);
 		message.setSessionID(0);
 		message.setSessionSequenceNumber(0);
 		message.setAuthenticationType(getAuthenticationType());
 		message.setPayloadAuthenticated(false);
 		message.setPayloadEncrypted(false);
 
 		message.setPayload(preparePayload(messageSequenceNumber));
 
 		return message;
 	}
 
 	@Override
 	protected IpmiPayload preparePayload(int sequenceNumber) {
 		byte[] usernameBytes = getUsernameBytes();
 		byte[] payload = new byte[28 + usernameBytes.length];
 
 		// message tag
 		payload[0] = TypeConverter.intToByte(sequenceNumber);
 
 		payload[1] = 0; // reserved
 		payload[2] = 0; // reserved
 		payload[3] = 0; // reserved
 
 		byte[] sId = TypeConverter.intToLittleEndianByteArray(getManagedSystemSessionId());
 
 		System.arraycopy(sId, 0, payload, 4, 4); // managed system session ID
 
 		System.arraycopy(consoleRandomNumber, 0, payload, 8, 16); // generated
 																															// random
 		// number
 
 		// requested privilege level; set name-only lookup
 		payload[24] = TypeConverter.intToByte(encodePrivilegeLevel(requestedMaximumPrivilegeLevel) | 0x10);
 
 		payload[25] = 0; // reserved
 		payload[26] = 0; // reserved
 
 		payload[27] = TypeConverter.intToByte(usernameBytes.length); // username length
 		System.arraycopy(usernameBytes, 0, payload, 28, usernameBytes.length); // username
 
 		return new PlainMessage(payload);
 	}
 
 	@Override
 	public byte getCommandCode() {
 		return 0;
 	}
 
 	@Override
 	public NetworkFunction getNetworkFunction() {
 		return null;
 	}
 
 	/**
 	 * @throws IllegalArgumentException
 	 *         when message is not a response for class-specific command,
 	 *         response has invalid length or authentication check fails.
 	 * @throws NoSuchAlgorithmException
 	 *         - when authentication, confidentiality or integrity algorithm
 	 *         fails.
 	 * @throws InvalidKeyException
 	 *         - when creating of the algorithm key fails
 	 */
 	@Override
 	public Rakp1ResponseData getResponseData(IpmiMessage message)
 			throws IPMIException,
 			NoSuchAlgorithmException,
 			InvalidKeyException {
 		if (!isCommandResponse(message)) {
 			throw new IllegalArgumentException("This is not RAKP 2 message!");
 		}
 
 		byte[] payload = validateSessionSetupResponse(message);
 
 		Rakp1ResponseData data = new Rakp1ResponseData();
 
 		data.setMessageTag(payload[0]);
 
 		data.setStatusCode(payload[1]);
 
 		int length = getCipherSuite().getAuthenticationAlgorithm().getKeyLength();
 
 		if (payload.length < 40 + length) {
 			throw new IllegalArgumentException("Invalid payload length");
 		}
 
 		byte[] buffer = new byte[4];
 
 		System.arraycopy(payload, 4, buffer, 0, 4);
 
 		data.setRemoteConsoleSessionId(TypeConverter.littleEndianByteArrayToInt(buffer));
 
 		byte[] managedSystemGuid = new byte[16];
 
 		System.arraycopy(payload, 24, managedSystemGuid, 0, 16);
 
 		data.setManagedSystemGuid(managedSystemGuid);
 
 		byte[] managedSystemRandomNumber = new byte[16];
 
 		System.arraycopy(payload, 8, managedSystemRandomNumber, 0, 16);
 
 		data.setManagedSystemRandomNumber(managedSystemRandomNumber);
 
 		byte[] key = Arrays.copyOfRange(payload, 40, 40 + length);
 
 		if (!getCipherSuite().getAuthenticationAlgorithm()
 				.checkKeyExchangeAuthenticationCode(prepareKeyExchangeAuthenticationCodeBase(data), key, getPasswordBytes())) {
 			throw new AuthenticationException("Authentication check failed");
 		}
 
 		return data;
 	}
 
 	/**
 	 * @return byte array holding prepared base for calculating
 	 *         KeyExchangeAuthenticationCode for RAKP Message 2
 	 */
 	private byte[] prepareKeyExchangeAuthenticationCodeBase(Rakp1ResponseData responseData) {
 		byte[] usernameBytes = getUsernameBytes();
 		byte[] keac = new byte[58 + usernameBytes.length];
 
 		byte[] rSID = TypeConverter.intToLittleEndianByteArray(responseData.getRemoteConsoleSessionId());
 
 		System.arraycopy(rSID, 0, keac, 0, 4);
 
 		byte[] mSID = TypeConverter.intToLittleEndianByteArray(getManagedSystemSessionId());
 
 		System.arraycopy(mSID, 0, keac, 4, 4);
 
 		System.arraycopy(getConsoleRandomNumber(), 0, keac, 8, 16);
 
 		System.arraycopy(responseData.getManagedSystemRandomNumber(), 0, keac, 24, 16);
 
 		System.arraycopy(responseData.getManagedSystemGuid(), 0, keac, 40, 16);
 
 		keac[56] = TypeConverter.intToByte(encodePrivilegeLevel(requestedMaximumPrivilegeLevel) | 0x10);
 
 		keac[57] = TypeConverter.intToByte(usernameBytes.length);
 		System.arraycopy(usernameBytes, 0, keac, 58, usernameBytes.length);
 
 		return keac;
 	}
 
 	/**
 	 * Calculates SIK (Session Integrity Key) based on RAKP Messages 1 and 2
 	 *
 	 * @param responseData
 	 *        RAKP Message 2 data
 	 * @return Session Integrity Key
 	 * @throws NoSuchAlgorithmException
 	 *         - when authentication, confidentiality or integrity algorithm
 	 *         fails.
 	 * @throws InvalidKeyException
 	 *         - when creating of the algorithm key fails
 	 */
 	public byte[] calculateSik(Rakp1ResponseData responseData) throws InvalidKeyException, NoSuchAlgorithmException {
 		byte[] key = null;
 		// An all-zero Kg is the default value, which means one-key logins (IPMI 2.0 section 13.33)
 		if (getBmcKey() == null || Arrays.equals(getBmcKey(), new byte[getBmcKey().length])) {
 			key = getPasswordBytes();
 		} else {
 			key = getBmcKey();
 		}
 
 		return getCipherSuite().getAuthenticationAlgorithm()
 				.getKeyExchangeAuthenticationCode(prepareSikBase(responseData), key);
 	}
 
 	/**
 	 * @return byte array holding prepared base for calculating Session
 	 *         Integrity Key
 	 */
 	private byte[] prepareSikBase(Rakp1ResponseData responseData) {
 		byte[] usernameBytes = getUsernameBytes();
 		byte[] sikBase = new byte[34 + usernameBytes.length];
 
 		System.arraycopy(getConsoleRandomNumber(), 0, sikBase, 0, 16);
 
 		System.arraycopy(responseData.getManagedSystemRandomNumber(), 0, sikBase, 16, 16);
 
 		sikBase[32] = TypeConverter.intToByte(encodePrivilegeLevel(requestedMaximumPrivilegeLevel) | 0x10);
 
 		sikBase[33] = TypeConverter.intToByte(usernameBytes.length);
 		System.arraycopy(usernameBytes, 0, sikBase, 34, usernameBytes.length);
 
 		return sikBase;
 	}
 
 	@Override
 	public boolean isCommandResponse(IpmiMessage message) {
 		return message instanceof Ipmiv20Message && ((Ipmiv20Message) message).getPayloadType() == PayloadType.Rakp2;
 	}
 }