Added CLENAED VERSION OF TEST CASES AND EXPECTED RESULTS FILE

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00001.java

@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00001")
+public class BenchmarkTest00001 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00001", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-00/BenchmarkTest00001.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00001")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + param;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00002.java

@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00002")
+public class BenchmarkTest00002 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00002", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-00/BenchmarkTest00002.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00002")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + param;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00003.java

@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00003")
+public class BenchmarkTest00003 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00003", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-00/BenchmarkTest00003.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00003")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00004.java

@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00004")
+public class BenchmarkTest00004 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00004", "color");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-00/BenchmarkTest00004.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00004")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(param, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(param)
+                                + "' with value: '10340' saved in session.");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00005.java

@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00005")
+public class BenchmarkTest00005 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00005") != null) {
+            param = request.getHeader("BenchmarkTest00005");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00006.java

@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00006")
+public class BenchmarkTest00006 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00006") != null) {
+            param = request.getHeader("BenchmarkTest00006");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + param);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00007.java

@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00007")
+public class BenchmarkTest00007 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00007") != null) {
+            param = request.getHeader("BenchmarkTest00007");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {param};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00008.java

@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00008")
+public class BenchmarkTest00008 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00008") != null) {
+            param = request.getHeader("BenchmarkTest00008");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String sql = "{call " + param + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00009.java

@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00009")
+public class BenchmarkTest00009 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00010.java

@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00010")
+public class BenchmarkTest00010 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00011.java

@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00011")
+public class BenchmarkTest00011 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00011");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        java.io.File fileTarget = new java.io.File(param, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00012.java

@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00012")
+public class BenchmarkTest00012 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00012");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + param + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00013.java

@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00013")
+public class BenchmarkTest00013 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, param, obj);
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00014.java

@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00014")
+public class BenchmarkTest00014 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(param, obj);
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00015.java

@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00015")
+public class BenchmarkTest00015 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00015");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + param);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00016.java

@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00016")
+public class BenchmarkTest00016 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00016");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00017.java

@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00017")
+public class BenchmarkTest00017 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00017");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + param);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00018.java

@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00018")
+public class BenchmarkTest00018 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00018");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + param + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00019.java

@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00019")
+public class BenchmarkTest00019 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.io.InputStream param = request.getInputStream();
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00020.java

@@ -0,0 +1,133 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00020")
+public class BenchmarkTest00020 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00020");
+        if (param == null) param = "";
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00021.java

@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00021")
+public class BenchmarkTest00021 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00021");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + param + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00022.java

@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00022")
+public class BenchmarkTest00022 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00022");
+        if (param == null) param = "";
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00023.java

@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00023")
+public class BenchmarkTest00023 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00023");
+        if (param == null) param = "";
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00024.java

@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00024")
+public class BenchmarkTest00024 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00024");
+        if (param == null) param = "";
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + param + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00025.java

@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00025")
+public class BenchmarkTest00025 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00025");
+        if (param == null) param = "";
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00026.java

@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00026")
+public class BenchmarkTest00026 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00026");
+        if (param == null) param = "";
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00027.java

@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00027")
+public class BenchmarkTest00027 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00027");
+        if (param == null) param = "";
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + param + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00028.java

@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00028")
+public class BenchmarkTest00028 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00028");
+            if (values != null) param = values[0];
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + param;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00029.java

@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00029")
+public class BenchmarkTest00029 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00029");
+            if (values != null) param = values[0];
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00030.java

@@ -0,0 +1,37 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00030")
+public class BenchmarkTest00030 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00030");
+            if (values != null) param = values[0];
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(param, obj);
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00031.java

@@ -0,0 +1,42 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00031")
+public class BenchmarkTest00031 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00031");
+            if (values != null) param = values[0];
+        }
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", param);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(param)
+                                + "' saved in session.");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00032.java

@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00032")
+public class BenchmarkTest00032 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00032");
+            if (values != null) param = values[0];
+        }
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00033.java

@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00033")
+public class BenchmarkTest00033 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00033");
+            if (values != null) param = values[0];
+        }
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00034.java

@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00034")
+public class BenchmarkTest00034 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00034");
+            if (values != null) param = values[0];
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00035.java

@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00035")
+public class BenchmarkTest00035 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00035")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00036.java

@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00036")
+public class BenchmarkTest00036 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00036")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (param != null) {
+            length = param.length();
+            response.getWriter().write(param.toCharArray(), 0, length);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00037.java

@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00037")
+public class BenchmarkTest00037 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00037")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + param + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00038.java

@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00038")
+public class BenchmarkTest00038 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00038")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00039.java

@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00039")
+public class BenchmarkTest00039 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00039")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00040.java

@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00040")
+public class BenchmarkTest00040 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00040");
+        if (param == null) param = "";
+
+        java.io.File fileTarget = new java.io.File(param);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00041.java

@@ -0,0 +1,38 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00041")
+public class BenchmarkTest00041 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00041");
+        if (param == null) param = "";
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (param != null) {
+            length = param.length();
+            response.getWriter().write(param, 0, length);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00042.java

@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00042")
+public class BenchmarkTest00042 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00042");
+        if (param == null) param = "";
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00043.java

@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00043")
+public class BenchmarkTest00043 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00043");
+        if (param == null) param = "";
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + param + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00044.java

@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00044")
+public class BenchmarkTest00044 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00044");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + param + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00045.java

@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00045")
+public class BenchmarkTest00045 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00045");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + param;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR +
+        // param).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00046.java

@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00046")
+public class BenchmarkTest00046 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00046");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00047.java

@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00047")
+public class BenchmarkTest00047 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00047" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00047"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00047" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(param, obj);
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00048.java

@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00048")
+public class BenchmarkTest00048 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00048" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00048"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00048" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(param.toCharArray());
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00049.java

@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00049")
+public class BenchmarkTest00049 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00049" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00049"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00049" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + param);
+    }
+}

OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00050.java

@@ -0,0 +1,134 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00050")
+public class BenchmarkTest00050 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00050");
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}