When Java first hit the market in the 1990s, the most prominent feature of its security architecture was the so called sandbox: A Java applet downloaded from the Internet could not access local files etc. unless the user explicitly granted permission to do so. A Java application loaded from the local disk, however, had unrestricted access to all resources.
Almost a decade later, this coarse approach has evolved into an architecture that provides much more fine-grained control at the cost of a considerably higher complexity. "Inside Java 2 Platform Security, Second Edition" promises a comprehensive overview of the Java security architecture and to teach its readers "everything they need to protect their information assets" [cover text]. While the book certainly does not leave many security related aspects of Java uncovered, it fails to live up to its latter promise.
Two of the authors were at some point responsible for the design and implementation of the security components of the Java platform. They have a lot of inside knowledge about the design decisions to share and also point out compromises made and interfaces that are likely to be revised. The necessary background is provided by a lot of references to relevant standards, research papers, and textbooks.
But most of the time, the description stays too abstract. The text explains permission classes, security managers and so on in detail and it probably mentions all customization hooks there are - but it fails to demonstrate on a concrete example how to make use of all these interfaces. This may not be a severe shortcoming with respect to the coverage of the cryptography APIs (JCA/JCE) and the secure networking APIs (JSSE and Java GSS-API). These APIs can serve a purpose that almost every security conscious developer will have learned about when using the Internet, e.g. secure log-on, SSL, or signed email. Hence, most readers can easily imagine use cases.
But its not that easy to come up with a use case where you have a compelling reason to install, e.g., your own class loader. Therefore, I missed that the authors outline a scenario that justifies modification of such fundamental parts of the runtime environment and use it to exhibit the interaction of all parts of Java's security architecture as well as potential security holes that must be avoided.
The chapter on deploying the Java security architecture is bound to Sun's Java implementation, but it offers much more examples than the chapters before. If you have to install your own Cryptographic Service Provider, for example, then this chapter shows you which configuration files need to be modified. All of this can be found somewhere in Sun's Java SDK documentation on the web, of course, but it is quite convenient to have this information subsumed in a book.
This book offers an extensive in-depth reference of Java's security aspects for developers who are already familiar with the pitfalls of IT-security. But it is not a first choice if you are looking for a tutorial on how to develop secure Java applications.