SSM implementiert die Chiffretext-Anmeldefunktion für das Kennwort des MySQL-Datenbankkontos

Paket com.hzdy.DCAD.common.util;
importiere sun.misc.BASE64Decoder;
importiere sun.misc.BASE64Encoder;
importiere javax.crypto.Cipher;
importiere javax.crypto.KeyGenerator;
importiere java.security.Key;
importiere java.security.SecureRandom;
/**
 * Erstellt von Wongy am 08.08.2019.
 */
öffentliche Klasse DESUtil {
  privater statischer Schlüssel;
  //Eigener Schlüsselprivate static String KEY_STR = "mykey";
  statisch {
    versuchen {
      KeyGenerator-Generator = KeyGenerator.getInstance("DES");
      SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
      secureRandom.setSeed(KEY_STR.getBytes());
      generator.init(sichererRandom);
      Schlüssel = Generator.GenerateKey();
      Generator = null;
    } Fang (Ausnahme e) {
      neue RuntimeException(e) auslösen;
    }
  }
  /**
   * Verschlüsseln Sie die Zeichenfolge und geben Sie die mit BASE64 verschlüsselte Zeichenfolge zurück*
   * @param str
   * @zurückkehren
   * @see [Klasse, Klassen#Methode, Klassen#Mitglied]
   */
  öffentliche statische Zeichenfolge getEncryptString(String str) {
    BASE64Encoder base64Encoder = neuer BASE64Encoder();
    versuchen {
      byte[] strBytes = str.getBytes("UTF-8");
      Chiffre cipher = Cipher.getInstance("DES");
      cipher.init(Cipher.ENCRYPT_MODE, Schlüssel);
      byte[] encryptStrBytes = cipher.doFinal(strBytes);
      gibt base64Encoder.encode(encryptStrBytes) zurück;
    } Fang (Ausnahme e) {
      neue RuntimeException(e) auslösen;
    }
  }
  /**
   * Entschlüsseln Sie die mit BASE64 verschlüsselte Zeichenfolge *
   */
  öffentliche statische Zeichenfolge getDecryptString(String str) {
    BASE64Decoder base64Decoder = neuer BASE64Decoder();
    versuchen {
      byte[] strBytes = base64Decoder.decodeBuffer(str);
      Chiffre cipher = Cipher.getInstance("DES");
      cipher.init(Cipher.DECRYPT_MODE, Schlüssel);
      byte[] encryptStrBytes = cipher.doFinal(strBytes);
      gib einen neuen String zurück (encryptStrBytes, "UTF-8");
    } Fang (Ausnahme e) {
      neue RuntimeException(e) auslösen;
    }
  }
  öffentliche statische void main(String[] args) {
    Zeichenfolgenname = "dbuser";
    Zeichenfolge „Passwort“ = „waction2016“;
    String-Verschlüsselungsname = getEncryptString(Name);
    String encrypassword = getEncryptString(Passwort);
    System.out.println("Verschlüsselungsname : " + Verschlüsselungsname);
    System.out.println("Verschlüsselungskennwort: " + Verschlüsselungskennwort);
    System.out.println("name : " + getDecryptString(verschlüsselungsname));
    System.out.println("Passwort: " + getDecryptString(encrypassword));
  }
}

Paket com.hzdy.DCAD.common.util;
importiere org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
öffentliche Klasse EncryptPropertyPlaceholderConfigurer erweitert PropertyPlaceholderConfigurer {
  //Die Eigenschaft muss mit dem SCHLÜSSEL der Konfigurationsdatei übereinstimmen private String[] encryptPropNames = {"jdbc.username", "jdbc.password"};
  @Überschreiben
  geschützte String-Konvertierungseigenschaft(String-Eigenschaftsname, String-Eigenschaftswert) {
    //Wenn die Eigenschaft in der Liste der verschlüsselten Eigenschaften gefunden wird if (isEncryptProp(propertyName)) {
      Zeichenfolge decryptValue = DESUtil.getDecryptString(Eigenschaftswert);
      System.out.println(entschlüsselnWert);
      gib den Entschlüsselungswert zurück;
    } anders {
      Eigenschaftswert zurückgeben;
    }
  }
  private boolean isEncryptProp(String Eigenschaftsname) {
    für (String encryptName : encryptPropNames) {
      wenn (Verschlüsselungsname.equals(Eigenschaftsname)) {
        gibt true zurück;
      }
    }
    gibt false zurück;
  }
}

#Vor dem Verschlüsseln der Konfiguration#jdbc.driver=com.mysql.jdbc.Driver
#jdbc.Benutzer=root
#jdbc.password=root
#jdbc.url=jdbc:mysql://localhost:3306/bookstore
#Nach der Verschlüsselungskonfiguration jdbc.driver=com.mysql.jdbc.Driver
jdbc.Benutzer=Ov4j7fKiCzY=
jdbc.password=Ov4j7fKiCzY=
jdbc.url=jdbc:mysql://localhost:3306/bookstore

Ändern Sie <context:property-placeholder location="classpath:.properties" /> im Spring-Kontext
 Ändern Sie in <bean class="com.hzdy.DCAD.common.util.EncryptPropertyPlaceholderConfigurer"p:locations="classpath:*.properties"/>
 //Beachten Sie, dass es nur eine Bean geben kann, die die Konfigurationsdatei liest, sonst liest das System nur die erste

Paket com.thinkgem.jeesite.common.encrypt;
importiere java.sql.Connection;
importiere java.sql.SQLException;
importiere java.util.Properties;
importiere javax.security.auth.callback.PasswordCallback;
importiere com.alibaba.druid.util.DruidPasswordCallback;
/**
 */
@SuppressWarnings("Seriennummer")
öffentliche Klasse DruidDataSource erweitert com.alibaba.druid.pool.DruidDataSource {
  öffentliche PhysicalConnectionInfo createPhysicalConnection() wirft SQLException {
    Zeichenfolge-URL = this.getUrl();
    Eigenschaften connectProperties = getConnectProperties();
    String-Benutzer;
    if (getUserCallback() != null) {
      Benutzer = getUserCallback().getName();
    } anders {
      Benutzer = getUsername();
    }
    //DES-Entschlüsselung user = DESUtils.getDecryptString(user);
    String-Passwort = DESUtils.getDecryptString(getPassword());
    Passwortrückruf Passwortrückruf = getPasswordCallback();
    if (passwordCallback != null) {
      if (passwordCallback-Instanz von DruidPasswordCallback) {
        DruidPasswordCallback druidPasswordCallback = (DruidPasswordCallback) PasswortCallback;
        druidPasswordCallback.setUrl(url);
        druidPasswordCallback.setProperties(connectProperties);
      }
      char[] chars = passwordCallback.getPassword();
      wenn (Zeichen != null) {
        Passwort = neuer String (Zeichen);
      }
    }
    Eigenschaften physicalConnectProperties = neue Eigenschaften();
    if (connectProperties != null) {
      physicalConnectProperties.putAll(connectProperties);
    }
    if (Benutzer != null && Benutzer.Länge() != 0) {
      physicalConnectProperties.put("Benutzer", Benutzer);
    }
    if (password != null && password.length() != 0) {
      physicalConnectProperties.put("Passwort", Passwort);
    }
    Anschlussanschl.;
    lange connectStartNanos = System.nanoTime();
    lange verbundene Nanos, initiierte Nanos, validierte Nanos;
    versuchen {
      conn = erstellePhysicalConnection(url, physicalConnectProperties);
      connectedNanos = System.nanoTime();
      wenn (conn == null) {
        throw new SQLException("Verbindungsfehler, URL " + URL + ", Treiberklasse " + diese.Treiberklasse);
      }
      initPhysicalConnection(conn);
      initedNanos = System.nanoTime();
      validiereVerbindung(conn);
      validiertNanos = System.nanoTime();
      setCreateError(null);
    } abfangen (SQLException-Beispiel) {
      setCreateError(Beispiel);
      werfen ex;
    } Fang (RuntimeException ex) {
      setCreateError(Beispiel);
      werfen ex;
    } catch (Fehler ex) {
      ErstelleErrorCount.incrementAndGet();
      werfen ex;
    Endlich
      langer Nano = System.nanoTime() - connectStartNanos;
      erstelleTimespan += nano;
    }
    gibt neue PhysicalConnectionInfo zurück (conn, connectStartNanos, connectedNanos, initedNanos, validatedNanos);
  }
}

#Vor der Änderung<!-- <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"> -->
#Nach der Änderung <bean id="dataSource"class="com.thinkgem.jeesite.common.encrypt.DruidDataSource" 
    init-method="init" destroy-method="schließen">
    <!-- Die Treiberklasse der Datenquelle kann weggelassen werden. Druid erkennt die Treiberklasse standardmäßig automatisch anhand der URL -->
    <Eigenschaftsname="TreiberKlassenname" Wert="${jdbc.driver}" />
    <!-- Basisattribute URL, Benutzer, Passwort -->
    <Eigenschaftsname="URL" Wert="${jdbc.url}" />
    <property name="Benutzername" value="${jdbc.username}" />
    <Eigenschaftsname="Passwort" Wert="${jdbc.password}" />

  </bean>