[TechDays2012] HTML5 et la sécurité

Posted on 07/02/2012 by JP Gouigoux

Excellente session présentée par Sébastien Gioria de OWasp. Je précise que ces articles sont à base de mes notes pendant les sessions, donc que ça peut paraître parfois un peu tapé au kilomètre. Mais j’ai bien sûr tout repris et remis en forme avant publication, et c’est ce qui me permet de mettre, après coup, ces appréciations sur les sessions. Celle-ci était particulièrement bien menée, avec une personne très experte, s’exprimant bien, avec un contenu étoffé et avec un plan clair. Bref, 20/20 si je peux me permettre de noter…

WebSocket, WebMessaging, IndexedDB, Offline web application, Web Storage, Cross Origin Resource Sharing sont des APIs liées à HTML5, et qui peuvent fournir des opportunités à un attaquant. Le but de cette session est de les passer en revue et de voir en quoi elles peuvent améliorer, mais plus souvent dégrader, la sécurité.

L’intervenant commence par définir ces différentes API, mais en reprenant mes notes sur la conférence, je m’aperçois que ce sera plus pratique de regrouper, pour une référence écrite.

WebMessaging

Il s’agit d’un mécanisme d’échange de JSON entre plusieurs iFrames. Il n’y a pas de principe de validation du contenu : c’est au récepteur de se débrouiller pour vérifier que ce n’est pas offensif.

IndexedDB

Stockage d’objets en local. Sensible aux injections SQL, donc…

Forms

Falsification de Forms : on peut piloter un formulaire en dehors du contenu de la balise <form>. Ce n’était pas possible en HTML4, mais en HTML5, on peut rajouter une <input> en dehors du <form> et qui pointe sur celui-ci ! On peut rajouter un input de type submit avec un formaction qui pointe sur une autre URL. C’est évidemment un gros problème, et il est même étonnant que le pas ait été fait pour aller vers moins de sécurité.

Protocol handlers

En HTML5, on peut enregistrer des handlers de protocole, et surtout la norme ne rend pas obligatoire de valider par une autorisation de l’utilisateur.

Cross Origin Resource Sharing

Ce point particulier pose réellement problème. Normalement, XmlHttpRequest ne permet de dialoguer que sur le même domaine. C’est quelque chose qu’on apprend la première fois qu’on essaie de mettre en place de l’AJAX. En HTML5, on autorise à aller plus loin. Le champ Access-Control-Allow-Origin dans le header permet d’ajouter des URLs autorisées, voire même carrément *. On peut du coup faire du bypass d’accès. Si un serveur intranet met ceci en *, cela veut dire qu’une application extranet pourrait pointer en JavaScript dessus, et renvoyer l’information sur le serveur qui ne devait pas avoir accès à l’intranet.

On peut également se servir de ce détournement pour faire réaliser à une victime des attaques par DOS sur une cible donnée. Du coup, attention aux modifications des entêtes par un attaquant.

Offline Web Applications / WebStorage

Il s’agit d’un système de stockage d’objets JSON en cache local à la machine cliente. L’utilisateur n’a pas de contrôle sur ce qui est stocké. L’injection de JavaScript peut bypasser la limitation du contrôle d’accès => vol de sessions, de données sensibles, tracking d’utilisateur, etc.

Attention, le flag HTTPOnly des cookies ne fonctionne pas sur les localStorage ! Du coup, une application JavaScript pour aller lire le contenu du storage d’une autre application. Elle a juste à découvrir la structure. Rien à voir donc avec l’IsolatedStorage de .NET, qui permet de bien étanchéifier les stockages locaux en fonction des applications signées. Mais en même temps, c’est un peu logique : les applications ne sont pas signées sur le web, et surtout elles sont beaucoup plus multiples que les applications riches déployées par un processus interne, même s’il est automatisé.

Si les localStorage ne sont pas supprimés forcément lorsqu’on efface l’historique, cela permettra de suivre l’utilisateur encore plus que les cookies, qui étaient limités dans le temps.

WebSocket

L’API WebSocket permet de communiquer par tunnel entre différents domaines, dans le but de diminuer la taille des données véhiculées. Le client demande un UpgradeWebSocket au serveur. Du coup, on revient un peu à HTTP 1.0 où la connexion restait ouverte si possible (en HTTP 1.1 sans KeepAlive, on ferme tout de suite la connexion). Ceci va permettre de lancer des shells distants, de faire du port scanning, ou même du proxy poisoining.

Divers

Application Offline : <html manifest=”/cache.manifest”> permet de garder tout ce qu’on cherche en cache. Les Advanced Persistant Threats vont être facilitées, en gardant des points d’attaques y compris après être sorti d’une application.

WebWorkers en JavaScript : permet de lancer des processus longs JavaScript, mais du coup, cela va faciliter les calculs distribués (Ravan pour calculer des MD5 / SHA1 pour attaque par Rainbow Tables), ainsi que les attaques par DOS.

Attention, CSS3 facilite le ClickJacking par la possibilité d’injecter du JavaScript.

Une touche d’espoir ?

La sécurité a tout de même été prise en compte dans HTML5.

Par exemple, il y a un système de bac à sable pour les iFrame. On peut limiter en empêchant les formulaires, les scripts, les plugins. De même, les iFrames sandbox sont interdits de LocalStorage, etc. Par contre, les différents contenus allow-… permettent de libérer certaines fonctions. Attention, tous les navigateurs ne supportent pas bien toute cette granularité de droits.

http://caniuse.com est le site de référence pour savoir quel navigateur supporte quelle fonctionnalité de HTML5. Peut-être que les retours des chercheurs en sécurité vont permettre de faire modifier la norme. Mais les développements commencent déjà, donc ça risque de poser problème.

Conclusion

Forte ouverture de la surface d’attaque, car l’ouverture s’est clairement faite au détriment de la sécurité. Attention également à la part belle qui est faite à JavaScript, alors que celui-ci est toujours exécuté en dehors du consentement utilisateur, à part une activation unique pour toutes les applications lors de la configuration du navigateur.

Encore une fois, cette session était de très grande qualité, et si vous vous intéressez à la sécurité ou à HTML5, je ne peux que vous conseiller de la visionner lorsque les webcast seront disponibles (quelques semaines après l’évènement, en général). Et un grand merci à Sébastien Gioria s’il me lit !

Posted in Retours, Sécurité | Tagged | 2 Comments

[TechDays2012] Développer une application Windows Phone 7.5 connectée à un service OData

Posted on 07/02/2012 by JP Gouigoux

Cette session faite suite à celle sur OData et Entity Framework. Stéphanie Hertrich poursuit l’exposition de A à Z d’une application de gestion de cave à vins. Le concept est très intéressant, parce que montrer une application complète avec son architecture et tout le code derrière aurait été proprement impossible en une heure, donc c’est une bonne idée de répartir les tiers sur plusieurs sessions. Ce coup-ci, c’est Rudy Huyn qui co-présente.

Access Control Service permet d’utiliser n’importe quel mode d’authentification (Facebook, LiveID, etc.), avec une compatibilité OAuth. ACS est porté par Azure, et le composant ACS est disponible dans NuGet.

Pour récupérer le service OData, on ajoute une référence de service, et on peut ensuite simplement utiliser le contexte comme on le ferait dans EntityFramework. Ensuite, on crée une ObservableCollection dans le ViewModel, et on la remplit avec la liste de données en provenance du service, et ce de manière asynchrone. Le Binding se fait ensuite exactement comme on le fait dans tous les cas standards sur Silverlight.

Un truc intéressant noté au passage : Blend pour Windows Phone est gratuit.

Windows Phone Controls Toolkit est récupérable sur NuGet, pour utiliser par exemple un effet de tilt.

La couleur blanche est utilisée comme étant la valeur pour les couleurs systèmes dans Windows Phone. Donc, attention, il faut tricher légèrement en mettant un blanc très peu dévié vers le gris si on souhaite vraiment mettre un item en blanc quel que soit le style.

AdControl SDK est fait pour intégrer des publicités en provenance d’une régie publicitaire Microsoft dans l’application. Au besoin, on peut le faire en fonction de new LicenseInformation().IsTrial(), de façon que les utilisateurs ne voient la publicité que dans la version d’essai de votre application. En dehors de toute considération sur l’invasion de la publicité dans nos écrans, la technique est visiblement extrêmement simple et il suffit d’insérer un contrôle pour que la régie s’occupe de toute la diffusion, et vous paie en retour. Les orateurs de Microsoft ont présenté le retour comme étant jusqu’à 10 fois plus intéressant financièrement qu’une autre régie, par le fait que celle de Microsoft soit en fait surtout un relai spécialisé permettant de cibler fortement les campagnes des régies extérieures.

WriteableBitmap permet de composer des bitmaps avec des images dedans, des blocs de texte, etc. Cette classe est montrée dans le but de pallier à la limite des nombres affichés dans les tuiles, et qui ne vont que jusqu’à 99. Une autre possibilité peut bien sûr être de mettre en place un composant Silverlight en tant que contenu.

En conclusion, beaucoup d’astuces techniques intéressantes dans cette session bien présentée, active. Surtout, une approche bien architecturée pour la conception de l’application, sans reprendre les bases qu’on a déjà vues ailleurs.

Posted in Retours | Tagged | Leave a comment

[TechDays2012] Entity Framework 4.2 et OData

Posted on 07/02/2012 by JP Gouigoux

Stéphanie Hertrich (relations Microsoft développeurs) et Sébastien Pertus – ou “Petrus”? 🙂 – présentent une session autour d’un besoin métier multi-device, réversible (déployable dans le cloud ou à demeure), et à authentification déportée. Il s’agit d’une application de gestion de caves à vins qui leur sert de fil rouge pour toute l’après-midi, entre la gestion de l’architectures, des services, du client mobile et de tout ce qui va autour. Les orateurs ont tout deux un blog sur lequel ils partagent la façon dont on peut créer cette application pas à pas. Ca vaut le coup d’aller voir ça, je pense que vous devriez retrouver rapidement le lien avec leur nom, le mot clé blog et si ça ne suffit pas, en rajoutant “Cave a vins”.

Mapping ORM avec EntityFramework

Les versions 4.2 et 4.3 se basent sur la version EF4 qui est livrée avec le Framework 4.0, et rajoutent une librairie EntityFramework avec les nouveautés (certainement par méthodes d’extension, etc.). Par contre, la version 4.5 aura besoin des innovations présentes dans le framework 4.5, et on ne pourra plus évoluer de manière aussi transparente, même si l’effort restera très limité.

Une classe hérite de DbContext et contient des DbSet<type à inclure>. Ensuite, on va instancier cette classe, rajouter des données et faire un SaveChanges. Cela suffit pour générer la base de données, avec pour convention d’utiliser le namespace et le nom de la classe de contexte. On aurait aussi pu utiliser un constructeur base(connectionString) depuis notre constructeur de classe de contexte. Il s’agit bien là d’un approche de type code-first, puisque même la mise en place de la base de données est subordonnée à l’exécution du programme.

On peut ajouter [System.ComponentModel.DataAnnotations.StringLength] pour enrichir les propriétés sur lesquelles on travaille. On a également la possibilité de dire qu’une propriété n’est pas mappée, qu’elle est obligatoire, etc. Ne pas oublier de marquer les accesseurs de liste en virtual, par contre, sinon le Lazy Loading ne pourra pas fonctionner.

Il est également possible de laisser les objets POCO complètement inchangés. Pour cela, on utilise l’API Fluent qui donne accès à un DbModelBuilder, sur lequel on pourrait ajouter ces contraintes sans toucher aux classes, propriétés, etc.

On peut surcharger le SaveChanges et utiliser le ChangeTracker pour ajouter des comportements métiers à la sauvegarde. Si on utilise du Linq normal, on voit dans SQLServer Profiler passer deux fois la requête. Par contre, si on utilise la fonction Find(), il y a bien utilisation du cache, dans le scope du DbContext bien sûr.

Gestion de la migration

Lors des mises à jour, on peut avoir des policies de destruction de bases de données en automatique. Evidemment, ce n’est pas possible d’utiliser ce mode destructif de données en production. La version 4.3 amène un modèle de migration de base de données, qui permet enfin d’avoir une gestion de la mise à jour des bases de données sur les changements de code. Ceci se fait avec du PowerShell ou bien sûr en code .NET.

install-package EntityFramework –includePreRelease dans NuGet permet de prendre la version 4.3 ainsi que tout ce qui est nécessaire en termes de dépendances pour qu’elle fonctionne. Bien sûr, quand il s’agira de la release officielle, il ne sera plus utile de rajouter l’option includePreRelease. Il faut inclure une classe de migration qui hérite de DbMigrationsConfiguration. On a toutefois le choix de dire que pour chaque marque de modification, on laisse faire EF 4.3 pour la mise à jour. Update-Database –Verbose –Force permet de prendre une photo de la structure de base de données, ou bien de lancer la migration automatique.

Nouveautés EF 4.5

Support des énumérations, des données géospatiales, des améliorations de Linq (en particulier la compilation automatique), etc. Par contre, tout ça n’arrivera que dans le Framework 4.5.

Publication des données

OData est une convention / une spécification plus qu’un protocole. Le principe est avant tout de pouvoir requêter sans connaître à l’avance la structuration des données.

Une instruction que je ne connaissais pas en OData : $expand. Il faudra que je voie à quoi ça sert… WCF Data Services permet de prendre n’importe quelle IQueryable et de l’exposer sous forme de flux OData. Enfin, OData V3 (seulement avec la CTP Octobre 2011 de WCF Data Services) supportera les types de données géolocalisés.

[QueryInterceptors(“Table”)] permet de rajouter la logique de droits pour les accès sur une table donnée. On peut alors se servir de l’authentification IIS, mais aussi de Access Control Services qui est plus large. ACS permet de déporter l’authentification à un processus externe, comme LiveID, Facebook, YahooID, etc. En ACS, du côté client, on surcharge le SendingRequest de WP qui va rajouter un token OAuth. Les QueryInterceptors permettent de renvoyer une expression qui permet de dire sur une ligne de donnée particulière (vue comme une instance d’un type) est autorisée ou pas.

Au final, beaucoup de choses apprises dans cette très bonne session technique, mais il va vraiment falloir tester tout ça en profondeur pour mieux comprendre et être capable de pratiquer.

Posted in .NET, Retours | Tagged | Leave a comment

[TechDays2012] Les nouveautés du Framework .NET 4.5

Posted on 07/02/2012 by JP Gouigoux

Cette session est présentée par Roch Baduel, MVP, architecte chez MCNext. L’amphi bleu continue à se remplir, et visiblement le sujet intéresse fortement puisque la salle est déjà quasi-bondée alors que c’est une des plus grandes.

La version 4.5 est une mise à jour par dessus la 4.0. Donc, comme pour la version 2.0 avec les versions 3.0 et 3.5: il n’y a pas de changement majeur de la CLR, mais juste des ajouts de fonctionnalités. La 4.5 pourra être déployée par Windows Update. Par contre, attention, il y a des modifications dans les classes du 4.0, même si la compatibilité est a priori bonne.

Asynchronisme

Le gros point important est la programmation asynchrone et parallèle : les briques de bases qui étaient auparavant disponibles en Community Technology Preview seront désormais inclues dans le Framework. Les Tasks sont étendues dans le 4.5 par rapport à leur version 4.0. Les DataFlow également seront intégrées.

L’asynchrone a évolué de l’Asynchronous Programming Model (méthodes Begin / End) au Event-based Asynchronous Programming (Callback de type Completed, méthode suffixée par Async), et maintenant en Task-based Asynchronous Programming (async / await).

On écrit typiquement Task<string> tache = webClient.DownloadStringTaskAsync(url); D’après ce que j’ai compris (mais je n’ai pas de Visual Studio 11 sur cette machine, donc à vérifier), il s’agit d’une des méthodes d’extension de WebClient qui ont été ajoutées lors du passage au .NET 4.5.

Cette ligne crée une tâche, à savoir un objet qui porte un traitement. C’est le gestionnaire de pool de thread qui décide quand lancer ce traitement. S’il se trouve qu’il n’a rien à faire, il peut le lancer tout de suite, mais il peut tout aussi bien le retarder et le traiter bien plus tard, selon son bon vouloir. C’est au code appelant de faire ce qui est nécessaire pour que la valeur soit calculée lors de son besoin.

Pour cela, on dispose de plusieurs méthodes de programmation. Tout d’abord, on peut utiliser une ligne comme tache.Result pour revenir dans un modèle synchrone et bloquant. Le fait d’appeler Result va demander l’exécution de la tâche, et attendre sa fin pour retrouver le résultat de sortie, qui sera du type qui avait été utilisé pour la classe générique Task<T>.

Une autre méthode qui est mieux est de chaîner une tâche avec un traitement suivant. Comme ça, on ne dit pas explicitement de calculer et on laisse le choix au moteur du moment opportun. tache.ContinueWith(task => string html = task.Result); permet de réaliser ceci. Bien sûr, il faut alors ne pas oublier de faire un Start() sur la tâche…

Et sinon, il y a la nouvelle grammaire string html = await task.Result; Je ne suis pas encore suffisamment au point sur les mots-clés async et await pour expliquer ceci proprement, mais en gros, il s’agit de “sucre syntaxique” et le compilateur se charge de recréer en arrière plan tout ce qui est nécessaire pour le fonctionnement asynchrone expliqué plus haut.

Les méthodes doivent être déclarées en async pour pouvoir être utilisées non pas comme des exécuteurs immédiats de traiement, mais plutôt comme fournisseur d’un résultat dans le futur,. Et logiquement, elles doivent dans ce cas renvoyer ou bien un Task,ou bien void. Au final, pour transformer une méthode synchrone en asynchrone, il suffit de mettre le mot clé async dans la signature, et de remplacer tous les appels de fonction par leur équivalent suffixé par Async, en mettant juste devant l’appel un mot clé await.

Un des gros avantages de l’asynchrone pour la réactivité des UI est qu’avec ce mode, on est de retour dans le contexte de la thread GUI, donc on peut facilement mettre à jour l’affichage sur le retour de la tâche. Il faut toutefois utiliser this.Dispatcher.InvokeAsync(), de façon que la modification de l’IHM soit bien réalisée sur le thread associé.

La démo n’est malheureusement pas super réussie, et surtout n’explique pas réellement la différence entre le cas asynchrone où les retours sont mélangés, et le second cas où l’écriture fait que le traitement est asynchrone, mais tout de même chaîné dans l’ordre. C’est dommage, parce que ça donnerait une meilleure compréhension de comment ça marche, plutôt que de s’arrêter sur l’aspect “magique” de la techno… Cette expression a également été trop entendue à mon sens lors des TechDays : très souvent, les orateurs indiquaient qu’à partir d’un certain moment, il suffisait de “laisser la magie opérer”. Je dis “trop entendue” parce qu’à mon sens, on est entre professionnels, et la magie est peut-être bonne pour le grand public, mais en tant que développeur, moi j’ai besoin de comprendre ce qu’il y a derrière, et je n’utiliserai pas une technologie Microsoft (ou n’importe quel autre éditeur, pour le coup) sans être raisonnablement au courant du fonctionnement interne de celle-ci. C’est une question de capacité à appliquer la technologie dans de bonnes conditions. Il y a un dicton comme “tout technologie suffisamment avancée est indifférenciable de la magie”. Dans notre cas, insister sur le fait que les technologies sont “magiques” me fait surtout imaginer qu’elles sont très complexes, et potentiellement donc fragiles…

Task

Des méthodes ont été ajoutées sur la classe Task, à savoir principalement Delay, WhenAny, Run, Yield, ContinueWith. A tester soi-même par contre, parce qu’aucune explication n’est donnée hormis un très rapide slide avec une ligne par fonction.

DataFlow

En .NET 4, traditionnellement, on part des données et on met en place le traitement. En DataFlow, l’idée est de faire dans l’autre sens, en créant un pipeline de traitement de données : on instancie un réseau de blocks, puis on injecte dedans de la donnée. On parle bien de réseau, et pas seulement de pipelines linéaires. Chaque block s’exécute de manière parallèle en utilisant le ThreadPool.

var ab = new ActionBlock<int>(i => { Process(i); });

for (int i = 0; i < 5; i++) ab.Post(i);

Il y a aussi des TransformBlock<TInput, TOutput>, des BroadCastBlock, JoinBlock, BufferBlock, etc.

using System.Threading.Tasks.Dataflow pour avoir accès à ces classes.

TransformationBlock<string, string> tb = new Transformation<string, string>(s => (if s.StartsWith(“a”) return Enumerable.Empty<string>() else return new string[] { s };);

Ensuite, il suffit de faire un LinkTo d’un bloc à l’autre, et de poster la donnée sur le premier bloc de la chaîne. Dans la démo, le dernier bloc fait un affichage, c’est un ActionBlock, mais il doit être possible de simplement donner en sortie un IEnumerable pour pouvoir travailler en mode pull comme avec Linq. J’essaierai de faire un article de blog plus complet avec un code fonctionnel reprenant tout ceci, mais là, je suis dans le train et LiveWriter est tout ce que j’ai pour retaper mes notes sous forme de blog.

Autres nouveautés

Sytem.Net.Http avec HttpClient, HttpRequestMessage, etc. : API de bas niveau pour HTTP.

MEF 2.0 : support des types génériques, composition basée sur des règles (les attributs ne sont plus obligatoires). Utilise RegistrationBuilder pour injecter des attributs. ReflectionContext : expose des types “altérés”. Ceci devra normalement nous permettre de travailler avec MEF de manière plus souple. Par exemple, tout objet avec un nom donné, ou implémentant une interface donnée, pourra être utilisé en injection, même s’il n’a pas été prévu pour cela dès le début.

Le concept de Portable Library, apparu pour garder en commun des libraires entre Silverlight et .NET, va être étendu à XBox, Windows Phone, etc.

WCF va enfin permettre de faire du Contract First : on pourra appeler svcutil /serviceContract pour générer le squelette de code à partir du WSDL. A voir si la montée en version se passe bien, toutefois, parce que c’est quelque chose de générer du code, mais c’est encore autre chose de le générer d’une manière qu’il puisse supporter une montée en version sans avoir à trop intervenir manuellement pour tout refaire. Normalement, les classes partielles devraient aider, et surtout, comme les services web sont en général exposés à l’externe et ont besoin d’une grande stabilité / compatibilité ascendante, il n’y aura normalement pas de souci, mais bon… J’attends de voir.

PasteXMLAsClasses permet, depuis Visual Studio, de créer automatiquement une classe de sérialisation à partir d’un XML quelconque. Sympa, même si ça tient plus du gagdet que du vrai outil de production. C’est plus à voir comme une sorte de snippet de génération de code dont le paramètre serait un XML exemple.

Du côté Workflow, les machines à état reviennent, et il est possible de mettre en place des règles en grammaire C#.

Le mécanisme de Ruban est inclus dans .NET 4.5 sur WPF. Pour le binding, un Delay est désormais possible, pour ne pas envoyer un tas de modifications lorsque l’utilisateur joue avec un slider pour arriver progressivement à la valeur qu’il souhaite, par exemple. IsVirtualizingWhenGrouping permet d’augmenter très fortement la performance sur le groupage dans un ListView en WPF. Il faudra toutefois vérifier que ça fonctionne bien avec des ruptures métier, de la pagination, etc.

Posted in .NET, Parallélisation, Retours | Leave a comment

[TechDays2012] Plénière Jour 1

Posted on 07/02/2012 by JP Gouigoux

Et voilà ! C’est reparti pour trois jours de TechDays, avec compte-rendu pour chacune des sessions auxquelles j’assisterai. On commence par la session plénière, comme d’habitude. J’ai manqué le début, mais voici les quelques points qui m’ont paru marquants.

Visual Studio 11 (à un moment, on parlait de vNext, mais maintenant c’est plutôt “11”, en attendant “2012” qui sera certainement la dénomination finale) contient un module qui s’appelle Parallel Watch, et qui permet d’arrêter certains threads pour voir les variables pendant du calcul parallèle. Pas de bol, la démo d’Eric Vernié plante… Eric Mittelette rebondit sur le fait que Visual Studio permettra également de faire du débogage GPU, ce qui est une excellente nouvelle pour les personnes intéressées par le calcul intensif.

La démonstration suivante est celle d’un découpage de base de données Azure par fédération. Il permet de faire voir un sharding dans le Cloud. L’idée est de partitionner les données selon un critère métier pour les équilibrer entre plusieurs nodes, qui en l’occurrence sont des instances des SQL Azure.

NuGet est présenté, et Microsoft se montrera à plusieurs sessions dithyrambique au sujet de cet utilitaire, qui complète efficacement un manque dans leurs outils. NuGet est un gestionnaire de paquetages : il permet de gérer simplement la récupération, montée en version et dépendances des références de vos projets Visual Studio. Il est intégrable dans l’interface Visual Studio, mais également sous forme de console avec des commandes PowerShell. C’est bien de voir que Microsoft s’ouvre suffisamment aux outils externes Open Source pour les intégrer (JQuery) ou en faire la publicité comme c’est le cas pour NuGet, qui le mérite bien d’ailleurs. J’ai personnellement commencé à l’utiliser il y a quelque temps pour mettre en place les dépendances du kit OGDI, et c’est super pratique de pouvoir ajouter un paquetage et que tout compile, plutôt que de récupérer douze projets et librairies externes, potentiellement plus dans les versions attendues. Bon, maintenant, j’espère que Microsoft ne fera pas que consommer ces outils, et contribuera en retour, mais ça avance dans le bon sens pour Hadoop, avec une contribution de la console JavaScript, par exemple.

Benjamin Guinebertière montre un projet de gestion de la montée en charge, et comme d’habitude avec lui, tout se déroule bien. On sent que l’exercice a été bien préparé. Par contre, on lui a donné peu de temps, et on a du coup peu de détails sur les retours d’expérience.

A noter qu’il existe un plugin WebMatrix pour déployer directement sur Azure.

La suite de la session est sur l’internet des objets. Il est estimé qu’en 2020, il y aura 7 milliards de personnes connectées, mais 50 milliards d’objets qui le seront également. Du coup, le présentateur (dont je n’ai pas noté le nom, désolé Edit : à savoir Pierre Cauchois – merci Pascal pour l’information) montre une expérience vraiment très sympa de montage électronique simple complètement simulé dans Visual Studio, et programmé en .NET Compact Framework. La Toolbox contient des composants de base, le concepteur se charge de les relier comme il faut et on peut programmer une mini station météo qui va publier les données de capteurs à destination d’un serveur. Les équivalents hardware des pièces sont disponibles, et le kit ressemble un peu au principe d’Arduino, d’après ce que j’en ai compris. J’ai cru entendre que le nom de ce kit était Gadgeteer, mais je ne suis pas 100% sûr.

On passe ensuite au règles de conception pour les nouvelles interfaces Metro :

  • Aligner sur une grille (des ergonomes ont montré que c’était ce qui suivait le plus le fonctionnement cérébral humain)
  • Mettre le focus sur le contenu (l’interface ne montre pas de fioritures)
  • Garder un code couleur (on retrouve facilement en un coup d’oeil des codes couleurs montrant rapidement dans quel application on se trouve)
  • Etre réactif aux interactions (l’idée est d’avoir un retour optique rapide lors d’une manipulation de type touch, pour que l’utilisateur soit assuré que l’application est active, et ce pendant que le traitement est lancé en asynchrone sur un autre thread)

La dernière partie de la session est une présentation de l’application du premier de ces principes dans le cas d’une application web. Microsoft a introduit une méthode d’utilisation des grilles de layout dans HTML5 / CSS3, et va demander validation par le W3C. L’idée est de remplacer des structures de <div> par un ensemble dans lequel les règles d’affichage seront prises en compte par le CSS, ce qui est la bonne façon d’appréhender une séparation plus complète du contenu et de l’affichage. A voir maintenant si cela sera accepté et normalisé, ou si on repartira dans une fragmentation des pratiques, ce qui serait bien sûr très mauvais. Un logiciel de type SketchFlow est utilisé pour prototyper rapidement l’application, de type création de SlideShow. L’utilisation semble très souple, alors qu’on reste dans un navigateur et qu’on n’est pas dans Silverlight. C’est David Rousset qui fait la démonstration, lui qui est un spécialiste de Silverlight justement (et de Star Wars, dont il nous parle abondamment).

Le show finit avec une révérence de tous les développeurs, qui lancent leur slogan pour ces Tech Days 2012, à savoir “fiers d’être développeurs”.

Posted in Retours | 2 Comments

Formations Microsoft gratuites

Posted on 24/01/2012 by JP Gouigoux

Microsoft France a mis quelques sessions en place sur les sujets suivants :

  • Hyper-V
  • Administration du datacenter virtualisé
  • Private Cloud
  • Consumérisation de l’IT

image

Toutes les sessions sont jouées au moins une fois sur le Campus Microsoft, mais certaines seront données en province. En jettant un oeil sur celle présentée à Nantes, on voit que ce sont des demi-journées.

Et Microsoft donne des coupons gratuits pour se certifier sur la technologique montrée ! Bon, je pense qu’il faut avoir une sacrée paire de bretelles pour s’attaquer à la certification dans la foulée de 4 heures de cours, mais en accéléré, c’est peut-être envisageable…

Toutes les infos sont ici : http://technet.microsoft.com/fr-fr/itcamps

Posted in Uncategorized | Leave a comment

Windows 8, Metro, HTML 5 et le futur de Silverlight

Posted on 18/01/2012 by JP Gouigoux

Rien de mieux qu’un cours, une formation ou, dans mon cas aujourd’hui, un entretien avec un journaliste pour se forcer à mettre ses idées en ordre. En l’occurrence, sur l’avenir de Silverlight dans Windows 8.

Pour résumer ma pensée, deux choses :

1) Silverlight est effectivement mal barré.

2) Mais ce n’est peut-être pas un problème.

Que je m’explique : j’adore le concept même de Silverlight et je trouve que c’est une technologie super aboutie, facile à programmer et extraordinairement riche de fonctionnalités. J’ai personnellement eu maille à partir avec Flex et il n’y a pas photo… C’est un peu comme programmer iOS ou Windows Phone : le choix est entre le burin ou le laser Sourire

Ce n’est donc pas de gaieté de cœur a priori que je constate que l’évolution de Silverlight est mise en danger par l’adoption d’HTML5 dans l’interface Metro de Windows 8. Ce qui m’a amené à modifier mon avis sur ce point est une lecture sur InfoQ (un de mes sites informatiques préférés), qui renvoyait sur une page extrêmement intéressante, avec une analyse des types communs entre WinRT et Silverlight 5.

Une énorme partie des API de Silverlight se retrouve dans WinRT !

Or, si on revient aux origines de Silverlight, quel était le but de la technologie, sinon combler le fossé entre le développement “riche” pour les applications Desktop et le développement d’applications web “légères” ? Je mets “légères” entre guillemets parce que quand on voit la taille de certaines pages web, on se demande pourquoi on appelle encore ça du client léger, mais bon… c’est un autre débat.

Silverlight a très bien comblé ce fossé entre le client riche et le client web, en utilisant un plugin qui permettait d’utiliser des technologies de développement riche (WPF, WCF, XAML, DataBinding, etc.) dans un navigateur web.

Mon idée est que Silverlight va disparaître non pas parce que la technologie est mauvaise, mais tout simplement parce que ce besoin de rapprocher le développement web du développement Windows va désormais être intégré directement dans le système d’exploitation : tout ce qui est nécessaire sera dans l’API WinRT. Il n’y aura donc pas besoin d’un plugin pour gérer ceci.

Quand on y pense, d’ailleurs, ça faisait un bout de temps que Microsoft avait mis des ponts en place entre les deux : Script#, la possibilité d’appeler des API .NET en JScript, le hosting de ControlUser dans IE (l’équivalent des applets Java), les applications en mode Page de WPF intégrées dans le navigateur… Ca faisait pas mal de tentatives, quand même ! Le fait que Microsoft ne démente pas la disparition de Silverlight tend à faire penser que cette fois-ci, ils ont préparé le coup de longue haleine.

On peut imaginer un Windows 8 avec une interface Metro légère dans lequel HTML5 est utilisé pour structurer les applications, avec des appels à WinRT pour les traitements.

En effet, il ne faut pas se voiler la face : malgré tout le battage médiatique autour de HTML5, il ne s’agit que d’un langage de structuration de contenu. Le seul élément portant sur du traitement est la prise en compte de la validation côté client : c’est un peu léger pour imaginer qu’on va pouvoir réaliser des applications avec HTML5. Il y aura encore beaucoup de JavaScript, JQuery, appels à des services web ou des API comme WinRT justement.

J’imagine que l’adoption d’HTML5 dans cet interface répond pour Microsoft à deux objectifs :

1) Ne pas se planter en laissant passer le train HTML5 comme ils l’ont fait avec l’internet il y a 10-15 ans.

2) Pouvoir offrir une interface utilisateur réactive sur les tablettes Windows 8, afin d’être au niveau des iPad (ce qui est loin d’être le cas aujourd’hui pour les tablettes Windows 7).

Maintenant, tout ceci n’est qu’anticipation de ma part, et si ça se trouve, dans un an ou deux, je serai mort de honte d’avoir écrit ceci. Mais bon, le ridicule ne tue pas… On en saura certainement un peu plus aux TechDays 2012 !

Posted in .NET | Tagged | 5 Comments

Erreur TFS “Le chemin {Path} est déjà mappé à l’espace de travail”

Posted on 18/01/2012 by JP Gouigoux

Lorsque vous avez affecté un répertoire de votre workspace à un projet d’équipe, et que vous supprimez ce projet d’équipe, vous pouvez vous retrouver avec ce message si vous essayez d’utiliser votre workspace pour un autre projet ou une autre collection de projets d’équipe.

La difficulté dans ce cas est que, comme le projet n’existe plus, vous ne pouvez plus accéder à la commande de suppression de mapping. Si vous souhaitez retrouver l’usage du répertoire pour TFS, un moyen un peu brutal mais efficace consiste à supprimer le fichier VersionControl.config.

image

Evidemment, si vous avez de nombreux mappings, il est plus élégant d’aller modifier ce fichier avant de relancer Visual Studio. Son contenu est typiquement quelque chose comme :

<VersionControlServer>
  <Servers>
    <ServerInfo uri="http://antares:8080/tfs/defaultcollection" repositoryGuid="7f6b85b3-9ead-4c5e-b924-a10224d2c699">
      <WorkspaceInfo name="ANTARES" ownerName="ANTARES\gouigoux-jp" computer="ANTARES" comment="" LastSavedCheckinTimeStamp="2011-07-27T14:31:13.8730421Z">
        <MappedPaths>
          <MappedPath path="D:\Workspace" />
        </MappedPaths>
      </WorkspaceInfo>
    </ServerInfo>
  </Servers>
</VersionControlServer>
Posted in ALM, Retours | 4 Comments

Précédence des opérateurs ternaires et de concaténation

Posted on 13/01/2012 by JP Gouigoux

Un tout petit article pour montrer un code qui va provoquer une grave erreur : le traitement dans le catch lève lui-même une exception.

using System;

namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                throw new Exception("coucou");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Erreur : " + ex.Message
                   + ex.InnerException != null
                   ? ex.InnerException.ToString()
                   : " (aucun détail)");
            }
        }
    }
}

Avez-vous trouvé ce qui se passait ? Personnellement, il me paraissait naturel que l’opérateur ternaire prenne la précédence sur celui de concaténation (et j’ai exprès grossi le trait avec l’indentation), mais ce n’est pas ce qui se passe, et si on veut que ça réagisse comme prévu, il faut rajouter les parenthèses comme ci-dessous :

Console.WriteLine("Erreur : " + ex.Message
    + (ex.InnerException != null ? ex.InnerException.ToString() : "..."));

Si on ne le fait pas, le compilateur comprend ceci :

Console.WriteLine(("Erreur : " + ex.Message + ex.InnerException) != null
    ? ex.InnerException.ToString()
    : "...");

Et évidemment, comme il n’y a pas d’InnerException, le code lève un NullReferenceException, qui n’est pas catchée dans notre cas, vu qu’on se trouve déjà dans une section de catch…

Du coup, on voit mieux ce qui parait contre-intuitif : l’opérateur de concaténation regroupe des chaînes, mais aussi une instance de System.Object, en l’occurrence ex.InnerException, sur laquelle il va automatiquement appliquer un ToString. Or, visuellement, on a plus tendance à associer fortement ex.InnerException avec le test de différence à null.

Personnellement, je ne vois pas pourquoi l’opérateur ternaire a une précédence aussi basse… Peut-être que ça a un lien avec le fait qu’elle remplace une structure if…else qui aurait alors englobé les paramètres, et aurait alors cédé automatiquement la priorité à l’évaluation complète des paramètres ?

Pour la liste complète des précédences des opérateurs C#, voir la documentation MSDN sur le sujet.

Posted in .NET, C# | Leave a comment

Revue de livre : La sécurité dans le Cloud (Vic Winkler / Pearson)

Posted on 12/01/2012 by JP Gouigoux

Ce n’est pas tous les jours qu’on trouve un livre en français sur un sujet aussi spécialisé que la sécurité dans le Cloud. Autant vous le dire tout de suite, toutefois : le traitement n’est pas aussi pointu qu’on aurait pu le souhaiter. Je suis le premier à enseigner que la sécurité est avant tout une question de méthodologie, mais il me parait tout de même difficile de ne pas rentrer dans la technique.

Un regret…

Ce livre approche timidement la technique, et une grande partie est en fait une explication de comment fonctionnent les différents types de Clouds. C’est très intéressant, et l’auteur est visiblement très expert sur la mise en place de Clouds, ainsi que sur la sécurité, mais en lisant ce livre, on s’attend à ce que le cœur du sujet soit les spécificités de la gestion de la sécurité (logicielle comme physique). Or, une grande partie reprend simplement une gestion des risques sur des cas d’étude de Clouds, sans apporter vraiment un plus…

D’une certaine manière, ce livre aurait du s’appeler “Considérations autour de la sécurité dans le Cloud” : cela montrerait que 100% du livre n’est pas sur des méthodes de sécurisation dédiées au Cloud, tout en mettant en avant les deux notions qui restent centrales, mais sont abordées presque séparément.

N’allez toutefois pas croire que je regrette une seule minute de mon temps passé à lire ce livre : j’y ai appris un tas de choses sur les Clouds en général. Ma petite déception est seulement due au fait que je m’attendais à trouver des réponses précises sur comment sécuriser des applicatifs à destination du Cloud, alors que la sécurité est plus envisagée du point de vue du fournisseur de service de Cloud. Mais un tas de petites informations très pratiques compensent largement ce petit décalage entre l’attente et la réalité.

Mais plein de bonnes idées…

Ce livre nous fait par exemple prendre conscience du fait que le temps nécessaire à déplacer les données dans le Cloud est un des critères les plus importants d’amélioration de la rentabilité par rapport à une infrastructure in-house. Dans le cas de données volumineuses, il faut bien regarder le coût du Go déplacé en upload. Certains fournisseurs de Cloud propose de leur envoyer des disques durs avec les données pour économiser sur la bande passante…

Un autre point intéressant est le DaaS (Desktop as a Service), qui consiste à virtualiser le bureau d’exécution. En particulier, l’analogie sur l’internet pris comme un très long câble reliant le clavier, la souris et l’affichage est très bonne. Surtout, elle pose la question de la possibilité de concevoir d’autres systèmes innovants en imaginant la segmentation en d’autres points du SI.

Le livre est également très bien renseigné sur l’impact des lois des différentes juridictions s’appliquant sur les données et les traitements du Cloud. Si vous avez des doutes sur les lois qui s’appliquent sur vos données, il vous donnera d’excellents pointeurs, et surtout une bonne idée des risques associées aux règlementations légales en cours, en Europe comme aux USA.

Un projet à surveiller pour éviter l’enfermement dans un Cloud propriétaire : le Data Liberation Front. Bien que j’ai tendance en ce moment à regarder d’un œil critique les déclarations de Google sur la “libération des services et des données”…

Avant de lire ce livre, je ne connaissais pas non plus bien la notion de Cloud communautaire. Je me rends compte que c’est peut-être une façon hybride d’amener des clients travaillant de manière différente à rapprocher leurs méthodes de fonctionnement par une réduction des coûts d’infrastructure, mais aussi par la garantie d’une évolution beaucoup plus transparente du logiciel.

Conclusion

Si vous êtes un manager ou un expert, à combien estimez-vous une bonne idée ? 1000 € ? 100 000 € ? Un livre comme celui-ci ne coûte que 37 € et vous en donnera certainement au moins quelques-unes… Je ne pense pas que ça devienne un classique, car il manque un peu de densité, mais il vaut sans aucun doute le coup de prendre le temps de le lire si votre activité vous oriente vers le Cloud.

Posted in Retours | Tagged , | Leave a comment