AppPerfect

Java Security 

Rules available in this category:

1. Reduce_scope_of_public_or_protected_methods
2. Reduce_scope_of_package_private_methods
3. Reduce_scope_of_public_or_protected_classes
4. Reduce_scope_of_package_private_classes
5. Reduce_scope_of_public_or_protected_fields
6. Reduce_scope_of_package_private_fields
7. Avoid_passing_byte_array_to_writeObject
8. Inspect_usage_of_random_methods
9. Inspect_usage_dynamically_created_strings_in_execute_executeQuery_executeUpdate_or_addBatch_methods
10. Always_ensure_Security_Manager_is_set
11. Inspect_usage_of_dynamically_created_strings_in_exec_method
12. Avoid_overriding_any_ClassLoader_method_other_than_loadClass
13. Always_ensure_all_exceptions_are_logged_or_rethrown
14. Inspect_fields_of_serializable_objects
15. Avoid_creating_your_own_SecurityManager
16. Inspect_instantiations_of_ClassLoader_objects
17. Inspect_usage_of_getName_method_of_Class_object
18. Avoid_calling_printStackTrace_method_of_Throwable_objects
19. Always_declare_readObject_and_writeObject_as_private
20. Avoid_comparing_classes_by_name
21. Make_classes_non_serializable
22. Inspect_package_scope_access
23. Always_implement_readObject_for_serializable_class
24. Make_classes_non_deserializable
25. Avoid_collection_type_fields_in_public_interface
26. Avoid_array_type_fields_in_public_interface
27. Make_classes_non_cloneable
28. Clone_method_should_throw_CloneNotSupportedException
29. Always_use_final_modifier_for_Clone_method
30. Avoid_protected_member_in_final_class
31. Avoid_using_inner_classes
32. Avoid_public_access_for_inner_classes

Rule 1: Reduce_scope_of_public_or_protected_methods

Severity:  Low
Rule:  Avoid granting more access than is required.
Reason:  Avoid granting more access than is required.

Usage Example: 

public class Test
{
	public int getSize() // VIOLATION
	{
		return 3;
	}

	public void fubar()
	{
		int size = getSize();
	}
}

Should be written as:

public class Test
{
	private int getSize()
	{
		return 3;
	}

	public void fubar()
	{
		int size = getSize();
	}
}

Reference:  Not available.

Rule 2: Reduce_scope_of_package_private_methods

Severity:  Low
Rule:  Avoid granting more access than is required.
Reason:  Avoid granting more access than is required.

Usage Example: 

package myPackage;

public class Test
{
	int getSize() // VIOLATION
	{
		return 3;
	}

	public void fubar()
	{
		int size = getSize();
	}
}

Should be written as:

package myPackage;

public class Test
{
	private int getSize() // FIXED
	{
		return 3;
	}

	public void fubar()
	{
		int size = getSize();
	}
}

Reference:  Not available.

Rule 3: Reduce_scope_of_public_or_protected_classes

Severity:  Low
Rule:  Avoid granting more access than is required.
Reason:  Avoid granting more access than is required.

Usage Example: 

public class MyClass 	// VIOLATION
{
	//...
}

class Test
{
	public MyClass instance = new MyClass();
}

Should be written as:

class MyClass 	// FIXED
{
	//...
}

class Test
{
	public MyClass instance = new MyClass();
}

Reference:  Not available.

Rule 4: Reduce_scope_of_package_private_classes

Severity:  Low
Rule:  Avoid granting more access than is required.
Reason:  Avoid granting more access than is required.

Usage Example: 

package myPackage;

public class Test
{
	class SomeClass				 // VIOLATION
	{
		public void performAction()
		{
			//....
		}
	}
	
	class AnotherInner
	{
		public void fubar()
		{
			SomeClass class1 = new SomeClass();
			class1.performAction();
		}
	}
}

Should be written as:

package myPackage;

public class Test
{
	private class SomeClass				 // FIXED
	{
		public void performAction()
		{
			//....
		}
	}
	
	class AnotherInner
	{
		public void fubar()
		{
			SomeClass class1 = new SomeClass();
			class1.performAction();
		}
	}
}

Reference:  Not available.

Rule 5: Reduce_scope_of_public_or_protected_fields

Severity:  Low
Rule:  Avoid granting more access than is required.
Reason:  Avoid granting more access than is required.

Usage Example: 

public class Test
{
	public int myField;			  // VIOLATION
	protected int anotherField; // VIOLATION

	public void setMyField(int i)
	{
		myField = i;	
	}

	public void setAnotherField(int i)
	{
		anotherField = i;
	}
}

Should be written as:

public class Test
{
	private int myField;			  // FIXED
	private int anotherField; // FIXED

	public void setMyField(int i)
	{
		myField = i;	
	}

	public void setAnotherField(int i)
	{
		anotherField = i;
	}
}

Reference:  Not available.

Rule 6: Reduce_scope_of_package_private_fields

Severity:  Low
Rule:  Avoid granting more access than is required.
Reason:  Avoid granting more access than is required.

Usage Example: 

public class Test
{
	int myField;			  // VIOLATION
	
	public void setMyField(int i)
	{
		myField = i;	
	}

	
}

Should be written as:

public class Test
{
	private int myField;			  // FIXED
	
	public void setMyField(int i)
	{
		myField = i;	
	}

	
}

Reference:  Not available.

Rule 7: Avoid_passing_byte_array_to_writeObject

Severity:  Medium
Rule:  Do not pass class fields of type byte array to ObjectOutputStream.write().
Reason:  Do not pass class fields of type byte array to ObjectOutputStream.write().

Usage Example: 

package com.rule;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Avoid_passing_byte_array_to_ObjectOutputStream_write_method_violation implements Serializable
{
	private byte[] data;
	
	private void writeObject(ObjectOutputStream out) throws IOException
	{
		out.write(data);	// VIOLATION
		byte[] tmp = new byte[0];
		out.write(tmp);
	}
}

Should be written as:

package com.rule;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Avoid_passing_byte_array_to_ObjectOutputStream_write_method_correction implements Serializable
{
	private byte[] data;
	
	private void writeObject(ObjectOutputStream out) throws IOException
	{
		out.write((byte[])data.clone());
		byte[] tmp = new byte[0];
		out.write(tmp);
	}
}

Reference:  Reference Not Available.

Rule 8: Inspect_usage_of_random_methods

Severity:  Low
Rule:  Inspect Random objects or Math.random methods that could indicate areas where malicious code has been placed.
Reason:  Inspect Random objects or Math.random methods that could indicate areas where malicious code has been placed.

Usage Example: 

public class Test
{
	public static String fubar() 
	{
		String s = "";
		for (int k = 0; k < 6; ++k)
		{
			s += (char)(Math.random() * 26 + 'A'); // VIOLATION
		}
		return s + "+";
	}
}

Should be written as:

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

public class Test
{
	public static String fubar() 
	{
		String s = "";
		SecureRandom prng = null;
		try 
		{
			prng = SecureRandom.getInstance("SHA1PRNG");
		} 
		catch (NoSuchAlgorithmException e) 
		{
			e.printStackTrace();
		}
		if(prng != null)
		{
			for (int k = 0; k < 6; ++k)
			{
				s += (char)(prng.nextDouble() * 26 + 'A'); // VIOLATION
			}
		}
		return s + "+";
	}
}

Reference:  http://java.sun.com/j2se/1.4.2/docs/api/java/security/SecureRandom.html

Rule 9: Inspect_usage_dynamically_created_strings_in_execute_executeQuery_executeUpdate_or_addBatch_methods

Severity:  Low
Rule:  Dynamically created strings passed to these methods could modify the database in an undesired manner.
Reason:  Dynamically created strings passed to these methods could modify the database in an undesired manner.

Usage Example: 

public class Test
{
	public void killMyDatabase(Connection con, String query)
	{
		if(con != null)
		{
			Statement stmt = con.createStatement();
			ResultSet = statement.executeQuery(query); // VIOLATION
			//...
		}	
	}	
}

Should be written as:

Investigate to ensure proper validation is present or any invocations to this method do not pass strings which could contain malicious code.

Reference:  Not available.

Rule 10: Always_ensure_Security_Manager_is_set

Severity:  Low
Rule:  The security manager is a class that allows applications to implement a security policy.
Reason:  The security manager is a class that allows applications to implement a security policy.

Usage Example: 

public class Test
{
	public static void main(String[] args) // VIOLATION
	{
		//...
	}
}

Should be written as:

public class Test
{
	public static void main(String[] args)
	{
		SecurityManager security = System.getSecurityManager(); // FIXED
		if (security != null) 
		{
			security.checkXXX(argument,  . . . );
		}
		//...
	}
}

Reference:  http://java.sun.com/j2se/1.4.2/docs/api/java/lang/SecurityManager.html

Rule 11: Inspect_usage_of_dynamically_created_strings_in_exec_method

Severity:  Low
Rule:  Dynamically created strings passed to the exec method could execute a command which might violate security on the host machine.
Reason:  Dynamically created strings passed to the exec method could execute a command which might violate security on the host machine.

Usage Example: 

public class Test
{
	public void fubar(String deadlyCommand)
	{
		Runtime.getRuntime().exec(deadlyCommand); // VIOLATION
		Runtime.getRuntime().exec(new String[]{deadlyCommand}); // VIOLATION
	}
}

Should be written as:

Investigate to ensure proper validation is present or any invocations to this method do not pass strings which could contain malicious code.

Reference:  Not available.

Rule 12: Avoid_overriding_any_ClassLoader_method_other_than_loadClass

Severity:  Low
Rule:  loadClass method is usually enough to do the job and overriding other methods might introduce certain security loopholes.
Reason:  loadClass method is usually enough to do the job and overriding other methods might introduce certain security loopholes.

Usage Example: 

package myPackage;

public class Test extends ClassLoader
{
	/* (non-Javadoc)
	 * @see java.lang.ClassLoader#clearAssertionStatus()
	 */
	public synchronized void clearAssertionStatus()  // VIOLATION
	{
		//...
	}
	
	
	public void fubar()
	{
		//...	
	}
}

class myClassLoader extends Test
{
	/* (non-Javadoc)
	 * @see myPackage.Test#fubar()
	 */
	public void fubar()  // VIOLATION
	{
		//...
	}
	
	/* (non-Javadoc)
	 * @see java.lang.ClassLoader#loadClass(java.lang.String)
	 */
	public Class loadClass(String arg0) throws ClassNotFoundException 
	{
		//...
		return super.loadClass(arg0);
	}
	
}

Should be written as:

Reference:  http://www.securingjava.com/chapter-two/chapter-two-7.html

Rule 13: Always_ensure_all_exceptions_are_logged_or_rethrown

Severity:  Low
Rule:  Loggers are configurable and flexible, and basically one can decide which level of severity it wants to report/act on, on a package-by-package basis.
Reason:  Loggers are configurable and flexible, and basically one can decide which level of severity it wants to report/act on, on a package-by-package basis.

Usage Example: 

public class Test
{
	public void fubar()
	{
		try
		{
			//...
		}
		catch(NoSuchMethodException e)	 // VIOLATION
		{
			e.printStackTrace();
		}
	}
}

Should be written as:

public class Test
{
	public void fubar()
	{
		try
		{
			//...
		}
		catch (NoSuchMethodException e)  // FIXED
		{
			LOG.error("Blah", e); 
		}
	}
}

Reference:  http://today.java.net/pub/a/today/2006/04/06/exception-handling-antipatterns.html

Rule 14: Inspect_fields_of_serializable_objects

Severity:  Low
Rule:  Inspect fields of serializable objects to make sure they do not expose any sensitive information.
Reason:  Inspect fields of serializable objects to make sure they do not expose any sensitive information.

Usage Example: 

import java.io.*;

public class Test implements Serializable 
{
	protected int myKey = 3235; // VIOLATION
	//...
}

Should be written as:

Inspect field to check if it does not disclose any sensitive information.

Reference:  Not available.

Rule 15: Avoid_creating_your_own_SecurityManager

Severity:  Medium
Rule:  For many applications, the default security manager is sufficient since a custom security manager could have certain loopholes and basically require investigation.
Reason:  For many applications, the default security manager is sufficient since a custom security manager could have certain loopholes and basically require investigation.

Usage Example: 

class FascistSecurityManager extends SecurityManager // VIOLATION	
{
	// ...
}

Should be written as:

Investigate for any possible loopholes.

Reference:  Not available.

Rule 16: Inspect_instantiations_of_ClassLoader_objects

Severity:  Low
Rule:  ClassLoader could be used to load an arbitrary class and call an arbitrary method which could be a possible security thread.
Reason:  ClassLoader could be used to load an arbitrary class and call an arbitrary method which could be a possible security thread.

Usage Example: 

import java.util.Hashtable;


public class Test extends ClassLoader
{
	private Hashtable classes = new Hashtable();

	public synchronized Class loadClass(String className, boolean resolveIt) 
throws ClassNotFoundException 
	{ 
		Class result = (Class)classes.get(className); 
		if (result != null) 
		{ 
			System.out.println(" >>>>>> returning cached result."); 
	return result; 
		}
		if (className.startsWith("java.")) 
		{
		 throw new ClassNotFoundException(); // malicious code
		}
		return null;
	} 

	public void test()
	{
		Test t = new Test();	 // VIOLATION
		try 
		{
			t.loadClass("myClass");
		} 
		catch (ClassNotFoundException e) 
		{
			e.printStackTrace();
		}
	}
}

Should be written as:

Inspect custom ClassLoader

Reference:  Not available.

Rule 17: Inspect_usage_of_getName_method_of_Class_object

Severity:  Low
Rule:  Inspect usage of getName from java.lang.Class object.
Reason:  Inspect usage of getName from java.lang.Class object.

Usage Example: 

public class Test
{
	public void fubar()
	{
		try
		{
			//...
		}
		catch(Exception e) 
		{
			System.err.println(e.getClass().getName() + ": " + e.getMessage()); // VIOLATION
		}
	}
}

Should be written as:

public class Test
{
	public void fubar()
	{
		try
		{
			//...
		}
		catch(Exception e) 
		{
			System.err.println(e.getMessage()); // FIXED
		}
	}
}

Reference:  Not available.

Rule 18: Avoid_calling_printStackTrace_method_of_Throwable_objects

Severity:  Medium
Rule:  printStackTrace might reveal internal program information.
Reason:  printStackTrace might reveal internal program information.

Usage Example: 

public class MyClass
{
	public static void printFile(String name) 
	{
  try 
	 {
InputStream in= new FileInputStream(name);
//...
  }
	  catch (FileNotFoundException e) 
	  {
	 e.printStackTrace(); //VIOLATION
  }
 }
	

}

Should be written as:

public class MyClass
{
	public static void printFile(String name) 
	{
  try 
	  {
InputStream in= new FileInputStream(name);
//...
  } 
	  catch (FileNotFoundException e) 
	  {
// CORRECTION
		// or log the exception
  }
 }
	
}

Reference:  No references available.

Rule 19: Always_declare_readObject_and_writeObject_as_private

Severity:  Medium
Rule:  Java serialization protocol requires you to declare readObject() and writeObject() private.
Reason:  Java serialization protocol requires you to declare readObject() and writeObject() private.

Usage Example: 

import java.io.*;

public class KeepPrivate implements Serializable
{
	static final long serialVersionUID = 23452963472762;

	public void writeObject(ObjectOutputStream s) throwsIOException  
		// VIOLATION
	{
 		s.defaultWriteObject();
	}

	public void readObject(ObjectInputStream s) throwsIOException, ClassNotFoundException  	// VIOLATION
	{
		s.defaultReadObject();
	}

}

Should be written as:

import java.io.*;

public class KeepPrivate implements Serializable
{
	static final long serialVersionUID = 23452963472762;

	private void writeObject(ObjectOutputStream s) throws IOException 
		// CORRECTION
	{
		s.defaultWriteObject();
	}

	private void readObject(ObjectInputStream s) throws IOException, 	ClassNotFoundException// CORRECTION
	{
		s.defaultReadObject();
	}

}

Reference:  http://java.sun.com/j2se/1.5.0/docs/guide/serialization/spec/security.html

Rule 20: Avoid_comparing_classes_by_name

Severity:  Medium
Rule:  Do not compare classes by name to avoid any security issues
Reason:  Do not compare classes by name to avoid any security issues

Usage Example: 

package com.rule;
class Avoid_comparing_classes_by_name_violation
{
	public boolean isClassOK(Class cls)
	{
		return cls.getName().equals("SomeClassName");		// VIOLATION
	}
}

Should be written as:

package com.rule;
class Avoid_comparing_classes_by_name_correction
{
	public boolean isClassOK(Class cls)
	{
		return cls == this.getClassLoader().loadClass("SomeClassName");		// CORRECTION
	}
}

Reference:  http://www.javaworld.com/javaworld/jw-12-1998/jw-12-securityrules_p.html

Rule 21: Make_classes_non_serializable

Severity:  Medium
Rule:  Make your classes non serializable to avoid security issues
Reason:  Make your classes non serializable to avoid security issues

Usage Example: 

package com.rule;
class Make_class_non_serializable_violation
{
}

Should be written as:

package com.rule;
import java.io.ObjectOutputStream;
class Make_class_non_serializable_correction
{
	private final void writeObject(ObjectOutputStream out) throws java.io.IOException
	{
		throw new java.io.IOException("Object cannot be serialized");
	}
}

Reference:  http://www.javaworld.com/javaworld/jw-12-1998/jw-12-securityrules_p.html

Rule 22: Inspect_package_scope_access

Severity:  Medium
Rule:  Give your classes, methods, and fields the most restricted access possible.
Reason:  Give your classes, methods, and fields the most restricted access possible.

Usage Example: 

class MyClass // VIOLATION
{

}

Should be written as:

Reference:  http://java.sun.com/j2se/1.3/docs/guide/extensions/spec.html#sealing

Rule 23: Always_implement_readObject_for_serializable_class

Severity:  Medium
Rule:  It is preferrable to always implement readObject method to validate all serialized data to guarantee security and class invariants.
Reason:  It is preferrable to always implement readObject method to validate all serialized data to guarantee security and class invariants.

Usage Example: 

import java.io.*;

public class AlwaysImplement_readObject_forSerializableClass implements Serializable  // VIOLATION
{  

 private int _max;
 private static final long serialVersionUID = 1;

 public void setMax (int max) 
 {
  _max = max;
 }
 
 public int getMax () 
 {
  return _max;
 }
}

Should be written as:

public class AlwaysImplement_readObject_forSerializableClass implements Serializable 
{
 
 private int _max;
 private static final long serialVersionUID = 1;

 private void readObject (ObjectInputStream in)  // CORRECTION
  throws IOException, ClassNotFoundException 
 {
  in.defaultReadObject ();
  if ( _max < 0 ) // validation assuming max should always be positive
throw new IOException ("Illegal max value read: " +  _max); 
 }

 public void setMax (int max) 
 {
  _max = max;
 }
 
 public int getMax () 
 {
  return _max;
 }
}

Reference:  Joshua Bloch: "Effective Java - Programming Language Guide" - Addison Wesley, 2001, pp. 218-219

Rule 24: Make_classes_non_deserializable

Severity:  Medium
Rule:  Make classes non deserializable to avoid any security issues
Reason:  Make classes non deserializable to avoid any security issues

Usage Example: 

package com.rule;
class Make_class_non_deserializable_violation
{
}

Should be written as:

package com.rule;
import java.io.ObjectInputStream;
class Make_class_non_deserializable_correction
{
	// CORRECTION - By writing the following method in your class, will make your
 // make your class non desrializable. NOTE: The method should be declared as final,
 //  so that a subclass defined by the adversary cannot override it.

	private final void readObject(ObjectInputStream in) throws java.io.IOException
	{
		throw new java.io.IOException("Class cannot be deserialized");
	}
}

Reference:  http://www.javaworld.com/javaworld/jw-12-1998/jw-12-securityrules_p.html

Rule 25: Avoid_collection_type_fields_in_public_interface

Severity:  Medium
Rule:  Avoid declaring collection type fields in public interface.
Reason:  Avoid declaring collection type fields in public interface.

Usage Example: 

package com.rule;

public interface Avoid_collection_type_fields_in_public_interface_violation
{
	final static int i = 10;

	final static Hashtable numbers = new Hashtable();	// Violation

	final static Collection c = new ArrayList();	// Violation
		
}

Should be written as:

Reference:  Reference not available.

Rule 26: Avoid_array_type_fields_in_public_interface

Severity:  Medium
Rule:  Avoid declaring array type fields in public interface.
Reason:  Avoid declaring array type fields in public interface.

Usage Example: 

package com.rule;

public interface Avoid_array_type_fields_in_public_interface_violation
{
	final static int i = 10;
	
	final static int Myarray[] = {10,20,30};	//Violation.
		
}

Should be written as:

Reference:  Reference not available.

Rule 27: Make_classes_non_cloneable

Severity:  Medium
Rule:  Make classes non cloneable to avoid any security issues
Reason:  Make classes non cloneable to avoid any security issues

Usage Example: 

package com.rule;
class Make_class_non_cloneable_violation		// VIOLATION
{
}

Should be written as:

package com.rule;
class Make_class_non_cloneable_correction
{
	public final Object clone() throws java.lang.CloneNotSupportedException		// CORRECTION
	{
		throw new java.lang.CloneNotSupportedException();
	}
}

Reference:  http://www.javaworld.com/javaworld/jw-12-1998/jw-12-securityrules_p.html

Rule 28: Clone_method_should_throw_CloneNotSupportedException

Severity:  Medium
Rule:  Clone method should throw CloneNotSupportedException.
Reason:  Clone method should throw CloneNotSupportedException.

Usage Example: 

package com.rule;

class Clone_method_should_throw_CloneNotSupportedException_violation implements Cloneable
{
	protected Object clone()
	{
		return null;
	}
}

Should be written as:

package com.rule;

class Clone_method_should_throw_CloneNotSupportedException_violation implements Cloneable
{
	protected Object clone() throws CloneNotSupportedException
	{
		return null;
	}
}

Reference:  Joshua Bloch : "Effective Java - Programming Language Guide" Addison Wesley, 2001

Rule 29: Always_use_final_modifier_for_Clone_method

Severity:  Medium
Rule:  Always use final modifier for Clone method.
Reason:  Always use final modifier for Clone method.

Usage Example: 

package com.rule;

public class Always_use_final_modifier_for_Clone_method  implements Cloneable
{
	public Object clone () throws CloneNotSupportedException	  // VIOLATION
	{
	
	}
	
}

Should be written as:

package com.rule;
	
public class Always_use_final_modifier_for_Clone_method  implements Cloneable
{
	public final Object clone () throws CloneNotSupportedException		//Correction.
	{
	
	}
	
}

Reference:  Reference not available.

Rule 30: Avoid_protected_member_in_final_class

Severity:  Medium
Rule:  Avoid protected member in final class
Reason:  Avoid protected member in final class

Usage Example: 

package com.rule;

final class Avoid_protected_member_in_final_class_violation
{
	protected int value;		// VIOLATION
}

Should be written as:

package com.rule;

final class Avoid_protected_member_in_final_class_correction
{
	int value;		// CORRECTION
}

Reference:  Reference Not Available.

Rule 31: Avoid_using_inner_classes

Severity:  Medium
Rule:  Avoid using inner classes for security reasons
Reason:  Avoid using inner classes for security reasons

Usage Example: 

package com.rule;
class Avoid_using_inner_classes_violation
{
	// some private field declarations
	// and required accessor methods
	
	class Avoid_using_inner_classes_InnerClass
	{
		public void takeAction()
		{
			// accessing private fields of outer class here
		}
	}
}

Should be written as:

package com.rule;
public class Avoid_using_inner_classes_correction
{
	// some private field declarations
	// and required accessor methods
}

class Avoid_using_inner_classes_InnerClass2
{
	public void takeAction()
	{
		// use accessor methods of the other class.
	}
}

Reference:  http://www.javaworld.com/javaworld/jw-12-1998/jw-12-securityrules_p.html

Rule 32: Avoid_public_access_for_inner_classes

Severity:  Medium
Rule:  Do not give public access for inner classes to avoid any security issues
Reason:  Do not give public access for inner classes to avoid any security issues

Usage Example: 

package com.rule;
class Avoid_public_access_for_inner_classes_violation
{
	public class Avoid_public_access_for_inner_classes_InnerClass // VIOLATION
	{
		public void takeAction()
		{
		}
	}
}

Should be written as:

package com.rule;
class Avoid_public_access_for_inner_classes_correction
{
	private class Avoid_public_access_for_inner_classes_InnerClass  // CORRECTION
	{
		public void takeAction()
		{
		}
	}
}

Reference:  http://www.javaworld.com/javaworld/jw-12-1998/jw-12-securityrules_p.html