obtendo a saída do netcat, decodificando-a e retornando uma saída

Question

Eu tenho que obter uma saída do netcat, decodificá-lo e devolvê-lo.

depois de digitar:

nc cs2107.spro.ink 9000

a saída que recebo é esta:

Welcome to the Proof of work challenge!  
Rules: i will provide hex encoded byte strings to you.  
Your task is to decode it and calculate the md5 hash in hex encoded format and return it back to me. You will need to do this 500 times!

Ready? Go!

cdde140fffda1da2bc3f

MD5:

Então eu tenho que pegar essa string codificada hexadecimal, decodificá-la e enviá-la novamente e isso é suposto acontecer 500 vezes.

Eu acho que sei o que tenho que fazer, mas não tenho ideia de como codificá-lo no unix. Eu acho que um arquivo .sh é necessário? Mas eu não tenho muita certeza.

1. inicie com nc cs2107.spro.ink 9000

2. pesquise a sequência hexa da saída nc

3. decodifique-o e calcule o hash md5

4. finalmente, envie de volta

editar:

Eu sei que sou capaz de salvar a saída de nc fazendo isso

nc cs2107.spro.ink 9000 > somefile.txt  

como faço para pesquisar especificamente a cadeia hexadecimal?
Como decodifico a cadeia hexadecimal?
e finalmente como devolver o resultado de volta ao terminal?

edit2: então eu tenho permissão para usar o python para fazer essa tarefa. Algumas dicas eram para usar o módulo de subprocesso ou o módulo de soquetes. tentei fazer isso com o subprocesso enquanto li que

subprocess.Popen

mantém o comando em execução em segundo plano

Atualmente estou preso com isso

import subprocess
p = subprocess.Popen('nc cs2107.spro.ink 9000', shell = True, stdin = subprocess.PIPE, stdout = subprocess.PIPE)
a = subprocess.Popen('grep ^[0-9a-f] | xxd -r | md5sum | awk "{print $1}" ', stdin = p.stdout, stdout = subprocess.PIPE)

agora estou preso tentando canalizar de volta para p

    

Answer 1

Aqui está uma solução parcial, fiquei frustrado ao fazer a entrada do script netcat acontecer.

1. Como pesquiso especificamente a sequência hexadecimal?

Aqui está uma maneira simples:

$ nc -d cs2107.spro.ink 9000 > file

Welcome to the Proof of Work Challenge.
Rules: I will provide hex encoded byte strings to you.
Your task is to decode it and calculate the md5 hash.
Return the md5 hash in hex encoded format back to me.
You will need to do this 500 times.
Ready? Go!
eeb105fb2f5e24216bd2
MD5:

Aqui eu originalmente tinha um comando sed que selecionou a linha específica # 7, mas depois de resolver a primeira cadeia de bytes codificados hexadecimais, a próxima saída é fornecida imediatamente. Então, mudei isso para uma expressão regular que corresponde a caracteres hexadecimais:

$ cat file.txt | grep '^[a-f0-9]'

eeb105fb2f5e24216bd2

2. Como decodifico a string hexadecimal?

$ cat file.txt | grep '^[a-f0-9]' | xxd -r -p | md5

92b34e4055a92b9ec32b15f89cc22389

Então, verifiquei que isso funciona manualmente:

Welcome to the Proof of Work Challenge.
Rules: I will provide hex encoded byte strings to you.
Your task is to decode it and calculate the md5 hash.
Return the md5 hash in hex encoded format back to me.
You will need to do this 500 times.
Ready? Go!
eeb105fb2f5e24216bd2
MD5: 92b34e4055a92b9ec32b15f89cc22389
Correct.
9ecbc2b8d14ae903dce5

3. E finalmente como devolver o resultado ao terminal?

Esta última pergunta é realmente o maior problema. Eu não fui capaz de fazê-lo funcionar. Eu escrevi vários scripts e nenhum deles resolveu o problema. O problema como Gilles mencionado, é que você precisa manter a conexão aberta o tempo suficiente para ler os dados, e alimentar de volta para o programa ainda aberto. Isso interfere na abordagem normal de usar os comandos canalizados no shell, como os que eu postei acima.

Este é o pseudocódigo que não consigo implementar corretamente em um script de shell:

1. para loop, iterar 500 vezes. OBRAS.
2. mantenha a conexão aberta para: cs2107.spro.ink 9000. EM PROGRESSO.
3. bits de leitura enviados pelo servidor. OBRAS.
4. decodifica string hexadecimal. OBRAS.
5. calcula o hash md5. OBRAS.
6. envia entrada para abrir a conexão. EM PROGRESSO.
7. repita os passos 3-6.
8. final.

Aqui estão alguns recursos que eu tentei

1. Uso de canais nomeados de entrada / saída para um TCP conexão
2. link
3. link
4. link
5. link
6. link

Eu ficaria curioso em saber a solução se você descobrir. Talvez eu tente novamente mais tarde.

    

Answer 2

Você está certo de que espera-se que faça programação de soquete para se comunicar com o servidor. Eu tentei o Python antes, mas acabei usando scripts Bash simples.

Para começar, você pode dar uma olhada em como inicializar um soquete com o Bash seguindo o tutorial aqui: link

Etapa 1: inicializar o soquete

Você pode usar o Bash exec e o redirecionamento unix <> para criar um soquete no pseudo-caminho. A sintaxe do caminho é /dev/<protocol>/<host>/<port>

exec 3<>/dev/tcp/cs2107.spro.ink/9000;

Etapa 2: lendo a saída do servidor

Precisamos ler os bytes codificados da saída do servidor. Isso pode ser feito com o comando cat , mas não funcionará como esperado. Isso ocorre porque o servidor está aguardando a entrada do cliente e não há nenhum caractere EOF. (Eu estou supondo que está relacionado a dados de streaming) Para evitar isso, você precisa evitar ler além da saída do servidor, ou seja, parar na linha 7.

head -7 <&3

Etapa 3: Grepping & transformação de dados

egrep -o '^[0-9a-f]{20}' | xxd -r -p | md5sum

Depois de lermos o pedaço de informação, podemos usar o egrep para recuperar os bytes hexadecimais. Como o tamanho do hexdump é fixo, podemos fazer uso da expressão regular para extrair os dados necessários.

O piping do hexdump para xxd -r -p converterá o hexdump em binário e os gerará como texto simples. md5sum fará o trabalho sujo e calculará a resposta para nós.

Etapa 4: gravação no servidor

awk '{print $1}' >&3;

No meu caso, o md5sum produz a resposta e o caractere extra no final da string, então eu faço uso de awk para imprimir a primeira coluna e escrever no servidor.

Passo 5: Repita mais 499 vezes

Semelhante às etapas de 2 a 4, exceto pelo fato de que precisamos modificar a etapa 2 porque o servidor só exibirá "correto" na resposta subsequente, em vez de um texto introdutório longo. Modifique o head para ler em 2 linhas. Nós também precisamos fazer isso por mais 499 vezes:

for i in {1..499}
do
    head -2 <&3 | egrep -o '^[0-9a-f]{20}' | xxd -r -p | md5sum | awk '{print $1}' >&3;
done

Etapa 5: capturar a bandeira

Quando todas as 500 respostas forem concluídas, o sinalizador poderá ser recuperado por meio do soquete.

cat <&3

P / S Eu estava fazendo o mesmo módulo e fazendo a mesma tarefa que o OP, então acho que vou compartilhar minha resposta aqui. Apenas aconteceu para descobrir este post após o módulo terminar.

    

Answer 3

Isso é difícil porque você precisa manter uma conexão aberta e obter dados de nc , processar esses dados e alimentá-los de volta na mesma instância de nc . Isso pode ser feito, mas é difícil.

Seria muito mais fácil se você pudesse interagir com a rede e controlar o fluxo de dados no mesmo idioma. Se você usar um dos shells bash, ksh ou ksh, poderá usar seus recursos de rede: esses shells podem ser clientes TCP. Por exemplo, aqui está um script que lê linhas do servidor e as ecoa uma a uma:

{
  while IFS= read -r line <&3; do
    echo "$line" >&3
  done
} 3<>/dev/tcp/cs2107.spro.ink/9000

Para decodificar a string hexadecimal, procure nc . Vou deixar você descobrir a lógica de processamento de dados.