Q:

Como conseguir um Mac-Address de um IP de rede local usando .NET Core em Linux?

Já tenho ferramentas que conseguem identificar o Mac-Address dos dispositivos da minha rede, desde que o 'servidor' ou a aplicação esteja rodando em Windows e .NET Framework.  
Tenho usado o seguinte:
using System;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Runtime.InteropServices;
namespace Yordi.Ferramentas
{
    /// <summary>
    /// Ferramentas para rede local
    /// </summary>
    public static class Rede
    {
        private static string _erro;
        public static string ErrorMessage { get { return _erro; } }
        [DllImport("iphlpapi.dll", ExactSpelling = true)]
        public static extern int SendARP(int DestIP, int SrcIP, byte[] pMacAddr, ref uint PhyAddrLen);
        /// <summary>
        /// Recupera o MAC Address de um equipamento na rede local baseado em seu IP
        /// </summary>
        /// <param name="ip">IP em formato string (Ex: 192.168.0.10)</param>
        /// <returns>String com o MAC Address no formato XX-XX-XX-XX-XX</returns>
        public static string TryGetMacAddress(string ip)
        {
            try
            {
                IPAddress IP = IPAddress.Parse(ip);
                byte[] macAddr = new byte[6];
                uint macAddrLen = (uint)macAddr.Length;
                if (SendARP((int)IP.Address, 0, macAddr, ref macAddrLen) != 0)
                {
                    _erro = "Não foi possível executar comando ARP";
                    return String.Empty;
                }
                string[] str = new string[(int)macAddrLen];
                for (int i = 0; i < macAddrLen; i++)
                    str[i] = macAddr[i].ToString("x2");
                return string.Join("-", str);
            }
            catch (Exception e)
            {
                _erro = e.Message;
            }
            return String.Empty;
        }
        /// <summary>
        /// Dado um ip que pertença a mesma rede, o MAC Address será dado 
        /// </summary>
        /// <param name="ip">IP que pertença à rede</param>
        /// <returns>string com os bytes separados por hífen</returns>
        public static string GetMyMacAddress(string ip)
        {
            NetworkInterface[] nics = NetworkInterface.GetAllNetworkInterfaces();
            foreach (NetworkInterface adapter in nics)
            {
                foreach (UnicastIPAddressInformation unip in adapter.GetIPProperties().UnicastAddresses)
                {
                    if (unip.Address.AddressFamily == AddressFamily.InterNetwork)
                    {
                        if (unip.Address.ToString() == ip)
                        {
                            PhysicalAddress address = adapter.GetPhysicalAddress();
                            return BitConverter.ToString(address.GetAddressBytes());
                        }
                    }
                }
            }
            return null;
        }
    }
}

A forma de se conseguir o Mac-Address da própria máquina é usar a classe NetworkInterface do .NET (em uso no método GetMyMacAddress(string ip)).
Para se tentar conseguir o Mac-Address de outro dispositivo na rede local é por usar o comando arp.
Para chamá-lo no Windows tenho que importar uma dll do sistema: 
[DllImport("iphlpapi.dll", ExactSpelling = true)]
Referencio-a:
public static extern int SendARP(int DestIP, int SrcIP, byte[] pMacAddr, ref uint PhyAddrLen);
E a uso aqui:
SendARP((int)IP.Address, 0, macAddr, ref macAddrLen)
Como estou portando a aplicação para .NET Core, para rodar num Raspberry PI 3 em Linux, quero saber como fazer o mesmo processo em Linux (isso se for a forma de correta de fazer nesse sistema).
A classe NetworkInterface existe também no .NET Core, sob o namespace System.Net.NetworkInformation.
Mas como conseguir o Mac-Address de um IP de outra máquina (em Linux com .NET Core)?

A:

Amigo, deculpa não saber responder sobre .NET
mas no linux vc pode descobrir o mac de um ip com o comando arping.
Sintaxe: arping -S   -w2000 -i  -C1 -R -r | tail -n1
arping -S 192.168.0.8 192.168.0.170 -w2000 -i eth0 -C1 -R -r | tail -n1

Onde o "IP1" é o ip da máquina que esta enviando a solicitação, e o IP2 é a maquina de destino.
Com a sintaxe acima você terá o resultado a baixo
9c:2a:83:21:4e:91 192.168.0.170

De uma lida no link a baixo para ajustar o comando conforme sua necessidade.
https://github.com/ThomasHabets/arping
Crie uma classe auxiliar da seguinte forma:
using System;
using System.Diagnostics;
    public static class ShellHelper
    {
        public static string Bash(this string cmd)
        {
            var escapedArgs = cmd.Replace("\"", "\\\"");

            var process = new Process()
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = "/bin/bash",
                    Arguments = $"-c \"{escapedArgs}\"",
                    RedirectStandardOutput = true,
                    UseShellExecute = false,
                    CreateNoWindow = true,
                }
            };
            process.Start();
            string result = process.StandardOutput.ReadToEnd();
            process.WaitForExit();
            return result;
        }
    }

Agora você poderá executar qualquer comando no bash da seguinte forma
var output = "arping -S 192.168.0.8 192.168.0.170 -w2000 -i eth0 -C1 -R -r | tail -n1".Bash();

Isso deve funcionar.

