0xatharv/cve-2025-40019-pocCVE-2025-40019 के लिए एक प्रूफ ऑफ कॉन्सेप्ट
CVE-2025-40019 एन्क्रिप्टेड सॉल्ट-सेक्टर इनिशियलाइज़ेशन वेक्टर मैकेनिज़्म (crypto/essiv.c) है जिसमें इनिशियलाइज़ेशन वेक्टर (IV) आकार के सापेक्ष एसोसिएटेड ऑथेंटिकेशन डेटा (AAD) लंबाई का अपर्याप्त सत्यापन होता है, जिससे आउट-ऑफ-बाउंड्स मेमोरी एक्सेस होती है। इस रिपॉजिटरी में दिया गया कोड सिर्फ एक बग ट्रिगर है लेकिन यह बग आसानी से शोषणीय है।
मुझे यह बग kernelctf स्प्रेडशीट में यहाँ मिला। चूंकि इस बग से जुड़ा कोई ब्लॉगपोस्ट या पीओसी नहीं था, मैंने लिनक्स कर्नेल के क्रिप्टो सबसिस्टम का पता लगाने का फैसला किया कि समस्या किस कारण से हुई।
ESSIV की आवश्यकता को समझने के लिए, हमें देखना होगा कि डिस्क पर डेटा कैसे संग्रहीत किया जाता है। डिस्क एन्क्रिप्शन (जैसे LUKS या dm-crypt) आमतौर पर सेक्टरों पर काम करता है। प्रत्येक सेक्टर को स्वतंत्र रूप से एन्क्रिप्ट किया जाना चाहिए ताकि एक सेक्टर को पढ़ने के लिए पूरी डिस्क को पढ़ने की आवश्यकता न हो।
मानक CBC (सिफर ब्लॉक चेनिंग) मोड में, प्रत्येक एन्क्रिप्शन ऑपरेशन के लिए एक इनिशियलाइज़ेशन वेक्टर (IV) की आवश्यकता होती है। प्रारंभिक डिस्क एन्क्रिप्शन कार्यान्वयनों ने सेक्टर नंबर को IV के रूप में उपयोग किया।
हालांकि, चूंकि सेक्टर नंबर पूर्वानुमानित होते हैं, एक हमलावर "वॉटरमार्किंग हमला" कर सकता है। किसी ज्ञात सेक्टर में विशेष रूप से तैयार डेटा लिखकर, हमलावर सिफरटेक्स्ट में पैटर्न देख सकता है जो विशिष्ट फाइलों की उपस्थिति को प्रकट करते हैं, प्रभावी रूप से एन्क्रिप्शन की गोपनीयता को दरकिनार करते हैं।
ESSIV (एन्क्रिप्टेड सॉल्ट-सेक्टर इनिशियलाइज़ेशन वेक्टर) को IV को अप्रत्याशित बनाने के लिए डिज़ाइन किया गया था। यह इस प्रकार काम करता है:
यह सुनिश्चित करता है कि भले ही कोई हमलावर सेक्टर नंबर जानता हो, वे गुप्त कुंजी को जाने बिना IV की भविष्यवाणी नहीं कर सकते।
प्रत्येक एल्गोरिदम, चाहे वह AES जैसा बेस सिफर हो या ESSIV जैसा रैपर, एक संरचना लागू करता है जिसका उपयोग कर्नेल कॉल को रूट करने के लिए करता है:
struct skcipher_alg {
int (*setkey)(struct crypto_skcipher *tfm, const u8 *key, unsigned int keylen);
int (*encrypt)(struct skcipher_request *req);
int (*decrypt)(struct skcipher_request *req);
// ...
struct skcipher_alg_common co; // Contains ivsize, chunksize, etc.
};
यह कमजोरी एक क्लासिक मामला है जहां यह मान लिया जाता है कि उपयोगकर्ता द्वारा प्रदान किया गया मेटाडेटा (AAD लंबाई) हमेशा क्रिप्टोग्राफिक ट्रांसफॉर्म की आंतरिक आवश्यकताओं को पूरा करेगा। "इन-प्लेस" या डिक्रिप्शन (!enc) पथ में, कोड एक ऑफसेट की गणना करता है: req->assoclen - crypto_aead_ivsize(tfm)। लेकिन यह कभी जांच नहीं करता है कि req->assoclen < ivsize है या नहीं। जिसका अर्थ है कि यह ऑफसेट नकारात्मक हो सकता है।
static int essiv_aead_crypt(struct aead_request *req, bool enc)
{
struct crypto_aead *tfm = crypto_aead_reqtfm(req);
const struct essiv_tfm_ctx *tctx = crypto_aead_ctx(tfm);
struct essiv_aead_request_ctx *rctx = aead_request_ctx(req);
struct aead_request *subreq = &rctx->aead_req;
struct scatterlist *src = req->src;
int err;
crypto_cipher_encrypt_one(tctx->essiv_cipher, req->iv, req->iv);
/*
* dm-crypt embeds the sector number and the IV in the AAD region, so
* we have to copy the converted IV into the right scatterlist before
* we pass it on.
*/
rctx->assoc = NULL;
if (req->src == req->dst || !enc) {
scatterwalk_map_and_copy(req->iv, req->dst,
req->assoclen - crypto_aead_ivsize(tfm), // <------- bug !
crypto_aead_ivsize(tfm), 1);
} else {
u8 *iv = (u8 *)aead_request_ctx(req) + tctx->ivoffset;
int ivsize = crypto_aead_ivsize(tfm);
int ssize = req->assoclen - ivsize;
struct scatterlist *sg;
int nents;
.
.
.
scatterwalk_map_and_copy फ़ंक्शन को देखते हुए, हम देख सकते हैं कि यह केवल scatterlist sg में मेमकॉपी करता है:
static inline void scatterwalk_map_and_copy(void *buf, struct scatterlist *sg,
unsigned int start,
unsigned int nbytes, int out)
{
if (out)
memcpy_to_sglist(sg, start, buf, nbytes);
else
memcpy_from_sglist(buf, sg, start, nbytes);
}
इस बग का पैच बहुत सरल था, यह सिर्फ जांचता है कि assoclen ivsize से कम है या नहीं
diff --git a/crypto/essiv.c b/crypto/essiv.c
index d003b78fcd855a..a47a3eab693519 100644
--- a/crypto/essiv.c
+++ b/crypto/essiv.c
@@ -186,9 +186,14 @@ static int essiv_aead_crypt(struct aead_request *req, bool enc)
const struct essiv_tfm_ctx *tctx = crypto_aead_ctx(tfm);
struct essiv_aead_request_ctx *rctx = aead_request_ctx(req);
struct aead_request *subreq = &rctx->aead_req;
+ int ivsize = crypto_aead_ivsize(tfm);
+ int ssize = req->assoclen - ivsize;
struct scatterlist *src = req->src;
int err;
+ if (ssize < 0)
+ return -EINVAL;
+
crypto_cipher_encrypt_one(tctx->essiv_cipher, req->iv, req->iv);
/*
@@ -198,19 +203,12 @@ static int essiv_aead_crypt(struct aead_request *req, bool enc)
*/
rctx->assoc = NULL;
if (req->src == req->dst || !enc) {
- scatterwalk_map_and_copy(req->iv, req->dst,
- req->assoclen - crypto_aead_ivsize(tfm),
- crypto_aead_ivsize(tfm), 1);
+ scatterwalk_map_and_copy(req->iv, req->dst, ssize, ivsize, 1);
} else {
u8 *iv = (u8 *)aead_request_ctx(req) + tctx->ivoffset;
- int ivsize = crypto_aead_ivsize(tfm);
- int ssize = req->assoclen - ivsize;
struct scatterlist *sg;
int nents;
- if (ssize < 0)
- return -EINVAL;
-
nents = sg_nents_for_len(req->src, ssize);
if (nents < 0)
return -EINVAL;