Commit 5c4fe9a7 authored by Niels Möller's avatar Niels Möller

Documentation about ARCTWO.

Rev: src/nettle/nettle.texinfo:1.26
parent c90d29a1
......@@ -23,7 +23,7 @@
Draft manual for the Nettle library. This manual corresponds to version
Copyright 2001 @value{AUTHOR}
Copyright 2001, 2004 @value{AUTHOR}
Permission is granted to make and distribute verbatim
copies of this manual provided the copyright notice and
......@@ -172,6 +172,11 @@ by Rafael Sevilla. Released under the LGPL.
The implementation of the ARCFOUR (also known as RC4) cipher is written
by Niels Möller. Released under the LGPL.
@item ARCTWO
The implementation of the ARCTWO (also known as RC2) cipher is written
by Nikos Mavroyanopoulos and modified by Werner Koch and Simon
Josefsson. Released under the LGPL.
The implementation of the BLOWFISH cipher is written by Werner Koch,
copyright owned by the Free Software Foundation. Also hacked by Ray
......@@ -358,7 +363,7 @@ To start over, you can call @code{md5_init} at any time.
@subsection @acronym{MD2}
MD2 is another hash function of Ronald Rivests', described in
MD2 is another hash function of Ronald Rivest's, described in
@cite{RFC 1319}. It outputs message digests of 128 bits, or 16 octets.
Nettle defines MD2 in @file{<nettle/md2.h>}.
......@@ -699,6 +704,67 @@ them one after another. The result is the same as if you had called
@code{arcfour_crypt} only once with all the data.
@end deftypefun
@subsection ARCTWO
ARCTWO (also known as the trade marked name RC2) is a block cipher
specified in RFC 2268. Nettle also include a variation of the ARCTWO
set key operation that lack one step, to be compatible with the
reverse engineered RRC2 cipher description, as described in a Usenet
post to @code{sci.crypt} by Peter Gutmann.
ARCTWO uses a block size of 64 bits, and variable key-size ranging
from 1 to 128 octets. Besides the key, ARCTWO also has a second
parameter to key setup, the number of effective key bits, @code{ekb}.
This parameter can be used to artificially reduce the key size. In
practice, @code{ekb} is usually set equal to the input key size.
Nettle defines ARCTWO in @file{<nettle/arctwo.h>}.
We do not recommend the use of ARCTWO; the Nettle implementation is
provided primarily for interoperability with existing applications and
@deftp {Context struct} {struct arctwo_ctx}
@end deftp
@defvr Constant ARCTWO_BLOCK_SIZE
The AES block-size, 8
@end defvr
@defvr Constant ARCTWO_MIN_KEY_SIZE
@end defvr
@defvr Constant ARCTWO_MAX_KEY_SIZE
@end defvr
@defvr Constant ARCTWO_KEY_SIZE
Default ARCTWO key size, 8
@end defvr
@deftypefun void arctwo_set_key_ekb (struct arctwo_ctx *@var{ctx}, unsigned @var{length}, const uint8_t *@var{key}, unsigned @var{ekb})
@deftypefunx void arctwo_set_key (struct arctwo_ctx *@var{ctx}, unsigned @var{length}, const uint8_t *@var{key})
@deftypefunx void arctwo_set_key_gutmann (struct arctwo_ctx *@var{ctx}, unsigned @var{length}, const uint8_t *@var{key})
Initialize the cipher. The same function is used for both encryption
and decryption. The first function is the most general one, which lets
you provide both the variable size key, and the desired effective key
size (in bits). The maximum value for @var{ekb} is 1024, and for
convenience, @code{ekb = 0} has the same effect as @code{ekb = 1024}.
@code{arctwo_set_key(ctx, length, key)} is equivalent to
@code{arctwo_set_key_ekb(ctx, length, key, 8*length)}, and
@code{arctwo_set_key_gutmann(ctx, length, key)} is equivalent to
@code{arctwo_set_key_ekb(ctx, length, key, 1024)}
@end deftypefun
@deftypefun void arctwo_encrypt (struct arctwo_ctx *@var{ctx}, unsigned @var{length}, const uint8_t *@var{dst}, uint8_t *@var{src})
Encryption function. @var{length} must be an integral multiple of the
block size. If it is more than one block, the data is processed in ECB
mode. @code{src} and @code{dst} may be equal, but they must not
overlap in any other way.
@end deftypefun
@deftypefun void arctwo_decrypt (struct arctwo_ctx *@var{ctx}, unsigned @var{length}, const uint8_t *@var{dst}, uint8_t *@var{src})
Analogous to @code{arctwo_encrypt}
@end deftypefun
@subsection CAST128
CAST-128 is a block cipher, specified in @cite{RFC 2144}. It uses a 64
......@@ -1015,8 +1081,13 @@ struct, which is of size @code{context_size}.
@deftypevrx {Constant Struct} {struct nettle_cipher} nettle_twofish192
@deftypevrx {Constant Struct} {struct nettle_cipher} nettle_twofish256
@deftypevrx {Constant Struct} {struct nettle_cipher} nettle_arctwo40;
@deftypevrx {Constant Struct} {struct nettle_cipher} nettle_arctwo64;
@deftypevrx {Constant Struct} {struct nettle_cipher} nettle_arctwo128;
@deftypevrx {Constant Struct} {struct nettle_cipher} nettle_arctwo_gutmann128;
Nettle includes such structs for all the @emph{regular} ciphers, i.e.
ones without weak keys or other oddity.
ones without weak keys or other oddities.
@end deftypevr
@node Cipher Block Chaining, Keyed hash functions, Cipher functions, Reference
......@@ -2241,4 +2312,5 @@ End:
@c LocalWords: NIST Alice's GMP bignum Diffie Adi Shamir Adleman Euclid's ASN
@c LocalWords: PKCS callbacks Young's urtica dioica autoconf automake SSH tad
@c LocalWords: unguessability reseeding reseed alternatingly keysym subkeys
@c LocalWords: DSA gmp FIPS DSS libdes OpenSSL
@c LocalWords: DSA gmp FIPS DSS libdes OpenSSL ARCTWO Josefsson Nikos Andreas
@c LocalWords: Mavroyanopoulos Sigfridsson Comstedt interoperability
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment