index = fessConfig.getIndexUserIndex();
                } else if ("fess_basic_config".equals(index) && !"fess_config".equals(fessConfig.getIndexConfigIndex())) {
                    index = "basic_" + fessConfig.getIndexConfigIndex();
                }
                final String alias = index;
                return asStream(filename).contentTypeOctetStream().stream(out -> {

                        if ("fess_basic_config".equals(aliasName) && !CONFIG_INDEX_PREFIX.equals(name)) {
                            aliasName = aliasName.replaceFirst("fess_basic_config", "basic_" + name);
                        } else {
                            aliasName = aliasName.replaceFirst(Pattern.quote(CONFIG_INDEX_PREFIX), name);
                        }

# HTTP Basic Auth { #http-basic-auth }

For the simplest cases, you can use HTTP Basic Auth.

In HTTP Basic Auth, the application expects a header that contains a username and a password.

If it doesn't receive it, it returns an HTTP 401 "Unauthorized" error.

And returns a header `WWW-Authenticate` with a value of `Basic`, and an optional `realm` parameter.

That tells the browser to show the integrated prompt for a username and password.

    private String domainController;

    /** Flag to enable load balancing across domain controllers */
    private boolean loadBalance;

    /** Flag to enable basic authentication */
    private boolean enableBasic;

    /** Flag to allow insecure basic authentication */
    private boolean insecureBasic;

    /** The authentication realm */
    private String realm;

    /** The CIFS context for transport operations */

        filter.doFilter(request, response, filterChain);

        // Should only offer NTLM, not Basic auth
        verify(response).setHeader("WWW-Authenticate", "NTLM");
        verify(response, never()).addHeader(eq("WWW-Authenticate"), eq("Basic realm=\"TestRealm\""));
    }

    @Test
    void testDoFilter_ntlmType1Message() throws Exception {

     * Default implementation delegates to the basic process method.
     *
     * @param target the document data to process
     * @param params the data store parameters
     * @return the processed document data
     */
    public Map<String, Object> process(final Map<String, Object> target, final DataStoreParams params) {
        return process(target);
    }

    /**

import jcifs.config.BaseConfiguration;

/**
 * Basic tests for MultiChannelManager to verify the createChannelTransport implementation.
 */
public class MultiChannelManagerBasicTest {

    private MultiChannelManager multiChannelManager;
    private Configuration config;

    @BeforeEach
    void setUp() throws Exception {
        // Create a basic configuration for testing

    /** Configuration key for allowing unsecure basic authentication. */
    protected static final String SPNEGO_ALLOW_UNSECURE_BASIC = "spnego.allow.unsecure.basic";

    /** Configuration key for allowing basic authentication. */
    protected static final String SPNEGO_ALLOW_BASIC = "spnego.allow.basic";

    /** Configuration key for pre-authentication password. */

      MockResponse(
        code = 401,
        headers = headersOf("WWW-Authenticate", "Basic realm=\"protected area\""),
      ),
    )
    server.enqueue(
      MockResponse(body = "c"),
    )
    val authenticator =
      RecordingOkAuthenticator(
        basic("jesse", "peanutbutter"),
        "Basic",
      )
    client =
      client
        .newBuilder()

    /** The NTLM SSP handler */
    private NtlmSsp ntlmSsp;
    /** Flag indicating if credentials were supplied */
    private boolean credentialsSupplied;
    /** Flag to enable basic authentication */
    private boolean enableBasic;
    /** Flag to allow insecure basic authentication */
    private boolean insecureBasic;
    /** The authentication realm */
    private String realm;
    /** The default domain for authentication */