* either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.exception;

import javax.crypto.IllegalBlockSizeException;

/**
 * Signals that this exception has been thrown when a block cipher is supplied with input data whose length is not a multiple of the cipher's block size, or that has been padded to the wrong length.

import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Transform Header for encrypted messages
 *
 * This header is used to encrypt SMB2/SMB3 messages and provides the necessary
 * cryptographic parameters for decryption including the nonce, session ID, and
 * authentication tag.
 *
 * @author mbechler
 */
public class Smb2TransformHeader implements Encodable {

    /**

     * Parse Kerberos authorization data based on the authorization type.
     *
     * @param authType the type of authorization data
     * @param token the authorization data token
     * @param keys the Kerberos keys for decryption
     * @return a list of parsed authorization data
     * @throws PACDecodingException if the data cannot be decoded
     */

                System.arraycopy(clientChallenge, 0, sessionNonce, 8, 8);

                final MessageDigest md4 = Crypto.getMD4();
                md4.update(passwordHash);
                final byte[] userSessionKey = md4.digest();

                final MessageDigest hmac = Crypto.getHMACT64(userSessionKey);
                hmac.update(sessionNonce);
                final byte[] ntlm2SessionKey = hmac.digest();

                            String data = line.substring(pos + 1).trim();
                            if (properyPattern.matcher(key).matches() && data.startsWith(CIPHER_PREFIX)) {
                                data = cipher.decrypt(data.substring(CIPHER_PREFIX.length()));
                            }
                            paramMap.put(key, data);
                        } else {
                            paramMap.put(key, StringUtil.EMPTY);

        return this.encryptionContext.encryptMessage(message, this.sessionId);
    }

    /**
     * Decrypt a message using the session's encryption context
     *
     * @param encryptedMessage the encrypted message with transform header
     * @return decrypted message
     * @throws CIFSException if decryption fails or encryption is not enabled
     */

            this.opad[i] = (byte) (key[i] ^ OPAD);
        }
        for (int i = length; i < BLOCK_LENGTH; i++) {
            this.ipad[i] = IPAD;
            this.opad[i] = OPAD;
        }

        this.md5 = Crypto.getMD5();
        engineReset();
    }

    private HMACT64(final HMACT64 hmac) throws CloneNotSupportedException {
        super("HMACT64");
        this.ipad = hmac.ipad;
        this.opad = hmac.opad;

		<property name="cookieKey">"fessRoles"</property>
		<property name="encryptedCookieValue">true</property>
		<property name="cipher">
			<component class="org.codelibs.core.crypto.CachedCipher">
				<property name="key">"1234567890123456"</property>
			</component>
		</property>
		<property name="valueSeparator">"\\n"</property>
		<property name="roleSeparator">","</property>
		 -->

- **Concurrent Utilities** (`org.codelibs.core.concurrent`) - Thread-safe collections and concurrency helpers using modern concurrent APIs
- **Crypto & Security** (`org.codelibs.core.crypto`, `org.codelibs.core.security`) - Basic cryptographic utilities, message digest operations, and secure random generation

import static org.junit.jupiter.api.Assertions.assertThrows;

import java.security.GeneralSecurityException;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.spec.SecretKeySpec;
import javax.security.auth.kerberos.KerberosKey;
import javax.security.auth.kerberos.KerberosPrincipal;

import org.junit.jupiter.api.Test;

/**
 * Tests for the PacMac class.
 */