*/
package jcifs;


/**
 * Interface for opaque credential data
 * 
 * @author mbechler
 *
 */
public interface Credentials {

    /**
     * 
     * @param type
     * @return instance for type, null if the type cannot be unwrapped
     */
    <T extends Credentials> T unwrap ( Class<T> type );


    /**
     * @return the domain the user account is in
     */

                final AuthScope authScope = getAuthScope(webAuthName, scheme, paramMap);
                final Credentials credentials = getCredentials(webAuthName, scheme, paramMap);
                basicAuthList.add(new AuthenticationImpl(authScope, credentials, authScheme));
            }
            factoryParamMap.put(HcHttpClient.BASIC_AUTHENTICATIONS_PROPERTY,

    /**
     * Authenticate arbitrary credentials represented by the
     * <tt>NtlmPasswordAuthentication</tt> object against the domain controller
     * specified by the <tt>UniAddress</tt> parameter. If the credentials are
     * not accepted, an <tt>SmbAuthException</tt> will be thrown. If an error
     * occurs an <tt>SmbException</tt> will be thrown. If the credentials are

          System.out.println("Authenticating for response: " + response);
          System.out.println("Challenges: " + response.challenges());
          String credential = Credentials.basic("jesse", "password1");
          return response.request().newBuilder()
              .header("Authorization", credential)
              .build();
        })
        .build();
  }

  public void run() throws Exception {

    new PreemptiveAuth().run();
  }

  static final class BasicAuthInterceptor implements Interceptor {
    private final String credentials;
    private final String host;

    BasicAuthInterceptor(String host, String username, String password) {
      this.credentials = Credentials.basic(username, password);
      this.host = host;
    }

    @Override public Response intercept(Chain chain) throws IOException {

import java.net.MalformedURLException;
import java.net.URLStreamHandler;

import jcifs.BufferCache;
import jcifs.CIFSContext;
import jcifs.CIFSException;
import jcifs.Configuration;
import jcifs.Credentials;
import jcifs.DfsResolver;
import jcifs.NameServiceClient;
import jcifs.SidResolver;
import jcifs.SmbPipeResource;
import jcifs.SmbResource;
import jcifs.SmbTransportPool;
import jcifs.smb.Handler;

    protected static final String ACCESS_CONTROL_ALLOW_PRIVATE_NETWORK = "Access-Control-Allow-Private-Network";

    protected static final String ACCESS_CONTROL_ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials";

    protected static final String ACCESS_CONTROL_MAX_AGE = "Access-Control-Max-Age";

    public abstract void process(String origin, ServletRequest request, ServletResponse response);

import javax.security.auth.Subject;

import jcifs.CIFSContext;
import jcifs.CIFSException;
import jcifs.Credentials;


/**
 * @author mbechler
 *
 */
public interface CredentialsInternal extends Cloneable, Credentials {

    /**
     * 
     * @return a copy of the credentials
     */
    CredentialsInternal clone ();


    /**
     * @param tc
     * @param targetDomain

 */

package jcifs.smb1.smb1;

/**
This class can be extended by applications that wish to trap authentication related exceptions and automatically retry the exceptional operation with different credentials. Read <a href="../../../authhandler.html">jCIFS Exceptions and NtlmAuthenticator</a> for complete details.
 */

public abstract class NtlmAuthenticator {

    private static NtlmAuthenticator auth;

        System.arraycopy(clientChallenge, 0, response, 16, 8);
        return response;
    }


    /**
     * Generate the Unicode MD4 hash for the password associated with these credentials.
     * 
     * @param password
     * @param challenge
     * @return the calculated response
     * @throws GeneralSecurityException
     */