Java example source code file (CheckPermission.java)

This example Java source code file (CheckPermission.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

access, arraylist, checks, file, filenamefilter, fileoperation, list, loggingsecuritymanager, override, permission, runtimeexception, security, set, string, threadlocal, util

The CheckPermission.java Java example source code

/*
 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/* @test
 * @bug 8017212
 * @summary Examine methods in File.java that access the file system do the
 *          right permission check when a security manager exists.
 * @author Dan Xu
 */

import java.io.File;
import java.io.FilenameFilter;
import java.io.FileFilter;
import java.io.IOException;
import java.security.Permission;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class CheckPermission {

    private static final String CHECK_PERMISSION_TEST = "CheckPermissionTest";

    public enum FileOperation {
        READ, WRITE, DELETE, EXEC
    }

    static class Checks {
        private List<Permission> permissionsChecked = new ArrayList<>();
        private Set<String> propertiesChecked = new HashSet<>();

        private Map<FileOperation, List fileOperationChecked =
            new EnumMap<>(FileOperation.class);

        List<Permission> permissionsChecked() {
            return permissionsChecked;
        }

        Set<String> propertiesChecked() {
            return propertiesChecked;
        }

        List<String> fileOperationChecked(FileOperation op) {
            return fileOperationChecked.get(op);
        }

        void addFileOperation(FileOperation op, String file) {
            List<String> opList = fileOperationChecked.get(op);
            if (opList == null) {
                opList = new ArrayList<>();
                fileOperationChecked.put(op, opList);
            }
            opList.add(file);
        }
    }

    static ThreadLocal<Checks> myChecks = new ThreadLocal<>();

    static void prepare() {
        myChecks.set(new Checks());
    }

    static class LoggingSecurityManager extends SecurityManager {
        static void install() {
            System.setSecurityManager(new LoggingSecurityManager());
        }

        private void checkFileOperation(FileOperation op, String file) {
            Checks checks = myChecks.get();
            if (checks != null)
                checks.addFileOperation(op, file);
        }

        @Override
        public void checkRead(String file) {
            checkFileOperation(FileOperation.READ, file);
        }

        @Override
        public void checkWrite(String file) {
            checkFileOperation(FileOperation.WRITE, file);
        }

        @Override
        public void checkDelete(String file) {
            checkFileOperation(FileOperation.DELETE, file);
        }

        @Override
        public void checkExec(String file) {
            checkFileOperation(FileOperation.EXEC, file);
        }

        @Override
        public void checkPermission(Permission perm) {
            Checks checks = myChecks.get();
            if (checks != null)
                checks.permissionsChecked().add(perm);
        }

        @Override
        public void checkPropertyAccess(String key) {
            Checks checks = myChecks.get();
            if (checks != null)
                checks.propertiesChecked().add(key);
        }
    }

    static void assertCheckPermission(Class<? extends Permission> type,
            String name)
    {
        for (Permission perm : myChecks.get().permissionsChecked()) {
            if (type.isInstance(perm) && perm.getName().equals(name))
                return;
        }
        throw new RuntimeException(type.getName() + "(\"" + name
            + "\") not checked");
    }

    static void assertCheckPropertyAccess(String key) {
        if (!myChecks.get().propertiesChecked().contains(key))
            throw new RuntimeException("Property " + key + " not checked");
    }

    static void assertChecked(File file, List<String> list) {
        if (list != null && !list.isEmpty()) {
            for (String path : list) {
                if (path.equals(file.getPath()))
                    return;
            }
        }
        throw new RuntimeException("Access not checked");
    }

    static void assertNotChecked(File file, List<String> list) {
        if (list != null && !list.isEmpty()) {
            for (String path : list) {
                if (path.equals(file.getPath()))
                    throw new RuntimeException("Access checked");
            }
        }
    }

    static void assertCheckOperation(File file, Set<FileOperation> ops) {
        for (FileOperation op : ops)
            assertChecked(file, myChecks.get().fileOperationChecked(op));
    }

    static void assertNotCheckOperation(File file, Set<FileOperation> ops) {
        for (FileOperation op : ops)
            assertNotChecked(file, myChecks.get().fileOperationChecked(op));
    }

    static void assertOnlyCheckOperation(File file,
            EnumSet<FileOperation> ops)
    {
        assertCheckOperation(file, ops);
        assertNotCheckOperation(file, EnumSet.complementOf(ops));
    }

    static File testFile, another;

    static void setup() {
        testFile = new File(CHECK_PERMISSION_TEST + System.currentTimeMillis());
        if (testFile.exists()) {
            testFile.delete();
        }

        another = new File(CHECK_PERMISSION_TEST + "Another"
                           + System.currentTimeMillis());
        if (another.exists()) {
            another.delete();
        }

        LoggingSecurityManager.install();
    }

    public static void main(String[] args) throws IOException {
        setup();

        prepare();
        testFile.canRead();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.canWrite();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.exists();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.isDirectory();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.isFile();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.isHidden();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.lastModified();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.length();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.createNewFile();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.list();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return false;
            }
        });
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.listFiles();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return false;
            }
        });
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                return false;
            }
        });
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));

        prepare();
        testFile.mkdir();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        if (testFile.exists()) {
            prepare();
            testFile.mkdirs();
            assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));
        }

        if (!another.exists()) {
            prepare();
            another.mkdirs();
            assertOnlyCheckOperation(another,
                    EnumSet.of(FileOperation.READ, FileOperation.WRITE));
        }

        prepare();
        another.delete();
        assertOnlyCheckOperation(another, EnumSet.of(FileOperation.DELETE));

        prepare();
        boolean renRst = testFile.renameTo(another);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));
        assertOnlyCheckOperation(another, EnumSet.of(FileOperation.WRITE));

        if (renRst) {
            if (testFile.exists())
                throw new RuntimeException(testFile + " is already renamed to "
                    + another);
            testFile = another;
        }

        prepare();
        testFile.setLastModified(0);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setReadOnly();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setWritable(true, true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setWritable(true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setReadable(true, true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setReadable(true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setExecutable(true, true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.setExecutable(true);
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.WRITE));

        prepare();
        testFile.canExecute();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.EXEC));

        prepare();
        testFile.getTotalSpace();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));
        assertCheckPermission(RuntimePermission.class,
                "getFileSystemAttributes");

        prepare();
        testFile.getFreeSpace();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));
        assertCheckPermission(RuntimePermission.class,
                "getFileSystemAttributes");

        prepare();
        testFile.getUsableSpace();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.READ));
        assertCheckPermission(RuntimePermission.class,
                "getFileSystemAttributes");

        prepare();
        File tmpFile = File.createTempFile(CHECK_PERMISSION_TEST, null);
        assertOnlyCheckOperation(tmpFile, EnumSet.of(FileOperation.WRITE));
        tmpFile.delete();
        assertCheckOperation(tmpFile, EnumSet.of(FileOperation.DELETE));

        prepare();
        tmpFile = File.createTempFile(CHECK_PERMISSION_TEST, null, null);
        assertOnlyCheckOperation(tmpFile, EnumSet.of(FileOperation.WRITE));
        tmpFile.delete();
        assertCheckOperation(tmpFile, EnumSet.of(FileOperation.DELETE));

        prepare();
        testFile.deleteOnExit();
        assertOnlyCheckOperation(testFile, EnumSet.of(FileOperation.DELETE));
    }
}