Monday, May 27, 2013

Insert code into your Blogger posts

Programmers know that blogger doesn't support code insertion (usefull if you need to demonstrate how to program something by copy/pasting code samples). Thus, you need to swicth  Blogger's editor to HTML and paste HTMLized text.

The nicest solution I found to format your code to HTML is to use this online code formatter : http://hilite.me/

So, let's show an example:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.horstmann.violet</groupId>
 <artifactId>parent</artifactId>
 <name>Violet UML Editor Parent Maven Project</name>
 <version>1.0.0</version>
 <packaging>pom</packaging>
 <modules>
     <module>violet-framework</module>
     <module>violetplugin-activitydiagram</module>
     <module>violetplugin-classdiagram</module>
     <module>violetplugin-objectdiagram</module>
     <module>violetplugin-sequencediagram</module>
     <module>violetplugin-statediagram</module>
     <module>violetplugin-usecasediagram</module>
     <module>violetproduct-swing</module>
     <module>violetdistrib-rpm</module>
 </modules>
 <properties>
     <applicationVersion>2.0.0-SNAPSHOT</applicationVersion>
   </properties>
 <build>
  <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.gif</include>
                    <include>**/*.jpg</include>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
  <pluginManagement>
         <plugins>
             <plugin>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>2.0.2</version>
                 <configuration>
                     <source>1.6</source>
                     <target>1.6</target>
                 </configuration>
             </plugin>
         </plugins>
  </pluginManagement>
 </build>


 <distributionManagement>
  <repository>
   <id>web.sourceforge.net</id>
   <name>Violet's Maven Repository</name>
   <url>
                sftp://web.sourceforge.net/home/groups/v/vi/violet/htdocs/maven2/repo
            </url>
  </repository>
 </distributionManagement>
 <repositories>
  <repository>
   <id>violet.repo</id>
   <name>Violet's Maven repository (public access)</name>
   <url>http://violet.sourceforge.net/maven2/repo/
            </url>
  </repository>
 </repositories>
</project>

So nice!

Wednesday, May 22, 2013

How to secure REST services exposed with Jersey (JAX-RS) using Spring Security

This is the challenge I had to perform. I have to open services to business partners and I want to secure them. I use a Java based application with Jersey API (JAX-RS).

The first thing to consider is : what kind of solution offers the best compromise between security and the effort I'll have to provide to maintain this solution?
After some discussions with developers and experts, the conclusion is : expose your services over https and use Basic authentication (Digest authentication and certificate based authentication are too complex for partners)

So, how to implement that? I delegate "https" to my Apache http servers. But I still need to handle authentication (and authorization of course). After long hours on Google, I understood that it is possible to manage security with Jersey by many many ways. Here is a short list :

  1. Delegate simple authentication and authorization to your container (Tomcat) or to your frontend (Apache)
  2. Delegate authentication to your container or frontend and let Jersey manage authorization with JSR-250 annotations such as @PermitAll, @DenyAll, @RolesAllowed written on methods. (For example : http://www.butonic.de/2010/06/18/a-simple-jax-rs-security-context-example-in-glassfish/)
  3. Be agnostic from any container  and let your "Jersey-based" application take in charge authentication and authorization by implementing your own ContainerRequestFilter. You can read these two excellents posts : http://simplapi.wordpress.com/2013/01/24/jersey-jax-rs-implements-a-http-basic-auth-decoder/ and http://anismiles.wordpress.com/2012/03/02/securing-versioning-and-auditing-rest-jax-rs-jersey-apis
  4. Be agnostic from any container like the solution 3 but let Spring Security manage authentication and authorization.
Of course, I choose the solution 4. With this solution, I didn't have to filter any URL (like I commonly do when I configure Spring Security with "url-interceptor"). I  let all URLs opened to anonymous user BUT I told Spring Security to filter method calls. As Jersey maps one service to one method, I  obtained what I needed : security over Jersey services.

Here are the stepsto implements that :
  1. Update your maven configuration (optional)
  2. Add a servlet filter to enable Spring Security (web.xml)
  3. Update my Spring configuration (dedicated applicationContext-security.xml file)
  4. Add annotation on methods I want to secure (Java code)
Dependencies to add to the pom.xml

 <!-- SECURITY (start) -->
 <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.2</version>
        </dependency>
 <!-- SECURITY (end) -->



In the web.xml :

    <!-- Filter to secure Jersey (JAX-RS) services -->
    <filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class>
            org.springframework.web.filter.DelegatingFilterProxy
        </filter-class>
    </filter>
    <filter-mapping>
        <filter-name>springSecurityFilterChain</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping> 

The applicationContext-security.xml file :

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:security="http://www.springframework.org/schema/security"
 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-3.1.xsd">

 <!-- To allow public access by default and to set authentication mode to basic login/password -->
 <security:http>
  <security:anonymous enabled="true" />
  <security:http-basic />
 </security:http>

 <!-- To delegate authorization to method calls rather than to urls -->
 <!-- (Thus, we don't need to set any url-interceptor in this conf) -->
 <security:global-method-security pre-post-annotations="enabled" />
 
 <!-- To create user/password with roles -->
 <security:authentication-manager alias="authenticationManager">
  <security:authentication-provider>
   <security:user-service>
    <security:user authorities="ROLE_DUMMY
name="user1" password="strongpassword1" />
   </security:user-service>
  </security:authentication-provider>
 </security:authentication-manager>
</beans>

A Java method exposed as REST service with Jersey

@Component
@Path("/userinfo")
public class UserInfoService {
 
@Autowired
private UserInfoDao dao;
 
@GET @Path("{userid}")
@Produces({MediaType.TEXT_XML})
@PreAuthorize("hasRole('ROLE_DUMMY')")
public UserInfo findUserInfoByCode(@PathParam("userid") String userid) {
  return dao.getUserInfo(userid);
}
...



If I want to expose a service to anonymous users, I just have to change @PreAuthorize("hasRole('ROLE_DUMMY')") to @PreAuthorize("permitAll") or simply remove the annotation.


That's all! Of course, Spring saved my day once again...


A good presentation about Spring Security