浅析java中File.getPath()方法引发命令执行漏洞的成因

try {

                    String command = "tail -n " + intLineCount + " " + logFile.getPath();

                    Runtime runtime = Runtime.getRuntime();

                    Process proc = null;

                    BufferedReader br = null;

            

                    proc = runtime.exec(command);

                String dirName = request.getParameter("dirName");

                String fileName = request.getParameter("fileName");

                String viewType = request.getParameter("viewType");

                String lineCount = request.getParameter("lineCount");

                String pattern = request.getParameter("pattern");

                if (lineCount == null ) lineCount = "1000";

                try {

                        intLineCount = Integer.parseInt(lineCount);

                        if ( intLineCount > MAXLINE ) {

                                intLineCount = MAXLINE;

                                lineCount = String.valueOf(MAXLINE);

                        }

                } catch (Exception e) {

                        intLineCount = 1000;

                }   

/**

     * Creates a new <code>File</code> instance by converting the given

     * pathname string into an abstract pathname.  If the given string is

     * the empty string, then the result is the empty abstract pathname.

     *

     * @param   pathname  A pathname string

     * @throws  NullPointerException

     *          If the <code>pathname</code> argument is <code>null</code>

     */

    public File(String pathname) {

        if (pathname == null) {

            throw new NullPointerException();

        }

        this.path = fs.normalize(pathname);

        this.prefixLength = fs.prefixLength(this.path);

    }

    /**

     * Converts this abstract pathname into a pathname string.  The resulting

     * string uses the {@link #separator default name-separator character} to

     * separate the names in the name sequence.

     *

     * @return  The string form of this abstract pathname

     */

    public String getPath() {

        return path;

    }

    /**

     * Convert the given pathname string to normal form.  If the string is

     * already in normal form then it is simply returned.

     */

    public abstract String normalize(String path);

        public Win32FileSystem() {

        slash = AccessController.doPrivileged(

            new GetPropertyAction("file.separator")).charAt(0);

        semicolon = AccessController.doPrivileged(

            new GetPropertyAction("path.separator")).charAt(0);

        altSlash = (this.slash == '\\') ? '/' : '\\';

    }

        /* Check that the given pathname is normal.  If not, invoke the real

       normalizer on the part of the pathname that requires normalization.

       This way we iterate through the whole pathname string only once. */

    public String normalize(String path) {

        int n = path.length();

        char slash = this.slash;

        char altSlash = this.altSlash;

        char prev = 0;

        for (int i = 0; i < n; i++) {

            char c = path.charAt(i);

            if (c == altSlash)

                return normalize(path, n, (prev == slash) ? i - 1 : i);

            if ((c == slash) && (prev == slash) && (i > 1))

                return normalize(path, n, i - 1);

            if ((c == ':') && (i > 1))

                return normalize(path, n, 0);

            prev = c;

        }

        if (prev == slash) return normalize(path, n, n - 1);

        return path;

    }

        package org.fengzai.test;



        import java.io.BufferedInputStream;

        import java.io.File;

        import java.io.IOException;

        import java.io.InputStream;



        public class ExecTest {

                public static String loadStream(InputStream in) throws IOException {

                        int ptr = 0;

                        in = new BufferedInputStream(in);

                        StringBuffer buffer = new StringBuffer();

                        while ((ptr = in.read()) != -1) {

                                buffer.append((char) ptr);

                        }



                        return buffer.toString();

                }



                public static void main(String args[]) {

                        String fileName = "file.txt | && ";

                        fileName = "file.txt";

                        fileName = "file.txt & dir";



                        File logFile = new File("c:" + File.separator + "logs" + File.separator

                                        + fileName);

                        

                        //test special character

                        System.out.println(logFile.getPath());



                        String command = "cmd.exe /C type " + logFile.getPath();



                        try {

                                Runtime runtime = Runtime.getRuntime();

                                Process proc = null;

                                proc = runtime.exec(command);

                                System.out.println(ExecTest.loadStream(proc.getInputStream()));

                                System.err.println(ExecTest.loadStream(proc.getErrorStream()));

                        } catch (IOException e) {

                                e.printStackTrace();

                        }

                }

        }