@@ -36,6 +36,7 @@ public class UserAuthority implements Authority {
     private static final Logger LOG = LoggerFactory.getLogger(UserAuthority.class);
     static final String ATHENZ_PROP_PAM_SERVICE_NAME = "athenz.auth.user.pam_service_name";
 
+    final String userDomain = System.getProperty("athenz.user_domain", "user");
     final String serviceName = System.getProperty(ATHENZ_PROP_PAM_SERVICE_NAME, "login");
     private PAM pam = null;
     
/**
 * Copyright 2016 Yahoo Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.yahoo.athenz.auth.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.yahoo.athenz.auth.Authority;
import com.yahoo.athenz.auth.Principal;

import java.nio.charset.StandardCharsets;

import org.bouncycastle.util.encoders.Base64;
import org.jvnet.libpam.PAM;
import org.jvnet.libpam.PAMException;
import org.jvnet.libpam.UnixUser;

/**
 * Implementation that performs validation of PAM.
 */
public class UserAuthority implements Authority {

    private static final Logger LOG = LoggerFactory.getLogger(UserAuthority.class);
    static final String ATHENZ_PROP_PAM_SERVICE_NAME = "athenz.auth.user.pam_service_name";

    final String serviceName = System.getProperty(ATHENZ_PROP_PAM_SERVICE_NAME, "login");
    private PAM pam = null;
    
    public UserAuthority() {
    }

    @Override
    public void initialize() {
    }

    @Override
    public String getDomain() {
        return "user";
    }

    @Override
    public String getHeader() {
        return "Authorization";
    };

    /*
     * we don't want the user to keep specifying their username and
     * password as part of the request. instead, the user must first
     * request a usertoken and then use that usertoken for all other
     * requests against ZMS and ZTS servers.
     * @see com.yahoo.athenz.auth.Authority#allowAuthorization()
     */
    @Override
    public boolean allowAuthorization() {
        return false;
    }
    
    void setPAM(PAM pam) {
        this.pam = pam;
    }
    
    PAM getPAM() throws PAMException {
        if (pam != null) {
            return pam;
        }
        return new PAM(serviceName);
    }
    
    @Override
    public Principal authenticate(String creds, String remoteAddr, String httpMethod, StringBuilder errMsg) {
        errMsg = errMsg == null ? new StringBuilder(512) : errMsg;

        // the HTTP Basic authorization format is: Basic base64(<username>:<password>)
        
        if (!creds.startsWith("Basic ")) {
            errMsg.append("UserAuthority:authenticate: credentials do not start with 'Basic '");
            LOG.error(errMsg.toString());
            return null;
        }
        
        // decode - need to skip the first 6 bytes for 'Basic '
        
        String decoded;
        try {
            decoded = new String(Base64.decode(creds.substring(6).getBytes(StandardCharsets.UTF_8)));
        } catch (Exception e) {
            errMsg.append("UserAuthority:authenticate: factory exc=").append(e.getMessage());
            LOG.error(errMsg.toString());
            return null;
        }

        String[] userArray = decoded.split(":");
        String username = userArray[0];
        String password = userArray[1];

        // we need to catch all exceptions here and just return
        // failure to allow other authorities to handle authentication
        // if necessary
        
        UnixUser user = null;
        try {
            user = getPAM().authenticate(username, password);
        } catch (Throwable ex) {
            errMsg.append("UserAuthority:authenticate: failed: user=").append(username).
                append(" exc=").append(ex.getMessage());
            LOG.error(errMsg.toString());
            return null;
        }
        
        if (user == null) {
            errMsg.append("UserAuthority:authenticate: failed: user=").append(username);
            LOG.error(errMsg.toString());
            return null;
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("UserAuthority.authenticate: valid user=" + username);
        }

        // all the role members in Athenz are normalized to lower case so we need to make
        // sure our principal's name and domain are created with lower case as well

        long issueTime = 0;
        SimplePrincipal princ = (SimplePrincipal) SimplePrincipal.create(getDomain().toLowerCase(),
                userArray[0].toLowerCase(), creds, issueTime, this);
        princ.setUnsignedCreds(creds);
        return princ;
    }
}

Not sure what is the reason for this? Is there is a reason why you want to configure the domain name? Most likely you need to define your own authority as oppose to changing the default user authority.