473,245 Members | 1,400 Online

# New lightweight block cipher algorithm

Dear all,

We have just developped a new block cipher called Raiden, following a
Feistel Network structure by means of genetic programming. Our
intention now consists on getting as much feedback as possible from
users, so we encourage you to test the algorithm and send us your
opinion. We would also like to receive enhancements and new versions of
the algorithm, developed in other source languages and platforms.

Our idea on developing this cipher is to propose it as an alternative
to TEA block cipher. TEA is a very interesting cipher with lots of real
applications. It is very simple and fast, and it reaches an acceptable
level of security by the application of a lot of cycles.

Nowadays TEA has been broken, and several weaknesses of the algorithm
have been discovered. Since most of these weaknesses are related to its
Key Shedule routine, the authors, Roger Needham and David Wheeler
proposed an extended version of the algorithm with a more complex one.
This new version, which they called XTEA, did not have the expected
success of its antecessor, in part because it is slower.

The algorithm known weaknesses, as well as its popularity, have made us
to think it was the time to develop an alternative to TEA. This

* It must be as quick as TEA, to be used in the same real world
applications
* It must be stronger, to avoid TEA weaknesses

To develop this new block cipher we have used a genetic
programming-based technique. More on this to follow in a coming
scientific paper.

Description of Raiden
----------------------------

Raiden is a very small and compact cipher. It works with blocks of 64
bits and keys of 128. As it can be seen below, the algorithm has the
same main structure as TEA: it is structured in cycles, where one cycle
contains two feistel rounds, and for both of them, the same round key
is used. In each round, the output of the round function on a sub block
is used to feed the other one. The round function of the algorithm has
the same size as TEA's one, but, as commented in section Raiden
Strength, it seems to be stronger.

The Key Schedule routine is more complex than TEA's, but it is simple
enough to not overload the cipher execution time. To maximize the
entropy introduced by this function, in each round, its output feeds
the position i%4 of the key array. This makes the key array passed to
the function to evolve as the algorithm is executed, and thus
generating new round keys for each cycle with that 128 bit array. This
also makes that function to behave much as a PRNG. After analyzing the
algorithm, as commented in it homepage
(http://raiden-cipher.sourceforge.net/ in the Results section), we
propose the execution of sixteen cycles. Below, the code of Raiden
encoding routine is shown.
void raiden(unsigned long *data,unsigned long *result,unsigned long
*key)
{

unsigned long b0=data[0],
b1=data[1],i,k[4]={key[0],key[1],key[2],key[3]}, sk;
for(i=0; i< 16; i++)
{
sk=k[i%4]=((k[0]+k[1])+((k[2]+k[3])^(k[0]<<k[2])));
b0 +=((sk+b1)<<9)^((sk-b1)^((sk+b1)>>14));
b1 +=((sk+b0)<<9)^((sk-b0)^((sk+b0)>>14));
}
result[0]=b0;
result[1]=b1;
}

The cipher receives the plain text in 'data' parameter, and puts the
cipher text in the 'result'. Key contains the 128 bit cipher key.
The cipher follows a Feistel structure, so the decoding is made in the
same way than the encoding but applying the round keys in the inverse
order. This is the Raiden decoding routine.

void decode_raiden(unsigned long *data,unsigned long *result,unsigned
long *key)
{

unsigned long b0=data[0],
b1=data[1],i,k[4]={key[0],key[1],key[2],key[3]},
subkeys[16];
for(i=0;i< 16;i++){
//Subkeys are calculated
k[i%4]=((k[0]+k[1])+((k[2]+k[3])^(k[0]<<k[2])));
subkeys[i]=k[i%4];
}
for(i=15; i!=-1; i--)
{
//Process is applied in the inverse order
b1 -= ((subkeys[i]+b0)<<9)^((subkeys[i]-b0)^
((subkeys[i]+b0)>>14));
b0 -= ((subkeys[i]+b1)<<9)^((subkeys[i]-b1)^
((subkeys[i]+b1)>>14));
}
result[0]=b0;
result[1]=b1;
}

In this case, the function receives the ciphertext in the 'data'
parameter and puts the plain text in the 'result'. The round keys are
calculated at the beginning of the function, and then they are applied
in the inverse order as they were when ciphering.

The algorithm is free to anyone, and has been developed in ANSI C
source code under Linux.
We propose you to develop new versions of it using other programming
languages and platforms.

Raiden Strength
---------------------

The main weaknesses of TEA, such as the Related Key Cryptanalysis, or
the equivalent keys, are related with its Key Shedule routine. Thus,
one of the main objectives when developing this new cipher has been to
develop an stronger Key Shedule function than TEA's.

The function developed is also very simple, but not as much as TEA's.
TEA Key Shedule function consists only on adding a constant
(0x9e3779b9) to a variable. Thus, it is very simple to, knowing the
round key of cycle i, obtain the keys corresponding to the previous and
the following cycles. This is not the case in our algorithm, in which
doing so it is not a trivial problem.

Therefore, the Key Shedule function behaves more as a Hash Function or
pseudorandom number generator, and does not have the same weaknesses as
TEA Key Schedule. Raiden's Round Function provided much better results
in the statistical tests than TEA's one, so we can conclude it is also
stronger, and, therefore, that the whole algorithm is also stronger.

When we analyzed the algorithm using the statistical tests ENT,
Diehard, NIST and Sexton, we realized that Raiden results when applied
16 cycles were, in many ocassions better, and at least comparable, to
TEA results when applied 32. This made us to conclude Raiden is
stronger than TEA and that 16 cycles would be an enough security margin
for the algorithm to be applied. The mentioned results can be consulted
in the Results of statistical tests on Raiden section at
http://raiden-cipher.sourceforge.net/

------------------------

Raiden has been developed by:

Julio Cesar Hernandez Castro, e-mail: jcesar_at_inf_dot_uc3m_dot_es
Javier Polimon Olabarrieta, jpolimon_at_gmail_dot_com

Don't hesitate to contact the authors with your feedback.

Oct 20 '06 #1
2 7234

On Fri, 20 Oct 2006, Julio C. Hernandez Castro wrote:
>
Dear all,
No kidding!
We have just developped a new block cipher called Raiden, following a
Feistel Network structure by means of genetic programming. Our
intention now consists on getting as much feedback as possible from
users, so we encourage you to test the algorithm and send us your
opinion. We would also like to receive enhancements and new versions of
the algorithm, developed in other source languages and platforms.
Is there a reason you crossposted this announcement to everywhere
on Usenet /except/ sci.crypt? Followups set.

(The rest of the post follows, untrimmed, for the benefit of sci.crypt

-Arthur

Our idea on developing this cipher is to propose it as an alternative
to TEA block cipher. TEA is a very interesting cipher with lots of real
applications. It is very simple and fast, and it reaches an acceptable
level of security by the application of a lot of cycles.

Nowadays TEA has been broken, and several weaknesses of the algorithm
have been discovered. Since most of these weaknesses are related to its
Key Shedule routine, the authors, Roger Needham and David Wheeler
proposed an extended version of the algorithm with a more complex one.
This new version, which they called XTEA, did not have the expected
success of its antecessor, in part because it is slower.

The algorithm known weaknesses, as well as its popularity, have made us
to think it was the time to develop an alternative to TEA. This

* It must be as quick as TEA, to be used in the same real world
applications
* It must be stronger, to avoid TEA weaknesses

To develop this new block cipher we have used a genetic
programming-based technique. More on this to follow in a coming
scientific paper.

Description of Raiden
----------------------------

Raiden is a very small and compact cipher. It works with blocks of 64
bits and keys of 128. As it can be seen below, the algorithm has the
same main structure as TEA: it is structured in cycles, where one cycle
contains two feistel rounds, and for both of them, the same round key
is used. In each round, the output of the round function on a sub block
is used to feed the other one. The round function of the algorithm has
the same size as TEA's one, but, as commented in section Raiden
Strength, it seems to be stronger.

The Key Schedule routine is more complex than TEA's, but it is simple
enough to not overload the cipher execution time. To maximize the
entropy introduced by this function, in each round, its output feeds
the position i%4 of the key array. This makes the key array passed to
the function to evolve as the algorithm is executed, and thus
generating new round keys for each cycle with that 128 bit array. This
also makes that function to behave much as a PRNG. After analyzing the
algorithm, as commented in it homepage
(http://raiden-cipher.sourceforge.net/ in the Results section), we
propose the execution of sixteen cycles. Below, the code of Raiden
encoding routine is shown.
void raiden(unsigned long *data,unsigned long *result,unsigned long
*key)
{

unsigned long b0=data[0],
b1=data[1],i,k[4]={key[0],key[1],key[2],key[3]}, sk;
for(i=0; i< 16; i++)
{
sk=k[i%4]=((k[0]+k[1])+((k[2]+k[3])^(k[0]<<k[2])));
b0 +=((sk+b1)<<9)^((sk-b1)^((sk+b1)>>14));
b1 +=((sk+b0)<<9)^((sk-b0)^((sk+b0)>>14));
}
result[0]=b0;
result[1]=b1;
}

The cipher receives the plain text in 'data' parameter, and puts the
cipher text in the 'result'. Key contains the 128 bit cipher key.
The cipher follows a Feistel structure, so the decoding is made in the
same way than the encoding but applying the round keys in the inverse
order. This is the Raiden decoding routine.

void decode_raiden(unsigned long *data,unsigned long *result,unsigned
long *key)
{

unsigned long b0=data[0],
b1=data[1],i,k[4]={key[0],key[1],key[2],key[3]},
subkeys[16];
for(i=0;i< 16;i++){
//Subkeys are calculated
k[i%4]=((k[0]+k[1])+((k[2]+k[3])^(k[0]<<k[2])));
subkeys[i]=k[i%4];
}
for(i=15; i!=-1; i--)
{
//Process is applied in the inverse order
b1 -= ((subkeys[i]+b0)<<9)^((subkeys[i]-b0)^
((subkeys[i]+b0)>>14));
b0 -= ((subkeys[i]+b1)<<9)^((subkeys[i]-b1)^
((subkeys[i]+b1)>>14));
}
result[0]=b0;
result[1]=b1;
}

In this case, the function receives the ciphertext in the 'data'
parameter and puts the plain text in the 'result'. The round keys are
calculated at the beginning of the function, and then they are applied
in the inverse order as they were when ciphering.

The algorithm is free to anyone, and has been developed in ANSI C
source code under Linux.
We propose you to develop new versions of it using other programming
languages and platforms.

Raiden Strength
---------------------

The main weaknesses of TEA, such as the Related Key Cryptanalysis, or
the equivalent keys, are related with its Key Shedule routine. Thus,
one of the main objectives when developing this new cipher has been to
develop an stronger Key Shedule function than TEA's.

The function developed is also very simple, but not as much as TEA's.
TEA Key Shedule function consists only on adding a constant
(0x9e3779b9) to a variable. Thus, it is very simple to, knowing the
round key of cycle i, obtain the keys corresponding to the previous and
the following cycles. This is not the case in our algorithm, in which
doing so it is not a trivial problem.

Therefore, the Key Shedule function behaves more as a Hash Function or
pseudorandom number generator, and does not have the same weaknesses as
TEA Key Schedule. Raiden's Round Function provided much better results
in the statistical tests than TEA's one, so we can conclude it is also
stronger, and, therefore, that the whole algorithm is also stronger.

When we analyzed the algorithm using the statistical tests ENT,
Diehard, NIST and Sexton, we realized that Raiden results when applied
16 cycles were, in many ocassions better, and at least comparable, to
TEA results when applied 32. This made us to conclude Raiden is
stronger than TEA and that 16 cycles would be an enough security margin
for the algorithm to be applied. The mentioned results can be consulted
in the Results of statistical tests on Raiden section at
http://raiden-cipher.sourceforge.net/

------------------------

Raiden has been developed by:

Julio Cesar Hernandez Castro, e-mail: jcesar_at_inf_dot_uc3m_dot_es
Javier Polimon Olabarrieta, jpolimon_at_gmail_dot_com

Don't hesitate to contact the authors with your feedback.

Oct 20 '06 #2
Julio C. Hernandez Castro wrote:
We have just developped a new block cipher called Raiden,
http://www.schneier.com/crypto-gram-...l#cipherdesign
--
Klaus Pommerening [http://www.staff.uni-mainz.de/pommeren/]
Institut für Medizinische Biometrie, Epidemiologie und Informatik
Johannes-Gutenberg-Universität, 55101 Mainz
Oct 23 '06 #3

This thread has been closed and replies have been disabled. Please start a new discussion.

### Similar topics

 4 by: Trevor Perrin | last post by: (I know this has come up before, but the previous discussions I could find seemed inconclusive, so I hope people don't mind...) Q: How about adding block ciphers to Python 2.4? PEP 272... 113 by: Bonj | last post by: I was in need of an encryption algorithm to the following requirements: 1) Must be capable of encrypting strings to a byte array, and decyrpting back again to the same string 2) Must have the same... 1 by: Sathyaish | last post by: I have the following scenario: Algorithm: 3DES Cipher Mode: CBC Key Size: 128-bit Block Size: 64 bit IV: 0x0000000000000000 (an eight byte array of zeros) The results I get using .NET with... 0 by: johnlim20088 | last post by: Hi, Currently I m doing a encryption with Microsoft Enterprise Enterlibrary Configuration. I does generated the encrypt and decrypt single string. I follow all the step, in creating... 2 by: yeruvavasavi | last post by: Algorithm 1: Write python programs to translate the following algorithm so that the computer can execute it. Algorithm for ceaser cipher. Plain: ABCDEFGHIJKLMNOPQRSTUVWXYZ