Le protocole de sécurité choisi pour mettre en oeuvre cette sécurité est SSL (Secure Socket Layer). Ce protocole a été développé par Netscape Communication Corporation pour permettre le transfert sécurisé de données sur Internet.
SSL opère à l'interface des sockets TCP. En conséquence,
tous les protocoles de la couche application comme HTTP, FTP, Telnet,
IIOP ... peuvent être protégés par un canal de transmission
sécurisée. En utilisant HTTP, une connexion SSL peut être
reconnue par l'URL de type https. Autrement dit, https désigne
le protocole HTTP mis en oeuvre sur une couche de transport sécurisée.
SSL est implanté dans la plupart des navigateurs (Netscape Navigator,
Microsoft Internet Explorer), et également dans les serveurs (Netscape
Server, Apache, NCSA).
La connexion du client au serveur de commerce lors de l'émission
de l'ordre d'achat doit être sécurisée. En effet, le
client doit recevoir la garantie que le serveur de commerce est bien celui
qu'il prétend être (authentification) et que les informations
transmises (numéro de carte bleue) restent confidentielles.
Remarquons que, quelque soient les mesures de sécurité prises,
le client n'est pas à l'abri d'une malveillance venant du serveur.
Certains protocoles (SET) permettent de résoudre ce problème.
Pratiquement toutes les parties intervenantes dans l'application Gicom
doivent pouvoir etre authentifiées, et doivent donc posséder
un point d'entrée SSL. Dans le cadre de ce projet, seule la partie
Serveur de nom, pour laquelle nous ne demandons pas de modification de
code, ne sera pas sécurisée.
Les opérations d'authentification seront
réalisées au niveau de l'application. Un objet Compte
d'une agence bancaire sera chargé d'authentifier les clients des
méthodes de préparation et de validation d'opérations
de débit/crédit .
De même le serveur de transaction devra
authentifier le coordinateur de la transaction comme étant un serveur
de commerce. Il vérifiera également que les ressources sont
des comptes bancaires.
Enfin, le serveur de commerce devra authentifier
le serveur de transactions.
Modeles à clés secrètes partagées
< a faire >
Kerberos
Modeles à clés publiques (algorithmes de chiffrement asymétrique)
Le principe des algorithmes a chiffrement asymetrique est qu'ils mettent
en jeu un couple de cles, dont l'une sert au chiffrement et l'autre au
dechiffrement. La cle de chiffrement est la cle publique, c'est a dire
que tout le monde peut demander a une entite sa cle publique (ou bien a
un annuaire), et utiliser cette cle pour envoyer un message confidentiel
a E en chiffrant le message selon un algorithme standart (RSA, DSA, ..).
Seul E pourra dechiffrer le message a l'aide de sa cle privee.
Remarquons qu'il est necessaire d'avoir confiance en la cle publique
du destinataire du message, et pour ce faire, on utilise une tierce autorite
delivrant des certificats (section suivante).
Si la méthode de production des clés satisfait en outre la propriété de commutativité, alors E2 peut également utiliser sa clé privée pour renvoyer un message crypté M' a E1, qui sera décryptable avec la clé publique de E2. Le message M' est par contre non confidentiel pusque toutes les entites connaissant la cle publique de E2 peuvent le dechiffrer. Il existe des extensions au protocole permettant le renvoi de messages confidentiels de E2 vers E1.
Figure 1. Principe du mecanisme a clé publique
Il faut savoir que les algorithmes asymetriques sont assez lents au regard des algorithmes symetriques. De plus, ils utilisent des cles plus grandes. En general, ces algorithmes sont utilises pour echanger entre un client et un serveur une cle secrete qui servira a communiquer au travers d'un algorithme de chiffrement symetriques.
Un certificat doit etre signé par une entité qui assure la validité du certificat. Cette entité possède elle-même un certificat signé par une autorité supérieure. Les autorités de certification (CA) sont organisées en structure d'arbre. Au sommet de la hiérarchie se trouve le root qui signe lui-même son certificat. Un certificat X.509 est principalement composé des champs suivants :
Figure 2. Certificat de Shooping Server signe par le CA Verisign,
et certificat de Verisign
Pour pouvoir etre authentifié, un serveur (prenons pour exemple le serveur GICOM) doit faire signer son certificat par le serveur Verisign. Pour ce faire, il envoie son certificat ainsi que sa clé publique au serveur Verisign. Ce dernier, apres verification de l'identite du demandeur, renvoie une signature contenant le certificat GICOM (soit C), ainsi qu'un résumé de C encrypté avec la clé secrete de Verisign (fig 2).
Figure 3. Authentification initiale
4.1 Exemple de Handshake
Le handshake permet au client et au serveur de s'authentifier mutuellement,
et de choisir un algorithme cryptographique qu'ils ont en commun.
Une fois la phase de handshake terminée, l'échange de données chiffrées et signées peut commencer (connexion sécurisée). Une session est créée par une phase de handshake et peut comporter de multiples connexions. Le concept de session est utilisé pour éviter de négocier les paramètres de cryptographie à chaque ouverture de connexion.
Le schéma ci-dessous représente un déroulement possible de la phase de handshake :
Le message certificate request du serveur est optionnel. Le client y répond en envoyant sa clé publique accompagnée de son certificat (certificate). Puis il s'authentifie (certificate verify) comme décrit précédemment, a l'aide d'une signature.
Le message finished est le premier message protégé avec les algorithmes négociés. Aucun acquittement n'est demandé ; les participants peuvent commencer à émettre les données chiffrées immédiatement après avoir envoyé le message finished.
Dans le cas de RSA, le gouvernement Américain limite la taille des clés pour le chiffrement à 512 bits, mais ne fixe aucune limite concernant celles utilisées pour les opérations de signature. En effet, certains certificats ont besoin de clés de taille supérieure à 512 bits car ces dernières ne sont pas suffisament sûres pour des transactions de valeur importante ou pour des applications nécessitant une sécurité à long terme. Ces certificats (sign-only certificate)sont signés avec des clés de taille supérieure à 512 bits, non autorisées pour le chiffrement des données. En conséquence, après avoir communiqué son certificat au client, le serveur signe une clé RSA de 512 bits, le maximum autorisé (server key exchange message). Cette clé temporaire sert à l'échange de clé secrète. Il est conseillé de changer de clé RSA temporaire toutes les 500 transactions.
RC2, DES et IDEA sont des algorithmes de chiffrement par blocs (block cipher).
RC2 et RC4 ont été conçus par RSA Data Security. Aucune publication n'existe sur RC2. RC4 est un algorithme de chiffrement en continu (stream cipher) à clé de longueur variable. Il a récemment été dévoilé sur Internet.
DES chiffre un texte par blocs de 64 bits. Les blocs sont chaînés de différentes façons pour que, en remplaçant un bloc par un autre le déchiffrement échoue à l'endroit du remplacement. Un vecteur d'initialisation (VI) permet d'amorcer le chainage des blocs.
Le DES à clé de 56 bits peut cependant être cassé par une recherche exhaustive en quelques heures, d'où l'idée d'utiliser trois clés de 56 bits (168 bits). DES est dans ce cas largement suffisant pour les applications commerciales actuelles.
IDEA est un autre algorithme de chiffrage par bloc utilisant une clé
de 128 bits. Aucune technique ne peut aujourd'hui casser IDEA.
hash(MAC_write_secret + pad_2 +
hash(MAC_write_secret + pad_1 + seq_num +
Compressed.type + Compressed.length + Compressed.fragment))
L'utilisation de nouvelles clés à chaque session sert à minimiser la quantité de données chiffrées qu'un intrus pourrait obtenir et en conséquence réduire les dommages au cas où une clé de session soit découverte.
L'état d'une connexion est défini par :
Certains navigateurs comme Netscape possèdent initialement un certain nombre de clés publiques de CA (comme Verisign) permettant d'authentifier les certificats envoyés par le serveur web. Si un certificat reçu n'est signé par aucune de ces autorités, le navigateur demande au client s'il accepte le certificat.
Dans le cas où le certificat est accepté, une connexion sécurisée est établie (que Netscape indique par un icône représentant un cadenas fermé). Lorsque le client ouvre par la suite une connexion non sécurisée, il est averti du changement.
Pour mettre en oeuvre cette communication sécurisée entre
un browser Netscape et des servlets, on est forcé d'utiliser un
vrai serveur Web. Nous proposons d'utiliser un serveur Apache-SSL, dont
l'installation et la configuration sont décrites a l'URL http://www.apache-ssl.org
.
La communication entre ces deux parties utilise une interface (Open
Communication Interface) indépendante de la couche de transport
utilisée. Cette interface permet de " brancher " facilement de nouveaux
protocoles sur l'ORB. Par exemple, la couche IIOP située au-dessus
de TCP implémente l'interface OCI.
Le protocole SSL est intégré à l'aide de l'interface
OCI.
Les schémas ci-dessous représentent les différentes couches :
Lorsqu'un client CORBA obtient la référence IOR d'un objet ayant deux profiles (IIOP et SSLIOP) la connexion peut être établie selon l'un ou l'autre de ces profiles. L'interface ConnectPolicy permet au client de choisir un profil sécurisé ou non.
Ci-apres, nous donnons le schéma des instructions a exécuter pour mettre en oeuvre un serveur Corba sécurisé. L'authentification de ce serveur repose sur le fait qu'un certificat a été généré préalablement, et placé dans les fichiers de nom siteRSA1024.der et caRSA1024.der. Ces fichiers ont ete generes avec un programme specifique, permettant de creer des certificats signes par nous-memes. Vous devez rapatrier ce programme.
-----------------------------------------------------------------------------------
Corba
Server initialization with SSL
-----------------------------------------------------------------------------------
orb = ORB.init(args, new java,new java.util.properties());
BOA boa = orb.BOA_init(args, new java.util.properties());
// naming server is unsecure, so we have to connect here in an unsecure
way
// before SSL initializations
///// naming server connections - get object references
// initializez the SSL pluggins
com.ooc.SSL.SSL.init(orb, boa, args);
com.ooc.SSL.Config ssl =com.ooc.SSL.ConfigHelper.narrow(
orb.resolve_initial_references("SSLConfig");
// get the certificates generated with Iaik
// suppose they are accessible in the current directory
String files = new String[2];
files[0] = "siteRSA1024.der";
files[1] = "caRSA1024.der";
// set the certificates as a client if needed
ssl.setCertificateAndKey(com.ooc.SSL.ConfigPackage.ServerOrClient.SET_CLIENT,
files,
"blabla");
// set the certificate as a server if needed
ssl.setCertificateAndKey(com.ooc.SSL.ConfigPackage.ServerOrClient.SET_SERVER,
files,
"blabla");
// get current reference to SSL object
static private sslCurrent = com.ooc.SSL.CurrentHelper.narrow(
orb.resolve_initial_reference("SSLCurrent");
// we have to check the identity of the clients of the current server
ssl.requestPeerCertificate(true);
// create distributed objects and connect them with both IIOP & SSLIOP
XXX xxx = new XXX(...);
((com.ooc.CORBA.ORB)orb).connect(xxx, <pid>);
// run implementation
orb.impl_is_ready();
authenticateAgency
(com.ooc.SSL.Current sslCurrent,
org.omg.CORBA.portable.ObjectImpl obj,
String CA, // the CA (certificate authority) of the caller
String bankName, String agencyName) throws Exception {
try {
// authentificate the object identified by obj
// it is possible to authentificate the caller
// object though getPeerCertificateChain(this)
com.ooc.SSL.X509Certificate[] chain = sslCurrent.getPeerCertificateChain(obj);
if (! (chain[0].getGuarantor().equals(CA) &&
chain[1].getGuarantor().equals(CA) &&
chain[1].getSubject().equals(CA)))
throw new exception("failed to authenticate object");
String subject = chain[0].getSubject();
if (subject.indexOf("O=" + bankName) == -1 ||
subject.indexOf("OU=Agency") == -1 ||
subject.indexOf("L=" + agencyName) == -1)
throw new exception("failed to authenticate object");
}