Zabezpieczanie usługi Web Service przy użyciu strategii WS-Security

Za pomocą strategii WS-Security w produkcie WebSphere® Application Server Libertymożna tworzyć i zabezpieczać usługę Web Service JAX-WS (Java API™ dla usług Web Service JAX-WS (Java Web Services). Przykłady przedstawiono w ramach kursu wyjaśniającego ogólne kroki, które są związane z tworzeniem i zabezpieczaniem usługi Web Service w produkcie Liberty.

W poniższych przykładach przedstawiono sposób tworzenia prostej aplikacji usługi Web Service JAX-WS i zabezpieczania tej aplikacji przy użyciu strategii WS-Security. Tych przykładów nie należy używać w środowisku produkcyjnym. Należy przejrzeć własne wymagania dotyczące zabezpieczeń, aby utworzyć kontrakt WSDL (Web Services Description Language) oraz strategię WS-Security w celu ochrony aplikacji usług Web Service.

Zanim rozpoczniesz

W tych przykładach używane są dwa przykładowe pliki kluczy, enc-sender.jceks i enc-receiver.jceks, które można uzyskać z instancji WebSphere Application Server tradycyjny lub wygenerować za pomocą Komenda keytool języka Java.

Te pliki kluczy są przykładowe magazyny kluczy WS-Security, które są dołączone do produktu WebSphere Application Server traditional. Jeśli użytkownik ma dostęp do tradycyjnej instalacji, można uzyskać przykładowe magazyny kluczy z jednego z następujących katalogów.

profile_root/etc/ws-security/samples

WASHOME/profileTemplates/defaultdocuments/etc/ws-security/samples

Jeśli użytkownik nie ma dostępu do instancji WebSphere Application Server traditional , to można wygenerować przykładowe pliki kluczy, uruchamiając następujące komendy języka Java keytool . Przykłady, które korzystają z tych plików, odwołują się do dwóch przykładowych użytkowników: Alice i Bob. Najpierw należy utworzyć magazyn kluczy produktu enc-sender.jceks , który zawiera samopodpisany certyfikat dla Alicji, oraz plik kluczy enc-receiver.jceks zawierający samopodpisany certyfikat dla Boba. Następnie należy wyodrębnić klucz Alice i zaimportować go do magazynu kluczy Boba, a następnie wyodrębnić klucz Roberta i zaimportować go do magazynu kluczy Alice.

Aby utworzyć magazyn kluczy enc-sender.jceks zawierający samopodpisany certyfikat dla Alicji, uruchom następującą komendę.

keytool -genkeypair -alias alice -dname "CN=Alice, O=IBM, C=US" -storetype jceks -validity 2000 -keystore enc-sender.jceks -storepass storepswd -keypass keypswd

Aby utworzyć magazyn kluczy produktu enc-receiver.jceks , który zawiera samopodpisany certyfikat dla Boba, uruchom następującą komendę.

keytool -genkeypair -alias bob -dname "CN=Bob, O=IBM, C=US" -storetype jceks -validity 2000 -keystore enc-receiver.jceks -storepass storepswd -keypass keypswd

Aby wyodrębnić klucz Alice i zaimportować go do magazynu kluczy enc-receiver.jceks Boba, uruchom następujące komendy.

keytool -export -keystore enc-sender.jceks -alias alice -file alice.cert -storetype jceks -storepass storepswd
keytool -import -keystore enc-receiver.jceks -storetype jceks -file alice.cert -storepass storepswd -alias alice

Aby wyodrębnić klucz Boba i zaimportować go do magazynu kluczy enc-sender.jceks Alice, należy uruchomić następujące komendy.

keytool -export -keystore enc-receiver.jceks -alias bob -file bob.cert -storetype jceks -storepass storepswd
keytool -import -keystore enc-sender.jceks -storetype jceks -file bob.cert -storepass storepswd -alias bob

Po uzyskaniu lub wygenerowaniu plików kluczy należy upewnić się, że znajdują się one w katalogu ${server.config.dir} , a następnie postępować zgodnie z poniższa przykładami.

Procedura

Utwórz umowę WSDL i strategię zabezpieczeń WS-Security.

W tym przykładzie tworzona jest umowa WSDL z strategią WS-Security dla aplikacji dostawcy usług Web Service JAX-WS. Używany jest szablon strategii WS-Security o nazwie UsernameToken z asymetrycznym zabezpieczeniem komunikatu X509Token (uwierzytelnianie wzajemne) . Klient podpisuje i szyfruje treść SOAP oraz podpisuje i szyfruje znacznik UsernameToken w komunikacie żądania. W komunikacie odpowiedzi dostawca podpisuje i szyfruje treść SOAP. Pełny opis ograniczeń zabezpieczeń w tym przykładzie znajduje się w sekcji UsernameToken z asymetrycznym zabezpieczeniem komunikatu X509Token (uwierzytelnianie wzajemne).

Utwórz umowę WSDL dla usługi.

W poniższym przykładzie przedstawiono przykładową umowę WSDL.

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
                  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
                  xmlns:tns="http://com/ibm/was/wssample/sei/echo/"
                  xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="WSSampleSei"
                  targetNamespace="http://com/ibm/was/wssample/sei/echo/">
  <wsdl:types>
    <xsd:schema targetNamespace="http://com/ibm/was/wssample/sei/echo/"
                xmlns:xsd="http://www.w3.org/2001/XMLSchema">
      <xsd:element name="echoStringResponse">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="echoResponse" type="xsd:string" />
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
      <xsd:element name="echoStringInput">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="echoInput" type="xsd:string" />
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
    </xsd:schema>
  </wsdl:types>
  <wsdl:message name="echoOperationRequest">
    <wsdl:part element="tns:echoStringInput" name="parameter" />
  </wsdl:message>
  <wsdl:message name="echoOperationResponse">
    <wsdl:part element="tns:echoStringResponse" name="parameter" />
  </wsdl:message>
  <wsdl:portType name="EchoServicePortType">
    <wsdl:operation name="echoOperation">
      <wsdl:input message="tns:echoOperationRequest" />
      <wsdl:output message="tns:echoOperationResponse" />
    </wsdl:operation>
  </wsdl:portType>
  <wsdl:binding name="Echo1SOAP" type="tns:EchoServicePortType">
    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
    <wsdl:operation name="echoOperation">
      <soap:operation soapAction="echoOperation" style="document" />
      <wsdl:input>
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:service name="Echo1Service">
    <wsdl:port binding="tns:Echo1SOAP" name="Echo1ServicePort">
      <soap:address location="http://localhost:8010/WSSampleSei/Echo1Service" />
    </wsdl:port>
  </wsdl:service>
</wsdl:definitions>

Należy dodać przestrzenie nazw, które są wymagane do obsługi strategii bezpieczeństwa, do pliku WSDL w elemencie wsdl:definitions .

W poniższym przykładzie przedstawiono dodane przestrzenie nazw.

xmlns:wsp="http://www.w3.org/ns/ws-policy"
xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
xmlns:sp="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702"
xmlns:sp13="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200802"
xmlns:wsaws="http://www.w3.org/2005/08/addressing"

Dodaj fragment strategii WS-Security do pliku WSDL tuż przed elementem wsdl:binding .
W tym przykładzie używany jest szablon strategii z UsernameToken z asymetrycznym zabezpieczeniem komunikatu X509Token (uwierzytelnianie wzajemne) .
Dodaj wsp:PolicyReference dla strategii bezpieczeństwa do elementu wsdl:binding .
W poniższym przykładzie przedstawiono wsp:PolicyReference.
```
<wsp:PolicyReference URI="#AsymmetricX509MutualAuthenticationWithUnt" />
```

Sprawdź, czy końcowy plik WSDL jest podobny do przykładu.

W poniższym przykładzie przedstawiono ostateczny plik WSDL.

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
                  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
                  xmlns:tns="http://com/ibm/was/wssample/sei/echo/"
                  xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="WSSampleSei"
                  xmlns:wsp="http://www.w3.org/ns/ws-policy"
                  xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
                  xmlns:sp="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702"
                  xmlns:sp13="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200802"
                  xmlns:wsaws="http://www.w3.org/2005/08/addressing"
                  targetNamespace="http://com/ibm/was/wssample/sei/echo/">
  <wsdl:types>
    <xsd:schema targetNamespace="http://com/ibm/was/wssample/sei/echo/"
                xmlns:xsd="http://www.w3.org/2001/XMLSchema">
      <xsd:element name="echoStringResponse">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="echoResponse" type="xsd:string" />
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
      <xsd:element name="echoStringInput">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="echoInput" type="xsd:string" />
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
    </xsd:schema>
  </wsdl:types>
  <wsdl:message name="echoOperationRequest">
    <wsdl:part element="tns:echoStringInput" name="parameter" />
  </wsdl:message>
  <wsdl:message name="echoOperationResponse">
    <wsdl:part element="tns:echoStringResponse" name="parameter" />
  </wsdl:message>
  <wsdl:portType name="EchoServicePortType">
    <wsdl:operation name="echoOperation">
      <wsdl:input message="tns:echoOperationRequest" />
      <wsdl:output message="tns:echoOperationResponse" />
    </wsdl:operation>
  </wsdl:portType>
  <wsp:Policy wsu:Id="AsymmetricX509MutualAuthenticationWithUnt">
    <wsp:ExactlyOne>
      <wsp:All>
        <sp:SignedEncryptedSupportingTokens xmlns:sp="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702">
          <wsp:Policy>
            <sp:UsernameToken sp:IncludeToken="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/AlwaysToRecipient">
              <wsp:Policy>
                <sp:WssUsernameToken10 />
              </wsp:Policy>
            </sp:UsernameToken>
          </wsp:Policy>
        </sp:SignedEncryptedSupportingTokens>
        <sp:AsymmetricBinding>
          <wsp:Policy>
            <sp:InitiatorToken>
              <wsp:Policy>
                <sp:X509Token sp:IncludeToken="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/AlwaysToRecipient">
                  <wsp:Policy>
                    <sp:WssX509V3Token10 />
                    <sp:RequireIssuerSerialReference />
                  </wsp:Policy>
                </sp:X509Token>
              </wsp:Policy>
            </sp:InitiatorToken>
            <sp:RecipientToken>
              <wsp:Policy>
                <sp:X509Token sp:IncludeToken="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/Never">
                  <wsp:Policy>
                    <sp:WssX509V3Token10 />
                    <sp:RequireIssuerSerialReference />
                  </wsp:Policy>
                </sp:X509Token>
              </wsp:Policy>
            </sp:RecipientToken>
            <sp:Layout>
              <wsp:Policy>
                <sp:Strict />
              </wsp:Policy>
            </sp:Layout>
            <sp:IncludeTimestamp />
            <sp:OnlySignEntireHeadersAndBody />
            <sp:EncryptSignature />
            <sp:AlgorithmSuite>
              <wsp:Policy>
                <sp:Basic128 />
              </wsp:Policy>
            </sp:AlgorithmSuite>
          </wsp:Policy>
        </sp:AsymmetricBinding>
        <sp:Wss11>
          <wsp:Policy>
            <sp:MustSupportRefKeyIdentifier />
            <sp:MustSupportRefIssuerSerial />
            <sp:MustSupportRefThumbprint />
            <sp:MustSupportRefEncryptedKey />
            <sp:RequireSignatureConfirmation />
          </wsp:Policy>
        </sp:Wss11>
        <sp:SignedParts>
          <sp:Body />
        </sp:SignedParts>
        <sp:EncryptedParts>
          <sp:Body />
        </sp:EncryptedParts>
      </wsp:All>
    </wsp:ExactlyOne>
  </wsp:Policy>
  <wsdl:binding name="Echo1SOAP" type="tns:EchoServicePortType">
    <wsp:PolicyReference URI="#AsymmetricX509MutualAuthenticationWithUnt" />
    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
    <wsdl:operation name="echoOperation">
      <soap:operation soapAction="echoOperation" style="document" />
      <wsdl:input>
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:service name="Echo1Service">
    <wsdl:port binding="tns:Echo1SOAP" name="Echo1ServicePort">
      <soap:address location="http://localhost:8010/WSSampleSei/Echo1Service" />
    </wsdl:port>
  </wsdl:service>
</wsdl:definitions>

Utwórz aplikację usługi Web Service przy użyciu pliku WSDL.

Ten krok można wykonać przed lub po dodaniu strategii WS-Security do pliku WSDL. Za pomocą obsługiwanych narzędzi można utworzyć aplikację usługi Web Service JAX-WS na podstawie pliku WSDL, który został opracowany w poprzedniej sekcji.

W poniższym przykładzie przedstawiono aplikację usługi Web Service, która jest rozwijana z poziomu pliku WSDL przy użyciu narzędzia Rational® Application Developer .

@javax.jws.WebService (endpointInterface="com.ibm.was.wssample.sei.echo.EchoServicePortType",
                       targetNamespace="http://com/ibm/was/wssample/sei/echo/", 
                       serviceName="Echo1Service", 
                       wsdlLocation = "WEB-INF/wsdl/Echo.wsdl",
                       portName="Echo1ServicePort")
public class Echo1SOAPImpl {

  public EchoStringResponse echoOperation(EchoStringInput parameter) {
    String strInput = (parameter == null ? "input_is_null" : parameter.getEchoInput() );
    try {
      com.ibm.was.wssample.sei.echo.EchoStringResponse strOutput = new EchoStringResponse();
      strOutput.setEchoResponse( "Echo1SOAPImpl>>" + strInput );
      return strOutput;
    } catch (java.lang.Exception ex) {
      ex.printStackTrace();
    }
  }

@WebService (name = "EchoServicePortType", 
             targetNamespace = "http://com/ibm/was/wssample/sei/echo/")
@SOAPBinding (parameterStyle = SOAPBinding.ParameterStyle.BARE)
@XmlSeeAlso ({
    ObjectFactory.class
})

public interface EchoServicePortType {

  @WebMethod (action = "echoOperation")
  @WebResult (name = "echoStringResponse", targetNamespace = "http://com/ibm/was/wssample/sei/echo/", partName = "parameter")
  public  EchoStringResponse echoOperation(
    @WebParam (name = "echoStringInput", targetNamespace = "http://com/ibm/was/wssample/sei/echo/", partName = "parameter")
    EchoStringInput parameter);

}

Poniższy kod przedstawia zarządzany klient usługi Web Service, który wywołuje aplikację dostawcy usług Web Service.

@WebServlet("ClientServlet")
public class ClientServlet extends HttpServlet {

  @WebServiceRef (value=Echo1Service.class, wsdlLocation="Echo.wsdl")
  Echo1Service echo1Service;

  public  ClientServlet() {
    super ();
  }

  protected void doGet(HttpServletRequest request,
                       HttpServletResponse response) throws ServletException, IOException {
    processRequest(request, response);
  } 

  protected void doPost(HttpServletRequest request,
                        HttpServletResponse response) throws ServletException, IOException {
    processRequest(request, response);
  }

  private void processRequest(HttpServletRequest req,
                              HttpServletResponse resp) throws ServletException, IOException {

    String endpointURL = "http://localhost:8010/WSSampleSei/Echo1Service";

    Echo1ServicePortProxy proxy = new Echo1ServicePortProxy(echo1Service);
    proxy._getDescriptor().setEndpoint(endpointURL);

    echoParm = new ObjectFactory().createEchoStringInput();
    echoParm.setEchoInput("Hello");

    String retval = proxy.echoOperation(echoParm).getEchoResponse();

  }
}

W poniższym przykładzie przedstawiono strukturę pliku war aplikacji dostawcy usług Web Service.

WEB-INF/web.xml
WEB-INF/wsdl/Echo.wsdl
WEB-INF/classes/com/ibm/was/wssample/sei/echo/Echo1SOAPImpl.class
WEB-INF/classes/com/ibm/was/wssample/sei/echo/EchoServicePortType.class
WEB-INF/classes/com/ibm/was/wssample/sei/echo/EchoStringInput.class
WEB-INF/classes/com/ibm/was/wssample/sei/echo/EchoStringResponse.class
WEB-INF/classes/com/ibm/was/wssample/sei/echo/ObjectFactory.class
WEB-INF/classes/com/ibm/was/wssample/sei/echo/package-info.class

W poniższym przykładzie przedstawiono strukturę pliku war aplikacji klienta usługi Web Service.

WEB-INF/web.xml
WEB-INF/wsdl/Echo.wsdl
WEB-INF/classes/com/ibm/was/wssample/client/ClientServlet.class
WEB-INF/classes/com/ibm/was/wssample/client/SampleClient.class
WEB-INF/classes/com/ibm/was/wssample/sei/echo/Echo1Service.class
WEB-INF/classes/com/ibm/was/wssample/sei/echo/Echo1ServicePortProxy.class
WEB-INF/classes/com/ibm/was/wssample/sei/echo/EchoStringInput.class
WEB-INF/classes/com/ibm/was/wssample/sei/echo/EchoStringResponse.class
WEB-INF/classes/com/ibm/was/wssample/sei/echo/ObjectFactory.class
WEB-INF/classes/com/ibm/was/wssample/sei/echo/package-info.class

Projektowanie procedury obsługi wywołania zwrotnego.

Należy utworzyć procedurę obsługi wywołania zwrotnego, aby pobrać hasła klucza użytkownika i klucza magazynu kluczy. Hasło użytkownika jest używane przy generowaniu znaczników UsernameTokens. Hasła magazynu kluczy są używane do uzyskiwania dostępu do kluczy prywatnych w magazynie kluczy. Procedura obsługi wywołania zwrotnego musi zwracać hasła w postaci zwykłego tekstu i musi być pakowana i instalowana jako opcja użytkownika Liberty .

Poniższy kod przykładowy ilustruje procedurę obsługi wywołania zwrotnego.

package com.ibm.ws.wssecurity.example.cbh;

import java.util.HashMap;
import java.util.Map;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import org.apache.ws.security.WSPasswordCallback;

public class SamplePasswordCallback implements CallbackHandler {
  private Map<String, String> userPasswords = new HashMap<String, String>();
  private Map<String, String> keyPasswords = new HashMap<String, String>();
  public SamplePasswordCallback() {
    // some example user passwords
    userPasswords.put("user1", "user1pswd");
    userPasswords.put("admin", "adminpswd");
    // some example key passwords
    keyPasswords.put("alice", "keypwsd");
    keyPasswords.put("bob", "keypswd");
  }
  public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {
    for (int i = 0; i < callbacks.length; i++) {
      WSPasswordCallback pwcb = (WSPasswordCallback)callbacks[i];
      String id = pwcb.getIdentifier();
      String pass = null;
      switch (pwcb.getUsage()) {
        case WSPasswordCallback.USERNAME_TOKEN:
          pass = userPasswords.get(id);
          pwcb.setPassword(pass);
          break;
        case WSPasswordCallback.SIGNATURE:
        case WSPasswordCallback.DECRYPT:
          pass = keyPasswords.get(id);
          pwcb.setPassword(pass);
          break;
      }
    }
  }
}

W poniższym przykładzie przedstawiono plik MANIFEST.MF , który jest spakowany z procedurą obsługi wywołania zwrotnego.

Manifest-Version: 1.0
Bnd-LastModified: 1359415594428
Build-Identifier: SNAPSHOT-Mon Jan 28 17:26:34 CST 2013
Bundle-Description: An PasswordCallbackHandler; version=1.0.0
Bundle-ManifestVersion: 2
Bundle-Name: wssecuritycbh
Bundle-SymbolicName: com.ibm.ws.wssecurity.example.cbh
Bundle-Vendor: IBM
Bundle-Version: 1.0.0
Created-By: 1.6.0 (IBM Corporation)
Export-Package: com.ibm.ws.wssecurity.example.cbh;uses:="com.ibm.websphe
re.ras.annotation,javax.security.auth.callback";version="1.0.0"
Import-Package: com.ibm.websphere.ras,com.ibm.websphere.ras.annotation,c
om.ibm.ws.ffdc,javax.security.auth.callback,org.apache.ws.security;version="[1.6,2)"
Require-Capability: osgi.ee;filter:="(&(osgi.ee=JavaSE)(version>=1.6))"
Tool: Bnd-2.1.0.20120920-170235
WS-TraceGroup: WSSecurity

Utwórz plik JAR z procedurą obsługi wywołania zwrotnego i plikiem manifestu składnika- wsseccbh-1.0.mf.

Utwórz plik JAR o nazwie SampleCbh.jar z następującą zawartością.

META-INF/MANIFEST.MF
com/ibm/ws/wssecurity/example/cbh/SamplePasswordCallback.class

W poniższym przykładzie przedstawiono plik wsseccbh-1.0.mf .

Subsystem-ManifestVersion: 1
Subsystem-SymbolicName: wsseccbh-1.0; visibility:=public
Subsystem-Version: 1.0.0
Subsystem-Content: com.ibm.ws.wssecurity.example.cbh; version="[1,1.0.100)";
    location:="lib/"; type="osgi.bundle"; start-phase:=APPLICATION_EARLY

Subsystem-Type: osgi.subsystem.feature
IBM-Feature-Version: 2

IBM-API-Package: com.ibm.ws.wssecurity.example.cbh; version="1.0"; type="internal"

Skopiuj plik JAR procedury obsługi wywołania zwrotnego i plik manifestu składnika w katalogu użytkownika Liberty .
Poniższy przykład przedstawia, gdzie kopiowany jest plik JAR procedury obsługi wywołania zwrotnego i plik manifestu składnika.
```
build.image/wlp/usr/extension/lib/SampleCbh.jar
build.image/wlp/usr/extension/lib/features/wsseccbh-1.0.mf
```

Skonfiguruj zabezpieczenia WS-Security na serwerze Liberty .

Włącz opcję zabezpieczeń WS-Security w pliku konfiguracyjnym serwera Liberty : server.xml i skonfiguruj zabezpieczenia WS-Security dla przykładowej aplikacji klienckiej i dostawcy usług WWW, która została opracowana w poprzednich sekcjach.

W poniższym przykładzie przedstawiono sposób konfigurowania zabezpieczeń WS-Security.

<server>
  <featureManager>
    <feature>usr:wsseccbh-1.0</feature>
    <feature>servlet-3.0</feature>
    <feature>appSecurity-2.0</feature>
    <feature>jsp-2.2</feature>
    <feature>jaxws-2.2</feature>
    <feature>wsSecurity-1.1</feature>
  </featureManager>
  <basicRegistry id="basic" realm="customRealm">
    <user ="user1" password="user1pswd" />
    <user name="user2" password="user2pswd" />
  </basicRegistry>
  <wsSecurityProvider id="default"
    ws-security.callback-handler="com.ibm.ws.wssecurity.example.cbh.SamplePasswordCallback"
    ws-security.signature.username="bob">
    <signatureProperties org.apache.ws.security.crypto.merlin.keystore.type="jceks"
      org.apache.ws.security.crypto.merlin.keystore.password="storepswd"
      org.apache.ws.security.crypto.merlin.keystore.alias="bob"
      org.apache.ws.security.crypto.merlin.file="${server.config.dir}/enc-receiver.jceks" />
    <encryptionProperties org.apache.ws.security.crypto.merlin.keystore.type="jceks"
      org.apache.ws.security.crypto.merlin.keystore.password="storepswd"
      org.apache.ws.security.crypto.merlin.keystore.alias="alice"
      org.apache.ws.security.crypto.merlin.file="${server.config.dir}/enc-receiver.jceks" />
  </wsSecurityProvider>
  <wsSecurityClient id="default"
    ws-security.password="security"
    ws-security.username="user1"
    ws-security.callback-handler="com.ibm.ws.wssecurity.example.cbh.SamplePasswordCallback"
    ws-security.encryption.username="alice">
    <signatureProperties org.apache.ws.security.crypto.merlin.keystore.type="jceks"
      org.apache.ws.security.crypto.merlin.keystore.password="storepswd"
      org.apache.ws.security.crypto.merlin.keystore.alias="alice"
      org.apache.ws.security.crypto.merlin.file="${server.config.dir}/enc-sender.jceks"/>
    <encryptionProperties org.apache.ws.security.crypto.merlin.keystore.type="jceks"
      org.apache.ws.security.crypto.merlin.keystore.password="storepswd"
      org.apache.ws.security.crypto.merlin.keystore.alias="bob"
      org.apache.ws.security.crypto.merlin.file="${server.config.dir}/enc-sender.jceks" />
  </wsSecurityClient>
</server>

Wyniki

Usługa Web Service została zabezpieczona za pomocą strategii WS-Security.

Przykład

Przykładowa strategia WS-Security, która została utworzona w pierwszym kroku, generuje żądania SOAP i komunikaty odpowiedzi podobne do następujących komunikatów.

W poniższym przykładzie przedstawiono komunikat żądania SOAP.

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Header xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
    <wsse:Security xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
                   xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
                   soap:mustUnderstand="1">
      <wsse:BinarySecurityToken
        EncodingType="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary"
        ValueType="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-x509-token-profile-1.0#X509v3"
        wsu:Id="X509-B1165B2A578AFFC7D613649595665924">...
      </wsse:BinarySecurityToken>
      <wsu:Timestamp wsu:Id="TS-1">
        <wsu:Created>2013-04-03T03:26:06.549Z</wsu:Created>
        <wsu:Expires>2013-04-03T03:31:06.549Z</wsu:Expires>
      </wsu:Timestamp>
      <xenc:EncryptedKey xmlns:xenc="http://www.w3.org/2001/04/xmlenc#" Id="EK-B1165B2A578AFFC7D613649595666705">
        <xenc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p"></xenc:EncryptionMethod>
        <ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
          <wsse:SecurityTokenReference>
            <ds:X509Data>
              <ds:X509IssuerSerial>
                <ds:X509IssuerName>CN=Bob,O=IBM,C=US</ds:X509IssuerName>
                <ds:X509SerialNumber>24054675667389</ds:X509SerialNumber>
              </ds:X509IssuerSerial>
            </ds:X509Data>
          </wsse:SecurityTokenReference>
        </ds:KeyInfo>
        <xenc:CipherData>
          <xenc:CipherValue>...</xenc:CipherValue>
        </xenc:CipherData>
        <xenc:ReferenceList>
          <xenc:DataReference URI="#ED-4"></xenc:DataReference>
          <xenc:DataReference URI="#ED-5"></xenc:DataReference>
          <xenc:DataReference URI="#ED-6"></xenc:DataReference>
        </xenc:ReferenceList>
      </xenc:EncryptedKey>
      <xenc:EncryptedData
        xmlns:xenc="http://www.w3.org/2001/04/xmlenc#" Id="ED-6" Type="http://www.w3.org/2001/04/xmlenc#Element">
        <xenc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes128-cbc"></xenc:EncryptionMethod>
        <ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
          <wsse:SecurityTokenReference
            xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
            xmlns:wsse11="http://docs.oasis-open.org/wss/oasis-wss-wssecurity-secext-1.1.xsd"
            wsse11:TokenType="http://docs.oasis-open.org/wss/oasis-wss-soap-message-security-1.1#EncryptedKey">
            <wsse:Reference URI="#EK-B1165B2A578AFFC7D613649595666705"></wsse:Reference>
          </wsse:SecurityTokenReference>
        </ds:KeyInfo>
        <xenc:CipherData>
          <xenc:CipherValue>...</xenc:CipherValue>
        </xenc:CipherData>
      </xenc:EncryptedData>
      <xenc:EncryptedData xmlns:xenc="http://www.w3.org/2001/04/xmlenc#"
                          Id="ED-5"
                          Type="http://www.w3.org/2001/04/xmlenc#Element">
        <xenc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes128-cbc"></xenc:EncryptionMethod>
        <ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
          <wsse:SecurityTokenReference
            xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
            xmlns:wsse11="http://docs.oasis-open.org/wss/oasis-wss-wssecurity-secext-1.1.xsd"
            wsse11:TokenType="http://docs.oasis-open.org/wss/oasis-wss-soap-message-security-1.1#EncryptedKey">
            <wsse:Reference URI="#EK-B1165B2A578AFFC7D613649595666705"></wsse:Reference>
          </wsse:SecurityTokenReference>
        </ds:KeyInfo>
        <xenc:CipherData>
          <xenc:CipherValue>...</xenc:CipherValue>
        </xenc:CipherData>
      </xenc:EncryptedData>
    </wsse:Security>
  </SOAP-ENV:Header>
  <soap:Body xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
             wsu:Id="Id-1788936596">
    <xenc:EncryptedData xmlns:xenc="http://www.w3.org/2001/04/xmlenc#"
                        Id="ED-4"
                        Type="http://www.w3.org/2001/04/xmlenc#Content">
      <xenc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes128-cbc"></xenc:EncryptionMethod>
      <ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
        <wsse:SecurityTokenReference
          xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
          xmlns:wsse11="http://docs.oasis-open.org/wss/oasis-wss-wssecurity-secext-1.1.xsd"
          wsse11:TokenType="http://docs.oasis-open.org/wss/oasis-wss-soap-message-security-1.1#EncryptedKey">
          <wsse:Reference URI="#EK-B1165B2A578AFFC7D613649595666705"></wsse:Reference>
        </wsse:SecurityTokenReference>
      </ds:KeyInfo>
      <xenc:CipherData>
        <xenc:CipherValue>...</xenc:CipherValue>
      </xenc:CipherData>
    </xenc:EncryptedData>
  </soap:Body>
</soap:Envelope>

W poniższym przykładzie przedstawiono komunikat odpowiedzi SOAP.

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Header xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
    <wsse:Security xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
                   xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
                   soap:mustUnderstand="1">
      <wsu:Timestamp wsu:Id="TS-7">
        <wsu:Created>2013-04-03T03:26:07.286Z</wsu:Created>
        <wsu:Expires>2013-04-03T03:31:07.286Z</wsu:Expires>
      </wsu:Timestamp>
      <xenc:EncryptedKey xmlns:xenc="http://www.w3.org/2001/04/xmlenc#" Id="EK-B1165B2A578AFFC7D613649595673129">
        <xenc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p"></xenc:EncryptionMethod>
        <ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
          <wsse:SecurityTokenReference>
            <ds:X509Data>
              <ds:X509IssuerSerial>
                <ds:X509IssuerName>CN=Alice,O=IBM,C=US</ds:X509IssuerName>
                <ds:X509SerialNumber>24054530212598</ds:X509SerialNumber>
              </ds:X509IssuerSerial>
            </ds:X509Data>
          </wsse:SecurityTokenReference>
        </ds:KeyInfo>
        <xenc:CipherData>
          <xenc:CipherValue>...</xenc:CipherValue>
        </xenc:CipherData>
        <xenc:ReferenceList>
          <xenc:DataReference URI="#ED-10"></xenc:DataReference>
          <xenc:DataReference URI="#ED-11"></xenc:DataReference>
          <xenc:DataReference URI="#ED-12"></xenc:DataReference>
        </xenc:ReferenceList>
      </xenc:EncryptedKey>
      <xenc:EncryptedData xmlns:xenc="http://www.w3.org/2001/04/xmlenc#"
                          Id="ED-12"
                          Type="http://www.w3.org/2001/04/xmlenc#Element">
        <xenc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes128-cbc"></xenc:EncryptionMethod>
        <ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
          <wsse:SecurityTokenReference
            xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
            xmlns:wsse11="http://docs.oasis-open.org/wss/oasis-wss-wssecurity-secext-1.1.xsd"
            wsse11:TokenType="http://docs.oasis-open.org/wss/oasis-wss-soap-message-security-1.1#EncryptedKey">
            <wsse:Reference URI="#EK-B1165B2A578AFFC7D613649595673129"></wsse:Reference>
          </wsse:SecurityTokenReference>
        </ds:KeyInfo>
        <xenc:CipherData>
          <xenc:CipherValue>...</xenc:CipherValue>
        </xenc:CipherData>
      </xenc:EncryptedData>
      <xenc:EncryptedData xmlns:xenc="http://www.w3.org/2001/04/xmlenc#"
                          Id="ED-11"
                          Type="http://www.w3.org/2001/04/xmlenc#Element">
        <xenc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes128-cbc"></xenc:EncryptionMethod>
        <ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
          <wsse:SecurityTokenReference
            xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
            xmlns:wsse11="http://docs.oasis-open.org/wss/oasis-wss-wssecurity-secext-1.1.xsd"
            wsse11:TokenType="http://docs.oasis-open.org/wss/oasis-wss-soap-message-security-1.1#EncryptedKey">
            <wsse:Reference URI="#EK-B1165B2A578AFFC7D613649595673129"></wsse:Reference>
          </wsse:SecurityTokenReference>
        </ds:KeyInfo>
        <xenc:CipherData>
          <xenc:CipherValue>...</xenc:CipherValue>
        </xenc:CipherData>
      </xenc:EncryptedData>
    </wsse:Security>
  </SOAP-ENV:Header>
  <soap:Body xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
             wsu:Id="Id-2035943749">
    <xenc:EncryptedData xmlns:xenc="http://www.w3.org/2001/04/xmlenc#"
                        Id="ED-10"
                        Type="http://www.w3.org/2001/04/xmlenc#Content">
      <xenc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes128-cbc"></xenc:EncryptionMethod>
      <ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
        <wsse:SecurityTokenReference
          xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
          xmlns:wsse11="http://docs.oasis-open.org/wss/oasis-wss-wssecurity-secext-1.1.xsd"
          wsse11:TokenType="http://docs.oasis-open.org/wss/oasis-wss-soap-message-security-1.1#EncryptedKey">
          <wsse:Reference URI="#EK-B1165B2A578AFFC7D613649595673129"></wsse:Reference>
        </wsse:SecurityTokenReference>
      </ds:KeyInfo>
      <xenc:CipherData>
        <xenc:CipherValue>...</xenc:CipherValue>
      </xenc:CipherData>
    </xenc:EncryptedData>
  </soap:Body>
</soap:Envelope>

Co dalej

Teraz można utworzyć własny plik WSDL i chronić aplikację usługi Web Service przy użyciu strategii WS-Security, która jest zgodna z wymaganiami zabezpieczeń.