.setRedirectUri(getOicRedirectUrl())//
                .setState(state)//
                .build();
    }

    /**
     * Decodes a Base64 string to bytes.
     *
     * @param base64String the Base64 string to decode
     * @return the decoded bytes, or null if input is null
     */
    protected byte[] decodeBase64(String base64String) {
        if (base64String == null) {

import java.nio.charset.StandardCharsets;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.Base64;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.logging.log4j.LogManager;

    // Base64 encoded Type 1 message: NTLMSSP, Type 1, flags=0x00088207
    // Domain="DOMAIN", Workstation="WORKSTATION"
    private final String type1MessageBase64 = "TlRMTVNTUAABAAAABzIAAAYABgArAAAACwALACAAAABET01BSU5XT1JLU1RBVElPTg==";

    // Base64 encoded Type 3 message: NTLMSSP, Type 3
    // User: "user", Domain: "DOMAIN", Workstation: "WORKSTATION"

        if (msg != null && msg.startsWith("NTLM ")) {
            final byte[] src = Base64.decode(msg.substring(5));
            if (src[8] == 1) {
                final Type1Message type1 = new Type1Message(src);
                final Type2Message type2 = new Type2Message(type1, challenge, null);
                msg = Base64.encode(type2.toByteArray());
                resp.setHeader("WWW-Authenticate", "NTLM " + msg);

        byte[] encrypted = encryptCredentials(plaintext);
        return Base64.getEncoder().encodeToString(encrypted);
    }

    /**
     * Decrypt credentials from a base64 string
     *
     * @param encryptedString base64 encoded encrypted credentials
     * @return decrypted credentials
     * @throws GeneralSecurityException if decryption fails
     */

  fun basic(
    username: String,
    password: String,
    charset: Charset = ISO_8859_1,
  ): String {
    val usernameAndPassword = "$username:$password"
    val encoded = usernameAndPassword.encode(charset).base64()
    return "Basic $encoded"
  }

     * @param path the path of the item
     * @param directory true if this item is a directory
     * @param size the size of the item in bytes
     * @param lastModified the last modified timestamp
     * @param encodedId the base64-encoded ID of the item
     */
    public StorageItem(final String name, final String path, final boolean directory, final long size, final ZonedDateTime lastModified,
            final String encodedId) {

 *
 * @author Ben Yu
 */

@NullUnmarked
public class PackageSanityTests extends AbstractPackageSanityTests {
  public PackageSanityTests() {
    setDefault(BaseEncoding.class, BaseEncoding.base64());
    setDefault(int.class, 32);
    setDefault(String.class, "abcd");
    setDefault(Method.class, AbstractPackageSanityTests.class.getDeclaredMethods()[0]);
    setDefault(MapMode.class, MapMode.READ_ONLY);

    /** Settings ID. */
    protected final String settingsId;
    /** Suggest settings. */
    protected final SuggestSettings settings;

    private static final Base64.Encoder encoder = Base64.getEncoder();

    /**
     * Constructor.
     * @param settings Suggest settings
     * @param client OpenSearch client
     * @param settingsIndexName Settings index name

 */
package org.codelibs.fess.opensearch.user.exentity;

import static org.codelibs.core.stream.StreamUtil.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.codelibs.fess.Constants;
import org.codelibs.fess.entity.FessUser;
import org.codelibs.fess.mylasta.direction.FessConfig;