OpENer
Shared lib and fix delayed list identity
OpENer é uma pilha EtherNet/IP™ para dispositivos adaptadores de E/S; suporta múltiplas E/S e conexões explícitas; inclui objetos e serviços para criar produtos compatíveis com EtherNet/IP™ definidos na ESPECIFICAÇÃO ETHERNET/IP e publicados pela ODVA (http://www.odva.org).
Usuários e desenvolvedores do OpENer podem ingressar nos respectivos Grupos do Google para trocar experiências, discutir o uso do OpENer e sugerir novos recursos e objetos CIP que sejam úteis para a comunidade.
Lista de discussão de desenvolvedores: https://groups.google.com/forum/#!forum/eip-stack-group-opener-developers
Lista de discussão de usuários: https://groups.google.com/forum/#!forum/eip-stack-group-opener-users
O OpENer foi desenvolvido para ser altamente portátil. A versão padrão é direcionada a PCs com sistema operacional POSIX e interface de rede com soquete BSD. Para testar esta versão recomendamos um PC Linux ou Windows com Cygwin (http://www.cygwin.com) instalado. Você precisará ter o seguinte instalado:
para construção normal. Eles devem ser instalados na maioria das instalações Linux e fazem parte dos pacotes de desenvolvimento do Cygwin.
Se você quiser executar os testes de unidade, também terá que baixar o CppUTest via https://github.com/cpputest/cpputest
Para configuração do projeto recomendamos o uso de uma GUI do CMake (por exemplo, o pacote cmake-gui no Linux, ou o Instalador para Windows disponível no CMake)
setup_posix.sh Invoque o comando make
Invocando o OpenEner:
./src/ports/POSIX/OpENer
por exemplo, ./src/ports/POSIX/OpENer eth1
O OpENer também agora possui uma inicialização POSIX com capacidade em tempo real por meio da opção OpENer_RT, que requer que o kernel usado tenha todos os patches RT preemptivos aplicados e ativados. Se você quiser usar OpENer_RT, antes da etapa 2, execute sudo setcap cap_ipc_lock,cap_sys_nice+ep ./src/ports/POSIX/OpENer para conceder OpENEr CAP_SYS_NICE e os recursos CAP_IPC_LOCK , que são necessários para o modo RT
O OpENer também pode ser construído e instalado como uma biblioteca definindo o sinalizador CMake -DOPENER_INSTALL_AS_LIB . Para construir uma biblioteca compartilhada, a opção global -DBUILD_SHARED_LIBS=ON também deve ser definida. Ele só foi testado na plataforma Linux/POSIX.
Build All no Visual StudioMude para binwin32srcportsWIN32
Dependendo se você escolheu a configuração Debug ou Release no Visual Studio, seu executável aparecerá na subpasta Debug ou Release
Invoque o OpenEner via
OpENer
por exemplo, OpENer 3
Para obter o índice de interface correto, digite o comando route print em um prompt de comando e procure o endereço MAC da interface de rede escolhida no início da saída. O número mais à esquerda é o índice da interface correspondente.
O arquivo de configuração POSIX pode ser reutilizado para Cygwin. Observe que você não pode usar o modo RT e terá que remover o código responsável por verificar e obter os recursos necessários, pois o libcap não está disponível no Cygwin. A maneira mais fácil e com suporte de construir o OpENer para Windows é usar MinGW ou Visual Studio.
setup_mingw.bat em uma linha de comando do DOS. (Não é um shell bash). Se o rastreamento for desejado, use o seguinte (onde o parâmetro cmake deve estar entre aspas) ou altere o arquivo ./source/CMakeList.txt. setup_mingw.bat "-DOpENer_TRACES:BOOL=TRUE"
A documentação das funções do OpENer faz parte do código fonte. Os pacotes fonte contêm a documentação gerada no diretório doc/api_doc. Se você usar a versão GIT você precisará do programa Doxygen para gerar a documentação HTML. Você pode gerar a documentação invocando doxygen na linha de comando no diretório principal do opener.
Fuzzing é um método de teste automatizado que direciona dados de entrada variados para um programa a fim de monitorar a saída. É uma forma de testar a confiabilidade geral, bem como identificar possíveis bugs de segurança.
O fuzzer que estamos usando é o AFL, um fuzzer que usa técnicas guiadas em tempo de execução para criar entrada para o programa testado. De uma perspectiva de alto nível, o AFL funciona da seguinte forma:
Para começar a difundir este projeto com AFL você precisará compilá-lo com AFL. Primeiro certifique-se de ter o AFL instalado:
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)"
Em seguida, compile o OpENer com AFL:
OpENer/bin/posix./setup_posix_fuzz_afl.shmakePor fim, gere alguns casos de teste e inicie o 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
Normalmente para reproduzir uma falha basta retransmitir o testcase usando cat testcase | nc IP_ADDR 44818 Entretanto, como o CIP é executado na camada EtherNet/IP, ele deve primeiro registrar uma sessão válida. Portanto, precisamos usar um script dedicado: python fuzz/scripts/send_testcase.py IP testcase_path
Verifique a rede que você criou com: docker network inspeciona mac_vlan_network
A rede atribuirá IPs aos contêineres docker e um scanner externo poderá se comunicar com eles. Para acessar os contêineres de dentro do host docker, você terá que criar uma ponte.
Crie um arquivo Docker. Isso usa o Ubuntu como imagem base. Ele copiará o OpENer para a raiz da imagem e instalará os pacotes necessários. Por último, execute o OpENer na eth0 da imagem: #Filename: Dockerfile FROM ubuntu:20.04 ADD ./bin/posix/src/ports/POSIX/OpENer / RUN apt-get update && apt-get install -y --no-install- recomenda libcap-dev nmap ENTRYPOINT ["./OpENer", "eth0"]
Crie um docker-compose.yml que permitirá conectar a rede macvlan aos contêineres e construí-los e desmontá-los facilmente: version: "3.3" services: dockerimagename: network_mode: mac_vlan_network image: dockeruser/dockerimagename
Observe que para fazer login em um contêiner em execução, você deve expor uma porta nos arquivos dockerfile e dockercompose e configurar uma ponte de rede.
Comandos Docker para iniciar e parar múltiplas instâncias dos contêineres OpENer: Inicie 128 instâncias de imagem do Docker: docker-compose up --scale dockerimagename=128 -d Encerre todas as instâncias: docker-compose down
Para portar o OpENer para novas plataformas, consulte a seção de portabilidade na documentação do Doxygen.
A maneira mais fácil é bifurcar o repositório e, em seguida, criar um branch de recurso/correção de bug. Depois de terminar seu recurso/correção de bug, crie uma solicitação pull e explique suas alterações. Além disso, atualize e/ou adicione comentários doxygen às seções de código fornecidas. Por favor, siga as convenções de codificação, conforme definido em source/doc/coding_rules. A maneira mais fácil de estar em conformidade com a conversão de recuo é definir uncrustify como filtro git no repositório OpENer, o que pode ser feito com os seguintes comandos:
git config filter.uncrustify.clean "/path/to/uncrustify/uncrustify -c uncrustify.cfg --mtime --no-backup"
git config filter.uncrustify.smudge "cat"
