JAX-RS-Anwendungen im Web-Container sichern

Sie können die Sicherheitsservices, die über den Web-Container verfügbar sind, verwenden, um REST-Ressourcen zu sichern. Sie können Sicherheitsverfahren konfigurieren, die die Benutzerauthentifizierung, die Transportsicherheit, die Berechtigungsprüfung und die Zuordnungen von Benutzern zu Rollen definieren.

Vorbereitende Schritte

Um Sicherheitsvorgaben richtig zu definieren, ist es wichtig, dass Sie mit der Anwendung und den RESTful-Ressourcen, die sie verfügbar machen, vertraut sind. Dieses Wissen hilft Ihnen, entsprechende Sicherheitsrollen, die für Ihre Anwendung erforderlich sind, und einzelne Ressourcen, die von der Anwendung verfügbar gemacht werden, zu bestimmen.

In diesem Artikel wird eine REST-Beispielanwendung mit dem Namen "AddressBookApp" verwendet, die veranschaulichen sollen, wie eine REST-Anwendung gesichert wird.

Sie müssen die Installation Ihrer Anwendung auf dem Anwendungsserver abschließen. Nachdem Sie die Anwendung "AddressBookApp" installiert haben, sieht der Implementierungsdeskriptor von "AddressBookApp" im Verzeichnis Profilstammverzeichnis/config/cells/cellName/applications/applicationName.ear/deployments/applicationName_war/applicationName.war/WEB-INF wie im folgenden Beispiel aus:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app id="WebApp_1255468655347">
 <display-name>Sample REST Web Application</display-name>
  <servlet>
    <servlet-name>AddressBookApp</servlet-name>
    <servlet-class>com.ibm.websphere.jaxrs.server.IBMRestServlet</servlet-class>
    <init-param>
      <param-name>javax.ws.rs.Application</param-name>
      <param-value>com.test.AddressBookApplication</param-value>
</init-param>
    <load-on-startup>1</load-on-startup>
    </servlet>  <servlet-mapping>
    <servlet-name>AddressBookApp</servlet-name>
    <url-pattern>/rest/*</url-pattern>
  </servlet-mapping>
</web-app>
In diesem Beispiel zeigt die Servlet-Zuordnung an, dass die REST-Ressourcen im Verzeichnis /Stammkontext_der_Anwendung/rest bereitgestellt werden. Stammkontext_der_Anwendung bezeichnet das, was Sie bei der Installation der Anwendung konfiguriert haben. Der Standardstammkontext ist /.

Sie müssen die Sicherheit für WebSphere Application Server aktivieren.

Informationen zu diesem Vorgang

Sie können den Web-Container verwenden, um die Authentifizierung durchzuführen, oder Sie können Berechtigungsvorgaben für eine REST-Anwendung festlegen, die in der Anwendungsserverumgebung ausgeführt wird. Die Berechtigung ist eine grundlegende Sicherheitsanforderung für geschäftliche REST-Ressourcen, die ein Mindestmaß an Sicherheit erfordern und möglicherweise Ressourcen basierend auf der Identität des Callers (Aufrufenden) schützen müssen.

Sie können Sicherheitsmechanismen für REST-Ressourcen wie folgt konfigurieren:
  • Festlegen, dass Benutzer sich nur über die HTTP-Basisauthentifizierung oder die Formularanmeldung für Ihre Anwendung authentifizieren dürfen
  • Die Anwendung so konfigurieren, dass sie beim Aufrufen von REST-Ressourcen einen SSL-Kanal für den Transport verwendet
  • Rollenbasierte Berechtigungsvorgaben für Ihre REST-Ressourcenmuster definieren
  • Die programmgesteuerte Verwendung des annotierten Objekts "SecurityContext" zur Bestimmung von Benutzeridentität und Rollen implementieren

Vorgehensweise

  1. Vergewissern Sie sich, dass die Sicherheit für den Anwendungsserver aktiviert ist.
    1. Starten Sie die Administrationskonsole von WebSphere Application Server.

      Starten Sie den Deployment Manager, und geben Sie in Ihrem Browser die Adresse Ihres Servers von WebSphere Application Server Network Deployment ein. Standardmäßig können Sie die Konsole mit dem URL http://Ihr_Host.Ihre_Domäne:9060/ibm/console aufrufen.

      Wenn die Sicherheit inaktiviert ist, werden Sie zur Eingabe einer Benutzer-ID aufgefordert. Melden Sie sich mit einer beliebigen Benutzer-ID an. Wenn die Sicherheit aktiviert ist, werden Sie jedoch aufgefordert, eine Benutzer-ID und ein Kennwort einzugeben. Melden Sie sich mit der ID und dem Kennwort eines vordefinierten Benutzers mit Verwaltungsaufgaben an.

    2. Klicken Sie auf Sicherheit > Globale Sicherheit.

      Wählen Sie die Option Awnendungssicherheit aktivieren aus.

      Fehler vermeiden Fehler vermeiden: Sie müssen die Verwaltungssicherheit aktivieren. Die Anwendungssicherheit kann nur wirksam werden, wenn die Verwaltungssicherheit aktiviert ist. gotcha
  2. Fügen Sie Sicherheitsvorgaben hinzu.
    Editieren Sie die Datei "web.xml" für die Anwendung, oder verwenden Sie das Assembliertool, um Sicherheitsvorgaben zu Ihrer Anwendung hinzuzufügen. Der folgende Codeausschnitt ist eine Sicherheitsvorgabe, die auf die Beispielanwendung AddressBookApp angewendet wird:
    <!-- Sicherheitsvorgaben für die Beispielanwendung -->
      <security-constraint id="SecurityConstraint_1">
        <!-- Hier wird die REST-Ressource definiert, die der Vorgabe zugeordnet ist. -->
        <web-resource-collection id="WebResourceCollection_1">
          <web-resource-name>AddressBookApp</web-resource-name>
          <description>Protection area for Rest resource /addresses </description>
          <url-pattern>/rest/addresses</url-pattern>
          <http-method>GET</http-method>
          <http-method>POST</http-method>
        </web-resource-collection>
    
        <!— Hier wird eine Berechtigungsvorgabe definiert, indem Role1 für die Ressource angefordert wird. -->
        <auth-constraint id="AuthConstraint_1">
          <description>Used to guard resources under this url-pattern </description>
          <role-name>Role1</role-name>
        </auth-constraint>
      </security-constraint>

    In diesem Beispiel befindet sich eine Webressource im Verzeichnis /root_context/rest/addresses, die auf eine HTTP-GET- oder eine HTTP-POST-Anforderung antworten kann. Es wird eine Sicherheitsvorgabe, AuthConstraint_1, auf die Webressource angewendet. Die Berechtigungsvorgabe gibt an, dass Benutzer die Rolle Role1 für den Zugriff auf die Ressource benötigen.

  3. Wählen Sie einen oder mehrere der folgenden Sicherheitsmechanismen zur Konfiguration für die REST-Anwendung aus.
    • Aktivieren Sie die HTTP-Basisauthentifizierung.
      1. Fügen Sie Sicherheitsvorgaben hinzu, indem Sie die Datei "web.xml" wie zuvor beschrieben bearbeiten.
      2. Konfigurieren Sie die Datei "web.xml", um die HTTP-Basisauthentifizierung zu aktivieren.
        Editieren Sie die Datei "web.xml" für die Anwendung, und fügen Sie das folgende Element hinzu, um die Verwendung der HTTP-Basisauthentifizierung zu definieren. Standardmäßig verwendet die Laufzeitumgebung der Anwendungsserversicherheit diese Authentifizierungsmethode.
        <!-- Hier wird die Anmeldekonfiguration für die HTTP-Basisauthentifizierung definiert.-->
         <login-config>
                <auth-method>BASIC</auth-method>
                <realm-name>test realm</realm-name>
         </login-config>
        Jetzt haben Sie eine Methode für die HTTP-Basisauthentifizierung definiert. Benutzer, die versuchen, auf die Ressource zuzugreifen, müssen sich mit Berechtigungsnachweisen anmelden.
    • Aktivieren Sie die Formularanmeldung.
      1. Fügen Sie Sicherheitsvorgaben hinzu, indem Sie die Datei "web.xml" wie zuvor beschrieben bearbeiten.
      2. Editieren Sie die Datei "web.xml" für die Anwendung, und fügen Sie das folgende Element hinzu, um die Verwendung der Formularanmeldung zu definieren.
        <login-config>
              <auth-method>FORM</auth-method>
              <form-login-config>
                 <form-login-page>/logon.jsp</form-login-page>
                 <form-error-page>/logonError.jsp</form-error-page>
              </form-login-config>
        </login-config>
        Es ist wichtig, dass Sie die Werte für die Webseiten "logon.jsp" und "logonError.jsp" durch Ihre Werte für Formularanmeldung bzw. Fehlerbehandlung ersetzen. Wenn Sie auf die Anwendung zugreifen, werden Benutzer über die Webseite "logon.jsp" zur Authentifizierung umgeleitet. Liegt ein Authentifizierungsfehler vor, werden Benutzer zur Webseite "logonError.jsp" umgeleitet. Das folgende Beispiel veranschaulicht die Position der Seiten "logon.jsp" und "logonError.jsp" in der WAR-Datei (Webarchiv):
        META-INF
              logon.jsp
              logonError.jsp
              WEB-INF/classes/
              WEB-INF/classes/
              WEB-INF/classes/com/
              WEB-INF/classes/com/test/   
              WEB- NF/classes/com/test/AddressBookApplication.class
              WEB-INF/classes/com/test/AddressBookResource.class
        Der folgende Codeausschnitt veranschaulicht ein Beispielanmeldeformular:
        <html>
        <head>
            <title>Login Page</title>
        </head>
        <h2>Hello, please log in:</h2>
        <br><br>
        <form action="j_security_check" method=post>
            <p><strong>Please Enter Your User Name: </strong>
            <input type="text" name="j_username" size="25">
            <p><p><strong>Please Enter Your Password: </strong>
            <input type="password" size="15" name="j_password">
            <p><p>
            <input type="submit" value="Submit">
            <input type="reset" value="Reset">
        </form>
        </html>
    • Aktivieren Sie SSL für Ihre Anwendung.
      1. Fügen Sie Sicherheitsvorgaben hinzu, indem Sie die Datei "web.xml" wie zuvor beschrieben bearbeiten.
      2. Editieren Sie die Datei "web.xml" für die Anwendung, und fügen Sie das folgende Element innerhalb des Elements "security-constraint" hinzu:
        <user-data-constraint id="UserDataConstraint_1">
            <transport-guarantee>CONFIDENTIAL</transport-guarantee>
         </user-data-constraint>
        Wenn Sie SSL nicht verwenden möchten, können Sie diese Vorgabe überspringen oder den Wert CONFIDENTIAL durch NONE ersetzen.
    • Aktivieren Sie die Berechtigungsprüfung, um Ressourcen mit URL-Mustern zu schützen.
      1. Fügen Sie Sicherheitsvorgaben hinzu, indem Sie die Datei "web.xml" wie zuvor beschrieben bearbeiten.
      2. Editieren Sie die Datei "web.xml" für die Anwendung, und fügen Sie das folgende Element innerhalb des Elements "security-constraint" hinzu. Im folgenden Beispiel geben Role1 und Role2 an, dass die REST-Ressource /rest/addresses bzw. /rest/resources/{i} geschützt werden soll:
        <security-constraint id="SecurityConstraint_1">
            <web-resource-collection id="WebResourceCollection_1">
              <web-resource-name>AddressBookApp</web-resource-name>
              <description>Protection area for Rest Servlet</description>
              <url-pattern>/rest/addresses</url-pattern>
              <http-method>GET</http-method>
              <http-method>POST</http-method>
            </web-resource-collection>
            <auth-constraint id="AuthConstraint_1">
                 <description> Role1 for this rest resource </description>
                 <role-name>Role1</role-name>
              </auth-constraint>
        </security-constraint>
        
        <security-constraint id="SecurityConstraint_2">
            <web-resource-collection id="WebResourceCollection_2">
              <web-resource-name>AddressBookApp</web-resource-name>
              <description>Protection area for Rest Servlet</description>
              <url-pattern>/rest/addresses/*</url-pattern>
              <http-method>GET</http-method>
              <http-method>POST</http-method>
            </web-resource-collection>
            <auth-constraint id="AuthConstraint_2">
                 <description> Role2 for this rest resource </description>
                 <role-name>Role2</role-name>
              </auth-constraint>
        </security-constraint>

        In diesem Beispiel können auf die Ressource root-context/rest/addresses nur die Benutzer zugreifen, die Member von Role1 sind. Außerdem können auf die Ressource root-context/rest/addresses/{i} nur Benutzer zugreifen, die Member von Role2 sind.

        Fehler vermeiden Fehler vermeiden: Es ist wichtig, dass Sie in den Sicherheitsvorgaben, die Sie definieren, im Pfad der geschützten Ressourcen die Servlet-Zuordnung als Präfix angeben. Um eine Umgehung der Zugriffsprüfung zu verhindern, können Sie festlegen, dass das Servlet dem Pfad /* zugeordnet wird. Mit dieser Zuordnung schützen Sie alle Ressourcen unterhalb des Stammkontextes. gotcha
        Fügen Sie die Elemente der Rollendefinitionen in das Element <web-app> ein, um Ihre Rollen zu definieren. Beispiel:
        <security-role id="SecurityRole_1">
            <description>This is Role1</description>
            <role-name>Role1</role-name>
        </security-role>  
        <security-role id="SecurityRole_2">
            <description>This is Role2</description>
            <role-name>Role2</role-name>
        </security-role>  

        Die Änderungen, die Sie am Implementierungsdeskriptor vornehmen, werden automatisch von der Laufzeitumgebung des Anwendungsservers aufgenommen, und es ist nicht erforderlich, dass Sie die Anwendung auf dem Server erneut starten. Andere Änderungstypen, wie z. B. der Zuordnungs-URL, machen einen Neustart des Anwendungsservers erforderlich. Es wird empfohlen, die Anwendung erneut zu starten, um sicherzustellen, dass die Änderungen wirksam werden.

    • Programmgesteuerte Verwendung des annotierten Sicherheitskontextes.
      Anwendungsentwickler können die JAX-RS-Annotation "@SecurityContext" verwenden, um den Sicherheitskontext bis zur serverseitigen Ressource zu kaskadieren und die Definition von Sicherheitsattributen zur Laufzeit zu ermöglichen. Die Schnittstelle "SecurityContext" bietet folgende Funktion:
      public String getAuthenticationScheme()
      public Principal getUserPrincipal()
      public boolean isUserInRole(String role)
      Das folgende Beispiel veranschaulicht die Schnittstelle "SecurityContext":
      package com.test;
      
      import javax.ws.rs.GET; 
      import javax.ws.rs.Consumes;
      import javax.ws.rs.POST;
      import javax.ws.rs.Path;
      import javax.ws.rs.PathParam;
      import javax.ws.rs.Produces;
      import javax.ws.rs.ext.*;
      import javax.ws.rs.core.SecurityContext;
      import javax.ws.rs.core.Context;
      
      /**   
       * Eine Beispielressource, die den Zugriff auf ein Adressbuch ermöglicht.
       * 
       */
      @Path(value="/addresses")
      public class AddressBookResource {
      	
      		@Context private SecurityContext securityContext;
          
          private static String[] list = new String[] {
              "Michael",
              "Ron",
              "Jane",
              "Sam"
          };
          
          @GET
          @Produces(value="text/plain")
          public String getList() {
             // Verwendetes Authentifizierungsschema abrufen (z. B. BASIC)
             String authnScheme = securityContext.getAuthenticationScheme());
             // Namen des Principal abrufen, der die Ressource aufgerufen hat
             String username = securityContext.getUserPrincipal().getName());
             // Prüfen, ob der aktuelle Benutzer Member von Role1 ist
              Boolean isUserInRole = securityContext.isUserInRole(“Role1”);
          	 
              StringBuffer buffer = new StringBuffer();
              buffer.append("{");
              for (int i = 0; i < list.length; ++i) {
                  if (i != 0) 
                      buffer.append(", ");
                  buffer.append(list[i]);
              }
              buffer.append("}");
              
              return buffer.toString();
          }
      }
    • Sicherheitsclienthandler für HTTP-Basisauthentifizierung verwenden
      Sie können den Sicherheitclienthandler verwenden, um die HTTP-Basisauthentifizierung mit einer sicheren JAX-RS-Ressource durchzuführen. Im folgenden Beispiel wird ein einfaches Programmiermodell vorgestellt, mit dem diese Task ausgeführt wird:
      /**
       * Dieser Ausschnitt veranschaulicht die Verwendung des JAX-RS-SecurityHandler durch
       * einen Client zur Durchführung einer HTTP-Basisauthentifizierung mit einem Zielservice.
       */ 
       
       import org.apache.wink.client.ClientConfig;
       import org.apache.wink.client.Resource;
       import org.apache.wink.client.RestClient;
       import org.apache.wink.client.handlers.BasicAuthSecurityHandler;
      
       ClientConfig config = new ClientConfig();
        BasicAuthSecurityHandler secHandler = new    
       BasicAuthSecurityHandler();
      
       // Benutzerberechtigungsnachweis definieren.
       secHandler.setUsername("user1");
       secHandler.setPassword("security");
      
       // Diesen Sicherheitshandler der Handlerkette hinzufügen.
       config.handlers(secHandler);
      
       // Die REST-Clientinstanz erstellen.
       RestClient client = new RestClient(config);
      
       // Die Ressourceninstanz erstellen, die mit dem Ersatz für
       // die Ressourcenadresse interagieren soll.
       resource =  
        client.resource("http://localhost:8080/path/to/resource");
      
      // Die Ressource kann jetzt aufgerufen werden. 
      Wenn Sie die Klasse BasicAuthSecurityHandler verwenden, müssen Sie sicherstellen, dass Sie die Zielressourcen für Ihre URLs mit dem HTTPS-Schema angeben und dass die Zielanwendung SSL unterstützt. Es wird dringend empfohlen, für das Senden von Benutzerberechtigungsnachweisen SSL-Verbindungen zu verwenden. Sie können die Voraussetzung für SSL in der Klasse BasicAuthSecurityHandler explizit inaktivieren, indem Sie die Methode setSSLRequired im Sicherheitshandler mit dem Wert false aufrufen. Die Standardeinstellung für diese Methode ist true.
      secHandler.setSSLRequired(false);
      Sie haben auch die Möglichkeit, die Benutzerberechtigung wie folgt in der Java™-Befehlszeile für Ihren Client anzugeben:
      java -Duser=Testbenutzer -Dpassword=Kennwort  Clientprogramm
      Sie können die Benutzerberechtigungen aus einer Eigenschaftendatei abrufen, deren Position Sie wie folgt über die Java-Befehlszeile angeben:
      java -Dclientpropsdir=Verzeichnis_für_Eigenschaftendatei  Clientprogramm
      Für diese Angaben gilt Folgendes: Das Verzeichnis_für_Eigenschaftendatei enthält die Datei "wink.client.props", in der die Eigenschaften Benutzer und Kennwort definiert sind.

Ergebnisse

Nachdem Sie Sicherheitsvorgaben definiert haben, ist der Zugriff auf die REST-Ressourcen, die in Ihrer Anwendung definiert sind, nur nach einer erfolgreichen Benutzerauthentifizierung möglich. Außerdem haben Sie Rollenvorgaben für verschiedene Ressourcen-URL-Muster angewendet, um einen rollenbasierten Zugriff auf diese Ressourcen zu ermöglichen.

Beispiel

Das folgende Beispiel veranschaulicht den Implementierungsdeskriptor "web.xml" für die Beispielanwendung "AddressBookApp", in der Sicherheitsvorgaben mit den oben beschriebenen Prozedurschritten definiert werden:
<web-app id="WebApp_1255468655347">
    <display-name>Sample REST Web Application</display-name>
    <servlet>
        <servlet-name>AddressBookApp</servlet-name>
        <servlet-class>com.ibm.websphere.jaxrs.server.IBMRestServlet</servlet-class>
        <init-param>
            <param-name>javax.ws.rs.Application</param-name>
            <param-value>com.test.AddressBookApplication</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
      </servlet>    <servlet-mapping>
        <servlet-name>AddressBookApp</servlet-name>
        <url-pattern>/rest/*</url-pattern>
    </servlet-mapping>
    <security-constraint id="SecurityConstraint_1">
      <web-resource-collection id="WebResourceCollection_1">
        <web-resource-name>AddressBookApp</web-resource-name>
        <description>Protection area for Rest Servlet</description>
        <url-pattern>/rest/addresses</url-pattern>
        <http-method>GET</http-method>
        <http-method>POST</http-method>
      </web-resource-collection>
      <auth-constraint id="AuthConstraint_1">
         <description>Role1 for this rest servlet</description>
         <role-name>Role1</role-name>
      </auth-constraint>
      <user-data-constraint id="UserDataConstraint_1">
            <transport-guarantee>CONFIDENTIAL</transport-guarantee>
      </user-data-constraint>
    </security-constraint>
    <security-constraint id="SecurityConstraint_2">
      <web-resource-collection id="WebResourceCollection_2">
        <web-resource-name>AddressBookApp</web-resource-name>
        <description>Protection area for Rest Servlet</description>
        <url-pattern>/rest/addresses/*</url-pattern>
        <http-method>GET</http-method>
        <http-method>POST</http-method>
      </web-resource-collection>
      <auth-constraint id="AuthConstraint_2">
         <description>Role2 for this rest servlet</description>
         <role-name>Role2</role-name>
      </auth-constraint>
      <user-data-constraint id="UserDataConstraint_1">
            <transport-guarantee>CONFIDENTIAL</transport-guarantee>
      </user-data-constraint>
    </security-constraint>
    <security-role id="SecurityRole_1">
         <description>This is Role1</description>
         <role-name>Role1</role-name>
    </security-role>  
    <security-role id="SecurityRole_2">
         <description>This is Role2</description>
         <role-name>Role2</role-name>
    </security-role>  
    <login-config>
      <auth-method>FORM</auth-method>
      <form-login-config>
         <form-login-page>/logon.jsp</form-login-page>
         <form-error-page>/logonError.jsp</form-error-page>
      </form-login-config>
    </login-config>
</web-app>

Nächste Schritte

Verwalten Sie die Sicherheit für Ihre JAX-RS-Anwendung über die Administrationskonsole.


Symbol, das den Typ des Artikels anzeigt. Taskartikel



Symbol für Zeitmarke Letzte Aktualisierung: 25.05.2016
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=twbs_jaxrs_impl_securejaxrs_webcont
Dateiname:twbs_jaxrs_impl_securejaxrs_webcont.html