## Apéndice B: Clases, Métodos y Permisos

Un gran número de métodos de la plataforma JavaTM 2 estan implementados para verificar permisos de acceso. Esto significa que antes de ejecutarse, verifican si ay un fichero de policia de sistema, usuario o programa con los permisos requeridos para que continue la ejecución. Si no se encuentran dichos permisos, la ejecución se detiene con una condición de error.

El código de verificación de acceso pasa los permisos requeridos al controlador de seguridad, y el controlador de seguridad comprueba estos permisos contra los permisos del fichero de policía para determinar los accesos. Esto significa que los métodos de la plataforma Java 2 están asociados con permisos específicos, y los permisos específcios están asociados con métodos específicos del java.security.SecurityManager.

Este apéndide lista los métodos de la plataforma Java 2, los permisos asociados con cada método, y el método java.security.SecurityManager llamado para verificar la existencia de este permiso. Necesitamos esta información cuando implementamos ciertos métodos abstractos o creamos nuestro propio controlador de seguridad para que podamos incluir código de verificación de acceso para mantener nuestras implementaciones en línea con la política de seguridad de la plataforma Java 2. Si no incluimos código de verificación de acceso, nuestras implementaciones no pasarán los chequeos de seguridad internos de la plataforma Java 2.

- java.awt.Graphics2D
- java.awt.ToolKit
- java.awt.Window
- java.beans.Beans
- java.beans.Introspector
- java.beans.PropertyEditorManager
- java.io.File
- java.io.FileOutputStream
- java.io.ObjectInputStream
- java.io.ObjectOutputStream
- java.io.RandomAccessFile
- java.lang.Class
- java.lang.ClassLoader
- java.lang.Runtime
- java.lang.SecurityManager
- java.lang.System
- java.lang.Thread
- java.lang.ThreadGroup
- java.lang.reflect.AccessibleObject
- java.net.Authenticator
- java.net.DatagramSocket
- java.net.HttpURLConnection
- java.net.InetAddress
- java.net.MulticastSocket
- java.net.ServerSocket
- java.net.Socket
- java.net.URL
- java.net.URLConnection
- java.net.URLClassLoader
- java.rmi.activation.ActivationGroup
- java.rmi.server.RMISocketFactory
- java.security.Identity
- java.security.IdentityScope
- java.security.Permission
- java.security.Policy
- java.security.Provider
- java.security.SecureClassLoader
- java.security.Security
- java.security.Signer
- java.util.Locale
- java.util.Zip

### java.awt.Graphics2D

>     public abstract void setComposite(Composite comp)
>     java.Security.SecurityManager.checkPermission
>     java.awt.AWTPermission "readDisplayPixels"

El código de verificaciónde acceso para setComposite debería llamar a java.Security.SecurityManager.checkPermission y pasarle java.awt.AWTPermission "readDisplayPixels" cuando el contexto Graphics2D dibuje un componente en la pantalla y el compuesto es un objeto personalizado en vez de un objeto AlphaComposite.

### java.awt.Toolkit

>     public void addAWTEventListener(
>     	AWTEventListener listener,
>             long eventMask)
>     public void removeAWTEventListener(
>     	AWTEventListener listener)
>     checkPermission
>     java.awt.AWTPermission "listenToAllAWTEvents"

~~~~~~~~~

>     public abstract PrintJob getPrintJob(
>     	Frame frame, String jobtitle,
>     	Properties props)
>     checkPrintJobAccess
>     java.lang.RuntimePermission "queuePrintJob"

~~~~~~~~~

>     public abstract Clipboard
>     	getSystemClipboard()
>     checkSystemClipboardAccess
>     java.awt.AWTPermission "accessClipboard"

~~~~~~~~~

>     public final EventQueue
>     	getSystemEventQueue()
>     checkAwtEventQueueAccess
>     java.awt.AWTPermission "accessEventQueue"

### java.awt.Window

>     Window()
>     checkTopLevelWindow
>     java.awt.AWTPermission
>     	"showWindowWithoutWarningBanner"

### java.beans.Beans

>     public static void setDesignTime(
>     	boolean isDesignTime)
>     public static void setGuiAvailable(
>     	boolean isGuiAvailable)
>     checkPropertiesAccess
>     java.util.PropertyPermissions "*", "read,write"

### java.beans.Introspector

>     public static synchronized void
>     	setBeanInfoSearchPath(String path[])
>     checkPropertiesAccess
>     java.util.PropertyPermissions "*", "read,write"

### java.beans.PropertyEditorManager

>     public static void registerEditor(
>     	Class targetType,
>     	Class editorClass)
>     public static synchronized void
>     	setEditorSearchPath(String path[])
>     checkPropertiesAccess
>     java.util.PropertyPermissions "*", "read,write"

### java.io.File

>     public boolean delete()
>     public void deleteOnExit()
>     checkDelete(String)
>     java.io.FilePermission "{name}", "delete"

~~~~~~~~~

>     public boolean exists()
>     public boolean canRead()
>     public boolean isFile()
>     public boolean isDirectory()
>     public boolean isHidden()
>     public long lastModified()
>     public long length()
>     public String[] list()
>     public String[] list(FilenameFilter filter)
>     public File[] listFiles()
>     public File[] listFiles(FilenameFilter filter)
>     public File[] listFiles(FileFilter filter)
>     checkRead(String)
>     java.io.FilePermission "{name}", "read"

~~~~~~~~~

>     public boolean canWrite()
>     public boolean createNewFile()
>     public static File createTempFile(
>             String prefix, String suffix)
>     public static File createTempFile(
>             String prefix,  String suffix,
>             File directory)
>     public boolean mkdir()
>     public boolean mkdirs()
>     public boolean renameTo(File dest)
>     public boolean setLastModified(long time)
>     public boolean setReadOnly()
>     checkWrite(String)
>     java.io.FilePermission "{name}", "write"

#### java.io.FileInputStream

>     FileInputStream(FileDescriptor fdObj)
>     checkRead(FileDescriptor)
>     java.lang.RuntimePermission "readFileDescriptor"

~~~~~~~~~

>     FileInputStream(String name)
>     FileInputStream(File file)
>     checkRead(String)
>     java.io.FilePermission "{name}", "read"

### java.io.FileOutputStream

>     FileOutputStream(FileDescriptor fdObj)
>     checkWrite(FileDescriptor)
>     java.lang.RuntimePermission "writeFileDescriptor"

~~~~~~~~~

>     FileOutputStream(File file)
>     FileOutputStream(String name)
>     FileOutputStream(String name, boolean append)
>     checkWrite(String)
>     java.io.FilePermission "{name}", "write"

### java.io.ObjectInputStream

>     protected final boolean
>     	enableResolveObject(boolean enable);
>     checkPermission
>     java.io.SerializablePermission
>     	"enableSubstitution"

~~~~~~~~~

>     protected ObjectInputStream()
>     protected ObjectOutputStream()
>     checkPermission
>     java.io.SerializablePermission
>     	"enableSubclassImplementation"

### java.io.ObjectOutputStream

>     protected final boolean
>     	enableReplaceObject(boolean enable)
>     checkPermission
>     java.io.SerializablePermission
>     	"enableSubstitution"

### java.io.RandomAccessFile

>     RandomAccessFile(String name, String mode)
>     RandomAccessFile(File file, String mode)
>     checkRead(String)
>     java.io.FilePermission "{name}", "read"

En ambos métodos el modo es r.
~~~~~~~~~

>     RandomAccessFile(String name, String mode)
>     checkRead(String) and checkWrite(String)
>     java.io.FilePermission "{name}", "read,write"

En este método el modo es rw.
~~~~~~~~~

### java.lang.Class

>     public static Class forName(
>     	String name, boolean initialize,
>     	ClassLoader loader)
>     checkPermission
>     java.lang.RuntimePermission("getClassLoader")

El código de verificación de acceso para este método llama a checkPermission y lo pasa a java.lang.RuntimePermission("getClassLoader") cuando loader es null y el cargador de la clase llamante no es null.
~~~~~~~~~

>     public Class[] getClasses()
>     checkMemberAccess(this, Member.DECLARED)
>     java.lang.RuntimePermission
>     	"accessDeclaredMembers"
>     java.lang.RuntimePermission
>     	"accessClassInPackage.{pkgName}"

El código de verificación de acceso para esta clase y cada una de sus superclases llama a checkMemberAccess(this, Member.DECLARED). Si la clase está en un paquete, checkPackageAccess({pkgName}) también se llama. Por defecto, checkMemberAccess no requiere permiso si el cargador de clase de esta clase es el mismo que el de la otra. De otra forma requiere java.lang.RuntimePermission "accessDeclaredMembers". Si la clase está en un paquete, también se requiere java.lang.RuntimePermission "accessClassInPackage.{pkgName}".
~~~~~~~~~

>     public ClassLoader getClassLoader()
>     checkPermission
>     java.lang.RuntimePermission "getClassLoader"

Si el llamador de la clase llamante es null, o si el si es el mismo que el del ancestro del cargador de la clase para la clase cuyo cargador de clase está siendo solicitado, no se necesita permiso. De otra forma, se necesita java.lang.RuntimePermission "getClassLoader".
~~~~~~~~~

>     public Class[] getDeclaredClasses()
>     public Field[] getDeclaredFields()
>     public Method[] getDeclaredMethods()
>     public Constructor[]
>     	getDeclaredConstructors()
>     public Field getDeclaredField(
>     	String name)
>     public Method getDeclaredMethod(...)
>     public Constructor
>     	getDeclaredConstructor(...)
>     checkMemberAccess(this, Member.DECLARED)
>     checkPackageAccess({pkgName})
>     java.lang.RuntimePermission
>     	"accessDeclaredMembers
>     java.lang.RuntimePermission
>     	"accessClassInPackage.{pkgName}

Si la clase está en un paquete, el código de verificación de acceso debería llamar a checkPackageAccess({pkgName}) y pasarlo a java.lang.RuntimePermission "accessClassInPackage.{pkgName}".

Si la clase no está en un paquete, el código de verificación de acceso para estos métodos debería llamar a checkMemberAccess(this, Member.DECLARED) y pasarlo a java.lang.RuntimePermission "accessClassInPackage.{pkgName}".

~~~~~~~~~

>     public Field[] getFields()
>     public Method[] getMethods()
>     public Constructor[] getConstructors()
>     public Field getField(String name)
>     public Method getMethod(...)
>     public Constructor getConstructor(...)
>     checkMemberAccess(this, Member.PUBLIC)
>     checkPackageAccess({pkgName})
>     java.lang.RuntimePermission
>     	"accessClassInPackage.{pkgName}"

Si la clase no está en un paquete, el código de verificación de acceso para estos métodos llama a checkMemberAccess(this, Member.PUBLIC), pero no se pasa ningún permiso.

Si la clase está en un paquete, el código de verificación de acceso para estos métodos debería llamar a checkPackageAccess({pkgName}) y pasarle checkPackageAccess({pkgName}).

~~~~~~~~~

>     public ProtectionDomain
>     	getProtectionDomain()
>     checkPermission
>     java.lang.RuntimePermission "getProtectionDomain"

### java.lang.ClassLoader

>     ClassLoader()
>     ClassLoader(ClassLoader parent)
>     checkCreateClassLoader
>     java.lang.RuntimePermission "createClassLoader"

~~~~~~~~~

>     public static ClassLoader
>     	getSystemClassLoader()
>     public ClassLoader getParent()
>     checkPermission
>     java.lang.RuntimePermission "getClassLoader"

Si el cargador de clases del llamante es null o es el mismo que el del ancestro del cargador de clases para la clase cuyo cargador está siendo solicitado, no se necesita permiso. De otra forma, se requiere java.lang.RuntimePermission "getClassLoader" .

### java.lang.Runtime

>     public Process exec(String command)
>     public Process exec(String command,
>     	String envp[])
>     public Process exec(String cmdarray[])
>     public Process exec(String cmdarray[],
>     	String envp[])
>     checkExec
>     java.io.FilePermission "{command}", "execute"

~~~~~~~~~

>     public void exit(int status)
>     public static void
>     	runFinalizersOnExit(boolean value)
>     checkExit(status) where status is 0 for
>     	runFinalizersOnExit
>     java.lang.RuntimePermission "exitVM"

~~~~~~~~~

>     public void load(String lib)
>     public void loadLibrary(String lib)
>     checkLink({libName})
>     java.lang.RuntimePermission
>     	"loadLibrary.{libName}"

En estos métodos {libName} es el argumento lib, filename o libname.

### java.lang.SecurityManager

>     <all methods>
>     checkPermission
>     See Security Manager Methods.

### java.lang.System

>     public static void exit(int status)
>     public static void
>             runFinalizersOnExit(boolean value)
>     checkExit(status) where status is 0 for
>     	runFinalizersOnExit
>     java.lang.RuntimePermission "exitVM"

~~~~~~~~~

>     public static void load(String filename)
>     public static void loadLibrary(
>             String libname)
>     checkLink({libName})
>     java.lang.RuntimePermission
>     	"loadLibrary.{libName}"

En estos métodos {libName} es el argumento lib, filename o libname.
~~~~~~~~~

>     public static Properties getProperties()
>     public static void setProperties(Properties props)
>     checkPropertiesAccess
>     java.util.PropertyPermission "*", "read,write"

~~~~~~~~~

>     public static String getProperty(String key)
>     public static String getProperty(String key,
>     				 String def)
>     checkPropertyAccess
>     java.util.PropertyPermission "{key}", "read"

~~~~~~~~~

>     public static void setIn(InputStream in)
>     public static void setOut(PrintStream out)
>     public static void setErr(PrintStream err)
>     checkPermission
>     java.lang.RuntimePermission "setIO"

~~~~~~~~~

>     public static String setProperty(String key,
>     				 String value)
>     checkPermission
>     java.util.PropertyPermission "{key}", "write"

~~~~~~~~~

>     public static synchronized void
>             setSecurityManager(SecurityManager s)
>     checkPermission
>     java.lang.RuntimePermission "setSecurityManager"

### java.lang.Thread

>     public ClassLoader getContextClassLoader()
>     checkPermission
>     java.lang.RuntimePermission "getClassLoader"

Si el cargador de clases del llamante es null o es el mismo que el del ancestro del cargador de clases para la clase cuyo cargador está siendo solicitado, no se necesita permiso. De otra forma, se requiere java.lang.RuntimePermission "getClassLoader".
~~~~~~~~~

>     public void setContextClassLoader
>     	(ClassLoader cl)
>     checkPermission
>     java.lang.RuntimePermission
>     	"setContextClassLoader"

~~~~~~~~~

>     public final void checkAccess()
>     public void interrupt()
>     public final void suspend()
>     public final void resume()
>     public final void setPriority
>     	(int newPriority)
>     public final void setName(String name)
>     public final void setDaemon(boolean on)
>     checkAccess(this)
>     java.lang.RuntimePermission "modifyThread"

~~~~~~~~~

>     public static int
>     	enumerate(Thread tarray[])
>     checkAccess({threadGroup})
>     java.lang.RuntimePermission "modifyThreadGroup"

~~~~~~~~~

>     public final void stop()
>     checkAccess(this).
>     checkPermission
>     java.lang.RuntimePermission "modifyThread"
>     java.lang.RuntimePermission "stopThread"

El código de verificación de accesos debería llamar a checkAccess y pasarlo a java.lang.RuntimePermission "modifyThread", a menos que thread actul intente parar otro thread distinto a sí mismo. En este caso, el código de verificación de acceso debería llamat a checkPermission y pasarlo a java.lang.RuntimePermission "stopThread".
~~~~~~~~~

>     public final synchronized void
>     	stop(Throwable obj)
>     checkAccess(this).
>     checkPermission
>     java.lang.RuntimePermission "modifyThread"
>     java.lang.RuntimePermission "stopThread"

El código de verificación de accesos debería llamar a checkAccess y pasarlo a java.lang.RuntimePermission "modifyThread", a menos que thread actul intente parar otro thread distinto a sí mismo. En este caso, el código de verificación de acceso debería llamat a checkPermission y pasarlo a java.lang.RuntimePermission "stopThread".
~~~~~~~~~

>     Thread()
>     Thread(Runnable target)
>     Thread(String name)
>     Thread(Runnable target, String name)
>     checkAccess({parentThreadGroup})
>     java.lang.RuntimePermission "modifyThreadGroup"

~~~~~~~~~

>     Thread(ThreadGroup group, ...)
>     checkAccess(this) for ThreadGroup methods, or
>     checkAccess(group) for Thread methods
>     java.lang.RuntimePermission "modifyThreadGroup"

### java.lang.ThreadGroup

>     public final void checkAccess()
>     public int enumerate(Thread list[])
>     public int enumerate(Thread list[],
>     	boolean recurse)
>     public int enumerate(ThreadGroup list[])
>     public int enumerate(ThreadGroup list[],
>     	boolean recurse)
>     public final ThreadGroup getParent()
>     public final void
>     	setDaemon(boolean daemon)
>     public final void setMaxPriority(int pri)
>     public final void suspend()
>     public final void resume()
>     public final void destroy()
>     checkAccess(this) for ThreadGroup methods, or
>     checkAccess(group) for Thread methods
>     java.lang.RuntimePermission "modifyThreadGroup"

~~~~~~~~~

>     ThreadGroup(String name)
>     ThreadGroup(ThreadGroup parent,
>     String name)
>     checkAccess({parentThreadGroup})
>     java.lang.RuntimePermission "modifyThreadGroup"

~~~~~~~~~

>     public final void interrupt()
>     checkAccess(this)
>     java.lang.RuntimePermission "modifyThreadGroup"
>     java.lang.RuntimePermission "modifyThread"

El código de verificación de accesos para este método también requiere java.lang.RuntimePermission "modifyThread" porque el método java.lang.Thread interrupt() se llama para cada thread en el grupo de threads y todos sus subgrupos.
~~~~~~~~~

>     public final void stop()
>     checkAccess(this)
>     java.lang.RuntimePermission "modifyThreadGroup"
>     java.lang.RuntimePermission "modifyThread"
>     java.lang.RuntimePermission "stopThread"

El código de verificación de accesos para este método también requiere java.lang.RuntimePermission "modifyThread" porque el método java.lang.Thread interrupt() se llama para cada thread en el grupo de threads y todos sus subgrupos.

### java.lang.reflect.AccessibleObject

>     public static void setAccessible(...)
>     public void setAccessible(...)
>     checkPermission
>     java.lang.reflect.ReflectPermission
>     	"suppressAccessChecks"

### java.net.Authenticator

>     public static PasswordAuthentication
>       requestPasswordAuthentication(InetAddress addr,
>         				int port,
>     				String protocol,
>     				String prompt,
>     				String scheme)
>     checkPermission
>     java.net.NetPermission
>     	"requestPasswordAuthentication"

~~~~~~~~~

>     public static void
>     	setDefault(Authenticator a)
>     checkPermission
>     java.net.NetPermission "setDefaultAuthenticator"

### java.net.DatagramSocket

>     public void send(DatagramPacket p)
>     checkMulticast(p.getAddress())
>     checkConnect(p.getAddress().getHostAddress(),
>     	     p.getPort())
>     java.net.SocketPermission((
>     	     p.getAddress()).getHostAddress(),
>     	     "accept,connect")
>     java.net.SocketPermission "{host}","resolve"

El código de verificación de acceso para send llama a checkMulticast en los siguientes casos:

>     if (p.getAddress().isMulticastAddress()) {
>       java.net.SocketPermission(
>         (p.getAddress()).getHostAddress(),
>          "accept,connect")
>     }

El código de verificación de acceso para send llama a checkConnect en los siguientes casos:

>     else {
>       port = p.getPort();
>       host = p.getAddress().getHostAddress();
>       if (port == -1) java.net.SocketPermission
>     			"{host}","resolve";
>       else java.net.SocketPermission
>     			"{host}:{port}","connect"
>     }

~~~~~~~~~

>     public InetAddress getLocalAddress()
>     checkConnect({host}, -1)
>     java.net.SocketPermission "{host}", "resolve"

~~~~~~~~~

>     DatagramSocket(...)
>     checkListen({port})

El código de verificación de acceso para este método llama a checkListen y le pasa permisos de sockets de esta forma:

>     if (port == 0)
>       java.net.SocketPermission "localhost:1024-",
>     			    "listen";
>     else
>       java.net.SocketPermission "localhost:{port}",
>     			    "listen"

~~~~~~~~~

>     public synchronized void receive(DatagramPacket p)
>     checkAccept({host}, {port})
>     java.net.SocketPermission "{host}:{port}",
>     			  "accept"

### java.net.HttpURLConnection

>     public static void setFollowRedirects(boolean set)
>     checkSetFactory
>     java.lang.RuntimePermission "setFactory"

### java.net.InetAddress

>     public String getHostName()
>     public static InetAddress[]
>             getAllByName(String host)
>     public static InetAddress getLocalHost()
>     checkConnect({host}, -1)
>     java.net.SocketPermission "{host}", "resolve"

### java.net.MulticastSocket

>     public void joinGroup(InetAddress mcastaddr)
>     public void leaveGroup(InetAddress mcastaddr)
>     checkMulticast(InetAddress)
>     java.net.SocketPermission(
>     		mcastaddr.getHostAddress(),
>             "accept,connect")

~~~~~~~~~

>     public synchronized void
>     	send(DatagramPacket p, byte ttl)
>     checkMulticast(p.getAddress(), ttl)
>     checkConnect(p.getAddress().getHostAddress(),
>     	     p.getPort())
>     java.net.SocketPermission((
>     	     p.getAddress()).getHostAddress(),
>                  "accept,connect")
>     java.net.SocketPermission "{host}","resolve"

El código de verificación de acceso para send llama a checkMulticast en los siguientes casos:

>     if (p.getAddress().isMulticastAddress()) {
>       java.net.SocketPermission(
>         (p.getAddress()).getHostAddress(),
>          "accept,connect")
>     }

El código de verificación de acceso para este método llama a checkConnect en los siguientes casos:

>     else {
>       port = p.getPort();
>       host = p.getAddress().getHostAddress();
>       if (port == -1) java.net.SocketPermission
>     	"{host}","resolve"
>       else java.net.SocketPermission
>     	"{host}:{port}","connect"
>     }

~~~~~~~~~

>     MulticastSocket(...)
>     checkListen({port})

El código de verificación de acceso para este método llama a checkListen en los siguientes casos:

>     if (port == 0)
>       java.net.SocketPermission
>     	"localhost:1024-", "listen";
>     else
>       java.net.SocketPermission
>     	"localhost:{port}","listen"

### java.net.ServerSocket

>     ServerSocket(...)
>     checkListen({port})

El código de verificación de acceso para este método llama a checkListen en los siguientes casos:

>     if (port == 0)
>       java.net.SocketPermission
>     	"localhost:1024-","listen";
>     else
>       java.net.SocketPermission
>     	"localhost:{port}","listen"

~~~~~~~~~

>     public Socket accept()
>     protected final void implAccept(Socket s)
>     checkAccept({host}, {port})
>     java.net.SocketPermission
>     	"{host}:{port}", "accept"

~~~~~~~~~

>     public static synchronized void
>     	setSocketFactory(...)
>     checkSetFactory
>     java.lang.RuntimePermission "setFactory"

### java.net.Socket

>     public static synchronized void
>     	setSocketImplFactory(...)
>     checkSetFactory
>     java.lang.RuntimePermission "setFactory"

~~~~~~~~~

>     Socket(...)
>     checkConnect({host}, {port})
>     java.net.SocketPermission
>     	"{host}:{port}", "connect"

### java.net.URL

>     public static synchronized void
>     	setURLStreamHandlerFactory(...)
>     checkSetFactory
>     java.lang.RuntimePermission "setFactory"

~~~~~~~~~

>     URL(...)
>     checkPermission
>     java.net.NetPermission "specifyStreamHandler"

### java.net.URLConnection

>     public static synchronized void
>     	setContentHandlerFactory(...)
>     public static void setFileNameMap(
>     	FileNameMap map)
>     checkSetFactory
>     java.lang.RuntimePermission "setFactory"

### java.net.URLClassLoader

>     URLClassLoader(...)
>     checkCreateClassLoader
>     java.lang.RuntimePermission "createClassLoader"

### java.rmi.activation.ActivationGroup

>     public static synchronized ActivationGroup
>     	createGroup(...)
>     public static synchronized void setSystem(
>     	ActivationSystem system)
>     checkSetFactory
>     java.lang.RuntimePermission "setFactory"

### java.rmi.server.RMISocketFactory

>     public synchronized static void setSocketFactory(...)
>     checkSetFactory
>     java.lang.RuntimePermission "setFactory"

### java.security.Identity

>     public void addCertificate(...)
>     checkSecurityAccess("addIdentityCertificate")
>     java.security.SecurityPermission
>     	"addIdentityCertificate"

~~~~~~~~~

>     public void removeCertificate(...)
>     checkSecurityAccess("removeIdentityCertificate")
>     java.security.SecurityPermission
>     	"removeIdentityCertificate"

~~~~~~~~~

>     public void setInfo(String info)
>     checkSecurityAccess("setIdentityInfo")
>     java.security.SecurityPermission
>     	"setIdentityInfo"

~~~~~~~~~

>     public void setPublicKey(PublicKey key)
>     checkSecurityAccess("setIdentityPublicKey")
>     java.security.SecurityPermission
>     	"setIdentityPublicKey"

~~~~~~~~~

>     public String toString(...)
>     checkSecurityAccess("printIdentity")
>     java.security.SecurityPermission
>     	"printIdentity"

### java.security.IdentityScope

>     protected static void setSystemScope()
>     checkSecurityAccess("setSystemScope")
>     java.security.SecurityPermission
>     	"setSystemScope"

### java.security.Permission

>     public void checkGuard(Object object)
>     checkPermission(this)

Este objeto Permission es el permiso chequeado.

### java.security.Policy

>     public static Policy getPolicy()
>     checkPermission
>     java.security.SecurityPermission "getPolicy"

~~~~~~~~~

>     public static void setPolicy(Policy policy);
>     checkPermission
>     java.security.SecurityPermission "setPolicy"

~~~~~~~~~

### java.security.Provider

>     public synchronized void clear()
>     checkSecurityAccess("clearProviderProperties."
>     		    +{name})
>     java.security.SecurityPermission
>     	"clearProviderProperties.{name}"

En este método name es el nombre del proveedor.
~~~~~~~~~

>     public synchronized Object put(Object key,
>     			       Object value)
>     checkSecurityAccess("putProviderProperty."
>     			       +{name})
>     java.security.SecurityPermission
>     	"putProviderProperty.{name}"

En este método name es el nombre del proveedor.
~~~~~~~~~

>     public synchronized Object remove(Object key)
>     checkSecurityAccess("removeProviderProperty."
>     		    +{name})
>     java.security.SecurityPermission
>     	"removeProviderProperty.{name}"

En este método name es el nombre del proveedor.

### java.security.SecureClassLoader

>     SecureClassLoader(...)
>     checkCreateClassLoader
>     java.lang.RuntimePermission "createClassLoader"

### java.security.Security

>     public static void getProperty(String key)
>     checkPermission
>     java.security.SecurityPermission "getProperty.{key}"

~~~~~~~~~

>     public static int addProvider(Provider provider)
>     public static int insertProviderAt(
>     			Provider provider,
>     			int position);
>     checkSecurityAccess("insertProvider."
>     			+provider.getName())
>     java.security.SecurityPermission
>     		"insertProvider.{name}"

~~~~~~~~~

>     public static void removeProvider(String name)
>     checkSecurityAccess("removeProvider."+name)
>     java.security.SecurityPermission "removeProvider.{name}"

~~~~~~~~~

>     public static void setProperty( String key,
>     			       	String datum)
>     checkSecurityAccess("setProperty."+key)
>     java.security.SecurityPermission
>     				"setProperty.{key}"

### java.security.Signer

>     public PrivateKey getPrivateKey()
>     checkSecurityAccess("getSignerPrivateKey")
>     java.security.SecurityPermission
>     	"getSignerPrivateKey"

~~~~~~~~~

>     public final void setKeyPair(KeyPair pair)
>     checkSecurityAccess("setSignerKeypair")
>     java.security.SecurityPermission
>     	"setSignerKeypair"

### java.util.Locale

>     public static synchronized void setDefault(
>     	Locale newLocale)
>     checkPermission
>     java.util.PropertyPermission
>     	"user.language","write"

### java.util.zip.ZipFile

>     ZipFile(String name)
>     checkRead
>     java.io.FilePermission "{name}","read"

Ozito