2019-05-27 06:55:01 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
/*
|
|
|
|
|
* CTR: Counter mode
|
|
|
|
|
*
|
|
|
|
|
* (C) Copyright IBM Corp. 2007 - Joy Latten <latten@us.ibm.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <crypto/algapi.h>
|
2007-12-17 13:34:32 +00:00
|
|
|
#include <crypto/ctr.h>
|
2012-12-28 10:04:58 +00:00
|
|
|
#include <crypto/internal/skcipher.h>
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
#include <linux/err.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
|
2007-12-17 13:34:32 +00:00
|
|
|
struct crypto_rfc3686_ctx {
|
2016-07-12 05:17:37 +00:00
|
|
|
struct crypto_skcipher *child;
|
2007-12-17 13:34:32 +00:00
|
|
|
u8 nonce[CTR_RFC3686_NONCE_SIZE];
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
};
|
|
|
|
|
|
2012-12-28 10:04:58 +00:00
|
|
|
struct crypto_rfc3686_req_ctx {
|
|
|
|
|
u8 iv[CTR_RFC3686_BLOCK_SIZE];
|
2016-07-12 05:17:37 +00:00
|
|
|
struct skcipher_request subreq CRYPTO_MINALIGN_ATTR;
|
2012-12-28 10:04:58 +00:00
|
|
|
};
|
|
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
static void crypto_ctr_crypt_final(struct skcipher_walk *walk,
|
2007-12-17 13:34:32 +00:00
|
|
|
struct crypto_cipher *tfm)
|
2007-11-29 13:23:53 +00:00
|
|
|
{
|
|
|
|
|
unsigned int bsize = crypto_cipher_blocksize(tfm);
|
2007-12-17 13:34:32 +00:00
|
|
|
unsigned long alignmask = crypto_cipher_alignmask(tfm);
|
|
|
|
|
u8 *ctrblk = walk->iv;
|
2018-04-09 13:54:47 +00:00
|
|
|
u8 tmp[MAX_CIPHER_BLOCKSIZE + MAX_CIPHER_ALIGNMASK];
|
2007-12-17 13:34:32 +00:00
|
|
|
u8 *keystream = PTR_ALIGN(tmp + 0, alignmask + 1);
|
2007-11-29 13:23:53 +00:00
|
|
|
u8 *src = walk->src.virt.addr;
|
|
|
|
|
u8 *dst = walk->dst.virt.addr;
|
|
|
|
|
unsigned int nbytes = walk->nbytes;
|
|
|
|
|
|
|
|
|
|
crypto_cipher_encrypt_one(tfm, keystream, ctrblk);
|
crypto: algapi - make crypto_xor() take separate dst and src arguments
There are quite a number of occurrences in the kernel of the pattern
if (dst != src)
memcpy(dst, src, walk.total % AES_BLOCK_SIZE);
crypto_xor(dst, final, walk.total % AES_BLOCK_SIZE);
or
crypto_xor(keystream, src, nbytes);
memcpy(dst, keystream, nbytes);
where crypto_xor() is preceded or followed by a memcpy() invocation
that is only there because crypto_xor() uses its output parameter as
one of the inputs. To avoid having to add new instances of this pattern
in the arm64 code, which will be refactored to implement non-SIMD
fallbacks, add an alternative implementation called crypto_xor_cpy(),
taking separate input and output arguments. This removes the need for
the separate memcpy().
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2017-07-24 10:28:04 +00:00
|
|
|
crypto_xor_cpy(dst, keystream, src, nbytes);
|
2007-12-17 13:34:32 +00:00
|
|
|
|
|
|
|
|
crypto_inc(ctrblk, bsize);
|
2007-11-29 13:23:53 +00:00
|
|
|
}
|
|
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
static int crypto_ctr_crypt_segment(struct skcipher_walk *walk,
|
2007-12-17 13:34:32 +00:00
|
|
|
struct crypto_cipher *tfm)
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
{
|
|
|
|
|
void (*fn)(struct crypto_tfm *, u8 *, const u8 *) =
|
|
|
|
|
crypto_cipher_alg(tfm)->cia_encrypt;
|
|
|
|
|
unsigned int bsize = crypto_cipher_blocksize(tfm);
|
2007-12-17 13:34:32 +00:00
|
|
|
u8 *ctrblk = walk->iv;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
u8 *src = walk->src.virt.addr;
|
|
|
|
|
u8 *dst = walk->dst.virt.addr;
|
|
|
|
|
unsigned int nbytes = walk->nbytes;
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
/* create keystream */
|
2007-11-29 13:23:53 +00:00
|
|
|
fn(crypto_cipher_tfm(tfm), dst, ctrblk);
|
|
|
|
|
crypto_xor(dst, src, bsize);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
|
|
|
|
/* increment counter in counterblock */
|
2007-12-17 13:34:32 +00:00
|
|
|
crypto_inc(ctrblk, bsize);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
|
|
|
|
src += bsize;
|
|
|
|
|
dst += bsize;
|
2007-11-29 13:23:53 +00:00
|
|
|
} while ((nbytes -= bsize) >= bsize);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
2007-11-29 13:23:53 +00:00
|
|
|
return nbytes;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
}
|
|
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
static int crypto_ctr_crypt_inplace(struct skcipher_walk *walk,
|
2007-12-17 13:34:32 +00:00
|
|
|
struct crypto_cipher *tfm)
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
{
|
|
|
|
|
void (*fn)(struct crypto_tfm *, u8 *, const u8 *) =
|
|
|
|
|
crypto_cipher_alg(tfm)->cia_encrypt;
|
|
|
|
|
unsigned int bsize = crypto_cipher_blocksize(tfm);
|
2007-12-17 13:34:32 +00:00
|
|
|
unsigned long alignmask = crypto_cipher_alignmask(tfm);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
unsigned int nbytes = walk->nbytes;
|
2007-12-17 13:34:32 +00:00
|
|
|
u8 *ctrblk = walk->iv;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
u8 *src = walk->src.virt.addr;
|
2018-04-09 13:54:47 +00:00
|
|
|
u8 tmp[MAX_CIPHER_BLOCKSIZE + MAX_CIPHER_ALIGNMASK];
|
2007-12-17 13:34:32 +00:00
|
|
|
u8 *keystream = PTR_ALIGN(tmp + 0, alignmask + 1);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
/* create keystream */
|
|
|
|
|
fn(crypto_cipher_tfm(tfm), keystream, ctrblk);
|
2007-11-29 13:23:53 +00:00
|
|
|
crypto_xor(src, keystream, bsize);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
|
|
|
|
/* increment counter in counterblock */
|
2007-12-17 13:34:32 +00:00
|
|
|
crypto_inc(ctrblk, bsize);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
|
|
|
|
src += bsize;
|
2007-11-29 13:23:53 +00:00
|
|
|
} while ((nbytes -= bsize) >= bsize);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
2007-11-29 13:23:53 +00:00
|
|
|
return nbytes;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
}
|
|
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
static int crypto_ctr_crypt(struct skcipher_request *req)
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
{
|
2019-01-04 04:16:17 +00:00
|
|
|
struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
|
|
|
|
|
struct crypto_cipher *cipher = skcipher_cipher_simple(tfm);
|
|
|
|
|
const unsigned int bsize = crypto_cipher_blocksize(cipher);
|
|
|
|
|
struct skcipher_walk walk;
|
|
|
|
|
unsigned int nbytes;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
int err;
|
|
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
err = skcipher_walk_virt(&walk, req, false);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
2007-11-29 13:23:53 +00:00
|
|
|
while (walk.nbytes >= bsize) {
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
if (walk.src.virt.addr == walk.dst.virt.addr)
|
2019-01-04 04:16:17 +00:00
|
|
|
nbytes = crypto_ctr_crypt_inplace(&walk, cipher);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
else
|
2019-01-04 04:16:17 +00:00
|
|
|
nbytes = crypto_ctr_crypt_segment(&walk, cipher);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
err = skcipher_walk_done(&walk, nbytes);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
}
|
2007-11-29 13:23:53 +00:00
|
|
|
|
|
|
|
|
if (walk.nbytes) {
|
2019-01-04 04:16:17 +00:00
|
|
|
crypto_ctr_crypt_final(&walk, cipher);
|
|
|
|
|
err = skcipher_walk_done(&walk, 0);
|
2007-11-29 13:23:53 +00:00
|
|
|
}
|
|
|
|
|
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
static int crypto_ctr_create(struct crypto_template *tmpl, struct rtattr **tb)
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
{
|
2019-01-04 04:16:17 +00:00
|
|
|
struct skcipher_instance *inst;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
struct crypto_alg *alg;
|
|
|
|
|
int err;
|
|
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
inst = skcipher_alloc_instance_simple(tmpl, tb, &alg);
|
|
|
|
|
if (IS_ERR(inst))
|
|
|
|
|
return PTR_ERR(inst);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
2007-12-17 13:34:32 +00:00
|
|
|
/* Block size must be >= 4 bytes. */
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
err = -EINVAL;
|
2007-12-17 13:34:32 +00:00
|
|
|
if (alg->cra_blocksize < 4)
|
2019-01-04 04:16:17 +00:00
|
|
|
goto out_free_inst;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
2007-11-20 12:32:56 +00:00
|
|
|
/* If this is false we'd fail the alignment of crypto_inc. */
|
2007-12-17 13:34:32 +00:00
|
|
|
if (alg->cra_blocksize % 4)
|
2019-01-04 04:16:17 +00:00
|
|
|
goto out_free_inst;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
/* CTR mode is a stream cipher. */
|
|
|
|
|
inst->alg.base.cra_blocksize = 1;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
/*
|
|
|
|
|
* To simplify the implementation, configure the skcipher walk to only
|
|
|
|
|
* give a partial block at the very end, never earlier.
|
|
|
|
|
*/
|
|
|
|
|
inst->alg.chunksize = alg->cra_blocksize;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
inst->alg.encrypt = crypto_ctr_crypt;
|
|
|
|
|
inst->alg.decrypt = crypto_ctr_crypt;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
err = skcipher_register_instance(tmpl, inst);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out_free_inst;
|
|
|
|
|
goto out_put_alg;
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2019-01-04 04:16:17 +00:00
|
|
|
out_free_inst:
|
|
|
|
|
inst->free(inst);
|
2007-12-17 13:34:32 +00:00
|
|
|
out_put_alg:
|
2019-01-04 04:16:17 +00:00
|
|
|
crypto_mod_put(alg);
|
|
|
|
|
return err;
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
}
|
|
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
static int crypto_rfc3686_setkey(struct crypto_skcipher *parent,
|
2012-12-28 10:04:58 +00:00
|
|
|
const u8 *key, unsigned int keylen)
|
2007-12-17 13:34:32 +00:00
|
|
|
{
|
2016-07-12 05:17:37 +00:00
|
|
|
struct crypto_rfc3686_ctx *ctx = crypto_skcipher_ctx(parent);
|
|
|
|
|
struct crypto_skcipher *child = ctx->child;
|
2007-12-17 13:34:32 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
/* the nonce is stored in bytes at end of key */
|
|
|
|
|
if (keylen < CTR_RFC3686_NONCE_SIZE)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
memcpy(ctx->nonce, key + (keylen - CTR_RFC3686_NONCE_SIZE),
|
|
|
|
|
CTR_RFC3686_NONCE_SIZE);
|
|
|
|
|
|
|
|
|
|
keylen -= CTR_RFC3686_NONCE_SIZE;
|
|
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
crypto_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
|
|
|
|
|
crypto_skcipher_set_flags(child, crypto_skcipher_get_flags(parent) &
|
|
|
|
|
CRYPTO_TFM_REQ_MASK);
|
|
|
|
|
err = crypto_skcipher_setkey(child, key, keylen);
|
|
|
|
|
crypto_skcipher_set_flags(parent, crypto_skcipher_get_flags(child) &
|
|
|
|
|
CRYPTO_TFM_RES_MASK);
|
2007-12-17 13:34:32 +00:00
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
static int crypto_rfc3686_crypt(struct skcipher_request *req)
|
2007-12-17 13:34:32 +00:00
|
|
|
{
|
2016-07-12 05:17:37 +00:00
|
|
|
struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
|
|
|
|
|
struct crypto_rfc3686_ctx *ctx = crypto_skcipher_ctx(tfm);
|
|
|
|
|
struct crypto_skcipher *child = ctx->child;
|
|
|
|
|
unsigned long align = crypto_skcipher_alignmask(tfm);
|
2012-12-28 10:04:58 +00:00
|
|
|
struct crypto_rfc3686_req_ctx *rctx =
|
2016-07-12 05:17:37 +00:00
|
|
|
(void *)PTR_ALIGN((u8 *)skcipher_request_ctx(req), align + 1);
|
|
|
|
|
struct skcipher_request *subreq = &rctx->subreq;
|
2012-12-28 10:04:58 +00:00
|
|
|
u8 *iv = rctx->iv;
|
2007-12-17 13:34:32 +00:00
|
|
|
|
|
|
|
|
/* set up counter block */
|
|
|
|
|
memcpy(iv, ctx->nonce, CTR_RFC3686_NONCE_SIZE);
|
2016-07-12 05:17:37 +00:00
|
|
|
memcpy(iv + CTR_RFC3686_NONCE_SIZE, req->iv, CTR_RFC3686_IV_SIZE);
|
2007-12-17 13:34:32 +00:00
|
|
|
|
|
|
|
|
/* initialize counter portion of counter block */
|
|
|
|
|
*(__be32 *)(iv + CTR_RFC3686_NONCE_SIZE + CTR_RFC3686_IV_SIZE) =
|
|
|
|
|
cpu_to_be32(1);
|
|
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
skcipher_request_set_tfm(subreq, child);
|
|
|
|
|
skcipher_request_set_callback(subreq, req->base.flags,
|
|
|
|
|
req->base.complete, req->base.data);
|
|
|
|
|
skcipher_request_set_crypt(subreq, req->src, req->dst,
|
|
|
|
|
req->cryptlen, iv);
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
return crypto_skcipher_encrypt(subreq);
|
2007-12-17 13:34:32 +00:00
|
|
|
}
|
|
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
static int crypto_rfc3686_init_tfm(struct crypto_skcipher *tfm)
|
2007-12-17 13:34:32 +00:00
|
|
|
{
|
2016-07-12 05:17:37 +00:00
|
|
|
struct skcipher_instance *inst = skcipher_alg_instance(tfm);
|
|
|
|
|
struct crypto_skcipher_spawn *spawn = skcipher_instance_ctx(inst);
|
|
|
|
|
struct crypto_rfc3686_ctx *ctx = crypto_skcipher_ctx(tfm);
|
|
|
|
|
struct crypto_skcipher *cipher;
|
2012-12-28 10:04:58 +00:00
|
|
|
unsigned long align;
|
2016-07-12 05:17:37 +00:00
|
|
|
unsigned int reqsize;
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2016-10-28 16:52:19 +00:00
|
|
|
cipher = crypto_spawn_skcipher(spawn);
|
2007-12-17 13:34:32 +00:00
|
|
|
if (IS_ERR(cipher))
|
|
|
|
|
return PTR_ERR(cipher);
|
|
|
|
|
|
|
|
|
|
ctx->child = cipher;
|
|
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
align = crypto_skcipher_alignmask(tfm);
|
2012-12-28 10:04:58 +00:00
|
|
|
align &= ~(crypto_tfm_ctx_alignment() - 1);
|
2016-07-12 05:17:37 +00:00
|
|
|
reqsize = align + sizeof(struct crypto_rfc3686_req_ctx) +
|
|
|
|
|
crypto_skcipher_reqsize(cipher);
|
|
|
|
|
crypto_skcipher_set_reqsize(tfm, reqsize);
|
2012-12-28 10:04:58 +00:00
|
|
|
|
2007-12-17 13:34:32 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
static void crypto_rfc3686_exit_tfm(struct crypto_skcipher *tfm)
|
2007-12-17 13:34:32 +00:00
|
|
|
{
|
2016-07-12 05:17:37 +00:00
|
|
|
struct crypto_rfc3686_ctx *ctx = crypto_skcipher_ctx(tfm);
|
|
|
|
|
|
|
|
|
|
crypto_free_skcipher(ctx->child);
|
|
|
|
|
}
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
static void crypto_rfc3686_free(struct skcipher_instance *inst)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_skcipher_spawn *spawn = skcipher_instance_ctx(inst);
|
|
|
|
|
|
|
|
|
|
crypto_drop_skcipher(spawn);
|
|
|
|
|
kfree(inst);
|
2007-12-17 13:34:32 +00:00
|
|
|
}
|
|
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
static int crypto_rfc3686_create(struct crypto_template *tmpl,
|
|
|
|
|
struct rtattr **tb)
|
2007-12-17 13:34:32 +00:00
|
|
|
{
|
2012-12-28 10:04:58 +00:00
|
|
|
struct crypto_attr_type *algt;
|
2016-07-12 05:17:37 +00:00
|
|
|
struct skcipher_instance *inst;
|
|
|
|
|
struct skcipher_alg *alg;
|
2012-12-28 10:04:58 +00:00
|
|
|
struct crypto_skcipher_spawn *spawn;
|
|
|
|
|
const char *cipher_name;
|
2017-02-27 12:38:26 +00:00
|
|
|
u32 mask;
|
|
|
|
|
|
2007-12-17 13:34:32 +00:00
|
|
|
int err;
|
|
|
|
|
|
2012-12-28 10:04:58 +00:00
|
|
|
algt = crypto_get_attr_type(tb);
|
|
|
|
|
if (IS_ERR(algt))
|
2016-07-12 05:17:37 +00:00
|
|
|
return PTR_ERR(algt);
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
if ((algt->type ^ CRYPTO_ALG_TYPE_SKCIPHER) & algt->mask)
|
|
|
|
|
return -EINVAL;
|
2012-12-28 10:04:58 +00:00
|
|
|
|
|
|
|
|
cipher_name = crypto_attr_alg_name(tb[1]);
|
|
|
|
|
if (IS_ERR(cipher_name))
|
2016-07-12 05:17:37 +00:00
|
|
|
return PTR_ERR(cipher_name);
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2012-12-28 10:04:58 +00:00
|
|
|
inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
|
|
|
|
|
if (!inst)
|
2016-07-12 05:17:37 +00:00
|
|
|
return -ENOMEM;
|
2012-12-28 10:04:58 +00:00
|
|
|
|
2017-02-27 12:38:26 +00:00
|
|
|
mask = crypto_requires_sync(algt->type, algt->mask) |
|
|
|
|
|
crypto_requires_off(algt->type, algt->mask,
|
|
|
|
|
CRYPTO_ALG_NEED_FALLBACK);
|
|
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
spawn = skcipher_instance_ctx(inst);
|
2012-12-28 10:04:58 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
crypto_set_skcipher_spawn(spawn, skcipher_crypto_instance(inst));
|
2017-02-27 12:38:26 +00:00
|
|
|
err = crypto_grab_skcipher(spawn, cipher_name, 0, mask);
|
2012-12-28 10:04:58 +00:00
|
|
|
if (err)
|
|
|
|
|
goto err_free_inst;
|
|
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
alg = crypto_spawn_skcipher_alg(spawn);
|
2012-12-28 10:04:58 +00:00
|
|
|
|
2007-12-17 13:34:32 +00:00
|
|
|
/* We only support 16-byte blocks. */
|
|
|
|
|
err = -EINVAL;
|
2016-07-12 05:17:37 +00:00
|
|
|
if (crypto_skcipher_alg_ivsize(alg) != CTR_RFC3686_BLOCK_SIZE)
|
2012-12-28 10:04:58 +00:00
|
|
|
goto err_drop_spawn;
|
2007-12-17 13:34:32 +00:00
|
|
|
|
|
|
|
|
/* Not a stream cipher? */
|
2016-07-12 05:17:37 +00:00
|
|
|
if (alg->base.cra_blocksize != 1)
|
2012-12-28 10:04:58 +00:00
|
|
|
goto err_drop_spawn;
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2012-12-28 10:04:58 +00:00
|
|
|
err = -ENAMETOOLONG;
|
2016-07-12 05:17:37 +00:00
|
|
|
if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
|
|
|
|
|
"rfc3686(%s)", alg->base.cra_name) >= CRYPTO_MAX_ALG_NAME)
|
2012-12-28 10:04:58 +00:00
|
|
|
goto err_drop_spawn;
|
2016-07-12 05:17:37 +00:00
|
|
|
if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
|
|
|
|
|
"rfc3686(%s)", alg->base.cra_driver_name) >=
|
|
|
|
|
CRYPTO_MAX_ALG_NAME)
|
2012-12-28 10:04:58 +00:00
|
|
|
goto err_drop_spawn;
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
inst->alg.base.cra_priority = alg->base.cra_priority;
|
|
|
|
|
inst->alg.base.cra_blocksize = 1;
|
|
|
|
|
inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
|
2012-12-28 10:04:58 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
inst->alg.ivsize = CTR_RFC3686_IV_SIZE;
|
|
|
|
|
inst->alg.chunksize = crypto_skcipher_alg_chunksize(alg);
|
|
|
|
|
inst->alg.min_keysize = crypto_skcipher_alg_min_keysize(alg) +
|
|
|
|
|
CTR_RFC3686_NONCE_SIZE;
|
|
|
|
|
inst->alg.max_keysize = crypto_skcipher_alg_max_keysize(alg) +
|
|
|
|
|
CTR_RFC3686_NONCE_SIZE;
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
inst->alg.setkey = crypto_rfc3686_setkey;
|
|
|
|
|
inst->alg.encrypt = crypto_rfc3686_crypt;
|
|
|
|
|
inst->alg.decrypt = crypto_rfc3686_crypt;
|
2012-12-28 10:04:58 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
inst->alg.base.cra_ctxsize = sizeof(struct crypto_rfc3686_ctx);
|
2007-11-30 10:38:37 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
inst->alg.init = crypto_rfc3686_init_tfm;
|
|
|
|
|
inst->alg.exit = crypto_rfc3686_exit_tfm;
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
inst->free = crypto_rfc3686_free;
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2016-07-12 05:17:37 +00:00
|
|
|
err = skcipher_register_instance(tmpl, inst);
|
|
|
|
|
if (err)
|
|
|
|
|
goto err_drop_spawn;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
return err;
|
2007-12-17 13:34:32 +00:00
|
|
|
|
2012-12-28 10:04:58 +00:00
|
|
|
err_drop_spawn:
|
|
|
|
|
crypto_drop_skcipher(spawn);
|
|
|
|
|
err_free_inst:
|
|
|
|
|
kfree(inst);
|
2016-07-12 05:17:37 +00:00
|
|
|
goto out;
|
2007-12-17 13:34:32 +00:00
|
|
|
}
|
|
|
|
|
|
2019-01-18 05:58:14 +00:00
|
|
|
static struct crypto_template crypto_ctr_tmpls[] = {
|
|
|
|
|
{
|
|
|
|
|
.name = "ctr",
|
|
|
|
|
.create = crypto_ctr_create,
|
|
|
|
|
.module = THIS_MODULE,
|
|
|
|
|
}, {
|
|
|
|
|
.name = "rfc3686",
|
|
|
|
|
.create = crypto_rfc3686_create,
|
|
|
|
|
.module = THIS_MODULE,
|
|
|
|
|
},
|
2007-12-17 13:34:32 +00:00
|
|
|
};
|
|
|
|
|
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
static int __init crypto_ctr_module_init(void)
|
|
|
|
|
{
|
2019-01-18 05:58:14 +00:00
|
|
|
return crypto_register_templates(crypto_ctr_tmpls,
|
|
|
|
|
ARRAY_SIZE(crypto_ctr_tmpls));
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __exit crypto_ctr_module_exit(void)
|
|
|
|
|
{
|
2019-01-18 05:58:14 +00:00
|
|
|
crypto_unregister_templates(crypto_ctr_tmpls,
|
|
|
|
|
ARRAY_SIZE(crypto_ctr_tmpls));
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
}
|
|
|
|
|
|
2019-04-12 04:57:42 +00:00
|
|
|
subsys_initcall(crypto_ctr_module_init);
|
[CRYPTO] ctr: Add CTR (Counter) block cipher mode
This patch implements CTR mode for IPsec.
It is based off of RFC 3686.
Please note:
1. CTR turns a block cipher into a stream cipher.
Encryption is done in blocks, however the last block
may be a partial block.
A "counter block" is encrypted, creating a keystream
that is xor'ed with the plaintext. The counter portion
of the counter block is incremented after each block
of plaintext is encrypted.
Decryption is performed in same manner.
2. The CTR counterblock is composed of,
nonce + IV + counter
The size of the counterblock is equivalent to the
blocksize of the cipher.
sizeof(nonce) + sizeof(IV) + sizeof(counter) = blocksize
The CTR template requires the name of the cipher
algorithm, the sizeof the nonce, and the sizeof the iv.
ctr(cipher,sizeof_nonce,sizeof_iv)
So for example,
ctr(aes,4,8)
specifies the counterblock will be composed of 4 bytes
from a nonce, 8 bytes from the iv, and 4 bytes for counter
since aes has a blocksize of 16 bytes.
3. The counter portion of the counter block is stored
in big endian for conformance to rfc 3686.
Signed-off-by: Joy Latten <latten@austin.ibm.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2007-10-23 00:50:32 +00:00
|
|
|
module_exit(crypto_ctr_module_exit);
|
|
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
2019-01-04 04:16:17 +00:00
|
|
|
MODULE_DESCRIPTION("CTR block cipher mode of operation");
|
2014-11-21 01:05:53 +00:00
|
|
|
MODULE_ALIAS_CRYPTO("rfc3686");
|
2014-11-25 00:32:38 +00:00
|
|
|
MODULE_ALIAS_CRYPTO("ctr");
|
