DevShivmohan
commented
4 months ago Configure beans of client side
package com.xcelore.common.beans;
import com.xcelore.archives.mapper.ArchiveMapper; import com.xcelore.central.properties.CentralServerProperties; import com.xcelore.common.mapper.GlobalSettingMapper; import com.xcelore.common.properties.DataSourceProperties; import com.xcelore.landing.mapper.LandingMapper; import com.xcelore.metar.mapper.MetarMapper; import com.xcelore.metar.utils.MetarUtils; import com.xcelore.synop.mapper.SynopMapper; import com.xcelore.taf.mapper.TafMapper; import com.xcelore.user.mappers.UserDetailMapper; import com.xcelore.warnings.mapper.WarningMapper; import com.xcelore.weather.entity.Derived; import com.xcelore.weather.mapper.DerivedMapper; import com.xcelore.weather.mapper.WeatherMapper; import com.xcelore.weather.model.kafka.WeatherData; import com.xcelore.weather.util.StatisticalUtils; import io.netty.handler.ssl.SslContextBuilder; import org.apache.hc.client5.http.impl.classic.CloseableHttpClient; import org.apache.hc.client5.http.impl.classic.HttpClients; import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder; import org.apache.hc.client5.http.io.HttpClientConnectionManager; import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory; import org.apache.hc.core5.ssl.SSLContextBuilder; import org.jasypt.encryption.StringEncryptor; import org.jasypt.encryption.pbe.StandardPBEStringEncryptor; import org.mapstruct.factory.Mappers; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.boot.jdbc.DataSourceBuilder; import org.springframework.boot.web.client.RestTemplateBuilder; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; import org.springframework.core.io.ClassPathResource; import org.springframework.http.client.HttpComponentsClientHttpRequestFactory; import org.springframework.stereotype.Component; import org.springframework.web.client.RestTemplate; import reactor.netty.http.client.HttpClient;
import javax.crypto.Cipher; import javax.crypto.NoSuchPaddingException; import javax.crypto.spec.SecretKeySpec; import javax.net.ssl.KeyManagerFactory; import javax.net.ssl.SSLContext; import javax.net.ssl.TrustManagerFactory; import javax.sql.DataSource; import java.io.IOException; import java.io.InputStream; import java.nio.charset.StandardCharsets; import java.security.InvalidKeyException; import java.security.KeyStore; import java.security.KeyStoreException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.security.UnrecoverableKeyException; import java.security.cert.CertificateException; import java.util.Arrays; import java.util.Base64; import java.util.List; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap;
@Configuration @EnableConfigurationProperties({DataSourceProperties.class, CentralServerProperties.class}) @Component public class Beans { private final DataSourceProperties dataSourceProperties; private final CentralServerProperties centralServerProperties;
@Value("${xcelore.airbase.software.crypto-secret}")
private String cryptoSecretKey;
public Beans(DataSourceProperties dataSourceProperties, CentralServerProperties centralServerProperties) {
this.dataSourceProperties = dataSourceProperties;
this.centralServerProperties = centralServerProperties;
}
/**
* one siteId has one weather data
*
* @return
*/
@Bean
public ConcurrentMap<Integer, WeatherData> concurrentSingleWeatherDataMap() {
return new ConcurrentHashMap<>();
}
/**
* one siteId has last three weather data
*
* @return
*/
@Bean
public ConcurrentMap<Integer, List<WeatherData>> concurrentLastThreeWeatherDataMap() {
return new ConcurrentHashMap<>();
}
/**
* All beans related to scheduler data
* @return
*/
@Bean
public SchedulerDataBean schedulerDataBean(){
return new SchedulerDataBean();
}
@Bean
public MetarMapper metarMapper() {
return Mappers.getMapper(MetarMapper.class);
}
@Bean
public SynopMapper synopMapper(){
return Mappers.getMapper(SynopMapper.class);
}
@Bean
public LandingMapper landingMapper(){ return Mappers.getMapper(LandingMapper.class);}
@Bean
public WarningMapper warningMapper(){return Mappers.getMapper(WarningMapper.class);}
@Bean
public TafMapper tafMapper() {return Mappers.getMapper(TafMapper.class);}
@Bean
public MetarUtils metarUtils(){ return new MetarUtils();
}
@Bean
public WeatherMapper weatherMapper(){
return Mappers.getMapper(WeatherMapper.class);
}
@Bean
public DerivedMapper derivedMapper() {
return Mappers.getMapper(DerivedMapper.class);
}
@Bean
public StatisticalUtils statisticalUtils() {
return new StatisticalUtils();
}
@Bean
public StringEncryptor stringEncryptor() {
StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor();
encryptor.setAlgorithm("PBEWithMD5AndDES");
encryptor.setPassword("Xcelore.Airbase.SGS100@980$#&546312"); // same key used to encrypt
return encryptor;
}
@Bean
@Primary
public DataSource dataSource() {
return DataSourceBuilder.create()
.url(dataSourceProperties.getUrl())
.username(dataSourceProperties.getUsername())
.password(new String(Base64.getDecoder().decode(dataSourceProperties.getPassword())))
.build();
}
@Bean
public Cipher cipher() throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException {
byte[] key = new String(Base64.getDecoder().decode(cryptoSecretKey)).getBytes(StandardCharsets.UTF_8);
final var sha = MessageDigest.getInstance("SHA-1");
key = sha.digest(key);
key = Arrays.copyOf(key, 16);
final var secretKey = new SecretKeySpec(key, "AES");
final var cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
return cipher;
}
@Bean
public ArchiveMapper archiveMapper() {
return Mappers.getMapper(ArchiveMapper.class);
}
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) throws Exception {
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
try (InputStream trustStoreStream = new ClassPathResource(centralServerProperties.getSslCertPath()).getInputStream()) {
trustStore.load(trustStoreStream, centralServerProperties.getSslCertPassword().toCharArray());
}
SSLContext sslContext = SSLContextBuilder.create()
.loadTrustMaterial(trustStore, (chain, authType) -> true) // Trust all certificates
.build();
SSLConnectionSocketFactory sslConFactory = new SSLConnectionSocketFactory(sslContext);
HttpClientConnectionManager cm = PoolingHttpClientConnectionManagerBuilder.create()
.setSSLSocketFactory(sslConFactory)
.build();
CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(cm).build();
HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(httpClient);
return builder
.requestFactory(() -> factory)
.build();
}
/**
*
* Web Reactor client config with SSL cert
* @return
*/
@Bean
public HttpClient httpClient() throws KeyStoreException, IOException, NoSuchAlgorithmException, UnrecoverableKeyException {
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
try (InputStream trustStoreStream = new ClassPathResource(centralServerProperties.getSslCertPath()).getInputStream()) {
trustStore.load(trustStoreStream, centralServerProperties.getSslCertPassword().toCharArray());
} catch (CertificateException e) {
throw new RuntimeException(e);
}
KeyManagerFactory keyManagerFactory =
KeyManagerFactory.getInstance("SunX509");
keyManagerFactory.init(trustStore, centralServerProperties.getSslCertPassword().toCharArray());
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustManagerFactory.init(trustStore);
final var sslContextBuilder = SslContextBuilder.forClient()
.trustManager(trustManagerFactory)
.keyManager(keyManagerFactory)
.build();
return HttpClient.create().secure(sslSpec -> sslSpec.sslContext(sslContextBuilder));
}
@Bean
public UserDetailMapper userMapper() {
return Mappers.getMapper(UserDetailMapper.class);
}
@Bean
public GlobalSettingMapper globalSettingMapper() {
return Mappers.getMapper(GlobalSettingMapper.class);
}
@Bean
public Derived derived() {
return new Derived();
}
@Bean
public ApplicationDataBean applicationDataBean(){
return new ApplicationDataBean();
}}
Server side generate Open SSL and configure it in Spring application
Generate a private key
openssl genpkey -algorithm RSA -out server.keyGenerate a self-signed certificate
openssl req -new -x509 -key server.key -out server.crt -days 365Create a PKCS12 keystore
openssl pkcs12 -export -in server.crt -inkey server.key -out keystore.p12 -name tomcatConfigure Spring Boot to Use SSL
Client-Side Configuration
Trust the Server's Certificate Import the server's certificate into a trust store
keytool -import -alias server-cert -file server.crt -keystore truststore.jks -storepass changeitSpring boot application create bean of RestTemplate with SSL certificate
Use maven dependency below
Configure RestTemplate on SSL certificate