234 lines
7.8 KiB
C
234 lines
7.8 KiB
C
/*
|
|
* windivert_hash.c
|
|
* (C) 2023, all rights reserved,
|
|
*
|
|
* This file is part of WinDivert.
|
|
*
|
|
* WinDivert is free software: you can redistribute it and/or modify it under
|
|
* the terms of the GNU Lesser General Public License as published by the
|
|
* Free Software Foundation, either version 3 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
|
* License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* WinDivert is free software; you can redistribute it and/or modify it under
|
|
* the terms of the GNU General Public License as published by the Free
|
|
* Software Foundation; either version 2 of the License, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc., 51
|
|
* Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* xxHash - Fast Hash algorithm
|
|
* Copyright (C) 2012-2016, Yann Collet
|
|
*
|
|
* BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following disclaimer
|
|
* in the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* This is a modified version of the 64bit xxHash algorithm:
|
|
* - The algorithm is seeded with packet data rather than the single 64bit
|
|
* "seed" value.
|
|
* - The input sized is fixed to 32bytes (excluding the seed), so there is
|
|
* only ever a single round. As such, the algorithm has been specialized.
|
|
* - [ETHERNET] uses an additional "pseudo-round" for the ethernet header.
|
|
*/
|
|
|
|
#define WINDIVERT_ROTL64(x, r) (((x) << (r)) | ((x) >> (64 - (r))))
|
|
|
|
static const UINT64 WINDIVERT_PRIME64_1 = 11400714785074694791ull;
|
|
static const UINT64 WINDIVERT_PRIME64_2 = 14029467366897019727ull;
|
|
static const UINT64 WINDIVERT_PRIME64_3 = 1609587929392839161ull;
|
|
static const UINT64 WINDIVERT_PRIME64_4 = 9650029242287828579ull;
|
|
|
|
static UINT64 WinDivertXXH64Round(UINT64 acc, UINT64 input)
|
|
{
|
|
acc += WINDIVERT_MUL64(input, WINDIVERT_PRIME64_2);
|
|
acc = WINDIVERT_ROTL64(acc, 31);
|
|
acc = WINDIVERT_MUL64(acc, WINDIVERT_PRIME64_1);
|
|
return acc;
|
|
}
|
|
|
|
static UINT64 WinDivertXXH64MergeRound(UINT64 acc, UINT64 val)
|
|
{
|
|
val = WinDivertXXH64Round(0, val);
|
|
acc ^= val;
|
|
acc = WINDIVERT_MUL64(acc, WINDIVERT_PRIME64_1) + WINDIVERT_PRIME64_4;
|
|
return acc;
|
|
}
|
|
|
|
static UINT64 WinDivertXXH64Avalanche(UINT64 h64)
|
|
{
|
|
h64 ^= h64 >> 33;
|
|
h64 = WINDIVERT_MUL64(h64, WINDIVERT_PRIME64_2);
|
|
h64 ^= h64 >> 29;
|
|
h64 = WINDIVERT_MUL64(h64, WINDIVERT_PRIME64_3);
|
|
h64 ^= h64 >> 32;
|
|
return h64;
|
|
}
|
|
|
|
/*
|
|
* WinDivert packet hash function.
|
|
*/
|
|
static UINT64 WinDivertHashPacket(
|
|
UINT64 seed,
|
|
const WINDIVERT_ETHHDR *eth_header,
|
|
const WINDIVERT_ARPHDR *arp_header,
|
|
const WINDIVERT_IPHDR *ip_header,
|
|
const WINDIVERT_IPV6HDR *ipv6_header,
|
|
const WINDIVERT_ICMPHDR *icmp_header,
|
|
const WINDIVERT_ICMPV6HDR *icmpv6_header,
|
|
const WINDIVERT_TCPHDR *tcp_header,
|
|
const WINDIVERT_UDPHDR *udp_header)
|
|
{
|
|
UINT64 h64, v1, v2, v3, v4, v[4];
|
|
const UINT64 *data64;
|
|
const UINT32 *data32;
|
|
UINT i;
|
|
static const UINT64 padding64[] = // SHA2 IV
|
|
{
|
|
0x428A2F9871374491ull, 0xB5C0FBCFE9B5DBA5ull, 0x3956C25B59F111F1ull,
|
|
0x923F82A4AB1C5ED5ull, 0xD807AA9812835B01ull, 0x243185BE550C7DC3ull,
|
|
0x72BE5D7480DEB1FEull, 0x9BDC06A7C19BF174ull, 0xE49B69C1EFBE4786ull,
|
|
};
|
|
|
|
// Set-up seed & data
|
|
v1 = seed ^ padding64[0];
|
|
if (ip_header != NULL)
|
|
{
|
|
data64 = (const UINT64 *)ip_header;
|
|
v2 = data64[0] ^ padding64[1];
|
|
v3 = data64[1] ^ padding64[2];
|
|
data32 = (const UINT32 *)ip_header;
|
|
v4 = (UINT64)data32[4] ^ padding64[3];
|
|
i = 0;
|
|
}
|
|
else if (ipv6_header != NULL)
|
|
{
|
|
data64 = (const UINT64 *)ipv6_header;
|
|
v2 = data64[0] ^ padding64[1];
|
|
v3 = data64[1] ^ padding64[2];
|
|
v4 = data64[2] ^ padding64[3];
|
|
v[0] = data64[3] ^ padding64[4];
|
|
v[1] = data64[4] ^ padding64[5];
|
|
i = 2;
|
|
}
|
|
else if (eth_header != NULL)
|
|
{
|
|
v2 = padding64[1];
|
|
v3 = padding64[2];
|
|
v4 = padding64[3];
|
|
i = 0;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (tcp_header != NULL)
|
|
{
|
|
data64 = (const UINT64 *)tcp_header;
|
|
v[i] = data64[0] ^ padding64[i+4]; i++;
|
|
v[i] = data64[1] ^ padding64[i+4]; i++;
|
|
data32 = (const UINT32 *)tcp_header;
|
|
if (i <= 3)
|
|
{
|
|
v[i] = (UINT64)data32[4] ^ padding64[i+4]; i++;
|
|
}
|
|
else
|
|
{
|
|
v2 ^= ((UINT64)data32[4] << 32);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (udp_header != NULL)
|
|
{
|
|
data64 = (const UINT64 *)udp_header;
|
|
v[i] = data64[0] ^ padding64[i+4]; i++;
|
|
}
|
|
else if (icmp_header != NULL)
|
|
{
|
|
data64 = (const UINT64 *)icmp_header;
|
|
v[i] = data64[0] ^ padding64[i+4]; i++;
|
|
}
|
|
else if (icmpv6_header != NULL)
|
|
{
|
|
data64 = (const UINT64 *)icmpv6_header;
|
|
v[i] = data64[0] ^ padding64[i+4]; i++;
|
|
}
|
|
}
|
|
|
|
while (i <= 3)
|
|
{
|
|
v[i] = seed ^ padding64[i+4]; i++;
|
|
}
|
|
|
|
// Hash
|
|
v1 = WinDivertXXH64Round(v[0], v1);
|
|
v2 = WinDivertXXH64Round(v[1], v2);
|
|
v3 = WinDivertXXH64Round(v[2], v3);
|
|
v4 = WinDivertXXH64Round(v[3], v4);
|
|
|
|
// Ethernet-layer pseudo-round:
|
|
if (eth_header != NULL)
|
|
{
|
|
data64 = (const UINT64 *)eth_header->DstAddr;
|
|
v1 = WinDivertXXH64Round(v1, data64[0] & 0xFFFFFFFFFFFFull);
|
|
data64 = (const UINT64 *)eth_header->SrcAddr;
|
|
v2 = WinDivertXXH64Round(v2, data64[0]);
|
|
if (arp_header != NULL)
|
|
{
|
|
data64 = (const UINT64 *)arp_header;
|
|
v3 = WinDivertXXH64Round(v3, data64[0]);
|
|
}
|
|
}
|
|
|
|
h64 = WINDIVERT_ROTL64(v1, 1) + WINDIVERT_ROTL64(v2, 7) +
|
|
WINDIVERT_ROTL64(v3, 12) + WINDIVERT_ROTL64(v4, 18);
|
|
h64 = WinDivertXXH64MergeRound(h64, v1);
|
|
h64 = WinDivertXXH64MergeRound(h64, v2);
|
|
h64 = WinDivertXXH64MergeRound(h64, v3);
|
|
h64 = WinDivertXXH64MergeRound(h64, v4);
|
|
h64 += 32; // "length"
|
|
h64 = WinDivertXXH64Avalanche(h64);
|
|
|
|
return h64;
|
|
}
|
|
|