org.keycloak.adapters.KcinitMain クラス

org.keycloak.adapters.KcinitMain の継承関係図

org.keycloak.adapters.KcinitMain 連携図

公開メンバ関数
void	mainCmd (String[] args) throws Exception
String	getHome ()
void	passwordKey ()
JWE	createJWE ()
String	encrypt (String payload)
String	decrypt (String encoded)
File	getConfigDirectory ()
File	getConfigFile ()
File	getTokenFilePath (String client)
File	getTokenDirectory ()
void	install ()
void	printHelp ()
AdapterConfig	getConfig ()
String	readToken (String client) throws Exception
String	readRefreshToken (String client) throws Exception
void	token () throws Exception
String	getProperty (String name)
Client	getHttpClient ()
void	login () throws Exception
void	doConsoleLogin () throws Exception
void	logout () throws Exception
void	uninstall () throws Exception

静的公開メンバ関数
static void	main (String[] args) throws Exception
static String	getenv (String name, String defaultValue)

静的公開変数類
static final String	KC_SESSION_KEY = "KC_SESSION_KEY"
static final String	KC_LOGIN_CONFIG_PATH = "KC_LOGIN_CONFIG_PATH"

限定公開メンバ関数
boolean	forceLogin ()
String	generateEncryptionKey (String password) throws NoSuchAlgorithmException, InvalidKeySpecException
String	getEncryptionKey ()
void	checkEnv ()
void	promptLocalPassword ()
String	readFile (File fp)
byte []	readFileRaw (File fp) throws IOException
void	writeFile (File fp, String payload)
String	getMasterClientSecret ()
String	getServer ()
String	getRealm ()

限定公開変数類
Map< String, String >	config
boolean	debug = true
boolean	forceLogin
boolean	browserLogin
String	encryptionKey
boolean	encrypted = false

静的限定公開変数類
static byte []	salt = new byte[]{-4, 88, 66, -101, 78, -94, 21, 105}

変数
String []	args = null

詳解

著者

Bill Burke

バージョン

Revision

1

関数詳解

checkEnv()

void org.keycloak.adapters.installed.KcinitDriver.checkEnv ( )

inlineprotectedinherited

                              {
        File configFile = getConfigFile();
        if (!configFile.exists()) {
            KeycloakInstalled.console().writer().println("You have not configured kcinit.  Please run 'kcinit install' to configure.");
            System.exit(1);
        }
        byte[] data = new byte[0];
        try {
            data = readFileRaw(configFile);
        } catch (IOException e) {

        }
        if (data == null) {
            KeycloakInstalled.console().writer().println("Config file unreadable.  Please run 'kcinit install' to configure.");
            System.exit(1);

        }
        String encodedJwe = null;
        try {
            encodedJwe = new String(data, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        if (encodedJwe.contains("realm")) {
            encrypted = false;
            return;
        } else {
            encrypted = true;
        }

        if (System.getenv(KC_SESSION_KEY) == null) {
            promptLocalPassword();
        }
    }

createJWE()

JWE org.keycloak.adapters.installed.KcinitDriver.createJWE ( )

inlineinherited

                           {
        String key = getEncryptionKey();
        if (key == null) {
            throw new RuntimeException(KC_SESSION_KEY + " env var not set");
        }
        byte[] aesKey = null;
        try {
            aesKey = Base64.decode(key.getBytes("UTF-8"));
        } catch (IOException e) {
            throw new RuntimeException("invalid " + KC_SESSION_KEY + "env var");
        }

        JWE jwe = new JWE();
        final SecretKey aesSecret = new SecretKeySpec(aesKey, "AES");
        jwe.getKeyStorage()
                .setEncryptionKey(aesSecret);
        return jwe;
    }

decrypt()

String org.keycloak.adapters.installed.KcinitDriver.decrypt ( String  encoded )

inlineinherited

                                          {
        JWE jwe = createJWE();
        try {
            jwe.verifyAndDecodeJwe(encoded);
            byte[] content = jwe.getContent();
            if (content == null) return null;
            return new String(content, "UTF-8");
        } catch (Exception ex) {
            throw new RuntimeException("cannot decrypt payload", ex);

        }

    }

doConsoleLogin()

void org.keycloak.adapters.installed.KcinitDriver.doConsoleLogin ( ) throws Exception

inlineinherited

                                                  {
        String masterClient = getMasterClient();
        AdapterConfig config = getConfig();
        KeycloakInstalled installed = new KeycloakInstalled(KeycloakDeploymentBuilder.build(config));
        //System.err.println("calling loginCommandLine");
        if (!installed.loginCommandLine()) {
            System.exit(1);
        }
        processResponse(installed, masterClient);
    }

encrypt()

String org.keycloak.adapters.installed.KcinitDriver.encrypt ( String  payload )

inlineinherited

                                          {
        JWE jwe = createJWE();
        JWEHeader jweHeader = new JWEHeader(JWEConstants.A128KW, JWEConstants.A128CBC_HS256, null);
        try {
            jwe.header(jweHeader).content(payload.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("cannot encode payload as UTF-8");
        }
        try {
            return jwe.encodeJwe();
        } catch (JWEException e) {
            throw new RuntimeException("cannot encrypt payload", e);
        }
    }

forceLogin()

boolean org.keycloak.adapters.installed.KcinitDriver.forceLogin ( )

inlineprotectedinherited

                                   {
        return args.length > 0 && args[0].equals("-f");

    }

generateEncryptionKey()

String org.keycloak.adapters.installed.KcinitDriver.generateEncryptionKey ( String  password ) throws NoSuchAlgorithmException, InvalidKeySpecException

inlineprotectedinherited

                                                                                                                     {
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 100, 128);
        SecretKey tmp = factory.generateSecret(spec);
        byte[] aeskey = tmp.getEncoded();
        return Base64.encodeBytes(aeskey);
    }

getConfig()

AdapterConfig org.keycloak.adapters.installed.KcinitDriver.getConfig ( )

inlineinherited

                                     {
        File configFile = getConfigFile();
        if (!configFile.exists()) {
            KeycloakInstalled.console().writer().println("You have not configured kcinit.  Please run 'kcinit install' to configure.");
            System.exit(1);
            return null;
        }

        AdapterConfig config = new AdapterConfig();
        config.setAuthServerUrl((String) getConfigProperties().get("server"));
        config.setRealm((String) getConfigProperties().get("realm"));
        config.setResource((String) getConfigProperties().get("client"));
        config.setSslRequired("external");
        String secret = (String) getConfigProperties().get("secret");
        if (secret != null && !secret.trim().equals("")) {
            Map<String, Object> creds = new HashMap<>();
            creds.put("secret", secret);
            config.setCredentials(creds);
        } else {
            config.setPublicClient(true);
        }
        return config;
    }

getConfigDirectory()

File org.keycloak.adapters.installed.KcinitDriver.getConfigDirectory ( )

inlineinherited

                                     {
        return Paths.get(getHome(), getenv(KC_LOGIN_CONFIG_PATH, ".keycloak"), "kcinit").toFile();
    }

getConfigFile()

File org.keycloak.adapters.installed.KcinitDriver.getConfigFile ( )

inlineinherited

                                {
        return Paths.get(getHome(), getenv(KC_LOGIN_CONFIG_PATH, ".keycloak"), "kcinit", "config.json").toFile();
    }

getEncryptionKey()

String org.keycloak.adapters.installed.KcinitDriver.getEncryptionKey ( )

inlineprotectedinherited

                                        {
        if (encryptionKey != null) return encryptionKey;
        return System.getenv(KC_SESSION_KEY);
    }

getenv()

static String org.keycloak.adapters.installed.KcinitDriver.getenv ( String  name, String  defaultValue  )

inlinestaticinherited

                                                                  {
        String val = System.getenv(name);
        return val == null ? defaultValue : val;
    }

getHome()

String org.keycloak.adapters.installed.KcinitDriver.getHome ( )

inlineinherited

                            {
        String home = System.getenv("HOME");
        if (home == null) {
            home = System.getProperty("HOME");
            if (home == null) {
                home = Paths.get("").toAbsolutePath().normalize().toString();
            }
        }
        return home;
    }

getHttpClient()

Client org.keycloak.adapters.installed.KcinitDriver.getHttpClient ( )

inlineinherited

                                  {
        return new ResteasyClientBuilder().disableTrustManager().build();
    }

getMasterClientSecret()

String org.keycloak.adapters.installed.KcinitDriver.getMasterClientSecret ( )

inlineprotectedinherited

                                             {
        return getProperty("secret");
    }

getProperty()

String org.keycloak.adapters.installed.KcinitDriver.getProperty ( String  name )

inlineinherited

                                           {
        return (String) getConfigProperties().get(name);
    }

getRealm()

String org.keycloak.adapters.installed.KcinitDriver.getRealm ( )

inlineprotectedinherited

                                {
        return getProperty("realm");
    }

getServer()

String org.keycloak.adapters.installed.KcinitDriver.getServer ( )

inlineprotectedinherited

                                 {
        return getProperty("server");
    }

getTokenDirectory()

File org.keycloak.adapters.installed.KcinitDriver.getTokenDirectory ( )

inlineinherited

                                    {
        return Paths.get(getHome(), getenv(KC_LOGIN_CONFIG_PATH, ".keycloak"), "kcinit", "tokens").toFile();
    }

getTokenFilePath()

File org.keycloak.adapters.installed.KcinitDriver.getTokenFilePath ( String  client )

inlineinherited

                                                {
        return Paths.get(getHome(), getenv(KC_LOGIN_CONFIG_PATH, ".keycloak"), "kcinit", "tokens", client).toFile();
    }

install()

void org.keycloak.adapters.installed.KcinitDriver.install ( )

inlineinherited

                          {
        if (getEncryptionKey() == null) {
            if (KeycloakInstalled.console().confirm("Do you want to protect tokens stored locally with a password? (y/n): ")) {
                String password = "p";
                String confirm = "c";
                do {
                    password = KeycloakInstalled.console().passwordPrompt("Enter local password: ");
                    confirm = KeycloakInstalled.console().passwordPrompt("Confirm local password: ");
                    if (!password.equals(confirm)) {
                        KeycloakInstalled.console().writer().println();
                        KeycloakInstalled.console().writer().println("Confirmation does not match.  Try again.");
                        KeycloakInstalled.console().writer().println();
                    }
                } while (!password.equals(confirm));
                try {
                    this.encrypted = true;
                    this.encryptionKey = generateEncryptionKey(password);
                } catch (Exception e) {
                    e.printStackTrace();
                    System.exit(1);
                }
            }
        } else {
            if (!KeycloakInstalled.console().confirm("KC_SESSION_KEY env var already set.  Do you want to use this as your local encryption key? (y/n): ")) {
                KeycloakInstalled.console().writer().println("Unset KC_SESSION_KEY env var and run again");
                System.exit(1);
            }
            this.encrypted = true;
            this.encryptionKey = getEncryptionKey();
        }
        String server = KeycloakInstalled.console().readLine("Authentication server URL [http://localhost:8080/auth]: ").trim();
        String realm = KeycloakInstalled.console().readLine("Name of realm [master]: ").trim();
        String client = KeycloakInstalled.console().readLine("CLI client id [kcinit]: ").trim();
        String secret = KeycloakInstalled.console().readLine("CLI client secret [none]: ").trim();
        if (server.equals("")) {
            server = "http://localhost:8080/auth";
        }
        if (realm.equals("")) {
            realm = "master";
        }
        if (client.equals("")) {
            client = "kcinit";
        }
        File configDir = getTokenDirectory();
        configDir.mkdirs();

        File configFile = getConfigFile();
        Map<String, String> props = new HashMap<>();
        props.put("server", server);
        props.put("realm", realm);
        props.put("client", client);
        props.put("secret", secret);

        try {
            String json = JsonSerialization.writeValueAsString(props);
            writeFile(configFile, json);
        } catch (Exception e) {
            e.printStackTrace();
        }

        KeycloakInstalled.console().writer().println();
        KeycloakInstalled.console().writer().println("Installation complete!");
        KeycloakInstalled.console().writer().println();
    }

login()

void org.keycloak.adapters.installed.KcinitDriver.login ( ) throws Exception

inlineinherited

                                         {
        checkEnv();
        this.args = Arrays.copyOfRange(this.args, 1, this.args.length);
        for (String arg : args) {
            if (arg.equals("-f") || arg.equals("-force")) {
                forceLogin = true;
                this.args = Arrays.copyOfRange(this.args, 1, this.args.length);
            } else if (arg.equals("-browser") || arg.equals("-b")) {
                browserLogin = true;
                this.args = Arrays.copyOfRange(this.args, 1, this.args.length);
            } else {
                System.err.println("Illegal argument: " + arg);
                printHelp();
                System.exit(1);
            }
        }

        String masterClient = getMasterClient();
        if (!forceLogin && readToken(masterClient) != null) {
            KeycloakInstalled.console().writer().println("Already logged in.  `kcinit -f` to force relogin");
            return;
        }
        doConsoleLogin();
        KeycloakInstalled.console().writer().println("Login successful!");
    }

logout()

void org.keycloak.adapters.installed.KcinitDriver.logout ( ) throws Exception

inlineinherited

                                          {
        String token = readRefreshToken(getMasterClient());
        if (token != null) {
            try {
                KeycloakDeployment deployment = KeycloakDeploymentBuilder.build(getConfig());
                ServerRequest.invokeLogout(deployment, token);
            } catch (Exception e) {
                if (debug) {
                    e.printStackTrace();
                }
            }

        }
        if (getTokenDirectory().exists()) {
            for (File fp : getTokenDirectory().listFiles()) fp.delete();
        }
    }

main()

static void org.keycloak.adapters.KcinitMain.main ( String []  args ) throws Exception

inlinestatic

                                                            {
        new KcinitMain().mainCmd(args);
    }

mainCmd()

void org.keycloak.adapters.installed.KcinitDriver.mainCmd ( String []  args ) throws Exception

inlineinherited

                                                        {

        this.args = args;


        if (args.length == 0) {
            printHelp();
            return;
        }

        if (args[0].equalsIgnoreCase("token")) {
            //System.err.println("executing token");
            token();
        } else if (args[0].equalsIgnoreCase("login")) {
            login();
        } else if (args[0].equalsIgnoreCase("logout")) {
            logout();
        } else if (args[0].equalsIgnoreCase("env")) {
            System.out.println(System.getenv().toString());
        } else if (args[0].equalsIgnoreCase("install")) {
            install();
        } else if (args[0].equalsIgnoreCase("uninstall")) {
            uninstall();
        } else if (args[0].equalsIgnoreCase("password")) {
            passwordKey();
        } else {
            KeycloakInstalled.console().writer().println("Unknown command: " + args[0]);
            KeycloakInstalled.console().writer().println();
            printHelp();
        }
    }

passwordKey()

void org.keycloak.adapters.installed.KcinitDriver.passwordKey ( )

inlineinherited

                              {
        if (args.length < 2) {
            printHelp();
            System.exit(1);
        }
        String password = args[1];
        try {
            String encodedKey = generateEncryptionKey(password);
            System.out.printf(encodedKey);
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

printHelp()

void org.keycloak.adapters.installed.KcinitDriver.printHelp ( )

inlineinherited

                            {
        KeycloakInstalled.console().writer().println("Commands:");
        KeycloakInstalled.console().writer().println("  login [-f] -f forces login");
        KeycloakInstalled.console().writer().println("  logout");
        KeycloakInstalled.console().writer().println("  token [client] - print access token of desired client.  Defaults to default master client.  Will print either 'error', 'not-allowed',  or 'login-required' on error.");
        KeycloakInstalled.console().writer().println("  install - Install this utility.  Will store in $HOME/.keycloak/kcinit unless " + KC_LOGIN_CONFIG_PATH + " env var is set");
        System.exit(1);
    }

promptLocalPassword()

void org.keycloak.adapters.installed.KcinitDriver.promptLocalPassword ( )

inlineprotectedinherited

                                         {
        String password = KeycloakInstalled.console().passwordPrompt("Enter password to unlock kcinit config files: ");
        try {
            encryptionKey = generateEncryptionKey(password);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

readFile()

String org.keycloak.adapters.installed.KcinitDriver.readFile ( File  fp )

inlineprotectedinherited

                                       {
        try {
            byte[] data = readFileRaw(fp);
            if (data == null) return null;
            String file = new String(data, "UTF-8");
            if (!encrypted) {
                return file;
            }
            String decrypted = decrypt(file);
            if (decrypted == null)
                throw new RuntimeException("Unable to decrypt file.  Did you set your local password correctly?");
            return decrypted;
        } catch (IOException e) {
            throw new RuntimeException("failed to decrypt file: " + fp.getAbsolutePath() + " Did you set your local password correctly?", e);
        }


    }

readFileRaw()

byte [] org.keycloak.adapters.installed.KcinitDriver.readFileRaw ( File  fp ) throws IOException

inlineprotectedinherited

                                                             {
        if (!fp.exists()) return null;
        FileInputStream fis = new FileInputStream(fp);
        byte[] data = new byte[(int) fp.length()];
        fis.read(data);
        fis.close();
        return data;
    }

readRefreshToken()

String org.keycloak.adapters.installed.KcinitDriver.readRefreshToken ( String  client ) throws Exception

inlineinherited

                                                                   {
        String json = getTokenResponse(client);
        if (json == null) return null;


        if (json != null) {
            try {
                AccessTokenResponse tokenResponse = JsonSerialization.readValue(json, AccessTokenResponse.class);
                return tokenResponse.getRefreshToken();
            } catch (Exception e) {
                if (debug) {
                    e.printStackTrace();
                }
                File tokenFile = getTokenFilePath(client);
                if (tokenFile.exists()) {
                    tokenFile.delete();
                }

                return null;
            }
        }
        return null;

    }

readToken()

String org.keycloak.adapters.installed.KcinitDriver.readToken ( String  client ) throws Exception

inlineinherited

                                                            {
        String json = getTokenResponse(client);
        if (json == null) return null;


        if (json != null) {
            try {
                AccessTokenResponse tokenResponse = JsonSerialization.readValue(json, AccessTokenResponse.class);
                if (Time.currentTime() < tokenResponse.getExpiresIn()) {
                    return tokenResponse.getToken();
                }
                AdapterConfig config = getConfig();
                KeycloakInstalled installed = new KeycloakInstalled(KeycloakDeploymentBuilder.build(config));
                installed.refreshToken(tokenResponse.getRefreshToken());
                processResponse(installed, client);
                return tokenResponse.getToken();
            } catch (Exception e) {
                File tokenFile = getTokenFilePath(client);
                if (tokenFile.exists()) {
                    tokenFile.delete();
                }

                return null;
            }
        }
        return null;

    }

token()

void org.keycloak.adapters.installed.KcinitDriver.token ( ) throws Exception

inlineinherited

                                         {
        KeycloakInstalled.console().stderrOutput();

        checkEnv();
        String masterClient = getMasterClient();
        String client = masterClient;
        if (args.length > 1) {
            client = args[1];
        }
        //System.err.println("readToken: " + client);
        String token = readToken(client);
        if (token != null) {
            System.out.print(token);
            return;
        }
        if (token == null && client.equals(masterClient)) {
            //System.err.println("not logged in, logging in.");
            doConsoleLogin();
            token = readToken(client);
            if (token != null) {
                System.out.print(token);
                return;
            }

        }
        String masterToken = readToken(masterClient);
        if (masterToken == null) {
            //System.err.println("not logged in, logging in.");
            doConsoleLogin();
            masterToken = readToken(masterClient);
            if (masterToken == null) {
                System.err.println("Login failed.  Cannot retrieve token");
                System.exit(1);
            }
        }

        //System.err.println("exchange: " + client);
        Client httpClient = getHttpClient();

        WebTarget exchangeUrl = httpClient.target(getServer())
                .path("/realms")
                .path(getRealm())
                .path("protocol/openid-connect/token");

        Form form = new Form()
                .param(OAuth2Constants.GRANT_TYPE, OAuth2Constants.TOKEN_EXCHANGE_GRANT_TYPE)
                .param(OAuth2Constants.CLIENT_ID, masterClient)
                .param(OAuth2Constants.SUBJECT_TOKEN, masterToken)
                .param(OAuth2Constants.SUBJECT_TOKEN_TYPE, OAuth2Constants.ACCESS_TOKEN_TYPE)
                .param(OAuth2Constants.REQUESTED_TOKEN_TYPE, OAuth2Constants.REFRESH_TOKEN_TYPE)
                .param(OAuth2Constants.AUDIENCE, client);
        if (getMasterClientSecret() != null) {
            form.param(OAuth2Constants.CLIENT_SECRET, getMasterClientSecret());
        }
        Response response = exchangeUrl.request().post(Entity.form(
                form
        ));

        if (response.getStatus() == 401 || response.getStatus() == 403) {
            response.close();
            System.err.println("Not allowed to exchange for client token");
            System.exit(1);
        }

        if (response.getStatus() != 200) {
            if (response.getMediaType() != null && response.getMediaType().equals(MediaType.APPLICATION_JSON_TYPE)) {
                try {
                    String json = response.readEntity(String.class);
                    OAuth2ErrorRepresentation error = JsonSerialization.readValue(json, OAuth2ErrorRepresentation.class);
                    System.err.println("Failed to exchange token: " + error.getError() + ". " + error.getErrorDescription());
                    System.exit(1);
                } catch (Exception ignore) {
                    ignore.printStackTrace();

                }
            }

            response.close();
            System.err.println("Unknown error exchanging for client token: " + response.getStatus());
            System.exit(1);
        }

        String json = response.readEntity(String.class);
        response.close();
        AccessTokenResponse tokenResponse = JsonSerialization.readValue(json, AccessTokenResponse.class);
        if (tokenResponse.getToken() != null) {
            getTokenDirectory().mkdirs();
            tokenResponse.setExpiresIn(Time.currentTime() + tokenResponse.getExpiresIn());
            tokenResponse.setIdToken(null);
            json = JsonSerialization.writeValueAsString(tokenResponse);
            writeFile(getTokenFilePath(client), json);
            System.out.printf(tokenResponse.getToken());
        } else {
            System.err.println("Error processing token");
            System.exit(1);
        }
    }

uninstall()

void org.keycloak.adapters.installed.KcinitDriver.uninstall ( ) throws Exception

inlineinherited

                                             {
        File configFile = getConfigFile();
        if (configFile.exists()) configFile.delete();
        if (getTokenDirectory().exists()) {
            for (File fp : getTokenDirectory().listFiles()) fp.delete();
        }
    }

writeFile()

void org.keycloak.adapters.installed.KcinitDriver.writeFile ( File  fp, String  payload  )

inlineprotectedinherited

                                                      {
        try {
            String data = payload;
            if (encrypted) data = encrypt(payload);
            FileOutputStream fos = new FileOutputStream(fp);
            fos.write(data.getBytes("UTF-8"));
            fos.flush();
            fos.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

メンバ詳解

args

String [] org.keycloak.adapters.installed.KcinitDriver.args = null

packageinherited

browserLogin

boolean org.keycloak.adapters.installed.KcinitDriver.browserLogin

protectedinherited

config

Map<String, String> org.keycloak.adapters.installed.KcinitDriver.config

protectedinherited

debug

boolean org.keycloak.adapters.installed.KcinitDriver.debug = true

protectedinherited

encrypted

boolean org.keycloak.adapters.installed.KcinitDriver.encrypted = false

protectedinherited

encryptionKey

String org.keycloak.adapters.installed.KcinitDriver.encryptionKey

protectedinherited

forceLogin

boolean org.keycloak.adapters.installed.KcinitDriver.forceLogin

protectedinherited

KC_LOGIN_CONFIG_PATH

final String org.keycloak.adapters.installed.KcinitDriver.KC_LOGIN_CONFIG_PATH = "KC_LOGIN_CONFIG_PATH"

staticinherited

KC_SESSION_KEY

final String org.keycloak.adapters.installed.KcinitDriver.KC_SESSION_KEY = "KC_SESSION_KEY"

staticinherited

salt

byte [] org.keycloak.adapters.installed.KcinitDriver.salt = new byte[]{-4, 88, 66, -101, 78, -94, 21, 105}

staticprotectedinherited

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/keycloak/doxygen/src/adapters/oidc/kcinit/src/main/java/org/keycloak/adapters/KcinitMain.java