Use crypto/subtle.XORBytes

The function XORBytes has been included in the Go standard library
since Go version 1.20.  This allows us to remove a bunch of
assembler code, and instead rely on the stdlib.

There are only three versions remaining:

  - xor_generic, which simply calls the stdlib function;
  - xor_old, which uses unsafe Go and is used with Go 1.19;
  - xor_arm, which is written in assembly and is used on
    32-bit ARM, since the stdlib doesn't implement a fast
    version of XORBytes on that architecture.

utils/xor/xor_generic.go

@@ -1,78 +1,17 @@
 // SPDX-FileCopyrightText: 2013 The Go Authors. All rights reserved.
 // SPDX-License-Identifier: BSD-3-Clause
-// SPDX-FileCopyrightText: 2022 The Pion community <https://pion.ly>
+// SPDX-FileCopyrightText: 2024 The Pion community <https://pion.ly>
 // SPDX-License-Identifier: MIT
 
-//go:build (!amd64 && !ppc64 && !ppc64le && !arm64 && !arm) || gccgo
-// +build !amd64,!ppc64,!ppc64le,!arm64,!arm gccgo
+//go:build go1.20 && !arm && !gccgo
 
-// Package xor provides utility functions used by other Pion
-// packages. Generic arch.
+// Package xor provides the XorBytes function.
 package xor
 
 import (
-	"runtime"
-	"unsafe"
+	"crypto/subtle"
 )
 
-const (
-	wordSize          = int(unsafe.Sizeof(uintptr(0)))                                                                                   // nolint:gosec
-	supportsUnaligned = runtime.GOARCH == "386" || runtime.GOARCH == "ppc64" || runtime.GOARCH == "ppc64le" || runtime.GOARCH == "s390x" // nolint:gochecknoglobals
-)
-
-func isAligned(a *byte) bool {
-	return uintptr(unsafe.Pointer(a))%uintptr(wordSize) == 0
-}
-
-// XorBytes xors the bytes in a and b. The destination should have enough
-// space, otherwise xorBytes will panic. Returns the number of bytes xor'd.
-//
-//revive:disable-next-line
 func XorBytes(dst, a, b []byte) int {
-	n := len(a)
-	if len(b) < n {
-		n = len(b)
-	}
-	if n == 0 {
-		return 0
-	}
-
-	switch {
-	case supportsUnaligned:
-		fastXORBytes(dst, a, b, n)
-	case isAligned(&dst[0]) && isAligned(&a[0]) && isAligned(&b[0]):
-		fastXORBytes(dst, a, b, n)
-	default:
-		safeXORBytes(dst, a, b, n)
-	}
-	return n
-}
-
-// fastXORBytes xors in bulk. It only works on architectures that
-// support unaligned read/writes.
-// n needs to be smaller or equal than the length of a and b.
-func fastXORBytes(dst, a, b []byte, n int) {
-	// Assert dst has enough space
-	_ = dst[n-1]
-
-	w := n / wordSize
-	if w > 0 {
-		dw := *(*[]uintptr)(unsafe.Pointer(&dst)) // nolint:gosec
-		aw := *(*[]uintptr)(unsafe.Pointer(&a))   // nolint:gosec
-		bw := *(*[]uintptr)(unsafe.Pointer(&b))   // nolint:gosec
-		for i := 0; i < w; i++ {
-			dw[i] = aw[i] ^ bw[i]
-		}
-	}
-
-	for i := (n - n%wordSize); i < n; i++ {
-		dst[i] = a[i] ^ b[i]
-	}
-}
-
-// n needs to be smaller or equal than the length of a and b.
-func safeXORBytes(dst, a, b []byte, n int) {
-	for i := 0; i < n; i++ {
-		dst[i] = a[i] ^ b[i]
-	}
+	return subtle.XORBytes(dst, a, b)
 }

utils/xor/xor_old.go

@@ -0,0 +1,77 @@
+// SPDX-FileCopyrightText: 2013 The Go Authors. All rights reserved.
+// SPDX-License-Identifier: BSD-3-Clause
+// SPDX-FileCopyrightText: 2022 The Pion community <https://pion.ly>
+// SPDX-License-Identifier: MIT
+
+//go:build (!go1.20 && !arm) || gccgo
+
+// Package xor provides the XorBytes function.
+// This version is only used on Go up to version 1.19.
+package xor
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+const (
+	wordSize          = int(unsafe.Sizeof(uintptr(0)))                                                                                   // nolint:gosec
+	supportsUnaligned = runtime.GOARCH == "386" || runtime.GOARCH == "ppc64" || runtime.GOARCH == "ppc64le" || runtime.GOARCH == "s390x" // nolint:gochecknoglobals
+)
+
+func isAligned(a *byte) bool {
+	return uintptr(unsafe.Pointer(a))%uintptr(wordSize) == 0
+}
+
+// XorBytes xors the bytes in a and b. The destination should have enough
+// space, otherwise xorBytes will panic. Returns the number of bytes xor'd.
+//
+//revive:disable-next-line
+func XorBytes(dst, a, b []byte) int {
+	n := len(a)
+	if len(b) < n {
+		n = len(b)
+	}
+	if n == 0 {
+		return 0
+	}
+
+	switch {
+	case supportsUnaligned:
+		fastXORBytes(dst, a, b, n)
+	case isAligned(&dst[0]) && isAligned(&a[0]) && isAligned(&b[0]):
+		fastXORBytes(dst, a, b, n)
+	default:
+		safeXORBytes(dst, a, b, n)
+	}
+	return n
+}
+
+// fastXORBytes xors in bulk. It only works on architectures that
+// support unaligned read/writes.
+// n needs to be smaller or equal than the length of a and b.
+func fastXORBytes(dst, a, b []byte, n int) {
+	// Assert dst has enough space
+	_ = dst[n-1]
+
+	w := n / wordSize
+	if w > 0 {
+		dw := *(*[]uintptr)(unsafe.Pointer(&dst)) // nolint:gosec
+		aw := *(*[]uintptr)(unsafe.Pointer(&a))   // nolint:gosec
+		bw := *(*[]uintptr)(unsafe.Pointer(&b))   // nolint:gosec
+		for i := 0; i < w; i++ {
+			dw[i] = aw[i] ^ bw[i]
+		}
+	}
+
+	for i := (n - n%wordSize); i < n; i++ {
+		dst[i] = a[i] ^ b[i]
+	}
+}
+
+// n needs to be smaller or equal than the length of a and b.
+func safeXORBytes(dst, a, b []byte, n int) {
+	for i := 0; i < n; i++ {
+		dst[i] = a[i] ^ b[i]
+	}
+}