Design and Analysis of SVKT Block Cipher
1. ABSTRACT
The most commonly used cryptosystem is DES. DES created a revolution in the field
of cryptography when it was first announced. However, the advancement in the cryptanalysis
techniques has rendered this technique as a weak algorithm. The original DES used a 64 bit
key and followed the standard Feistel cipher methodology in which the message was divided
into two parts and operations of permutation and substitution were performed on it. The key
schedule of the standard DES and its improved versions is easily obtainable because the
permutations are very simple. In this project, we have introduced a better and improved DES
in which we use a 112 bit key instead and also divide a 96 bit message block into 3 subblocks and use 2 functions f1 and f2 in each round. Each function uses different key (K1 and
K2 respectively). For the key schedule, we perform SHA 2 hash function on the initial key
and also successive rounds. Each hash value is 512 bit and is partitioned into 4 keys that can
be used for four successive rounds of the 3 block DES. The time required for cracking the
algorithm increases. This makes the key schedule much stronger. Dividing the message block
into 3 blocks instead of 2 and applying 2 different functions f1 and f2 at each round with two
different round sub-keys improves the complexity further. We also perform cryptanalysis of
our algorithm to test its strength using Cryptool. Also, we use established cryptanalytic
practices used to crack DES and attempt to make our algorithm invulnerable to such attacks.
Finally, we perform performance analysis of our algorithm, and establish a comprehensive
comparison of DES and our proposed algorithm.
Department of Computer Engineering, DJSCOE
Page 1
Design and Analysis of SVKT Block Cipher
2. REVIEW OF LITERATURE
The main base for our improved algorithm is the Data Encryption Standard. We referred
to some white papers on the original algorithm. DES (Data Encryption Standard) was the first
encryption standard to be recommended by NIST (National Institute of Standards and
Technology). It was developed by an IBM team around 1974 and adopted as a national
standard in 1997. The algorithm processes with an initial permutation, sixteen rounds block
cipher and a final permutation. DES application is very popular in commercial, military, and
other domains in the last decades. A major weakness of DES is its key schedule. Thus, as a
solution, we will be using SHA 2 to make the key more secure against cryptanalysis.
In cryptography, SHA-2 is a set of cryptographic hash functions (SHA-224, SHA-256,
SHA-384, SHA-512) designed by the National Security Agency(NSA) and published in 2001
by the NIST as a U.S. Federal Information Processing Standard. SHA stands for Secure Hash
Algorithm. SHA-2 includes a significant number of changes from its predecessor, SHA-1.
SHA-2 consists of a set of four hash functions with digests that are 224, 256, 384 or 512 bits.
In 2005, security flaws were identified in SHA-1, namely that a mathematical weakness
might exist, indicating that a stronger hash function would be desirable. Although SHA-2
bears some similarity to the SHA-1 algorithm, these attacks have not been successfully
extended to SHA-2. SHA 2 is a very strong algorithm used to compute a 512 bit hash value.
We will be using it for our key schedule in the modified DES rounds.
We also came across a white paper of modified DES (The improved Data Encryption
Standard (DES) Algorithm – by Sueng-Jo Han and Jongan Park). This paper describes an
enhanced DES algorithm in which the message block is divided into 3 sub-blocks and the
Feistel technique is slightly modified and applied to it. The complexity of the algorithm is
increased and hence its security. Thus, we have combined several improvements and have
changed the key schedule to make a new algorithm altogether.
Department of Computer Engineering, DJSCOE
Page 2
Design and Analysis of SVKT Block Cipher
3. PROBLEM DEFINITION WITH SCOPE OF THE PROJECT
The aim of this project is to minimize the weaknesses of the Data Encryption Standard.
3.1 Algorithm
The DES algorithm is insecure primarily due to the following reasons:
-
Small key length: 56 bits
-
Susceptible key schedule: The user password directly becomes the key for the first
round
-
Vulnerability to S-boxes to linear and differential cryptanalysis
By doubling the key length, changing the internal operation and fortifying the key schedule
using the SHA-512 algorithm for initial key generation, the proposed algorithm removes
several of DES’s known vulnerabilities. Splitting the 512-bit hash key into four parts also
ensures that consecutive round keys are not interdependent.
3.2 Scope:
The proposed algorithm can replace DES in multiple applications, especially the ones
requiring additional security. It can be used in innumerable areas of information security and
networking. Today, several new types of attacks like linear cryptanalysis and differential
cryptanalysis have made existing algorithms weak and vulnerable. SHA 2 is a very strong
hash function and will make it very difficult to crack. Thus, this algorithm can be used for
securing important information that is accessed over the internet. It can also be used on a
small scale such as securing confidential information within a company or organization.
Department of Computer Engineering, DJSCOE
Page 3
Design and Analysis of SVKT Block Cipher
4. PROPOSED SYSTEM
4.1 Pre-encryption
Initially the user enters a password which will be used as the input to our key generator. The
password can be of any length, but will generate only a 512-bit message digest. SHA-2
operations are performed on it to generate a new 512 bit hash key.
Figure 1 : SHA-512 internal working
One iteration in a SHA-2 family compression function. The blue components perform the
following operations:
>>> represents rotate right and the number corresponds to the number of bits rotated.
The 512 bit hash key produced will be divided into 4 parts of 128 bits each.
Department of Computer Engineering, DJSCOE
Page 4
Design and Analysis of SVKT Block Cipher
4.2 Key Schedule
This hash key is divided into 4 128-bit keys, which will be used for the first 4 rounds. This
eliminates a DES weakness of interdependence of round keys. After every 4 rounds, the keys
are modified using the SHA-2 algorithm. Decryption can be achieved by simply reversing the
encryption steps.
4.3 Internal working of SVKT rounds
Instead of the standard 56 bit DES, we will use a 112 bit key. Also, our modified DES
algorithm will be able to encrypt 96 bits of data at a time as against 64 bit in the earlier
versions. Instead of the standard feistel cipher technique, we will make a few additional
changes as follows:
Figure 2 : SVKT round structure
Department of Computer Engineering, DJSCOE
Page 5
Design and Analysis of SVKT Block Cipher
1) The 96 bit block will be divided into 3 blocks of 32 bits each (A, B, C).
2) We will use S3 S-boxes (S1 to S8) as shown below.
3) In each round, the generated 128 bit key is divided into two parts (k1 and k2) and the
appropriate function is performed.
4) The same function is used with two different 56 bit keys (reduced from 64 bit) is used in
each round.
5) The operations are as follows:
Encryption:
A(i) = B(i-1)
B(i) = C(i-1) exor f(B(i-1), K(2,i))
C(i) = A(i-1) exor f(B(i-1), K(1,i))
Decryption:
A(i-1) = C(i) exor f(A(i), K(2,i))
B(i-1) = A(i)
C(i-1) = B(i) exor f(A(i), K(1,i))
f1(B(i-1, K(1,i)) = P(S1(D1)…..S8(D8))
f2(B(i-1), K(2,i)) = P(S1(D9),….S8(D16))
We will perform the SHA 2 algorithm at the end of every four rounds as a part of our key
schedule. We will perform 16 or 8 rounds of modified DES Feistel technique, depending on
the user’s requirements of speed and security.
Since we are using SHA 2 for the key schedule after slightly modifying it, it serves to
increase the security of the key and makes it less vulnerable to attacks.
S3 DES S-boxes
These S3 DES boxes have been taken from the IEEE paper ‘Reconstruction of s2 DES Sboxes and their Immunity to Differential Cryptanalysis’. The paper proves that these S-boxes
are designed using a criteria which makes them immune to Differential Cryptanalysis without
changing the internal structure of the algorithm.
Department of Computer Engineering, DJSCOE
Page 6
Design and Analysis of SVKT Block Cipher
Department of Computer Engineering, DJSCOE
Page 7
Design and Analysis of SVKT Block Cipher
5. PROJECT MANAGEMENT
5.1 Schedule
5.1.1 Work Breakdown Structure
TASK
Start
End Date
No. of days
Date
Research Work
Referring to IEEE papers
Understanding existing algorithms
Study of Cryptography
Selection and consolidation of
suitable algorithms
Analysing strengths and weakness of
selected algorithms
Modification
Selecting areas to strengthen
Studying strengthening methods
Select and modify existing methods
Merge modified methods and finalize
algorithm
Algorithm Implementation
Select Platform
Create Round functions
Create function for Key Schedule
Merge created functions
Cryptanalysis
Find tools to analyse existing
algorithm
Study tool
Analyse results
User interface
Design GUI using developed
algorithm
Select platform of implementation
Coding
Testing
Debugging
Documentation
Project Report
UML diagrams
08/08/12
08/08/12
08/17/12
08/27/12
08/27/12
08/24/12
08/17/12
08/24/12
09/14/12
09/07/12
13
8
6
15
10
09/09/12
09/14/12
6
09/16/12
09/16/12
09/21/12
10/01/12
10/13/12
10/19/12
09/21/12
09/28/12
10/12/12
10/19/12
26
6
6
10
6
01/10/13
01/10/13
01/12/13
01/16/13
01/22/13
01/29/13
01/29/13
01/28/13
01/11/13
01/16/13
01/21/13
01/28/13
02/18/13
02/06/13
13
2
4
4
5
15
7
02/07/13
02/14/13
02/22/13
02/22/13
02/14/13
02/18/13
03/28/13
02/25/13
6
3
25
2
02/25/13
02/27/13
03/14/13
03/21/13
03/28/13
03/28/13
03/29/13
02/26/13
03/14/13
03/21/13
03/28/13
03/30/13
03/29/13
03/29/13
2
12
6
6
2
2
1
Figure 3 : Work breakdown structure
Department of Computer Engineering, DJSCOE
Page 8
Design and Analysis of SVKT Block Cipher
5.1.2 Timeline Chart
Table 2 : Timeline chart
Department of Computer Engineering, DJSCOE
Page 9
Design and Analysis of SVKT Block Cipher
5.2 Estimation (COCOMO & function point)
We will be using basic COCOMO as the cost estimation model for quick, early and rough
order of magnitude estimates of software costs. COCOMO uses 3 levels of project
complexity:
1. Organic project
2. Semi-detached project
3. Embedded project
Our project can be classified as a semi-detached mode project.
The equations in this model are:
E = ab(KLOC)bb
D = Cb(E)db
P=E/D
Where: E is the effort applied in person-months,
D is the development time in chronological months.
KLOC is the kilo-lines of code
The coefficients ab, bb, cb, db for semi-detached mode are as follows:
ab = 3.0
bb = 1.12
cb = 2.5
db = 0.35
Now, we assume that the estimated kilo-lines of code in our project are 5KLOC.
Effort Estimation:
E = 3.0 x (5)1.12
Department of Computer Engineering, DJSCOE
Page 10
Design and Analysis of SVKT Block Cipher
= 18.19
= 19 person-months approx.
Duration estimation:
D = 2.5 x (19)0.35
= 7.01
= 7 months approx.
Persons Estimation:
P = 19 / 7
= 2.72
= 3 persons approx.
a. FUNCTION POINT:
Considering average weighting factor for the project we have,
Number of user inputs=1
Number of user output = 1
Number of user enquiries = 0
Number of files = 5 (code, input, key, output, UI)
Number of external interfaces = 1
Count total = (1*4+1*5+0*4+5*10+1*7) = 66
Some of the countable measures considered are:
1.
Does the system require reliable backup and recovery?
2.
Is performance critical?
3.
Are the input, outputs, files or inquiries complex?
4.
Is the internal processing complex?
5.
Is the code designed to be reusable?
Department of Computer Engineering, DJSCOE
Page 11
Design and Analysis of SVKT Block Cipher
6.
Are conversions and installation included in the design?
7.
Is the system designed for multiple installations in different
organizations?
By assigning weights to these measures we have,
Function Point (FP) = Count total * (0.65 + (0.01 * sum(measures))
FP = 66 * (0.65 + (0.01 * 24)) = 59
5.3 Project Resources
5.3.1. Minimum Hardware requirements

128 MB RAM

300 MB of free Hard Disk Space (for JAVA installation)

Pentium 2 266MHz processor
5.3.2. Minimum Software requirements

Java development Kit (JDK)

Any Operating System with JAVA support

Cryptool
5.3.3. Operating environment

Any Operating System with JAVA support
Department of Computer Engineering, DJSCOE
Page 12
Design and Analysis of SVKT Block Cipher
6. PROJECT DESIGN
6.1 System Architecture
Figure 4 : System Architecture
Department of Computer Engineering, DJSCOE
Page 13
Design and Analysis of SVKT Block Cipher
6.2 Design Diagrams
6.2.1. Control flow
START
STOP
Figure 5 : Control flow
Department of Computer Engineering, DJSCOE
Page 14
Design and Analysis of SVKT Block Cipher
6.2.2. Use case diagram for application:
Figure 6 : Use case diagram
6.2.3. Activity diagram for application
Figure 7 : Activity diagram
Department of Computer Engineering, DJSCOE
Page 15
Design and Analysis of SVKT Block Cipher
6.2.4. Sequence Diagram
Figure 8 : Sequence diagram
6.2.5. State Transition Diagram
Figure 9 : State transition diagram
Department of Computer Engineering, DJSCOE
Page 16
Design and Analysis of SVKT Block Cipher
6.3. Data Design
6.3.1. Data flow diagram
Figure 10 : Data flow
Department of Computer Engineering, DJSCOE
Page 17
Design and Analysis of SVKT Block Cipher
7. PROJECT IMPLEMENTATION
7.1 Graphical User Interface design
Figure 11 : GUI
There are four sections in the user interface.
1. Text Area 1 – In this the user needs to enter the plain text which is to be encrypted.
2. Text Area 2 – In this the user needs to enter the key/password which is to be used to
encrypt the pain text.
3. Text Area 3 – This is used to display the rounds performed in the algorithm. It
displays the cipher text in BITSTRING and HEX after each round. At the end of the
algorithm, it displays the encrypted text in hex and also the decrypted text.
4. Text Area 4 – This is used to display the keys that are used in each round. If there are
multiple blocks of the plain text, then it displays the round keys of each block. This
Department of Computer Engineering, DJSCOE
Page 18
Design and Analysis of SVKT Block Cipher
section is also used to display the 4 keys generated by SHA-512 after each of its
execution.
7.2 Code
//Key Generator
public static String calc(String t) throws Exception{
MessageDigest digest = java.security.MessageDigest.getInstance("SHA-512");
digest.update(t.getBytes());
byte messageDigest[] = digest.digest();
// Create Hex String
StringBuffer hexString = new StringBuffer();
for (int i = 0; i < messageDigest.length; i++) {
String h = Integer.toHexString(0xFF & messageDigest[i]);
while (h.length() < 2)
h = "0" + h;
hexString.append(h);
}
return hexString.toString();
}
//In Round function
public static String func(StringBuffer msgblock,StringBuffer key)
{
String temp=key.toString();
String t=new BigInteger(temp,16).toString(2);
while(t.length()<64)
{
t="0"+t;
}
StringBuffer k1=new StringBuffer(t);
StringBuffer key1=new StringBuffer();
StringBuffer key2=new StringBuffer();
StringBuffer msg1=new StringBuffer();
//Performing PC1
for (int i=0;i<56;i++)
{
key1.append(k1.charAt(PC1[i]-1));
}
for (int i=0;i<48;i++)
{
key2.append(key1.charAt(PC2[i]-1));
}
for (int i=0;i<48;i++)
{
msg1.append(msgblock.charAt(expandTbl[i]-1));
}
Department of Computer Engineering, DJSCOE
Page 19
Design and Analysis of SVKT Block Cipher
BitSet msg=new BitSet(48);
for(int i=0;i<48;i++)
{
if(msg1.charAt(i)=='1')
msg.set(i);
}
BitSet keybits=new BitSet(48);
for(int i=0;i<48;i++)
{
if(key2.charAt(i)=='1')
keybits.set(i);
}
keybits.xor(msg);
StringBuffer result=new StringBuffer();
for(int i=0;i<48;i++)
if(keybits.get(i))
result.append("1");
else
result.append("0");
//Substitution 48 to 32 bits
String finalresult="";
for(int i=0,j=0;j<8;i+=6,j++)
{
int x=0;
int y=0;
if(Integer.parseInt(""+result.charAt(i))==1)
x+=2;
if(Integer.parseInt(""+result.charAt(i+5))==1)
x+=1;
if(Integer.parseInt(""+result.charAt(i+1))==1)
y+=8;
if(Integer.parseInt(""+result.charAt(i+2))==1)
y+=4;
if(Integer.parseInt(""+result.charAt(i+3))==1)
y+=2;
if(Integer.parseInt(""+result.charAt(i+4))==1)
y+=1;
int z=sboxes[j][x][y];
StringBuffer bitstring=new StringBuffer();
while(z!=0)
{
bitstring.append(z%2);
z/=2;
}
bitstring.reverse();
String bitstringfinal=new String(bitstring);
while(bitstringfinal.length()<4)
bitstringfinal="0"+bitstringfinal;
finalresult+=bitstringfinal;
}
return finalresult;
Department of Computer Engineering, DJSCOE
Page 20
Design and Analysis of SVKT Block Cipher
}
//Main
public static void main(String[] args) throws IOException, Exception{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String msg=new String();
StringBuffer msginbits=new StringBuffer();
String encryptedmsg=new String();
StringBuffer bitblock=new StringBuffer();
System.out.println("Enter a message");
msg=br.readLine();
char c[]=msg.toCharArray();
for(char t:c)
{
String g="";
int len=Integer.toBinaryString(t).length();
while(len<8)
{
g+="0";
len++;
}
msginbits.append(g+Integer.toBinaryString(t));
}
System.out.println(msginbits);
System.out.println("Enter Password");
String enterpwd=br.readLine();
String pwd=calc(enterpwd);
String keys[]=new String [16];
int i=0;
for(int k=0;k<4;k++)
{
int j=0;
int c1=0;
for(;c1<4;i++,c1++)
{
keys[i]=pwd.substring(j,j+32);
j+=32;
}
pwd=calc(pwd);
}
System.out.println(Arrays.toString(keys));
int len=msginbits.length();
int a=len/96;
int b=96-Math.abs(a*96-msginbits.length());
if(b!=0)
{ msginbits.append('1');
b--;
for(i=0;i<b;i++)
{
msginbits.append('0');
}
Department of Computer Engineering, DJSCOE
Page 21
Design and Analysis of SVKT Block Cipher
}
a++;
//divide into 96 bit blocks
int l=1;
StringBuffer msgblocks[]=new StringBuffer[a];
for(int k=0,p=0;k<a&&l<=a;l++,p+=96)
{
StringBuffer d=new StringBuffer(msginbits.substring(p,l*96));
msgblocks[l-1]=d;
}
msgblocks[a-1]=msgblocks[a-1].append(msginbits.charAt(msginbits.length()-1));
for( int m=0;m<a;m++)
{
//initial permutation
String temp="";
for(int p=0;p<96;p++)
{
temp+=msgblocks[m].charAt(IP[p]-1);
}
msgblocks[m]=new StringBuffer(temp);
StringBuffer A=null;
StringBuffer B=null;
StringBuffer C=null;
A=new StringBuffer(msgblocks[m].substring(0,32));
B=new StringBuffer(msgblocks[m].substring(32,64));
C=new StringBuffer(msgblocks[m].substring(64));
for(int n=0;n<=15;n++)
{
StringBuffer k1=new StringBuffer(keys[n].substring(0,16));
StringBuffer k2=new StringBuffer(keys[n].substring(16,32));
System.out.println(k1+"\t"+k2);
BitSet bitA=new BitSet(A.length());
for(i=0;i<A.length();i++)
if(A.charAt(i)=='1')
bitA.set(i);
BitSet bitB=new BitSet(B.length());
for(i=0;i<B.length();i++)
if(B.charAt(i)=='1')
bitB.set(i);
BitSet bitC=new BitSet(C.length());
for(i=0;i<C.length();i++)
if(C.charAt(i)=='1')
bitC.set(i);
A=B;
String t1=func(B,k2);
String t2=func(B,k1);
BitSet bitt1=new BitSet(32);
for(i=0;i<t1.length();i++)
if(t1.charAt(i)=='1')
bitt1.set(i);
BitSet bitt2=new BitSet(32);
for(i=0;i<t2.length();i++)
{
if(t2.charAt(i)=='1')
bitt2.set(i);
Department of Computer Engineering, DJSCOE
Page 22
Design and Analysis of SVKT Block Cipher
}
bitt1.xor(bitC);
bitt2.xor(bitA);
B=new StringBuffer();
C=new StringBuffer();
for(i=0;i<32;i++)
if(bitt1.get(i))
B.append("1");
else
B.append("0");
for(i=0;i<32;i++)
if(bitt2.get(i))
C.append("1");
else
C.append("0");
}
StringBuffer g=new StringBuffer(""+A+B+C);
temp="";
for(int p=0;p<96;p++)
temp+=g.charAt(invIP[p]-1);
g=new StringBuffer(temp);
encrypt+=g;
}
System.out.println("Encrypted Message:"+encrypt);
}
}
Department of Computer Engineering, DJSCOE
Page 23
Design and Analysis of SVKT Block Cipher
8. PROJECT TESTING
In our project the main objective of project testing is to ensure that all functions of the
algorithm are working properly. Apart from that, we need to ensure that the security of the
algorithm is at least on par, if not better than the existing system.
Our objective is to design tests that systematically uncover different classes of error and to do
so with minimum amount of time and effort. We will ensure that this happens by making sure
that the test cases are designed to reduce the redundancy to the minimum level, and ensure
that optimum amount of time and resources are employed to get the desired result in
minimum time.
We will take special care while designing the test cases that is we will use Black Box testing
to ensure that the individual components are in order and are effectively working to give
desired output; the ranges of all parameters will be tested dynamically to ensure that the real
time environment is well suited.
The white box testing will ensure that a combination of all possible components involved are
tested, so that their simultaneous evaluation can be gauged and thus if need be their
performance can be varied by bringing about a change in the development logic of the
respective model.
8.1 Test Plan
Testing is a set of activities that can be planned in advance and conducted systematically. In
our project, testing begins at the component level and works outward towards the integration
of the entire system. As soon as coding phase starts, the testing implicitly comes into play.
The various small test cases, which are there in a particular module, are being taken care of
while coding it. As soon as a particular module is completed, the whole module is tested for
its completeness and whether the software correctly implements a function or in a broad
sense a “Module”.
The Testing plan that we have implemented in our software as time progresses is as follows:
Unit Testing:
Unit testing tests if the smallest units of the software are working
satisfactorily. Unit testing started with the coding itself. It included testing single
rounds of the algorithm.
Integration Testing:
Integration testing is a systematic technique for constructing the program
structure while at the same time conducting tests to uncover errors associated with
interfacing and other planning. Interfaces in our software are tested completely and a
systematic approach is applied for this. The program was constructed and tested in
small increments, grouping two to three rounds at a time and testing them for
Department of Computer Engineering, DJSCOE
Page 24
Design and Analysis of SVKT Block Cipher
efficiency and improvement thus increasing the quality of the software.
System Testing:
System Testing is actually a series of different tests whose primary purpose is to
fully exercise the computer-based system. The whole system is tested as a whole here.
The various modules are together tested here so that if there’s any discrepancy, then it
could be determined and properly corrected. Also here the software is tested as a
whole as such it conforms to the requirements. Various tests that simulate full length
algorithm & check its strength in comparison to the existing standard are applied.
8.2 Test Case
As described the test plan above, the various test cases have been derived and tested by the
various persons involved in the software implementation. Test cases help to find out the
errors or flaws in the software and hardware and thus correct it and improve the quality.
Some of the test cases that we have applied are described below with the various modules:
TEST CASE 1:
Test case name: Plain text validation
Test case: To check plaintext using cryptool.
Prerequisites: 1) Cryptool
SR.NO
TEST
EXPECTED RESULT
DESCRIPTION
Checking plaintext Structured plaintext
for
all
cryptool
parameters
1.
PASS/FAIL
PASS
Table 3: Test case 1
Plain text is analyzed using Cryptool to examine its structure.
TEST CASE 2:
Test case name: Single round working validation
Test case: To check if single round is working properly.
Prerequisites: 1) Java Development Kit
Department of Computer Engineering, DJSCOE
Page 25
Design and Analysis of SVKT Block Cipher
This is a unit test to check the structure of each single round of the algorithm.
SR.NO
1.
TEST
DESCRIPTION
Checking
validity
and completeness of
single
round
operation. Do the
same for DES
EXPECTED RESULT
PASS/FAIL
66% of the input test
is changed. The
remaining stays
unchanged.
PASS
Table 4 : Test case 2
TEST CASE 3:
Test case name: Multiple rounds tested together.
Test case: To check if data is modified accurately.
Prerequisites: 1) Java Development Kit
2) Single round working is accurate
SR.NO
1.
TEST
DESCRIPTION
Check
multiple
rounds for proper
working
and
adequate
strength.
Do the same for
standard DES.
EXPECTED RESULT
PASS/FAIL
66% change between
round outputs. Increase
in confusion and
diffusion over a period
of rounds
PASS
Table 5 : Test case 3
This is an integration test used to check whether multiple rounds can function accurately.
TEST CASE 4:
Test case name: Full algorithm check
Test case: To check if algorithm executes correctly.
Prerequisites: 1) Java Development Kit
2) Single round is working correctly
3) Increase in confusion and diffusion over rounds
Department of Computer Engineering, DJSCOE
Page 26
Design and Analysis of SVKT Block Cipher
SR.NO
1.
TEST
DESCRIPTION
To check if entire
algorithm executes
correctly. Check 8
round and 16 round
SVKT.
Perform
cryptool analysis.
EXPECTED RESULT
PASS/FAIL
A decipherable
ciphertext is obtained.
This validates accurate
Feistel structure. Also,
the strength of the
algorithm reaches close
to its peak, without
excessive resource
utilization
PASS
Table 6 : Test case 4
This is a system test which checks the structure of the entire algorithm.
TEST CASE 5:
Test case name: Comparison with standard DES, 3DES and AES
Test case: To check if the results are comparable to standard DES, 3DES and AES
Prerequisites: 1) Java Development Kit
2) Single round is running
3) Increasing parameter values over rounds
4) Full Algorithm is running
SR.NO
1.
TEST
DESCRIPTION
To check if strength
of the algorithm is
comparable
to
standard DES, 3DES
and AES
EXPECTED RESULT
PASS/FAIL
Cryptool parameter
values which are on par,
if not better than
standard DES. As
additional reference,
3DES and AES are also
compared to our
algorithm.
PASS
Table 7 : Test case 5
This is a system test to comparatively analyze our algorithm with the existing ones.
Department of Computer Engineering, DJSCOE
Page 27
Design and Analysis of SVKT Block Cipher
8.3 Testing Methods
The tool used for performing cryptographic analysis is ‘Cryptool’
Cryptool is used to analyse the following factors of the text:
1) Entropy
Entropy is the planned disorder given to the set of cipher-text in a message. It might be made
up of several things that are mainly randomness, mathematical disfiguration and obfuscation.
Entropy is the measure of uncertainty associated with a random variable. In terms of
Cryptography, entropy must be supplied by the cipher for injection into the plaintext of a
message so as to neutralize the amount of structure that is present in the unsecure plaintext
message. The common notion of entropy is the notion of Shannon entropy. The Shannon
entropy H(x) of a value x that occurs with probability Pr[x]:
H(x) = -log_2(Pr[x])
you can interpret this as the uncertainty about x knowing only the distribution according to
which x is chosen. For the case of bit strings the important message is, the entropy not always
equals the bit length of x. I.e. if you want to seed a pseudorandom generator, it is important to
choose a seed with high entropy. If you use the actual time as seed the entropy of the seed is
very low, as everybody can easily guess parts of the seed (year, day, perhaps even hour and
minute).
2) Histogram
A histogram is a graphical representation showing a visual impression of the distribution of
data. It is an estimate of the probability distribution of a continuous variable and was first
introduced by Karl Pearson. A histogram consists of tabular frequencies, shown as lines
erected over discrete intervals (bins), with an area equal to the frequency of the observations
in the interval. The height of a line is also equal to the frequency density of the interval, i.e.,
the frequency divided by the width of the interval. A histogram may also be normalized
displaying relative frequencies. The categories are usually specified as consecutive, nonoverlapping intervals of a variable. The categories (intervals) must be adjacent, and often are
chosen to be of the same size.
3) N gram
What is N gram? An n-gram model is a type of probabilistic language model for predicting
the next item in such a sequence in the form of a –order Markov model. n-gram models are
now widely used in probability, communication theory, computational linguistics (for
instance, statistical natural language processing), computational biology (for instance,
biological sequence analysis), and data compression. The two core advantages[compared to?]
of n-gram models (and algorithms that use them) are relative simplicity and the ability to
scale up – by simply increasing n a model can be used to store more context with a wellunderstood space–time tradeoff, enabling small experiments to scale up very efficiently.
Department of Computer Engineering, DJSCOE
Page 28
Design and Analysis of SVKT Block Cipher
8.4 Test Results
TEST CASE 1
In the first test case we analyze the plain text which is the BYE message of VOIP.
Plaintext used for analysis
BYE message of VOIP
14:33:14.710 Wed 28 Mar 2012, 192.168.29.12:5060/udp (373 bytes): sent BYE
sip:alice@192.168.29.12:5070 SIP/2.0 Via: SIP/2.0/UDP
192.168.30.118:5080;rport;branch=z9hG4bK90155 Route: <sip:192.168.29.12;lr> MaxForwards: 70 To: Alice <sip:alice@192.168.29.12>;tag=c657427878e54118 From: Bob
<sip:bob@192.168.29.12>;tag=z9hG4bK60492682 Call-ID:308705092944@192.168.30.118
CSeq: 2 BYE User-Agent: mjsip stack 1.6 Content-Length: 0
Entropy
Figure 12 : Entropy of SVKT for BYE message plaintext of VOIP
Histogram
Figure 13 : Histogram for BYE message plaintext(SVKT)
Department of Computer Engineering, DJSCOE
Page 29
Design and Analysis of SVKT Block Cipher
Figure 14 : Histogram values for BYE message plaintext(SVKT)
Digram
Figure 15 : Digram values for BYE message plaintext (SVKT)
Department of Computer Engineering, DJSCOE
Page 30
Design and Analysis of SVKT Block Cipher
Trigram
Figure 16 : Trigram values for BYE message plaintext (SVKT)
Analysis:
As we can see the entropy is decently high. However, after encryption the entropy of the
cipher text will be higher which will be evident in the analysis shown below.
The characters are not very well spread in the text.
The digram and trigram analysis also prove that the occurrence of certain character sequences
is very high. Thus they are more probable than others and hence the plaintext is relatively
simple to predict.
TEST CASE 2:
Single round analysis of Data Encryption Standard.
Input message: a
Key: hello
ENTROPY
Round 1
Output: 020100006b160410
Department of Computer Engineering, DJSCOE
Page 31
Design and Analysis of SVKT Block Cipher
Figure 17 : Entropy of DES round 1
Histogram
Figure 18 : Histogram for round 1 of DES
Figure 19 : Histogram values for round 1 DES
Department of Computer Engineering, DJSCOE
Page 32
Design and Analysis of SVKT Block Cipher
Digram
Figure 20 : Digram values for round 1 DES
Trigram
Figure 21 : Trigram values for round 1 DES
Department of Computer Engineering, DJSCOE
Page 33
Design and Analysis of SVKT Block Cipher
Single round analysis of SVKT Block Cipher
The input given is character ‘a’
Hexadecimal input: 611000000000000000000000
Single round output: 00010020378f41ac352531b8
ENTROPY
Round 1
Figure 22 : Entropy of round 1 SVKT
Histogram
Figure 23 : Histogram of round 1 SVKT
Department of Computer Engineering, DJSCOE
Page 34
Design and Analysis of SVKT Block Cipher
Figure 24 : Histogram values of round 1 SVKT
Analysis:
The histogram as compared to that of the plaintext has clearly improved in terms of
the frequency of occurrence of certain characters.
Digram
Figure 25 : Digram values of round 1 SVKT
Department of Computer Engineering, DJSCOE
Page 35
Design and Analysis of SVKT Block Cipher
Trigram
Figure 26 : Trigram values for round 1 SVKT
Analysis:
As seen above the digram and trigram have also improved over those of the
plaintext.
TEST CASE 3:
SVKT Rounds 2 & 3
Round 2 Output 378f41ac0e48137affe1ec06
Histogram
Figure 27 : Histogram of round 2 SVKT
Department of Computer Engineering, DJSCOE
Page 36
Design and Analysis of SVKT Block Cipher
Figure 28 : Histogram values for round 2 SVKT
N-gram
Digram
Figure 29 : Digram for round 2 SVKT
Department of Computer Engineering, DJSCOE
Page 37
Design and Analysis of SVKT Block Cipher
Trigram
Figure 30 : Trigram for round 2 SVKT
Round 3 Output 0e48137ad7568df4d4a852c3
Histogram
Figure 31 : Histogram for round 3 SVKT
Department of Computer Engineering, DJSCOE
Page 38
Design and Analysis of SVKT Block Cipher
Figure 32 : Histogram values for round 3 SVKT
N-gram
Digram
Figure 33 : Digram for round 3 SVKT
Department of Computer Engineering, DJSCOE
Page 39
Design and Analysis of SVKT Block Cipher
Trigram
Figure 34 : Trigram for round 3 SVKT
Analysis for round 2 and round 3:
As seen from the figures above, the entropy goes on increasing as the rounds progress
indicating the structure is destroyed more and more. Also the histogram and ngram
analysis indicate that the frequency of particular characters or sequences is not very
high.
DES rounds 2 & 3
Round 2
Output: 6b160410963facc3
Figure 35 : Entropy of round 2 DES
Department of Computer Engineering, DJSCOE
Page 40
Design and Analysis of SVKT Block Cipher
Histogram
Figure 36 : Histogram of round 2 DES
Figure 37 : Histogram values for round 2 DES
Department of Computer Engineering, DJSCOE
Page 41
Design and Analysis of SVKT Block Cipher
Digram
Figure 38 : Digram values for round 2 DES
Trigram
Figure 39 : Trigram values for round 2 DES
Department of Computer Engineering, DJSCOE
Page 42
Design and Analysis of SVKT Block Cipher
Round 3
Output: 963facc3c863dbc5
Entropy
Figure 40 : Entropy for round 3 DES
Histogram
Figure 41: Histogram for round 3 DES
Figure 42 : Histogram values for round 3 DES
Department of Computer Engineering, DJSCOE
Page 43
Design and Analysis of SVKT Block Cipher
Digram
Figure 43 : Digram values for round 3 DES
Trigram
Figure 44 : Trigram values for round 3 DES
Analysis:
In the round by round analysis, we can see that as the rounds progress, the
histogram becomes better. Also, ideally the entropy should go on increasing in
each round. However, after round 3 the entropy reduces.
Department of Computer Engineering, DJSCOE
Page 44
Design and Analysis of SVKT Block Cipher
TEST CASE 4:
We analyse the cipher text of SVKT Block Cipher (8 rounds)
Analysis of SVKT Block Cipher (8 rounds)
Cipher Text
706aa252b21af34058d427340e02720ab675b4cbf7aaa36e465659880852156ef
49846cb5adde7c24415babe19d9f6bc70805b5bc5c2db1f89828079e461ebe873
70c1cf93a5119a6e298c0f9631fa842b1608251ac978b6604b4ec718f5193d42cf
1fdee8b318d40d59e88f45047b3ee3ef24e4b46045223e588f95d3c7b71835868
e2ba48566f69a9c7f9fd7840a42812e398085630c909373f0e6a650955eeade049
b3a71cfa7d98a99a866007c1396dd554c316b149ace7ea46895839872ab322efa
c55ee6a35ab833155d4cc088477a868cbdaa5e57b110bdd7cd5a6eface5eee4ccb
7556b6d25ca8cca6bc922894e55ede5fa12c990888c36b19f4b8d36a45650940c
0330eb79a1d3cf158a91aa8401db71d2d5b0394034fc3f662c4c109b1aaaf9270
1951d2d6eba5fc54b521605c9e1f74b4b592298db22e6c866925421d171514bf8
da4edf204007bbdda37a0f2b6e2d882cc902afd02bcec7ac69632297ec45efef5cf
059d081a2a57abc928ef82630dd1675bb4bba477a689c8c13c09d63c19cce7eb1
efd45b06f06b1b1d7d897d1a360c8c53b1b40bd09295e414eb83d4477001e7e4
4803d008a6375d7
Entropy
Figure 45 : Entropy for ciphertext (SVKT)
Histogram
Figure 46 : Histogram of ciphertext(SVKT)
Department of Computer Engineering, DJSCOE
Page 45
Design and Analysis of SVKT Block Cipher
Figure 47 : Histogram values for ciphertext(SVKT)
N-gram
Digram
Figure 48 : Digram for ciphertext (SVKT)
Department of Computer Engineering, DJSCOE
Page 46
Design and Analysis of SVKT Block Cipher
Trigram
Figure 49 : Trigram values for ciphertext(SVKT)
Analysis:
As we can see, the entropy is the same as that of DES. Also the graph of histogram is more or
less the same. However we can see that the di-gram of SVKT Block Cipher is better than that
of DES.
We analyse the cipher text of SVKT Block Cipher (16 rounds)
Cipher Text
4e41c97c3c293e11b75c882564c05168cce51339dc07641a6164d91cd6eff07a6
8dee269c94b562157c009d03cf7792102d2c190e2269b11987ef846c397b1b2b
0e58fe5fc82b0980ea1f11ece0c844463029590e36cb3f847910b761e33068a79e
ae0b04251958a9fb6908155ab9582055b9ef7d3d556a3eeb75331e86f700a6a88
33a2f9a8a181a8c3482823ed11e175bbed905dbd6b7f0f7bf3301a09fee23a12fb
8f8f60c65cd48677bdbffb478a8db4d06664c4ca72fdfa6a1611082cbf8c9d9c13
3c24126fe85834572d1179aae7e1e0f3693963a07a6f463ce17f513399440aacbd
fc6f6a16ed776c76b9e71e0cc33c34bc35f97a6476f43a001027bed8116b4bc9fb
cf0fcf02e7635b224f4fea197dae9d4fe66a3adf8548ab97509faa66e89954d7785
865a74045e89c4a79dd96f563bad5c41d0ba22da3ed194c160b79296b8af868cd
41884f02e192d5d2ee3fbd142fe61fcfc971ad81e0c741e202942633657610b5de
4f22096b2b61919ea08f892483d38196a5b0f68373842e6ff2af5a8d7cc3a30321
Department of Computer Engineering, DJSCOE
Page 47
Design and Analysis of SVKT Block Cipher
034f51ed040fdc30d45aea33e76a6af3a158979098f41bc7eea36c61f2a4e68be7
d62cf4c49
Entropy
Figure 50 : Entropy for SVKT 16 round
Histogram
Figure 51 : Histogram for SVKT 16 round
Department of Computer Engineering, DJSCOE
Page 48
Design and Analysis of SVKT Block Cipher
Figure 52 : Histogram values for SVKT 16 round
N-gram
Digram
Figure 53 : Digram values for SVKT 16 round
Department of Computer Engineering, DJSCOE
Page 49
Design and Analysis of SVKT Block Cipher
Trigram
Figure 54 : Trigram values for SVKT 16 round
Analysis:
As we can see, the di-gram of SVKT Block Cipher (16 rounds) is also better
than that of DES.
TEST CASE 5:
We analyse the cipher text of Data Encryption Standard.
Cipher Text
f5612bb3ed3d664067dd45c9ebb9ed3151fdd30345d85028de8b55eb6f1e7672d
26d47a884d9fb2a30de7a05b02cc751a33a7bdb231f2a7e5c1fbd1c4672eb895e
09a58e72eebb07b003602b39b733e69c8f63872d63236bb3066210c2d65a32dff
0b710f9c651e0e7a8efcf7317934ce02d6b14a81ee2346ecee82e85afa12d0511f
d4a1f1070841c5019ec88e3cbb75cb94d4b165a6af3af484239af6f5cd27824123
9c8c12504a106f93ebbf1f6c49a0afa23a6c89b6054aaa4efa223c4d3c5641f9be2
b9ee39e2d214b647458f77a2e8df53a6b0620ea0b3b0450c84a24a03a68f64d2d
5b26f876f153e6410362df3425da3b13129c5c5641f9be2b9ee398f2592597d82
bf0533864901a751b30e155c449f6e64461b131cf619f101aa633440ac8ed2744
e3887be95c3a8d63aabaa1ea5e33116d0a1e007a3f733be809487ad5b60781df0
36f8c9b62ef2d88c7d82be192245d84fed4c26a4f18c52bcead74aec2d4bd671bb
24464a8b91bf8e6c8e55f8a95da76bd98f68a1815b9a8bb2b5a80331087813c8f
9464b52ab533c5f0dfd0fc9b8dad53df2dff2ad57aabda049613ce3bee9a449d3ef
f87b8e48a5b9
Department of Computer Engineering, DJSCOE
Page 50
Design and Analysis of SVKT Block Cipher
Entropy
Figure 55 : Entropy for DES
Histogram
Figure 56 : Histogram for DES
Figure 57 : Histogram values for DES
Department of Computer Engineering, DJSCOE
Page 51
Design and Analysis of SVKT Block Cipher
Di-gram
Figure 58 : Digram values for DES
Trigram
Figure 59 : Trigram values for DES
Analysis:
As we can see, the entropy of the cipher text is very high.
From the graph of histogram, we can conclude that there are some characters
which occur more frequently than others.
From the N-gram analysis, we can see that the graph of the cipher text is more
or less flat.
Department of Computer Engineering, DJSCOE
Page 52
Design and Analysis of SVKT Block Cipher
Triple DES
Cipher text:
253ad5b03bf535014baedfc4d1ff01fa21ab521f1e427a7c972931d644c46883f239a19e07c193f
e895e21421d5cb764cc13cf34a5691a0318da293d234b8fa95c2ed5c76ad8fac49c27179c8061b
12c2fc5faea8abf1b969b8bda0586a2738eb231ca25638c1faf3ceafd8d6380e389c54c259aaa74
10a231ea4c3c3014f94c5f3a107da8b2f5e59e312225d8c4b1fd108e1142dac5f647dd4fa573e4c
a9e0e244117ee32988524d9ae21096d4190d8be01311e8565fb15c5793126721ed940d7fea915
d02ab88a31b562beda8ba54bc0486d0ca4609f6e166bdcfaa41a378bd833a5e27cccb6cf7dc634
54f44a5a172fcedfa43958e5351e07e325515949562b0e6f7cc03f7354024a4ace1b3c006a50f2d
1dadc4353dc9a708e257e16824765bd303d0bc960eb1f598ba0d1c0bece3b46f46ed80a1f4a515
0b18acd5c48e31d82328ec99ee5fdd4857dbddb489decbcdba635dc5dd82d3a0c2410eb58dc2b
d27b56987d20972a33043c261357ed22cb1fc680bf5b2b724cd41e5753d1df54a6891f9085cc7
963a6b6b41e7e0a97ce0ac5d5dbb208c3f9c83b5b6b63d8018d2090cf7a444fa66f
Entropy
Figure 60 : Entropy for 3DES
Histogram
Figure 61 : Histogram for 3DES
Department of Computer Engineering, DJSCOE
Page 53
Design and Analysis of SVKT Block Cipher
Figure 62 : Histogram values for 3 DES
N-gram
Digram
Figure 63 : Digram for 3DES
Department of Computer Engineering, DJSCOE
Page 54
Design and Analysis of SVKT Block Cipher
Trigram
Figure 64 : Trigram for 3DES
AES
Cipher text:
a13873541c7b5f25dc70ed5c55c74477186e5df73bd009dda90c38cbcb20771c4152e5e48d114
18424c1b5229cf231217750a6b0a7eb15933d59238a370925cb0503fd570431ef9532ac16ac49
06f885a1090c630bf259c2a86ab684cfd31874199dc4c3171a86f41a7456beb12536083bf0d42a
75baf53cb75a0e45af68363b175248f1c29572a76cef0d3f1c7eea091d1b229ae80f74902fa891e
9ab03e57506f2f9d1fdc5f0fd8200165a4546ffaade190a8b7fc84fc5518b85bb7102d125fd47a8
02b395f106adb0491565d91e4dd999918c2a515a9f799a0ceab544649cc9a981d8147872aa049
fcdf14199075e4198262ec03fb47aa3d028bc78d28d852b0e4bdc90f29447a151679d270e8e4c3
343388ea00bc127ebb6ab202ec855a396e5387da13f5de5c3e85e06b05b081c0c8effd8bedd21f
51e1a770291e7b4d0d92a34c6edcdaa026417304726fcf1c03b8167e3b8c358f4d897972c6afd9
e5e879a68c66e2e19aaf7d2b2989f4bc9135839a8f9c9420b225c6149f63075166a7fafa9e796f5
0866113d3f38fb613181e0916e75fc7ba99d487c523c921b949e36e5ab1f94b6a0c2458f92c37c
cf090fe66a37159276ba1e505a28bdd49c182e
Department of Computer Engineering, DJSCOE
Page 55
Design and Analysis of SVKT Block Cipher
Entropy
Figure 65 : Entropy for AES
Histogram
Figure 66 : Histogram for AES
Figure 67 :Histogram values for AES
Department of Computer Engineering, DJSCOE
Page 56
Design and Analysis of SVKT Block Cipher
Digram
Figure 68 : Digram values for AES
Trigram
Figure 69 : Trigram values for AES
Department of Computer Engineering, DJSCOE
Page 57
Design and Analysis of SVKT Block Cipher
TABLE OF COMPARISON
Parameter
DES
3DES
AES
SVKT(8
rounds)
SVKT(16
rounds)
Entropy
3.98
3.98
3.98
3.98
3.98
Histogram
range
39-65
38-64
46-70
39-65
43-67
Digram
range
7-12
6-9
7-8
6-10
7-10
Trigram
range
2-3
2-3
2-3
2-3
2-3
Table 8: Comparison
8.5. Performance Analysis
Our aim is to evaluate the performance of two algorithms (DES and our algorithm) for a
comparative study. To implement the two algorithms, we have coded the methods using the
same basic steps. This ensures that time and space requirements are comparable, and there is
no issue about difference in levels of optimization of both codes. The input plaintext used for
this purpose is the VoIP “BYE” message. The code has been implemented using the Java
language. The experiments were performed on a 2.33 GHZ Intel Core2Quad PC, with a 4 GB
RAM and Windows 7. A table of comparison is shown below:
Data Encryption Standard (DES)
DES modifies 32 bits per round and it
performs 16 such rounds. So, if there are x
blocks then the total data modified
effectively will be
32 bits* 16 rounds* x blocks
Department of Computer Engineering, DJSCOE
SVKT Block Cipher
SVKT modifies 64 bits per round and it
performs 8 such rounds. If there are y
blocks then in comparison to DES y=2/3*x.
So, the total data modified effectively will
be
64 bits* 8 rounds* 2/3*x.
Thus, as no. of blocks increases, memory
requirements of SVKT reduce in
comparison to DES.
Page 58
Design and Analysis of SVKT Block Cipher
Time required for DES execution (Input
VoIP BYE message): 57725937
nanoseconds
Assume that 1 evaluation of {DES} takes 10
operations, and we can
perform 1015 operations per second.
Trivially, that means we can evaluate 1014,
or about 246.5 {DES} encryptions per
second. This is a simplistic view: we are
ignoring here the cost of testing whether we
found the correct key, and the key schedule
cost.
So on our hypothetical machine, a 56-bit
DES key would take, on
average, 255/246.5=28.5≈362seconds to find.
Time Required for SVKT (8 round variant)
for same input: 73921261 nanoseconds
On the same hypothetical machine, a 112bit SVKT key would take, on average, 264.5
seconds= 235 years to crack.
The effective time taken to crack an entire
512-bit SHA-512 key is much greater.
Table 9 : Comparison of DES and SVKT
NETBEANS PROFILER
NetBeans profiler is a module to provide a full-featured profiling functionality for the
NetBeans IDE. The profiling functions include CPU, memory and threads profiling as well as
basic JVM monitoring, allowing developers to be more productive in solving memory or
performance-related issues.
In our testing, we have made use of the memory profiling feature of the NetBeans profiler.
The Analyze Memory Usage task gives you data on objects that have been allocated in the
target application such as the number, type and location of the allocated objects.
To analyze memory performance, you choose how much data you want to obtain by selecting
one of the following options.

Quick. When this option is selected, the profiler samples the application to provide
data that is limited to the live objects. This option only tracks live objects and does
not track allocations when instrumenting. It is not possible to record stack traces or to
use profiling points if you select this option. This option incurs a significantly lower
overhead than the Advanced option.

Advanced. When this option is selected application you can obtain information about
the number, type, and location of allocated objects. All classes that are currently
loaded by the target JVM (and each new class as it is loaded) are instrumented to
produce information about object allocations. You need to select this option if you
Department of Computer Engineering, DJSCOE
Page 59
Design and Analysis of SVKT Block Cipher
want to use profiling points when analyzing memory usage or if you want to record
the call stack. This option incurs a greater profiling overhead than the Quick option.
The output of the Advanced profiling task looks as follows:
Figures below show the memory requirements of both algorithms:
1. Standard DES
2. SVKT 8 round
As can be seen, the space requirements of both algorithms are very similar.
Department of Computer Engineering, DJSCOE
Page 60
Design and Analysis of SVKT Block Cipher
9. MAINTENANCE
9.1 User Manual
9.1.1 Getting Started
The UI can be started simply by running the UI frame file. A user
friendly GUI is displayed where the user can enter the input and key.
9.1.2 Key Generation
The Algorithm performs SHA-512 hashing to the input message to
obtain all round keys. These round keys can be checked for accuracy
using the “Display next 4 keys” option on the UI.
9.1.3 Using the Graphical User Interface to see working details
The GUI allows the user to input the data and key to run the algorithm.
The user can see round by round modifications on the data and every
round key. He can also verify the accuracy of the encryption by
checking decrypted output to match original plaintext.
9.2 Constraints for use of product
 The user system must be running Java
 The user must use either the UI implementation for understanding or the
direct Java code for speed as it eliminates redundant I/O operations
Department of Computer Engineering, DJSCOE
Page 61
Design and Analysis of SVKT Block Cipher
10. CONCLUSION
The aim of our work is to improve the security of the Data Encryption Standard algorithm by
proposing a new algorithm. In other words, this algorithm uses well renowned cryptographic
principles to eliminate known weaknesses of DES.
To enhance the security of the key schedule and make the algorithm non-susceptible to brute
force attacks, we have made use of a one way hash message digest for keying purposes. This
ensures that obtaining further round keys is not possible without cracking all 512 bits of the
message digest, and also ensures that all consecutive round keys have no known
dependencies.
In order to remove weaknesses to advanced cryptanalysis, we have made use of S3 s-boxes.
These s-boxes remove DES vulnerabilities to linear and differential cryptanalysis. Also, we
analyze our algorithm extensively using cryptool to obtain results proving our algorithm
obtains very high levels of confusion and diffusion.
Finally, we have designed a user interface to ensure ease of understanding of the algorithm
for the user, and to ensure that debugging operations in the future are supplemented
adequately.
Department of Computer Engineering, DJSCOE
Page 62
Design and Analysis of SVKT Block Cipher
11. FUTURE SCOPE
We can extend this algorithm in the future in the following ways:




Optimize implementation to ensure minimum possible use of critical resources
Make use of a simpler one-way function which provides similar levels of security as
SHA-512, thus reducing time required to encrypt.
Perform extensive linear and differential cryptanalysis of this algorithm to check for
any flaws.
Implement this algorithm in existing cryptosystems which currently use standard
DES.
Department of Computer Engineering, DJSCOE
Page 63
Design and Analysis of SVKT Block Cipher
12. REFERENCES
[1] M. E. Hellman,"DES will be totally insecure within ten years" lEEE Spectrum, Vo1.16,
N0.7,pp32-39, July 1979.
[2] NBS, "Data Encryption Standard," FIPS Pub. 46, U,S, National Bureau of Standards,
Washington DC, Jan. 1977.
[3] D. Coppersmith, " The data encryption standard (DES) and its strength against attacks,"
IBMJ ournal Research Dewlop. Vol. 38, No. 3, pp.243-250, 1994.
[4] E. Biham and A. Shamir, "Differential cryptanalysis of DES-like cryptosystem," Journal
of Cryptology, Vo1.4, No.1,1991.
[5] S. Even and 0. Goldriech, "DES-like Functions can Generate the Alternating Group,"
IEEE Trans. on IT, Vo1.29, pp.863-865, 1983.
[6] Kwangjo Kim, Sanjun Park, Sangin Lee, “Reconstruction of s2 DES S-boxes and their
Immunity to Differential Cryptanalysis” IEEE Korea-Japan, Joint Workshop on Information
Security and Cryptology, Oct, 1993
Department of Computer Engineering, DJSCOE
Page 64