lib/accelerated: report GNUTLS_E_SHORT_MEMORY_BUFFER in many places

Signed-off-by: Alexander Sosedkin <asosedkin@redhat.com>

diff --git a/lib/accelerated/aarch64/aes-cbc-aarch64.c b/lib/accelerated/aarch64/aes-cbc-aarch64.c
index 68434f3656834c6f603cdff31d632f2b77f4b74a..299a0808de17348448778cb6bf088110d6900d99 100644 (file)
--- a/lib/accelerated/aarch64/aes-cbc-aarch64.c
+++ b/lib/accelerated/aarch64/aes-cbc-aarch64.c
@@ -91,6 +91,9 @@ aes_aarch64_encrypt(void *_ctx, const void *src, size_t src_size,
        if (unlikely(src_size % 16 != 0))
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        aes_v8_cbc_encrypt(src, dst, src_size, ALIGN16(&ctx->expanded_key),
                          ctx->iv, 1);
        return 0;
@@ -105,6 +108,9 @@ aes_aarch64_decrypt(void *_ctx, const void *src, size_t src_size,
        if (unlikely(src_size % 16 != 0))
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        aes_v8_cbc_encrypt(src, dst, src_size, ALIGN16(&ctx->expanded_key),
                          ctx->iv, 0);
 

diff --git a/lib/accelerated/aarch64/aes-ccm-aarch64.c b/lib/accelerated/aarch64/aes-ccm-aarch64.c
index 5de7ab0e89cb9a0c2f6dc5aca6ea7dabe8dbfb8c..a2ba259e9949e2fdf856acc0c293e07a88d57854 100644 (file)
--- a/lib/accelerated/aarch64/aes-ccm-aarch64.c
+++ b/lib/accelerated/aarch64/aes-ccm-aarch64.c
@@ -126,6 +126,9 @@ aes_ccm_aead_decrypt(void *_ctx,
        if (unlikely(encr_size < tag_size))
                return gnutls_assert_val(GNUTLS_E_DECRYPTION_FAILED);
 
+       if (unlikely(plain_size < encr_size - tag_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        ret = ccm_decrypt_message(&ctx->key, aarch64_aes_encrypt,
                                  nonce_size, nonce,
                                  auth_size, auth,

diff --git a/lib/accelerated/aarch64/aes-gcm-aarch64.c b/lib/accelerated/aarch64/aes-gcm-aarch64.c
index 01f22136a65b3c420a229cd418889b5e33bd04dd..901bd9f60f1e29c41d5761b261ca319a78fa15c0 100644 (file)
--- a/lib/accelerated/aarch64/aes-gcm-aarch64.c
+++ b/lib/accelerated/aarch64/aes-gcm-aarch64.c
@@ -233,6 +233,9 @@ aes_gcm_encrypt(void *_ctx, const void *src, size_t src_size,
        if (unlikely(ctx->finished))
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 
+       if (unlikely(length < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        if (blocks > 0) {
                ctr32_encrypt_blocks(src, dst,
                                     blocks,
@@ -268,6 +271,9 @@ aes_gcm_decrypt(void *_ctx, const void *src, size_t src_size,
        if (unlikely(ctx->finished))
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        gcm_ghash(ctx, src, src_size);
        ctx->gcm.len.u[1] += src_size;
 

diff --git a/lib/accelerated/afalg.c b/lib/accelerated/afalg.c
index 12d4df7a5de4936a45eb2b3737b86b93fc8147fa..6348e3f19715cfd04d7f0f6a8dbfcb7c7bb87bef 100644 (file)
--- a/lib/accelerated/afalg.c
+++ b/lib/accelerated/afalg.c
@@ -134,8 +134,11 @@ static int afalg_cipher_encrypt(void *_ctx, const void *src, size_t src_size,
                return gnutls_assert_val(GNUTLS_E_ENCRYPTION_FAILED);
        }
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        iov.iov_base = (void *)dst;
-       iov.iov_len = (src_size > dst_size) ? dst_size : src_size;
+       iov.iov_len = src_size;
 
        if (kcapi_cipher_stream_op(ctx->handle, &iov, 1) < 0) {
                gnutls_assert();
@@ -162,8 +165,11 @@ static int afalg_cipher_decrypt(void *_ctx, const void *src, size_t src_size,
                return gnutls_assert_val(GNUTLS_E_ENCRYPTION_FAILED);
        }
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        iov.iov_base = (void *)dst;
-       iov.iov_len = (src_size > dst_size) ? dst_size : src_size;
+       iov.iov_len = src_size;
 
        if (kcapi_cipher_stream_op(ctx->handle, &iov, 1) < 0) {
                gnutls_assert();
@@ -313,6 +319,12 @@ static int afalg_aead_decrypt(void *_ctx,
                goto end;
        }
 
+       if (unlikely(plain_size < encr_size - tag_size)) {
+               gnutls_assert();
+               ret = GNUTLS_E_SHORT_MEMORY_BUFFER;
+               goto end;
+       }
+
        /* Init stream once. */
        if (!ctx->taglen_set) {
                ctx->taglen_set = 1;

diff --git a/lib/accelerated/cryptodev-gcm.c b/lib/accelerated/cryptodev-gcm.c
index 876756094e3a6447e6dd8b7ad6af9d1be963f0c4..a847f821c48c0d8c23fd2ce0d9d7451df11671ca 100644 (file)
--- a/lib/accelerated/cryptodev-gcm.c
+++ b/lib/accelerated/cryptodev-gcm.c
@@ -138,7 +138,7 @@ aes_gcm_encrypt(void *_ctx, const void *src, size_t src_size,
         * encrypted data.
         */
        if (dst_size < src_size + GCM_BLOCK_SIZE)
-               return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
 
        ctx->cryp.len = src_size;
        ctx->cryp.src = (void *) src;
@@ -176,6 +176,9 @@ aes_gcm_decrypt(void *_ctx, const void *src, size_t src_size,
        ctx->cryp.auth_len = ctx->auth_data_size;
        ctx->cryp.auth_src = ctx->auth_data;
 
+       if (dst_size < src_size - GCM_BLOCK_SIZE)
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        if (ioctl(ctx->cfd, CIOCAUTHCRYPT, &ctx->cryp)) {
                gnutls_assert();
                return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;

diff --git a/lib/accelerated/cryptodev.c b/lib/accelerated/cryptodev.c
index d28322967db123e88d13b32337c074fc158951fc..dca3aa8ee80b394c6046010b9b580fc146f755d8 100644 (file)
--- a/lib/accelerated/cryptodev.c
+++ b/lib/accelerated/cryptodev.c
@@ -128,6 +128,11 @@ cryptodev_encrypt(void *_ctx, const void *src, size_t src_size,
        ctx->cryp.op = COP_ENCRYPT;
        ctx->cryp.flags = COP_FLAG_WRITE_IV;
 
+       if (unlikely(dst_size < src_size)) {
+               gnutls_assert();
+               return GNUTLS_E_SHORT_MEMORY_BUFFER;
+       }
+
        if (ioctl(ctx->cfd, CIOCCRYPT, &ctx->cryp)) {
                gnutls_assert();
                return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;
@@ -148,6 +153,11 @@ cryptodev_decrypt(void *_ctx, const void *src, size_t src_size,
        ctx->cryp.op = COP_DECRYPT;
        ctx->cryp.flags = COP_FLAG_WRITE_IV;
 
+       if (unlikely(dst_size < src_size)) {
+               gnutls_assert();
+               return GNUTLS_E_SHORT_MEMORY_BUFFER;
+       }
+
        if (ioctl(ctx->cfd, CIOCCRYPT, &ctx->cryp)) {
                gnutls_assert();
                return GNUTLS_E_CRYPTODEV_IOCTL_ERROR;

diff --git a/lib/accelerated/x86/aes-cbc-x86-aesni.c b/lib/accelerated/x86/aes-cbc-x86-aesni.c
index e4364d54a11c10bebcee0765a5f4bdd40d15ef1d..fa9858d1a12be3a1592a205c68183e4a9574e19d 100644 (file)
--- a/lib/accelerated/x86/aes-cbc-x86-aesni.c
+++ b/lib/accelerated/x86/aes-cbc-x86-aesni.c
@@ -100,6 +100,9 @@ aes_encrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct aes_ctx *ctx = _ctx;
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        if (unlikely(src_size % 16 != 0))
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 
@@ -114,6 +117,9 @@ aes_decrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct aes_ctx *ctx = _ctx;
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        if (unlikely(src_size % 16 != 0))
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 

diff --git a/lib/accelerated/x86/aes-cbc-x86-ssse3.c b/lib/accelerated/x86/aes-cbc-x86-ssse3.c
index fe09f502c3a1cb37c9b690c0ae3d124975e99ac1..7999fc1320e422d8fb692495010c837471953fb4 100644 (file)
--- a/lib/accelerated/x86/aes-cbc-x86-ssse3.c
+++ b/lib/accelerated/x86/aes-cbc-x86-ssse3.c
@@ -89,6 +89,9 @@ aes_ssse3_encrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct aes_ctx *ctx = _ctx;
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        if (unlikely(src_size % 16 != 0))
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 
@@ -103,6 +106,9 @@ aes_ssse3_decrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct aes_ctx *ctx = _ctx;
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        if (unlikely(src_size % 16 != 0))
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 

diff --git a/lib/accelerated/x86/aes-ccm-x86-aesni.c b/lib/accelerated/x86/aes-ccm-x86-aesni.c
index 95607b95c16db7d033775df5c5df61f0cccf310f..701c0f992a5703d3e8e65b4d31a895c38fdc1e32 100644 (file)
--- a/lib/accelerated/x86/aes-ccm-x86-aesni.c
+++ b/lib/accelerated/x86/aes-ccm-x86-aesni.c
@@ -118,6 +118,9 @@ aes_ccm_aead_decrypt(void *_ctx,
        if (unlikely(encr_size < tag_size))
                return gnutls_assert_val(GNUTLS_E_DECRYPTION_FAILED);
 
+       if (unlikely(plain_size < encr_size - tag_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        ret = ccm_decrypt_message(&ctx->key, x86_aes_encrypt,
                                  nonce_size, nonce,
                                  auth_size, auth,

diff --git a/lib/accelerated/x86/aes-gcm-aead.h b/lib/accelerated/x86/aes-gcm-aead.h
index f8cb5a5ea1a1f7deb696cb39e33dd05e6c56391c..3f473b51d5e0ca3918d8a428b3504fb1a44ebc42 100644 (file)
--- a/lib/accelerated/x86/aes-gcm-aead.h
+++ b/lib/accelerated/x86/aes-gcm-aead.h
@@ -10,7 +10,7 @@ aes_gcm_aead_encrypt(void *ctx,
                        void *encr, size_t encr_size)
 {
        /* proper AEAD cipher */
-       if (encr_size < plain_size + tag_size)
+       if (unlikely(encr_size < plain_size + tag_size))
                return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
 
        aes_gcm_setiv(ctx, nonce, nonce_size);
@@ -32,9 +32,12 @@ aes_gcm_aead_decrypt(void *ctx,
 {
        uint8_t tag[MAX_HASH_SIZE];
 
-       if (encr_size < tag_size)
+       if (unlikely(encr_size < tag_size))
                return gnutls_assert_val(GNUTLS_E_DECRYPTION_FAILED);
 
+       if (unlikely(plain_size < encr_size - tag_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        aes_gcm_setiv(ctx, nonce, nonce_size);
        aes_gcm_auth(ctx, auth, auth_size);
 

diff --git a/lib/accelerated/x86/aes-gcm-padlock.c b/lib/accelerated/x86/aes-gcm-padlock.c
index d651d0aed59482361bc403d35b57a24463786e38..a9c7441d650b18a75569748b1fd1825ee1b1d618 100644 (file)
--- a/lib/accelerated/x86/aes-gcm-padlock.c
+++ b/lib/accelerated/x86/aes-gcm-padlock.c
@@ -137,6 +137,9 @@ aes_gcm_encrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct gcm_padlock_aes_ctx *ctx = _ctx;
 
+       if (unlikely(length < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        GCM_ENCRYPT(ctx, padlock_aes_encrypt, src_size, dst, src);
 
        return 0;
@@ -148,6 +151,9 @@ aes_gcm_decrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct gcm_padlock_aes_ctx *ctx = _ctx;
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        GCM_DECRYPT(ctx, padlock_aes_encrypt, src_size, dst, src);
        return 0;
 }

diff --git a/lib/accelerated/x86/aes-gcm-x86-aesni.c b/lib/accelerated/x86/aes-gcm-x86-aesni.c
index 6c1bb1f6fd5a168cb0bd6ac77aecda934b72be73..b0edaebfba8c2886eafb83deb2c994e5fb673147 100644 (file)
--- a/lib/accelerated/x86/aes-gcm-x86-aesni.c
+++ b/lib/accelerated/x86/aes-gcm-x86-aesni.c
@@ -133,6 +133,9 @@ aes_gcm_encrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct gcm_x86_aes_ctx *ctx = _ctx;
 
+       if (unlikely(length < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        GCM_ENCRYPT(ctx, x86_aes_encrypt, src_size, dst, src);
 
        return 0;
@@ -144,6 +147,9 @@ aes_gcm_decrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct gcm_x86_aes_ctx *ctx = _ctx;
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        GCM_DECRYPT(ctx, x86_aes_encrypt, src_size, dst, src);
        return 0;
 }

diff --git a/lib/accelerated/x86/aes-gcm-x86-pclmul-avx.c b/lib/accelerated/x86/aes-gcm-x86-pclmul-avx.c
index f601c0b2823d17c7c4edf19e8e6cc625a174bc2e..21aef94440e02f06c4d93382a79c12dd2c2dc895 100644 (file)
--- a/lib/accelerated/x86/aes-gcm-x86-pclmul-avx.c
+++ b/lib/accelerated/x86/aes-gcm-x86-pclmul-avx.c
@@ -188,6 +188,9 @@ aes_gcm_encrypt(void *_ctx, const void *src, size_t src_size,
        if (unlikely(ctx->finished))
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 
+       if (unlikely(length < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        if (blocks > 0) {
                aesni_ctr32_encrypt_blocks(src, dst,
                                           blocks,
@@ -334,14 +337,14 @@ aesni_gcm_aead_decrypt(void *_ctx,
        if (unlikely(encr_size < tag_size))
                return gnutls_assert_val(GNUTLS_E_DECRYPTION_FAILED);
 
+       if (unlikely(plain_size < encr_size - tag_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        aes_gcm_setiv(ctx, nonce, nonce_size);
        aes_gcm_auth(ctx, auth, auth_size);
 
        encr_size -= tag_size;
 
-       if (unlikely(plain_size < encr_size))
-               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
-
        if (encr_size >= 96) {
                s = aesni_gcm_decrypt(encr, plain, encr_size, ALIGN16(&ctx->expanded_key),
                        ctx->gcm.Yi.c, ctx->gcm.Xi.u);

diff --git a/lib/accelerated/x86/aes-gcm-x86-pclmul.c b/lib/accelerated/x86/aes-gcm-x86-pclmul.c
index dc1e68dfe87beb64099c8124167df6e394b0e654..e6b4990cbfdb750017f21ae419874d25a0a307ab 100644 (file)
--- a/lib/accelerated/x86/aes-gcm-x86-pclmul.c
+++ b/lib/accelerated/x86/aes-gcm-x86-pclmul.c
@@ -188,6 +188,9 @@ aes_gcm_encrypt(void *_ctx, const void *src, size_t src_size,
        if (unlikely(ctx->finished))
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 
+       if (unlikely(length < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        if (blocks > 0) {
                aesni_ctr32_encrypt_blocks(src, dst,
                                           blocks,
@@ -223,6 +226,9 @@ aes_gcm_decrypt(void *_ctx, const void *src, size_t src_size,
        if (unlikely(ctx->finished))
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        gcm_ghash(ctx, src, src_size);
        ctx->gcm.len.u[1] += src_size;
 

diff --git a/lib/accelerated/x86/aes-gcm-x86-ssse3.c b/lib/accelerated/x86/aes-gcm-x86-ssse3.c
index f6b14681c9256ccd15b3ca91d2a131ebab819328..7a2ac50869fe470e57b44e0d5c113cac5db66e7c 100644 (file)
--- a/lib/accelerated/x86/aes-gcm-x86-ssse3.c
+++ b/lib/accelerated/x86/aes-gcm-x86-ssse3.c
@@ -142,6 +142,9 @@ aes_gcm_encrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct gcm_x86_aes_ctx *ctx = _ctx;
 
+       if (unlikely(length < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        GCM_ENCRYPT(ctx, x86_aes_encrypt, src_size, dst, src);
 
        return 0;
@@ -153,6 +156,9 @@ aes_gcm_decrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct gcm_x86_aes_ctx *ctx = _ctx;
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        GCM_DECRYPT(ctx, x86_aes_encrypt, src_size, dst, src);
        return 0;
 }

diff --git a/lib/accelerated/x86/aes-padlock.c b/lib/accelerated/x86/aes-padlock.c
index 1e9b77c2152679302923bf2e4b8ae0b2ece16b9a..4fa6389a000f15dbf47954273731379808725242 100644 (file)
--- a/lib/accelerated/x86/aes-padlock.c
+++ b/lib/accelerated/x86/aes-padlock.c
@@ -134,6 +134,9 @@ padlock_aes_cbc_encrypt(void *_ctx, const void *src, size_t src_size,
        struct padlock_cipher_data *pce;
        int ret = 1;
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        pce = ALIGN16(&ctx->expanded_key);
 
        if (src_size > 0)
@@ -151,6 +154,9 @@ padlock_aes_cbc_decrypt(void *_ctx, const void *src, size_t src_size,
        struct padlock_cipher_data *pcd;
        int ret = 1;
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        pcd = ALIGN16(&ctx->expanded_key);
 
        if (src_size > 0)

diff --git a/lib/accelerated/x86/aes-xts-x86-aesni.c b/lib/accelerated/x86/aes-xts-x86-aesni.c
index b904cbf0085182b30b535b897c0714a5fd6d8513..0588d0bd55f407c040f45141932453fad9179d0e 100644 (file)
--- a/lib/accelerated/x86/aes-xts-x86-aesni.c
+++ b/lib/accelerated/x86/aes-xts-x86-aesni.c
@@ -119,6 +119,9 @@ x86_aes_xts_encrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct x86_aes_xts_ctx *ctx = _ctx;
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        if (src_size < 16)
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 
@@ -133,6 +136,9 @@ x86_aes_xts_decrypt(void *_ctx, const void *src, size_t src_size,
 {
        struct x86_aes_xts_ctx *ctx = _ctx;
 
+       if (unlikely(dst_size < src_size))
+               return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
+
        if (src_size < 16)
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);