 |
|
| Science Forum Index » Cryptography Forum » Strong 2048 bits block-cipher Algorithm... |
|
Page 1 of 1 |
|
| Author |
Message |
| aerr0... |
 Posted: Wed Oct 28, 2009 12:36 am |
|
|
|
Guest
|
Hello,
I've wrote a paper to explain the A2DCrypt strong 2048 b-c algo, And I
would like to know what people thinks about, because it looks like
strong, but is it ?
The software who uses this algo : http://www.netnavis.hostoi.com/a2dcrypt/setup.zip
The TEXT PAPER:
- - - > CUT HERE < - - -
A2dCrypt - 2048 bits Block-Cipher Encryption algorithm
-
- This document describes the A2DCrypt Algorithm. -
http://www.netnavis.hostoi.com/ <s-coder at (no spam) hotmail.com>
= = This document is the official description of the A2DCrypt Algorithm.
The
distribution of this document is unlimited. The commercial usage of
the
A2DCrypt Algorithm without the author's authorization is NOT ALLOWED.
= =
= = Table of Content:
1°) .................. Algoithm Overview
2°) .................. Key generation
3°) .................. Main Process
3.1 ........... Encryption
3.2 ........... Decryption
4°) .................. S-Boxes
5°) .................. Permutation algorithm
6°) .................. Contact the author
= = 1°) Algorithm Overview
A2DCrypt Algorithm is a powerfull 2048 bits encryption algorithm. It
takes for entry
a 2048 bits data-block, and as key a 2048 data-block too. At each new
data-block, a new
sub-key is generated, using the main key. The algorithm uses four 2048
bits Substitutions
boxes, used during the encryption/decryption process, or during the
subkey-generation
process. And, finaly, the A2DCrypt Algorithm uses a permutation
process on every data-block, before the encryption process, and after
the decryption process.
2°) Key generation
The A2DCrypt sub-key generation algorithm uses 3 statics variables
and the four S-Boxes
to generate a diferent and irregular new subkey. The sub-key (like the
main key) is a
2D 2048 bits (256 octets - 16 * 16) variable.
Algorithm:
At the beginning:
- m1, m2, m3 statics are initialised at 0
- UnderKeyBlockContent[16][16] is the subkey container.
It contain the last subkey during the key-generation.
- MainKey[][] is the key introduced at the beginning by user.
- The SBOX function is UNSIGNED CHAR SBOX(UNSIGNED CHAR Value,
UNSIGNED CHAR Select);
- "Select" is 0 < Select < 5, is the SBOX 1, 2, 3, or 4.
- Here, i = Y position, and j = X position, for example:
EXAMPLE[5][5]={ {0, 1, 2, 3, 4},
{1, 2, 3, 4, 0}, if y = 2
{2, 3, 4, 0, 1}, and x = 3
{3, 4, 0, 1, 2}, then the EXAMPLE[y][x] = EXAMPLE [2][3]
= 0;
{4, 0, 1, 2, 3} };
= = = >
static m1 = 0, m2 = 0, m3 = 0;
for(int i=0;i<256;i++) /* The Y position */
{
for(int j=0;j<256;j++) /* The X position */
{
m1 = m1 + MainKey[i][j];
if(i==0 and j>0) /* if we are not on the first byte of a line but
on the first line */
{
m2 = m2 + MainKey[i][j - 1] + ( SBOX(MainKey[i][j - 1], (MainKey[i]
[j]%4)+1 );
}
else if(i>0 and j==0) /* if we are on the first byte, but not on
the first line */
{
m2 = m2 + MainKey[i - 1][j] + ( SBOX(MainKey[i - 1][j], (MainKey[i]
[j]%4)+1 );
}
else if(i>0 and j>0) /* if we are not on the first byte of a line
and not on the first line */
{
m2 = m2 + MainKey[i - 1][j - 1] + SBOX(MainKey[i - 1][j - 1],
(MainKey[i][j]%4)+1 );
};
m3 = m3 + SBOX(m1, 0x01);
m3 = m3 + SBOX(m1, 0x02);
m3 = m3 + SBOX(m2, 0x03);
m3 = m3 + SBOX(m2, 0x04);
UnderKeyBlockContent[i][j] = UnderKeyBlockContent[i][j] + m3;
};
};
< = =
3°) Main Process
3.1) Encryption
The encryption process is used for every 2048 bits block, and uses
the 4 SBOXES, the generated
subkey, and a special function, called:
UNSIGNED CHAR FA2DCRYPT(UNSIGNED CHAR d1, UNSIGNED CHAR d2); /* d1
and d2 and bytes values */
This special function does a binary operation:
FA2DCRYPT(d1, d2) = (d1) XOR [ I1(d2) + I2(d2) ]
The I1 function:
/*
* Example: 01001011
* 01 | 00 | 10 | 11 => 00 | 01 |11 | 10
* A B C D => B A D C
*/
The I2 function:
/*
* Example: 01001011
* 0 | 10 | 0 | 10 | 11 => 0 | 11 | 0 | 10 | 10
* A B C D E => C E A B D
*/
= = = > Encryption < = = - The DataBlockContent[16][16] is the data-block value. all
operations are done on it.
- The DataBlockPermutation() is the permutation function, describes
next.
= = BuildKey(); /* Make the subkey */
DataBlockPermutation(); /* Permutation of the Data-Block */
for(int i=0;i<16;i++)
{
for(int j=0;j<16;j++)
{
DataBlockContent[i][j] = SBOX(DataBlockContent[i][j],
0x01);
DataBlockContent[i][j] = FA2DCRYPT(DataBlockContent[i][j],
UnderKeyBlockContent[i][j]);
DataBlockContent[i][j] = SBOX(DataBlockContent[i][j],
0x02);
DataBlockContent[i][j] = FA2DCRYPT(DataBlockContent[i][j],
UnderKeyBlockContent[i][j]);
DataBlockContent[i][j] = SBOX(DataBlockContent[i][j],
0x03);
DataBlockContent[i][j] = FA2DCRYPT(DataBlockContent[i][j],
UnderKeyBlockContent[i][j]);
DataBlockContent[i][j] = SBOX(DataBlockContent[i][j],
0x04);
DataBlockContent[i][j] = FA2DCRYPT(DataBlockContent[i][j],
UnderKeyBlockContent[i][j]);
};
};
= = = > Encryption < = =
3.2) Decryption
The decryption process is the reversed encryption process:
= = => Decryption < = = - REV_SBOX(UNSIGNED CHAR Value, Select) is the revers operation to
get the initial value before
the encryption sboxing.
BuildKey(); /* Make the subkey */
for(int i=0;i<16;i++)
{
for(int j=0;j<16;j++)
{
DataBlockContent[i][j] = FA2DCRYPT(DataBlockContent[i][j],
UnderKeyBlockContent[i][j]);
DataBlockContent[i][j] = REV_SBOX(DataBlockContent[i][j],
0x04);
DataBlockContent[i][j] = FA2DCRYPT(DataBlockContent[i][j],
UnderKeyBlockContent[i][j]);
DataBlockContent[i][j] = REV_SBOX(DataBlockContent[i][j],
0x03);
DataBlockContent[i][j] = FA2DCRYPT(DataBlockContent[i][j],
UnderKeyBlockContent[i][j]);
DataBlockContent[i][j] = REV_SBOX(DataBlockContent[i][j],
0x02);
DataBlockContent[i][j] = FA2DCRYPT(DataBlockContent[i][j],
UnderKeyBlockContent[i][j]);
DataBlockContent[i][j] = REV_SBOX(DataBlockContent[i][j],
0x01);
};
};
DataBlockPermutation(); /* Permutation of the Data-Block */
= = => Decryption < = =
4°) S-Boxes
The SBOXES are 4 2048 bits 2D constants:
SBOX_1[16][16]={
0x16, 0x15, 0x4b, 0x74, 0x08, 0xcf, 0xe5, 0x92, 0x2c, 0xb6, 0xa8,
0x91, 0xb3, 0xe7, 0x03, 0xa2,
0x0c, 0x6d, 0x1d, 0x7f, 0xf5, 0xc1, 0x1f, 0xf2, 0x27, 0x2f, 0x13,
0x9f, 0xc3, 0xb0, 0xf1, 0x78,
0xcb, 0x63, 0xbb, 0x6a, 0xd3, 0x5a, 0x73, 0x4f, 0xf7, 0x3b, 0xea,
0xda, 0xc5, 0xb9, 0x75, 0x17,
0xa1, 0xe4, 0xe6, 0x2e, 0x60, 0xd7, 0xb8, 0xf6, 0x8f, 0xfb, 0x83,
0x38, 0x86, 0x11, 0x97, 0xa3,
0x82, 0xdf, 0x0a, 0xb4, 0x68, 0xa4, 0xd8, 0xcc, 0x26, 0x35, 0xe1,
0x50, 0xd0, 0xd2, 0xaf, 0x7e,
0x5e, 0x14, 0x37, 0xbd, 0x2d, 0x25, 0x55, 0xeb, 0x85, 0xd4, 0x02,
0x22, 0x4d, 0x31, 0xab, 0xe2,
0x53, 0x87, 0x05, 0x00, 0x1c, 0xae, 0x39, 0x40, 0x64, 0x3a, 0x93,
0x20, 0xb2, 0x9b, 0x06, 0x0e,
0x90, 0x36, 0xb5, 0xc6, 0x56, 0x8a, 0x65, 0x2b, 0xc2, 0x18, 0x84,
0xbe, 0x54, 0x77, 0x4c, 0x41,
0x44, 0x24, 0xa5, 0xd6, 0xf4, 0xc9, 0x1e, 0x57, 0x7d, 0x5f, 0x5b,
0x0d, 0x34, 0x7b, 0xa7, 0xde,
0xb7, 0x1a, 0x0f, 0xfd, 0xff, 0x09, 0x69, 0x7c, 0x04, 0xac, 0xe9,
0xad, 0xe3, 0x52, 0x79, 0x7a,
0x2a, 0xcd, 0xbf, 0x89, 0x98, 0x3f, 0x6e, 0xf8, 0xbc, 0xb1, 0x72,
0x12, 0x71, 0x47, 0x33, 0x1b,
0x58, 0xca, 0x4a, 0x99, 0x3d, 0xed, 0x9a, 0x48, 0x8b, 0x8d, 0xf9,
0xa9, 0x6b, 0xf3, 0x45, 0xfa,
0xdd, 0x5d, 0xdc, 0xef, 0x19, 0xa0, 0xc0, 0x51, 0x8c, 0x4e, 0x3e,
0x70, 0x67, 0x49, 0xfe, 0xee,
0x01, 0x46, 0x96, 0x0b, 0x8e, 0x30, 0x42, 0xec, 0x6c, 0xf0, 0xd5,
0x9d, 0x28, 0xa6, 0xe0, 0x94,
0x76, 0xce, 0x29, 0xe8, 0xd1, 0xaa, 0x81, 0x9e, 0x10, 0x23, 0x5c,
0x61, 0xba, 0x66, 0xd9, 0x95,
0x80, 0x3c, 0x59, 0x6f, 0xc8, 0x32, 0x88, 0x43, 0x21, 0xfc, 0xc7,
0x07, 0xdb, 0x62, 0xc4, 0x9c};
SBOX_2[16][16]={
0x82, 0x89, 0xe3, 0x35, 0x11, 0x36, 0x8d, 0xa6, 0x1b, 0x64, 0x7f,
0x7d, 0x00, 0xb0, 0xe9, 0x94,
0x01, 0x1c, 0x93, 0x04, 0x9f, 0xb9, 0x9e, 0x81, 0x8f, 0xf0, 0xea,
0x06, 0xbc, 0x6b, 0x1d, 0x34,
0x16, 0xf1, 0x10, 0x0e, 0xe8, 0x1e, 0x51, 0xe5, 0x8c, 0xc4, 0xba,
0xbd, 0x5d, 0x73, 0xe6, 0xbe,
0xfa, 0x41, 0xc0, 0xe0, 0x6a, 0x3f, 0x71, 0xa2, 0xb5, 0xf7, 0x2d,
0xad, 0xbb, 0xdd, 0xca, 0xc2,
0x14, 0x0c, 0x48, 0x57, 0x53, 0x96, 0x5e, 0x75, 0x09, 0xb8, 0x97,
0xa4, 0x2e, 0x3a, 0xfc, 0xb2,
0xcd, 0x66, 0x7b, 0xa5, 0xd9, 0x0f, 0x12, 0x5b, 0xb7, 0xa9, 0xcc,
0xf8, 0x25, 0x3d, 0x0b, 0x8e,
0xac, 0xd4, 0x9a, 0xfd, 0x8a, 0x72, 0xb3, 0xec, 0x03, 0x5c, 0x7e,
0x29, 0xb4, 0x55, 0xf4, 0xc5,
0x62, 0x67, 0x9c, 0x2a, 0x88, 0x87, 0x6e, 0xf2, 0x44, 0x80, 0x1f,
0x37, 0x45, 0xfb, 0x0d, 0xc1,
0x21, 0xaf, 0x3e, 0x3b, 0xcf, 0x6f, 0x50, 0xfe, 0xce, 0x68, 0x7a,
0x4b, 0xf5, 0xd1, 0x22, 0xd7,
0x08, 0xe2, 0x60, 0x9d, 0x17, 0x3c, 0x42, 0xc3, 0xab, 0xd5, 0x84,
0x18, 0xf9, 0xa3, 0xb1, 0x28,
0x65, 0x47, 0x63, 0x56, 0xee, 0xc7, 0xaa, 0xd2, 0x32, 0x7c, 0x4a,
0xc9, 0x83, 0x4f, 0x9b, 0x13,
0xe7, 0x58, 0x33, 0x15, 0xff, 0x30, 0xde, 0x79, 0xbf, 0x43, 0xc6,
0xe1, 0xeb, 0x0a, 0xa1, 0x26,
0x61, 0xf6, 0x99, 0x49, 0xa7, 0x07, 0x85, 0x4c, 0x39, 0x78, 0x02,
0xc8, 0xd8, 0xef, 0x40, 0xdc,
0x77, 0x98, 0x31, 0xcb, 0xe4, 0x4e, 0xd0, 0xed, 0x70, 0x95, 0xd3,
0xae, 0xb6, 0x5a, 0x2f, 0xa0,
0x8b, 0x19, 0x86, 0x6c, 0x74, 0xdf, 0x05, 0x54, 0x38, 0x4d, 0xdb,
0x6d, 0xf3, 0xa8, 0x59, 0xda,
0x91, 0x27, 0x2c, 0x5f, 0x69, 0x2b, 0x24, 0x90, 0x1a, 0x20, 0x76,
0xd6, 0x92, 0x23, 0x52, 0x46};
SBOX_3[16][16]={
0xc0, 0x45, 0xbe, 0x27, 0x9a, 0xa6, 0x4b, 0x7d, 0x58, 0x21, 0xa8,
0x9e, 0x8a, 0x13, 0x80, 0xe1,
0x15, 0xd2, 0xfe, 0x00, 0x56, 0x6f, 0x46, 0x0e, 0xc4, 0xde, 0x7a,
0x5d, 0xf4, 0xca, 0x84, 0x77,
0xe8, 0xa9, 0x5a, 0xd7, 0x62, 0xb0, 0x0c, 0x31, 0xef, 0xd9, 0x9c,
0xbf, 0x52, 0xfa, 0x8d, 0x64,
0x69, 0x96, 0x7c, 0xc3, 0xa3, 0x4a, 0xf2, 0xce, 0xad, 0xec, 0x0f,
0xb3, 0x89, 0x66, 0xb2, 0xcb,
0xb8, 0xb7, 0xe4, 0xb1, 0x60, 0x8b, 0x71, 0xd1, 0xe5, 0x10, 0xc7,
0x3e, 0x99, 0x78, 0x51, 0x33,
0x6d, 0x79, 0xf9, 0x94, 0xa2, 0x85, 0x24, 0x95, 0x63, 0xcc, 0x73,
0x2f, 0x04, 0xd3, 0xb6, 0xd4,
0x1f, 0x91, 0xaa, 0x37, 0xb9, 0x2a, 0xba, 0x32, 0xbd, 0xae, 0x08,
0x65, 0xcd, 0x86, 0x12, 0xab,
0x05, 0x5b, 0x29, 0x01, 0x6e, 0xed, 0xf8, 0xa5, 0xe2, 0xdd, 0x6b,
0x81, 0x11, 0x0b, 0x61, 0xda,
0x26, 0xbc, 0xbb, 0x68, 0x14, 0xea, 0x7e, 0xfc, 0xf3, 0xeb, 0x41,
0x28, 0x3c, 0xf5, 0x1e, 0x17,
0x7f, 0x40, 0x44, 0xcf, 0x1b, 0x5e, 0x50, 0x5c, 0xc1, 0xf7, 0x20,
0xc8, 0xc6, 0x8f, 0xd5, 0x8e,
0xb5, 0xdf, 0x36, 0x03, 0x76, 0x98, 0xff, 0x1c, 0x1d, 0x9b, 0xa7,
0xfd, 0xa1, 0x8c, 0x35, 0x3b,
0x7b, 0x30, 0xac, 0x18, 0xe7, 0x4c, 0xee, 0x87, 0x4f, 0x83, 0x4d,
0xf1, 0xf0, 0x06, 0x2b, 0x23,
0x42, 0x92, 0xdc, 0xa4, 0x93, 0x02, 0x72, 0x6c, 0x34, 0x38, 0x97,
0x88, 0xc5, 0x0d, 0x2e, 0xd8,
0xe6, 0x4e, 0xc9, 0x70, 0xe9, 0x74, 0x9f, 0x2c, 0x0a, 0x67, 0x09,
0x53, 0x75, 0x2d, 0x54, 0xf6,
0x07, 0x16, 0xd0, 0x48, 0x19, 0x43, 0xfb, 0x6a, 0xb4, 0x39, 0x90,
0x1a, 0xd6, 0x49, 0x25, 0xa0,
0x59, 0x82, 0x47, 0x22, 0xdb, 0xe0, 0x9d, 0x57, 0x3d, 0xc2, 0x55,
0x3a, 0xaf, 0xe3, 0x3f, 0x5f};
SBOX_4[16][16]={
0xed, 0x12, 0xb1, 0x1e, 0xae, 0x64, 0x3d, 0x35, 0x77, 0x1f, 0x11,
0x56, 0x6a, 0xb5, 0xad, 0xea,
0xb4, 0xff, 0x96, 0x9b, 0x20, 0xf3, 0x08, 0x0d, 0x5e, 0xc2, 0x41,
0xdd, 0x37, 0x78, 0xb9, 0x5c,
0xf1, 0xa8, 0x52, 0x54, 0x00, 0xd8, 0xe7, 0x60, 0x67, 0x87, 0x90,
0x26, 0x83, 0x80, 0xfc, 0x23,
0x3a, 0xeb, 0x6c, 0x9e, 0xda, 0xa6, 0x17, 0xc7, 0x43, 0x4a, 0xb7,
0xc4, 0xd4, 0x24, 0x76, 0x32,
0x55, 0x9c, 0xa5, 0x65, 0x28, 0x0a, 0x14, 0x2c, 0xc9, 0xbb, 0xf7,
0xba, 0xf8, 0xc1, 0x09, 0x48,
0x79, 0x89, 0x22, 0xe8, 0x13, 0x8d, 0x4f, 0xb6, 0x0c, 0xbe, 0xf6,
0x7a, 0xcf, 0x07, 0x18, 0xce,
0xc5, 0xef, 0x58, 0x06, 0x2a, 0x6b, 0x81, 0x88, 0xe2, 0x74, 0x0f,
0xb8, 0x01, 0x4b, 0xcd, 0xd5,
0xd6, 0x86, 0x38, 0x45, 0x15, 0xa4, 0x46, 0x33, 0x1c, 0xd7, 0xf0,
0x53, 0xa9, 0xbc, 0x34, 0x50,
0x7e, 0xc8, 0x91, 0x31, 0xc6, 0xa3, 0xdc, 0x4d, 0x51, 0x3f, 0xf5,
0x7d, 0xe6, 0xfa, 0x92, 0xde,
0xee, 0xb3, 0x04, 0xdf, 0x9a, 0x29, 0x8f, 0x1d, 0xa0, 0xb2, 0x42,
0xa1, 0x73, 0x5b, 0x02, 0xaa,
0x75, 0xf9, 0x8e, 0xcc, 0x82, 0x5a, 0x39, 0xfb, 0x2f, 0xe3, 0xaf,
0x25, 0x61, 0xab, 0x4c, 0x16,
0x2b, 0x2d, 0xe5, 0xb0, 0x69, 0x8b, 0x40, 0xc0, 0xe0, 0x3e, 0x68,
0x57, 0x71, 0x27, 0x84, 0x21,
0x36, 0xe4, 0x1b, 0x7c, 0x7f, 0xec, 0xf4, 0xa2, 0xd9, 0x59, 0x44,
0x94, 0xfd, 0x5f, 0x72, 0x8c,
0x49, 0x0e, 0x5d, 0x6e, 0x03, 0x30, 0xd0, 0x93, 0x99, 0x7b, 0x1a,
0xbd, 0x3b, 0x47, 0x9d, 0x95,
0x62, 0xd2, 0xcb, 0x9f, 0x05, 0xfe, 0xe9, 0x63, 0xdb, 0x70, 0x19,
0xa7, 0x10, 0x8a, 0x0b, 0x66,
0x2e, 0x6f, 0xc3, 0xe1, 0xf2, 0xac, 0x85, 0x98, 0x6d, 0xbf, 0x4e,
0xca, 0xd3, 0xd1, 0x3c, 0x97};
= = =< >= = The SBOX Function takes for entry a byte, and returns a byte. To
select a value, the sbox function
take the 4 first low bits of the entry byte, and put the value
(0=<value=<15) on the X variable.
After, if takes the 4 last bits and put the value on the Y variable.
At the end, the returned
value is the byte SBOX[Y][X] of the selected SBOX.
For example: i = [10101111]binary, and the selected SBOX is 4:
SBOX_4[Y][X] of i is SBOX_4[1010][1111] = SBOX_4[10][15] = 0x16
So we have: i = 175, SBOX_4(i) = 22.
5°) Permutation algorithm
The permutation algorithm is simple: For a key[16][16] call k[16]
[16], and a data-block[16][16]
called d[16][16]:
= = => Permutation < = = - LAST_HIGHT_BITS(i), for example if i = [10101111]binary, are
LAST_HIGHT_BITS(i) = [00001010]binary
- FIRST_LOW_BITS(i), for example if i = [10101111]binary, are
FIRST_LOW_BITS(i) = [00001111]binary
for(int i=0;i<16;i++)
{
for(int j=0;j<16;j++)
{
BYTE a = d[i][j];
BYTE b = d[ LAST_HIGHT_BITS( k[i][j] ) ][ FIRST_LOW_BITS( k[i]
[j] ) ];
d[i][j] = b;
d[ LAST_HIGHT_BITS( k[i][j] ) ][ FIRST_LOW_BITS( k[i][j] ) ] = a;
};
};
= = => Permutation < = =
For the decryption, the permutation starts at the end of the data-
block: i = 16, j = 16 to i = 0, j = 0;
6°) Contact the author
Please if there is a bug, or if you like the A2DCrypt algorithm (or
not) send me an email
at: s-coder at (no spam) hotmail.com or visit http://www.netnavis.hostoi.com/
= = A2DCRYPT ALGORITHM OFFICIAL DESCRIPTION: END
= =
- - - > CUT HERE < - - - |
|
|
| Back to top |
|
|
|
| aerr0... |
| Posted: Wed Oct 28, 2009 2:22 am |
|
|
|
Guest
|
[quote]It appears to be horribly weak against a simple algebraic attack.
Joe
[/quote]
S-Boxes are made for the protection against algebraic attacks, built
with special properties.
please could you explain how did you find that it was weak against ? |
|
|
| Back to top |
|
|
|
| SG... |
| Posted: Wed Oct 28, 2009 3:15 am |
|
|
|
Guest
|
On 28 Okt., 11:36, aerr0 wrote:
[quote]
I've wrote a paper to explain the A2DCrypt strong 2048 b-c algo, And I
would like to know what people thinks about, because it looks like
strong, but is it ?
[/quote]
Probably not -- judging by the quality of your description alone.
[quote]This document is the official description of the A2DCrypt
Algorithm. The distribution of this document is unlimited.
The commercial usage of the A2DCrypt Algorithm without the
author's authorization is NOT ALLOWED.
[/quote]
1. Why would anybody WANT to use it?
2. Copyright doesn't apply to algorithms and I don't think
you filed a patent. So, I could do whatever I wanted
with your "algorithm" and you can't do anything about
it.
By the way: algorithm != source code.
Cheers,
SG |
|
|
| Back to top |
|
|
|
| aerr0... |
| Posted: Wed Oct 28, 2009 3:39 am |
|
|
|
Guest
|
Ok, for the quality, you're right. But "judging by the quality of your
description alone" isn't a serious argument to say that algorithm is
weak...
I was asking a mathematical reasoning...
Thank you for responding.. |
|
|
| Back to top |
|
|
|
| Joseph Ashwood... |
| Posted: Wed Oct 28, 2009 6:00 am |
|
|
|
Guest
|
"aerr0" <admin at (no spam) netnavis.hostoi.com> wrote in message
news:ef385068-90a7-43a6-b5b2-869b97777638 at (no spam) v30g2000yqm.googlegroups.com...
[quote]I've wrote a paper to explain the A2DCrypt strong 2048 b-c algo, And I
would like to know what people thinks about,
[/quote]
I think poorly formatted pseudo-code that is missing sections is about the
worst possible way to document a thrown together algorithm like this one.
[quote]because it looks like
strong, but is it ?
[/quote]
It appears to be horribly weak against a simple algebraic attack.
Joe |
|
|
| Back to top |
|
|
|
| Scott Fluhrer... |
| Posted: Wed Oct 28, 2009 8:37 am |
|
|
|
Guest
|
"aerr0" <admin at (no spam) netnavis.hostoi.com> wrote in message
news:d3242525-f051-4c9d-a0d5-30f59f8db88a at (no spam) d21g2000yqn.googlegroups.com...
[quote]Ok, for the quality, you're right. But "judging by the quality of your
description alone" isn't a serious argument to say that algorithm is
weak...
I was asking a mathematical reasoning...
[/quote]
You have that backwards, ciphers are not "presumed innocence until proven
guilty". Instead, a new cipher is presumed weak until strong evidence is
presented that it is not.
If you were hoping that people would give you evidence that the cipher is
strong, well, providing such evidence is hard, even in the best cases.
You're trying to rely on the goodness of strangers to give you free
analysis. If the description is poorly written or confusing, and misses key
details (such as the design criteria), well, you've made it that much harder
on a would-be volunteer. Hence, "your description is lousy" is a perfectly
good justification for not looking at a cipher (even had justification been
needed...). I won't promise you that someone would look at it if you did
write up a good description (don't forget your own analysis, for example,
why linear or differential cryptanalysis don't work), but it increases the
odds...
--
poncho |
|
|
| Back to top |
|
|
|
| Joseph Ashwood... |
| Posted: Thu Oct 29, 2009 1:22 am |
|
|
|
Guest
|
"aerr0" <admin at (no spam) netnavis.hostoi.com> wrote in message
news:6231f3f5-79aa-40d5-9362-124e6c830085 at (no spam) m16g2000yqc.googlegroups.com...
[quote]It appears to be horribly weak against a simple algebraic attack.
Joe
S-Boxes are made for the protection against algebraic attacks, built
with special properties.
[/quote]
Then what were the "special properties?" S-boxes are not necessarily a way
to increase the length of the algebraic equations in any significant way.
[quote]please could you explain how did you find that it was weak against ?
[/quote]
Express the algorithm as a set of algebraic equations, reduce, the length of
the ending equations determines the difficulty of applying an algebraic
attack. This is high school algebra.
Joe |
|
|
| Back to top |
|
|
|
| aerr0... |
| Posted: Fri Oct 30, 2009 1:50 am |
|
|
|
Guest
|
I'm at the hight school, and doing it is more difficult than it looks
like. But ok, I'll do it.
and the properties of my SBOX are such that the 8 input bits have at
least 4 bits of modified output, linked by any simple mathematical
operation.
thank you for your advice. |
|
|
| Back to top |
|
|
|
|
|
All times are GMT - 5 Hours
The time now is Sun Dec 06, 2009 2:10 am
|
|