import jcifs.smb1.util.HMACT64;
import jcifs.smb1.util.MD4;
import jcifs.smb1.util.RC4;

import java.security.GeneralSecurityException;

/**
 * Represents an NTLMSSP Type-3 message.
 */
public class Type3Message extends NtlmMessage {

    static final long MILLISECONDS_BETWEEN_1970_AND_1601 = 11644473600000L;

    private static final int DEFAULT_FLAGS;

    private static final String DEFAULT_DOMAIN;

import jcifs.ntlmssp.av.AvTargetName;
import jcifs.ntlmssp.av.AvTimestamp;
import jcifs.smb.NtlmUtil;
import jcifs.util.Crypto;


/**
 * Represents an NTLMSSP Type-3 message.
 */
public class Type3Message extends NtlmMessage {

    private byte[] lmResponse;
    private byte[] ntResponse;
    private String domain;
    private String user;
    private String workstation;
    private byte[] masterKey = null;

        };
        String domain = "TESTDOM";
        String user = "TESTUSER";
        String workstation = "TESTWS";
        Type3Message t3 = new Type3Message(flags, lmResponse, ntResponse, domain, user, workstation);

        Type3Message parsed = new Type3Message(t3.toByteArray());

        assertEquals(domain, parsed.getDomain());
        assertEquals(user, parsed.getUser());

     * @return
     * @throws GeneralSecurityException
     * @throws CIFSException
     */
    protected Type3Message createType3Message ( Type2Message msg2 ) throws GeneralSecurityException, CIFSException {
        if ( this.auth instanceof NtlmNtHashAuthenticator ) {
            return new Type3Message(
                this.transportContext,
                msg2,
                this.targetName,

                if (response != HTTP_UNAUTHORIZED &&
                        response != HTTP_PROXY_AUTH) {
                    return;
                }
                Type3Message type3 = (Type3Message)
                        attemptNegotiation(response);
                if (type3 == null) return;
                connection.setRequestProperty(authProperty, authMethod + ' ' +

                resp.setHeader("WWW-Authenticate", "NTLM " + msg);
            }
            else if ( src[ 8 ] == 3 ) {
                Type3Message type3 = new Type3Message(src);
                byte[] lmResponse = type3.getLMResponse();
                if ( lmResponse == null )
                    lmResponse = new byte[0];

                msg = Base64.encode(type2.toByteArray());
                resp.setHeader( "WWW-Authenticate", "NTLM " + msg );
            } else if (src[8] == 3) {
                Type3Message type3 = new Type3Message(src);
                byte[] lmResponse = type3.getLMResponse();
                if (lmResponse == null) lmResponse = new byte[0];
                byte[] ntResponse = type3.getNTResponse();

                    serverChallenge = msg2.getChallenge();
                    ntlmsspFlags &= msg2.getFlags();

//                  netbiosName = getNtlmsspListItem(token, 0x0001);

                    Type3Message msg3 = new Type3Message(msg2,
                                auth.getPassword(),
                                auth.getDomain(),
                                auth.getUsername(),
                                workstation,

import jcifs.CIFSContext;
import jcifs.RuntimeCIFSException;
import jcifs.ntlmssp.NtlmFlags;
import jcifs.ntlmssp.NtlmMessage;
import jcifs.ntlmssp.Type1Message;
import jcifs.ntlmssp.Type2Message;
import jcifs.ntlmssp.Type3Message;
import jcifs.smb.NtlmPasswordAuthentication;


/**
 * Wraps an <code>HttpURLConnection</code> to provide NTLM authentication
 * services.
 *

                        } catch (SmbException se) {
                            /* We must close the transport or the server will be expecting a
                             * Type3Message. Otherwise, when we send a Type1Message it will return
                             * "Invalid parameter".
                             */