PVS-Studio est maintenant disponible sur Chocolatey : vérification de Chocolatey via Azure DevOps

Nous continuons à faciliter l'utilisation de PVS-Studio. Désormais, notre analyseur est disponible dans Chocolatey, le gestionnaire de paquets pour Windows. Nous pensons que cela simplifiera le déploiement de PVS-Studio, notamment dans les services cloud. Pour ne pas aller loin, vérifions le code source de Chocolatey. Azure DevOps servira de système CI.

Voici une liste de nos autres articles sur l'intégration avec des systèmes cloud :

• PVS-Studio s'installe dans le cloud : Azure DevOps
• PVS-Studio s'installe dans le cloud : Travis CI
• PVS-Studio s'installe dans le cloud : CircleCI
• PVS-Studio s'installe dans le cloud : GitLab CI/CD

Je vous conseille de prêter attention au premier article sur l'intégration avec Azure DevOps, car certains points y sont omis pour éviter les doublons.

Ainsi, les héros de cet article sont :

PVS-Studio — un outil d'analyse statique du code, conçu pour identifier les erreurs et les vulnérabilités potentielles dans des programmes écrits en C, C++, C# et Java. Il fonctionne sur des systèmes 64 bits sous Windows, Linux et macOS, et peut analyser du code destiné aux plateformes ARM 32 bits, 64 bits et embarquées. Si vous essayez l'analyse statique du code pour la première fois sur vos projets, nous vous recommandons de consulter mais la syntaxe des requêtes y est ancienne, il faut en tenir compte. sur la façon de visualiser rapidement les avertissements intéressants de PVS-Studio et d'évaluer les capacités de cet outil.

Azure DevOps — un ensemble de services cloud qui couvre tout le processus de développement. Cette plateforme comprend des outils tels que Azure Pipelines, Azure Boards, Azure Artifacts, Azure Repos, et Azure Test Plans, permettant d'accélérer le processus de création de logiciels et d'en améliorer la qualité.

Chocolatey – un gestionnaire de paquets open source pour Windows. L'objectif du projet est d'automatiser l'ensemble du cycle de vie des logiciels, de l'installation à la mise à jour et à la suppression, sous les systèmes d'exploitation Windows.

Sur l'utilisation de Chocolatey

Vous pouvez voir comment installer le gestionnaire de paquets lui-même à partir de cette le lien. La documentation complète sur l'installation de l'analyseur est disponible le lien dans la section « Installation à l'aide du gestionnaire de paquets Chocolatey ». Je vais brièvement rappeler certains points de là-bas.

Commande pour installer la dernière version de l'analyseur :

choco install pvs-studio

Commande pour installer une version spécifique du paquet PVS-Studio :

choco install pvs-studio --version=7.05.35617.2075

Par défaut, seul le noyau de l'analyseur - le composant Core - est installé. Tous les autres indicateurs (Standalone, JavaCore, IDEA, MSVS2010, MSVS2012, MSVS2013, MSVS2015, MSVS2017, MSVS2019) peuvent être passés à l'aide de —package-parameters.

Voici un exemple de commande qui installera l'analyseur avec le plugin pour Visual Studio 2019 :

choco install pvs-studio --package-parameters="'\/MSVS2019'"

Voyons maintenant un exemple d'utilisation pratique de l'analyseur sous Azure DevOps.

Configuration

Je rappelle que des points comme l'enregistrement d'un compte, la création d'un pipeline de construction et la synchronisation du compte avec le projet dans le dépôt sur GitHub sont abordés dans un document séparé. article. Notre configuration commencera directement par l'écriture du fichier de configuration.

Pour commencer, configurons le déclencheur d'exécution en indiquant que nous ne lançons que pour les modifications dans master la branche :

trigger:
- master

Ensuite, nous devons choisir une machine virtuelle. Pour le moment, ce sera un agent hébergé par Microsoft avec Windows Server 2019 et Visual Studio 2019 :

pool:
  vmImage: 'windows-latest'

Passons au corps du fichier de configuration (bloc steps). Bien qu'il ne soit pas possible d'installer des logiciels arbitraires sur la machine virtuelle, je n'ai pas ajouté de conteneur Docker. Nous pouvons ajouter Chocolatey en tant qu'extension pour Azure DevOps. Pour cela, allons à le lien. Cliquez sur Get it free. Ensuite, si vous êtes déjà connecté, il vous suffit de choisir votre compte, sinon, suivez la même procédure après vous être connecté.

Ici, vous devez choisir où nous ajouterons l'extension, puis appuyer sur le bouton Installer.

Après l'installation réussie, cliquons sur Proceed to organization:

Vous pouvez maintenant voir le modèle de tâche Chocolatey dans la fenêtre tasks lors de l'édition du fichier de configuration azure-pipelines.yml :

Cliquons sur Chocolatey et verrons la liste des champs :

Ici, nous devons sélectionner install dans le champ des commandes. Dans Nuspec File Name nous spécifions le nom du package souhaité - pvs-studio. Si nous ne spécifions pas de version, c'est la dernière qui sera installée, ce qui nous convient parfaitement. Cliquons sur le bouton add et nous verrons la tâche générée dans le fichier de configuration.

steps:
- task: ChocolateyCommand@0
  inputs:
    command: 'install'
    installPackageId: 'pvs-studio'

Passons maintenant à la partie principale de notre fichier :

- task: CmdLine@2
  inputs:
    script : 

Nous devons maintenant créer un fichier avec la licence de l'analyseur. Ici PVSNAME et PVSKEY – sont les noms des variables dont nous spécifions les valeurs dans les paramètres. Elles stockeront le login et la clé de licence de PVS-Studio. Pour définir leurs valeurs, ouvrons le menu Variables->New variable. Créons des variables PVSNAME pour le login et PVSKEY pour la clé de l'analyseur. N'oubliez pas de cocher la case Gardez cette valeur secrète pour PVSKEY. Code de la commande :

call "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" credentials 
–u $(PVSNAME) –n $(PVSKEY)

Nous allons rassembler le projet à l'aide du fichier bat situé dans le référentiel :

call build.bat

Créons un dossier où seront stockés les fichiers contenant les résultats du travail de l'analyseur :

call mkdir PVSTestResults

Lançons l'analyse du projet :

call "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" 
–t .srcchocolatey.sln –o .PVSTestResultsChoco.plog 

Convertissons notre rapport au format html en utilisant l'utilitaire PlogConverter :

call "C:Program Files (x86)PVS-StudioPlogConverter.exe" 
–t html –o PVSTestResults .PVSTestResultsChoco.plog

Nous devons maintenant créer une tâche afin de pouvoir télécharger le rapport.

- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: PVSTestResults
    artifactName: PVSTestResults
    condition: always()

Le fichier de configuration complet ressemble à ceci :

trigger:
- master

pool:
  vmImage: 'windows-latest'

steps:
- task: ChocolateyCommand@0
  inputs:
    command: 'install'
    installPackageId: 'pvs-studio'

- task: CmdLine@2
  inputs:
    script: |
      call "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" 
      credentials –u $(PVSNAME) –n $(PVSKEY)
      call build.bat
      call mkdir PVSTestResults
      call "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" 
      –t .srcchocolatey.sln –o .PVSTestResultsChoco.plog
      call "C:Program Files (x86)PVS-StudioPlogConverter.exe" 
      –t html –o .PVSTestResults .PVSTestResultsChoco.plog

- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: PVSTestResults
    artifactName: PVSTestResults
    condition: always()

Cliquez sur Enregistrer->Enregistrer->Exécuter pour exécuter la tâche. Nous téléchargerons le rapport en accédant à l'onglet des tâches.

Le projet Chocolatey contient un total de 37615 lignes de code C#. Examinons certaines des erreurs trouvées.

Résultats de l'analyse

Avertissement N1

Avertissement de l'analyseur : V3005 La variable ‘Provider’ est assignée à elle-même. CrytpoHashProviderSpecs.cs 38

public abstract class CrytpoHashProviderSpecsBase : TinySpec
{
  ....
  protected CryptoHashProvider Provider;
  ....
  public override void Context()
  {
    Provider = Provider = new CryptoHashProvider(FileSystem.Object);
  }
}

L'analyseur a détecté qu'une variable est assignée à elle-même, ce qui n'a pas de sens. Il est probable qu'à la place de l'une de ces variables, une autre devrait être utilisée. Ou alors, c'est une faute de frappe, et l'assignation superflue peut tout simplement être supprimée.

Avertissement N2

Avertissement de l'analyseur : V3093 [CWE-480] L'opérateur ‘&’ évalue les deux opérandes. Peut-être qu'un opérateur ‘&&’ à court-circuit devrait être utilisé à la place. Platform.cs 64

public static PlatformType get_platform()
{
  switch (Environment.OSVersion.Platform)
  {
    case PlatformID.MacOSX:
    {
      ....
    }
    case PlatformID.Unix:
    if(file_system.directory_exists("/Applications")
      & file_system.directory_exists("/System")
      & file_system.directory_exists("/Users")
      & file_system.directory_exists("/Volumes"))
      {
        return PlatformType.Mac;
      }
        else
          return PlatformType.Linux;
    default:
      return PlatformType.Windows;
  }
}

La différence entre l'opérateur & et l'opérateur && réside dans le fait que si la partie gauche de l'expression — faux, cela calculera tout de même la partie droite, ce qui dans ce cas implique des appels de méthode inutiles. system.directory_exists.

Dans le fragment examiné, c'est un petit détail. Oui, cette condition peut être optimisée en remplaçant l'opérateur & par l'opérateur &&, mais d'un point de vue pratique, cela n'a aucune influence. Cependant, dans d'autres cas, la confusion entre & et && peut provoquer de graves problèmes lorsque la partie droite de l'expression traite des valeurs incorrectes ou non autorisées. Par exemple, dans notre collection d'erreurs, détectées par le diagnostic V3093, il y a ce cas :

if ((k < nct) && (s[k] != 0.0))

Même si l'index k est incorrect, il sera utilisé pour accéder à l'élément du tableau. Cela générera une exception IndexOutOfRangeException.

Avertissements N3, N4

Avertissement de l'analyseur : V3022 [CWE-571] L'expression ‘shortPrompt’ est toujours vraie. InteractivePrompt.cs 101
Avertissement de l'analyseur : V3022 [CWE-571] L'expression ‘shortPrompt’ est toujours vraie. InteractivePrompt.cs 105

public static string 
prompt_for_confirmation(.... bool shortPrompt = false, ....)
{
  ....
  if (shortPrompt)
  {
    var choicePrompt = choice.is_equal_to(defaultChoice) //1
    ?
    shortPrompt //2
    ?
    "[[{0}]{1}]".format_with(choice.Substring(0, 1).ToUpperInvariant(), //3
    choice.Substring(1,choice.Length - 1))
    :
    "[{0}]".format_with(choice.ToUpperInvariant()) //0
    : 
    shortPrompt //4
    ? 
    "[{0}]{1}".format_with(choice.Substring(0,1).ToUpperInvariant(), //5
    choice.Substring(1,choice.Length - 1)) 
    :
    choice; //0
    ....
  }
  ....
}

Dans ce cas, il y a une logique étrange dans le fonctionnement de l'opérateur ternaire. Examinons plus en détail : si la condition marquée par le chiffre 1 se réalise, nous passerons à la condition 2, qui est toujours true, ce qui signifie que la ligne 3 sera exécutée. Si la condition 1 s'avère fausse, nous passerons à la ligne marquée par le chiffre 4, dont la condition est également toujours true, ce qui signifie que la ligne 5 sera exécutée. Ainsi, les conditions marquées par le commentaire 0 ne seront jamais exécutées, ce qui peut ne pas correspondre à la logique que le programmeur avait en tête.

Avertissement N5

Avertissement de l'analyseur : V3123 [CWE-783] Peut-être que l'opérateur ‘?:’ fonctionne différemment de ce qui était attendu. Sa priorité est inférieure à celle d'autres opérateurs dans sa condition. Options.cs 1019

private static string GetArgumentName (...., string description)
{
  string[] nameStart;
  if (maxIndex == 1)
  {
    nameStart = new string[]{"{0:", "{"};
  }
  else
  {
    nameStart = new string[]{"{" + index + ":"};
  }
  for (int i = 0; i = 0 && j != 0 ? description [j++ - 1] == '{' : false);
    ....
    return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1);
  }
}

Le diagnostic a été déclenché sur la ligne :

while (start >= 0 && j != 0 ? description [j++ - 1] == '{' : false)

Étant donné que la variable j plus haut, il est initialisé à zéro, l'opérateur ternaire retournera une valeur faux. En raison de cette condition, le corps de la boucle ne s'exécutera qu'une seule fois. Je pense que ce fragment de code fonctionne tout à fait différemment de ce que le programmeur avait prévu.

Avertissement N6

Avertissement de l'analyseur : V3022 [CWE-571] L'expression 'installedPackageVersions.Count != 1' est toujours vraie. NugetService.cs 1405

private void remove_nuget_cache_for_package(....)
{
  if (!config.AllVersions && installedPackageVersions.Count > 1)
  {
    const string allVersionsChoice = "Toutes versions";
    if (installedPackageVersions.Count != 1)
    {
      choices.Add(allVersionsChoice);
    }
    ....
  }
  ....
}

Il y a une condition imbriquée étrange ici : installedPackageVersions.Count != 1, qui sera toujours true. Souvent, ce genre d'avertissement signale une erreur logique dans le code, ou parfois juste une vérification redondante.

Avertissement N7

Avertissement de l'analyseur : V3001 Il y a des sous-expressions identiques 'commandArguments.contains("-apikey")' à gauche et à droite de l'opérateur '||'. ArgumentsUtility.cs 42

public static bool arguments_contain_sensitive_information(string
 commandArguments)
{
  return commandArguments.contains("-install-arguments-sensitive")
  || commandArguments.contains("-package-parameters-sensitive")
  || commandArguments.contains("apikey ")
  || commandArguments.contains("config ")
  || commandArguments.contains("push ")
  || commandArguments.contains("-p ")
  || commandArguments.contains("-p=")
  || commandArguments.contains("-password")
  || commandArguments.contains("-cp ")
  || commandArguments.contains("-cp=")
  || commandArguments.contains("-certpassword")
  || commandArguments.contains("-k ")
  || commandArguments.contains("-k=")
  || commandArguments.contains("-key ")
  || commandArguments.contains("-key=")
  || commandArguments.contains("-apikey")
  || commandArguments.contains("-api-key")
  || commandArguments.contains("-apikey")
  || commandArguments.contains("-api-key");
}

Le programmeur qui a écrit ce bout de code a copié-collé les deux dernières lignes et a oublié de les modifier. En conséquence, les utilisateurs de Chocolatey n'ont pas pu appliquer le paramètre apikey d'autres manières également. De la même manière que les paramètres ci-dessus, je peux proposer les options suivantes :

commandArguments.contains("-apikey=");
commandArguments.contains("-api-key=");

Les erreurs de copie-coller ont de grandes chances d'apparaître tôt ou tard dans tout projet avec beaucoup de code source, et l'un des meilleurs moyens de lutter contre cela est l'analyse statique.

P.S. Et comme toujours, cette erreur a tendance à apparaître à la fin d'une condition multi-ligne :). Voir la publication "L'effet de la dernière ligne".

Avertissement N8

Avertissement de l'analyseur : V3095 [CWE-476] L'objet 'installedPackage' a été utilisé avant d'avoir été vérifié contre null. Vérifiez les lignes : 910, 917. NugetService.cs 910

public virtual ConcurrentDictionary get_outdated(....)
{
  ....
  var pinnedPackageResult = outdatedPackages.GetOrAdd(
    packageName, 
    new PackageResult(installedPackage, 
                      _fileSystem.combine_paths(
                        ApplicationParameters.PackagesLocation, 
                        installedPackage.Id)));
  ....
  if (   installedPackage != null
      && !string.IsNullOrWhiteSpace(installedPackage.Version.SpecialVersion) 
      && !config.UpgradeCommand.ExcludePrerelease)
  {
    ....
  }
  ....
}

Erreur classique : l'objet est utilisé avant d'être vérifié installedPackage Cela indique l'une des deux problèmes dans le programme : soit nulln'est jamais égal à installedPackage , ce qui est douteux, et donc la vérification est superflue, soit nous pouvons potentiellement rencontrer une grave erreur dans le code – une tentative d'accès par un pointeur nul. nullVoilà, nous avons encore fait un petit pas – utiliser PVS-Studio est devenu encore plus simple et pratique. Je tiens également à dire que Chocolatey est un bon gestionnaire de paquets avec peu d'erreurs dans le code, qui pourraient encore diminuer avec l'utilisation de PVS-Studio.

Conclusion

et essayez PVS-Studio. L'utilisation régulière de l'analyseur statique améliorera la qualité et la fiabilité du code développé par votre équipe et aidera à prévenir de nombreuses

Nous vous invitons télécharger vulnérabilités de type zero-day Avant publication, nous avons envoyé l'article aux développeurs de Chocolatey, et ils l'ont bien accueilli. Rien de critique n'a été trouvé par nos soins, mais ils ont, par exemple, apprécié l'erreur que nous avons trouvée concernant la clé « api-key »..

P.S.

PVS-Studio est maintenant intégré à Chocolatey : Vérification de Chocolatey sous Azure DevOps

Si vous souhaitez partager cet article avec un public anglophone, veuillez utiliser le lien vers la traduction : Vladislav Stolyarov. Nous continuons..

Source : habr.com