Spring WS a šifrované správy
source link: https://novotnyr.github.io/scrolls/spring-ws-sifrovane-spravy/
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
Spring WS a šifrované správy
2008/08/25
Keystore
Vygenerovanie dvojice privátny kľúč-verejný kľúč pre server
keytool -genkey
-alias ais-ws-server
-keystore ais-ws-server.jks
-keyalg RSA
Pozn. treba explicitne zvoliť algoritmus RSA, pretože implicitný algoritmus DSA vedie na klientskej strane k chybe:
Can't use DSA for encryption
Export serverovského certifikátu
export verejného kľúča (= serverovského certifikátu), ktorým bude klient šifrovať správy
keytool -export
-alias ais-ws-server
-file ais-ws-server-public-key.crt
-keystore ais-ws-server.jks
Súbor ais-ws-server-public-key.crt obsahuje certifikát servera, ktorý importneme do keystoru u klienta.
Import certifikátu do keystoru klienta
keytool -import -keystore ais-ws-client.jks
-file ais-ws-server-public-key.crt
-alias spring-ws-server-pubkey
Server
JARy:
- commons-logging.jar
- log4j-1.2.15.jar
- opensaml-1.1.jar
- spring.jar
- spring-webmvc.jar
- spring-ws-1.5.4.jar
- wsdl4j-1.6.1.jar
- wss4j-1.5.4.jar
- xalan-2.7.0.jar
- xmlsec-1.4.0.jar
Endpoint:
package movie.ws;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
public class RegistrationEndPoint {
public void handleMovieReservationRequest(MovieReservationRequest) {
try {
Transformer transformer = TransformerFactory.newInstance().newTransformer();
transformer.transform(messageSource, new StreamResult(System.out));
} catch (Exception e) {
e.printStackTrace();
}
}
}
Endpoint je klasické POJO. Ak môžeme používať anotácie, máme dve možnosti:
- anotovať endpoint cez
@Endpointa príslušnú metódu pomocou@PayloadRoot - anotovať endpoint cez
@Endpointa príslušnú metódu pomocou@SoapAction, kde sa volaná metóda určí na základe hlavičky SoapAction v požiadavke.
Možnosť s @PayloadRoot je však v prípade šifrovaných správ nepoužiteľná, keďže vyhodnocovanie volanej metódy sa určí ešte pred aplikáciou interceptorov. Inak povedané, mapovanie endpointov pracuje ešte nad šifrovanou správou, kde ešte nevidíme do pôvodnej nešifrovanej správy.
@Endpoint
public class RegistrationEndPoint {
@SoapAction("http://movies/movieReservation")
public void handleMovieReservationRequest(MovieReservationRequest request) {
try {
Transformer transformer = TransformerFactory.newInstance().newTransformer();
transformer.transform(messageSource, new StreamResult(System.out));
} catch (Exception e) {
e.printStackTrace();
}
}
}
Aplikačný kontext
Predovšetkým zapneme autodetekciu endpointov:
<context:component-scan base-package="movie.ws"/>
Ďalej dodáme endpoint adaptér, ktorý povolí objektové typy v parametroch metód a návratových hodnotách. Zároveň dodáme marshaller a unmarshaller:
<bean class="org.springframework.ws.server.endpoint.adapter.GenericMarshallingMethodEndpointAdapter">
<property name="marshaller" ref="marshaller" />
<property name="unmarshaller" ref="unmarshaller" />
</bean>
<bean name="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name="contextPath" value="ais.ws.types" />
</bean>
<alias name="marshaller" alias="unmarshaller"/>
Ďalej potrebujeme definovať:
- požiadaviek na endpointy
- security interceptor.
V security interceptore potrebujeme definovať akcie, ktoré sa udejú nad prichádzajúcimi požiadavkami, teda validujúce akcie. Definujeme dve: overovanie hesla (
UsernameToken) a dešifrovanie (Encrypt). Ku každej akcii definujeme callback handler, ktorý obslúži príslušnú validujúcu akciu. - keystoreCallbackHandler dešifruje správy privátnym kľúčom servera. Ten sa zoberie z keystoru, ktorý je reprezentovaný implementáciou triedy
Crypto - callbackHandler overí mená a heslá podľa vopred definovanej mapy mien a hesiel
<!-- support @Endpoint and @SoapAction annotations -->
<bean class="org.springframework.ws.soap.server.endpoint.mapping.SoapActionAnnotationMethodEndpointMapping">
<property name="interceptors">
<list>
<ref local="securityInterceptor"/>
</list>
</property>
</bean>
<bean id="securityInterceptor" class="org.springframework.ws.soap.security.wss4j.Wss4jSecurityInterceptor">
<property name="validationCallbackHandlers">
<list>
<ref local="keystoreCallbackHandler"/>
<ref local="callbackHandler"/>
</list>
</property>
<property name="validationActions" value="UsernameToken Encrypt"/>
<property name="validationDecryptionCrypto">
<bean class="org.springframework.ws.soap.security.wss4j.support.CryptoFactoryBean">
<property name="keyStorePassword" value="hesloheslo"/>
<property name="keyStoreLocation" value="file:/d:/AIS/ais-ws-spring-security/ais-ws-server.jks" />
</bean>
</property>
</bean>
<bean id="callbackHandler" class="org.springframework.ws.soap.security.wss4j.callback.SimplePasswordValidationCallbackHandler">
<property name="users">
<props>
<prop key="Bert">Ernie</prop>
</props>
</property>
</bean>
<bean id="keystoreCallbackHandler" class="org.springframework.ws.soap.security.wss4j.callback.KeyStoreCallbackHandler">
<property name="privateKeyPassword" value="hesloheslo"/>
</bean>
Klient
V klientovi potrebujeme definovať security interceptor, marshaller a akcie určené pre zabezpečenie správy.
Definujeme XML aplikačného kontextu springws-client.xml, do ktorého uvedieme nasledovné beany:
<bean id="securityInterceptor" class="org.springframework.ws.soap.security.wss4j.Wss4jSecurityInterceptor">
<!-- akcie pre zabezpečenie sú presne také isté ako na strane servera -->
<property name="securementActions" value="UsernameToken Encrypt" />
<!-- login pri autentifikácii -->
<property name="securementUsername" value="Bert"/>
<!-- heslo pri autentifikácii -->
<property name="securementPassword" value="Ernie"/>
<!-- spôsob prepravy hesla - použijeme hashovanú formu -->
<property name="securementPasswordType" value="PasswordDigest" />
<!-- referencia na bean sprístupňujúci klientský keystore -->
<property name="securementEncryptionCrypto" ref="cryptoFactoryBean" />
<!-- alias pre certifikat v keystore -->
<property name="securementEncryptionUser" value="spring-ws-server-pubkey" />
</bean>
<bean id="cryptoFactoryBean" class="org.springframework.ws.soap.security.wss4j.support.CryptoFactoryBean">
<property name="keyStoreLocation" value="file:/d:/AIS/ais-ws-spring-security/ais-ws-client.jks" />
<property name="keyStorePassword" value="hesloheslo" />
</bean>
Ďalej dokonfigurujeme šablónu WebServiceTemplate a prepojíme ju s interceptorom a marshallerom:
<bean id="webServiceTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">
<property name="marshaller" ref="marshaller" />
<property name="unmarshaller" ref="marshaller" />
<property name="interceptors" ref="securityInterceptor" />
</bean>
<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name="contextPath" value="movie.ws.types" />
</bean>
Kód klienta:
ClassPathXmlApplicationContext ctx
= new ClassPathXmlApplicationContext("ais/web/springws-client.xml");
WebServiceTemplate webServiceTemplate
= (WebServiceTemplate) ctx.getBean("webServiceTemplate");
webServiceTemplate.setDefaultUri("http://localhost:8080/movie-ws/");
MovieReservation reservation = new MovieReservation(4, "Godzilla");
// callback, ktorý nastaví správe hlavičku SoapAction
SoapActionCallback soapActionCallback
= new SoapActionCallback("http://movies/movieReservation");
webServiceTemplate.marshalSendAndReceive(reservation, soapActionCallback);
Workflow šifrovaných správ medzi serverom a klientom
Komunikácia klient->server
- Klient vlastní verejný kľúč servera
- Zašifruje ním správu
- Odošle ju serveru
- Server ju dešifruje svojim privátnym kľúčom.
Komunikácia klient-server
- Klient podpíše správu svojim privátnym kľúčom
- Spolu so správou odošle svoj X.509 certifikát (teda verejný kľúč)
- Server overí správu verejným kľúčom od klienta
- Zašifruje odpoveď verejným kľúčom zo servera
- Odošle ju klientovi.
- Klient ju odšifruje svojim privátnym kľúčom
Literatúra
http://msdn.microsoft.com/en-us/library/ms977327(printer).aspx
Shared key encryption is very fast, scalable to any size message, and, consequently, is always used for encrypting the XML text of a message. Public key encryption has beneficial key management characteristics because a public key, typically wrapped in an X.509 certificate issued by a certificate authority, can be published publicly in a registry or even in the WSDL. The recipient’s public key can then be used to encrypt the shared key, and the shared key can be used to encrypt the different parts of the message itself.
Let’s go over that again but in a different order. First, the message itself, or perhaps multiple individual parts of the message, are encrypted using a generated arbitrary shared key. Second, this shared key is then encrypted using the recipient’s public key. Because the recipient is the holder of the solitary matching and highly protected private key, theoretically, the recipient is the only one who can decrypt the shared key and then proceed to decrypt the rest of the message.
The technique is often called key wrapping or digital enveloping because the shared key is wrapped by the recipient’s public key. Although we tend to emphasize using a public key for key wrapping, it is equally possible to use a shared key to wrap a shared key.
Troubleshooting
An unsupported signature or encryption algorithm was used (unsupported key transport encryption algorithm: No such algorithm: http://www.w3.org/2001/04/xmlenc#rsa-1_5
Nainštalujte BouncyCastle, napr. z http://www.bouncycastle.org/download/bcprov-jdk16-140.jar
Recommend
About Joyk
Aggregate valuable and interesting links.
Joyk means Joy of geeK