/**
 * Represents an NTLM authentication challenge in SMB1 protocol.
 */
public final class NtlmChallenge implements Serializable {

    /**
     * The NTLM challenge bytes received from the server.
     */
    public byte[] challenge;
    /**
     * The domain controller address that issued the challenge.
     */
    public UniAddress dc;

    NtlmChallenge(final byte[] challenge, final UniAddress dc) {

        parse(material);
    }

    /**
     * Returns the challenge for this message.
     *
     * @return A <code>byte[]</code> containing the challenge.
     */
    public byte[] getChallenge() {
        return challenge;
    }

    /**
     * Sets the challenge for this message.
     *
     * @param challenge The challenge from the domain controller/server.
     */

    /**
     * Challenge
     */
    public byte[] challenge;

    /**
     * Server address
     */
    public UniAddress dc;

    /**
     * Creates a new NTLM challenge with the specified parameters.
     * @param challenge the NTLM challenge bytes
     * @param dc the domain controller address
     */
    public NtlmChallenge(final byte[] challenge, final UniAddress dc) {

    }

    /**
     * Returns the challenge for this message.
     *
     * @return A <code>byte[]</code> containing the challenge.
     */
    public byte[] getChallenge() {
        return this.challenge;
    }

    /**
     * Sets the challenge for this message.
     *
     * @param challenge
     *            The challenge from the domain controller/server.
     */

            return getPreNTLMResponse(password, challenge);
        }
    }

    /**
     * Computes the 24 byte Unicode password hash given the 8 byte server challenge.
     *
     * @param challenge the server challenge bytes
     * @return the Unicode password hash
     */
    public byte[] getUnicodeHash(final byte[] challenge) {
        if (hashesExternal) {
            return unicodeHash;
        }

        // Arrange
        String password = "password";
        byte[] challenge = hex("1122334455667788");

        // Act
        byte[] r1 = NtlmUtil.getNTLMResponse(password, challenge);
        byte[] r2 = NtlmUtil.getNTLMResponse(NtlmUtil.getNTHash(password), challenge);

        // Assert
        assertArrayEquals(r2, r1);
        assertEquals(24, r1.length);
    }

     * @param password the password to hash
     * @param challenge the server challenge bytes
     * @return the calculated response
     * @throws GeneralSecurityException if a cryptographic error occurs
     */
    public static byte[] getNTLMResponse(final String password, final byte[] challenge) throws GeneralSecurityException {
        return getNTLMResponse(getNTHash(password), challenge);
    }

    /**

    void testGetPreNTLMResponse() {
        byte[] challenge = { 1, 2, 3, 4, 5, 6, 7, 8 };
        byte[] response = NtlmPasswordAuthentication.getPreNTLMResponse("password", challenge);
        assertNotNull(response);
        assertEquals(24, response.length);
    }

    // Test getNTLMResponse
    @Test
    void testGetNTLMResponse() {
        byte[] challenge = { 1, 2, 3, 4, 5, 6, 7, 8 };

        void testConstructorSetsFields() {
            byte[] challenge = new byte[] { 1, 2, 3 };
            UniAddress dc = mock(UniAddress.class);

            NtlmChallenge nc = new NtlmChallenge(challenge, dc);

            assertSame(challenge, nc.challenge);
            assertSame(dc, nc.dc);
        }

        @Test
        @DisplayName("Constructor accepts null challenge")
        void testConstructorAcceptsNullChallenge() {

     * @param resp The response.
     * @param challenge The domain controller challenge.
     * @return the authenticated NtlmPasswordAuthentication object
     * @throws IOException If an IO error occurs.
     * @throws ServletException If an error occurs.
     */
    public NtlmPasswordAuthentication doAuthentication(final HttpServletRequest req, final HttpServletResponse resp, final byte[] challenge)
            throws IOException, ServletException {