Développement sécurisé

Exemple tiré de [JSEBibliographie] : ouverture et écriture dans un fichier texte :

private Vector vector;
private static final int SIZE = 10;
 
PrintWriter out = null;
 
try
{
    System.out.println("Entered try statement");
    out    = new PrintWriter (new FileWriter ("OutFile.txt"));
 
    for    (int i = 0;    i <    SIZE; i++)
    {
        out.println("Value at: "+i+" = "+vector.elementAt(i));
    }
}
catch …
finally …

• FileWriter peut lever une exception de type IOException.
• PrintWriter peut lever une exception de type FileNotFoundException.
• L'appel à println ne lève jamais d'exception, comme indiqué dans la Javadoc :

Methods in this class never throw I/O exceptions, although some of its constructors may. The client may inquire as to whether any errors have occurred by invoking checkError().

Exemple tiré de [JSEBibliographie] :

try 
{
    ...
}
 
catch (FileNotFoundException e) 
{
    System.err.println("FileNotFoundException: " + e.getMessage());
    throw new SampleException(e);
}
 
catch (I0Exception e) 
{ 
    System.err.println("Caught I0Exception: IT " + e.getMessage());
}
 
finally 
{
    System.out.println("PrintWriter not open");
}

• FileNotFoundException hérite de IOException : l'ordre des catch est important.
• System.err est la sortie standard d'erreur.
• La directive finally est exécutée dans tous les cas après un ou aucun catch.

Une méthode qui lève une exception la déclare dans son prototype à l'aide du mot-clé throws (à ne pas confondre avec throw):

• obligation pour les codes appelant de choisir entre :
  • récupérer l'exception (à l'aide d'un try/catch),
  • laisser remonter l'exception en la filtrant (et filtrer les exceptionsFiltrer les exceptions),
  • laisser remonter l'exception en la retypant (et chaînes d'exceptionsChaîne d'exception) ;
• plusieurs exceptions peuvent être déclarées (séparation par une virgule). Une méthode peut lever une ou plusieurs exceptions :

public void writeList() throws I0Exception 
{ … }
public void writeList() throws FileNotFoundException, EOFException 
{ … }

Le main est un cas particulier qui fait remonter l'exception jusqu'à la virtual machine qui arrête alors l'exécution :

public static void main(String args[]) throws Exception { ...

Lever une exception consiste à arrêter l'exécution normale du programme et à « lancer » une exception à travers un objet nouvellement instancié, héritant de Throwable qui va remonter la pile d'appels des fonctions.

• Lever une exception se fait à l'aide de throw(e).
• L'objet créé est une instance d'une classe d'exception

public Object pop() 
{
    if (size == 0) 
    {
        throw new EmptyStackException(); 
    }
    ...

• Un bloc catch(X e) capture une exception de type Y si Y est une sous-classe de X.
• On peut donc « filtrer » les exceptions par des catchs successifs :
  • le premier catch filtre l'exception la plus typée ;
  • les catch suivants filtrent les exceptions de type plus général ;
  • c'est le principe du tamis filtrant du sable mélange à du gravier…

try 
{
   …
}
catch (FileNotFoundException e) 
{ 
    System.Prr.println("Erreur d'ouverture de fichier.");
}
catch (I0Exception e) 
{ 
    System.err.println("Erreur d'entrée/sortie.");
}

Une chaîne d'exception permet de faire suivre une exception en la retypant.

• La récupération d'exception peut parfois ne pas être résolue : on la forward.
• Le changement de type permet de clarifier le type du problème :
  • NullPointerException : peu précis ;
  • I0FileException : mieux ;
  • I0CarWriterException : très précis

public class IOCarWriter 
{
    public write()
    {
        try 
        {
            ...
        }
        catch (I0FileException e) 
        {
            throw new IOCarWriterException("Other I0Exception", e);
        } 
    } 
}
 
public class CarManager 
{
    IOCarWriter writer = new IOCarWriter();
    try 
    {
        writer.write();
    }
    catch (I0CarWriterException e) 
    {
        System.err.println("Error when writing a car !");
    } 
}

• Qu'est-ce que le test ?
  • Ce n'est pas « exécuter une fois ».
  • C'est vérifier les sorties d'un programme pour une ou plusieurs exécutions dont on connaît les entrées.
• Qu'est-ce que le test unitaire ?
  • C'est tester toutes les parties d'un système compliqué (et non pas complexe).
  • C'est supposer que tester des parties permet au système de mieux fonctionner.
• Que doit-on/peut-on tester ?
  • Le comportement « normal ».
  • Le comportement aux bornes.
  • Le comportement en dehors d'une plage valide.

• Éviter les oublis : votre objectif est de passer le test unitaire.
• Réduire le nombre de bogues : chercher un bogue coûte cher.
• Éviter les régressions de code lors d'ajouts, refactoring, modifications.
• Faciliter le travail en équipe : le test d'autrui est testé et de confiance.

Avant une batterie de tests, il faut souvent faire des opérations pour instancier les objets, ouvrir les fichiers, ouvrir les sockets nécessaires aux tests. C'est l'installation du test (fixture en anglais). Deux tags Junit sont prévus pour cela :

• @Before : méthode appelée avant le test ;
• @After : méthode appelée avant le test.

public class MoneyTest 
{ 
    private Money f12CHF; 
    private Money f14CHF; 
    private Money f28USD;
 
    @Before public void setUp() 
    { 
        f12CHF= new Moneyk12, "CHF"); 
        f14CHF= new Money(14, "CHF"); 
        f28USD= new Money(28, "USD"); 
    }
}

Exécution des tests unitaires dans Eclipse :

Trying:
    factorial (3)
Expecting:
    6
ok
1 items had no tests:
    __main__
1 items passed all tests:
    1 tests in __main__ .factorial 
1 tests in 2 items.
1 passed and 0 failed.
Test passed.

En cas d'échec du test :

Failed example: 
    factorial (3)
Expected:
    6 
Got:
    7

Le fichier contenant les tests peut être externe au programme. En fait, les tests peuvent être situés dans n'importe quel document texte

Ceci est un fichier texte banal. Il contient des tests,
mais il faut auparavant faire l'import du module concern2: 
    >>> from example import factorial
Le test en lui-meme :
    >>> factorial(6)
    120

Le main consiste alors à exécuter les tests du fichier :

doctest.testfile("factoriel_test_externe.txt")

Failed example:
    factorial (6)
Expected:
    120 
Got:
    720

Doctest se base sur la comparaison de l'output de la fonction testée avec l'output fourni dans le test. Certaines règles particulières sont à connaître :

• les lignes vides ne sont pas autorisées : elles servent de délimiteur pour signaler la fin de l'output (utiliser <BLANKLINE> à la place dans le test) ;
• stderr est ignoré ; seul stdout est capturé ;
• si un backslash est attendu en output, des raw strings doivent être utilisées

r"""
>>> machin(3)
6\n4
"""

Expected:
    6\n4
Got
    6
    4

Unitest est un ensemble de classes permettant de développer des tests en utilisant les concepts suivants :

• test fixture : préparation du test (création d'objets, lancement de serveurs, proxys) ;
• test case : un test unitaire à proprement parler ;
• test suite : un ensemble de tests à exécuter successivement ;
• test runner : orchestration des tests et rapports à l'utilisateur (texte, graphique).

Unittest et doctest

Unittest est capable d'appeler des tests doctets :

import unittest
import doctest
import my module_with_doctests, and another
 
suite    unittest.TestSuite()
 
for mod in my_module_with_doctests, and_another: 
    suite.addTest(doctest DocTestSuite(mod)) 
runner = unittest TextTestRunner()
runner.run(suite)

Le Bytecode verifier

Le Bytecode verifier s'assure que byte code ne viole pas des règles du langage Java (cf. Le Bytecode verifierLe Bytecode verifier). Toutes les classes ne sont pas vérifiées, notamment celle du core API.

Le class loader

Le class loader est responsable du chargement des classes qui ne sont pas trouvées dans le CLASSPATH.

L'access controller

Il autorise ou interdit les accès des classes du core API vers l'operating system. C'est une sorte de contrôle des appels système.

Le security manager

Prend les décisions d'accès aux ressources du système (fichiers, réseau, etc.) en fonction de la politique chargée. II peut coopérer avec raccess controller pour une partie de ses décisions.

Le security package

Le package java.security est un ensemble d'outils dédiés aux mécanismes d'authentification des classes Java signées (clés, certificats, signatures, cryptage).

File permission : java.io.FilePermission

permission java.io.FilePermission "tmpFoo", "write";
permission java.io.FilePermission "<<ALL FILES>>",
                                  "read,write,delete,execute";
permission java.io.FilePermission "Sfuser.homel/-", "read";

Socket permission : java.net.SocketPermission

permission java.net.SocketPermission "www.ensi-bourges.fr:1-", 
                                     "accept,listen,connect,resolve"

Runtime permission : java.lang.RuntimePermission

createClassLoader, getClassLoader, createSecurityManager, setI0, stopThread.

permission java.lang.RuntimePermission "accessClassInPackage.sdo.foo";

Security permission : java.io.SerialisablePermission

enableSubstitution : autorise enableReplaceObject() de ObjectInputStream. enableSubclassImplementation : autorise la surcharge de readObjet() et writeObject().

Property permission : java.util.PropertyPermission

permission java.util.PropertyPermission "java.*", "read";

All permission : java.security.AIIPermission.

Fichiers :

file:/C:/files/truc.txt
file://files/truc.txt
file:${java.home}/files/truc.txt

URL :

// One jar filer
http://www.ensi-bourges.fr/files/truc.jar 
// Class files:
http://www.ensi-bourges.fr/files/
// Class and jar files:
http://www.ensi-bourges.fr/files/*
// Class and jar files in any sub directories: 
http://www.ensi-bourges.fr/files/-

Permettre le sandboxing :

Java -Djava.security.manager TestEcriture
Exception in thread "main" java.security.AccessControlException:
access denied (java.io.FilePermission testEcriture.txt write)

Préciser une politique (URL du type HTTP ou file) :

java -Djava.security.manager -Djava.security.policy=URL TestEcriture

Préciser une et une seule politique :

java -Djava.security.manager -Djava.security.policy==URL TestEcriture

Appletviewer :

appletviewer -J-Djava.security.policy=URL urls

Changer de security manager :

• récupérer le security manager courant (ou null) ;
• Installer le security manager (ne peut plus être enlevé) (utile pour une applet qui ne peut plus le changer).

public static SecurityManager getSecurityManager()
public static void setSecurityManager(SecurityManager sm)

Exemple :

public class TestSecurityManager 
{
    public static void main(String args[]) 
    {
        System.setSecurityManager(new SecurityManagerImpl()); 
        ...do the work of the application... 
    }
}

Vérification de lecture/écriture/suppression de fichier :

public void checkRead(FileDescriptor fd) 
public void checkRead(String file) 
public void checkWrite(FileDescriptor fd)
public void checkWrite(String file) 
public void checkDelete(String file)

checkRead() est appelé pour :

File.canRead()
File.isDirectory() 
File.isFile()
File.lastModified()

Extrait Javadoc :

Check if the current thread is allowed to read the given file. This method is called from FilelnputStream.FilelnputStreamO, RandomAccessFile. RandomAccessFile(), File.exists(), canReadO, isFile(), isDirectory(), lastModified(), length() and lista The default implementation checks FilePermission(filename, "read,. If you override this, call super.checkRead rather than throwing an exception.

Vérifier l'ouverture d'une socket (appel pour Socket()) :

public void checkConnect(String host, int port)

Vérifier l'écoute d'un port et l'acceptation d'une requête (appel pour ServerSocket.accept()) :

public void checkListen(int port)
public void checkAccept(String host, int port)

Changer l'implémentation par défaut d'une socket :

public void checkSetFactory()

Extrait Javadoc :

Check if the current thread is allowed to accept a connection from a particular host on a particular port. This method is called by ServerSocketimplAccept(). The default implementation checks SocketPermission(host + ":" + port, "accept,. If you override this, call super.checkAccept rather than throwing an exception.

Protection de la virtual machine :

checkCreateClassLoader() --> ClassLoader() // Changement de class loader
checkExit() --> Runtime.exit() // Arret de la virtual machine 
checkLink() --> Runtime.loadLibrary() // Chargement de code natif 
checkExec() --> Runtime.exec() // Execution de commande shell

Protection des threads avec checkAccess(Thread g) :

Thread.stop() Thread.interrupt() 
Thread.suspend() Thread.resume() 
Thread.setPriority0 Thread.setName() 
Thread.setDaemon()

Protection de l'inspection de classes avec checkMemberAccess() :

Class.getFields() 
Class.getMethods() 
Class.getConstructors()
Class.getField() 
Class.getMethod() 
Class.getConstructor()

public class CreditCard 
{
    public String acctNo = "0001 0002 0003 0004"; 
}

public class TestCreditCard 
{
    public static void main(String args[]) 
    { 
        CreditCard cc = new CreditCard(); System.out.println("Your account number is " + cc.acctNo);
    }
}

On change public en private :

jf@linotte:security/code> javac CreditCard.java 
jf@linotte:security/code> javac TestCreditCard.java 
jf@linotte:security/code> java TestCreditCard 
Your account number is 0001 0002 0003 0004
jf@linotte:security/code) gvim CreditCard.java 
jf@linotte:security/code> javac CreditCard.jaNTA 
jf@linotte:security/code> java TestCreditCard
Exception in thread "main" java.lang.IllegalAccessError:
    tried to access field CreditCard.acctNo from class
    TestCreditCard at TestCreditCard.main(TestCreditCard.java:4) 
jf@linotte:security/code> javac TestCreditCard.java 
TestCreditCard.java:4: acctNo has private access in CreditCard
System.out.println("Your account number is " + cc.acctNo);

Autre exemple tiré de [JSECBibliographie] :

• copy the java.lang.String source file into our CLASSPATH ;
• in the copy of the file, modify the definition of value--the private array that holds the actual characters of the string--to be public ;
• compile this modified class, and replace the String.class file in the JDK ;
• compile some new code against this modified version of the String class. The new code could include something like this :

public class CorruptString
{
    public static void modifyString(String src String dst) 
    { 
        for (int i = 0; i < src.length; i++) 
        {
            if (i == dst.length)
                return;
            src.value[i]    dst.value[i]; 
        }
    }
}

Now any time you want to modify a string in place, simply call this modifyString() method with the string you want to corrupt (src) and the new string you want it to have (dst).

Remove the modified version of the String class.

• Fichier .class : format correct ;
• Classes final : n'ont pas de sous-classe ;
• Méthodes final : non surchargées ;
• classe : une seule superclasse ;
• pas de cast illégal (ex. int vers object) ;
• vérification upcast/downcast ;
• data stack : débordement (récursion infinie) ;
• operand stack : no overflow/underflow.

Les vérifications sont faites avant l'exécution et/ou en temps réel :

• code vérifie avant l'exécution ;
• Remplace par un code spécial indiquant que les tests ont été faits ;
• Sinon : IllegalAccessException ;
• possibilité d'option : -noverify (ne marche plus en Java 2).

À l'exécution par exemple les casts, les bornes des tableaux :

void initArray(int a[], int nItems) 
{ 
    for (int i = 0; i < nItems; i++) 
        a[i] = 0;

Constructeur du proxy pour un objet :

Proxy(object,interface=None,passobj=None)

• interface : séquence de string autorisant l'accès aux attributs/méthodes ;
• passobj : permet d'autoriser la récupération de l'objet via .proxy_object().

Proxy avec read-cache : met en cache les attributs de l'objet wrappé

CachingInstanceProxy(object,interface=None,passobj=None)

(attention aux remises à jour de l'objet wrappé) .

Proxy de type read-only :

ReadonlyInstanceProxy(object,interface=None,passobj=None)

Proxy factory : permet de créer des instances de Class wrappe dans un Proxy

ProxyFactory(Class,interface=None)

Méthode permettant de récupérer des attributs :

• .proxy_getattr(name) : récupère l'attribut name ;
• .proxy_setattr(name) : modifie l'attribut name ;
• .proxy_defunct() : retourne 1 si l'objet a déjà été garbage collecté.

from mx import Proxy 
class DataRecord: 
    a= 2
    b= 3
    # Make read-only:
    def    public_setattr (self,what,to):
        raise Proxy.AccessError('read-only')
    # Cleanup protocol
    def    cleanup (self): 
        print 'cleaning up',self
o = DataRecord()
# wrap the instance: 
p = Proxy.InstanceProxy(o,('a',))
# Remove o from the accessible system:
del o
 
print p.proxy_getattr( 'a') 
print p.a

Pour récupérer des méthodes :

from mx import Proxy 
class DataRecord: 
    a= 2
    b= 3
    # Make read-only:
    def    public_setattr (self,what,to):
        raise Proxy.AccessError('read-only')
    # Cleanup protocol
    def    cleanup (self): 
        print 'cleaning up',self
    def essai(self): 
        print 'coucou'
o = DataRecord()
# Wrap the instance:
p = Proxy.InstanceProxy(o,('essai',))
# Remove o from the accessible system:
del o
 
print p.essai()
print p.b # Ne marche pas