[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-22 18:50:32 -06:00
|
|
|
/*
|
|
|
|
* CTR: Counter mode
|
|
|
|
*
|
|
|
|
* (C) Copyright IBM Corp. 2007 - Joy Latten <latten@us.ibm.com>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <crypto/algapi.h>
|
2007-12-17 06:34:32 -07:00
|
|
|
#include <crypto/ctr.h>
|
2012-12-28 03:04:58 -07: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-22 18:50:32 -06:00
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/random.h>
|
|
|
|
#include <linux/scatterlist.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
|
|
|
struct crypto_ctr_ctx {
|
|
|
|
struct crypto_cipher *child;
|
2007-12-17 06:34:32 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct crypto_rfc3686_ctx {
|
2016-07-11 23:17:37 -06:00
|
|
|
struct crypto_skcipher *child;
|
2007-12-17 06:34:32 -07: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-22 18:50:32 -06:00
|
|
|
};
|
|
|
|
|
2012-12-28 03:04:58 -07:00
|
|
|
struct crypto_rfc3686_req_ctx {
|
|
|
|
u8 iv[CTR_RFC3686_BLOCK_SIZE];
|
2016-07-11 23:17:37 -06:00
|
|
|
struct skcipher_request subreq CRYPTO_MINALIGN_ATTR;
|
2012-12-28 03:04:58 -07: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-22 18:50:32 -06:00
|
|
|
static int crypto_ctr_setkey(struct crypto_tfm *parent, const u8 *key,
|
|
|
|
unsigned int keylen)
|
|
|
|
{
|
|
|
|
struct crypto_ctr_ctx *ctx = crypto_tfm_ctx(parent);
|
|
|
|
struct crypto_cipher *child = ctx->child;
|
2007-12-17 06:34:32 -07:00
|
|
|
int 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-22 18:50:32 -06:00
|
|
|
|
|
|
|
crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
|
|
|
|
crypto_cipher_set_flags(child, crypto_tfm_get_flags(parent) &
|
|
|
|
CRYPTO_TFM_REQ_MASK);
|
|
|
|
err = crypto_cipher_setkey(child, key, keylen);
|
|
|
|
crypto_tfm_set_flags(parent, crypto_cipher_get_flags(child) &
|
|
|
|
CRYPTO_TFM_RES_MASK);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2007-11-29 06:23:53 -07:00
|
|
|
static void crypto_ctr_crypt_final(struct blkcipher_walk *walk,
|
2007-12-17 06:34:32 -07:00
|
|
|
struct crypto_cipher *tfm)
|
2007-11-29 06:23:53 -07:00
|
|
|
{
|
|
|
|
unsigned int bsize = crypto_cipher_blocksize(tfm);
|
2007-12-17 06:34:32 -07:00
|
|
|
unsigned long alignmask = crypto_cipher_alignmask(tfm);
|
|
|
|
u8 *ctrblk = walk->iv;
|
|
|
|
u8 tmp[bsize + alignmask];
|
|
|
|
u8 *keystream = PTR_ALIGN(tmp + 0, alignmask + 1);
|
2007-11-29 06:23:53 -07: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_xor(keystream, src, nbytes);
|
|
|
|
memcpy(dst, keystream, nbytes);
|
2007-12-17 06:34:32 -07:00
|
|
|
|
|
|
|
crypto_inc(ctrblk, bsize);
|
2007-11-29 06:23:53 -07: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-22 18:50:32 -06:00
|
|
|
static int crypto_ctr_crypt_segment(struct blkcipher_walk *walk,
|
2007-12-17 06:34:32 -07: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-22 18:50:32 -06: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 06:34:32 -07: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-22 18:50:32 -06:00
|
|
|
u8 *src = walk->src.virt.addr;
|
|
|
|
u8 *dst = walk->dst.virt.addr;
|
|
|
|
unsigned int nbytes = walk->nbytes;
|
|
|
|
|
|
|
|
do {
|
|
|
|
/* create keystream */
|
2007-11-29 06:23:53 -07: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-22 18:50:32 -06:00
|
|
|
|
|
|
|
/* increment counter in counterblock */
|
2007-12-17 06:34:32 -07: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-22 18:50:32 -06:00
|
|
|
|
|
|
|
src += bsize;
|
|
|
|
dst += bsize;
|
2007-11-29 06:23:53 -07: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-22 18:50:32 -06:00
|
|
|
|
2007-11-29 06:23:53 -07: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-22 18:50:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int crypto_ctr_crypt_inplace(struct blkcipher_walk *walk,
|
2007-12-17 06:34:32 -07: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-22 18:50:32 -06: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 06:34:32 -07: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-22 18:50:32 -06:00
|
|
|
unsigned int nbytes = walk->nbytes;
|
2007-12-17 06:34:32 -07: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-22 18:50:32 -06:00
|
|
|
u8 *src = walk->src.virt.addr;
|
2007-12-17 06:34:32 -07:00
|
|
|
u8 tmp[bsize + alignmask];
|
|
|
|
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-22 18:50:32 -06:00
|
|
|
|
|
|
|
do {
|
|
|
|
/* create keystream */
|
|
|
|
fn(crypto_cipher_tfm(tfm), keystream, ctrblk);
|
2007-11-29 06:23:53 -07: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-22 18:50:32 -06:00
|
|
|
|
|
|
|
/* increment counter in counterblock */
|
2007-12-17 06:34:32 -07: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-22 18:50:32 -06:00
|
|
|
|
|
|
|
src += bsize;
|
2007-11-29 06:23:53 -07: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-22 18:50:32 -06:00
|
|
|
|
2007-11-29 06:23:53 -07: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-22 18:50:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int crypto_ctr_crypt(struct blkcipher_desc *desc,
|
|
|
|
struct scatterlist *dst, struct scatterlist *src,
|
|
|
|
unsigned int nbytes)
|
|
|
|
{
|
|
|
|
struct blkcipher_walk walk;
|
|
|
|
struct crypto_blkcipher *tfm = desc->tfm;
|
|
|
|
struct crypto_ctr_ctx *ctx = crypto_blkcipher_ctx(tfm);
|
|
|
|
struct crypto_cipher *child = ctx->child;
|
|
|
|
unsigned int bsize = crypto_cipher_blocksize(child);
|
|
|
|
int err;
|
|
|
|
|
|
|
|
blkcipher_walk_init(&walk, dst, src, nbytes);
|
|
|
|
err = blkcipher_walk_virt_block(desc, &walk, bsize);
|
|
|
|
|
2007-11-29 06:23:53 -07: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-22 18:50:32 -06:00
|
|
|
if (walk.src.virt.addr == walk.dst.virt.addr)
|
2007-12-17 06:34:32 -07:00
|
|
|
nbytes = crypto_ctr_crypt_inplace(&walk, child);
|
[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-22 18:50:32 -06:00
|
|
|
else
|
2007-12-17 06:34:32 -07:00
|
|
|
nbytes = crypto_ctr_crypt_segment(&walk, child);
|
[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-22 18:50:32 -06:00
|
|
|
|
|
|
|
err = blkcipher_walk_done(desc, &walk, nbytes);
|
|
|
|
}
|
2007-11-29 06:23:53 -07:00
|
|
|
|
|
|
|
if (walk.nbytes) {
|
2007-12-17 06:34:32 -07:00
|
|
|
crypto_ctr_crypt_final(&walk, child);
|
2007-11-29 06:23:53 -07:00
|
|
|
err = blkcipher_walk_done(desc, &walk, 0);
|
|
|
|
}
|
|
|
|
|
[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-22 18:50:32 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypto_ctr_init_tfm(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
struct crypto_instance *inst = (void *)tfm->__crt_alg;
|
2007-12-17 06:34:32 -07:00
|
|
|
struct crypto_spawn *spawn = crypto_instance_ctx(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-22 18:50:32 -06:00
|
|
|
struct crypto_ctr_ctx *ctx = crypto_tfm_ctx(tfm);
|
|
|
|
struct crypto_cipher *cipher;
|
|
|
|
|
2007-12-17 06:34:32 -07:00
|
|
|
cipher = crypto_spawn_cipher(spawn);
|
[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-22 18:50:32 -06:00
|
|
|
if (IS_ERR(cipher))
|
|
|
|
return PTR_ERR(cipher);
|
|
|
|
|
|
|
|
ctx->child = cipher;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void crypto_ctr_exit_tfm(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
struct crypto_ctr_ctx *ctx = crypto_tfm_ctx(tfm);
|
|
|
|
|
|
|
|
crypto_free_cipher(ctx->child);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct crypto_instance *crypto_ctr_alloc(struct rtattr **tb)
|
|
|
|
{
|
|
|
|
struct crypto_instance *inst;
|
|
|
|
struct crypto_alg *alg;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_BLKCIPHER);
|
|
|
|
if (err)
|
|
|
|
return ERR_PTR(err);
|
|
|
|
|
|
|
|
alg = crypto_attr_alg(tb[1], CRYPTO_ALG_TYPE_CIPHER,
|
|
|
|
CRYPTO_ALG_TYPE_MASK);
|
|
|
|
if (IS_ERR(alg))
|
2010-05-25 18:36:51 -06:00
|
|
|
return ERR_CAST(alg);
|
[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-22 18:50:32 -06:00
|
|
|
|
2007-12-17 06:34:32 -07: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-22 18:50:32 -06:00
|
|
|
err = -EINVAL;
|
2007-12-17 06:34:32 -07:00
|
|
|
if (alg->cra_blocksize < 4)
|
[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-22 18:50:32 -06:00
|
|
|
goto out_put_alg;
|
|
|
|
|
2007-11-20 05:32:56 -07:00
|
|
|
/* If this is false we'd fail the alignment of crypto_inc. */
|
2007-12-17 06:34:32 -07:00
|
|
|
if (alg->cra_blocksize % 4)
|
2007-11-20 05:32:56 -07:00
|
|
|
goto out_put_alg;
|
|
|
|
|
2007-12-17 06:34:32 -07:00
|
|
|
inst = crypto_alloc_instance("ctr", alg);
|
|
|
|
if (IS_ERR(inst))
|
|
|
|
goto out;
|
[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-22 18:50:32 -06:00
|
|
|
|
|
|
|
inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER;
|
|
|
|
inst->alg.cra_priority = alg->cra_priority;
|
|
|
|
inst->alg.cra_blocksize = 1;
|
2007-11-29 06:23:53 -07:00
|
|
|
inst->alg.cra_alignmask = alg->cra_alignmask | (__alignof__(u32) - 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-22 18:50:32 -06:00
|
|
|
inst->alg.cra_type = &crypto_blkcipher_type;
|
|
|
|
|
2007-12-17 06:34:32 -07:00
|
|
|
inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize;
|
|
|
|
inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize;
|
|
|
|
inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize;
|
[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-22 18:50:32 -06:00
|
|
|
|
|
|
|
inst->alg.cra_ctxsize = sizeof(struct crypto_ctr_ctx);
|
|
|
|
|
|
|
|
inst->alg.cra_init = crypto_ctr_init_tfm;
|
|
|
|
inst->alg.cra_exit = crypto_ctr_exit_tfm;
|
|
|
|
|
|
|
|
inst->alg.cra_blkcipher.setkey = crypto_ctr_setkey;
|
|
|
|
inst->alg.cra_blkcipher.encrypt = crypto_ctr_crypt;
|
|
|
|
inst->alg.cra_blkcipher.decrypt = crypto_ctr_crypt;
|
|
|
|
|
2009-08-13 07:10:39 -06:00
|
|
|
inst->alg.cra_blkcipher.geniv = "chainiv";
|
|
|
|
|
2007-12-17 06:34:32 -07:00
|
|
|
out:
|
[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-22 18:50:32 -06:00
|
|
|
crypto_mod_put(alg);
|
|
|
|
return inst;
|
2007-12-17 06:34:32 -07:00
|
|
|
|
|
|
|
out_put_alg:
|
|
|
|
inst = ERR_PTR(err);
|
|
|
|
goto out;
|
[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-22 18:50:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void crypto_ctr_free(struct crypto_instance *inst)
|
|
|
|
{
|
2007-12-17 06:34:32 -07:00
|
|
|
crypto_drop_spawn(crypto_instance_ctx(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-22 18:50:32 -06:00
|
|
|
kfree(inst);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct crypto_template crypto_ctr_tmpl = {
|
|
|
|
.name = "ctr",
|
|
|
|
.alloc = crypto_ctr_alloc,
|
|
|
|
.free = crypto_ctr_free,
|
|
|
|
.module = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
static int crypto_rfc3686_setkey(struct crypto_skcipher *parent,
|
2012-12-28 03:04:58 -07:00
|
|
|
const u8 *key, unsigned int keylen)
|
2007-12-17 06:34:32 -07:00
|
|
|
{
|
2016-07-11 23:17:37 -06:00
|
|
|
struct crypto_rfc3686_ctx *ctx = crypto_skcipher_ctx(parent);
|
|
|
|
struct crypto_skcipher *child = ctx->child;
|
2007-12-17 06:34:32 -07: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-11 23:17:37 -06: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 06:34:32 -07:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
static int crypto_rfc3686_crypt(struct skcipher_request *req)
|
2007-12-17 06:34:32 -07:00
|
|
|
{
|
2016-07-11 23:17:37 -06: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 03:04:58 -07:00
|
|
|
struct crypto_rfc3686_req_ctx *rctx =
|
2016-07-11 23:17:37 -06:00
|
|
|
(void *)PTR_ALIGN((u8 *)skcipher_request_ctx(req), align + 1);
|
|
|
|
struct skcipher_request *subreq = &rctx->subreq;
|
2012-12-28 03:04:58 -07:00
|
|
|
u8 *iv = rctx->iv;
|
2007-12-17 06:34:32 -07:00
|
|
|
|
|
|
|
/* set up counter block */
|
|
|
|
memcpy(iv, ctx->nonce, CTR_RFC3686_NONCE_SIZE);
|
2016-07-11 23:17:37 -06:00
|
|
|
memcpy(iv + CTR_RFC3686_NONCE_SIZE, req->iv, CTR_RFC3686_IV_SIZE);
|
2007-12-17 06:34:32 -07:00
|
|
|
|
|
|
|
/* initialize counter portion of counter block */
|
|
|
|
*(__be32 *)(iv + CTR_RFC3686_NONCE_SIZE + CTR_RFC3686_IV_SIZE) =
|
|
|
|
cpu_to_be32(1);
|
|
|
|
|
2016-07-11 23:17:37 -06: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 06:34:32 -07:00
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
return crypto_skcipher_encrypt(subreq);
|
2007-12-17 06:34:32 -07:00
|
|
|
}
|
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
static int crypto_rfc3686_init_tfm(struct crypto_skcipher *tfm)
|
2007-12-17 06:34:32 -07:00
|
|
|
{
|
2016-07-11 23:17:37 -06: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 03:04:58 -07:00
|
|
|
unsigned long align;
|
2016-07-11 23:17:37 -06:00
|
|
|
unsigned int reqsize;
|
2007-12-17 06:34:32 -07:00
|
|
|
|
2016-10-28 10:52:19 -06:00
|
|
|
cipher = crypto_spawn_skcipher(spawn);
|
2007-12-17 06:34:32 -07:00
|
|
|
if (IS_ERR(cipher))
|
|
|
|
return PTR_ERR(cipher);
|
|
|
|
|
|
|
|
ctx->child = cipher;
|
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
align = crypto_skcipher_alignmask(tfm);
|
2012-12-28 03:04:58 -07:00
|
|
|
align &= ~(crypto_tfm_ctx_alignment() - 1);
|
2016-07-11 23:17:37 -06:00
|
|
|
reqsize = align + sizeof(struct crypto_rfc3686_req_ctx) +
|
|
|
|
crypto_skcipher_reqsize(cipher);
|
|
|
|
crypto_skcipher_set_reqsize(tfm, reqsize);
|
2012-12-28 03:04:58 -07:00
|
|
|
|
2007-12-17 06:34:32 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
static void crypto_rfc3686_exit_tfm(struct crypto_skcipher *tfm)
|
2007-12-17 06:34:32 -07:00
|
|
|
{
|
2016-07-11 23:17:37 -06:00
|
|
|
struct crypto_rfc3686_ctx *ctx = crypto_skcipher_ctx(tfm);
|
|
|
|
|
|
|
|
crypto_free_skcipher(ctx->child);
|
|
|
|
}
|
2007-12-17 06:34:32 -07:00
|
|
|
|
2016-07-11 23:17:37 -06: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 06:34:32 -07:00
|
|
|
}
|
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
static int crypto_rfc3686_create(struct crypto_template *tmpl,
|
|
|
|
struct rtattr **tb)
|
2007-12-17 06:34:32 -07:00
|
|
|
{
|
2012-12-28 03:04:58 -07:00
|
|
|
struct crypto_attr_type *algt;
|
2016-07-11 23:17:37 -06:00
|
|
|
struct skcipher_instance *inst;
|
|
|
|
struct skcipher_alg *alg;
|
2012-12-28 03:04:58 -07:00
|
|
|
struct crypto_skcipher_spawn *spawn;
|
|
|
|
const char *cipher_name;
|
2007-12-17 06:34:32 -07:00
|
|
|
int err;
|
|
|
|
|
2012-12-28 03:04:58 -07:00
|
|
|
algt = crypto_get_attr_type(tb);
|
|
|
|
if (IS_ERR(algt))
|
2016-07-11 23:17:37 -06:00
|
|
|
return PTR_ERR(algt);
|
2007-12-17 06:34:32 -07:00
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
if ((algt->type ^ CRYPTO_ALG_TYPE_SKCIPHER) & algt->mask)
|
|
|
|
return -EINVAL;
|
2012-12-28 03:04:58 -07:00
|
|
|
|
|
|
|
cipher_name = crypto_attr_alg_name(tb[1]);
|
|
|
|
if (IS_ERR(cipher_name))
|
2016-07-11 23:17:37 -06:00
|
|
|
return PTR_ERR(cipher_name);
|
2007-12-17 06:34:32 -07:00
|
|
|
|
2012-12-28 03:04:58 -07:00
|
|
|
inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
|
|
|
|
if (!inst)
|
2016-07-11 23:17:37 -06:00
|
|
|
return -ENOMEM;
|
2012-12-28 03:04:58 -07:00
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
spawn = skcipher_instance_ctx(inst);
|
2012-12-28 03:04:58 -07:00
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
crypto_set_skcipher_spawn(spawn, skcipher_crypto_instance(inst));
|
2016-10-28 10:51:13 -06:00
|
|
|
err = crypto_grab_skcipher(spawn, cipher_name, 0,
|
|
|
|
crypto_requires_sync(algt->type,
|
|
|
|
algt->mask));
|
2012-12-28 03:04:58 -07:00
|
|
|
if (err)
|
|
|
|
goto err_free_inst;
|
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
alg = crypto_spawn_skcipher_alg(spawn);
|
2012-12-28 03:04:58 -07:00
|
|
|
|
2007-12-17 06:34:32 -07:00
|
|
|
/* We only support 16-byte blocks. */
|
|
|
|
err = -EINVAL;
|
2016-07-11 23:17:37 -06:00
|
|
|
if (crypto_skcipher_alg_ivsize(alg) != CTR_RFC3686_BLOCK_SIZE)
|
2012-12-28 03:04:58 -07:00
|
|
|
goto err_drop_spawn;
|
2007-12-17 06:34:32 -07:00
|
|
|
|
|
|
|
/* Not a stream cipher? */
|
2016-07-11 23:17:37 -06:00
|
|
|
if (alg->base.cra_blocksize != 1)
|
2012-12-28 03:04:58 -07:00
|
|
|
goto err_drop_spawn;
|
2007-12-17 06:34:32 -07:00
|
|
|
|
2012-12-28 03:04:58 -07:00
|
|
|
err = -ENAMETOOLONG;
|
2016-07-11 23:17:37 -06: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 03:04:58 -07:00
|
|
|
goto err_drop_spawn;
|
2016-07-11 23:17:37 -06: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 03:04:58 -07:00
|
|
|
goto err_drop_spawn;
|
2007-12-17 06:34:32 -07:00
|
|
|
|
2016-07-11 23:17:37 -06: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 06:34:32 -07:00
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
|
2012-12-28 03:04:58 -07:00
|
|
|
|
2016-07-11 23:17:37 -06: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 06:34:32 -07:00
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
inst->alg.setkey = crypto_rfc3686_setkey;
|
|
|
|
inst->alg.encrypt = crypto_rfc3686_crypt;
|
|
|
|
inst->alg.decrypt = crypto_rfc3686_crypt;
|
2012-12-28 03:04:58 -07:00
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
inst->alg.base.cra_ctxsize = sizeof(struct crypto_rfc3686_ctx);
|
2007-11-30 03:38:37 -07:00
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
inst->alg.init = crypto_rfc3686_init_tfm;
|
|
|
|
inst->alg.exit = crypto_rfc3686_exit_tfm;
|
2007-12-17 06:34:32 -07:00
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
inst->free = crypto_rfc3686_free;
|
2007-12-17 06:34:32 -07:00
|
|
|
|
2016-07-11 23:17:37 -06:00
|
|
|
err = skcipher_register_instance(tmpl, inst);
|
|
|
|
if (err)
|
|
|
|
goto err_drop_spawn;
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
2007-12-17 06:34:32 -07:00
|
|
|
|
2012-12-28 03:04:58 -07:00
|
|
|
err_drop_spawn:
|
|
|
|
crypto_drop_skcipher(spawn);
|
|
|
|
err_free_inst:
|
|
|
|
kfree(inst);
|
2016-07-11 23:17:37 -06:00
|
|
|
goto out;
|
2007-12-17 06:34:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct crypto_template crypto_rfc3686_tmpl = {
|
|
|
|
.name = "rfc3686",
|
2016-07-11 23:17:37 -06:00
|
|
|
.create = crypto_rfc3686_create,
|
2007-12-17 06:34:32 -07:00
|
|
|
.module = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
[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-22 18:50:32 -06:00
|
|
|
static int __init crypto_ctr_module_init(void)
|
|
|
|
{
|
2007-12-17 06:34:32 -07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = crypto_register_template(&crypto_ctr_tmpl);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = crypto_register_template(&crypto_rfc3686_tmpl);
|
|
|
|
if (err)
|
|
|
|
goto out_drop_ctr;
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
|
|
|
|
out_drop_ctr:
|
|
|
|
crypto_unregister_template(&crypto_ctr_tmpl);
|
|
|
|
goto out;
|
[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-22 18:50:32 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit crypto_ctr_module_exit(void)
|
|
|
|
{
|
2007-12-17 06:34:32 -07:00
|
|
|
crypto_unregister_template(&crypto_rfc3686_tmpl);
|
[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-22 18:50:32 -06:00
|
|
|
crypto_unregister_template(&crypto_ctr_tmpl);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(crypto_ctr_module_init);
|
|
|
|
module_exit(crypto_ctr_module_exit);
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DESCRIPTION("CTR Counter block mode");
|
2014-11-20 18:05:53 -07:00
|
|
|
MODULE_ALIAS_CRYPTO("rfc3686");
|
2014-11-24 17:32:38 -07:00
|
|
|
MODULE_ALIAS_CRYPTO("ctr");
|