defaultuserdatabase.java

这是linux下ssl vpn的实现程序

        ps.startTransaction();
        try {
            try {
                ps.setString(1, principalName);
                ps.execute();
            } finally {
                ps.releasePreparedStatement();
            }
            JDBCPreparedStatement ps2 = attributesDb.getStatement(ps, "updateAttributes.insert");
            for (Iterator i = attributes.keySet().iterator(); i.hasNext();) {
                ps2.reset();
                String key = (String) i.next();
                ps2.setString(1, principalName);
                ps2.setString(2, key);
                UserAttributeDefinition def = getUserAttributeDefinition(key);
                if(def != null && def.getVisibility() == UserAttributeDefinition.USER_CONFIDENTIAL_ATTRIBUTE) {
                    ps2.setString(3, PublicKeyStore.getInstance().encryptText(attributes.getProperty(key), principalName));
                }
                else {
                    ps2.setString(3, attributes.getProperty(key));
                }
                try {
                    ps2.execute();
                } finally {
                    ps2.releasePreparedStatement();
                }
            }
            ps.commit();
        } catch (Exception e) {
            ps.rollback();
            throw e;
        } finally {
            ps.endTransaction();
        }
    }

    /* (non-Javadoc)
     * @see com.sslexplorer.security.UserDatabase#updateAttribute(java.lang.String, java.lang.String, java.lang.String)
     */
    public void updateAttribute(String principalName, String key, String value) throws  Exception{
        // Delete the entry if there is 1.
        JDBCPreparedStatement ps = attributesDb.getStatement("updateAttribute.delete");
        try {
            ps.setString(1, principalName);
            ps.setString(2, key);
            ps.execute();
        } 
        finally {
            ps.releasePreparedStatement();
        }
        // now re-insert the attribute.
        JDBCPreparedStatement ps2 = attributesDb.getStatement(ps, "updateAttributes.insert");
        try {
            ps2.setString(1, principalName);
            ps2.setString(2, key);
            UserAttributeDefinition def = getUserAttributeDefinition(key);
            if(def != null && def.getVisibility() == UserAttributeDefinition.USER_CONFIDENTIAL_ATTRIBUTE) {
                ps2.setString(3, PublicKeyStore.getInstance().encryptText(value, principalName));
            }
            else {
                ps2.setString(3, value);
            }
            ps2.execute();
        } finally {
            ps2.releasePreparedStatement();
        }
    }

    /* (non-Javadoc)
     * @see com.sslexplorer.security.UserDatabase#loadAttributes(com.sslexplorer.security.User)
     */
    public void loadAttributes(User user) throws Exception {
        JDBCPreparedStatement ps = attributesDb.getStatement("getAttributes.select");
        try {
            ps.setString(1, user.getPrincipalName());
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                String name = rs.getString("attribute_name"); 
                UserAttributeDefinition def = getUserAttributeDefinition(name);
                if(def != null && def.getVisibility() == UserAttributeDefinition.USER_CONFIDENTIAL_ATTRIBUTE) {
                    /* We can only get confidential attributes after the users 
                     * private key has been verified. This may not have happened
                     * when a users attributes are first loaded so we must
                     * skip such attributes.
                     * 
                     * It is up to the LogonController to reload the attributes
                     * once the certificate is available
                     */
                    if(PublicKeyStore.getInstance().hasLoadedKey(user.getPrincipalName())) {
                        try {
                            user.getAttributes().put(name, PublicKeyStore.getInstance().decryptText(rs.getString("attribute_value"), user.getPrincipalName()));
                        }
                        catch(Throwable t) {
                            log.warn("Failed to decrypt confidential user attributre, probably corrup.", t);
                        }
                    }
                }
                else {
                    user.getAttributes().put(name, rs.getString("attribute_value"));
                }
            }
        } finally {
            ps.releasePreparedStatement();
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.UserDatabase#createUserAttributeDefinition(com.sslexplorer.security.UserAttributeDefinition)
     */
    public void createUserAttributeDefinition(UserAttributeDefinition definition) throws Exception {
        if (definition.isSystem()) {
            throw new Exception("System user attribute definitions may not be created.");
        }
        JDBCPreparedStatement ps = attributesDb.getStatement("createUserAttributeDefinitions.create");
        try {
            userAttributeDefinitions.put(definition.getName(), definition);
            ps.setString(1, definition.getName());
            ps.setInt(2, definition.getVisibility());
            ps.setInt(3, definition.getType());
            ps.setInt(4, definition.getSortOrder());
            ps.setString(5, definition.getLabel());
            ps.setString(6, definition.getDescription());
            ps.setString(7, definition.getTypeMeta());
            ps.setInt(8, definition.getCategory());
            ps.setString(9, definition.getCategoryLabel());
            ps.setString(10, definition.getDefaultValue());
            ps.setInt(11, definition.isHidden() ? 1 : 0);
            ps.execute();
        } finally {
            ps.releasePreparedStatement();
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.UserDatabase#deleteUserAttributeDefinition(java.lang.String)
     */
    public void deleteUserAttributeDefinition(String definitionName) throws Exception {
        UserAttributeDefinition def = getUserAttributeDefinition(definitionName);
        if (def == null) {
            throw new Exception("Definition with name " + definitionName + " cannot be deleted as it does not exist.");
        }
        if (def.isSystem()) {
            throw new Exception("Definition with name " + definitionName + " cannot be deleted as it is a system definition.");
        }
        JDBCPreparedStatement ps = attributesDb.getStatement("deleteUserAttributeDefinitions.delete");
        try {
            userAttributeDefinitions.remove(definitionName);
            ps.setString(1, definitionName);
            ps.execute();
        } finally {
            ps.releasePreparedStatement();
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.UserDatabase#getUserAttributeDefinitions()
     */
    public List getUserAttributeDefinitions() throws Exception {
        List v = new ArrayList();
        for (Iterator i = userAttributeDefinitions.entrySet().iterator(); i.hasNext();) {
            v.add((UserAttributeDefinition) ((Map.Entry) i.next()).getValue());
        }
        Collections.sort(v, new DefinitionComparator());
        return v;
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.UserDatabase#getUserAttributeDefinition(java.lang.String)
     */
    public UserAttributeDefinition getUserAttributeDefinition(String name) throws Exception {
        return (UserAttributeDefinition) userAttributeDefinitions.get(name);
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.UserDatabase#updateUserAttributeDefinition(com.sslexplorer.security.UserAttributeDefinition)
     */
    public void updateUserAttributeDefinition(UserAttributeDefinition definition) throws Exception {
        if (definition.isSystem()) {
            throw new Exception("System user attribute definitions may not be updated.");
        }
        JDBCPreparedStatement ps = attributesDb.getStatement("updateUserAttributeDefinitions.update");
        try {
            userAttributeDefinitions.put(definition.getName(), definition);
            ps.setInt(1, definition.getVisibility());
            ps.setInt(2, definition.getType());
            ps.setInt(3, definition.getSortOrder());
            ps.setString(4, definition.getLabel());
            ps.setString(5, definition.getDescription());
            ps.setString(6, definition.getTypeMeta());
            ps.setInt(7, definition.getCategory());
            ps.setString(8, definition.getCategoryLabel());
            ps.setString(9, definition.getDefaultValue());
            ps.setInt(10, definition.isHidden() ? 1 : 0);
            ps.setString(11, definition.getName());
            ps.execute();
        } finally {
            ps.releasePreparedStatement();
        }

    }

    void loadUserAttributeDefinitions() throws Exception {
        userAttributeDefinitions = new HashMap();
        JDBCPreparedStatement ps = attributesDb.getStatement("loadUserAttributeDefinitions.select");
        ResultSet rs = ps.executeQuery();
        try {
            while (rs.next()) {
                UserAttributeDefinition def = new UserAttributeDefinition(rs.getInt("type"), rs.getString("name"), rs
                                .getString("type_meta"), rs.getInt("category"), rs.getString("category_label"), rs
                                .getString("default_value"), rs.getInt("visibility"), rs.getInt("sort_order"),
                                rs.getInt("hidden") == 1, rs.getString("text_label"), rs.getString("text_description"), false);
                userAttributeDefinitions.put(def.getName(), def);
            }
        } finally {
            rs.close();
            ps.releasePreparedStatement();
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.UserDatabase#registerUserAttributeDefinition(com.sslexplorer.security.UserAttributeDefinition)
     */
    public void registerUserAttributeDefinition(UserAttributeDefinition definition) throws Exception {
        if (userAttributeDefinitions.containsKey(definition.getName())) {
            throw new Exception("User attribute definition with name " + definition.getName()
                            + " has already been registered or created.");
        }
        if (!definition.isSystem()) {
            throw new Exception("Only system user attribute definitions may be registered.");
        }
        userAttributeDefinitions.put(definition.getName(), definition);

    }

    /*
     * (non-Javadoc)
     * 
     * @see com.sslexplorer.security.UserDatabase#deregisterUserAttributeDefinition(java.lang.String)
     */
    public void deregisterUserAttributeDefinition(String definitionName) throws Exception {
        UserAttributeDefinition def = getUserAttributeDefinition(definitionName);
        if (def == null) {
            throw new Exception("Definition with name " + definitionName + " cannot be deleted as it does not exist.");
        }
        if (!def.isSystem()) {
            throw new Exception("Definition with name " + definitionName
                            + " cannot be de-registered as it is not a system definition.");
        }
        userAttributeDefinitions.remove(definitionName);

    }
}