diff --git a/.gitea/workflows/BuildRelease.yaml b/.gitea/workflows/BuildRelease.yaml index f009b3a..6062a6d 100644 --- a/.gitea/workflows/BuildRelease.yaml +++ b/.gitea/workflows/BuildRelease.yaml @@ -55,6 +55,7 @@ jobs: files: |- ehs-windows-amd64.zip api_key: '${{secrets.RELEASE_TOKEN}}' + pre_release: false Linux-AMD64-Build: runs-on: linux-x86_64 @@ -100,6 +101,7 @@ jobs: files: |- ehs-linux-amd64.zip api_key: '${{secrets.RELEASE_TOKEN}}' + pre_release: false Linux-AARCH64-Build: runs-on: linux-aarch64 @@ -143,4 +145,5 @@ jobs: with: files: |- ehs-linux-aarch64.zip - api_key: '${{secrets.RELEASE_TOKEN}}' \ No newline at end of file + api_key: '${{secrets.RELEASE_TOKEN}}' + pre_release: false \ No newline at end of file diff --git a/README.md b/README.md index b2a5fa6..29c74fc 100644 --- a/README.md +++ b/README.md @@ -22,6 +22,7 @@ This project does not fully follow the C++ standard. - Semaphores - CPU information and features at runtime - HTTP(S) Socket Layer +- ICMP & ICMPv6 Socket - TCP Socket - UDP Socket - COM (Serial) IO diff --git a/include/ehs/io/socket/BaseICMP.h b/include/ehs/io/socket/BaseICMP.h index ab5acdd..b81e12e 100644 --- a/include/ehs/io/socket/BaseICMP.h +++ b/include/ehs/io/socket/BaseICMP.h @@ -25,6 +25,8 @@ namespace ehs IP version; public: + virtual ~BaseICMP() = default; + BaseICMP(); BaseICMP(IP version); @@ -39,15 +41,17 @@ namespace ehs virtual UInt_64 Send(const Str_8 &address, ICMP_Header header, const Byte *data, UInt_64 size); - virtual UInt_64 Receive(Str_8 &address, ICMP_Header header, Serializer &data); + virtual UInt_64 Receive(Str_8 &address, ICMP_Header &header, Serializer &data); void SendEchoRequest(const Str_8 &address, ICMP_EchoRequest er, const Byte *data, UInt_64 size); virtual void SetReceiveTimeout(UInt_64 timeout); + IP GetVersion() const; + virtual bool IsValid() const; protected: - static UInt_16 ComputeChecksum(UInt_16 *buffer, Size length); + static UInt_16 ComputeChecksumV4(UInt_16 *buffer, Size length); }; } diff --git a/include/ehs/io/socket/ICMP_LNX.h b/include/ehs/io/socket/ICMP_LNX.h index eb255fc..68efaaa 100644 --- a/include/ehs/io/socket/ICMP_LNX.h +++ b/include/ehs/io/socket/ICMP_LNX.h @@ -2,14 +2,26 @@ #include "BaseICMP.h" +#include + namespace ehs { - class ICMP : public BaseICMP + struct PseudoICMPv6_Header + { + sockaddr_in6 src; + sockaddr_in6 dst; + UInt_32 length; + }; + + class ICMP final : public BaseICMP { private: Int_32 hdl; + sockaddr_in6 src; public: + ~ICMP(); + ICMP(); ICMP(IP version); @@ -24,10 +36,27 @@ namespace ehs UInt_64 Send(const Str_8 &address, ICMP_Header header, const Byte *data, UInt_64 size) override; - UInt_64 Receive(Str_8 &address, ICMP_Header header, Serializer &data) override; + UInt_64 Receive(Str_8 &address, ICMP_Header &header, Serializer &data) override; void SetReceiveTimeout(UInt_64 timeout) override; bool IsValid() const override; + + private: + static bool IsLinkLocal(const in6_addr &addr); + + static sockaddr_in6 RetrieveSrcAddress(); + + static UInt_32 CalculatePseudoHeaderChecksum(const PseudoICMPv6_Header &header); + + UInt_16 ComputeChecksumV6(UInt_16* buffer, Size length, const sockaddr_in6& dst); + + UInt_64 SendV6(const Str_8 &address, ICMP_Header header, const Byte *data, UInt_64 size); + + UInt_64 SendV4(const Str_8 &address, ICMP_Header header, const Byte *data, UInt_64 size); + + UInt_64 ReceiveV6(Str_8 &address, ICMP_Header &header, Serializer &data) const; + + UInt_64 ReceiveV4(Str_8 &address, ICMP_Header &header, Serializer &data) const; }; } \ No newline at end of file diff --git a/src/io/socket/BaseICMP.cpp b/src/io/socket/BaseICMP.cpp index 48af730..63ef63f 100644 --- a/src/io/socket/BaseICMP.cpp +++ b/src/io/socket/BaseICMP.cpp @@ -50,7 +50,7 @@ namespace ehs return 0; } - UInt_64 BaseICMP::Receive(Str_8 &address, ICMP_Header header, Serializer &data) + UInt_64 BaseICMP::Receive(Str_8 &address, ICMP_Header &header, Serializer &data) { return 0; } @@ -65,7 +65,7 @@ namespace ehs } ICMP_Header header = { - 8, + version == IP::V6 ? (UInt_8)128 : (UInt_8)8, 0, 0 }; @@ -85,12 +85,17 @@ namespace ehs { } + IP BaseICMP::GetVersion() const + { + return version; + } + bool BaseICMP::IsValid() const { return false; } - UInt_16 BaseICMP::ComputeChecksum(UInt_16 *buffer, Size length) + UInt_16 BaseICMP::ComputeChecksumV4(UInt_16 *buffer, Size length) { Size sum = 0; while (length > 1) diff --git a/src/io/socket/ICMP_LNX.cpp b/src/io/socket/ICMP_LNX.cpp index 5e426fd..1274b2f 100644 --- a/src/io/socket/ICMP_LNX.cpp +++ b/src/io/socket/ICMP_LNX.cpp @@ -5,18 +5,30 @@ #include #include #include +#include +#include namespace ehs { + ICMP::~ICMP() + { + if (close(hdl) == -1) + EHS_LOG_INT(LogType::ERR, 0, "Failed to close socket."); + } + ICMP::ICMP() - : hdl(EHS_INVALID_SOCKET) + : hdl(EHS_INVALID_SOCKET), src{} { } ICMP::ICMP(const IP version) - : BaseICMP(version) + : BaseICMP(version), src{} { - hdl = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP); + if (version == IP::V6) + hdl = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6); + else + hdl = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP); + if (hdl < 0) { EHS_LOG_INT(LogType::ERR, 0, "Failed to create ICMP socket with error #" + Str_8::FromNum(errno) + "."); @@ -27,13 +39,14 @@ namespace ehs } ICMP::ICMP(ICMP &&icmp) noexcept - : BaseICMP((BaseICMP &&)icmp), hdl(icmp.hdl) + : BaseICMP((BaseICMP &&)icmp), hdl(icmp.hdl), src(icmp.src) { icmp.hdl = EHS_INVALID_SOCKET; + icmp.src = {}; } ICMP::ICMP(const ICMP &icmp) - : BaseICMP(icmp), hdl(icmp.hdl) + : BaseICMP(icmp), hdl(icmp.hdl), src{} { } @@ -45,8 +58,10 @@ namespace ehs BaseICMP::operator=((BaseICMP &&)icmp); hdl = icmp.hdl; + src = icmp.src; icmp.hdl = EHS_INVALID_SOCKET; + icmp.src = {}; return *this; } @@ -59,11 +74,138 @@ namespace ehs BaseICMP::operator=(icmp); hdl = icmp.hdl; + src = {}; return *this; } UInt_64 ICMP::Send(const Str_8 &address, ICMP_Header header, const Byte *data, const UInt_64 size) + { + if (GetVersion() == IP::V6) + return SendV6(address, header, data, size); + + return SendV4(address, header, data, size); + } + + UInt_64 ICMP::Receive(Str_8 &address, ICMP_Header &header, Serializer &data) + { + if (GetVersion() == IP::V6) + return ReceiveV6(address, header, data); + + return ReceiveV4(address, header, data); + } + + void ICMP::SetReceiveTimeout(const UInt_64 timeout) + { + timeval result = {}; + result.tv_sec = (long)timeout; + result.tv_usec = 0; + + if (setsockopt(hdl, SOL_SOCKET, SO_RCVTIMEO, &result, sizeof(result)) < 0) + { + EHS_LOG_INT(LogType::WARN, 0, "Failed to set receive timeout with error #" + Str_8::FromNum(errno) + "."); + + return; + } + + EHS_LOG_SUCCESS(); + } + + bool ICMP::IsValid() const + { + return hdl != EHS_INVALID_SOCKET; + } + + bool ICMP::IsLinkLocal(const in6_addr &addr) + { + return addr.s6_addr[0] == 0xfe && (addr.s6_addr[1] & 0xc0) == 0x80; + } + + sockaddr_in6 ICMP::RetrieveSrcAddress() + { + ifaddrs *ifaddr; + sockaddr_in6 addr = {}; + + if (getifaddrs(&ifaddr) == -1) + { + EHS_LOG_INT(LogType::ERR, 0, "Failed to retrieve public address with error #" + Str_8::FromNum(errno) + "."); + + return addr; + } + + for (ifaddrs *ifa = ifaddr; ifa; ifa = ifa->ifa_next) + { + if (ifa->ifa_addr == nullptr || ifa->ifa_addr->sa_family != AF_INET6) + continue; + + addr = *(sockaddr_in6 *)ifa->ifa_addr; + if (!addr.sin6_addr.s6_addr32[0] || IsLinkLocal(addr.sin6_addr)) + continue; + + break; + } + + freeifaddrs(ifaddr); + + EHS_LOG_SUCCESS(); + + return addr; + } + + UInt_32 ICMP::CalculatePseudoHeaderChecksum(const PseudoICMPv6_Header &header) + { + UInt_32 checksum = 0; + + for (UInt_8 i = 0; i < 16; ++i) + checksum += header.src.sin6_addr.s6_addr[i]; + + for (UInt_8 i = 0; i < 16; ++i) + checksum += header.dst.sin6_addr.s6_addr[i]; + + checksum += 58; + + checksum += htons(header.length); + + checksum = (checksum >> 16) + (checksum & 0xFFFF); + checksum += (checksum >> 16); + + return checksum; + } + + UInt_16 ICMP::ComputeChecksumV6(UInt_16 *buffer, Size length, const sockaddr_in6 &dst) + { + UInt_32 checksum = 0; + + if (!src.sin6_addr.s6_addr32[0]) + { + src = RetrieveSrcAddress(); + if (!src.sin6_addr.s6_addr32[0]) + { + EHS_LOG_INT(LogType::ERR, 0, "Could not retrieve a suitable global address."); + return checksum; + } + } + + checksum += CalculatePseudoHeaderChecksum({src, dst, (UInt_32)length}); + + while (length > 1) + { + checksum += *buffer++; + length -= sizeof(UInt_16); + } + + if (length == 1) + checksum += *(UInt_8 *)buffer; + + // Carry over any overflow from the 16-bit result + checksum = (checksum >> 16) + (checksum & 0xFFFF); + checksum += (checksum >> 16); + + // Return the 16-bit complement + return ~checksum; + } + + UInt_64 ICMP::SendV6(const Str_8 &address, ICMP_Header header, const Byte *data, UInt_64 size) { if (!IsValid()) { @@ -82,17 +224,17 @@ namespace ehs payload.SetOffset(payload.GetOffset() + size); - header.checksum = ComputeChecksum((UInt_16 *)&payload[0], payload.Size()); + sockaddr_in6 dst = {}; + dst.sin6_family = AF_INET6; + inet_pton(AF_INET6, address, &(dst.sin6_addr)); + + header.checksum = ComputeChecksumV6((UInt_16 *)&payload[0], payload.Size(), dst); payload.SetOffset(0); payload.Write(header); payload.SetOffset(payload.Size()); - sockaddr_in dst_addr = {}; - dst_addr.sin_family = AF_INET; - inet_pton(AF_INET, address, &(dst_addr.sin_addr)); - - SInt_64 sent = sendto(hdl, payload, payload.Size(), 0, (sockaddr *)&dst_addr, sizeof(dst_addr)); + SInt_64 sent = sendto(hdl, payload, payload.Size(), 0, (sockaddr *)&dst, sizeof(sockaddr_in6)); if (sent < 0) { EHS_LOG_INT(LogType::ERR, 0, "Failed to send packet with error #" + Str_8::FromNum(errno) + "."); @@ -105,7 +247,96 @@ namespace ehs return sent; } - UInt_64 ICMP::Receive(Str_8 &address, ICMP_Header header, Serializer &data) + UInt_64 ICMP::SendV4(const Str_8 &address, ICMP_Header header, const Byte *data, UInt_64 size) + { + if (!IsValid()) + { + EHS_LOG_INT(LogType::WARN, 0, "Socket is not initialized."); + + return 0; + } + + header.checksum = 0; + + Serializer payload(Endianness::LE); + payload.Write(header); + payload.Resize(payload.Size() + size); + + Util::Copy(&payload[payload.GetOffset()], data, size); + + payload.SetOffset(payload.GetOffset() + size); + + header.checksum = ComputeChecksumV4((UInt_16 *)&payload[0], payload.Size()); + + payload.SetOffset(0); + payload.Write(header); + payload.SetOffset(payload.Size()); + + sockaddr_in dst = {}; + dst.sin_family = AF_INET; + inet_pton(AF_INET, address, &(dst.sin_addr)); + + SInt_64 sent = sendto(hdl, payload, payload.Size(), 0, (sockaddr *)&dst, sizeof(sockaddr_in)); + if (sent < 0) + { + EHS_LOG_INT(LogType::ERR, 0, "Failed to send packet with error #" + Str_8::FromNum(errno) + "."); + + return 0; + } + + EHS_LOG_SUCCESS(); + + return sent; + } + + UInt_64 ICMP::ReceiveV6(Str_8 &address, ICMP_Header &header, Serializer &data) const + { + if (!IsValid()) + { + EHS_LOG_INT(LogType::WARN, 0, "Socket is not initialized."); + + return 0; + } + + Serializer payload(Endianness::LE); + payload.Resize(1500); + + sockaddr_in6 remote = {}; + socklen_t from_len = sizeof(remote); + + SInt_64 recv = recvfrom(hdl, payload, 1500, 0, (sockaddr *)&remote, &from_len); + if (recv < 0) + { + int code = errno; + if (code == EAGAIN) + EHS_LOG_SUCCESS(); + else + EHS_LOG_INT(LogType::ERR, 0, "Failed to receive packet with error #" + Str_8::FromNum(code) + "."); + + return 0; + } + + payload.Resize(recv); + + char tmpAddr[INET6_ADDRSTRLEN]; + + if (!inet_ntop(remote.sin6_family, &remote.sin6_addr, tmpAddr, INET6_ADDRSTRLEN)) + { + EHS_LOG_INT(LogType::ERR, 1, "Failed to convert IPv6 address with error #" + Str_8::FromNum(errno) + "."); + + return recv; + } + + address = tmpAddr; + header = payload.Read(); + data = Serializer(payload.GetEndianness(), &payload[payload.GetOffset()], payload.Size() - payload.GetOffset()); + + EHS_LOG_SUCCESS(); + + return recv; + } + + UInt_64 ICMP::ReceiveV4(Str_8 &address, ICMP_Header &header, Serializer &data) const { if (!IsValid()) { @@ -152,25 +383,4 @@ namespace ehs return recv; } - - void ICMP::SetReceiveTimeout(UInt_64 timeout) - { - timeval result = {}; - result.tv_sec = (long)timeout; - result.tv_usec = 0; - - if (setsockopt(hdl, SOL_SOCKET, SO_RCVTIMEO, &result, sizeof(result)) < 0) - { - EHS_LOG_INT(LogType::WARN, 0, "Failed to set receive timeout with error #" + Str_8::FromNum(errno) + "."); - - return; - } - - EHS_LOG_SUCCESS(); - } - - bool ICMP::IsValid() const - { - return hdl != EHS_INVALID_SOCKET; - } }