fuzzing

Go dispose de tests de fuzzing en version bêta

Soumis par fredericmazue le

Le fuzzing (ou test à données aléatoire) est une technique pour tester des logiciels. L'idée est d'injecter des données aléatoires dans les entrées d'un programme. Si le programme échoue (par exemple en plantant ou en générant une erreur), alors il y a des défauts à corriger. L'équipe du projet du langage Go vient d'annoncer la disponibilité de ce type de test pour ce langage. Le fuzzing pour Go est en version bêta pour le moment.

Pour utiliser le fuzzing vous devez d'abord créer la chaîne d'outils Go à partir de la branche de développement dev.fuzz

$ go get golang.org/dl/gotip
$ gotip download dev.fuzz

Ceci ne sera plus nécessaire une fois que le code sera fusionné dans la branche principale.

Une fois la chaîne construite, il est possible d'exécuter des commandes comme

$ gotip test -fuzz=FuzzFoo

gotip remplaçant go

Une cible fuzz doit se trouver dans un fichier *_test.go en tant que fonction sous la forme FuzzXxx. Cette fonction doit recevoir un argument *testing.F, un peu comme un argument *testing.T est passé à une fonction TestXxx .

Voici un exemple de cible fuzz qui teste le comportement du package net/url.

// +build gofuzzbeta

package fuzz

import (
    "net/url"
    "reflect"
    "testing"
)

func FuzzParseQuery(f *testing.F) {
    f.Add("x=1&y=2")
    f.Fuzz(func(t *testing.T, queryStr string) {
        query, err := url.ParseQuery(queryStr)
        if err != nil {
            t.Skip()
        }
        queryStr2 := query.Encode()
        query2, err := url.ParseQuery(queryStr2)
        if err != nil {
            t.Fatalf("ParseQuery failed to decode a valid encoded query %s: %v", queryStr2, err)
        }
        if !reflect.DeepEqual(query, query2) {
            t.Errorf("ParseQuery gave different query after being encoded\nbefore: %v\nafter: %v", query, query2)
        }
    })
}

Vous pouvez en savoir plus sur les API de fuzzing avec go doc

gotip doc testing
gotip doc testing.F
gotip doc testing.F.Add
gotip doc testing.F.Fuzz

 

Microsoft ouvre son nouvel outil de fuzzing OneFuzz

Soumis par fredericmazue le

Le fuzzing (ou test à données aléatoire) est une technique pour tester des logiciels. L'idée est d'injecter des données aléatoires dans les entrées d'un programme. Si le programme échoue (par exemple en plantant ou en générant une erreur), alors il y a des défauts à corriger. (Wikipedia)

Microsoft utilise cette technique et a pendant longtemps utilisé son outil interne Microsoft Security and Risk Detection. Plus tôt cette année, Microsoft avait annoncé son intention de remplacer cet outil par un outil open source.

Ce nouvel outil s'appelle OneFuzz. Il est un framework de test fuzz extensible pour Azure. Microsoft utilise OneFuzz en interne pour tester son navigateur Edge et Windows.

Permettre aux développeurs d'effectuer des tests fuzz déplace la découverte des vulnérabilités au début du cycle de vie du développement et libère simultanément les équipes d'ingénierie de la sécurité pour qu'elles poursuivent un travail proactif, souligne Microsoft.

OneFuzz est conçu pour être multi plates-formes. Cela signifie que vous pouvez l'employer sur linux, en utilisant votre propre build de système d'exploitation, noyau ou hyperviseur imbriqué.

OneFuzz est un logiciel libre sous licence MIT, disponible sur GitHub.

Fuzzlyn : un fuzzer pour trouver des bugs dans le JIT de .NET

Soumis par fredericmazue le

Fuzzlyn est un utilitaire qui intéressera ceux qui aiment pousser dans leurs derniers retranchements les outils avec lesquels ils travaillent.

Fuzzlyn est un fuzzer qui génère avec Roselyn des programmes  C# aléatoires dans le but de trouver des bugs dans le compilateur JIT (Just In Time) de .NET

Le fuzzing (ou test à données aléatoire) est une technique pour tester des logiciels. L'idée est d'injecter des données aléatoires dans les entrées d'un programme. Si le programme échoue (par exemple en plantant ou en générant une erreur), alors il y a des défauts à corriger. (Wikipedia)

Dans le cas de Fuzzlyn, les données aléatoires sont donc des programmes aléatoires qui sont les entrées du programme à tester qu'est le JIT .NET.

Au fait pourquoi tester le JIT de .NET et non le compilateur Roselyn lui-même ? Parce que ce dernier fait peu d'optimisations au moment de la compilation. Il y a donc peu de chances de trouver des bugs en son sein. En revanche le compilateur JIT effectue d'importantes opérations d'optimisation, et c'est à priori là que les bugs préféreront venir se nicher. Ce genre de bugs se manifestera par un résultat du programme différent selon qu'il s'exécute en mode 'debug' (non optimisé) ou en mode 'release'.

On lance Fuzzlyn en lui demandant par exemple de générer un million de programmes (= 1 million d'entrées aléatoires pour le JIT.NET)

dotnet fuzzlyn.dll --num-programs 1000000

On fait chauffer son café et on attend que Fuzzlyn génère ce million de programmes en exécutant chacun d'eux en mode debug et release et signale les cas qui produisent une sortie différente.

Fuzzlyn est un projet open source, disponible sur GitHub.

Sur la page du projet sont présentés quelques bugs qui ont été trouvés avec Fuzzlyn. Par exemple :

// Generated by Fuzzlyn on 2018-06-03 16:17:09
// Seed: 10744458083861091494
// Reduced from 21.3 KB to 0.2 KB
// Debug: Outputs '246'
// Release: Outputs '4294967286'

public class Program
{
    static sbyte s_1 = -10;
    public static void Main()
    {
        ulong vr44 = (byte)(0U ^ s_1);
        System.Console.WriteLine(vr44);
    }
} 

ou bien

// Generated by Fuzzlyn on 2018-06-03 16:15:22
// Seed: 10187462581749713401
// Reduced from 186.5 KB to 0.2 KB
// Debug: Runs successfully
// Release: Throws 'System.DivideByZeroException'

public class Program
{
   public static void Main()
   {
       var vr219 = 'N' % ((35815 / M1(new ushort[]{65535})) | 1);
   }

   static ushort M1(ushort[] arg2)
   {
       return arg2[0];
   }
}