Examples with FileValue password.pwm.config.value.FileValue used on opensource projects

Example 1 with FileValue

use of password.pwm.config.value.FileValue in project pwm by pwm-project.

the class ConfigGuideServlet method restUploadJDBCDriver.

@ActionHandler(action = "uploadJDBCDriver")
private ProcessStatus restUploadJDBCDriver(final PwmRequest pwmRequest) throws PwmUnrecoverableException, IOException, ServletException {
    try {
        final ConfigGuideBean configGuideBean = getBean(pwmRequest);
        final int maxFileSize = Integer.parseInt(pwmRequest.getConfig().readAppProperty(AppProperty.CONFIG_MAX_JDBC_JAR_SIZE));
        final FileValue fileValue = ConfigEditorServletUtils.readFileUploadToSettingValue(pwmRequest, maxFileSize);
        configGuideBean.setDatabaseDriver(fileValue);
        final RestResultBean restResultBean = RestResultBean.forSuccessMessage(pwmRequest, Message.Success_Unknown);
        pwmRequest.getPwmResponse().outputJsonResult(restResultBean);
    } catch (PwmException e) {
        final RestResultBean restResultBean = RestResultBean.fromError(e.getErrorInformation(), pwmRequest);
        pwmRequest.getPwmResponse().outputJsonResult(restResultBean);
        LOGGER.error(pwmRequest, e.getErrorInformation().toDebugStr());
    }
    return ProcessStatus.Halt;
}

Example 2 with FileValue

use of password.pwm.config.value.FileValue in project pwm by pwm-project.

the class ConfigGuideForm method generateStoredConfig.

public static StoredConfigurationImpl generateStoredConfig(final ConfigGuideBean configGuideBean) throws PwmUnrecoverableException {
    final Map<ConfigGuideFormField, String> formData = configGuideBean.getFormData();
    final StoredConfigurationImpl storedConfiguration = StoredConfigurationImpl.newStoredConfiguration();
    // templates
    updateStoredConfigTemplateValue(formData, storedConfiguration, PwmSetting.TEMPLATE_LDAP, ConfigGuideFormField.PARAM_TEMPLATE_LDAP, PwmSettingTemplate.Type.LDAP_VENDOR);
    updateStoredConfigTemplateValue(formData, storedConfiguration, PwmSetting.TEMPLATE_STORAGE, ConfigGuideFormField.PARAM_TEMPLATE_STORAGE, PwmSettingTemplate.Type.STORAGE);
    updateStoredConfigTemplateValue(formData, storedConfiguration, PwmSetting.DB_VENDOR_TEMPLATE, ConfigGuideFormField.PARAM_DB_VENDOR, PwmSettingTemplate.Type.DB_VENDOR);
    // establish a default ldap profile
    storedConfiguration.writeSetting(PwmSetting.LDAP_PROFILE_LIST, null, new StringArrayValue(Collections.singletonList(LDAP_PROFILE_NAME)), null);
    {
        final String newLdapURI = figureLdapUrlFromFormConfig(formData);
        final StringArrayValue newValue = new StringArrayValue(Collections.singletonList(newLdapURI));
        storedConfiguration.writeSetting(PwmSetting.LDAP_SERVER_URLS, LDAP_PROFILE_NAME, newValue, null);
    }
    if (configGuideBean.isUseConfiguredCerts()) {
        final StoredValue newStoredValue = new X509CertificateValue(configGuideBean.getLdapCertificates());
        storedConfiguration.writeSetting(PwmSetting.LDAP_SERVER_CERTS, LDAP_PROFILE_NAME, newStoredValue, null);
    }
    {
        // proxy/admin account
        final String ldapAdminDN = formData.get(ConfigGuideFormField.PARAM_LDAP_PROXY_DN);
        final String ldapAdminPW = formData.get(ConfigGuideFormField.PARAM_LDAP_PROXY_PW);
        storedConfiguration.writeSetting(PwmSetting.LDAP_PROXY_USER_DN, LDAP_PROFILE_NAME, new StringValue(ldapAdminDN), null);
        final PasswordValue passwordValue = new PasswordValue(PasswordData.forStringValue(ldapAdminPW));
        storedConfiguration.writeSetting(PwmSetting.LDAP_PROXY_USER_PASSWORD, LDAP_PROFILE_NAME, passwordValue, null);
    }
    storedConfiguration.writeSetting(PwmSetting.LDAP_CONTEXTLESS_ROOT, LDAP_PROFILE_NAME, new StringArrayValue(Collections.singletonList(formData.get(ConfigGuideFormField.PARAM_LDAP_CONTEXT))), null);
    {
        final String ldapContext = formData.get(ConfigGuideFormField.PARAM_LDAP_CONTEXT);
        storedConfiguration.writeSetting(PwmSetting.LDAP_CONTEXTLESS_ROOT, LDAP_PROFILE_NAME, new StringArrayValue(Collections.singletonList(ldapContext)), null);
    }
    {
        final boolean testuserEnabled = Boolean.parseBoolean(formData.get(ConfigGuideFormField.PARAM_LDAP_TEST_USER_ENABLED));
        if (testuserEnabled) {
            final String ldapTestUserDN = formData.get(ConfigGuideFormField.PARAM_LDAP_TEST_USER);
            storedConfiguration.writeSetting(PwmSetting.LDAP_TEST_USER_DN, LDAP_PROFILE_NAME, new StringValue(ldapTestUserDN), null);
        } else {
            storedConfiguration.resetSetting(PwmSetting.LDAP_TEST_USER_DN, LDAP_PROFILE_NAME, null);
        }
    }
    {
        // set admin query
        final String groupDN = formData.get(ConfigGuideFormField.PARAM_LDAP_ADMIN_GROUP);
        final List<UserPermission> userPermissions = Collections.singletonList(new UserPermission(UserPermission.Type.ldapGroup, null, null, groupDN));
        storedConfiguration.writeSetting(PwmSetting.QUERY_MATCH_PWM_ADMIN, new UserPermissionValue(userPermissions), null);
    }
    {
        // database
        final String dbClass = formData.get(ConfigGuideFormField.PARAM_DB_CLASSNAME);
        storedConfiguration.writeSetting(PwmSetting.DATABASE_CLASS, null, new StringValue(dbClass), null);
        final String dbUrl = formData.get(ConfigGuideFormField.PARAM_DB_CONNECT_URL);
        storedConfiguration.writeSetting(PwmSetting.DATABASE_URL, null, new StringValue(dbUrl), null);
        final String dbUser = formData.get(ConfigGuideFormField.PARAM_DB_USERNAME);
        storedConfiguration.writeSetting(PwmSetting.DATABASE_USERNAME, null, new StringValue(dbUser), null);
        final String dbPassword = formData.get(ConfigGuideFormField.PARAM_DB_PASSWORD);
        final PasswordValue passwordValue = new PasswordValue(PasswordData.forStringValue(dbPassword));
        storedConfiguration.writeSetting(PwmSetting.DATABASE_PASSWORD, null, passwordValue, null);
        final FileValue jdbcDriver = configGuideBean.getDatabaseDriver();
        if (jdbcDriver != null) {
            storedConfiguration.writeSetting(PwmSetting.DATABASE_JDBC_DRIVER, null, jdbcDriver, null);
        }
    }
    {
        // telemetry
        final boolean telemetryEnabled = Boolean.parseBoolean(formData.get(ConfigGuideFormField.PARAM_TELEMETRY_ENABLE));
        storedConfiguration.writeSetting(PwmSetting.PUBLISH_STATS_ENABLE, null, new BooleanValue(telemetryEnabled), null);
        final String siteDescription = formData.get(ConfigGuideFormField.PARAM_TELEMETRY_DESCRIPTION);
        storedConfiguration.writeSetting(PwmSetting.PUBLISH_STATS_SITE_DESCRIPTION, null, new StringValue(siteDescription), null);
    }
    // cr policy
    if (formData.containsKey(ConfigGuideFormField.CHALLENGE_RESPONSE_DATA)) {
        final String stringValue = formData.get(ConfigGuideFormField.CHALLENGE_RESPONSE_DATA);
        final StoredValue challengeValue = ChallengeValue.factory().fromJson(stringValue);
        storedConfiguration.writeSetting(PwmSetting.CHALLENGE_RANDOM_CHALLENGES, "default", challengeValue, null);
    }
    // set site url
    storedConfiguration.writeSetting(PwmSetting.PWM_SITE_URL, new StringValue(formData.get(ConfigGuideFormField.PARAM_APP_SITEURL)), null);
    // enable debug mode
    storedConfiguration.writeSetting(PwmSetting.DISPLAY_SHOW_DETAILED_ERRORS, null, new BooleanValue(true), null);
    return storedConfiguration;
}

Example 3 with FileValue

use of password.pwm.config.value.FileValue in project pwm by pwm-project.

the class ConfigEditorServlet method restReadSetting.

@ActionHandler(action = "readSetting")
private ProcessStatus restReadSetting(final PwmRequest pwmRequest) throws IOException, PwmUnrecoverableException {
    final ConfigManagerBean configManagerBean = getBean(pwmRequest);
    final StoredConfigurationImpl storedConfig = configManagerBean.getStoredConfiguration();
    final String key = pwmRequest.readParameterAsString("key");
    final Object returnValue;
    final LinkedHashMap<String, Object> returnMap = new LinkedHashMap<>();
    final PwmSetting theSetting = PwmSetting.forKey(key);
    if (key.startsWith("localeBundle")) {
        final StringTokenizer st = new StringTokenizer(key, "-");
        st.nextToken();
        final PwmLocaleBundle bundleName = PwmLocaleBundle.valueOf(st.nextToken());
        final String keyName = st.nextToken();
        final Map<String, String> bundleMap = storedConfig.readLocaleBundleMap(bundleName.getTheClass().getName(), keyName);
        if (bundleMap == null || bundleMap.isEmpty()) {
            final Map<String, String> defaultValueMap = new LinkedHashMap<>();
            final String defaultLocaleValue = ResourceBundle.getBundle(bundleName.getTheClass().getName(), PwmConstants.DEFAULT_LOCALE).getString(keyName);
            for (final Locale locale : pwmRequest.getConfig().getKnownLocales()) {
                final ResourceBundle localeBundle = ResourceBundle.getBundle(bundleName.getTheClass().getName(), locale);
                if (locale.toString().equalsIgnoreCase(PwmConstants.DEFAULT_LOCALE.toString())) {
                    defaultValueMap.put("", defaultLocaleValue);
                } else {
                    final String valueStr = localeBundle.getString(keyName);
                    if (!defaultLocaleValue.equals(valueStr)) {
                        final String localeStr = locale.toString();
                        defaultValueMap.put(localeStr, localeBundle.getString(keyName));
                    }
                }
            }
            returnValue = defaultValueMap;
            returnMap.put("isDefault", true);
        } else {
            returnValue = bundleMap;
            returnMap.put("isDefault", false);
        }
        returnMap.put("key", key);
    } else if (theSetting == null) {
        final String errorStr = "readSettingAsString request for unknown key: " + key;
        LOGGER.warn(errorStr);
        pwmRequest.outputJsonResult(RestResultBean.fromError(new ErrorInformation(PwmError.ERROR_UNKNOWN, errorStr)));
        return ProcessStatus.Halt;
    } else {
        final String profile = theSetting.getCategory().hasProfiles() ? pwmRequest.readParameterAsString("profile") : null;
        switch(theSetting.getSyntax()) {
            case PASSWORD:
                returnValue = Collections.singletonMap("isDefault", storedConfig.isDefaultValue(theSetting, profile));
                break;
            case X509CERT:
                returnValue = ((X509CertificateValue) storedConfig.readSetting(theSetting, profile)).toInfoMap(true);
                break;
            case PRIVATE_KEY:
                returnValue = ((PrivateKeyValue) storedConfig.readSetting(theSetting, profile)).toInfoMap(true);
                break;
            case ACTION:
                returnValue = ((ActionValue) storedConfig.readSetting(theSetting, profile)).toInfoMap();
                break;
            case REMOTE_WEB_SERVICE:
                returnValue = ((RemoteWebServiceValue) storedConfig.readSetting(theSetting, profile)).toInfoMap();
                break;
            case FILE:
                returnValue = ((FileValue) storedConfig.readSetting(theSetting, profile)).toInfoMap();
                break;
            default:
                returnValue = storedConfig.readSetting(theSetting, profile).toNativeObject();
        }
        returnMap.put("isDefault", storedConfig.isDefaultValue(theSetting, profile));
        if (theSetting.getSyntax() == PwmSettingSyntax.SELECT) {
            returnMap.put("options", theSetting.getOptions());
        }
        {
            final ValueMetaData settingMetaData = storedConfig.readSettingMetadata(theSetting, profile);
            if (settingMetaData != null) {
                if (settingMetaData.getModifyDate() != null) {
                    returnMap.put("modifyTime", settingMetaData.getModifyDate());
                }
                if (settingMetaData.getUserIdentity() != null) {
                    returnMap.put("modifyUser", settingMetaData.getUserIdentity());
                }
            }
        }
        returnMap.put("key", key);
        returnMap.put("category", theSetting.getCategory().toString());
        returnMap.put("syntax", theSetting.getSyntax().toString());
    }
    returnMap.put("value", returnValue);
    pwmRequest.outputJsonResult(RestResultBean.withData(returnMap));
    return ProcessStatus.Halt;
}

Example 4 with FileValue

use of password.pwm.config.value.FileValue in project pwm by pwm-project.

the class ConfigEditorServletUtils method readFileUploadToSettingValue.

public static FileValue readFileUploadToSettingValue(final PwmRequest pwmRequest, final int maxFileSize) throws PwmUnrecoverableException, IOException, ServletException {
    final Map<String, PwmRequest.FileUploadItem> fileUploads;
    try {
        fileUploads = pwmRequest.readFileUploads(maxFileSize, 1);
    } catch (PwmException e) {
        pwmRequest.outputJsonResult(RestResultBean.fromError(e.getErrorInformation(), pwmRequest));
        LOGGER.error(pwmRequest, "error during file upload: " + e.getErrorInformation().toDebugStr());
        return null;
    } catch (Throwable e) {
        final ErrorInformation errorInformation = new ErrorInformation(PwmError.ERROR_UNKNOWN, "error during file upload: " + e.getMessage());
        pwmRequest.outputJsonResult(RestResultBean.fromError(errorInformation, pwmRequest));
        LOGGER.error(pwmRequest, errorInformation);
        return null;
    }
    if (fileUploads.containsKey(PwmConstants.PARAM_FILE_UPLOAD)) {
        final PwmRequest.FileUploadItem uploadItem = fileUploads.get(PwmConstants.PARAM_FILE_UPLOAD);
        final Map<FileValue.FileInformation, FileValue.FileContent> newFileValueMap = new LinkedHashMap<>();
        newFileValueMap.put(new FileValue.FileInformation(uploadItem.getName(), uploadItem.getType()), new FileValue.FileContent(uploadItem.getContent()));
        return new FileValue(newFileValueMap);
    }
    final ErrorInformation errorInformation = new ErrorInformation(PwmError.ERROR_UNKNOWN, "no file found in upload");
    pwmRequest.outputJsonResult(RestResultBean.fromError(errorInformation, pwmRequest));
    LOGGER.error(pwmRequest, "error during file upload: " + errorInformation.toDebugStr());
    return null;
}

Example 5 with FileValue

use of password.pwm.config.value.FileValue in project pwm by pwm-project.

the class ConfigEditorServlet method doUploadFile.

@ActionHandler(action = "uploadFile")
private ProcessStatus doUploadFile(final PwmRequest pwmRequest) throws PwmUnrecoverableException, IOException, ServletException {
    final ConfigManagerBean configManagerBean = getBean(pwmRequest);
    final String key = pwmRequest.readParameterAsString("key");
    final PwmSetting setting = PwmSetting.forKey(key);
    final int maxFileSize = Integer.parseInt(pwmRequest.getConfig().readAppProperty(AppProperty.CONFIG_MAX_JDBC_JAR_SIZE));
    if (setting == PwmSetting.HTTPS_CERT) {
        try {
            final PasswordData passwordData = pwmRequest.readParameterAsPassword("password");
            final String alias = pwmRequest.readParameterAsString("alias");
            final HttpsServerCertificateManager.KeyStoreFormat keyStoreFormat;
            try {
                keyStoreFormat = HttpsServerCertificateManager.KeyStoreFormat.valueOf(pwmRequest.readParameterAsString("format"));
            } catch (IllegalArgumentException e) {
                throw new PwmUnrecoverableException(new ErrorInformation(PwmError.ERROR_MISSING_PARAMETER, "unknown format type: " + e.getMessage(), new String[] { "format" }));
            }
            final Map<String, PwmRequest.FileUploadItem> fileUploads = pwmRequest.readFileUploads(maxFileSize, 1);
            final ByteArrayInputStream fileIs = new ByteArrayInputStream(fileUploads.get(PwmConstants.PARAM_FILE_UPLOAD).getContent().getBytes());
            HttpsServerCertificateManager.importKey(configManagerBean.getStoredConfiguration(), keyStoreFormat, fileIs, passwordData, alias);
            pwmRequest.outputJsonResult(RestResultBean.forSuccessMessage(pwmRequest, Message.Success_Unknown));
            return ProcessStatus.Halt;
        } catch (PwmException e) {
            LOGGER.error(pwmRequest, "error during https certificate upload: " + e.getMessage());
            pwmRequest.respondWithError(e.getErrorInformation(), false);
            return ProcessStatus.Halt;
        }
    }
    final FileValue fileValue = ConfigEditorServletUtils.readFileUploadToSettingValue(pwmRequest, maxFileSize);
    if (fileValue != null) {
        final UserIdentity userIdentity = pwmRequest.isAuthenticated() ? pwmRequest.getPwmSession().getUserInfo().getUserIdentity() : null;
        configManagerBean.getStoredConfiguration().writeSetting(setting, fileValue, userIdentity);
        pwmRequest.outputJsonResult(RestResultBean.forSuccessMessage(pwmRequest, Message.Success_Unknown));
    }
    return ProcessStatus.Halt;
}