# V5302. OWASP. Exception classes should be publicly accessible.

The analyzer has detected an exception class inaccessible to external classes. If such an exception is thrown, the external code will have to catch instances of the nearest accessible parent class such as the base class of all exceptions, 'Throwable'. In this case, it becomes more difficult to handle specific exceptions, because the external code will not be able to clearly identify the problem that has arisen.

Lack of clear identification of exceptions poses an additional security risk because some specific exceptions may require specific handling rather than general handling. Insufficient logging and monitoring (including exception identification) are pointed out as a separate category on OWASP Top 10 Application Security Risks 2017: A10:2017-Insufficient Logging & Monitoring.

Consider the following simple example taken from a real project:

    public class TxnLogToolkit implements Closeable
    {
      static class TxnLogToolkitException extends Exception
      {
        ....
        private int exitCode;

        TxnLogToolkitException(int exitCode, ....)
        {
          super(....);
          this.exitCode = exitCode;
        }

        int getExitCode()
        {
          return exitCode;
        }
      }
      ....
    }

To correctly handle a given exception, the exception class must be declared as 'public':

    public class TxnLogToolkit implements Closeable
    {
      public static class TxnLogToolkitException extends Exception
      {
        ....
        private int exitCode;

        public TxnLogToolkitException(int exitCode, ....)
        {
          super(....);
          this.exitCode = exitCode;
        }

        public int getExitCode()
        {
          return exitCode;
        }
      }
      ....
    }

Now the code of external classes will be able to catch this exception and handle the specific situation.

Keep in mind that declaring an exception class as 'public' may be insufficient if it is a nested class, as in the following example:

    class OperatorHelper
    {
      public static class OpCertificateException extends CertificateException
      {
        private Throwable cause;

        public OpCertificateException(String msg, Throwable cause)
        {
          super(msg);
          this.cause = cause;
        }

        public Throwable getCause()
        {
          return cause;
        }
      }
    }

Here, the exception class is nested into 'OperatorHelper' class, which is implicitly has 'package-private'. Therefore, the 'OpCertificateException' will also only be available within the current package, even though it has the 'public' access modifier. The analyzer recognizes situations like that and issues the warning.

This diagnostic is classified as:

CWE-544 OWASP-7.4.2