diff --git a/meta-openembedded/meta-oe/recipes-security/keyutils/files/0001-tests-toolbox.inc.sh-update-regex-for-getting-endian.patch b/meta-openembedded/meta-oe/recipes-security/keyutils/files/0001-tests-toolbox.inc.sh-update-regex-for-getting-endian.patch
index 769118e..314487a 100644
--- a/meta-openembedded/meta-oe/recipes-security/keyutils/files/0001-tests-toolbox.inc.sh-update-regex-for-getting-endian.patch
+++ b/meta-openembedded/meta-oe/recipes-security/keyutils/files/0001-tests-toolbox.inc.sh-update-regex-for-getting-endian.patch
@@ -6,7 +6,7 @@
 Update regex for getting endian in following condition:
 /proc/777/exe: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2
 
-Upstream-Status: Submited [Submitted to keyrings@vger.kernel.org ]
+Upstream-Status: Submitted [Submitted to keyrings@vger.kernel.org ]
 
 Signed-off-by: Changqing Li <changqing.li@windriver.com>
 ---
diff --git a/meta-openembedded/meta-oe/recipes-security/usbguard/usbguard/0001-include-missing-cstdint.patch b/meta-openembedded/meta-oe/recipes-security/usbguard/usbguard/0001-include-missing-cstdint.patch
new file mode 100644
index 0000000..5cbe640
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-security/usbguard/usbguard/0001-include-missing-cstdint.patch
@@ -0,0 +1,45 @@
+From 1da0cfbb9ae978822d961d8b22d8d5125c11247a Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Thu, 26 Jan 2023 23:46:56 -0800
+Subject: [PATCH] include missing <cstdint>
+
+gcc 13 moved some includes around and as a result <cstdint> is no
+longer transitively included [1]. Explicitly include it for
+uint8_t.
+
+[1] https://gcc.gnu.org/gcc-13/porting_to.html#header-dep-changes
+
+Upstream-Status: Submitted [https://github.com/USBGuard/usbguard/pull/583]
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ src/Library/Base64.cpp | 1 -
+ src/Library/Base64.hpp | 1 +
+ 2 files changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/Library/Base64.cpp b/src/Library/Base64.cpp
+index ddb28dc..0246a13 100644
+--- a/src/Library/Base64.cpp
++++ b/src/Library/Base64.cpp
+@@ -22,7 +22,6 @@
+ 
+ #include "Base64.hpp"
+ #include <stdexcept>
+-#include <cstdint>
+ 
+ namespace usbguard
+ {
+diff --git a/src/Library/Base64.hpp b/src/Library/Base64.hpp
+index 0947f21..e0c745c 100644
+--- a/src/Library/Base64.hpp
++++ b/src/Library/Base64.hpp
+@@ -23,6 +23,7 @@
+ #endif
+ 
+ #include <string>
++#include <cstdint>
+ #include <cstddef>
+ 
+ namespace usbguard
+-- 
+2.39.1
+
diff --git a/meta-openembedded/meta-oe/recipes-security/usbguard/usbguard_1.1.2.bb b/meta-openembedded/meta-oe/recipes-security/usbguard/usbguard_1.1.2.bb
index e1e087a..4e96b4f 100644
--- a/meta-openembedded/meta-oe/recipes-security/usbguard/usbguard_1.1.2.bb
+++ b/meta-openembedded/meta-oe/recipes-security/usbguard/usbguard_1.1.2.bb
@@ -12,6 +12,7 @@
 LIC_FILES_CHKSUM = "file://LICENSE;md5=b234ee4d69f5fce4486a80fdaf4a4263"
 
 SRC_URI = "https://github.com/USBGuard/usbguard/releases/download/${BPN}-${PV}/${BPN}-${PV}.tar.gz \
+    file://0001-include-missing-cstdint.patch \
     file://0001-Add-and-use-pkgconfig-instead-of-libgcrypt-config.patch"
 
 SRC_URI[sha256sum] = "dcf5c90f3f93030e04df1baeb8d388b678c40dd48b135ea12a7be7dee8944934"
