Add support for regular CFB.

Signed-off-by: David Dudas <david.dudas03@e-uvt.ro>

diff --git a/devel/libgnutls.abignore b/devel/libgnutls.abignore
index c19dce38e11a1c763a5d7bb7a17888e269dc61bf..64df9b2de7b003853cb1174b4e3b5aafcd878d8c 100644 (file)
--- a/devel/libgnutls.abignore
+++ b/devel/libgnutls.abignore
@@ -70,3 +70,7 @@ name = drbg_aes_reseed
 
 # The following should be removed in the new release, after updating the
 # abi-dump repository:
+
+[suppress_type]
+name = gnutls_cipher_algorithm_t
+changed_enumerators = GNUTLS_CIPHER_AES_128_CFB, GNUTLS_CIPHER_AES_192_CFB, GNUTLS_CIPHER_AES_256_CFB
\ No newline at end of file

diff --git a/lib/algorithms/ciphers.c b/lib/algorithms/ciphers.c
index 1edee6ff3954cd95c37b0218b5d5bc73b2ffa981..e2064cc7a7f384ba1f608f72d8787da4184471e7 100644 (file)
--- a/lib/algorithms/ciphers.c
+++ b/lib/algorithms/ciphers.c
@@ -274,6 +274,27 @@ static const cipher_entry_st algorithms[] = {
          .type = CIPHER_BLOCK,
          .explicit_iv = 16,
          .cipher_iv = 16 },
+       { .name = "AES-128-CFB",
+         .id = GNUTLS_CIPHER_AES_128_CFB,
+         .blocksize = 16,
+         .keysize = 16,
+         .type = CIPHER_BLOCK,
+         .explicit_iv = 16,
+         .cipher_iv = 16 },
+       { .name = "AES-192-CFB",
+         .id = GNUTLS_CIPHER_AES_192_CFB,
+         .blocksize = 16,
+         .keysize = 24,
+         .type = CIPHER_BLOCK,
+         .explicit_iv = 16,
+         .cipher_iv = 16 },
+       { .name = "AES-256-CFB",
+         .id = GNUTLS_CIPHER_AES_256_CFB,
+         .blocksize = 16,
+         .keysize = 32,
+         .type = CIPHER_BLOCK,
+         .explicit_iv = 16,
+         .cipher_iv = 16 },
        { .name = "AES-128-XTS",
          .id = GNUTLS_CIPHER_AES_128_XTS,
          .blocksize = 16,

diff --git a/lib/crypto-selftests.c b/lib/crypto-selftests.c
index f6505f7fe588d0a5a6faf4065898bf117cd5ef53..d93ed906aaabeea35bd1f5d4073c6271007507b6 100644 (file)
--- a/lib/crypto-selftests.c
+++ b/lib/crypto-selftests.c
@@ -366,6 +366,24 @@ const struct cipher_vectors_st aes128_cfb8_vectors[] = {
        },
 };
 
+const struct cipher_vectors_st aes128_cfb_vectors[] = {
+       /* NIST 800-38a */
+       {
+               STR(key, key_size,
+                   "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c"),
+               STR(plaintext, plaintext_size,
+                   "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
+                   "\xae\x2d"),
+               .ciphertext =
+                       (uint8_t *)"\x3b\x3f\xd9\x2e\xb7\x2d\xad\x20\x33\x34\x49\xf8\xe8\x3c\xfb\x4a"
+                                  "\xc8\xa6",
+               STR(iv, iv_size,
+                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"),
+               STR(internal_iv, internal_iv_size,
+                   "\x3b\x3f\xd9\x2e\xb7\x2d\xad\x20\x33\x34\x49\xf8\xe8\x3c\xfb\x4a"),
+       },
+};
+
 const struct cipher_vectors_st aes192_cfb8_vectors[] = {
        /* NIST 800-38a */
        {
@@ -386,6 +404,25 @@ const struct cipher_vectors_st aes192_cfb8_vectors[] = {
        },
 };
 
+const struct cipher_vectors_st aes192_cfb_vectors[] = {
+       /* NIST 800-38a */
+       {
+               STR(key, key_size,
+                   "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b\x80\x90\x79\xe5"
+                   "\x62\xf8\xea\xd2\x52\x2c\x6b\x7b"),
+               STR(plaintext, plaintext_size,
+                   "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
+                   "\xae\x2d"),
+               .ciphertext =
+                       (uint8_t *)"\xcd\xc8\x0d\x6f\xdd\xf1\x8c\xab\x34\xc2\x59\x09\xc9\x9a\x41\x74"
+                                  "\x67\xce",
+               STR(iv, iv_size,
+                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"),
+               STR(internal_iv, internal_iv_size,
+                   "\xcd\xc8\x0d\x6f\xdd\xf1\x8c\xab\x34\xc2\x59\x09\xc9\x9a\x41\x74"),
+       },
+};
+
 const struct cipher_vectors_st aes256_cfb8_vectors[] = {
        /* NIST 800-38a */
        {
@@ -406,6 +443,25 @@ const struct cipher_vectors_st aes256_cfb8_vectors[] = {
        },
 };
 
+const struct cipher_vectors_st aes256_cfb_vectors[] = {
+       /* NIST 800-38a */
+       {
+               STR(key, key_size,
+                   "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
+                   "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4"),
+               STR(plaintext, plaintext_size,
+                   "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
+                   "\xae\x2d"),
+               .ciphertext =
+                       (uint8_t *)"\xdc\x7e\x84\xbf\xda\x79\x16\x4b\x7e\xcd\x84\x86\x98\x5d\x38\x60"
+                                  "\x39\xff",
+               STR(iv, iv_size,
+                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"),
+               STR(internal_iv, internal_iv_size,
+                   "\xdc\x7e\x84\xbf\xda\x79\x16\x4b\x7e\xcd\x84\x86\x98\x5d\x38\x60"),
+       },
+};
+
 /* GOST 28147-89 vectors come from the testsuite contributed to OpenSSL by
  * Sergey E. Leontiev. CryptoPro-B test vector is just truncated.
  * TC26Z is calculated using Nettle */
@@ -2811,6 +2867,15 @@ int gnutls_cipher_self_test(unsigned flags, gnutls_cipher_algorithm_t cipher)
                CHECK(GNUTLS_CIPHER_AES_256_CFB8, test_cipher_all_block_sizes,
                      aes256_cfb8_vectors);
                FALLTHROUGH;
+               CASE(GNUTLS_CIPHER_AES_128_CFB, test_cipher,
+                    aes128_cfb_vectors);
+               FALLTHROUGH;
+               CASE(GNUTLS_CIPHER_AES_192_CFB, test_cipher,
+                    aes192_cfb_vectors);
+               FALLTHROUGH;
+               CASE(GNUTLS_CIPHER_AES_256_CFB, test_cipher,
+                    aes256_cfb_vectors);
+               FALLTHROUGH;
                CASE(GNUTLS_CIPHER_AES_128_XTS, test_cipher,
                     aes128_xts_vectors);
                FALLTHROUGH;

diff --git a/lib/fips.h b/lib/fips.h
index 71a8f6929b8da5c4faf18476ba3fc5387d4b4ada..390839a06640d189ba6b3264a45a8ab7515e9f76 100644 (file)
--- a/lib/fips.h
+++ b/lib/fips.h
@@ -134,6 +134,9 @@ is_cipher_algo_approved_in_fips(gnutls_cipher_algorithm_t algo)
        case GNUTLS_CIPHER_AES_128_CFB8:
        case GNUTLS_CIPHER_AES_192_CFB8:
        case GNUTLS_CIPHER_AES_256_CFB8:
+       case GNUTLS_CIPHER_AES_128_CFB:
+       case GNUTLS_CIPHER_AES_192_CFB:
+       case GNUTLS_CIPHER_AES_256_CFB:
        case GNUTLS_CIPHER_AES_128_XTS:
        case GNUTLS_CIPHER_AES_256_XTS:
                return true;

diff --git a/lib/includes/gnutls/gnutls.h.in b/lib/includes/gnutls/gnutls.h.in
index 964366ded2d8aeeb01451070029120b219b0e1f7..9d0fd3bfcca22e398ed9dabbf9662f5691acf7e3 100644 (file)
--- a/lib/includes/gnutls/gnutls.h.in
+++ b/lib/includes/gnutls/gnutls.h.in
@@ -150,6 +150,9 @@ extern "C" {
  * @GNUTLS_CIPHER_AES_192_GCM: AES in GCM mode with 192-bit keys (AEAD).
  * @GNUTLS_CIPHER_AES_128_SIV_GCM: AES in SIV-GCM mode with 128-bit key.
  * @GNUTLS_CIPHER_AES_256_SIV_GCM: AES in SIV-GCM mode with 256-bit key.
+ * @GNUTLS_CIPHER_AES_128_CFB8: AES in CFB mode with 128-bit keys.
+ * @GNUTLS_CIPHER_AES_192_CFB8: AES in CFB mode with 192-bit keys.
+ * @GNUTLS_CIPHER_AES_256_CFB8: AES in CFB mode with 256-bit keys.
  *
  * Enumeration of different symmetric encryption algorithms.
  */
@@ -198,6 +201,9 @@ typedef enum gnutls_cipher_algorithm {
        GNUTLS_CIPHER_KUZNYECHIK_CTR_ACPKM = 41,
        GNUTLS_CIPHER_AES_128_SIV_GCM = 42,
        GNUTLS_CIPHER_AES_256_SIV_GCM = 43,
+       GNUTLS_CIPHER_AES_128_CFB = 44,
+       GNUTLS_CIPHER_AES_192_CFB = 45,
+       GNUTLS_CIPHER_AES_256_CFB = 46,
 
        /* used only for PGP internals. Ignored in TLS/SSL
         */

diff --git a/lib/nettle/cipher.c b/lib/nettle/cipher.c
index f5db2e504dff39790914d5b7d1ec06f56d3c18c1..def127b3236da0651c2fa1676f7f4640a729f0e1 100644 (file)
--- a/lib/nettle/cipher.c
+++ b/lib/nettle/cipher.c
@@ -164,19 +164,6 @@ static void _cbc_decrypt(struct nettle_cipher_ctx *ctx, size_t length,
                    ctx->iv, length, dst, src);
 }
 
-#if ENABLE_GOST
-struct magma_acpkm_ctx {
-       uint8_t iv[MAGMA_BLOCK_SIZE];
-       struct acpkm_ctx ctx;
-       struct magma_ctx cipher;
-};
-
-struct kuznyechik_acpkm_ctx {
-       uint8_t iv[KUZNYECHIK_BLOCK_SIZE];
-       struct acpkm_ctx ctx;
-       struct kuznyechik_ctx cipher;
-};
-
 static void _cfb_encrypt(struct nettle_cipher_ctx *ctx, size_t length,
                         uint8_t *dst, const uint8_t *src)
 {
@@ -191,6 +178,19 @@ static void _cfb_decrypt(struct nettle_cipher_ctx *ctx, size_t length,
                    ctx->iv, length, dst, src);
 }
 
+#if ENABLE_GOST
+struct magma_acpkm_ctx {
+       uint8_t iv[MAGMA_BLOCK_SIZE];
+       struct acpkm_ctx ctx;
+       struct magma_ctx cipher;
+};
+
+struct kuznyechik_acpkm_ctx {
+       uint8_t iv[KUZNYECHIK_BLOCK_SIZE];
+       struct acpkm_ctx ctx;
+       struct kuznyechik_ctx cipher;
+};
+
 static void _ctr_acpkm_crypt(struct nettle_cipher_ctx *ctx, size_t length,
                             uint8_t *dst, const uint8_t *src)
 {
@@ -1108,6 +1108,57 @@ static const struct nettle_cipher_st builtin_ciphers[] = {
                        (nettle_set_key_func *)aes256_set_encrypt_key,
                .max_iv_size = AES_BLOCK_SIZE,
        },
+       {
+               .algo = GNUTLS_CIPHER_AES_128_CFB,
+               .block_size = AES_BLOCK_SIZE,
+               .key_size = AES128_KEY_SIZE,
+               .encrypt_block = (nettle_cipher_func *)aes128_encrypt,
+               .decrypt_block = (nettle_cipher_func *)aes128_encrypt,
+
+               .ctx_size = sizeof(
+                       struct CFB_CTX(struct aes128_ctx, AES_BLOCK_SIZE)),
+               .encrypt = _cfb_encrypt,
+               .decrypt = _cfb_decrypt,
+               .set_encrypt_key =
+                       (nettle_set_key_func *)aes128_set_encrypt_key,
+               .set_decrypt_key =
+                       (nettle_set_key_func *)aes128_set_encrypt_key,
+               .max_iv_size = AES_BLOCK_SIZE,
+       },
+       {
+               .algo = GNUTLS_CIPHER_AES_192_CFB,
+               .block_size = AES_BLOCK_SIZE,
+               .key_size = AES192_KEY_SIZE,
+               .encrypt_block = (nettle_cipher_func *)aes192_encrypt,
+               .decrypt_block = (nettle_cipher_func *)aes192_encrypt,
+
+               .ctx_size = sizeof(
+                       struct CFB_CTX(struct aes192_ctx, AES_BLOCK_SIZE)),
+               .encrypt = _cfb_encrypt,
+               .decrypt = _cfb_decrypt,
+               .set_encrypt_key =
+                       (nettle_set_key_func *)aes192_set_encrypt_key,
+               .set_decrypt_key =
+                       (nettle_set_key_func *)aes192_set_encrypt_key,
+               .max_iv_size = AES_BLOCK_SIZE,
+       },
+       {
+               .algo = GNUTLS_CIPHER_AES_256_CFB,
+               .block_size = AES_BLOCK_SIZE,
+               .key_size = AES256_KEY_SIZE,
+               .encrypt_block = (nettle_cipher_func *)aes256_encrypt,
+               .decrypt_block = (nettle_cipher_func *)aes256_encrypt,
+
+               .ctx_size = sizeof(
+                       struct CFB_CTX(struct aes256_ctx, AES_BLOCK_SIZE)),
+               .encrypt = _cfb_encrypt,
+               .decrypt = _cfb_decrypt,
+               .set_encrypt_key =
+                       (nettle_set_key_func *)aes256_set_encrypt_key,
+               .set_decrypt_key =
+                       (nettle_set_key_func *)aes256_set_encrypt_key,
+               .max_iv_size = AES_BLOCK_SIZE,
+       },
        {
                .algo = GNUTLS_CIPHER_AES_128_XTS,
                .block_size = AES_BLOCK_SIZE,

diff --git a/lib/tpm2/callbacks/aes/aes_callbacks.c b/lib/tpm2/callbacks/aes/aes_callbacks.c
index 2414d8d34e81db19118a151482401ca4da59f042..dc2fd3ef981c9272aadffb4482ee9a92f39ce131 100644 (file)
--- a/lib/tpm2/callbacks/aes/aes_callbacks.c
+++ b/lib/tpm2/callbacks/aes/aes_callbacks.c
@@ -37,11 +37,11 @@ _gnutls_convert_tpm2_cipher_alg(TPMI_AES_KEY_BITS key_bits, TPM2_ALG_ID mode)
 
        switch (key_bits) {
        case 128:
-               return GNUTLS_CIPHER_AES_128_CFB8;
+               return GNUTLS_CIPHER_AES_128_CFB;
        case 192:
-               return GNUTLS_CIPHER_AES_192_CFB8;
+               return GNUTLS_CIPHER_AES_192_CFB;
        case 256:
-               return GNUTLS_CIPHER_AES_256_CFB8;
+               return GNUTLS_CIPHER_AES_256_CFB;
        default:
                return GNUTLS_CIPHER_UNKNOWN;
        }

diff --git a/tests/fips-test.c b/tests/fips-test.c
index c02442737fe042d0964e7cb8f3b982886d41276f..c6e8c1ff52e5899ba7539acb36a7e1b20166e443 100644 (file)
--- a/tests/fips-test.c
+++ b/tests/fips-test.c
@@ -300,6 +300,9 @@ static inline void test_ciphers(void)
        test_cipher_approved(GNUTLS_CIPHER_AES_128_CFB8);
        test_cipher_approved(GNUTLS_CIPHER_AES_192_CFB8);
        test_cipher_approved(GNUTLS_CIPHER_AES_256_CFB8);
+       test_cipher_approved(GNUTLS_CIPHER_AES_128_CFB);
+       test_cipher_approved(GNUTLS_CIPHER_AES_192_CFB);
+       test_cipher_approved(GNUTLS_CIPHER_AES_256_CFB);
        test_cipher_allowed(GNUTLS_CIPHER_AES_128_GCM);
        test_cipher_allowed(GNUTLS_CIPHER_AES_192_GCM);
        test_cipher_allowed(GNUTLS_CIPHER_AES_256_GCM);