ferm | ferm is a frontend for iptables

I just succeeded, here is the result for those who need:

The main problem is that the client does not know when the complete message from the server has been received. The receiving code expects the server to close the connection before it can process the incoming data. However, the server can not close the connection because it is waiting for the client to send a response over the same connection.

The client is blocked at data = connexion_avec_serveur.recv(buf) until the server closes the connection, or some other network event occurs that severs that connection. Meanwhile the server is also blocked at dat = self.client.recv(buf) awaiting a response from the client - there is a deadlock.

The solution is to arrange for the client to know when it has received the complete message from the server, which means adding some protocol. One way is for the sever to append a sentinel value to signal the end of the message, and for the client to watch for that sentinel. Another way is for the server to prepend to the message the length of the payload, in this case the length of the pickled data, which I show here.

For the client change the run() function:

The tasks below

Your strace output makes the problem clear: connect returns an error code (between -4095 to -1), so the high bytes of EAX are 0xffffff... Later mov al, imm8¹ leaves them unmodified, resulting in EAX= invalid system call number².

If you want to make it exit cleanly even if an earlier system call returned negative, xor eax,eax / inc eax / int 0x80 at the end to do a SYS_exit. (With BL=1 or some non-zero value to exit with a non-zero status).

Or use push 0xb / pop eax to set EAX=SYS_execve for that final system call, so the shell definitely runs. (But with stdin not redirected, so that's not very good).

Or just get used to using strace as error checking, now that you understand what happens when a system call return value leaves the high bytes of EAX non-zero. You could put a ud2 at the end so it will exit with an illegal instruction instead of segfault (when execution falls into 00 00 add [eax], al bytes.)

Or if you really want, write actual error checking for the connect system call, checking for a negative EAX and using write to output an error message before exiting. That would obviously be useless in real shellcode which would run with its stdout connected to something on the victim computer, not yours. connect is the one most likely to fail, so you can still leave the other syscalls unchecked other than by strace.

Footnote 1: Remember you're using mov al, 0xb instead of mov eax, 0xb to avoid zeros in your machine code, although push 0x0100007F doesn't do that. >.< Not a problem when building as an executable, but would be a problem for injection via a strcpy or other C-string buffer overflow vulnerability.

Footnote 2: Apparently strace or the kernel is sign-extending that to 64 bits, despite the fact that the full RAX isn't accessible in 32-bit mode.

Try this

Don't use ...

whenever i want to work with serial ports, i always first check that i could define my ports correctly before writing data to it. In your code, you get ports 2 times, I suggest to use the example of JSerialComm defining the ports. Then use the one it is finding.

try this first to see if you can find your ports first.

Firslty thank you to @toolic for his help and guidance :) Whilst trying to create a reproducible example it started working and I think the problem is how I made my populations file.

Previously I used: paste sample_names pops | column -s $'\t' -t > pop_file.txt to output the file printed in the question. However it works if i simply use: paste sample_names pops > pop_file.txt

Also I have put the full path to the .vcf file instead of path from the current directory.

I hope this helps anyone who comes across this issue in the future :)