Pause café #35. Comment se conformer aux règles de sécurité de GitHub. Conseils utiles pour déboguer rapidement le code Java

Comment rester en sécurité sur GitHub

Source : DZone GitHub est à juste titre considérée comme la plateforme de développement d'équipe la plus populaire. Selon les données de l'automne dernier, plus de 40 millions de programmeurs ont utilisé ce service. Et comme la plupart d’entre eux utilisent l’open source pour créer des logiciels, la sécurité lorsque vous travaillez sur Github devrait être votre priorité absolue. La réutilisation du code augmente le risque de propagation des vulnérabilités. Cela signifie que chaque utilisateur de GitHub doit accorder une attention maximale à la création d'un environnement de développement sécurisé. Il y a 8 règles que vous devez suivre pour assurer la sécurité de votre code GitHub.

Assurer le contrôle d’accès

Le contrôle d'accès est l'un des meilleurs moyens d'améliorer la sécurité non seulement sur GitHub, mais dans tout autre environnement où la protection du code est requise. GitHub propose plusieurs façons de réduire les risques dans votre travail. Tout d’abord, prenez pour habitude d’accorder le moindre privilège : accordez aux utilisateurs du référentiel uniquement les autorisations dont ils ont besoin pour faire leur travail. Il existe d'autres méthodes de contrôle d'accès que vous devez suivre :

• limiter la création de référentiels pour empêcher les utilisateurs de divulguer des informations sur l'organisation dans des référentiels publics ;
• activer la protection des branches et les contrôles d'état afin que les utilisateurs puissent fusionner les validations ou gérer les branches en toute sécurité ;
• Autoriser ou désactiver le fork des référentiels privés pour garantir que les utilisateurs ne divulguent pas ou ne partagent pas votre code avec d'autres ;
• révoquer l'accès à tous les utilisateurs inactifs qui ne sont plus membres de votre communauté ou employés de l'entreprise ;
• Vérifiez périodiquement les droits d'accès à vos projets sur GitHub ;
• Assurez-vous que les utilisateurs ne partagent pas l'accès au compte GitHub ou les mots de passe avec d'autres ;
• assurez-vous que chaque utilisateur du référentiel utilise une authentification à deux facteurs dans son compte ;
• Modifiez périodiquement les jetons d'accès personnels et les clés SSH.

Ne stockez jamais les données d'accès dans vos fichiers GitHub

La fuite d'informations d'accès à votre référentiel GitHub via du code, des fichiers de configuration ou des messages de validation peut être utilisée pour des attaques. Pour empêcher l'ajout de données sensibles à votre référentiel, utilisez des outils de contrôle d'accès comme git-secrets ou vault . Ces outils analysent votre base de code et modifient l'accès chaque fois que des informations sensibles sont trouvées dans votre code ou vos fichiers de configuration. Si vous trouvez des informations sensibles dans votre référentiel GitHub, vous devez les supprimer immédiatement. Mais comme GitHub conserve un historique de tous les commits dans votre référentiel, la suppression seule des données ne suffit pas. Vous devrez supprimer des fichiers de l'historique de votre référentiel GitHub. Une étape importante pour améliorer la sécurité sera le remplacement de tous les mots de passe et jetons qui étaient auparavant accessibles au public.

Activer les alertes pour les dépendances vulnérables

À mesure que les utilisateurs de GitHub travaillent sur davantage de projets, il devient de plus en plus difficile de contrôler le nombre croissant d'objets dépendants. Heureusement, GitHub fournit des alertes automatiques pour les dépendances vulnérables trouvées dans le référentiel. Ces alertes sont basées sur la base de données nationale sur les vulnérabilités (NVD), les avis de sécurité GitHub et la base de données sur les vulnérabilités WhiteSource, qui prend en charge plus de 200 langages de programmation. Les alertes GitHub facilitent et sécurise l'utilisation des bibliothèques open source.

Vérifier les applications ajoutées depuis GitHub

Le GitHub Marketplace contient des centaines d'applications écrites par des développeurs et des entreprises tiers. Par conséquent, il est important d’examiner attentivement chaque application que vous ajoutez à votre référentiel. Lors de l'installation d'applications à partir de GitHub Marketplace, suivez ces directives :

• Appliquer le principe du moindre privilège. N'accordez jamais aux applications plus de droits d'accès que ce dont elles ont besoin ;
• Remettez toujours en question les droits d’accès ou les autorisations demandés par une application. Pensez aux dégâts que cela pourrait causer avec ce niveau d’accès ;
• Vérifiez que l'entreprise ou le développeur de l'application existe réellement avant de lui accorder l'accès à votre référentiel GitHub ;
• Vérifiez la fonctionnalité et la sécurité de l'application. S'il contient des vulnérabilités, vous risquez d'être victime de piratage ;

La sécurité d’une application se juge par sa partie la plus faible. Cela s'applique également aux référentiels GitHub. Ainsi, avant de donner à une application l’accès à votre stockage, assurez-vous de lui faire confiance et qu’elle correspond au niveau d’accès qu’elle demande.

Vérifiez tout le code importé de GitHub

Les développeurs utilisent souvent le code d'autres personnes. Chaque fois que vous copiez une partie du code de quelqu'un d'autre dans votre projet, effectuez un examen complet de celui-ci. Cela peut sembler une perte de temps, surtout pour les petits projets, mais il est possible qu'en négligeant cette règle, vous introduisiez une vulnérabilité dans votre référentiel. Un autre risque associé au code importé est qu'il peut contenir des informations sensibles telles que des données d'accès. S'ils sont stockés dans des fichiers GitHub, cela crée un autre risque de sécurité. Auditer le code avant de le copier permet d'identifier de telles failles. Ne présumez pas que le code de quelqu'un d'autre est en sécurité parce qu'il se trouve dans un référentiel privé. Cela pourrait très bien nuire à votre base de code.

Utilisez l'analyse statique automatique du code source pour vos référentiels

Il existe plusieurs outils tiers que vous pouvez utiliser pour analyser les vulnérabilités de votre référentiel. L'un d'eux est WhiteSource Bolt , un outil gratuit du GitHub Marketplace. WhiteSource Bolt analyse vos référentiels à la recherche de vulnérabilités dans tout le code exposé. Il fournit également des informations détaillées sur les vulnérabilités et suggère des options de remédiation.

Utilisez le plan GitHub qui correspond à vos besoins

De nombreuses entreprises ont des politiques qui empêchent les développeurs de publier du code sur des plateformes comme GitHub. Ces restrictions sont particulièrement courantes dans les ministères et les institutions financières. Si vous travaillez dans un environnement hautement réglementé, utilisez GitHub Enterprise , un plan d'entreprise qui vous permet d'héberger des référentiels sur un serveur local. Cela offre un niveau de sécurité plus élevé car cela permet aux développeurs de l'entreprise d'avoir accès à tous les projets sans se soucier des utilisateurs GitHub non autorisés.

Suivez une politique de sécurité globale dans vos projets

La sécurité est une responsabilité collective. Si vous travaillez en équipe, il est important d’établir des règles de sécurité que toutes les parties prenantes doivent respecter. Idéalement, vous devriez réunir les équipes de cybersécurité et de développement pendant la phase de planification pour vous assurer qu'elles travaillent en synchronisation. Il sera ainsi plus facile d’assurer la protection pendant le processus de développement. Si l’un des membres de votre équipe néglige de stocker des mots de passe ou d’autres informations sensibles, cela pourrait mettre en danger l’ensemble du référentiel. Pour éviter cela, documentez clairement la procédure de sécurité que tous vos collègues doivent suivre.

Conclusion

Sécuriser votre code sur GitHub est simple. Il vous suffit de garantir un contrôle d'accès approprié, en profitant des fonctionnalités de sécurité intégrées de GitHub. Si vous êtes intéressé par une protection maximale, intégrez des outils supplémentaires qui augmenteront la sécurité du code à toutes les étapes du développement. Nous vous recommandons également de consulter les sections GitHub Security for Business et Free Users de la documentation . De cette façon, vous pouvez obtenir des informations supplémentaires sur la sécurité et la protection du code.

Conseils utiles pour déboguer rapidement le code Java

Source : Hackernoon Outre l'écriture de code efficace, améliorer le débogage est l'une des choses les plus utiles que vous puissiez faire pour vous faciliter la vie en tant que développeur Java. Ceci est particulièrement important dans les conditions modernes de développement de logiciels, où le monde du logiciel évolue activement vers des architectures distribuées et du code asynchrone. Même si les erreurs logicielles sont inévitables, elles deviennent de plus en plus difficiles à détecter et à corriger dans les versions complexes. Et lorsque l'on passe à l'étape de publication du produit, le processus de débogage devient un problème encore plus grave. Malheureusement, il n'y a aucun moyen d'éviter cela : le débogage est nécessaire. Pour vous aider, j'ai décidé de partager quelques conseils utiles pour déboguer les applications Java à différentes étapes de développement.

Utiliser des points de contrôle

Commençons par les points d'arrêt, un point évident mais très important qui sous-tend tout processus de débogage. Les points de contrôle vous permettent d'arrêter l'exécution d'une application afin que vous puissiez analyser l'état du programme et comprendre pourquoi le code ne fonctionne pas correctement. Chaque débogueur propose plusieurs options de points d'arrêt, notamment des points d'arrêt conditionnels, des points d'arrêt d'exception, des points de surveillance et des points de trace. Apprendre comment et quand utiliser différents types de points d'arrêt peut rendre le processus de débogage plus fluide. Il convient de mentionner que certains outils modernes prennent en charge les points de contrôle sans interrompre l'application. Cela permet de définir des points dans votre code et de collecter des données de débogage sans arrêter l'exécution du programme.

Afficher la structure logique

La fonctionnalité Afficher la structure logique est très utile lors de la surveillance du contenu des classes Java. Si cette fonctionnalité est activée, la liste des variables affiche un tableau, ce qui est bien plus utile dans un contexte de débogage. C'est très pratique, surtout si votre code ne dispose pas de méthodes toString() pour les objets. Les vues variables vous permettent également de modifier directement les valeurs de vos variables lors du débogage. Cela peut permettre de gagner beaucoup de temps en évitant de devoir redémarrer la session de débogage avec des données d'entrée modifiées.

Apprenez à naviguer dans la base de code

Tout débogueur Java peut utiliser plusieurs fonctions qui vous permettent de naviguer dans différentes sections de code lors du débogage. Certains d'entre eux incluent « courir jusqu'à la ligne », « enjamber », « entrer dans » et « entrer dans ». En plus de celles-ci, envisagez deux autres options :

1. Drop to frame - Cette fonction est utilisée pour revenir à un point de votre frame de pile. Si vous avez manqué un point et devez revenir en arrière, utilisez simplement la fonction Drop to frame.
2. Filtrage par étapes - vous permet d'ignorer certains paquets pendant le débogage. Vous n'avez pas besoin de parcourir toutes les classes du système JDK lorsque vous pouvez simplement filtrer les types dont vous n'avez pas besoin.

Pour améliorer la vitesse de navigation de votre code, vous devez maîtriser les combinaisons de touches de fonction :

• F5 - pour « entrer ».
• F6 - pour « enjamber ».
• F7 - pour "retour pas à pas".
• F8 - pour courir jusqu'au prochain point de contrôle.

Bien que les raccourcis clavier puissent varier d'un IDE à l'autre, si vous vous en souvenez, cela vous évitera d'avoir à utiliser la souris plus souvent.

Apprenez à éviter les blocages

Un scénario de blocage se produit lorsque deux threads ou plus se bloquent après avoir formé une dépendance circulaire. Étant donné qu'un ensemble de threads Java attend généralement une autre ressource, cela peut entraîner l'arrêt complet de l'application. Le débogage des blocages de jstack peut être assez difficile car ils n'affichent pas d'indicateurs de problèmes tels que les pics de mémoire, la charge du processeur, etc. Il existe différentes approches pour résoudre une situation de blocage de jstack. Tout d’abord, vous pouvez capturer plusieurs thread dumps dans votre cluster JVM pour déduire des modèles de thread. Dans ce cas, l’analyse d’un thread dump statique peut ne pas suffire. En fonction de la taille du cluster JVM, il peut être nécessaire d'explorer plusieurs fichiers, ce qui constitue souvent un processus long et fastidieux. Il est préférable d'utiliser une solution de surveillance des applications qui fournit la couche JV et la couche de code nécessaires pour isoler les blocages de threads. Heureusement, il existe des outils innovants qui peuvent aider à résoudre cette situation, notamment certains débogueurs modernes ainsi que des outils APM commerciaux. Ces outils augmentent la transparence de votre code Java tout en identifiant les erreurs.

Tirez parti de la puissance des débogueurs de production

Le processus de débogage typique que la plupart des développeurs suivent généralement consiste à répliquer l'environnement, à isoler l'erreur, puis à la corriger. Toutefois, cela ne s’applique pas dans tous les cas. Si tel est le cas, le développeur doit utiliser de puissants débogueurs de production. Rookout est l'un de ces outils. Il vous permet de collecter des données de débogage à partir d'applications sans changer leur état ou leur contrôle de flux. Avec Rookout, vous pouvez définir des points d'arrêt insécables pour obtenir une trace complète de la pile, capturer des variables actives ou toute autre donnée d'application nécessaire au débogage. Ainsi, au lieu d'utiliser des solutions de surveillance coûteuses pour le débogage en production, utilisez simplement Rookout, qui fournit tout ce dont vous avez besoin pour déboguer les applications sans redéployer ni écrire de nouveau code. Que vous travailliez sur des applications côté serveur ou conteneurisées, Rookout est un excellent ajout à votre arsenal de débogage.

N'oubliez pas le débogage à distance

La grande majorité des IDE, tels que NetBeans, Eclipse, IntelliJ IDEA et Visual Studio, prennent en charge le débogage à distance, une technique qui vous permet de corriger le code Java situé sur un autre ordinateur. Ceci est particulièrement important dans les situations où votre système ne prend pas en charge le débogage local ou lorsque votre ordinateur ne dispose pas de suffisamment de ressources pour exécuter des débogueurs. Pour effectuer un débogage à distance, vous devez fournir les informations de configuration que le débogueur utilisera pour se connecter au port distant. Le débogage à distance est également utile dans les situations de dépannage dans lesquelles les développeurs hors site doivent se connecter à l'application pour corriger un bug. N'oubliez pas que le débogage peut parfois prendre plus de temps que la mise en œuvre réelle. Au fur et à mesure que vous perfectionnez vos compétences en débogage Java, efforcez-vous toujours d’écrire du code propre et efficace : cela s’avère payant lorsqu’il s’agit de corriger des bogues. Si vous avez l’impression que les choses deviennent incontrôlables, c’est toujours une bonne idée de faire une pause. Un bug est un casse-tête de programmation, et de nombreux programmeurs ont réussi à résoudre ce problème sans être à proximité de leur ordinateur. Utilisez les stratégies décrites ci-dessus pour vous débarrasser des problèmes de débogage Java. Bon codage !