OpENer
Shared lib and fix delayed list identity
OpENer est une pile EtherNet/IP™ pour les dispositifs adaptateurs d'E/S ; prend en charge plusieurs E/S et connexions explicites ; inclut des objets et des services pour créer des produits conformes à EtherNet/IP™ définis dans la SPÉCIFICATION ETHERNET/IP et publiés par ODVA (http://www.odva.org).
Les utilisateurs et les développeurs d'OpENer peuvent rejoindre les groupes Google respectifs afin d'échanger des expériences, de discuter de l'utilisation d'OpENer et de suggérer de nouvelles fonctionnalités et objets CIP qui seraient utiles à la communauté.
Liste de diffusion des développeurs : https://groups.google.com/forum/#!forum/eip-stack-group-opener-developers
Liste de diffusion des utilisateurs : https://groups.google.com/forum/#!forum/eip-stack-group-opener-users
OpENer a été développé pour être hautement portable. La version par défaut cible les PC dotés d'un système d'exploitation POSIX et d'une interface réseau socket BSD. Pour tester cette version, nous recommandons un PC Linux ou Windows avec Cygwin (http://www.cygwin.com) installé. Vous devrez installer les éléments suivants :
pour une construction normale. Ceux-ci doivent être installés sur la plupart des installations Linux et font partie des packages de développement de Cygwin.
Si vous souhaitez exécuter les tests unitaires, vous devrez également télécharger CppUTest via https://github.com/cpputest/cpputest
Pour configurer le projet, nous recommandons l'utilisation d'une interface graphique CMake (par exemple, le package cmake-gui sous Linux ou le programme d'installation pour Windows disponible sur CMake).
setup_posix.sh Invoquez la commande make
Appel d'Opener :
./src/ports/POSIX/OpENer
par exemple ./src/ports/POSIX/OpENer eth1
OpENer dispose également désormais d'un démarrage POSIX en temps réel via l'option OpENer_RT, qui nécessite que le noyau utilisé dispose de tous les correctifs RT préemptifs appliqués et activés. Si vous souhaitez utiliser OpENer_RT, avant l'étape 2, exécutez sudo setcap cap_ipc_lock,cap_sys_nice+ep ./src/ports/POSIX/OpENer pour accorder à OpENEr CAP_SYS_NICE et les capacités CAP_IPC_LOCK , qui sont nécessaires pour le mode RT.
OpENer peut également être construit et installé en tant que bibliothèque en définissant l'indicateur CMake -DOPENER_INSTALL_AS_LIB . Pour créer une bibliothèque partagée, l'option globale -DBUILD_SHARED_LIBS=ON doit également être définie. Il a été testé uniquement sous plateforme Linux/POSIX.
Build All dans Visual StudioRemplacez par binwin32srcportsWIN32
Selon si vous avez choisi la configuration Debug ou Release dans Visual Studio, votre exécutable apparaîtra dans le sous-dossier Debug ou Release.
Appelez Opener via
OpENer
par exemple OpENer 3
Afin d'obtenir l'index d'interface correct, entrez la commande route print dans une invite de commande et recherchez l'adresse MAC de l'interface réseau choisie au début de la sortie. Le numéro le plus à gauche est l'index d'interface correspondant.
Le fichier d'installation POSIX peut être réutilisé pour Cygwin. Veuillez noter que vous ne pouvez pas utiliser le mode RT et que vous devrez supprimer le code chargé de vérifier et d'obtenir les fonctionnalités nécessaires, car libcap n'est pas disponible dans Cygwin. Le moyen le plus simple et le plus pris en charge de créer OpENer pour Windows consiste à utiliser MinGW ou Visual Studio.
setup_mingw.bat dans une ligne de commande dos. (Pas un shell bash). Si le traçage est souhaité, utilisez ce qui suit (où le paramètre cmake doit être placé entre guillemets) ou modifiez le fichier ./source/CMakeList.txt. setup_mingw.bat "-DOpENer_TRACES:BOOL=TRUE"
La documentation des fonctions d'OpENer fait partie du code source. Les packages sources contiennent la documentation générée dans le répertoire doc/api_doc. Si vous utilisez la version GIT, vous aurez besoin du programme Doxygen pour générer la documentation HTML. Vous pouvez générer la documentation en appelant doxygen à partir de la ligne de commande dans le répertoire principal de l'ouvreur.
Le fuzzing est une méthode de test automatisée qui dirige différentes données d'entrée vers un programme afin de surveiller la sortie. C'est un moyen de tester la fiabilité globale ainsi que d'identifier les bogues de sécurité potentiels.
Le fuzzer que nous utilisons est AFL, un fuzzer qui utilise des techniques guidées à l'exécution pour créer une entrée pour le programme testé. D'un point de vue de haut niveau, l'AFL fonctionne comme suit :
Pour commencer à fuzzer ce projet avec AFL, vous devrez le compiler avec AFL. Assurez-vous d’abord que AFL est installé :
sudo apt install build-essential
wget http://lcamtuf.coredump.cx/afl/releases/afl-latest.tgz
tar xzf afl-latest.tgz
cd afl*
make && sudo make install
echo "AFL is ready at: $(which afl-fuzz)"
Ensuite, compilez OpENer avec AFL :
OpENer/bin/posix./setup_posix_fuzz_afl.shmakeEnfin, générez quelques cas de test et démarrez AFL :
# Generate inputs
mkdir inputs
echo 630000000000000000000000000000000000000000000000 | xxd -r -p > ./inputs/enip_req_list_identity
# You can also use the inputs we prepared from OpENer/fuzz/inputs
# Finally, let's fuzz!
afl-fuzz -i inputs -o findings ./src/ports/POSIX/OpENer
Habituellement, pour reproduire un crash, il suffit de retransmettre le testcase en utilisant cat testcase | nc IP_ADDR 44818 Cependant, étant donné que CIP s'exécute sur la couche EtherNet/IP, il doit d'abord enregistrer une session valide. Par conséquent, nous devons utiliser un script dédié : python fuzz/scripts/send_testcase.py IP testcase_path
Vérifiez le réseau que vous avez créé avec : docker network inspect mac_vlan_network
Le réseau attribuera des adresses IP aux conteneurs Docker et un scanner externe pourra communiquer avec eux. Pour accéder aux conteneurs depuis l'intérieur de l'hôte Docker, vous devrez créer un pont.
Créez un fichier Docker. Cela utilise Ubuntu comme image de base. Il copiera OpENer à la racine de l'image et installera les packages requis. Enfin, exécutez OpENer sur eth0 de l'image : #Filename: Dockerfile FROM ubuntu:20.04 ADD ./bin/posix/src/ports/POSIX/OpENer / RUN apt-get update && apt-get install -y --no-install- recommande libcap-dev nmap ENTRYPOINT ["./OpENer", "eth0"]
Créez un docker-compose.yml qui vous permettra de connecter le réseau macvlan aux conteneurs et de les construire et de les démonter facilement : version : "3.3" services : dockerimagename : network_mode : mac_vlan_network image : dockeruser/dockerimagename
Notez que pour vous connecter à un conteneur en cours d'exécution, vous devez exposer un port dans les fichiers dockerfile et dockercompose et configurer un pont réseau.
Commandes Docker pour démarrer et arrêter plusieurs instances des conteneurs OpENer : Démarrez 128 instances d'image Docker : docker-compose up --scale dockerimagename=128 -d Arrêtez toutes les instances : docker-compose down
Pour porter OpENer sur de nouvelles plates-formes, veuillez consulter la section sur le portage dans la documentation de Doxygen.
Le moyen le plus simple est de créer un fork du référentiel, puis de créer une branche fonctionnalité/correction de bugs. Après avoir terminé votre fonctionnalité/correction de bug, créez une pull request et expliquez vos modifications. Veuillez également mettre à jour et/ou ajouter des commentaires doxygen aux sections de code fournies. Veuillez vous en tenir aux conventions de codage, telles que définies dans source/doc/coding_rules. Le moyen le plus simple de se conformer à la conversion d'indentation est de définir uncrustify comme filtre git dans le référentiel OpENer, ce qui peut être fait avec les commandes suivantes :
git config filter.uncrustify.clean "/path/to/uncrustify/uncrustify -c uncrustify.cfg --mtime --no-backup"
git config filter.uncrustify.smudge "cat"
