Shiro vs. SpringSecurity [geschlossen]

Ich habe derzeit Java-basierte Sicherheits-Frameworks evaluiert. Ich bin ein Spring 3.0-Benutzer, daher schien SpringSecurity die richtige Wahl zu sein, aber Spring-Sicherheit scheint unter übermäßiger Komplexität zu leiden. Es scheint sicherlich nicht, dass es die Implementierung der Sicherheit erleichtert. Shiro scheint viel kohärenter und leichter zu verstehen zu sein. Ich suche nach Listen mit Vor- und Nachteilen zwischen diesen beiden Frameworks.

Ich stimme auch zu, dass sich Spring Security (für mich) zu kompliziert anfühlt. Sicher, sie haben Dinge getan, um die Komplexität zu reduzieren, wie das Erstellen von benutzerdefinierten XML-Namespaces, um die Menge der XML-Konfiguration zu reduzieren, aber für mich geht dies nicht auf mein persönliches grundlegendes Problem mit Spring Security ein: Die Namen und Konzepte sind im Allgemeinen oft verwirrend mich. Es ist schwer, es einfach zu bekommen.

Sobald Sie Shiro verwenden, bekommen Sie es einfach. Was in der Sicherheitswelt schwer zu verstehen war, ist viel einfacher zu verstehen. Dinge, die im JDK unerträglich schwer zu verwenden sind (z. B. Chiffren), werden auf ein Niveau vereinfacht, das nicht nur erträglich, sondern oft auch eine Freude ist.

Wie können Sie beispielsweise ein Kennwort hashen + salzen und base64 in Java oder Spring Security codieren? Weder sind so einfach und intuitiv wie Shiros Lösung:

ByteSource salt = new SecureRandomNumberGenerator().nextBytes();
new Sha512Hash(password, salt).toBase64();

Kein Commons-Codec oder sonst etwas nötig. Nur das Shiro-Glas.

In Bezug auf Spring-Umgebungen verwenden die meisten Shiro-Entwickler Spring als primäre Anwendungsumgebung. Das bedeutet, dass Shiros Spring-Integration hervorragend ist und alles außergewöhnlich gut funktioniert. Sie können sicher sein, dass Sie beim Schreiben einer Spring-App ein umfassendes Sicherheitserlebnis haben.

Betrachten Sie beispielsweise das Spring XML-Konfigurationsbeispiel in einem anderen Beitrag in diesem Thread. So würden Sie (im Wesentlichen) dasselbe in Shiro tun:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd>

<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
    <property name="securityManager" ref="securityManager"/>
    <property name="loginUrl" value="/login.jsp"/>
    <property name="successUrl" value="/home.jsp"/>
    <property name="unauthorizedUrl" value="/unauthorized.jsp"/>
    <property name="filterChainDefinitions">
        <value>
        /secure/** = authc
        /** = anon
        </value>
    </property>
</bean>

<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
    <property name="realm" ref="myRealm"/>
</bean>

<bean id="myRealm" class="...">
    ...
</bean>

Obwohl etwas ausführlicher als das andere Spring-Beispiel, ist es einfacher, IMO zu lesen.

Sie werden auch feststellen, dass die Verwendung von Shiros Filterkettendefinitionen wahrscheinlich der einfachste Weg ist, allgemeine Filterketten und webbasierte Sicherheitsregeln zu definieren! Viel schöner als sie in web.xml zu definieren.

Schließlich bietet Shiro auch extreme Steckbarkeit. Sie werden sehen, dass Sie dank Shiros POJO / Injection-freundlicher Architektur fast alles konfigurieren und / oder ersetzen können. Shiro setzt fast alles standardmäßig auf vernünftige Standardeinstellungen und Sie können nur das überschreiben oder konfigurieren, was Sie benötigen.

Letztendlich denke ich, dass die Wahl eines dieser beiden Modelle mehr von Ihrem mentalen Modell abhängt - welches der beiden Modelle ist sinnvoller und für Sie intuitiver? Für einige wird es Shiro sein, für andere wird es Spring Security sein. Shiro funktioniert hervorragend in Frühlingsumgebungen, daher würde ich sagen, wählen Sie basierend darauf, welche der beiden Sie mehr genießen und was für Sie am sinnvollsten ist.

Weitere Informationen zur Spring-Integration von Shiro: http://shiro.apache.org/spring.html

Ich habe keine Erfahrung mit Shiro und stimme "teilweise" dem zu, was Sie über Spring Security gesagt haben. Vor Spring Security 3.x war die Einrichtung von Spring Security (oder Acegi) sehr schmerzhaft. Eine einfache rollenbasierte Konfiguration benötigt mindestens 140 Zeilen kryptischer XML-Konfiguration ... Ich weiß das, weil ich die Zeilen selbst gezählt habe. Es war etwas, das Sie einmal eingerichtet haben, und Sie beten, dass es für immer funktioniert, ohne dass Sie die Konfiguration erneut berühren, weil Sie sicher sein können, dass Sie vergessen haben, was die gesamte Konfiguration bedeutet. :) :)

Mit Spring Security 3.x wurde es enorm verbessert. Es wird ein securityNamespace eingeführt , der die Konfiguration drastisch von 140 Zeilen auf ~ 30 Zeilen verkürzt. Hier ist ein Beispiel für Spring Security 3.x eines meiner Projekte: -

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:security="http://www.springframework.org/schema/security" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security.xsd">

    <security:http auto-config="true">
        <security:form-login login-page="/index.do" authentication-failure-url="/index.do?login_error=1" default-target-url="/index.do"
            always-use-default-target="true" />
        <security:logout logout-success-url="/index.do" />
        <security:intercept-url pattern="/secure/**" access="ROLE_ADMIN,ROLE_USER" />
        <security:intercept-url pattern="/**" access="IS_AUTHENTICATED_ANONYMOUSLY" />
    </security:http>

    <bean id="customAuthenticationProvider" class="my.project.CustomAuthenticationProviderImpl">
        ...
    </bean>

    <security:authentication-manager>
        <security:authentication-provider ref="customAuthenticationProvider" />
    </security:authentication-manager>

</beans>

Das Schöne an Spring Security 3.x ist, dass es extrem konfigurierbar ist, was zu einem der Hauptnachteile beiträgt: zu kompliziert, um es zu verstehen. Die Dokumentation ist auch nicht leicht zu lesen, da ich mit einigen der verwendeten Begriffe von Spring Security nur teilweise vertraut bin. Die Optionen stehen jedoch zur Verfügung, wenn Sie Ihre benutzerdefinierte Konfiguration erstellen oder steuern müssen, wie detailliert Ihre Sicherheit sein soll. Sie können sich auch an die obigen <30 Zeilen halten, um eine rollenbasierte Sicherheitsüberprüfung durchzuführen.

Was ich an Spring Security wirklich mag, ist, dass die Sicherheit nach dem Einrichten nahtlos in das Projekt integriert wird. Es ist, als ob der eigentliche Projektcode die Existenz der Sicherheit nicht kennt ... und das ist gut so, weil ich damit die Sicherheitskomponente in Zukunft problemlos trennen oder aktualisieren kann (z. B. Datenbankauthentifizierung in LDAP / CAS ändern) auth).

Ich habe Spring Security (Version 3.1) seit einigen Monaten verwendet und war ziemlich zufrieden damit. Es ist wirklich mächtig und hat einige sehr schöne Funktionen, besonders nachdem ich alles von Hand implementiert habe, wie ich es zuvor getan habe! Es war jedoch, wie ich irgendwo gelesen habe, etwas, das Sie einmal zu Beginn der Entwicklung der App eingerichtet haben und dann beten, dass es bis zum Ende weiterarbeitet, denn wenn Sie es reparieren müssen, werden Sie es tun Wahrscheinlich haben Sie die meisten Dinge vergessen, die Sie parametrieren mussten.

Aber dann kam ein neues Projekt mit komplexeren Sicherheitsanforderungen. Kurz gesagt, wir mussten eine Art benutzerdefiniertes SSO zwischen einigen verwandten Webanwendungen implementieren.

Ich wusste genau, was ich in Bezug auf HTTP-Logik, Cookies, Sitzungs-IDs und so weiter erreichen wollte und was in welcher Reihenfolge passieren sollte, aber ich verbrachte den größten Teil eines Tages damit, mit den Spring Security-APIs zu kämpfen, und konnte es immer noch nicht herausfinden Finden Sie heraus, welche Klasse oder Schnittstelle ich implementieren oder überschreiben soll und wie Sie sie in den Kontext einfügen. Die gesamte API fühlte sich sehr komplex und manchmal etwas esoterisch an. Und obwohl das Dokument für die allgemeinen Anwendungsfälle und sogar für einige Anpassungen recht gut ist, ging es nicht tief genug, um meine Anforderungen zu erfüllen.

Nachdem ich die Antworten hier und an einigen anderen Stellen im Internet gelesen hatte, hatte ich den Eindruck, dass Shiro leichter zu verstehen und an meine Bedürfnisse anzupassen wäre. Also habe ich es versucht.

Und ich bin froh, dass ich das getan habe, denn nach einem Tag Arbeit habe ich genug über die APIs gelernt, um nicht nur ein grundlegendes Authentifizierungs- und Autorisierungssystem in meiner Spring-Webanwendung einzurichten, sondern auch das benutzerdefinierte SSO-Verhalten zu implementieren, das ich war Auf der Suche nach. Ich musste nur 2 oder 3 Klassen erweitern, und das Ganze dauerte in meinem Frühlingskontext nur etwa 25 Zeilen XML-Konfiguration.

Zusammenfassend lässt sich sagen, dass Shiro in Bezug auf die Benutzerfreundlichkeit und die Aspekte der Lernkurve sehr sympathisch ist, und ich denke, ich werde es wahrscheinlich in Zukunft tun, es sei denn, ich stoße auf fehlende Funktionen oder ein anderes Problem (das ich nicht habe) bisher).

TL; DR: Beide sind mächtig, aber Shiro ist viel einfacher zu lernen.