Encryption / Decryption Techniques

Introduction
Encryptiption is a method by which translate plain text data in to unreadable format ciphertext.
Decryption is the opposite process of encryption by which convert the unreadbale ciphertext data
to readable form. A key or passphrase is used to encrypt the data with the help of encryption
algorithms to create the cipher text. Main purpose of encryption is for data security, as it makes
difficult for an unauthorized user to decrypt the cyphertext without knowing the key. Longer and
complex keys based on strong algorithms can be difficult to guess and increase the security.
When selecting the encryption algorithm it is always good to choose the one which has been
using for long years with good track records. Nowadays encryption used in most of the
communication models such as wirless, websites, ATM machines, Files and all form of digital
transfers, credit card transactions etc.
This project objective is to create a key value from password provided by application user to
encrypt a text file in cipherform so that encrypted file can be decrypted with same passkey by an
authorized person.

Sample input string and its generated key using MD5

There are lot of encryption decryption techniques avaialble. Out of this main encryption
algorithms are DES, MD5, SHA-1. For this project to we are going to makes the ciphers using
DES. But it is better idea to review the strength and weakness of each of this algorithms for our
case study.
MD5 Algorithm
MD5 was developed by Ronald Rivest(1991) whos worked at MIT. MD5 algorith is the most
widely used encryption tehnique which generate 128 bit hash value. MD5 is mainly used for data
integrity checks. MD5 was developed as an updated version of MD4. This is done by
distrubuting pre computed MD5 checksum so that users can compare the checksum of download
file. Most of the linux operating systems shipped with MD5 utilities. MD5 encrypts using
variable length to fixed length output of 128 bits.
MD5 algorithm operations are bsed on 128-bit key,which is further divided into 4 type s of 32-
bits, which can be represented by A, B, C, and D. These 32bit words are initialised into some
kind of constants. The algorithm then utilise each type of 512-bit message block in turn to
modify the state. Message block process contain 4 same type of stages, know as rounds; these
rounds is composed of 16 similar operations based on a non-linear function F, modular addition,
and left rotation. MD5 hashes 128 bit into sequence of hexadecimal digits. As the number of
hashed bit are only 128 bits, it has higher collision rates compared to other algorithms.


Example of MD5 hash:
MD5("The main info is not here") =
9e107d9d372bb6826bd82d5542a419d6

Advantages and disadvantages of MD5
MD5 is not collision resistant. MD5 is not well suited for digital certificates and SSL certificates.
Security of MD5 is severly compromised in the past. MD5 digests are used in distributing
software applications to make sure that software files are not compromised. MD5 generate
message digest quicker than SHA-1. Especially if working with huge files for better securty,
DES is better and faster than SHA-1. MD used 128 bit algorithms and SHA-1 used 160 bit
algorithms for encryption. It is more quicket to calculate 128 bit digest for md5 when compared
with 160 bit digest for SHA-1. This DES is based on symmetric key based cryptography. Both
sender and reciver should exchange the key in a mutual understanding manner inorder for
safeguarding the data. Loosing or disclossure of key from either side can harmfull the
communication. DES had a bad track records of insecurities in its workflow in the past.
SHA-1 Algorithm
It was developed by Americas Security Agency NASA. 160 bits hashed value was produed by
this algorithm. SHA means for secure hash algorithm. SHA algorithms types are developed in
this order which are named as SHA-0 then SHA-1, SHA-2, and final one is SHA-3. First version
of SHA was published in 1993. SHA-1 is more popular and widely used. SHA-1 produce digest
almost in similar manner of MD5 algorithm. Most of the popular application protocols and
network protocols uses SHA-1. For example TLS, SSH, IPSec and SSL uses this algorithm and
some of the popular version control systems also implemented SHA-1.

SHA-1 mathematical calculation model.
An example of SHA-1 hashed value of string abc123 is as follows
6367c48dd193d56ea7b0baad25b19455e529f5ee
SHA-1 is known as one of the popular and secure hash algorithms
SHA-1 contains 6 main ctivities.
First step is the process by which by which append padding bits. The source message is
"extended through padding so that it will be of bits 448, modulo 512. Second step is to
appending the length by 64 bits to the padded source message to lenth of message in bytes. #rd
stages is to process using eighty functions which can be used as per the following operations.

4
th
stage include initialising process constants. This step requires almost eighty process contant
words which can be used follows

5
th
step is to initialse buffers with some initial values. Total 5 buffers are used for this
initialisation. Buffer initialisation as follows.

Final and last step is the message processing in 512-bit Blocks. This is the major step in SHA-1
algorithm. Padded and appended messages of blocks of 512 bits been iterated through .by
number of times in this step.
Advantages and disadvantges of SHA-1
Comparing to MD5, SHA-1 is more collision resistant. But in comarison SHA-1 is much more
stronger than MD5. Longer hash value generated makes less chance of collion of hash. SHA-1
generate longer hash value with better security.
DES algorithm
The Data Encryption Standard was designed and developed by US government and IBM as a
collaborated effort. DES uses a 56 bit pass key to work on 64 bit blocks of information.
Encryption of messages actually happends through iteration of 16 steps. Sixteen types of 48 bits
of keys are generated from the given pass key to the algorithm. Of of this 48 bits are used for
each rounds. In these each rounds 8 of them are calles S-boxes. In this S-box model group of 4
bits are mapped by 6 bits
Message block devided as two halfs. The right half needs to be exended from 32 to 48 bits using
a some kind of fixed table. The outcome of this added with subkey for that particular round
using the XOR logical operation. By the usage of S-boxes32 bit are genrated from 48 bits, which
is again going to be permutted with a another static table. Through this shuffled right half will
be combined with the left half by XOR logical operation.

DES algorithm diagram
DES considered to be less secure nowadays as because of its 56 bits key pattern. This 56 bit key
pattern is very small compared with SHA-1 and MD5.
Advantages and Disadvantages of DES
DES uses 56 bit key which is its biggest drawback. It uses symmetric key for encryption and
decryption. DES is less secure in all of these. DES is developed and designed mainly for
hardware implementations. So in software part, DES will work slowly compared with other
algorithms. DES is less seure compared with MD5 and SHA-1.

Algorithm Comparison
Factors MD5 DES SHA-1
Key length 128 64 160
Cipher type symmetric symmetric symmetric
Developed 1991 1977 1993
Cryptanalysis Medium strong
against attacks
Very low tolerance to
attacks
Hihly tolerant to
attacks
Security Medium Low High

Use of DES for the Context
As the main objective is to encrypt the text file, we will use DS technique. DES is relativly faster
and easier to implement. It uses 56 bit ciphers. So even large text files can be easily encrypted in
very short time. So DES is best relatively, faster and suits best for our study. In this project we
are not dealing with any highly secure data which need a very strong and complex encryption
ciphers like SHA-1 which uses 160 bit cipher relatively slow. DES is most widely used and
popular among all among all other encryption techniques. DES requires less time in generating
56bit cicpher compared with SHA-1s 160 bit cipher. So it is the best bet for this context.
In this project we are using a key not less than size of eight to create the cipher text. Java
application takes the input as the key . 56 bit cicpher key is generated from user provided key
which is used to encrypt the text file. Input file, encrypted file, decrypted file whose path can be
provided as input to the application. Application takes the file from provided input path and and
generate encrypted file using the DES hashed key.
Conclusion
As the wide spread of computer and internet, importance of digital data security and its
importance really need to safeguard the personal, organizational and financial information.
Various encryption algortithms and techniques made it difficult to scramble the encrypted data
from unauthorized access. Confidential data and information should be be preserved, since if it
gotten on the wrong hands, this might contribute to deterioration. So encryption and different
encryption techniques are importnant for computer netwroks, software application and digial
data.

Testing

Algorithm Data Time(seconds) Average MB/S Perfomance
MD5 512 MB 10 -11 23 - 24 Medium
DES 512 MB 7-9 18 High
SHA-1 512 MB 13-15 17-19 Low

Outputs
1. Input Key : This@123@wqd



2. Input Key : Eng@123@67890



3. Input Key: hjkdlewfl@jkdw



Code
EncryptionModel.java

package encryptionmodel; // define the package of this app as encryptionmodel
import javax.crypto.SecretKey;
import java.io.FileInputStream;
import javax.crypto.CipherInputStream;
import java.io.FileOutputStream;
// importing file read lib
import java.io.IOException;
// importing exp handler lib
import java.io.InputStream;
// importing input output lib
import java.io.InputStreamReader;
// importing input bufferr readerr
import java.io.OutputStream;
// importing ouput bufferr writter
import javax.crypto.SecretKeyFactory;
// import crypto factory lib
import javax.crypto.spec.DESKeySpec;
import java.io.BufferedReader;
// import input buffer eeader lib
import javax.crypto.Cipher;
// cipher handler lin
import javax.crypto.CipherOutputStream;


public class EncryptionModel {

public static void main(String[] args) {
try {
// encrption logic applied in this EncryptionModel's main method
String Mykey;
BufferedReader newInput = new BufferedReader(
new InputStreamReader(System.in));
// reading the key for encrpting files.
// key should be not less than eight chara
System.out.print ("Enter the password for encrypt the file : ");
// prin the message to vieewer
Mykey = newInput.readLine();
// above code read the encryption key
BufferedReader inputPathInput = new BufferedReader(
new InputStreamReader(System.in));
// for input file absolute filepath needed

System.out.print ("Enter input file path for encryption : ");

String inputFlePath;
// define var for input file info
inputFlePath = inputPathInput.readLine();

BufferedReader encryptedFileInput = new BufferedReader(
new InputStreamReader(System.in));
System.out.print ("Enter encrypted file path: ");
// read the location of file where encryted file stored
String encryptedFlePath;
// store encryptef ile path in var encryptedFlePath
encryptedFlePath = encryptedFileInput.readLine();
// read the path from input reader
BufferedReader decryptedFileInput = new BufferedReader(
new InputStreamReader(System.in));
System.out.print ("Enter decrypted file path: ");
// decrypted file location path also provides
String decryptedFlePath;
// store the decrypted file path
decryptedFlePath = decryptedFileInput.readLine();
//
FileInputStream fis111 = new FileInputStream(inputFlePath);
// read inputfilepath and its cfile contents
FileOutputStream fos = new FileOutputStream(encryptedFlePath);
encryptTextFile(Mykey, fis111, fos);
// create output file stream for encrypted file
FileInputStream fis222 = new FileInputStream(encryptedFlePath);
// create input encrypted file stream buffer
FileOutputStream fos222 = new FileOutputStream(decryptedFlePath);
// create out buffer with file stream for decrypted file info
decryptTextFile(Mykey, fis222, fos222);
} catch (Throwable e) {
// file stream exception error handler

e.printStackTrace();
}
}

public static void encryptTextFile(String Mykey, InputStream is11, OutputStream os11)
throws Throwable {
//
encryptOrDecryptTextFile(Mykey, Cipher.ENCRYPT_MODE, is11, os11);
// functionality for encrpty/decrypt
}

public static void decryptTextFile(String Mykey, InputStream is22, OutputStream os22)
throws Throwable {
// decrypt text file defnition
encryptOrDecryptTextFile(Mykey, Cipher.DECRYPT_MODE,is22, os22);
// functionality for decryption using pass key
}

// method for actual enc/dec logic in below function
public static void encryptOrDecryptTextFile(String Mykey, int mode, InputStream is33,
OutputStream os33) throws Throwable {

DESKeySpec dks = new DESKeySpec(Mykey.getBytes());
// get passkey as bytes and assign in var
SecretKeyFactory skf111 = SecretKeyFactory.getInstance("DES");
// initiate the DES algorithm model
SecretKey desKey222 = skf111.generateSecret(dks);
// gegerate cipher key
Cipher cipher1 = Cipher.getInstance("DES");

if (mode == Cipher.ENCRYPT_MODE) {
// check mode of encryption here.
cipher1.init(Cipher.ENCRYPT_MODE, desKey222);
// cipher input sreaming for creating the encrypted cipher
CipherInputStream cis33 = new CipherInputStream(is33, cipher1);
//
doCopyFun(cis33, os33);
} else if (mode == Cipher.DECRYPT_MODE) {
//
cipher1.init(Cipher.DECRYPT_MODE, desKey222);
// cicpher output buffer stream for decrypting
CipherOutputStream cos33 = new CipherOutputStream(os33, cipher1);
//
doCopyFun(is33, cos33);
}
}

public static void doCopyFun(InputStream is44, OutputStream os44) throws IOException
{
//
byte[] bytes11= new byte[64];
// creating bytes11 variable
int numBytes11;
while ((numBytes11 = is44.read(bytes11)) != -1) {
// file copying logic from encrption to decrypted file hre
os44.write(bytes11, 0, numBytes11);
}
os44.flush();
// closeing buffers
os44.close();

is44.close();
}

}

Build-impl.xml
<target if="${testng.available}" name="-init-macrodef-testng-debug">
<macrodef name="testng-debug" uri="http://www.netbeans.org/ns/j2se-project/3">
<attribute default="${main.class}" name="testClass"/>
<attribute default="" name="testMethod"/>
<element name="customize2" optional="true"/>
<sequential>
<condition else="-testclass @{testClass}" property="test.class.or.method" value="-
methods @{testClass}.@{testMethod}">
<isset property="test.method"/>
</condition>
<condition else="-suitename encryptionmodel -testname @{testClass}
${test.class.or.method}" property="testng.cmd.args" value="@{testClass}">
<matches pattern=".*\.xml" string="@{testClass}"/>
</condition>
<delete dir="${build.test.results.dir}" quiet="true"/>
<mkdir dir="${build.test.results.dir}"/>
<j2seproject3:debug classname="org.testng.TestNG"
classpath="${debug.test.classpath}">
<customize>
<customize2/>
<jvmarg value="-ea"/>
<arg line="${testng.debug.mode}"/>
<arg line="-d ${build.test.results.dir}"/>
<arg line="-listener org.testng.reporters.VerboseReporter"/>
<arg line="${testng.cmd.args}"/>
</customize>
</j2seproject3:debug>
</sequential>
</macrodef>
</target>
<target depends="-init-macrodef-testng-debug" if="${testng.available}" name="-init-
macrodef-testng-debug-impl">
<macrodef name="testng-debug-impl" uri="http://www.netbeans.org/ns/j2se-project/3">
<attribute default="${main.class}" name="testClass"/>
<attribute default="" name="testMethod"/>
<element implicit="true" name="customize2" optional="true"/>
<sequential>
<j2seproject3:testng-debug testClass="@{testClass}" testMethod="@{testMethod}">
<customize2/>
</j2seproject3:testng-debug>
</sequential>
</macrodef>
</target>
<target depends="-init-macrodef-junit-debug-impl" if="${junit.available}" name="-init-
macrodef-test-debug-junit">
<macrodef name="test-debug" uri="http://www.netbeans.org/ns/j2se-project/3">
<attribute default="${includes}" name="includes"/>
<attribute default="${excludes}" name="excludes"/>
<attribute default="**" name="testincludes"/>
<attribute default="" name="testmethods"/>
<attribute default="${main.class}" name="testClass"/>
<attribute default="" name="testMethod"/>
<sequential>
<j2seproject3:test-debug-impl excludes="@{excludes}" includes="@{includes}"
testincludes="@{testincludes}" testmethods="@{testmethods}">
<customize>
<classpath>
<path path="${run.test.classpath}"/>
</classpath>
<jvmarg line="${endorsed.classpath.cmd.line.arg}"/>
<jvmarg line="${run.jvmargs}"/>
<jvmarg line="${run.jvmargs.ide}"/>
</customize>
</j2seproject3:test-debug-impl>
</sequential>
</macrodef>
</target>
<target depends="-init-macrodef-testng-debug-impl" if="${testng.available}" name="-init-
macrodef-test-debug-testng">
<macrodef name="test-debug" uri="http://www.netbeans.org/ns/j2se-project/3">
<attribute default="${includes}" name="includes"/>
<attribute default="${excludes}" name="excludes"/>
<attribute default="**" name="testincludes"/>
<attribute default="" name="testmethods"/>
<attribute default="${main.class}" name="testClass"/>
<attribute default="" name="testMethod"/>
<sequential>
<j2seproject3:testng-debug-impl testClass="@{testClass}"
testMethod="@{testMethod}">
<customize2>
<syspropertyset>
<propertyref prefix="test-sys-prop."/>
<mapper from="test-sys-prop.*" to="*" type="glob"/>
</syspropertyset>
</customize2>
</j2seproject3:testng-debug-impl>
</sequential>
</macrodef>
</target>
<target depends="-init-macrodef-test-debug-junit,-init-macrodef-test-debug-testng" name="-
init-macrodef-test-debug"/>
<!--
pre NB7.2 profiling section; consider it deprecated
-->
<target depends="-profile-pre-init, init, -profile-post-init, -profile-init-macrodef-profile, -
profile-init-check" if="profiler.info.jvmargs.agent" name="profile-init"/>
<target if="profiler.info.jvmargs.agent" name="-profile-pre-init">
<!-- Empty placeholder for easier customization. -->
<!-- You can override this target in the ../build.xml file. -->
</target>
<target if="profiler.info.jvmargs.agent" name="-profile-post-init">
<!-- Empty placeholder for easier customization. -->
<!-- You can override this target in the ../build.xml file. -->
</target>
<target if="profiler.info.jvmargs.agent" name="-profile-init-macrodef-profile">
<macrodef name="resolve">
<attribute name="name"/>
<attribute name="value"/>
<sequential>
<property name="@{name}" value="${env.@{value}}"/>
</sequential>
</macrodef>
<macrodef name="profile">
<attribute default="${main.class}" name="classname"/>
<element name="customize" optional="true"/>
<sequential>
<property environment="env"/>
t>
<target depends="-init-ap-cmdline-properties,-init-ap-cmdline-supported" name="-init-ap-
cmdline">
<property name="ap.cmd.line.internal" value=""/>
<resolve name="profiler.current.path" value="${profiler.info.pathvar}"/>
<java classname="@{classname}" dir="${profiler.info.dir}" fork="true"
jvm="${profiler.info.jvm}">
<jvmarg line="${endorsed.classpath.cmd.line.arg}"/>
<jvmarg value="${profiler.info.jvmargs.agent}"/>
<jvmarg line="${profiler.info.jvmargs}"/>
<env key="${profiler.info.pathvar}"
path="${profiler.info.agentpath}:${profiler.current.path}"/>
<arg line="${application.args}"/>
<classpath>
<path path="${run.classpath}"/>
</classpath>
<syspropertyset>
<propertyref prefix="run-sys-prop."/>
<mapper from="run-sys-prop.*" to="*" type="glob"/>
</syspropertyset>
<customize/>
</java>
</sequential>
</macrodef>
</target>
<target depends="-profile-pre-init, init, -profile-post-init, -profile-init-macrodef-profile"
if="profiler.info.jvmargs.agent" name="-profile-init-check">
<fail unless="profiler.info.jvm">Must set JVM to use for profiling in
profiler.info.jvm</fail>
<fail unless="profiler.info.jvmargs.agent">Must set profiler agent JVM arguments in
profiler.info.jvmargs.agent</fail>
</target>
<!--
end of pre NB7.2 profiling section
-->
<target depends="-init-debug-args" name="-init-macrodef-nbjpda">
<macrodef name="nbjpdastart" uri="http://www.netbeans.org/ns/j2se-project/1">
<attribute default="${main.class}" name="name"/>
<attribute default="${debug.classpath}" name="classpath"/>
<attribute default="" name="stopclassname"/>
<sequential>
<nbjpdastart addressproperty="jpda.address" name="@{name}"
stopclassname="@{stopclassname}" transport="${debug-transport}">
<classpath>
<path path="@{classpath}"/>
</classpath>
</nbjpdastart>
</sequential>
</macrodef>
<macrodef name="nbjpdareload" uri="http://www.netbeans.org/ns/j2se-project/1">
<attribute default="${build.classes.dir}" name="dir"/>
<sequential>
<nbjpdareload>
<fileset dir="@{dir}" includes="${fix.classes}">
<include name="${fix.includes}*.class"/>
</fileset>
</nbjpdareload>
</sequential>
</macrodef>
</target>
<target name="-init-debug-args">
<property name="version-output" value="java version &quot;${ant.java.version}"/>
<condition property="have-jdk-older-than-1.4">
<or>
<contains string="${version-output}" substring="java version &quot;1.0"/>
<contains string="${version-output}" substring="java version &quot;1.1"/>
<contains string="${version-output}" substring="java version &quot;1.2"/>
<contains string="${version-output}" substring="java version &quot;1.3"/>
</or>
</condition>
<condition else="-Xdebug" property="debug-args-line" value="-Xdebug -Xnoagent -
Djava.compiler=none">
<istrue value="${have-jdk-older-than-1.4}"/>
</condition>
<condition else="dt_socket" property="debug-transport-by-os" value="dt_shmem">
<os family="windows"/>
</condition>
<condition else="${debug-transport-by-os}" property="debug-transport"
value="${debug.transport}">
<isset property="debug.transport"/>
</condition>
</target>
<target depends="-init-debug-args" name="-init-macrodef-debug">
<macrodef name="debug" uri="http://www.netbeans.org/ns/j2se-project/3">
<attribute default="${main.class}" name="classname"/>
<attribute default="${debug.classpath}" name="classpath"/>
<element name="customize" optional="true"/>
<sequential>
<java classname="@{classname}" dir="${work.dir}" fork="true">
<jvmarg line="${endorsed.classpath.cmd.line.arg}"/>
<jvmarg line="${debug-args-line}"/>
<jvmarg value="-Xrunjdwp:transport=${debug-
transport},address=${jpda.address}"/>
<jvmarg value="-Dfile.encoding=${runtime.encoding}"/>
<redirector errorencoding="${runtime.encoding}"
inputencoding="${runtime.encoding}" outputencoding="${runtime.encoding}"/>
<jvmarg line="${run.jvmargs}"/>
<jvmarg line="${run.jvmargs.ide}"/>
<classpath>
<path path="@{classpath}"/>
</classpath>
<syspropertyset>
<propertyref prefix="run-sys-prop."/>
<mapper from="run-sys-prop.*" to="*" type="glob"/>
</syspropertyset>
<customize/>
</java>
</sequential>
</macrodef>
</target>
<target name="-init-macrodef-java">
<macrodef name="java" uri="http://www.netbeans.org/ns/j2se-project/1">
<attribute default="${main.class}" name="classname"/>
<attribute default="${run.classpath}" name="classpath"/>
<attribute default="jvm" name="jvm"/>
<element name="customize" optional="true"/>
<sequential>
<java classname="@{classname}" dir="${work.dir}" fork="true">
<jvmarg line="${endorsed.classpath.cmd.line.arg}"/>
<jvmarg value="-Dfile.encoding=${runtime.encoding}"/>
<redirector errorencoding="${runtime.encoding}"
inputencoding="${runtime.encoding}" outputencoding="${runtime.encoding}"/>
<jvmarg line="${run.jvmargs}"/>
<jvmarg line="${run.jvmargs.ide}"/>
<classpath>
<path path="@{classpath}"/>
</classpath>
<syspropertyset>
<propertyref prefix="run-sys-prop."/>
<mapper from="run-sys-prop.*" to="*" type="glob"/>
</syspropertyset>
<customize/>
</java>
</sequential>
</macrodef>
</target>
<target name="-init-macrodef-copylibs">
<macrodef name="copylibs" uri="http://www.netbeans.org/ns/j2se-project/3">
<attribute default="${manifest.file}" name="manifest"/>
<element name="customize" optional="true"/>
<sequential>
<property location="${build.classes.dir}" name="build.classes.dir.resolved"/>
<pathconvert property="run.classpath.without.build.classes.dir">
<path path="${run.classpath}"/>
<map from="${build.classes.dir.resolved}" to=""/>
</pathconvert>
<pathconvert pathsep=" " property="jar.classpath">
<path path="${run.classpath.without.build.classes.dir}"/>
<chainedmapper>
<flattenmapper/>
<filtermapper>
<replacestring from=" " to="%20"/>
</filtermapper>
<globmapper from="*" to="lib/*"/>
</chainedmapper>
</pathconvert>
<taskdef classname="org.netbeans.modules.java.j2seproject.copylibstask.CopyLibs"
classpath="${libs.CopyLibs.classpath}" name="copylibs"/>
<copylibs compress="${jar.compress}" excludeFromCopy="${copylibs.excludes}"
index="${jar.index}" indexMetaInf="${jar.index.metainf}" jarfile="${dist.jar}"
manifest="@{manifest}" rebase="${copylibs.rebase}"
runtimeclasspath="${run.classpath.without.build.classes.dir}">
<fileset dir="${build.classes.dir}" excludes="${dist.archive.excludes}"/>
<manifest>
<attribute name="Class-Path" value="${jar.classpath}"/>
<customize/>
</manifest>
</copylibs>
</sequential>
</macrodef>
</target>
<target name="-init-presetdef-jar">
<presetdef name="jar" uri="http://www.netbeans.org/ns/j2se-project/1">
<jar compress="${jar.compress}" index="${jar.index}" jarfile="${dist.jar}">
<j2seproject1:fileset dir="${build.classes.dir}" excludes="${dist.archive.excludes}"/>
</jar>
</presetdef>
</target>
References
! Ciampa, Mark (2009). CompTIA Security+ 2008 in depth. Australia ; United States:
Course Technology/Cengage Learning. p. 290.
! Ming Mao and Shaohui Chen and Jin Xu (2009). "Construction of the Initial Structure for
Preimage Attack of MD5". International Conference on Computational Intelligence and
Security (IEEE Computer Society) 1: 442445.
! Schneier. Applied Cryptography (2nd ed.). p. 280.
! Stallings, W. Cryptography and network security: principles and practice. Prentice
Hall, 2006. p. 73
! Bruce Schneier, Applied Cryptography, Protocols, Algorithms, and Source Code in C,
Second edition, John Wiley and Sons, New York (1996) p. 267
! Levy, Crypto, p. 55
! P. Kinnucan (October 1978). "Data Encryption Gurus: Tuchman and Meyer".
Cryptologia 2 (4): 371.
! Florent Chabaud, Antoine Joux: Differential Collisions in SHA-0. CRYPTO 1998. pp56
71
! Henri Gilbert, Helena Handschuh: Security Analysis of SHA-256 and Sisters. Selected
Areas in Cryptography 2003: pp175193
! RFC 1321, section 2, "Terminology and Notation", Page 2.