Injecting faults in JVM

Question

Hi
Injecting faults in JVM, to test the robustness of my application, to predict unforeseen application crashes?
Want to carry low level test with application by injecting faults in JVM, like I want the JVM to execute a a` instead of a function a where it a` throws some unknown exception?
How can I go about that?
What are possible architectures for Fault Injection?
What are problems with JVM security?
What if I want to implement the same for an application packaged in jar file?
How do I go about changing the class-loading mechnism externally and get the application call-tree so as to plug my testing module?
If I want to implement the same without changing the JVM, so I am independent of vendor specific JVM dependencies, how can I do that?
regds
SA

Answer 1

I think you can trick it using your own class loader.
Something like this:
=== normal implementation ==
package com.xxx;
public class A {
   int a(int p1,int p2) throws AException,BException {
        // real implementation
}=== faulty implementation, in different source path ==
package com.xxx;
public class A {
   int a(int p1,int p2) throws AException,BException {
        throw new RuntimeException();
}=========================
After you compiled faulty implementation rename "com/xxx/A.class" file to be "com/xxx/A.faulty" and put it along with your normal "com/xxx/A.class" file (doesn't matter to jar or to regular directory structure).
Then move your main() code to separate class:
package com.xxx;
public class MainImpl implements Runnable {
        public void run() {
                // here comes code from your original main() method.
}And in your main class:
package com.xx;
import java.io.InputStream;
import java.io.ByteArrayOutputStream;
public class Main {
     public static void main(String[] args) {
           MyClassLoader cl = new MyClassLoader();
           Runnable mainImpl = (Runnable) cl.loadClass("com.xxx.MainImpl").newInstance();
           mainImpl.run();
      This class loader, if -Dfaulty=true is specified, will first try to load
      bytecode from .faulty file and if it failed then from .class file.
     public static class MyClassLoader extends ClassLoader {
           private static final boolean FAULTY = Boolean.getBoolean("faulty");
           public Class findClass(String name) {
               if (FAULTY) {
                   byte[] b = loadClassData(name);
                   return defineClass(name, b, 0, b.length);
               return super.findClass(name);
         private byte[] loadClassData(String name) {
               final String faultyName = name.replace('.', '/') + ".faulty";
               InputStream io = null;
               io = getParent().getSystemResourceAsStream(faultyName);
               if (io == null) {
                   // i.e. there is no file with extension '.faulty'
                  // and we are going to load usual class file.
                   final String normalName = name.replace('.', '/') + ".class";
                   io = getParent().getSystemResourceAsStream(normalName);
               byte[] data = new byte[io.available()];
               io.read(data);
               return data;
}In order to start your application in 'faulty' mode you'll need to start it with option:
java -Dfaulty=true com.xxx.Main
PS: have not tried to compile/run it. So, there is possibiliy that some changes will be required.