One place for hosting & domains

      programas

      Como instalar e utilizar a ferramenta Radamsa para fazer teste de fuzzing em programas e serviços de rede no Ubuntu 18.04


      O autor selecionou a Electronic Frontier Foundation, Inc para receber uma doação como parte do programa Write for DOnations.

      Introdução

      As ameaças de segurança estão se tornando cada vez mais sofisticadas, de modo que os desenvolvedores e administradores de sistemas precisam adotar uma abordagem proativa na defesa e teste da segurança de seus aplicativos.

      Um método comum para testar a segurança dos aplicativos cliente ou serviços de rede é o fuzzing, que envolve a transmissão de dados inválidos ou malformados repetidamente para o aplicativo e analisando sua resposta. Isso é útil para ajudar a testar a resiliência e a robustez do aplicativo a entradas inesperadas, que podem incluir dados corrompidos ou ataques reais.

      A Radamsa é uma ferramenta de fuzzing de código aberto que pode gerar casos de teste baseados em dados de entrada específicos do usuário. A Radamsa é totalmente passível de script e, até agora, tem sido bem-sucedida em encontrar vulnerabilidades em aplicativos reais, como o Gzip.

      Neste tutorial, você instalará e usará a Radamsa para fazer o teste de fuzzing da linha de comando e dos aplicativos baseados em rede, usando seus próprios casos de teste.

      Aviso: a Radamsa é uma ferramenta de teste de penetração que pode permitir que você identifique as vulnerabilidades ou pontos fracos em certos sistemas ou aplicativos. Você não deve usar as vulnerabilidades encontradas com a Radamsa para qualquer forma de comportamento inconsequente, exploração prejudicial ou mal-intencionada. As vulnerabilidades devem ser relatadas para o mantenedor do aplicativo afetado, de maneira ética e não ser divulgadas publicamente, sem permissão expressa.

      Pré-requisitos

      Antes de iniciar este guia, será necessário o seguinte:

      • Um servidor Ubuntu 18.04 configurado de acordo com o tutorial de Configuração Inicial do servidor com o Ubuntu 18.04, incluindo um usuário não raiz com privilégios sudo e firewall habilitado para bloquear portas não essenciais.
      • Um aplicativo de linha de comando ou baseado em rede que deseja testar, como o Gzip, Tcpdumb, Bind, Apache, jq ou qualquer outro aplicativo de sua escolha. A título de exemplo para este tutorial,usaremos o jq.

      Aviso: a Radamsa pode provocar a instabilidade ou a falha dos aplicativos ou sistemas em execução. Assim, somente execute a Radamsa em um ambiente em que você esteja preparado para essa situação, como num servidor dedicado, por exemplo. Além disso, assegure-se de que possui a devida permissão escrita do proprietário de um sistema, antes de realizar o teste de fuzzing em tal sistema.

      Assim que tiver tudo pronto, logue no seu servidor como usuário não raiz para começar.

      Passo 1 — Instalando a Radamsa

      Primeiro, você irá baixar e compilar a Radamsa para começar a usá-la no seu sistema. O código fonte da Radamsa está disponível no repositório oficial no GitLab.

      Comece atualizando o índice de pacotes local para refletir quaisquer novas alterações dos autores do código:

      Em seguida, instale os pacotes gcc, git, make e wget. Eles são necessários para compilar o código fonte em um binário executável:

      • sudo apt install gcc git make wget

      Após confirmar a instalação, a ferramenta apt irá baixar e instalar os pacotes especificados e todas as dependências necessárias.

      Em seguida, você irá baixar uma cópia do código fonte da Radamsa, clonando-o a partir do repositório hospedado no GitLab:

      • git clone https://gitlab.com/akihe/radamsa.git

      Isso criará um diretório chamado radamsa, que contém o código fonte do aplicativo. Vá para o diretório para começar a compilar o código:

      Em seguida, inicie o processo de compilação usando o make:

      Por fim, instale o binário da Radamsa compilado para o seu $PATH:

      Assim que terminar, verifique a versão instalada para garantir que tudo está funcionando:

      Sua saída será semelhante à seguinte:

      Output

      Radamsa 0.6

      Caso veja um erro radamsa: command not found (comando não encontrado), verifique novamente se todas as dependências necessárias foram instaladas e se não houve erros durante a compilação.

      Agora que instalou a Radamsa, comece a gerar alguns exemplos de casos para teste, a fim de entender como a Radamsa funciona e para o que ela pode ser usada.

      Passo 2 — Gerando casos para o teste de fuzzing

      Agora que a Radamsa foi instalada, utilize-a para gerar alguns casos para o teste de fuzzing.

      Um caso de teste é uma fração de dados que será usada como entrada para o programa que você estiver testando. Por exemplo, se estiver fazendo o teste de fuzzing em um programa de arquivamento como o Gzip. Como caso para teste, você pode usar um arquivo morto que estiver tentando descompactar.

      Nota: a Radamsa manipulará os dados de entrada de diversas formas inesperadas, inclusive através de repetição extrema, bit flips [manipulação de bits], controle de injeção de caractere e assim por diante. Isso pode provocar a interrupção ou a instabilidade de sua sessão no terminal; portanto, esteja ciente disso, antes de continuar.

      Primeiro, envie uma mensagem de texto simples para a Radamsa para ver o que acontece:

      • echo "Hello, world!" | radamsa

      Isso manipulará (ou confundirá) os dados inseridos e dará como resultado um caso de teste, por exemplo:

      Output

      Hello,, world!

      Neste caso, a Radamsa adicionou uma vírgula extra entre o Hello e o world. Pode não parecer uma alteração significativa, mas, em alguns aplicativos, pode levar à interpretação incorreta dos dados.

      Vamos tentar novamente, executando o mesmo comando. Você verá um outro resultado:

      Output

      Hello, '''''''wor'd!

      Dessa vez, várias aspas (') foram inseridas na string, incluindo uma que sobrescreveu-e à letra l da palavra world. Esse caso de teste em particular traz maior probabilidade de gerar problemas para um aplicativo, uma vez que as aspas simples/duplas são usadas com frequência para separar diferentes frações de dados em uma lista.

      Vamos testar mais uma vez:

      Output

      Hello, $+$PATHu0000`xcalc`world!

      Nesse caso, a Radamsa inseriu uma string de injeção do shell, o que será útil para testar as vulnerabilidades da injeção de comandos no aplicativo que você está testando.

      Você usou a Radamsa para fazer fuzz com uma string de entrada e produzir uma série de casos de teste. Em seguida, você usará a Radamsa para fazer o fuzz em um aplicativo de linha de comando.

      Passo 3 — Fazendo o fuzzing em um aplicativo de linha de comando

      Neste passo, você utilizará o Radamsa para fazer o fuzz em um aplicativo de linha de comando e informará sobre quaisquer falhas que ocorrerem.

      A técnica exata para o fuzzing em cada programa varia significativamente e métodos distintos serão mais eficazes para programas distintos. No entanto, neste tutorial utilizaremos o exemplo do jq, que é um programa de linha de comando para o processamento de dados JSON.

      Você pode usar qualquer outro programa similar, desde que ele siga o princípio geral de tomar alguma forma de dados estruturados ou não estruturados, fazendo algo com eles e em seguida, exibindo um resultado. Por exemplo, esse exemplo também funcionaria com o Gzip, Grep, bc, tr e assim por diante.

      Se ainda não tiver o jq instalado, instale-o usando a apt:

      O jq será instalado agora.

      Para começar o fuzzing, crie um arquivo de exemplo que você usará como a entrada para a Radamsa:

      Então, adicione os seguintes dados de exemplo em JSON ao arquivo:

      test.json

      {
        "test": "test",
        "array": [
          "item1: foo",
          "item2: bar"
        ]
      }
      

      Você pode analisar esse arquivo usando o jq caso queria verificar se a sintaxe JSON é válida:

      Se o JSON for válido, o jq exibirá o arquivo. Caso contrário, ele exibirá um erro, que você pode usar para corrigir a sintaxe, onde for necessário.

      Em seguida, faça o fuzz no arquivo de teste em JSON usando a Radamsa e, em seguida, envie-o para o jq. Isso fará com que o jq leia o caso de teste de fuzzing/para manipulação, em vez de dados originais JSON válidos:

      Se a Radamsa fizer o fuzzing dos dados JSON, de modo que ainda fiquem válidos – do ponto de vista sintático, o jq exibirá os dados, mas com as alterações que a Radamsa tiver feito neles.

      Como alternativa, se a Radamsa fizer com que os dados JSON se tornem inválidos, o jq exibirá um erro relevante. Por exemplo:

      Output

      parse error: Expected separator between values at line 5, column 16

      O resultado alternativo seria que o jq não conseguiria lidar corretamente com os dados que passaram por fuzzing, fazendo com que ele falhe ou que se comporte indevidamente. É precisamente isso o que você estará buscando alcançar com o fuzzing, uma vez que isso pode ser indicação de uma vulnerabilidade de segurança, tais como um estouro de buffer ou uma injeção de comando.

      Para testar as vulnerabilidades de maneira mais eficaz dessa maneira, um script Bash pode ser usado para automatizar o processo de fuzzing, incluindo a geração de casos de teste, passando-os para o programa alvo e capturando qualquer resultado relevante.

      Crie um arquivo chamado jq-fuzz.sh:

      O conteúdo exato do script irá variar, dependendo do tipo de programa em que você estiver fazendo o fuzzing e os dados de entrada. No caso do jq e de outros programas semelhantes, porém, o script a seguir será o suficiente.

      Copie o script em seu arquivo jq-fuzz.sh:

      jq-fuzz.sh

      #!/bin/bash
      while true; do
        radamsa test.json > input.txt
        jq . input.txt > /dev/null 2>&1
        if [ $? -gt 127 ]; then
          cp input.txt crash-`date +s%.%N`.txt
          echo "Crash found!"
        fi
      done
      

      Esse script contém um while para fazer o conteúdo entrar em um loop, repetidas vezes. A cada vez que o script entrar em loop, a Radamsa gerará um caso de teste, com base no test.json e o salvará no arquivo input.txt.

      Na sequência, o caso de teste, input.txt, será executado com o programa jq e todo o resultado – padrão e de erros – será redirecionado para o diretório /dev/null, a fim de evitar que a tela do terminal fique cheia.

      Por fim, o valor de saída do jq é verificado. Se o valor de saída for maior que 127, isso indica que houve um encerramento fatal (uma falha); em seguida, os dados de entrada são salvos – para revisão posterior – em um arquivo chamado crash-, seguido de carimbo de data do Unix, com a data atual em segundos e nanossegundos.

      Marque o script como executável e o coloque em funcionamento, de modo a iniciar o teste de fuzzing do jq, automaticamente:

      • chmod +x jq-fuzz.sh
      • ./jq-fuzz.sh

      Você pode teclar o CTRL+C a qualquer momento para terminar o script. Então, você pode verificar se foram encontradas falhas com o ls, a fim de exibir uma listagem de diretório, contendo quaisquer arquivos de falha que tiverem sido criados.

      Você pode querer melhorar seus dados de entrada JSON, uma vez que o uso de um arquivo de entrada mais complexo provavelmente melhoraria a qualidade de seus resultados de fuzzing. Evite utilizar um arquivo grande ou que contenha muitos dados repetidos—um arquivo pequeno seria a entrada ideal, mas que contenha o máximo de elementos ‘complexos’ possível. Por exemplo, um bom arquivo de entrada conterá amostras de dados armazenados em todos formatos, que incluem strings, números inteiros, booleanos, listas e objetos, bem como dados aninhados, sempre que possível.

      Você usou a Radamsa para fazer o fuzzing em um aplicativo de linha de comando. Em seguida, você usará a Radamsa para fazer o fuzz em serviços de rede.

      Passo 4 — Pedidos de fuzzing em serviços de rede

      A Radamsa também pode ser usada para fazer o fuzzing em serviços de rede, seja atuando como um cliente ou servidor de rede. Neste passo, você usará a Radamsa para fazer o fuzzing em um serviço de rede, com a Radamsa atuando como cliente.

      O objetivo do fuzzing em serviços de rede é testar o quão resiliente um determinado serviço de rede é para os clientes, enviando-lhe dados malformados ou mal-intencionados. Muitos serviços de rede – como servidores Web ou DNS – são geralmente expostos à Internet, o que significa que eles são um alvo comum para invasores. Um serviço de rede que não seja resistente o suficiente para receber dados malformados pode falhar ou, pior ainda, falhar em um estado aberto, o que permite que invasores leiam dados confidenciais, como chaves de criptografia ou dados do usuário.

      A técnica específica para o fuzzing em serviços de rede varia bastante, dependendo do serviço de rede em questão. No entanto, neste exemplo usaremos a Radamsa para fazer o fuzz em um servidor Web básico, servindo conteúdo de HTML estático.

      Primeiro, você precisa configurar o servidor Web para testes. Você pode fazer isso usando o servidor de desenvolvimento integrado que vem com o pacote php-cli. Você também precisará do curl para testar seu servidor Web.

      Se não tiver o php-cli e/ou o curl instalados, instale-os usando a ferramenta apt:

      • sudo apt install php-cli curl

      Em seguida, crie um diretório para armazenar seus arquivos do servidor Web e vá até ele:

      Então, crie um arquivo HTML que contenha uma amostra de texto:

      Adicione o que vem a seguir ao arquivo:

      index.html

      <h1>Hello, world!</h1>
      

      Agora, você pode executar seu servidor Web do PHP. Você precisará ser capaz de visualizar o registro do servidor Web, ao mesmo tempo que ainda continuará a usar outra sessão de terminal. Dessa maneira, abra outra sessão de terminal e de SSH para o seu servidor para este fim:

      • cd ~/www
      • php -S localhost:8080

      Isso irá gerar algo parecido com o seguinte:

      Output

      PHP 7.2.24-0ubuntu0.18.04.1 Development Server started at Wed Jan 1 16:06:41 2020 Listening on http://localhost:8080 Document root is /home/user/www Press Ctrl-C to quit.

      Agora, você pode retornar para a sessão de terminal original e testar se o servidor Web está funcionando, usando o curl:

      Isso exibirá o arquivo de exemplo index.html que você criou anteriormente:

      Output

      <h1>Hello, world!</h1>

      Seu servidor Web precisa estar acessível apenas localmente. Assim, você não deve abrir quaisquer portas no seu firewall para ele.

      Agora que você configurou seu servidor Web de teste, você pode iniciar o teste de fuzzing nele, usando a Radamsa.

      Primeiro, será necessário criar um exemplo de pedido de HTTP para usar como dados de entrada para a Radamsa. Crie um novo arquivo para armazenar isso em:

      Então, copie a seguinte amostra de pedido HTTP para o arquivo:

      http-request.txt

      GET / HTTP/1.1
      Host: localhost:8080
      User-Agent: test
      Accept: */*
      

      Em seguida, utilize a Radamsa para enviar esse pedido HTTP para o seu servidor Web local. Para fazer isso, você terá que usar a Radamsa como cliente TCP, o que pode ser feito especificando-se um endereço IP e porta à qual se conectar:

      • radamsa -o 127.0.0.1:8080 http-request.txt

      Nota: esteja ciente que usar a Radamsa como um cliente TCP possivelmente fará com que dados malformados/mal-intencionados sejam transmitidos pela rede. Isso pode interromper as coisas. Assim, tenha o cuidado de acessar somente as redes que você está autorizado a testar ou, de preferência, continue usando o endereço do localhost (127.0.0.1).

      Por fim, caso visualize os registros produzidos em relação ao seu servidor Web local, verá que ele recebeu os pedidos, mas provavelmente não os processou, já que eles eram inválidos/malformados.

      Os registros produzidos estarão visíveis em sua segunda janela de terminal:

      Output

      [Wed Jan 1 16:26:49 2020] 127.0.0.1:49334 Invalid request (Unexpected EOF) [Wed Jan 1 16:28:04 2020] 127.0.0.1:49336 Invalid request (Malformed HTTP request) [Wed Jan 1 16:28:05 2020] 127.0.0.1:49338 Invalid request (Malformed HTTP request) [Wed Jan 1 16:28:07 2020] 127.0.0.1:49340 Invalid request (Unexpected EOF) [Wed Jan 1 16:28:08 2020] 127.0.0.1:49342 Invalid request (Malformed HTTP request)

      Para obter resultados ideais e garantir que as falhas fiquem registradas, talvez você queira escrever um script de automação semelhante ao usado no Passo 3. Você deve considerar, ainda, o uso de um arquivo de entrada mais complexo, que possa conter adições, como a função de cabeçalhos HTTP extras.

      Você fez o fuzzing em um serviço de rede usando a Radamsa, que agiu como um cliente TCP. Em seguida você fará o fuzzing em um cliente de rede com a Radamsa atuando como um servidor.

      Passo 5 — Fazendo o fuzzing em aplicativos clientes de rede

      Neste passo, você usará a Radamsa para fazer o teste de fuzzing em um aplicativo cliente de rede. Isso pode ser feito através da interceptação das respostas de um serviço de rede e do fuzzing delas, antes de serem recebidas pelo cliente.

      O objetivo deste tipo de fuzzing é testar o quão resilientes os aplicativos cliente de rede são para receberem dados malformados ou mal-intencionados, vindos de serviços de rede. Por exemplo, testar um navegador Web (cliente) recebendo um HTML malformado de um servidor Web (serviço de rede), ou testar um cliente DNS recebendo respostas de DNS malformadas de um servidor DNS.

      Tal como aconteceu com o fuzzing de aplicativos de linha de comando ou de serviços de rede, a técnica exata para o fuzzing em cada aplicativo cliente de rede varia consideravelmente. No entanto, neste exemplo, você usará o whois, que é um aplicativo de envio/recebimento, baseado no protocolo TCP.

      O aplicativo whois é utilizado para fazer pedidos aos servidores WHOIS e receber registros WHOIS como resposta. O WHOIS opera pela porta TCP 43 em texto não criptografado, o que o torna um bom candidato para testes de fuzzing baseados em rede.

      Se ainda não tiver o whois instalado, instale-o usando a ferramenta apt:

      Primeiro, você precisará adquirir uma amostra de resposta do whois para usar como dados de entrada. Para tanto, você pode fazer um pedido whois e salvar o resultado em um arquivo. Aqui, você pode usar qualquer domínio que quiser, uma vez que estará testando o programa whois localmente, usando dados de amostra:

      • whois example.com > whois.txt

      Em seguida, você precisará configurar a Radamsa como um servidor que atenda versões dessa resposta do whois que já passaram pelo fuzzing. Uma vez que a Radamsa está executando em modo de servidor, você terá que conseguir continuar usando o seu terminal. Assim, é recomendável abrir outra sessão de terminal e outra conexão via protocolo SSH com o seu servidor para esse fim:

      • radamsa -o :4343 whois.txt -n inf

      Agora, a Radamsa estará executando em modo de servidor TCP e atenderá uma versão de whois.txt – que já passou por fuzzing – toda vez que uma conexão for feita no servidor, independentemente de quais dados da solicitação forem recebidos.

      Agora, você já pode prosseguir com o teste do aplicativo cliente whois. Você vai precisar fazer uma solicitação whois normal para um domínio de sua escolha (não precisa ser o mesmo para os quais os dados da amostra se destinam), mas com o whois apontado para o seu servidor local da Radamsa:

      • whois -h localhost:4343 example.com

      A resposta consistirá nos dados da sua amostra, mas que já passaram pelo processo de fuzzing da Radamsa. Desde que a Radamsa esteja em execução, você pode continuar a fazer pedidos para o servidor local, pois toda vez ele irá fornecer uma resposta diferente que já passou pelo fuzzing.

      Assim como ocorre no fuzzing em serviços de rede, para melhorar a eficiência esse teste de fuzzing do cliente de rede e assegurar que eventuais falhas sejam capturadas, talvez você queira escrever um script de automação semelhante ao usado no Passo 3.

      Neste passo final, você usou a Radamsa para realizar o teste de fuzzing de um aplicativo cliente de rede.

      Conclusão

      Neste artigo, você configurou a Radamsa e a usou para fazer o fuzzing em um aplicativo de linha de comando, um serviço de rede e um cliente de rede. Portanto, você já tem o conhecimento básico necessário para fazer o teste de fuzzing em seus próprios aplicativos, com a expectativa de aprimorar a robustez e a resistência deles a ataques.

      Se quiser explorar a Radamsa ainda mais, faça uma revisão detalhada do arquivo README da Radamsa, pois ele traz outras informações técnicas e exemplos de como a ferramenta pode ser usada:

      Confira também algumas outras ferramentas de fuzzing, como a American Fuzzy Lop (AFL), que é uma ferramenta de fuzzing avançada, desenvolvida para testar aplicativos binários em velocidade e com precisão extremamente elevadas.



      Source link

      Como compilar e instalar programas em Go


      Introdução

      Até agora, em nossa série de artigos sobre Como codificar em Go, você usou o comando go run para compilar automaticamente seu código fonte e executar o arquivo executável resultante. Embora esse comando seja útil para testar seu código na linha de comando, distribuir ou implantar, o seu aplicativo exige que você compile o seu código em um executável binário compartilhável ou em um único arquivo contendo um código de byte de máquina que possa executar seu aplicativo. Para tanto, utilize a cadeia de ferramentas do Go para compilar e instalar o seu programa.

      No Go, o processo de tradução do código fonte em um executável binário é chamado de compilação. Assim que esse executável estiver compilado, ele terá que conter não apenas o seu aplicativo, mas também todo o código de suporte necessário para executar o binário na plataforma de destino. Isso significa que um binário do Go não precisa das dependências de sistema como as ferramentas do Go para executar em um novo sistema, ao contrário de outras linguagens como Ruby, Python, ou Node.js. Colocar esses executáveis em um caminho de arquivo executável em seu próprio sistema permitirá que você execute o programa de qualquer lugar em seu sistema. Esse procedimento é chamado de instalação do programa no sistema.

      Neste tutorial, você usará a cadeia de ferramentas do Go para executar, compilar e instalar um programa exemplo Hello, World!, permitindo que você use, distribua e implante aplicativos futuros de maneira eficaz.

      Pré-requisitos

      Para seguir o exemplo neste artigo, você precisará de:

      Configurando e executando o binário do Go

      Primeiro, crie um aplicativo para usar como um exemplo para demonstrar a cadeia de ferramentas do Go. Para fazer isso, você usará o clássico programa “Hello, World!!” do tutorial Como escrever seu primeiro programa em Go.

      Crie um diretório chamado greeter em seu diretório src:

      Em seguida, mova-o para o diretório recém-criado e crie o arquivo main.go no editor de texto da sua escolha:

      Assim que o arquivo estiver aberto, adicione o seguinte conteúdo:

      src/greeter/main.go

      package main
      
      import "fmt"
      
      func main() {
          fmt.Println("Hello, World!")
      }
      

      Quando executar, esse programa imprimirá a frase Hello, World! no console e, depois, o programa fechará com sucesso.

      Salve e saia do arquivo.

      Para testar o programa, utilize o comando go run, como fez em tutoriais anteriores:

      Você receberá o seguinte resultado:

      Output

      Hello, World!

      Como mencionamos anteriormente, o comando go run compilou o seu arquivo fonte em um binário executável e, em seguida, executou o programa compilado. Entretanto, o objetivo deste tutorial é compilar o binário de maneira a possibilitar que você o compartilhe e distribua à vontade. Para fazer isso, utilize o comando go build no passo seguinte.

      Ao usar o go build, você pode gerar um binário executável para nosso aplicativo exemplo em Go, permitindo que distribua e implante o programa onde quiser.

      Experimente isso com main.go. No seu diretório greeter, execute o seguinte comando:

      Se você não fornecer um argumento para esse comando, o go build compilará automaticamente o programa main.go em seu diretório atual. O comando incluirá todos os seus arquivos *.go no diretório. Ele também compilará todo o código de suporte necessário para conseguir executar o binário em qualquer computador com a mesma arquitetura de sistema, independentemente do sistema ter os arquivos fonte .go, ou mesmo uma instalação do Go.

      Neste caso, você compilou seu aplicativo greeter em um arquivo executável que foi adicionado ao seu diretório atual. Verifique isso executando o comando ls:

      Se estiver usando o macOS ou o Linux, você encontrará um novo arquivo executável que foi nomeado depois do diretório no qual você compilou o seu programa:

      Output

      greeter main.go

      Nota: no Windows, o seu executável será o greeter.exe.

      Por padrão, o go build irá gerar um executável para a plataforma e arquitetura atuais. Por exemplo, se ele foi compilado em um sistema linux/386, o executável será compatível com qualquer outro sistema linux/386, mesmo se o Go não estiver instalado. O Go oferece suporte à compilação para outras plataformas e arquiteturas. Você pode ler mais a esse respeito em nosso artigo intitulado Compilando aplicativos em Go para diferentes sistemas operacionais e arquiteturas.

      Agora que você criou seu executável, execute-o para garantir que o binário foi compilado corretamente. No macOS ou Linux, execute o seguinte comando:

      No Windows, execute:

      O resultado do binário corresponderá ao resultado obtido quando você executou o programa com o go run:

      Output

      Hello, World!

      Com isto, você criou um binário executável único que contém não apenas seu programa, mas também todo o código do sistema necessário para executar aquele binário. Agora, você já pode distribuir esse programa para novos sistemas ou implantá-lo em um servidor, sabendo que o arquivo sempre executará o mesmo programa.

      Na próxima seção, este tutorial irá explicar como nomear um binário e como modificá-lo, para que tenha um controle melhor sobre o processo de compilação do seu programa.

      Alterando o nome do binário

      Agora que você sabe como gerar um executável, o próximo passo é identificar como o Go escolhe um nome para o binário e como personalizar esse nome para o seu projeto.

      Ao executar o go build, por padrão o Go decide automaticamente o nome do executável gerado. Ele faz isso em uma das duas maneiras: se estiver usando o Go Modules, então, o Go usará a última parte do nome do seu módulo; caso contrário, o Go usará o nome do diretório atual. Esse foi o método usado na última seção, quando você criou o diretório greeter, transformou-o e, em seguida, executou o go build.

      Vamos examinar o método do módulo mais atentamente. Se você tivesse um arquivo go.mod em seu projeto com uma declaração de module como a seguinte:

      go.mod

      module github.com/sammy/shark
      

      Então, o nome padrão para o executável gerado seria shark.

      Em programas mais complexos que exijam convenções de nome específicas, esses valores padrão nem sempre serão a melhor escolha para nomear o seu binário. Nesses casos, seria melhor personalizar seu resultado com o sinalizador -o.

      Para testar isso, altere o nome do executável que você fez na última seção para hello e o coloque em uma subpasta chamada bin. Você não precisa criar essa pasta; o Go fará isso sozinho durante o processo de compilação.

      Execute o seguinte comando go build com o sinalizador -o:

      O sinalizador -o fará o Go corresponder o resultado do comando com o argumento que você tiver escolhido. Neste caso, o resultado seria um novo executável chamado hello em uma subpasta chamada bin.

      Para testar o novo executável, faça a alteração no novo diretório e execute o binário:

      Você receberá o seguinte resultado:

      Output

      Hello, World!

      Agora, é possível personalizar o nome de seu executável para atender às necessidades do seu projeto, completando nossa pesquisa de como compilar binários em Go. Com o go build, porém, você ainda estará limitado a executar seu binário a partir do diretório atual. Para usar executáveis recém-compilados de qualquer lugar em seu sistema, instale-o usando o go install.

      Até agora, neste artigo, discutimos sobre como gerar binários executáveis a partir de nossos arquivos fontes .go. Esses executáveis são úteis para distribuir, implantar e testar, mas eles ainda não podem ser executados fora de seus diretórios fonte. Isto seria um problema caso você quisesse usar de maneira ativa seus programas, por exemplo, se tivesse desenvolvido uma ferramenta de linha de comando para ajudar seu fluxo de trabalho em seu próprio sistema. Para facilitar o uso dos programas, você pode instalá-los em seu sistema e acessá-los de qualquer lugar.

      Para entender o que isso significa, você usará o comando go install para instalar seu aplicativo exemplo.

      O comando go install se comporta quase da mesma forma que o go build. Porém, em vez de deixar o executável no diretório atual, ou em um diretório especificado pelo sinalizador -o, ele coloca o executável no diretório $GOPATH/bin.

      Para descobrir onde seu diretório $GOPATH está localizado, execute o seguinte comando:

      O resultado que receber irá variar, mas o padrão é o diretório go dentro do seu diretório $HOME:

      Output

      $HOME/go

      Uma vez que o go install irá colocar os executáveis gerados em um subdiretório $GOPATH chamado de bin, este diretório deve ser adicionado à variável de ambiente $PATH. Isso está explicado no passo Criando seu espaço de trabalho em Go do artigo com os pré-requisitos de Como instalar o Go e configurar um ambiente de programação local.

      Com o diretório $GOPATH/bin configurado, volte para seu diretório greeter:

      Agora, execute o comando de instalação:

      Isso irá compilar seu binário e colocar ele em $GOPATH/bin. Para testar isso, execute o seguinte:

      Isso listará o conteúdo do $GOPATH/bin:

      Output

      greeter

      Nota: o comando go install não oferece suporte ao sinalizador -o. Assim, ele irá usar um dos nomes padrão descritos anteriormente para nomear o executável.

      Com o binário instalado, teste para ver se o programa executará fora de seu diretório fonte. Volte para seu diretório home:

      Use o seguinte para executar o programa:

      Isso irá resultar no seguinte:

      Output

      Hello, World!

      Agora, você pode pegar os programas que escrever e instalá-los em seu sistema, permitindo que os utilize onde e quando precisar.

      Conclusão

      Neste tutorial, você demonstrou como a cadeia de ferramentas do Go torna fácil a compilação de binários executáveis do código fonte. Esses binários podem ser distribuídos para executar em outros sistemas, mesmo aqueles que não tenham as ferramentas e ambientes em Go. Você também usou o go install para compilar e instalar automaticamente nossos programas como executáveis no $PATH do sistema. Com o go build e o go install, agora você pode compartilhar e usar o seu aplicativo à vontade.

      Agora que você sabe o básico sobre o go build, você pode explorar mais a fundo sobre como tornar o código fonte modular, consultando o tutorial Personalizando binários em Go com build tags, ou sobre como compilar para diferentes plataformas, consultando o artigo Compilando aplicativos em Go para diferentes sistemas operacionais e arquiteturas. Se quiser aprender mais sobre a linguagem de programação Go em geral, confira nossa série de artigos sobre Como codificar em Go.



      Source link

      Cómo crear e instalar programas de Go


      Introducción

      Hasta ahora, en nuestra serie Cómo escribir código en Go utilizó el comando go run para compilar automáticamente su código fuente y hacer funcionar el ejecutable resultante. Aunque este comando es útil para probar su código en la línea de comandos, para distribuir o implementar su aplicación es necesario que compile su código en un ejecutable binario intercambiable o en un archivo único que contenga código de bytes de máquina que pueda ejecutar su aplicación. Para hacer esto, puede usar la cadena de herramientas de Go para compilar e instalar su programa.

      En Go, el proceso de traducir el código fuerte a un binario ejecutable se denomina compilación. Una vez compilado, este ejecutable contendrá no solo su aplicación, sino también todo el código de soporte necesario para ejecutar el binario en la plataforma de destino. Esto significa que un binario de Go no necesita dependencias del sistema como las herramientas de Go para ejecutarse en un nuevo sistema, a diferencia de otros lenguajes como Ruby, Python o Node.js. Poner estos ejecutables en una ruta de archivo ejecutable en su propio sistema le permitirá ejecutar el programa desde cualquier parte de su sistema. Esto es instalar el programa en su sistema.

      A través de este tutorial, usará las herramientas de Go para ejecutar, compilar e instalar un programa Hello, World! de ejemplo que le permitirá usar, distribuir, e implementar futuras aplicaciones de manera efectiva.

      Requisitos previos

      Para seguir el ejemplo de este artículo, necesitará lo siguiente:

      Configurar y ejecutar el binario de Go

      Primero, cree una aplicación que se usará como ejemplo para mostrar la cadena de herramientas de Go. Para hacer esto, usará el programa clásico “Hello, World!” del tutorial Cómo escribir su primer programa en Go.

      Cree un directorio llamado greeter en su directorio src:

      A continuación, posiciónese en el directorio recién creado y cree el archivo main.go en el editor de texto que prefiera:

      Una vez abierto el archivo, añada el siguiente contenido:

      src/greeter/main.go

      package main
      
      import "fmt"
      
      func main() {
          fmt.Println("Hello, World!")
      }
      

      Cuando se ejecute, este programa imprimirá la frase Hello World! en la consola y luego se cerrará correctamente.

      Guarde el archivo y ciérrelo.

      Para probar el programa, utilice el comando go run como en los tutoriales anteriores:

      Obtendrá el siguiente resultado:

      Output

      Hello, World!

      Como se mencionó antes, el comando go run compiló su archivo de origen en un binario ejecutable y luego ejecutó el programa compilado. Sin embargo, el propósito de este tutorial es compilar el binario de tal forma que pueda compartirlo y distribuirlo como desee. Para hacer esto, usará el comando go build en el siguiente paso.

      Compilar binarios de Go con go build

      Usando go build, puede generar un binario ejecutable para nuestra aplicación de Go de ejemplo, lo que le permitirá distribuir e implementar el programa donde lo desee.

      Pruebe esto con main.go. En su directorio greeter, ejecute el siguiente comando:

      Si no proporciona un argumento para este comando, go build compilará automáticamente el programa main.go en su directorio actual. El comando incluirá todos sus archivos *.go en el directorio. También creará todo el código de soporte necesario para poder ejecutar el binario en computadoras que tengan la misma arquitectura de sistema, independientemente de que este tenga los archivos de origen .go o incluso una instalación de Go.

      En este caso, compiló su aplicación greeter en un archivo ejecutable que se añadió a su directorio actual. Compruebe esto ejecutando el comando ls:

      Si usa macOS o Linux, encontrará un nuevo archivo ejecutable al que se asignó el nombre del directorio en el cual compiló su programa:

      Output

      greeter main.go

      Nota: En Windows, su ejecutable será greeter.exe.

      Por defecto, go build generará un ejecutable para la plataforma y arquitectura actuales. Por ejemplo, si se crea en un sistema linux/386, el ejecutable será compatible con cualquier otro sistema linux/386, incluso si Go no está instalado. Go admite la compilación para otras plataformas y arquitecturas. Puede obtener más información sobre esto en nuestro artículo Crear aplicaciones de Go para diferentes sistemas operativos y arquitecturas.

      Ahora que creó su ejecutable, inícielo para asegurarse de que el binario se haya creado correctamente. En macOS o Linux, ejecute el siguiente comando:

      En Windows, ejecute esto:

      El resultado del binario coincidirá con el resultado cuando ejecute el programa con go run:

      Output

      Hello, World!

      Con esto, habrá creado un único binario ejecutable que contendrá no solo su programa, sino también todo el código del sistema necesario para ejecutar ese binario. Ahora, podrá distribuir este programa a nuevos sistemas o implementarlo a un servidor, sabiendo que el archivo siempre ejecutará el mismo programa.

      En la siguiente sección de este tutorial, se explicará la manera de asignar un nombre a un binario y de cambiarlo, para que pueda controlar mejor el proceso de compilación de su programa.

      Cambiar el nombre del binario

      Ahora que conoce la manera de generar un ejecutable, el siguiente paso es identificar la forma en que Go selecciona un nombre para el binario y personalizar el nombre para su proyecto.

      Cuando ejecuta go build, el valor predeterminado supone que Go decida automáticamente el nombre del ejecutable generado. Hace esto de una de las siguientes formas: si está usando Go Modules, Go utilizará la última parte del nombre de su módulo; de lo contrario, empleará el nombre del directorio actual. Éste es el método usado en la última sección, cuando creó el directorio greeter, se posicionó en él y ejecutó go build.

      Veremos en más detalle el método de módulos. Si dispusiera de un archivo go.mod en su proyecto con una declaración module como la siguiente:

      go.mod

      module github.com/sammy/shark
      

      El nombre predeterminado para el ejecutable generado sería shark.

      En programas más complejos que requieren convenciones de nomenclatura específicas, estos valores predeterminados no siempre serán la mejor opción para asignar un nombre a su binario. En estos casos, sería mejor personalizar su resultado con el indicador -o.

      Para probar esto, cambie el nombre del ejecutable que creó en la última sección por hello y sitúelo en una subcarpeta llamada bin. No tiene que crear esta carpeta; Go hará esto por su cuenta durante el proceso de compilación.

      Ejecute el siguiente comando go build con el indicador -o:

      El indicador -0 hace que Go haga coincidir el resultado del comando con el argumento que elija. En este caso, el resultado es un nuevo ejecutable llamado hello en una subcarpeta llamada bin.

      Para probar el nuevo ejecutable, posiciónese en el nuevo directorio y ejecute el binario:

      Recibirá el siguiente resultado:

      Output

      Hello, World!

      Ahora, podrá personalizar el nombre de su ejecutable para que se adapte a las necesidades de su proyecto y completar nuestro estudio sobre cómo compilar binarios en Go. Con go build, sin embargo, aún experimentará limitaciones para ejecutar su binario desde el directorio actual. Para usar los ejecutables recién creados desde cualquier parte de su sistema, puede instalarlo usando go install.

      Instalar programas Go con go install

      Hasta ahora, en el artículo analizamos la forma de generar binarios ejecutables desde nuestros archivos de origen .go. Estos ejecutables son útiles para la distribución, la implementación y la prueba, pero aún no se pueden ejecutar desde fuera de sus directorios de origen. Esto sería un problema si quisiera usar su programa de forma activa, como si hubiera desarrollado una herramienta de línea de comandos para asistir a flujo de trabajo en su propio sistema. Para que los programas se puedan usar de forma más sencilla, puede instalarlos en su sistema y acceder a ellos desde cualquier parte.

      Para comprender lo que esto significa, usará el comando go install a fin de instalar su aplicación de ejemplo.

      El comando go install tiene un comportamiento casi idéntico al de go build, pero en vez de dejar el ejecutable en el directorio actual, o en un directorio especificado por el indicador -o, dispone el ejecutable en el directorio $GOPATH/bin.

      Para encontrar el punto en el que está su directorio $GOPATH, ejecute el siguiente comando:

      El resultado que reciba variará, pero el predeterminado es el directorio go situado dentro de su directorio $HOME:

      Output

      $HOME/go

      Ya que go install dispondrá los ejecutables generados en un subdirectorio de $GOPATH llamado bin, este directorio debe añadirse a la variable de entorno $PATH. Esto se abarca en el paso *Crear su espacio de trabajo de Go *del artículo Cómo instalar Go y configurar un entorno de programación local de los requisitos previos.

      Una vez configurado el directorio $GOPATH/bin, posiciónese en su directorio greeter:

      Ahora ejecute el comando install:

      Con esto, se compilará su binario y se dispondrá en $GOPATH/bin. Para probar esto, ejecute lo siguiente:

      Con esto se listará el contenido de $GOPATH/bin:

      Output

      greeter

      Nota: El comando go install no admite el indicador -0, por lo cual usará uno de los nombres predeterminados descritos anteriormente para nombrar el ejecutable.

      Una vez instalado el binario, compruebe si el programa se ejecuta desde fuera de su directorio de origen. Regrese a su directorio de inicio:

      Utilice lo siguiente para ejecutar el programa:

      Obtendrá el siguiente resultado:

      Output

      Hello, World!

      Ahora podrá instalar en su sistema los programas que escriba, lo que le permitirá usarlos desde cualquier sitio y en cualquier momento en que los necesite.

      Conclusión

      A través de este tutorial, pudo comprobar que las herramientas de Go facilitan la compilación de binarios ejecutables a partir de código fuente. Estos binarios pueden distribuirse para funcionar en otros sistemas, incluso en aquellos que no tienen herramientas ni entornos de Go. También utilizó go install para crear e instalar automáticamente nuestros programas como ejecutables en el $PATH del sistema. Con go build y go install, podrá compartir y usar su aplicación como lo desee.

      Ahora que conoce los aspectos básicos de go build, puede ver la forma de crear código fuente modular en el tutorial Personalizar binarios de Go con etiquetas de compilación, o de realizar compilaciones para diferentes plataformas a través de Compilar aplicaciones de Go para diferentes sistemas operativos y arquitecturas. Si desea obtener más información acerca del lenguaje de programación Go en general, consulte toda la serie Cómo realizar codificaciones en Go.



      Source link