[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
/*
|
|
|
|
|
* Authenc: Simple AEAD wrapper for IPsec
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
|
* under the terms of the GNU General Public License as published by the Free
|
|
|
|
|
* Software Foundation; either version 2 of the License, or (at your option)
|
|
|
|
|
* any later version.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
2007-12-10 08:20:24 +00:00
|
|
|
#include <crypto/aead.h>
|
2008-08-31 12:21:09 +00:00
|
|
|
#include <crypto/internal/hash.h>
|
2007-12-17 12:12:49 +00:00
|
|
|
#include <crypto/internal/skcipher.h>
|
2007-11-22 15:11:53 +00:00
|
|
|
#include <crypto/authenc.h>
|
2007-12-07 10:52:49 +00:00
|
|
|
#include <crypto/scatterwalk.h>
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
#include <linux/err.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/module.h>
|
2007-11-22 15:11:53 +00:00
|
|
|
#include <linux/rtnetlink.h>
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
#include <linux/slab.h>
|
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
typedef u8 *(*authenc_ahash_t)(struct aead_request *req, unsigned int flags);
|
|
|
|
|
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
struct authenc_instance_ctx {
|
2009-08-05 09:35:34 +00:00
|
|
|
struct crypto_ahash_spawn auth;
|
2007-12-17 12:12:49 +00:00
|
|
|
struct crypto_skcipher_spawn enc;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct crypto_authenc_ctx {
|
2009-08-05 09:35:34 +00:00
|
|
|
unsigned int reqoff;
|
|
|
|
|
struct crypto_ahash *auth;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
struct crypto_ablkcipher *enc;
|
|
|
|
|
};
|
|
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
struct authenc_request_ctx {
|
|
|
|
|
unsigned int cryptlen;
|
|
|
|
|
struct scatterlist *sg;
|
|
|
|
|
struct scatterlist asg[2];
|
|
|
|
|
struct scatterlist cipher[2];
|
|
|
|
|
crypto_completion_t complete;
|
|
|
|
|
crypto_completion_t update_complete;
|
|
|
|
|
char tail[];
|
|
|
|
|
};
|
|
|
|
|
|
2010-04-26 01:14:05 +00:00
|
|
|
static void authenc_request_complete(struct aead_request *req, int err)
|
|
|
|
|
{
|
|
|
|
|
if (err != -EINPROGRESS)
|
|
|
|
|
aead_request_complete(req, err);
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-15 11:49:30 +00:00
|
|
|
int crypto_authenc_extractkeys(struct crypto_authenc_keys *keys, const u8 *key,
|
|
|
|
|
unsigned int keylen)
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
{
|
2013-10-15 11:49:30 +00:00
|
|
|
struct rtattr *rta = (struct rtattr *)key;
|
2007-11-22 15:11:53 +00:00
|
|
|
struct crypto_authenc_key_param *param;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2007-12-10 02:55:21 +00:00
|
|
|
if (!RTA_OK(rta, keylen))
|
2013-10-15 11:49:30 +00:00
|
|
|
return -EINVAL;
|
2007-11-22 15:11:53 +00:00
|
|
|
if (rta->rta_type != CRYPTO_AUTHENC_KEYA_PARAM)
|
2013-10-15 11:49:30 +00:00
|
|
|
return -EINVAL;
|
crypto: authenc - fix parsing key with misaligned rta_len
commit 8f9c469348487844328e162db57112f7d347c49f upstream.
Keys for "authenc" AEADs are formatted as an rtattr containing a 4-byte
'enckeylen', followed by an authentication key and an encryption key.
crypto_authenc_extractkeys() parses the key to find the inner keys.
However, it fails to consider the case where the rtattr's payload is
longer than 4 bytes but not 4-byte aligned, and where the key ends
before the next 4-byte aligned boundary. In this case, 'keylen -=
RTA_ALIGN(rta->rta_len);' underflows to a value near UINT_MAX. This
causes a buffer overread and crash during crypto_ahash_setkey().
Fix it by restricting the rtattr payload to the expected size.
Reproducer using AF_ALG:
#include <linux/if_alg.h>
#include <linux/rtnetlink.h>
#include <sys/socket.h>
int main()
{
int fd;
struct sockaddr_alg addr = {
.salg_type = "aead",
.salg_name = "authenc(hmac(sha256),cbc(aes))",
};
struct {
struct rtattr attr;
__be32 enckeylen;
char keys[1];
} __attribute__((packed)) key = {
.attr.rta_len = sizeof(key),
.attr.rta_type = 1 /* CRYPTO_AUTHENC_KEYA_PARAM */,
};
fd = socket(AF_ALG, SOCK_SEQPACKET, 0);
bind(fd, (void *)&addr, sizeof(addr));
setsockopt(fd, SOL_ALG, ALG_SET_KEY, &key, sizeof(key));
}
It caused:
BUG: unable to handle kernel paging request at ffff88007ffdc000
PGD 2e01067 P4D 2e01067 PUD 2e04067 PMD 2e05067 PTE 0
Oops: 0000 [#1] SMP
CPU: 0 PID: 883 Comm: authenc Not tainted 4.20.0-rc1-00108-g00c9fe37a7f27 #13
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.12.0-20181126_142135-anatol 04/01/2014
RIP: 0010:sha256_ni_transform+0xb3/0x330 arch/x86/crypto/sha256_ni_asm.S:155
[...]
Call Trace:
sha256_ni_finup+0x10/0x20 arch/x86/crypto/sha256_ssse3_glue.c:321
crypto_shash_finup+0x1a/0x30 crypto/shash.c:178
shash_digest_unaligned+0x45/0x60 crypto/shash.c:186
crypto_shash_digest+0x24/0x40 crypto/shash.c:202
hmac_setkey+0x135/0x1e0 crypto/hmac.c:66
crypto_shash_setkey+0x2b/0xb0 crypto/shash.c:66
shash_async_setkey+0x10/0x20 crypto/shash.c:223
crypto_ahash_setkey+0x2d/0xa0 crypto/ahash.c:202
crypto_authenc_setkey+0x68/0x100 crypto/authenc.c:96
crypto_aead_setkey+0x2a/0xc0 crypto/aead.c:62
aead_setkey+0xc/0x10 crypto/algif_aead.c:526
alg_setkey crypto/af_alg.c:223 [inline]
alg_setsockopt+0xfe/0x130 crypto/af_alg.c:256
__sys_setsockopt+0x6d/0xd0 net/socket.c:1902
__do_sys_setsockopt net/socket.c:1913 [inline]
__se_sys_setsockopt net/socket.c:1910 [inline]
__x64_sys_setsockopt+0x1f/0x30 net/socket.c:1910
do_syscall_64+0x4a/0x180 arch/x86/entry/common.c:290
entry_SYSCALL_64_after_hwframe+0x49/0xbe
Fixes: e236d4a89a2f ("[CRYPTO] authenc: Move enckeylen into key itself")
Cc: <stable@vger.kernel.org> # v2.6.25+
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-12-17 07:23:22 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* RTA_OK() didn't align the rtattr's payload when validating that it
|
|
|
|
|
* fits in the buffer. Yet, the keys should start on the next 4-byte
|
|
|
|
|
* aligned boundary. To avoid confusion, require that the rtattr
|
|
|
|
|
* payload be exactly the param struct, which has a 4-byte aligned size.
|
|
|
|
|
*/
|
|
|
|
|
if (RTA_PAYLOAD(rta) != sizeof(*param))
|
2013-10-15 11:49:30 +00:00
|
|
|
return -EINVAL;
|
crypto: authenc - fix parsing key with misaligned rta_len
commit 8f9c469348487844328e162db57112f7d347c49f upstream.
Keys for "authenc" AEADs are formatted as an rtattr containing a 4-byte
'enckeylen', followed by an authentication key and an encryption key.
crypto_authenc_extractkeys() parses the key to find the inner keys.
However, it fails to consider the case where the rtattr's payload is
longer than 4 bytes but not 4-byte aligned, and where the key ends
before the next 4-byte aligned boundary. In this case, 'keylen -=
RTA_ALIGN(rta->rta_len);' underflows to a value near UINT_MAX. This
causes a buffer overread and crash during crypto_ahash_setkey().
Fix it by restricting the rtattr payload to the expected size.
Reproducer using AF_ALG:
#include <linux/if_alg.h>
#include <linux/rtnetlink.h>
#include <sys/socket.h>
int main()
{
int fd;
struct sockaddr_alg addr = {
.salg_type = "aead",
.salg_name = "authenc(hmac(sha256),cbc(aes))",
};
struct {
struct rtattr attr;
__be32 enckeylen;
char keys[1];
} __attribute__((packed)) key = {
.attr.rta_len = sizeof(key),
.attr.rta_type = 1 /* CRYPTO_AUTHENC_KEYA_PARAM */,
};
fd = socket(AF_ALG, SOCK_SEQPACKET, 0);
bind(fd, (void *)&addr, sizeof(addr));
setsockopt(fd, SOL_ALG, ALG_SET_KEY, &key, sizeof(key));
}
It caused:
BUG: unable to handle kernel paging request at ffff88007ffdc000
PGD 2e01067 P4D 2e01067 PUD 2e04067 PMD 2e05067 PTE 0
Oops: 0000 [#1] SMP
CPU: 0 PID: 883 Comm: authenc Not tainted 4.20.0-rc1-00108-g00c9fe37a7f27 #13
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.12.0-20181126_142135-anatol 04/01/2014
RIP: 0010:sha256_ni_transform+0xb3/0x330 arch/x86/crypto/sha256_ni_asm.S:155
[...]
Call Trace:
sha256_ni_finup+0x10/0x20 arch/x86/crypto/sha256_ssse3_glue.c:321
crypto_shash_finup+0x1a/0x30 crypto/shash.c:178
shash_digest_unaligned+0x45/0x60 crypto/shash.c:186
crypto_shash_digest+0x24/0x40 crypto/shash.c:202
hmac_setkey+0x135/0x1e0 crypto/hmac.c:66
crypto_shash_setkey+0x2b/0xb0 crypto/shash.c:66
shash_async_setkey+0x10/0x20 crypto/shash.c:223
crypto_ahash_setkey+0x2d/0xa0 crypto/ahash.c:202
crypto_authenc_setkey+0x68/0x100 crypto/authenc.c:96
crypto_aead_setkey+0x2a/0xc0 crypto/aead.c:62
aead_setkey+0xc/0x10 crypto/algif_aead.c:526
alg_setkey crypto/af_alg.c:223 [inline]
alg_setsockopt+0xfe/0x130 crypto/af_alg.c:256
__sys_setsockopt+0x6d/0xd0 net/socket.c:1902
__do_sys_setsockopt net/socket.c:1913 [inline]
__se_sys_setsockopt net/socket.c:1910 [inline]
__x64_sys_setsockopt+0x1f/0x30 net/socket.c:1910
do_syscall_64+0x4a/0x180 arch/x86/entry/common.c:290
entry_SYSCALL_64_after_hwframe+0x49/0xbe
Fixes: e236d4a89a2f ("[CRYPTO] authenc: Move enckeylen into key itself")
Cc: <stable@vger.kernel.org> # v2.6.25+
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-12-17 07:23:22 +00:00
|
|
|
BUILD_BUG_ON(sizeof(*param) % RTA_ALIGNTO);
|
2007-11-22 15:11:53 +00:00
|
|
|
|
|
|
|
|
param = RTA_DATA(rta);
|
2013-10-15 11:49:30 +00:00
|
|
|
keys->enckeylen = be32_to_cpu(param->enckeylen);
|
2007-11-22 15:11:53 +00:00
|
|
|
|
crypto: authenc - fix parsing key with misaligned rta_len
commit 8f9c469348487844328e162db57112f7d347c49f upstream.
Keys for "authenc" AEADs are formatted as an rtattr containing a 4-byte
'enckeylen', followed by an authentication key and an encryption key.
crypto_authenc_extractkeys() parses the key to find the inner keys.
However, it fails to consider the case where the rtattr's payload is
longer than 4 bytes but not 4-byte aligned, and where the key ends
before the next 4-byte aligned boundary. In this case, 'keylen -=
RTA_ALIGN(rta->rta_len);' underflows to a value near UINT_MAX. This
causes a buffer overread and crash during crypto_ahash_setkey().
Fix it by restricting the rtattr payload to the expected size.
Reproducer using AF_ALG:
#include <linux/if_alg.h>
#include <linux/rtnetlink.h>
#include <sys/socket.h>
int main()
{
int fd;
struct sockaddr_alg addr = {
.salg_type = "aead",
.salg_name = "authenc(hmac(sha256),cbc(aes))",
};
struct {
struct rtattr attr;
__be32 enckeylen;
char keys[1];
} __attribute__((packed)) key = {
.attr.rta_len = sizeof(key),
.attr.rta_type = 1 /* CRYPTO_AUTHENC_KEYA_PARAM */,
};
fd = socket(AF_ALG, SOCK_SEQPACKET, 0);
bind(fd, (void *)&addr, sizeof(addr));
setsockopt(fd, SOL_ALG, ALG_SET_KEY, &key, sizeof(key));
}
It caused:
BUG: unable to handle kernel paging request at ffff88007ffdc000
PGD 2e01067 P4D 2e01067 PUD 2e04067 PMD 2e05067 PTE 0
Oops: 0000 [#1] SMP
CPU: 0 PID: 883 Comm: authenc Not tainted 4.20.0-rc1-00108-g00c9fe37a7f27 #13
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.12.0-20181126_142135-anatol 04/01/2014
RIP: 0010:sha256_ni_transform+0xb3/0x330 arch/x86/crypto/sha256_ni_asm.S:155
[...]
Call Trace:
sha256_ni_finup+0x10/0x20 arch/x86/crypto/sha256_ssse3_glue.c:321
crypto_shash_finup+0x1a/0x30 crypto/shash.c:178
shash_digest_unaligned+0x45/0x60 crypto/shash.c:186
crypto_shash_digest+0x24/0x40 crypto/shash.c:202
hmac_setkey+0x135/0x1e0 crypto/hmac.c:66
crypto_shash_setkey+0x2b/0xb0 crypto/shash.c:66
shash_async_setkey+0x10/0x20 crypto/shash.c:223
crypto_ahash_setkey+0x2d/0xa0 crypto/ahash.c:202
crypto_authenc_setkey+0x68/0x100 crypto/authenc.c:96
crypto_aead_setkey+0x2a/0xc0 crypto/aead.c:62
aead_setkey+0xc/0x10 crypto/algif_aead.c:526
alg_setkey crypto/af_alg.c:223 [inline]
alg_setsockopt+0xfe/0x130 crypto/af_alg.c:256
__sys_setsockopt+0x6d/0xd0 net/socket.c:1902
__do_sys_setsockopt net/socket.c:1913 [inline]
__se_sys_setsockopt net/socket.c:1910 [inline]
__x64_sys_setsockopt+0x1f/0x30 net/socket.c:1910
do_syscall_64+0x4a/0x180 arch/x86/entry/common.c:290
entry_SYSCALL_64_after_hwframe+0x49/0xbe
Fixes: e236d4a89a2f ("[CRYPTO] authenc: Move enckeylen into key itself")
Cc: <stable@vger.kernel.org> # v2.6.25+
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-12-17 07:23:22 +00:00
|
|
|
key += rta->rta_len;
|
|
|
|
|
keylen -= rta->rta_len;
|
2007-11-22 15:11:53 +00:00
|
|
|
|
2013-10-15 11:49:30 +00:00
|
|
|
if (keylen < keys->enckeylen)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
keys->authkeylen = keylen - keys->enckeylen;
|
|
|
|
|
keys->authkey = key;
|
|
|
|
|
keys->enckey = key + keys->authkeylen;
|
2007-11-22 15:11:53 +00:00
|
|
|
|
2013-10-15 11:49:30 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_authenc_extractkeys);
|
|
|
|
|
|
|
|
|
|
static int crypto_authenc_setkey(struct crypto_aead *authenc, const u8 *key,
|
|
|
|
|
unsigned int keylen)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
|
|
|
|
|
struct crypto_ahash *auth = ctx->auth;
|
|
|
|
|
struct crypto_ablkcipher *enc = ctx->enc;
|
|
|
|
|
struct crypto_authenc_keys keys;
|
|
|
|
|
int err = -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (crypto_authenc_extractkeys(&keys, key, keylen) != 0)
|
|
|
|
|
goto badkey;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
crypto_ahash_clear_flags(auth, CRYPTO_TFM_REQ_MASK);
|
|
|
|
|
crypto_ahash_set_flags(auth, crypto_aead_get_flags(authenc) &
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
CRYPTO_TFM_REQ_MASK);
|
2013-10-15 11:49:30 +00:00
|
|
|
err = crypto_ahash_setkey(auth, keys.authkey, keys.authkeylen);
|
2009-08-05 09:35:34 +00:00
|
|
|
crypto_aead_set_flags(authenc, crypto_ahash_get_flags(auth) &
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
CRYPTO_TFM_RES_MASK);
|
|
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
crypto_ablkcipher_clear_flags(enc, CRYPTO_TFM_REQ_MASK);
|
|
|
|
|
crypto_ablkcipher_set_flags(enc, crypto_aead_get_flags(authenc) &
|
|
|
|
|
CRYPTO_TFM_REQ_MASK);
|
2013-10-15 11:49:30 +00:00
|
|
|
err = crypto_ablkcipher_setkey(enc, keys.enckey, keys.enckeylen);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
crypto_aead_set_flags(authenc, crypto_ablkcipher_get_flags(enc) &
|
|
|
|
|
CRYPTO_TFM_RES_MASK);
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
return err;
|
2007-11-22 15:11:53 +00:00
|
|
|
|
|
|
|
|
badkey:
|
|
|
|
|
crypto_aead_set_flags(authenc, CRYPTO_TFM_RES_BAD_KEY_LEN);
|
|
|
|
|
goto out;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
}
|
|
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
static void authenc_geniv_ahash_update_done(struct crypto_async_request *areq,
|
|
|
|
|
int err)
|
|
|
|
|
{
|
|
|
|
|
struct aead_request *req = areq->data;
|
|
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
|
|
|
|
|
struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
|
|
|
|
|
struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
|
|
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
ahash_request_set_crypt(ahreq, areq_ctx->sg, ahreq->result,
|
|
|
|
|
areq_ctx->cryptlen);
|
|
|
|
|
ahash_request_set_callback(ahreq, aead_request_flags(req) &
|
|
|
|
|
CRYPTO_TFM_REQ_MAY_SLEEP,
|
|
|
|
|
areq_ctx->complete, req);
|
|
|
|
|
|
|
|
|
|
err = crypto_ahash_finup(ahreq);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
scatterwalk_map_and_copy(ahreq->result, areq_ctx->sg,
|
|
|
|
|
areq_ctx->cryptlen,
|
|
|
|
|
crypto_aead_authsize(authenc), 1);
|
|
|
|
|
|
|
|
|
|
out:
|
2010-04-26 01:14:05 +00:00
|
|
|
authenc_request_complete(req, err);
|
2009-08-05 09:35:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void authenc_geniv_ahash_done(struct crypto_async_request *areq, int err)
|
|
|
|
|
{
|
|
|
|
|
struct aead_request *req = areq->data;
|
|
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
|
|
|
|
|
struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
|
|
|
|
|
struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
|
|
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
scatterwalk_map_and_copy(ahreq->result, areq_ctx->sg,
|
|
|
|
|
areq_ctx->cryptlen,
|
|
|
|
|
crypto_aead_authsize(authenc), 1);
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
aead_request_complete(req, err);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void authenc_verify_ahash_update_done(struct crypto_async_request *areq,
|
|
|
|
|
int err)
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
{
|
2009-08-05 09:35:34 +00:00
|
|
|
u8 *ihash;
|
|
|
|
|
unsigned int authsize;
|
|
|
|
|
struct ablkcipher_request *abreq;
|
|
|
|
|
struct aead_request *req = areq->data;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
|
2009-08-05 09:35:34 +00:00
|
|
|
struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
|
|
|
|
|
struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
|
2010-05-20 09:40:31 +00:00
|
|
|
unsigned int cryptlen = req->cryptlen;
|
2009-08-05 09:35:34 +00:00
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
ahash_request_set_crypt(ahreq, areq_ctx->sg, ahreq->result,
|
|
|
|
|
areq_ctx->cryptlen);
|
|
|
|
|
ahash_request_set_callback(ahreq, aead_request_flags(req) &
|
|
|
|
|
CRYPTO_TFM_REQ_MAY_SLEEP,
|
|
|
|
|
areq_ctx->complete, req);
|
|
|
|
|
|
|
|
|
|
err = crypto_ahash_finup(ahreq);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
authsize = crypto_aead_authsize(authenc);
|
2010-05-20 09:40:31 +00:00
|
|
|
cryptlen -= authsize;
|
2009-08-05 09:35:34 +00:00
|
|
|
ihash = ahreq->result + authsize;
|
|
|
|
|
scatterwalk_map_and_copy(ihash, areq_ctx->sg, areq_ctx->cryptlen,
|
|
|
|
|
authsize, 0);
|
|
|
|
|
|
crypto: crypto_memneq - add equality testing of memory regions w/o timing leaks
commit 6bf37e5aa90f18baf5acf4874bca505dd667c37f upstream.
When comparing MAC hashes, AEAD authentication tags, or other hash
values in the context of authentication or integrity checking, it
is important not to leak timing information to a potential attacker,
i.e. when communication happens over a network.
Bytewise memory comparisons (such as memcmp) are usually optimized so
that they return a nonzero value as soon as a mismatch is found. E.g,
on x86_64/i5 for 512 bytes this can be ~50 cyc for a full mismatch
and up to ~850 cyc for a full match (cold). This early-return behavior
can leak timing information as a side channel, allowing an attacker to
iteratively guess the correct result.
This patch adds a new method crypto_memneq ("memory not equal to each
other") to the crypto API that compares memory areas of the same length
in roughly "constant time" (cache misses could change the timing, but
since they don't reveal information about the content of the strings
being compared, they are effectively benign). Iow, best and worst case
behaviour take the same amount of time to complete (in contrast to
memcmp).
Note that crypto_memneq (unlike memcmp) can only be used to test for
equality or inequality, NOT for lexicographical order. This, however,
is not an issue for its use-cases within the crypto API.
We tried to locate all of the places in the crypto API where memcmp was
being used for authentication or integrity checking, and convert them
over to crypto_memneq.
crypto_memneq is declared noinline, placed in its own source file,
and compiled with optimizations that might increase code size disabled
("Os") because a smart compiler (or LTO) might notice that the return
value is always compared against zero/nonzero, and might then
reintroduce the same early-return optimization that we are trying to
avoid.
Using #pragma or __attribute__ optimization annotations of the code
for disabling optimization was avoided as it seems to be considered
broken or unmaintained for long time in GCC [1]. Therefore, we work
around that by specifying the compile flag for memneq.o directly in
the Makefile. We found that this seems to be most appropriate.
As we use ("Os"), this patch also provides a loop-free "fast-path" for
frequently used 16 byte digests. Similarly to kernel library string
functions, leave an option for future even further optimized architecture
specific assembler implementations.
This was a joint work of James Yonan and Daniel Borkmann. Also thanks
for feedback from Florian Weimer on this and earlier proposals [2].
[1] http://gcc.gnu.org/ml/gcc/2012-07/msg00211.html
[2] https://lkml.org/lkml/2013/2/10/131
Signed-off-by: James Yonan <james@openvpn.net>
Signed-off-by: Daniel Borkmann <dborkman@redhat.com>
Cc: Florian Weimer <fw@deneb.enyo.de>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Cc: Jason A. Donenfeld <Jason@zx2c4.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
2013-09-26 08:20:39 +00:00
|
|
|
err = crypto_memneq(ihash, ahreq->result, authsize) ? -EBADMSG : 0;
|
2009-08-05 09:35:34 +00:00
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
abreq = aead_request_ctx(req);
|
|
|
|
|
ablkcipher_request_set_tfm(abreq, ctx->enc);
|
|
|
|
|
ablkcipher_request_set_callback(abreq, aead_request_flags(req),
|
|
|
|
|
req->base.complete, req->base.data);
|
|
|
|
|
ablkcipher_request_set_crypt(abreq, req->src, req->dst,
|
2010-05-20 09:40:31 +00:00
|
|
|
cryptlen, req->iv);
|
2009-08-05 09:35:34 +00:00
|
|
|
|
|
|
|
|
err = crypto_ablkcipher_decrypt(abreq);
|
|
|
|
|
|
|
|
|
|
out:
|
2010-04-26 01:14:05 +00:00
|
|
|
authenc_request_complete(req, err);
|
2009-08-05 09:35:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void authenc_verify_ahash_done(struct crypto_async_request *areq,
|
|
|
|
|
int err)
|
|
|
|
|
{
|
|
|
|
|
u8 *ihash;
|
|
|
|
|
unsigned int authsize;
|
|
|
|
|
struct ablkcipher_request *abreq;
|
|
|
|
|
struct aead_request *req = areq->data;
|
|
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
|
|
|
|
|
struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
|
|
|
|
|
struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
|
2010-05-20 09:40:31 +00:00
|
|
|
unsigned int cryptlen = req->cryptlen;
|
2009-08-05 09:35:34 +00:00
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
authsize = crypto_aead_authsize(authenc);
|
2010-05-20 09:40:31 +00:00
|
|
|
cryptlen -= authsize;
|
2009-08-05 09:35:34 +00:00
|
|
|
ihash = ahreq->result + authsize;
|
|
|
|
|
scatterwalk_map_and_copy(ihash, areq_ctx->sg, areq_ctx->cryptlen,
|
|
|
|
|
authsize, 0);
|
|
|
|
|
|
crypto: crypto_memneq - add equality testing of memory regions w/o timing leaks
commit 6bf37e5aa90f18baf5acf4874bca505dd667c37f upstream.
When comparing MAC hashes, AEAD authentication tags, or other hash
values in the context of authentication or integrity checking, it
is important not to leak timing information to a potential attacker,
i.e. when communication happens over a network.
Bytewise memory comparisons (such as memcmp) are usually optimized so
that they return a nonzero value as soon as a mismatch is found. E.g,
on x86_64/i5 for 512 bytes this can be ~50 cyc for a full mismatch
and up to ~850 cyc for a full match (cold). This early-return behavior
can leak timing information as a side channel, allowing an attacker to
iteratively guess the correct result.
This patch adds a new method crypto_memneq ("memory not equal to each
other") to the crypto API that compares memory areas of the same length
in roughly "constant time" (cache misses could change the timing, but
since they don't reveal information about the content of the strings
being compared, they are effectively benign). Iow, best and worst case
behaviour take the same amount of time to complete (in contrast to
memcmp).
Note that crypto_memneq (unlike memcmp) can only be used to test for
equality or inequality, NOT for lexicographical order. This, however,
is not an issue for its use-cases within the crypto API.
We tried to locate all of the places in the crypto API where memcmp was
being used for authentication or integrity checking, and convert them
over to crypto_memneq.
crypto_memneq is declared noinline, placed in its own source file,
and compiled with optimizations that might increase code size disabled
("Os") because a smart compiler (or LTO) might notice that the return
value is always compared against zero/nonzero, and might then
reintroduce the same early-return optimization that we are trying to
avoid.
Using #pragma or __attribute__ optimization annotations of the code
for disabling optimization was avoided as it seems to be considered
broken or unmaintained for long time in GCC [1]. Therefore, we work
around that by specifying the compile flag for memneq.o directly in
the Makefile. We found that this seems to be most appropriate.
As we use ("Os"), this patch also provides a loop-free "fast-path" for
frequently used 16 byte digests. Similarly to kernel library string
functions, leave an option for future even further optimized architecture
specific assembler implementations.
This was a joint work of James Yonan and Daniel Borkmann. Also thanks
for feedback from Florian Weimer on this and earlier proposals [2].
[1] http://gcc.gnu.org/ml/gcc/2012-07/msg00211.html
[2] https://lkml.org/lkml/2013/2/10/131
Signed-off-by: James Yonan <james@openvpn.net>
Signed-off-by: Daniel Borkmann <dborkman@redhat.com>
Cc: Florian Weimer <fw@deneb.enyo.de>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Cc: Jason A. Donenfeld <Jason@zx2c4.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
2013-09-26 08:20:39 +00:00
|
|
|
err = crypto_memneq(ihash, ahreq->result, authsize) ? -EBADMSG : 0;
|
2009-08-05 09:35:34 +00:00
|
|
|
if (err)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
abreq = aead_request_ctx(req);
|
|
|
|
|
ablkcipher_request_set_tfm(abreq, ctx->enc);
|
|
|
|
|
ablkcipher_request_set_callback(abreq, aead_request_flags(req),
|
|
|
|
|
req->base.complete, req->base.data);
|
|
|
|
|
ablkcipher_request_set_crypt(abreq, req->src, req->dst,
|
2010-05-20 09:40:31 +00:00
|
|
|
cryptlen, req->iv);
|
2009-08-05 09:35:34 +00:00
|
|
|
|
|
|
|
|
err = crypto_ablkcipher_decrypt(abreq);
|
|
|
|
|
|
|
|
|
|
out:
|
2010-04-26 01:14:05 +00:00
|
|
|
authenc_request_complete(req, err);
|
2009-08-05 09:35:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static u8 *crypto_authenc_ahash_fb(struct aead_request *req, unsigned int flags)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
|
|
|
|
|
struct crypto_ahash *auth = ctx->auth;
|
|
|
|
|
struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
|
|
|
|
|
struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
|
|
|
|
|
u8 *hash = areq_ctx->tail;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
int err;
|
|
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
hash = (u8 *)ALIGN((unsigned long)hash + crypto_ahash_alignmask(auth),
|
|
|
|
|
crypto_ahash_alignmask(auth) + 1);
|
|
|
|
|
|
|
|
|
|
ahash_request_set_tfm(ahreq, auth);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
err = crypto_ahash_init(ahreq);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
if (err)
|
2009-08-05 09:35:34 +00:00
|
|
|
return ERR_PTR(err);
|
|
|
|
|
|
|
|
|
|
ahash_request_set_crypt(ahreq, req->assoc, hash, req->assoclen);
|
|
|
|
|
ahash_request_set_callback(ahreq, aead_request_flags(req) & flags,
|
|
|
|
|
areq_ctx->update_complete, req);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
err = crypto_ahash_update(ahreq);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
if (err)
|
2009-08-05 09:35:34 +00:00
|
|
|
return ERR_PTR(err);
|
|
|
|
|
|
|
|
|
|
ahash_request_set_crypt(ahreq, areq_ctx->sg, hash,
|
|
|
|
|
areq_ctx->cryptlen);
|
|
|
|
|
ahash_request_set_callback(ahreq, aead_request_flags(req) & flags,
|
|
|
|
|
areq_ctx->complete, req);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
err = crypto_ahash_finup(ahreq);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
if (err)
|
2009-08-05 09:35:34 +00:00
|
|
|
return ERR_PTR(err);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
return hash;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static u8 *crypto_authenc_ahash(struct aead_request *req, unsigned int flags)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
|
|
|
|
|
struct crypto_ahash *auth = ctx->auth;
|
|
|
|
|
struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
|
|
|
|
|
struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
|
|
|
|
|
u8 *hash = areq_ctx->tail;
|
|
|
|
|
int err;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
hash = (u8 *)ALIGN((unsigned long)hash + crypto_ahash_alignmask(auth),
|
|
|
|
|
crypto_ahash_alignmask(auth) + 1);
|
|
|
|
|
|
|
|
|
|
ahash_request_set_tfm(ahreq, auth);
|
|
|
|
|
ahash_request_set_crypt(ahreq, areq_ctx->sg, hash,
|
|
|
|
|
areq_ctx->cryptlen);
|
|
|
|
|
ahash_request_set_callback(ahreq, aead_request_flags(req) & flags,
|
|
|
|
|
areq_ctx->complete, req);
|
|
|
|
|
|
|
|
|
|
err = crypto_ahash_digest(ahreq);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
if (err)
|
2007-12-10 08:15:41 +00:00
|
|
|
return ERR_PTR(err);
|
|
|
|
|
|
|
|
|
|
return hash;
|
|
|
|
|
}
|
|
|
|
|
|
2007-12-10 08:20:24 +00:00
|
|
|
static int crypto_authenc_genicv(struct aead_request *req, u8 *iv,
|
|
|
|
|
unsigned int flags)
|
2007-12-10 08:15:41 +00:00
|
|
|
{
|
|
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
2009-08-05 09:35:34 +00:00
|
|
|
struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
|
2007-12-10 08:15:41 +00:00
|
|
|
struct scatterlist *dst = req->dst;
|
2009-08-05 09:35:34 +00:00
|
|
|
struct scatterlist *assoc = req->assoc;
|
|
|
|
|
struct scatterlist *cipher = areq_ctx->cipher;
|
|
|
|
|
struct scatterlist *asg = areq_ctx->asg;
|
2007-12-10 08:20:24 +00:00
|
|
|
unsigned int ivsize = crypto_aead_ivsize(authenc);
|
2009-08-05 09:35:34 +00:00
|
|
|
unsigned int cryptlen = req->cryptlen;
|
|
|
|
|
authenc_ahash_t authenc_ahash_fn = crypto_authenc_ahash_fb;
|
|
|
|
|
struct page *dstp;
|
2007-12-10 08:20:24 +00:00
|
|
|
u8 *vdst;
|
2007-12-10 08:15:41 +00:00
|
|
|
u8 *hash;
|
|
|
|
|
|
2007-12-10 08:20:24 +00:00
|
|
|
dstp = sg_page(dst);
|
|
|
|
|
vdst = PageHighMem(dstp) ? NULL : page_address(dstp) + dst->offset;
|
|
|
|
|
|
2009-01-13 00:26:18 +00:00
|
|
|
if (ivsize) {
|
|
|
|
|
sg_init_table(cipher, 2);
|
|
|
|
|
sg_set_buf(cipher, iv, ivsize);
|
2010-11-22 10:26:54 +00:00
|
|
|
scatterwalk_crypto_chain(cipher, dst, vdst == iv + ivsize, 2);
|
2009-01-13 00:26:18 +00:00
|
|
|
dst = cipher;
|
2009-08-05 09:35:34 +00:00
|
|
|
cryptlen += ivsize;
|
2009-01-13 00:26:18 +00:00
|
|
|
}
|
2007-12-10 08:20:24 +00:00
|
|
|
|
2012-09-11 04:05:45 +00:00
|
|
|
if (req->assoclen && sg_is_last(assoc)) {
|
2009-08-05 09:35:34 +00:00
|
|
|
authenc_ahash_fn = crypto_authenc_ahash;
|
|
|
|
|
sg_init_table(asg, 2);
|
|
|
|
|
sg_set_page(asg, sg_page(assoc), assoc->length, assoc->offset);
|
2010-11-22 10:26:54 +00:00
|
|
|
scatterwalk_crypto_chain(asg, dst, 0, 2);
|
2009-08-05 09:35:34 +00:00
|
|
|
dst = asg;
|
|
|
|
|
cryptlen += req->assoclen;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
areq_ctx->cryptlen = cryptlen;
|
|
|
|
|
areq_ctx->sg = dst;
|
|
|
|
|
|
|
|
|
|
areq_ctx->complete = authenc_geniv_ahash_done;
|
|
|
|
|
areq_ctx->update_complete = authenc_geniv_ahash_update_done;
|
|
|
|
|
|
|
|
|
|
hash = authenc_ahash_fn(req, flags);
|
2007-12-10 08:15:41 +00:00
|
|
|
if (IS_ERR(hash))
|
|
|
|
|
return PTR_ERR(hash);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2009-01-13 00:26:18 +00:00
|
|
|
scatterwalk_map_and_copy(hash, dst, cryptlen,
|
2007-12-02 07:49:21 +00:00
|
|
|
crypto_aead_authsize(authenc), 1);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void crypto_authenc_encrypt_done(struct crypto_async_request *req,
|
|
|
|
|
int err)
|
|
|
|
|
{
|
2008-08-22 15:04:06 +00:00
|
|
|
struct aead_request *areq = req->data;
|
|
|
|
|
|
2007-12-10 08:20:24 +00:00
|
|
|
if (!err) {
|
|
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(areq);
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
|
2013-11-12 17:46:04 +00:00
|
|
|
struct authenc_request_ctx *areq_ctx = aead_request_ctx(areq);
|
|
|
|
|
struct ablkcipher_request *abreq = (void *)(areq_ctx->tail
|
|
|
|
|
+ ctx->reqoff);
|
|
|
|
|
u8 *iv = (u8 *)abreq - crypto_ablkcipher_ivsize(ctx->enc);
|
2007-12-10 08:20:24 +00:00
|
|
|
|
|
|
|
|
err = crypto_authenc_genicv(areq, iv, 0);
|
|
|
|
|
}
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2010-04-26 01:14:05 +00:00
|
|
|
authenc_request_complete(areq, err);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int crypto_authenc_encrypt(struct aead_request *req)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
|
2010-03-03 14:41:08 +00:00
|
|
|
struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
|
2007-12-10 08:20:24 +00:00
|
|
|
struct crypto_ablkcipher *enc = ctx->enc;
|
|
|
|
|
struct scatterlist *dst = req->dst;
|
|
|
|
|
unsigned int cryptlen = req->cryptlen;
|
2010-03-03 14:41:08 +00:00
|
|
|
struct ablkcipher_request *abreq = (void *)(areq_ctx->tail
|
|
|
|
|
+ ctx->reqoff);
|
|
|
|
|
u8 *iv = (u8 *)abreq - crypto_ablkcipher_ivsize(enc);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
int err;
|
|
|
|
|
|
2007-12-10 08:20:24 +00:00
|
|
|
ablkcipher_request_set_tfm(abreq, enc);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
ablkcipher_request_set_callback(abreq, aead_request_flags(req),
|
|
|
|
|
crypto_authenc_encrypt_done, req);
|
2007-12-10 08:20:24 +00:00
|
|
|
ablkcipher_request_set_crypt(abreq, req->src, dst, cryptlen, req->iv);
|
|
|
|
|
|
|
|
|
|
memcpy(iv, req->iv, crypto_aead_ivsize(authenc));
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
|
|
|
|
err = crypto_ablkcipher_encrypt(abreq);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
2007-12-10 08:20:24 +00:00
|
|
|
return crypto_authenc_genicv(req, iv, CRYPTO_TFM_REQ_MAY_SLEEP);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void crypto_authenc_givencrypt_done(struct crypto_async_request *req,
|
|
|
|
|
int err)
|
|
|
|
|
{
|
2008-08-22 15:04:06 +00:00
|
|
|
struct aead_request *areq = req->data;
|
|
|
|
|
|
2007-12-10 08:20:24 +00:00
|
|
|
if (!err) {
|
2008-04-29 13:44:28 +00:00
|
|
|
struct skcipher_givcrypt_request *greq = aead_request_ctx(areq);
|
2007-12-10 08:20:24 +00:00
|
|
|
|
2008-04-29 13:44:28 +00:00
|
|
|
err = crypto_authenc_genicv(areq, greq->giv, 0);
|
2007-12-10 08:20:24 +00:00
|
|
|
}
|
|
|
|
|
|
2010-04-26 01:14:05 +00:00
|
|
|
authenc_request_complete(areq, err);
|
2007-12-10 08:20:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int crypto_authenc_givencrypt(struct aead_givcrypt_request *req)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_aead *authenc = aead_givcrypt_reqtfm(req);
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
|
|
|
|
|
struct aead_request *areq = &req->areq;
|
|
|
|
|
struct skcipher_givcrypt_request *greq = aead_request_ctx(areq);
|
|
|
|
|
u8 *iv = req->giv;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
skcipher_givcrypt_set_tfm(greq, ctx->enc);
|
|
|
|
|
skcipher_givcrypt_set_callback(greq, aead_request_flags(areq),
|
|
|
|
|
crypto_authenc_givencrypt_done, areq);
|
|
|
|
|
skcipher_givcrypt_set_crypt(greq, areq->src, areq->dst, areq->cryptlen,
|
|
|
|
|
areq->iv);
|
|
|
|
|
skcipher_givcrypt_set_giv(greq, iv, req->seq);
|
|
|
|
|
|
|
|
|
|
err = crypto_skcipher_givencrypt(greq);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
return crypto_authenc_genicv(areq, iv, CRYPTO_TFM_REQ_MAY_SLEEP);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
}
|
|
|
|
|
|
2007-12-04 09:04:21 +00:00
|
|
|
static int crypto_authenc_verify(struct aead_request *req,
|
2009-08-05 09:35:34 +00:00
|
|
|
authenc_ahash_t authenc_ahash_fn)
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
{
|
|
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
2009-08-05 09:35:34 +00:00
|
|
|
struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
|
2007-12-10 08:15:41 +00:00
|
|
|
u8 *ohash;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
u8 *ihash;
|
|
|
|
|
unsigned int authsize;
|
|
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
areq_ctx->complete = authenc_verify_ahash_done;
|
2010-03-02 13:59:54 +00:00
|
|
|
areq_ctx->update_complete = authenc_verify_ahash_update_done;
|
2009-08-05 09:35:34 +00:00
|
|
|
|
|
|
|
|
ohash = authenc_ahash_fn(req, CRYPTO_TFM_REQ_MAY_SLEEP);
|
2007-12-10 08:15:41 +00:00
|
|
|
if (IS_ERR(ohash))
|
|
|
|
|
return PTR_ERR(ohash);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2007-12-02 07:49:21 +00:00
|
|
|
authsize = crypto_aead_authsize(authenc);
|
2007-12-10 08:15:41 +00:00
|
|
|
ihash = ohash + authsize;
|
2009-08-05 09:35:34 +00:00
|
|
|
scatterwalk_map_and_copy(ihash, areq_ctx->sg, areq_ctx->cryptlen,
|
|
|
|
|
authsize, 0);
|
crypto: crypto_memneq - add equality testing of memory regions w/o timing leaks
commit 6bf37e5aa90f18baf5acf4874bca505dd667c37f upstream.
When comparing MAC hashes, AEAD authentication tags, or other hash
values in the context of authentication or integrity checking, it
is important not to leak timing information to a potential attacker,
i.e. when communication happens over a network.
Bytewise memory comparisons (such as memcmp) are usually optimized so
that they return a nonzero value as soon as a mismatch is found. E.g,
on x86_64/i5 for 512 bytes this can be ~50 cyc for a full mismatch
and up to ~850 cyc for a full match (cold). This early-return behavior
can leak timing information as a side channel, allowing an attacker to
iteratively guess the correct result.
This patch adds a new method crypto_memneq ("memory not equal to each
other") to the crypto API that compares memory areas of the same length
in roughly "constant time" (cache misses could change the timing, but
since they don't reveal information about the content of the strings
being compared, they are effectively benign). Iow, best and worst case
behaviour take the same amount of time to complete (in contrast to
memcmp).
Note that crypto_memneq (unlike memcmp) can only be used to test for
equality or inequality, NOT for lexicographical order. This, however,
is not an issue for its use-cases within the crypto API.
We tried to locate all of the places in the crypto API where memcmp was
being used for authentication or integrity checking, and convert them
over to crypto_memneq.
crypto_memneq is declared noinline, placed in its own source file,
and compiled with optimizations that might increase code size disabled
("Os") because a smart compiler (or LTO) might notice that the return
value is always compared against zero/nonzero, and might then
reintroduce the same early-return optimization that we are trying to
avoid.
Using #pragma or __attribute__ optimization annotations of the code
for disabling optimization was avoided as it seems to be considered
broken or unmaintained for long time in GCC [1]. Therefore, we work
around that by specifying the compile flag for memneq.o directly in
the Makefile. We found that this seems to be most appropriate.
As we use ("Os"), this patch also provides a loop-free "fast-path" for
frequently used 16 byte digests. Similarly to kernel library string
functions, leave an option for future even further optimized architecture
specific assembler implementations.
This was a joint work of James Yonan and Daniel Borkmann. Also thanks
for feedback from Florian Weimer on this and earlier proposals [2].
[1] http://gcc.gnu.org/ml/gcc/2012-07/msg00211.html
[2] https://lkml.org/lkml/2013/2/10/131
Signed-off-by: James Yonan <james@openvpn.net>
Signed-off-by: Daniel Borkmann <dborkman@redhat.com>
Cc: Florian Weimer <fw@deneb.enyo.de>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Cc: Jason A. Donenfeld <Jason@zx2c4.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
2013-09-26 08:20:39 +00:00
|
|
|
return crypto_memneq(ihash, ohash, authsize) ? -EBADMSG : 0;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
}
|
|
|
|
|
|
2007-12-10 08:20:24 +00:00
|
|
|
static int crypto_authenc_iverify(struct aead_request *req, u8 *iv,
|
|
|
|
|
unsigned int cryptlen)
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
{
|
2007-12-10 08:20:24 +00:00
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
2009-08-05 09:35:34 +00:00
|
|
|
struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
|
2007-12-10 08:20:24 +00:00
|
|
|
struct scatterlist *src = req->src;
|
2009-08-05 09:35:34 +00:00
|
|
|
struct scatterlist *assoc = req->assoc;
|
|
|
|
|
struct scatterlist *cipher = areq_ctx->cipher;
|
|
|
|
|
struct scatterlist *asg = areq_ctx->asg;
|
2007-12-10 08:20:24 +00:00
|
|
|
unsigned int ivsize = crypto_aead_ivsize(authenc);
|
2009-08-05 09:35:34 +00:00
|
|
|
authenc_ahash_t authenc_ahash_fn = crypto_authenc_ahash_fb;
|
|
|
|
|
struct page *srcp;
|
2007-12-10 08:20:24 +00:00
|
|
|
u8 *vsrc;
|
|
|
|
|
|
|
|
|
|
srcp = sg_page(src);
|
|
|
|
|
vsrc = PageHighMem(srcp) ? NULL : page_address(srcp) + src->offset;
|
|
|
|
|
|
2009-01-13 00:26:18 +00:00
|
|
|
if (ivsize) {
|
|
|
|
|
sg_init_table(cipher, 2);
|
|
|
|
|
sg_set_buf(cipher, iv, ivsize);
|
2010-11-22 10:26:54 +00:00
|
|
|
scatterwalk_crypto_chain(cipher, src, vsrc == iv + ivsize, 2);
|
2009-01-13 00:26:18 +00:00
|
|
|
src = cipher;
|
2009-08-05 09:35:34 +00:00
|
|
|
cryptlen += ivsize;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-11 04:05:45 +00:00
|
|
|
if (req->assoclen && sg_is_last(assoc)) {
|
2009-08-05 09:35:34 +00:00
|
|
|
authenc_ahash_fn = crypto_authenc_ahash;
|
|
|
|
|
sg_init_table(asg, 2);
|
|
|
|
|
sg_set_page(asg, sg_page(assoc), assoc->length, assoc->offset);
|
2010-11-22 10:26:54 +00:00
|
|
|
scatterwalk_crypto_chain(asg, src, 0, 2);
|
2009-08-05 09:35:34 +00:00
|
|
|
src = asg;
|
|
|
|
|
cryptlen += req->assoclen;
|
2009-01-13 00:26:18 +00:00
|
|
|
}
|
2007-12-10 08:20:24 +00:00
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
areq_ctx->cryptlen = cryptlen;
|
|
|
|
|
areq_ctx->sg = src;
|
|
|
|
|
|
|
|
|
|
return crypto_authenc_verify(req, authenc_ahash_fn);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int crypto_authenc_decrypt(struct aead_request *req)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
|
|
|
|
|
struct ablkcipher_request *abreq = aead_request_ctx(req);
|
2007-12-04 09:04:21 +00:00
|
|
|
unsigned int cryptlen = req->cryptlen;
|
|
|
|
|
unsigned int authsize = crypto_aead_authsize(authenc);
|
2007-12-10 08:20:24 +00:00
|
|
|
u8 *iv = req->iv;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
int err;
|
|
|
|
|
|
2007-12-04 09:04:21 +00:00
|
|
|
if (cryptlen < authsize)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
cryptlen -= authsize;
|
|
|
|
|
|
2007-12-10 08:20:24 +00:00
|
|
|
err = crypto_authenc_iverify(req, iv, cryptlen);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
ablkcipher_request_set_tfm(abreq, ctx->enc);
|
|
|
|
|
ablkcipher_request_set_callback(abreq, aead_request_flags(req),
|
2007-12-10 08:20:24 +00:00
|
|
|
req->base.complete, req->base.data);
|
|
|
|
|
ablkcipher_request_set_crypt(abreq, req->src, req->dst, cryptlen, iv);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
|
|
|
|
return crypto_ablkcipher_decrypt(abreq);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int crypto_authenc_init_tfm(struct crypto_tfm *tfm)
|
|
|
|
|
{
|
2009-08-05 09:35:34 +00:00
|
|
|
struct crypto_instance *inst = crypto_tfm_alg_instance(tfm);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
struct authenc_instance_ctx *ictx = crypto_instance_ctx(inst);
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_tfm_ctx(tfm);
|
2009-08-05 09:35:34 +00:00
|
|
|
struct crypto_ahash *auth;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
struct crypto_ablkcipher *enc;
|
|
|
|
|
int err;
|
|
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
auth = crypto_spawn_ahash(&ictx->auth);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
if (IS_ERR(auth))
|
|
|
|
|
return PTR_ERR(auth);
|
|
|
|
|
|
2007-12-17 12:12:49 +00:00
|
|
|
enc = crypto_spawn_skcipher(&ictx->enc);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
err = PTR_ERR(enc);
|
|
|
|
|
if (IS_ERR(enc))
|
2009-08-05 09:35:34 +00:00
|
|
|
goto err_free_ahash;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
|
|
|
|
ctx->auth = auth;
|
|
|
|
|
ctx->enc = enc;
|
2010-02-16 12:27:20 +00:00
|
|
|
|
2010-03-03 14:41:08 +00:00
|
|
|
ctx->reqoff = ALIGN(2 * crypto_ahash_digestsize(auth) +
|
|
|
|
|
crypto_ahash_alignmask(auth),
|
|
|
|
|
crypto_ahash_alignmask(auth) + 1) +
|
|
|
|
|
crypto_ablkcipher_ivsize(enc);
|
|
|
|
|
|
|
|
|
|
tfm->crt_aead.reqsize = sizeof(struct authenc_request_ctx) +
|
|
|
|
|
ctx->reqoff +
|
|
|
|
|
max_t(unsigned int,
|
|
|
|
|
crypto_ahash_reqsize(auth) +
|
2010-02-16 12:27:20 +00:00
|
|
|
sizeof(struct ahash_request),
|
2009-08-05 09:35:34 +00:00
|
|
|
sizeof(struct skcipher_givcrypt_request) +
|
2010-03-03 14:41:08 +00:00
|
|
|
crypto_ablkcipher_reqsize(enc));
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
err_free_ahash:
|
|
|
|
|
crypto_free_ahash(auth);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void crypto_authenc_exit_tfm(struct crypto_tfm *tfm)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_authenc_ctx *ctx = crypto_tfm_ctx(tfm);
|
|
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
crypto_free_ahash(ctx->auth);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
crypto_free_ablkcipher(ctx->enc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct crypto_instance *crypto_authenc_alloc(struct rtattr **tb)
|
|
|
|
|
{
|
2007-12-17 12:12:49 +00:00
|
|
|
struct crypto_attr_type *algt;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
struct crypto_instance *inst;
|
2009-08-05 09:35:34 +00:00
|
|
|
struct hash_alg_common *auth;
|
|
|
|
|
struct crypto_alg *auth_base;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
struct crypto_alg *enc;
|
|
|
|
|
struct authenc_instance_ctx *ctx;
|
2007-12-17 12:12:49 +00:00
|
|
|
const char *enc_name;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
int err;
|
|
|
|
|
|
2007-12-17 12:12:49 +00:00
|
|
|
algt = crypto_get_attr_type(tb);
|
|
|
|
|
if (IS_ERR(algt))
|
2013-01-22 11:29:26 +00:00
|
|
|
return ERR_CAST(algt);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2007-12-17 12:12:49 +00:00
|
|
|
if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
|
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
auth = ahash_attr_alg(tb[1], CRYPTO_ALG_TYPE_HASH,
|
|
|
|
|
CRYPTO_ALG_TYPE_AHASH_MASK);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
if (IS_ERR(auth))
|
2010-05-26 00:36:51 +00:00
|
|
|
return ERR_CAST(auth);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
auth_base = &auth->base;
|
|
|
|
|
|
2007-12-17 12:12:49 +00:00
|
|
|
enc_name = crypto_attr_alg_name(tb[2]);
|
|
|
|
|
err = PTR_ERR(enc_name);
|
|
|
|
|
if (IS_ERR(enc_name))
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
goto out_put_auth;
|
|
|
|
|
|
|
|
|
|
inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
|
|
|
|
|
err = -ENOMEM;
|
|
|
|
|
if (!inst)
|
2007-12-17 12:12:49 +00:00
|
|
|
goto out_put_auth;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
|
|
|
|
ctx = crypto_instance_ctx(inst);
|
|
|
|
|
|
2009-08-05 09:35:34 +00:00
|
|
|
err = crypto_init_ahash_spawn(&ctx->auth, auth, inst);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
if (err)
|
|
|
|
|
goto err_free_inst;
|
|
|
|
|
|
2007-12-17 12:12:49 +00:00
|
|
|
crypto_set_skcipher_spawn(&ctx->enc, inst);
|
|
|
|
|
err = crypto_grab_skcipher(&ctx->enc, enc_name, 0,
|
|
|
|
|
crypto_requires_sync(algt->type,
|
|
|
|
|
algt->mask));
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
if (err)
|
|
|
|
|
goto err_drop_auth;
|
|
|
|
|
|
2007-12-17 12:12:49 +00:00
|
|
|
enc = crypto_skcipher_spawn_alg(&ctx->enc);
|
|
|
|
|
|
|
|
|
|
err = -ENAMETOOLONG;
|
|
|
|
|
if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME,
|
2009-08-05 09:35:34 +00:00
|
|
|
"authenc(%s,%s)", auth_base->cra_name, enc->cra_name) >=
|
2007-12-17 12:12:49 +00:00
|
|
|
CRYPTO_MAX_ALG_NAME)
|
|
|
|
|
goto err_drop_enc;
|
|
|
|
|
|
|
|
|
|
if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME,
|
2009-08-05 09:35:34 +00:00
|
|
|
"authenc(%s,%s)", auth_base->cra_driver_name,
|
2007-12-17 12:12:49 +00:00
|
|
|
enc->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
|
|
|
|
|
goto err_drop_enc;
|
|
|
|
|
|
|
|
|
|
inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD;
|
|
|
|
|
inst->alg.cra_flags |= enc->cra_flags & CRYPTO_ALG_ASYNC;
|
2009-08-05 09:35:34 +00:00
|
|
|
inst->alg.cra_priority = enc->cra_priority *
|
|
|
|
|
10 + auth_base->cra_priority;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
inst->alg.cra_blocksize = enc->cra_blocksize;
|
2009-08-05 09:35:34 +00:00
|
|
|
inst->alg.cra_alignmask = auth_base->cra_alignmask | enc->cra_alignmask;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
inst->alg.cra_type = &crypto_aead_type;
|
|
|
|
|
|
2007-12-10 02:54:44 +00:00
|
|
|
inst->alg.cra_aead.ivsize = enc->cra_ablkcipher.ivsize;
|
2009-08-05 09:35:34 +00:00
|
|
|
inst->alg.cra_aead.maxauthsize = auth->digestsize;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
|
|
|
|
inst->alg.cra_ctxsize = sizeof(struct crypto_authenc_ctx);
|
|
|
|
|
|
|
|
|
|
inst->alg.cra_init = crypto_authenc_init_tfm;
|
|
|
|
|
inst->alg.cra_exit = crypto_authenc_exit_tfm;
|
|
|
|
|
|
|
|
|
|
inst->alg.cra_aead.setkey = crypto_authenc_setkey;
|
|
|
|
|
inst->alg.cra_aead.encrypt = crypto_authenc_encrypt;
|
|
|
|
|
inst->alg.cra_aead.decrypt = crypto_authenc_decrypt;
|
2007-12-10 08:20:24 +00:00
|
|
|
inst->alg.cra_aead.givencrypt = crypto_authenc_givencrypt;
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
|
|
|
|
|
out:
|
2009-08-05 09:35:34 +00:00
|
|
|
crypto_mod_put(auth_base);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
return inst;
|
|
|
|
|
|
2007-12-17 12:12:49 +00:00
|
|
|
err_drop_enc:
|
|
|
|
|
crypto_drop_skcipher(&ctx->enc);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
err_drop_auth:
|
2009-08-05 09:35:34 +00:00
|
|
|
crypto_drop_ahash(&ctx->auth);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
err_free_inst:
|
|
|
|
|
kfree(inst);
|
2007-12-17 12:12:49 +00:00
|
|
|
out_put_auth:
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
inst = ERR_PTR(err);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void crypto_authenc_free(struct crypto_instance *inst)
|
|
|
|
|
{
|
|
|
|
|
struct authenc_instance_ctx *ctx = crypto_instance_ctx(inst);
|
|
|
|
|
|
2007-12-17 12:12:49 +00:00
|
|
|
crypto_drop_skcipher(&ctx->enc);
|
2009-08-05 09:35:34 +00:00
|
|
|
crypto_drop_ahash(&ctx->auth);
|
[CRYPTO] aead: Add authenc
This patch adds the authenc algorithm which constructs an AEAD algorithm
from an asynchronous block cipher and a hash. The construction is done
by concatenating the encrypted result from the cipher with the output
from the hash, as is used by the IPsec ESP protocol.
The authenc algorithm exists as a template with four parameters:
authenc(auth, authsize, enc, enckeylen).
The authentication algorithm, the authentication size (i.e., truncating
the output of the authentication algorithm), the encryption algorithm,
and the encryption key length. Both the size field and the key length
field are in bytes. For example, AES-128 with SHA1-HMAC would be
represented by
authenc(hmac(sha1), 12, cbc(aes), 16)
The key for the authenc algorithm is the concatenation of the keys for
the authentication algorithm with the encryption algorithm. For the
above example, if a key of length 36 bytes is given, then hmac(sha1)
would receive the first 20 bytes while the last 16 would be given to
cbc(aes).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-08-30 08:24:15 +00:00
|
|
|
kfree(inst);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct crypto_template crypto_authenc_tmpl = {
|
|
|
|
|
.name = "authenc",
|
|
|
|
|
.alloc = crypto_authenc_alloc,
|
|
|
|
|
.free = crypto_authenc_free,
|
|
|
|
|
.module = THIS_MODULE,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int __init crypto_authenc_module_init(void)
|
|
|
|
|
{
|
|
|
|
|
return crypto_register_template(&crypto_authenc_tmpl);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __exit crypto_authenc_module_exit(void)
|
|
|
|
|
{
|
|
|
|
|
crypto_unregister_template(&crypto_authenc_tmpl);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
module_init(crypto_authenc_module_init);
|
|
|
|
|
module_exit(crypto_authenc_module_exit);
|
|
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
MODULE_DESCRIPTION("Simple AEAD wrapper for IPsec");
|
2014-11-25 00:32:38 +00:00
|
|
|
MODULE_ALIAS_CRYPTO("authenc");
|
