À l'aide de mot de passe codé pour la source de données utilisée au printemps applicationContext.xml

Je veux garder le mot de passe codé dans mon mentionnés ci-dessous springApplicationContext.xml

Est-il un moyen pour y parvenir?

actuellement j'ai configuré toutes les propriétés à l'aide de la propriété de l'espace réservé
comme indiqué ci-dessous, mais le mot de passe brut est encore ouvert dans ma base de données.propriétés

springApplicationContext.xml

<beans:bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <beans:property name="driverClassName"><beans:value>${db.driverClassName}</beans:value></beans:property>
        <beans:property name="url"><beans:value>${db.url}</beans:value></beans:property>
        <beans:property name="username"><beans:value>${db.username}</beans:value></beans:property>
        <beans:property name="password"><beans:value>${db.password}</beans:value></beans:property>
</beans:bean>

mais les valeurs réelles sont présents dans mon database.properties

db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost/myDB
db.username=root
db.password=root

Je veux quelque chose comme ci-dessous:

springApplicationContext.xml (même que ci-dessus)

<beans:bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <beans:property name="driverClassName"><beans:value>${db.driverClassName}</beans:value></beans:property>
        <beans:property name="url"><beans:value>${db.url}</beans:value></beans:property>
        <beans:property name="username"><beans:value>${db.username}</beans:value></beans:property>
        <beans:property name="password"><beans:value>${db.password}</beans:value></beans:property>
</beans:bean>

Mais le mot de passe de la valeur de la propriété doit être dans encripted format dans mon database.properties

db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost/myDB
db.username=root
db.password=3g6n72ef8x (using any encription method).

et ma source de données interne de décrypter le mot de passe avant de prendre de nouveaux DB connexion.

Très apprécier pour toute aide/suggestion dans ce.

L'approche proposée ci-dessous fonctionne très bien quand vous pouvez prendre une chaîne codée et de décoder directement. Mais pour la vraie cryptage, vous ne pouvez pas prendre une chaîne cryptée et juste décrypter: vous prenez un mot de passe en clair, les chiffrer, et de la comparer à la valeur chiffrée. Par exemple, voir org.springframework.de sécurité.crypto.le mot de passe.StandardPasswordEncoder qui est quelque chose comme ce que vous devriez probablement utiliser une fois que vous déplacez au-delà de l'encoder en base64. La question est donc: comment est-ce que votre source de données obtenir le mot de passe pour vérifier l'encontre de la valeur chiffrée de la db.le mot de passe?
En fait, l'exigence a été de ne pas garder le mot de passe brut ouvrir dans ma base de données.fichier de propriétés. D'où mon CustomDataSource est le décodage de la valeur codée de la base de données.les propriétés de fichier et ensuite l'utiliser pour créer de nouvelles connexions de base de données.
Je dirais qu'un mot de passe crypté en base64 est essentiellement la même que les raw d'un mot de passe (pas sûr), mais je suppose que la sémantique de l'exigence l'exigence de décideurs de décider.

InformationsquelleAutor Sandy | 2012-10-11

19

Sa pourrait être drôle que je réponds à ma propre question. mais je voulais juste dire à ma solution, d'autres personnes qui pourraient avoir face à un même genre de problème..

pour des raisons de simplicité, j'ai utilisé BASE64Encoder & BASE64Decoder. plus tard, je vais modifier mon code pour utiliser un/un meilleur chiffrement/déchiffrement.

J'ai codé mon mot de passe de la base de données(ex: root pour mon cas) en utilisant le code ci-dessous:
```
private String encode(String str) {
        BASE64Encoder encoder = new BASE64Encoder();
        str = new String(encoder.encodeBuffer(str.getBytes()));
        return str;
    }
```
et placé de l'encodage du mot de passe de ma base de données.les propriétés de fichier comme ci-dessous:

avant
```
db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost/myDB
db.username=root
db.password=root
```
après
```
db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost/myDB
db.username=root
db.password=cm9vdA==  (Note: encoded 'root' by using BASE64Encoder)
```
Maintenant, j'ai écrit une classe wrapper pour org.apache.commons.dbcp.BasicDataSource
et remplacé setPassword() méthode:
```
import java.io.IOException;
import org.apache.commons.dbcp.BasicDataSource;
import sun.misc.BASE64Decoder;

public class MyCustomBasicDataSource extends BasicDataSource{

    public CustomBasicDataSource() {
        super();
    }

    public synchronized void setPassword(String encodedPassword){
        this.password = decode(encodedPassword);
    }

    private String decode(String password) {
        BASE64Decoder decoder = new BASE64Decoder();
        String decodedPassword = null;
        try {
            decodedPassword = new String(decoder.decodeBuffer(password));
        } catch (IOException e) {
            e.printStackTrace();
        }       
        return decodedPassword;
    }
}
```
De cette façon, je suis de décodage(BASE64Decoder) de l'encodage du mot de passe fournis dans la base de données.propriétés

et modifie l'attribut de classe de ma source de données bean mentionné dans springApplicationContext.xml fichier.
```
<beans:bean id="dataSource" class="edu.config.db.datasource.custom.MyCustomBasicDataSource" destroy-method="close">
    <beans:property name="driverClassName"><beans:value>${db.driverClassName}</beans:value></beans:property>
    <beans:property name="url"><beans:value>${db.url}</beans:value></beans:property>
    <beans:property name="username"><beans:value>${db.username}</beans:value></beans:property>
    <beans:property name="password"><beans:value>${db.password}</beans:value></beans:property>
```
Grâce.
- N'avez-vous pas besoin de faire de super.mot de passe =decode(encodedPassword); au lieu de cela.mot de passe= decode(encodedPassword);
- Base64 n'est pas le cryptage, c'est l'encodage ! Lors de l'encodage du nom d'utilisateur et le mot de passe avec l'algorithme Base64 généralement les rend illisibles à l'oeil nu, ils sont aussi facilement décodé comme ils sont codés. La sécurité n'est pas le but de l'étape de codage. Plutôt, l'intention de l'encodage est de coder non-HTTP-compatible caractères qui peut être le nom d'utilisateur ou mot de passe dans celles qui sont HTTP-compatible.
- Cette solution permet un codage en base 64 du mot de passe dans votre fichier de propriétés, mais il n'est PAS crypté! J'ai copier collé "cm9vdA==" en base64decode.org et tout de suite eu un "root". Pour le bien des autres la lecture de cette question et la réponse, s'il vous plaît modifier la question à se poser "Comment utiliser la base de 64 codé mot de passe" au lieu de "la Façon d'utiliser le mot de passe crypté" parce que cette réponse n'est certainement pas le chiffrer. Je ne veux pas que d'autres lecteurs à penser que l'encodage est le même que le cryptage.
InformationsquelleAutor Sandy

De créer des PropertyPlaceHolderConfigurer l'extension de Printemps PropertyPlaceHolderConfigurer

public class PropertyPlaceholderConfigurer extends
        org.springframework.beans.factory.config.PropertyPlaceholderConfigurer {

    @Override
    protected String convertPropertyValue(final String originalValue) {
        if (originalValue.startwith("SomeText:")) {
            //Apply the decryption logic
            ...
        }
    }
}

Vous pouvez crypter les propriétés et ajouter SomeText:. Utilisez ce personnalisés PropertyPlaceHolderConfigurer pour charger les propriétés

InformationsquelleAutor Sujith

3

Créer une classe wrapper mise en œuvre de la Datasource interface qui délègue c'est les appels de méthode à la source de données sous-jacente, mais déchiffre le mot de passe avant de le faire.
- Grâce Abhinav pour suggérer que moi.. Maintenant, je suis en mesure de réaliser cela à l'aide d'un CustomBasicDataSource.
InformationsquelleAutor Abhinav Sarkar
3

Je voudrais regarder l'image plus grande ici: pourquoi voulez-vous chiffrer les valeurs dans les propriétés de votre fichier? Quel est votre scénario où des personnes non autorisées aient accès à votre fichier de propriétés?

Une technique habituelle pour traiter ce problème de stockage de la production des informations d'identification est de rendre les informations d'identification d'une partie de votre environnement, par opposition à une partie de votre code source. Voici quelques façons de le faire:
- De placer le fichier de propriétés (avec mots de passe en clair) dans le classpath de du serveur web en production, de cette façon, l'accès à ce mot de passe est contrôlée par l'accès à la machine de production.
- Propriétés de la banque dans web.xml (context-param avec param-name), encore une fois ce fichier fait partie de l'environnement dans lequel vous exécutez votre code et qui n'est pas distribué avec votre code d'accès à ce fichier est contrôlé par l'accès à la machine.
- Utiliser JNDI et configurer la ressource dans votre serveur d'applications.
- J'ai une situation similaire à ci-dessus, et nous voulons que les mots de passe cryptés dans le fichier de propriétés, parce qu'une partie de notre application est installée sur un serveur du client avec une autre application de la nôtre. Cet agent utilise l'autre de l'application de base de données. Nous ne voulons pas que nos clients aient accès à cette application de base de données. Donc, il y a un scénario dans lequel les mots de passe cryptés dans les fichiers de propriétés seraient nécessaires.
- C'est un scénario intéressant que je n'avais pas envisagé, merci.
- - Il encore ne donne que l'apparence et l'affinité de la sécurité, puisque n'importe quel mot de passe crypté peut être déchiffré éventuellement par un tiers. Mais il va arrêter la fête décontractée, il est probablement assez bon.
- Il y a un autre scénario à considérer, qui est l'endroit où l'application est autonome. J'ai l'habitude de travailler dans une entreprise qui avait un logiciel avec exactement la même situation, comme expliqué ci-dessus, mais c'était une application autonome =)
InformationsquelleAutor Jay
0

Si vous utilisez tomcat pool de connexion en tant que source de données, voici une mise en œuvre

http://www.jdev.it/encrypting-passwords-in-tomcat/

Créer une classe qui étend org.apache.tomcat.jdbc.piscine.DataSourceFactory et le configurer dans le server.xml

InformationsquelleAutor Sujith Nair

Vous devez vous connecter pour publier un commentaire.