Evoluzione e concetti della sicurezza Java, Parte 3: sicurezza dell'applet

La crescita iniziale di Java è stata stimolata dal codice scaricabile su una rete, meglio conosciuto come applet. La sicurezza delle applet si è evoluta con la crescita di Java e oggi è fonte di frequente confusione a causa della varietà di versioni di Java, browser disponibili in commercio e plug-in.

Questo articolo, il terzo della serie, coprirà i vari requisiti per eseguire in modo sicuro il codice Java scaricato da una rete. Sebbene il codice mobile non sia un concetto rivoluzionario, Java e Internet presentano alcune sfide uniche alla sicurezza del computer. L'evoluzione dell'architettura Java e il suo impatto sulla sicurezza di base di Java è stata discussa nelle parti 1 e 2. Questo articolo ha un approccio diverso: un approccio pratico per legare insieme tutti i concetti distribuendo una semplice applet che scrive nel filesystem locale .

Evoluzione e concetti della sicurezza Java: leggi l'intera serie!

  • Parte 1: apprendi concetti e termini sulla sicurezza del computer in questa panoramica introduttiva
  • Parte 2: scopri i dettagli della sicurezza Java
  • Parte 3: affronta la sicurezza delle applet Java con sicurezza
  • Parte 4: scopri come i pacchetti opzionali estendono e migliorano la sicurezza Java
  • Parte 5: J2SE 1.4 offre numerosi miglioramenti alla sicurezza Java

Al centro dell'applet di esempio c'è la crittografia a chiave pubblica, introdotta in precedenza in questa serie. Il codice firmato utilizzando la chiave privata del firmatario può essere eseguito sui computer client una volta che la chiave pubblica corrispondente al firmatario è considerata attendibile sulla rispettiva macchina. Discuteremo anche di come i file dei criteri, che concedono autorizzazioni e keystore, possono essere utilizzati come repository per chiavi pubbliche e private. Inoltre, metteremo in evidenza gli strumenti di sicurezza di Java 2 SDK e Netscape signtool, poiché consentono la distribuzione.

Questo articolo traccia l'evoluzione della sicurezza Java, a partire dalla sicurezza delle applicazioni nella versione iniziale di Java 2 e passando all'ultima versione di Java 2, versione 1.3. Questo approccio aiuta a introdurre i concetti gradualmente, partendo da concetti molto semplici e culminando in un esempio abbastanza avanzato.

Questa serie non intende fornire una guida completa alla sicurezza informatica. La sicurezza informatica è una questione multiforme che tocca diverse discipline, dipartimenti e culture. Gli investimenti in tecnologie dovrebbero essere seguiti da investimenti nella formazione del personale, nell'applicazione rigorosa delle politiche e nella revisione periodica della politica di sicurezza generale.

Nota: questo articolo presenta un'applet Java in esecuzione progettata per dimostrare i problemi di sicurezza dell'applet. Leggere sotto per ulteriori dettagli.

Sicurezza delle applicazioni

Iniziamo la nostra indagine esaminando la sicurezza delle applicazioni. Nella Parte 2 abbiamo visto come la sicurezza Java si è evoluta da un modello sandbox a un modello di sicurezza granulare. Abbiamo anche visto che le applicazioni (codice locale) per impostazione predefinita ottengono un regno gratuito e non sono soggette allo stesso controllo delle applet (codice scaricabile dalla rete), che sono generalmente considerate non attendibili. In un cambiamento rispetto al passato, in Java 2 le applicazioni di sicurezza possono essere facoltativamente soggette allo stesso livello di controllo delle applet.

Innanzitutto, una breve nota sul writeFile.javacodice utilizzato in questo articolo per illustrare le funzionalità di sicurezza in Java 2. Questo programma è una versione leggermente modificata del codice dell'applet fornito da Sun, disponibile sul Web per illustrare alcune delle funzionalità di Java 2 sicurezza. Il programma, modificato per fornire supporto all'applicazione, tenta di creare e scrivere un file sul filesystem locale. L'accesso a un file system locale è controllato dal gestore della sicurezza. In questo articolo vedremo come questa particolare operazione può essere consentita in modo sicuro.

/ ** * Per impostazione predefinita, questo solleva un'eccezione di sicurezza come applet. * * Con JDK 1.2 appletviewer, * se configuri il tuo sistema per garantire applet firmati da "Duke" * e scaricati dal sito Web del software Java per scrivere un file * nella tua directory / tmp (o nel file denominato "C: \ tmpfoo "su un sistema * Windows), quindi questa applet può essere eseguita. * * @version JDK 1.2 * @author Marianne Mueller * @Modified by Raghavan Srinivas [Rags] * / import java.awt. *; import java.io. *; import java.lang. *; import java.applet. *; la classe pubblica writeFile estende l'applet {String myFile = "/ tmp / foo"; File f = nuovo file (myFile); DataOutputStream dos; public void init () {String osname = System.getProperty ("os.name"); if (osname.indexOf ("Windows")! = -1) {myFile = "C:" + File.separator + "tmpfoo";}} public void paint (Graphics g) {try {dos = new DataOutputStream (new BufferedOutputStream (new FileOutputStream (myFile), 128)); dos.writeBytes ("I gatti possono ipnotizzarti quando meno te lo aspetti \ n"); dos.flush (); dos.close (); g.drawString ("Scritto con successo nel file denominato" + myFile + "- dai un'occhiata!", 10, 10); } catch (SecurityException e) {g.drawString ("writeFile: cattura eccezione di sicurezza", 10, 10); } catch (IOException ioe) {g.drawString ("writeFile: ha catturato eccezione i / o", 10, 10); }} public static void main (String args []) {Frame f = new Frame ("writeFile"); writeFile writefile = new writeFile (); writefile.init (); writefile.start (); f.add ("Center", writefile); f.setSize (300, 100); f.show (); }}}}}}I gatti possono ipnotizzarti quando meno te lo aspetti \ n "); dos.flush (); dos.close (); g.drawString (" Scritto con successo nel file denominato "+ myFile +" - dai un'occhiata ! ", 10, 10);} catch (SecurityException e) {g.drawString (" writeFile: catch security exception ", 10, 10);} catch (IOException ioe) {g.drawString (" writeFile: catch i / o eccezione ", 10, 10);}} public static void main (String args []) {Frame f = new Frame (" writeFile "); writeFile writefile = new writeFile (); writefile.init (); writefile.start ( ); f.add ("Center", writefile); f.setSize (300, 100); f.show ();}}I gatti possono ipnotizzarti quando meno te lo aspetti \ n "); dos.flush (); dos.close (); g.drawString (" Scritto con successo nel file denominato "+ myFile +" - dai un'occhiata ! ", 10, 10);} catch (SecurityException e) {g.drawString (" writeFile: catch security exception ", 10, 10);} catch (IOException ioe) {g.drawString (" writeFile: catch i / o eccezione ", 10, 10);}} public static void main (String args []) {Frame f = new Frame (" writeFile "); writeFile writefile = new writeFile (); writefile.init (); writefile.start ( ); f.add ("Center", writefile); f.setSize (300, 100); f.show ();}}} catch (SecurityException e) {g.drawString ("writeFile: cattura eccezione di sicurezza", 10, 10); } catch (IOException ioe) {g.drawString ("writeFile: ha rilevato un'eccezione i / o", 10, 10); }} public static void main (String args []) {Frame f = new Frame ("writeFile"); writeFile writefile = new writeFile (); writefile.init (); writefile.start (); f.add ("Center", writefile); f.setSize (300, 100); f.show (); }}} catch (SecurityException e) {g.drawString ("writeFile: cattura eccezione di sicurezza", 10, 10); } catch (IOException ioe) {g.drawString ("writeFile: ha rilevato un'eccezione i / o", 10, 10); }} public static void main (String args []) {Frame f = new Frame ("writeFile"); writeFile writefile = new writeFile (); writefile.init (); writefile.start (); f.add ("Center", writefile); f.setSize (300, 100); f.show (); }}

L'esecuzione del bytecode generato in un Java 2 Runtime Environment, Standard Edition (JRE) consentirà all'applicazione di modificare il file sul file system locale per impostazione predefinita, poiché la politica predefinita non sottopone le applicazioni Java 2 a un gestore della sicurezza. Questa politica è giustificata perché le applicazioni sono in genere codice generato localmente e non vengono scaricate in rete. La seguente riga di comando produce la finestra mostrata nella Figura 1, che indica che il file è stato creato e scritto.

$ java writeFile 

Per sottoporre il codice al gestore della sicurezza Java 2, richiamare la seguente riga di comando, che dovrebbe produrre i risultati indicati nella Figura 2. Si noti che l'applicazione ha generato un'eccezione di sicurezza causata da un tentativo di modificare il filesystem locale. Il gestore della sicurezza esplicitamente incluso ha generato l'eccezione.

$ java -Djava.security.manager writeFile 

I casi illustrati sopra rappresentano esempi estremi di politica di sicurezza. Nel primo caso la domanda non è stata sottoposta ad alcun controllo; in quest'ultimo era soggetto a un controllo molto rigido. Nella maggior parte dei casi sarà necessario impostare la politica da qualche parte nel mezzo.

È possibile realizzare un criterio intermedio utilizzando un file di criteri. A tale scopo, creare un file di criteri chiamato all.policynella directory di lavoro:

concedi {autorizzazione java.io.FilePermission "<>", "write"; };

L'esecuzione della stessa parte di codice con la seguente riga di comando consentirà la modifica del filesystem locale:

$ java -Djava.security.manager -Djava.security.policy = all.policy writeFile 

In questo esempio, l'applicazione era soggetta al gestore della sicurezza, ma la politica generale era governata dal file della politica, che consentiva di modificare tutti i file sul filesystem locale. Una politica più rigorosa avrebbe potuto essere quella di consentire la modifica solo del file pertinente, tmpfooin questo caso.

Tratterò maggiori dettagli del file dei criteri, inclusa la sintassi delle voci, più avanti in questo articolo. Ma prima, esaminiamo la sicurezza delle applet e confrontiamola con la sicurezza delle applicazioni.

Sicurezza dell'applet

Finora abbiamo studiato la sicurezza delle applicazioni. Pertanto, è possibile accedere e modificare la maggior parte delle funzionalità di sicurezza tramite la riga di comando. Fornire una politica adeguatamente sicura e tuttavia piuttosto flessibile in un ambiente applet si rivela sostanzialmente più impegnativo. Inizieremo esaminando la distribuzione di un'applet in Appletviewer. Più avanti esamineremo le applet distribuite dal browser.

La politica del codice Java è dettata principalmente da CodeSource, che comprende due informazioni: il luogo in cui ha avuto origine il codice e la persona che lo ha firmato.

Appletviewer

Crea un file chiamato writeFile.htmlcon i seguenti contenuti:

  Esempio di protezione Java: scrittura di file 
   

Running the applet with the following command line would result in the window shown in Figure 3:

$ appletviewer writeFile.html 

Notice that -- in contrast to what would happen with an application -- the applet generated an exception since the applet is subject to the security manager by default. The installation can be governed by a customizable policy, if required. Running the following command line:

appletviewer -J"-Djava.security.policy=all.policy" writeFile.html 

would, as you might expect, allow modification of the tmpfoo file, since this was permitted in accordance with the policy file.

Browsers

Applet security in browsers strives to prevent untrusted applets from performing potentially dangerous operations, while simultaneously allowing optimal access to trusted applets. Applet security deployment in browsers is substantially different from what we have seen so far, primarily due to the following reasons:

  • A default lack of trust in code downloaded over the network
  • Insufficient access to the command-line options for running the JVM, since the JVM is hosted in the context of a browser
  • Inadequate support for some of the latest security features in the JVMs bundled with browsers

As for the first problem, to obviate the potential problems resulting from running untrusted code, earlier versions of Java used the sandbox model (see "Sidebar 1: Sandbox Model"). Trust is a largely philosophical or emotional issue, rather than a technical issue; however, technology can help. For example, Java code can be signed using certificates. In this example, the signer implicitly vouches for the code by signing it. The onus is ultimately upon the user running the code to trust the signing entity or not, given that these certificates guarantee that the code was indeed signed by the intended person or organization.

The second problem stems from the lack of access to the options for running the JVM in the browser context. For example, there is no simple way to deploy and use customized policy files as we could in the previous example. Instead, such policies will have to be set by files based on the JRE installation. Customized class loaders or security managers cannot be installed easily.

The third problem, the lack of support for the latest versions of the JRE in the default JVM with the browser, is solved by using the Java plug-in (see "Sidebar 2: Java Plug-in Primer"). Indeed, an underlying issue is that modification of policy files is not very straightforward. Since applets may be deployed on thousands or even millions of client machines, there might be environments where users might not have a good understanding of security or may not be acquainted with methods for modifying the policy file. The Java plug-in provides a workaround, although it's recommended to use policy files wherever practical and applicable.

Next, we'll look in more detail at applet security involving code-signing examples in a browser environment with a Java plug-in. We will confine the discussion to Java plug-in version 1.3 unless explicitly stated otherwise.

The Java plug-in and security

The Java plug-in supports the standard Java 2 SDK, Standard Edition (J2SE), including the security model. All applets run under the standard applet security manager, which prevents potentially malicious applets from performing dangerous operations, such as reading local files. RSA-signed applets can be deployed using the Java plug-in. Additionally, the Java plug-in attempts to run applets in an identical way in both Netscape Navigator and Internet Explorer by avoiding browser-specific resources. This ensures that an RSA-signed applet will run identically in both browsers with the Java plug-in. The Java plug-in also supports HTTPS, a secure version of HTTP.

In order for a plug-in-enhanced browser to trust an applet and grant it all privileges or a set of fine-grained permissions (as specified in a J2EE policy file), the user has to preconfigure his or her cache of trusted signer certificates (the .keystore file in JRE 1.3) to add the applet's signer to it. However, this solution does not scale well if the applet needs to be deployed on thousands of client machines, and may not always be feasible because users may not know in advance who signed the applet that they are trying to run. Also, earlier versions of the Java plug-in supported code signing using DSA, which is not as widely prevalent as RSA.

A new class loader, sun.plugin.security.PluginClassLoader in the Java plug-in 1.3, overcomes the limitations mentioned above. It implements support for RSA verification and dynamic trust management.

The Software Development Kit (SDK) tools

The three tools dealing with security, available as part of the Java 2 SDK, are:

  • keytool -- Manages keystores and certificates
  • jarsigner -- Generates and verifies JAR signatures
  • policytool -- Manages policy files via a GUI-based tool

We will look at some of these tools' important options in the sections below. Refer to Resources for more detailed documentation associated with particular tools.