Download this source code from our download section. This html file may contain errors due to markup.

/*

******************************************************************

This source code is under development. Even though you can use it as

such, it is recommended you check back after a few hours for an updated

version. The current version lacks descriptive comments also.

******************************************************************

*/

#include<stdio.h>

#include<string.h>

#include<malloc.h>

#include<math.h>

#include<stdlib.h>

#define rotateleft(x,n) ((x<<n) | (x>>(32-n)))

#define rotateright(x,n) ((x>>n) | (x<<(32-n)))

void SHA1(unsigned char * str1)

{

unsigned long int h0,h1,h2,h3,h4,a,b,c,d,e,f,k,temp;

h0 = 0x67452301;

h1 = 0xEFCDAB89;

h2 = 0x98BADCFE;

h3 = 0x10325476;

h4 = 0xC3D2E1F0;

unsigned char * str;

str = (unsigned char *)malloc(strlen((const char *)str1)+100);

strcpy((char *)str,(const char *)str1);

int current_length = strlen((const char *)str);

int original_length = current_length;

str[current_length] = 0x80;

str[current_length + 1] = '\0';

char ic = str[current_length];

current_length++;

int ib = current_length % 64;

if(ib<56)

ib = 56-ib;

else

ib = 120 - ib;

for(int i=0;i < ib;i++)

{

str[current_length]=0x00;

current_length++;

}

str[current_length + 1]='\0';

for(i=0;i<6;i++)

{

str[current_length]=0x0;

current_length++;

}

str[current_length] = (original_length *  / 0x100 ;

current_length++;

str[current_length] = (original_length *  % 0x100;

current_length++;

str[current_length+i]='\0';

int number_of_chunks = current_length/64;

unsigned long int word[80];

for(i=0;i<number_of_chunks;i++)

{

for(int j=0;j<16;j++)

{

word[j] = str[i*64 + j*4 + 0] * 0x1000000 + str[i*64 + j*4 + 1] * 0x10000 + str[i*64 + j*4 + 2] * 0x100 + str[i*64 + j*4 + 3];

}

for(j=16;j<80;j++)

{

word[j] = rotateleft((word[j-3] ^ word[j-8] ^ word[j-14] ^ word[j-16]),1);

}

a = h0;

b = h1;

c = h2;

d = h3;

e = h4;

for(int m=0;m<80;m++)

{

if(m<=19)

{

f = (b & c) | ((~b) & d);

k = 0x5A827999;

}

else if(m<=39)

{

f = b ^ c ^ d;

k = 0x6ED9EBA1;

}

else if(m<=59)

{

f = (b & c) | (b & d) | (c & d);

k = 0x8F1BBCDC;

}

else

{

f = b ^ c ^ d;

k = 0xCA62C1D6;

}

temp = (rotateleft(a,5) + f + e + k + word[m]) & 0xFFFFFFFF;

e = d;

d = c;

c = rotateleft(b,30);

b = a;

a = temp;

}

h0 = h0 + a;

h1 = h1 + b;

h2 = h2 + c;

h3 = h3 + d;

h4 = h4 + e;

}

printf("\n\n");

printf("Hash: %x %x %x %x %x",h0, h1, h2, h3, h4);

printf("\n\n");

}

void main()

{

SHA1((unsigned char *)"The quick brown fox jumps over the lazy dog");

}

– End of Source code –

License: No license. You are free to use this as you like.

Anyway if you use this source code, it would be nice if you could link back to us or give credit to the author.

Lot of work has gone into the development of this work. Anyway, thank you for visiting.

Author: Niyaz PK

The AES decryption source code in C/C++ is given below. Comments are given in separate color.

Download this source code from our download section. This html file may contain errors due to markup.

/*

******************************************************************

**       Advanced Encryption Standard implementation in C.      **

**       By Niyaz PK                                            **

**       E-mail: niyazlife@gmail.com                            **

**       Downloaded from Website: www.hoozi.com                 **

******************************************************************

This is the source code for decryption using the latest AES algorithm.

AES algorithm is also called Rijndael algorithm. AES algorithm is

recommended for non-classified use by the National Institute of Standards

and Technology(NIST), USA. Now-a-days AES is being used for almost

all encryption applications all around the world.

THE MAIN FEATURE OF THIS AES ENCRYPTION PROGRAM IS NOT EFFICIENCY; IT

IS SIMPLICITY AND READABILITY. THIS SOURCE CODE IS PROVIDED FOR ALL

TO UNDERSTAND THE AES ALGORITHM.

Comments are provided as needed to understand the program. But the

user must read some AES documentation to understand the underlying

theory correctly.

It is not possible to describe the complete AES algorithm in detail

here. For the complete description of the algorithm, point your

browser to:

http://www.csrc.nist.gov/publications/fips/fips197/fips-197.pdf

Find the Wikipedia page of AES at:

http://en.wikipedia.org/wiki/Advanced_Encryption_Standard

******************************************************************

*/

// Include stdio.h for standard input/output.

// Used for giving output to the screen.

#include<stdio.h>

// The number of columns comprising a state in AES. This is a constant in AES. Value=4

#define Nb 4

// The number of rounds in AES Cipher. It is simply initiated to zero. The actual value is recieved in the program.

int Nr=0;

// The number of 32 bit words in the key. It is simply initiated to zero. The actual value is recieved in the program.

int Nk=0;

// in – it is the array that holds the CipherText to be decrypted.

// out – it is the array that holds the output of the for decryption.

// state – the array that holds the intermediate results during decryption.

unsigned char in[16], out[16], state[4][4];

// The array that stores the round keys.

unsigned char RoundKey[240];

// The Key input to the AES Program

unsigned char Key[32];

int getSBoxInvert(int num)

{

int rsbox[256] =

{ 0×52, 0×09, 0x6a, 0xd5, 0×30, 0×36, 0xa5, 0×38, 0xbf, 0×40, 0xa3, 0x9e, 0×81, 0xf3, 0xd7, 0xfb

, 0x7c, 0xe3, 0×39, 0×82, 0x9b, 0x2f, 0xff, 0×87, 0×34, 0x8e, 0×43, 0×44, 0xc4, 0xde, 0xe9, 0xcb

, 0×54, 0x7b, 0×94, 0×32, 0xa6, 0xc2, 0×23, 0x3d, 0xee, 0x4c, 0×95, 0x0b, 0×42, 0xfa, 0xc3, 0x4e

, 0×08, 0x2e, 0xa1, 0×66, 0×28, 0xd9, 0×24, 0xb2, 0×76, 0x5b, 0xa2, 0×49, 0x6d, 0x8b, 0xd1, 0×25

, 0×72, 0xf8, 0xf6, 0×64, 0×86, 0×68, 0×98, 0×16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0×65, 0xb6, 0×92

, 0x6c, 0×70, 0×48, 0×50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0×15, 0×46, 0×57, 0xa7, 0x8d, 0x9d, 0×84

, 0×90, 0xd8, 0xab, 0×00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0×58, 0×05, 0xb8, 0xb3, 0×45, 0×06

, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0×02, 0xc1, 0xaf, 0xbd, 0×03, 0×01, 0×13, 0x8a, 0x6b

, 0x3a, 0×91, 0×11, 0×41, 0x4f, 0×67, 0xdc, 0xea, 0×97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0×73

, 0×96, 0xac, 0×74, 0×22, 0xe7, 0xad, 0×35, 0×85, 0xe2, 0xf9, 0×37, 0xe8, 0x1c, 0×75, 0xdf, 0x6e

, 0×47, 0xf1, 0x1a, 0×71, 0x1d, 0×29, 0xc5, 0×89, 0x6f, 0xb7, 0×62, 0x0e, 0xaa, 0×18, 0xbe, 0x1b

, 0xfc, 0×56, 0x3e, 0x4b, 0xc6, 0xd2, 0×79, 0×20, 0x9a, 0xdb, 0xc0, 0xfe, 0×78, 0xcd, 0x5a, 0xf4

, 0x1f, 0xdd, 0xa8, 0×33, 0×88, 0×07, 0xc7, 0×31, 0xb1, 0×12, 0×10, 0×59, 0×27, 0×80, 0xec, 0x5f

, 0×60, 0×51, 0x7f, 0xa9, 0×19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0×93, 0xc9, 0x9c, 0xef

, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0×83, 0×53, 0×99, 0×61

, 0×17, 0x2b, 0×04, 0x7e, 0xba, 0×77, 0xd6, 0×26, 0xe1, 0×69, 0×14, 0×63, 0×55, 0×21, 0x0c, 0x7d };

return rsbox[num];

}

int getSBoxValue(int num)

{

int sbox[256] =   {

//0     1    2      3     4    5     6     7      8    9     A      B    C     D     E     F

0×63, 0x7c, 0×77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0×30, 0×01, 0×67, 0x2b, 0xfe, 0xd7, 0xab, 0×76,

0xca, 0×82, 0xc9, 0x7d, 0xfa, 0×59, 0×47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0×72, 0xc0,

0xb7, 0xfd, 0×93, 0×26, 0×36, 0x3f, 0xf7, 0xcc, 0×34, 0xa5, 0xe5, 0xf1, 0×71, 0xd8, 0×31, 0×15,

0×04, 0xc7, 0×23, 0xc3, 0×18, 0×96, 0×05, 0x9a, 0×07, 0×12, 0×80, 0xe2, 0xeb, 0×27, 0xb2, 0×75,

0×09, 0×83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0×52, 0x3b, 0xd6, 0xb3, 0×29, 0xe3, 0x2f, 0×84,

0×53, 0xd1, 0×00, 0xed, 0×20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0×39, 0x4a, 0x4c, 0×58, 0xcf,

0xd0, 0xef, 0xaa, 0xfb, 0×43, 0x4d, 0×33, 0×85, 0×45, 0xf9, 0×02, 0x7f, 0×50, 0x3c, 0x9f, 0xa8,

0×51, 0xa3, 0×40, 0x8f, 0×92, 0x9d, 0×38, 0xf5, 0xbc, 0xb6, 0xda, 0×21, 0×10, 0xff, 0xf3, 0xd2,

0xcd, 0x0c, 0×13, 0xec, 0x5f, 0×97, 0×44, 0×17, 0xc4, 0xa7, 0x7e, 0x3d, 0×64, 0x5d, 0×19, 0×73,

0×60, 0×81, 0x4f, 0xdc, 0×22, 0x2a, 0×90, 0×88, 0×46, 0xee, 0xb8, 0×14, 0xde, 0x5e, 0x0b, 0xdb,

0xe0, 0×32, 0x3a, 0x0a, 0×49, 0×06, 0×24, 0x5c, 0xc2, 0xd3, 0xac, 0×62, 0×91, 0×95, 0xe4, 0×79,

0xe7, 0xc8, 0×37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0×56, 0xf4, 0xea, 0×65, 0x7a, 0xae, 0×08,

0xba, 0×78, 0×25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0×74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,

0×70, 0x3e, 0xb5, 0×66, 0×48, 0×03, 0xf6, 0x0e, 0×61, 0×35, 0×57, 0xb9, 0×86, 0xc1, 0x1d, 0x9e,

0xe1, 0xf8, 0×98, 0×11, 0×69, 0xd9, 0x8e, 0×94, 0x9b, 0x1e, 0×87, 0xe9, 0xce, 0×55, 0×28, 0xdf,

0x8c, 0xa1, 0×89, 0x0d, 0xbf, 0xe6, 0×42, 0×68, 0×41, 0×99, 0x2d, 0x0f, 0xb0, 0×54, 0xbb, 0×16 };

return sbox[num];

}

// The round constant word array, Rcon[i], contains the values given by

// x to th e power (i-1) being powers of x (x is denoted as {02}) in the field GF(2^8)

// Note that i starts at 1, not 0).

int Rcon[255] = {

0x8d, 0×01, 0×02, 0×04, 0×08, 0×10, 0×20, 0×40, 0×80, 0x1b, 0×36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,

0x2f, 0x5e, 0xbc, 0×63, 0xc6, 0×97, 0×35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0×91, 0×39,

0×72, 0xe4, 0xd3, 0xbd, 0×61, 0xc2, 0x9f, 0×25, 0x4a, 0×94, 0×33, 0×66, 0xcc, 0×83, 0x1d, 0x3a,

0×74, 0xe8, 0xcb, 0x8d, 0×01, 0×02, 0×04, 0×08, 0×10, 0×20, 0×40, 0×80, 0x1b, 0×36, 0x6c, 0xd8,

0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0×63, 0xc6, 0×97, 0×35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,

0xc5, 0×91, 0×39, 0×72, 0xe4, 0xd3, 0xbd, 0×61, 0xc2, 0x9f, 0×25, 0x4a, 0×94, 0×33, 0×66, 0xcc,

0×83, 0x1d, 0x3a, 0×74, 0xe8, 0xcb, 0x8d, 0×01, 0×02, 0×04, 0×08, 0×10, 0×20, 0×40, 0×80, 0x1b,

0×36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0×63, 0xc6, 0×97, 0×35, 0x6a, 0xd4, 0xb3,

0x7d, 0xfa, 0xef, 0xc5, 0×91, 0×39, 0×72, 0xe4, 0xd3, 0xbd, 0×61, 0xc2, 0x9f, 0×25, 0x4a, 0×94,

0×33, 0×66, 0xcc, 0×83, 0x1d, 0x3a, 0×74, 0xe8, 0xcb, 0x8d, 0×01, 0×02, 0×04, 0×08, 0×10, 0×20,

0×40, 0×80, 0x1b, 0×36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0×63, 0xc6, 0×97, 0×35,

0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0×91, 0×39, 0×72, 0xe4, 0xd3, 0xbd, 0×61, 0xc2, 0x9f,

0×25, 0x4a, 0×94, 0×33, 0×66, 0xcc, 0×83, 0x1d, 0x3a, 0×74, 0xe8, 0xcb, 0x8d, 0×01, 0×02, 0×04,

0×08, 0×10, 0×20, 0×40, 0×80, 0x1b, 0×36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0×63,

0xc6, 0×97, 0×35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0×91, 0×39, 0×72, 0xe4, 0xd3, 0xbd,

0×61, 0xc2, 0x9f, 0×25, 0x4a, 0×94, 0×33, 0×66, 0xcc, 0×83, 0x1d, 0x3a, 0×74, 0xe8, 0xcb  };

// This function produces Nb(Nr+1) round keys. The round keys are used in each round to decrypt the states.

void KeyExpansion()

{

int i,j;

unsigned char temp[4],k;

// The first round key is the key itself.

for(i=0;i<Nk;i++)

{

RoundKey[i*4]=Key[i*4];

RoundKey[i*4+1]=Key[i*4+1];

RoundKey[i*4+2]=Key[i*4+2];

RoundKey[i*4+3]=Key[i*4+3];

}

// All other round keys are found from the previous round keys.

while (i < (Nb * (Nr+1)))

{

for(j=0;j<4;j++)

{

temp[j]=RoundKey[(i-1) * 4 + j];

}

if (i % Nk == 0)

{

// This function rotates the 4 bytes in a word to the left once.

// [a0,a1,a2,a3] becomes [a1,a2,a3,a0]

// Function RotWord()

{

k = temp[0];

temp[0] = temp[1];

temp[1] = temp[2];

temp[2] = temp[3];

temp[3] = k;

}

// SubWord() is a function that takes a four-byte input word and

// applies the S-box to each of the four bytes to produce an output word.

// Function Subword()

{

temp[0]=getSBoxValue(temp[0]);

temp[1]=getSBoxValue(temp[1]);

temp[2]=getSBoxValue(temp[2]);

temp[3]=getSBoxValue(temp[3]);

}

temp[0] =  temp[0] ^ Rcon[i/Nk];

}

else if (Nk > 6 && i % Nk == 4)

{

// Function Subword()

{

temp[0]=getSBoxValue(temp[0]);

temp[1]=getSBoxValue(temp[1]);

temp[2]=getSBoxValue(temp[2]);

temp[3]=getSBoxValue(temp[3]);

}

}

RoundKey[i*4+0] = RoundKey[(i-Nk)*4+0] ^ temp[0];

RoundKey[i*4+1] = RoundKey[(i-Nk)*4+1] ^ temp[1];

RoundKey[i*4+2] = RoundKey[(i-Nk)*4+2] ^ temp[2];

RoundKey[i*4+3] = RoundKey[(i-Nk)*4+3] ^ temp[3];

i++;

}

}

// This function adds the round key to state.

// The round key is added to the state by an XOR function.

void AddRoundKey(int round)

{

int i,j;

for(i=0;i<4;i++)

{

for(j=0;j<4;j++)

{

state[j][i] ^= RoundKey[round * Nb * 4 + i * Nb + j];

}

}

}

// The SubBytes Function Substitutes the values in the

// state matrix with values in an S-box.

void InvSubBytes()

{

int i,j;

for(i=0;i<4;i++)

{

for(j=0;j<4;j++)

{

state[i][j] = getSBoxInvert(state[i][j]);

}

}

}

// The ShiftRows() function shifts the rows in the state to the left.

// Each row is shifted with different offset.

// Offset = Row number. So the first row is not shifted.

void InvShiftRows()

{

unsigned char temp;

// Rotate first row 1 columns to right

temp=state[1][3];

state[1][3]=state[1][2];

state[1][2]=state[1][1];

state[1][1]=state[1][0];

state[1][0]=temp;

// Rotate second row 2 columns to right

temp=state[2][0];

state[2][0]=state[2][2];

state[2][2]=temp;

temp=state[2][1];

state[2][1]=state[2][3];

state[2][3]=temp;

// Rotate third row 3 columns to right

temp=state[3][0];

state[3][0]=state[3][1];

state[3][1]=state[3][2];

state[3][2]=state[3][3];

state[3][3]=temp;

}

// xtime is a macro that finds the product of {02} and the argument to xtime modulo {1b}

#define xtime(x)   ((x<<1) ^ (((x>>7) & 1) * 0x1b))

// Multiplty is a macro used to multiply numbers in the field GF(2^8)

#define Multiply(x,y) (((y & 1) * x) ^ ((y>>1 & 1) * xtime(x)) ^ ((y>>2 & 1) * xtime(xtime(x))) ^ ((y>>3 & 1) * xtime(xtime(xtime(x)))) ^ ((y>>4 & 1) * xtime(xtime(xtime(xtime(x))))))

// MixColumns function mixes the columns of the state matrix.

// The method used to multiply may be difficult to understand for beginners.

// Please use the references to gain more information.

void InvMixColumns()

{

int i;

unsigned char a,b,c,d;

for(i=0;i<4;i++)

{

a = state[0][i];

b = state[1][i];

c = state[2][i];

d = state[3][i];

state[0][i] = Multiply(a, 0x0e) ^ Multiply(b, 0x0b) ^ Multiply(c, 0x0d) ^ Multiply(d, 0×09);

state[1][i] = Multiply(a, 0×09) ^ Multiply(b, 0x0e) ^ Multiply(c, 0x0b) ^ Multiply(d, 0x0d);

state[2][i] = Multiply(a, 0x0d) ^ Multiply(b, 0×09) ^ Multiply(c, 0x0e) ^ Multiply(d, 0x0b);

state[3][i] = Multiply(a, 0x0b) ^ Multiply(b, 0x0d) ^ Multiply(c, 0×09) ^ Multiply(d, 0x0e);

}

}

// InvCipher is the main function that decrypts the CipherText.

void InvCipher()

{

int i,j,round=0;

//Copy the input CipherText to state array.

for(i=0;i<4;i++)

{

for(j=0;j<4;j++)

{

state[j][i] = in[i*4 + j];

}

}

// Add the First round key to the state before starting the rounds.

AddRoundKey(Nr);

// There will be Nr rounds.

// The first Nr-1 rounds are identical.

// These Nr-1 rounds are executed in the loop below.

for(round=Nr-1;round>0;round–)

{

InvShiftRows();

InvSubBytes();

AddRoundKey(round);

InvMixColumns();

}

// The last round is given below.

// The MixColumns function is not here in the last round.

InvShiftRows();

InvSubBytes();

AddRoundKey(0);

// The decryption process is over.

// Copy the state array to output array.

for(i=0;i<4;i++)

{

for(j=0;j<4;j++)

{

out[i*4+j]=state[j][i];

}

}

}

void main()

{

int i;

// Receive the length of key here.

while(Nr!=128 && Nr!=192 && Nr!=256)

{

printf(“Enter the length of Key(128, 192 or 256 only): “);

scanf(“%d”,&Nr);

}

// Calculate Nk and Nr from the received value.

Nk = Nr / 32;

Nr = Nk + 6;

// Part 1 is for demonstrative purpose. The key and plaintext are given in the program itself.

//     Part 1: ********************************************************

// The array temp stores the key.

// The array temp2 stores the plaintext.

unsigned char temp[32] = {0×00  ,0×01  ,0×02  ,0×03  ,0×04  ,0×05  ,0×06  ,0×07  ,0×08  ,0×09  ,0x0a  ,0x0b  ,0x0c  ,0x0d  ,0x0e  ,0x0f};

unsigned char temp2[16]= {0×69  ,0xc4  ,0xe0  ,0xd8  ,0x6a  ,0x7b  ,0×04  ,0×30  ,0xd8  ,0xcd  ,0xb7  ,0×80  ,0×70  ,0xb4  ,0xc5  ,0x5a};

// Copy the Key and CipherText

for(i=0;i<Nk*4;i++)

{

Key[i]=temp[i];

in[i]=temp2[i];

}

//           *********************************************************

// Uncomment Part 2 if you need to read Key and CipherText from the keyboard.

//     Part 2: ********************************************************

/*

//Clear the input buffer

flushall();

//Recieve the Key from the user

printf(“Enter the Key in hexadecimal: “);

for(i=0;i<Nk*4;i++)

{

scanf(“%x”,&Key[i]);

}

printf(“Enter the CipherText in hexadecimal: “);

for(i=0;i<Nb*4;i++)

{

scanf(“%x”,&in[i]);

}

*/

//             ********************************************************

//The Key-Expansion routine must be called before the decryption routine.

KeyExpansion();

// The next function call decrypts the CipherText with the Key using AES algorithm.

InvCipher();

// Output the decrypted text.

printf(“\nText after decryption:\n”);

for(i=0;i<Nb*4;i++)

{

printf(“%02x “,out[i]);

}

printf(“\n\n”);

}

– End of Source code –

License: No license. You are free to use this as you like.

Anyway if you use this source code, it would be nice if you could link back to us or give credit to the author.

Lot of work has gone into the development of this work. Anyway, thank you for visiting.

Author: Niyaz PK

The AES encryption source code in C/C++ is given below. Comments are given in separate color.

Download this source code from our download section. This html file may contain errors due to markup.

/*

******************************************************************

**       Advanced Encryption Standard implementation in C.      **

**       By Niyaz PK                                            **

**       E-mail: niyazlife@gmail.com                            **

**       Downloaded from Website: www.hoozi.com                 **

******************************************************************

This is the source code for encryption using the latest AES algorithm.

AES algorithm is also called Rijndael algorithm. AES algorithm is

recommended for non-classified use by the National Institute of Standards

and Technology(NIST), USA. Now-a-days AES is being used for almost

all encryption applications all around the world.

THE MAIN FEATURE OF THIS AES ENCRYPTION PROGRAM IS NOT EFFICIENCY; IT

IS SIMPLICITY AND READABILITY. THIS SOURCE CODE IS PROVIDED FOR ALL

TO UNDERSTAND THE AES ALGORITHM.

Comments are provided as needed to understand the program. But the

user must read some AES documentation to understand the underlying

theory correctly.

It is not possible to describe the complete AES algorithm in detail

here. For the complete description of the algorithm, point your

browser to:

http://www.csrc.nist.gov/publications/fips/fips197/fips-197.pdf

Find the Wikipedia page of AES at:

http://en.wikipedia.org/wiki/Advanced_Encryption_Standard

******************************************************************

*/

// Include stdio.h for standard input/output.

// Used for giving output to the screen.

#include<stdio.h>

// The number of columns comprising a state in AES. This is a constant in AES. Value=4

#define Nb 4

// The number of rounds in AES Cipher. It is simply initiated to zero. The actual value is recieved in the program.

int Nr=0;

// The number of 32 bit words in the key. It is simply initiated to zero. The actual value is recieved in the program.

int Nk=0;

// in - it is the array that holds the plain text to be encrypted.

// out - it is the array that holds the output CipherText after encryption.

// state - the array that holds the intermediate results during encryption.

unsigned char in[16], out[16], state[4][4];

// The array that stores the round keys.

unsigned char RoundKey[240];

// The Key input to the AES Program

unsigned char Key[32];

int getSBoxValue(int num)

{

    int sbox[256] =   {

    //0     1    2      3     4    5     6     7      8    9     A      B    C     D     E     F

    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, //0

    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, //1

    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, //2

    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, //3

    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, //4

    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, //5

    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, //6

    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, //7

    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, //8

    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, //9

    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, //A

    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, //B

    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, //C

    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, //D

    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, //E

    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 }; //F

    return sbox[num];

}

// The round constant word array, Rcon[i], contains the values given by

// x to th e power (i-1) being powers of x (x is denoted as {02}) in the field GF(28)

// Note that i starts at 1, not 0).

int Rcon[255] = {

    0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,

    0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,

    0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,

    0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,

    0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,

    0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,

    0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,

    0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,

    0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,

    0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,

    0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,

    0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,

    0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,

    0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,

    0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,

    0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb  };

// This function produces Nb(Nr+1) round keys. The round keys are used in each round to encrypt the states.

void KeyExpansion()

{

    int i,j;

    unsigned char temp[4],k;

    // The first round key is the key itself.

    for(i=0;i<Nk;i++)

    {

        RoundKey[i*4]=Key[i*4];

        RoundKey[i*4+1]=Key[i*4+1];

        RoundKey[i*4+2]=Key[i*4+2];

        RoundKey[i*4+3]=Key[i*4+3];

    }

    // All other round keys are found from the previous round keys.

    while (i < (Nb * (Nr+1)))

    {

        for(j=0;j<4;j++)

        {

            temp[j]=RoundKey[(i-1) * 4 + j];

        }

        if (i % Nk == 0)

        {

            // This function rotates the 4 bytes in a word to the left once.

            // [a0,a1,a2,a3] becomes [a1,a2,a3,a0]

            // Function RotWord()

            {

                k = temp[0];

                temp[0] = temp[1];

                temp[1] = temp[2];

                temp[2] = temp[3];

                temp[3] = k;

            }

            // SubWord() is a function that takes a four-byte input word and

            // applies the S-box to each of the four bytes to produce an output word.

            // Function Subword()

            {

                temp[0]=getSBoxValue(temp[0]);

                temp[1]=getSBoxValue(temp[1]);

                temp[2]=getSBoxValue(temp[2]);

                temp[3]=getSBoxValue(temp[3]);

            }

            temp[0] =  temp[0] ^ Rcon[i/Nk];

        }

        else if (Nk > 6 && i % Nk == 4)

        {

            // Function Subword()

            {

                temp[0]=getSBoxValue(temp[0]);

                temp[1]=getSBoxValue(temp[1]);

                temp[2]=getSBoxValue(temp[2]);

                temp[3]=getSBoxValue(temp[3]);

            }

        }

        RoundKey[i*4+0] = RoundKey[(i-Nk)*4+0] ^ temp[0];

        RoundKey[i*4+1] = RoundKey[(i-Nk)*4+1] ^ temp[1];

        RoundKey[i*4+2] = RoundKey[(i-Nk)*4+2] ^ temp[2];

        RoundKey[i*4+3] = RoundKey[(i-Nk)*4+3] ^ temp[3];

        i++;

    }

}

// This function adds the round key to state.

// The round key is added to the state by an XOR function.

void AddRoundKey(int round)

{

    int i,j;

    for(i=0;i<4;i++)

    {

        for(j=0;j<4;j++)

        {

            state[j][i] ^= RoundKey[round * Nb * 4 + i * Nb + j];

        }

    }

}

// The SubBytes Function Substitutes the values in the

// state matrix with values in an S-box.

void SubBytes()

{

    int i,j;

    for(i=0;i<4;i++)

    {

        for(j=0;j<4;j++)

        {

            state[i][j] = getSBoxValue(state[i][j]);

        }

    }

}

// The ShiftRows() function shifts the rows in the state to the left.

// Each row is shifted with different offset.

// Offset = Row number. So the first row is not shifted.

void ShiftRows()

{

    unsigned char temp;

    // Rotate first row 1 columns to left

    temp=state[1][0];

    state[1][0]=state[1][1];

    state[1][1]=state[1][2];

    state[1][2]=state[1][3];

    state[1][3]=temp;

    // Rotate second row 2 columns to left

    temp=state[2][0];

    state[2][0]=state[2][2];

    state[2][2]=temp;

    temp=state[2][1];

    state[2][1]=state[2][3];

    state[2][3]=temp;

    // Rotate third row 3 columns to left

    temp=state[3][0];

    state[3][0]=state[3][3];

    state[3][3]=state[3][2];

    state[3][2]=state[3][1];

    state[3][1]=temp;

}

// xtime is a macro that finds the product of {02} and the argument to xtime modulo {1b}

#define xtime(x)   ((x<<1) ^ (((x>>7) & 1) * 0x1b))

// MixColumns function mixes the columns of the state matrix

// The method used may look complicated, but it is easy if you know the underlying theory.

// Refer the documents specified above.

void MixColumns()

{

    int i;

    unsigned char Tmp,Tm,t;

    for(i=0;i<4;i++)

    {

        t=state[0][i];

        Tmp = state[0][i] ^ state[1][i] ^ state[2][i] ^ state[3][i] ;

        Tm = state[0][i] ^ state[1][i] ; Tm = xtime(Tm); state[0][i] ^= Tm ^ Tmp ;

        Tm = state[1][i] ^ state[2][i] ; Tm = xtime(Tm); state[1][i] ^= Tm ^ Tmp ;

        Tm = state[2][i] ^ state[3][i] ; Tm = xtime(Tm); state[2][i] ^= Tm ^ Tmp ;

        Tm = state[3][i] ^ t ; Tm = xtime(Tm); state[3][i] ^= Tm ^ Tmp ;

    }

}

// Cipher is the main function that encrypts the PlainText.

void Cipher()

{

    int i,j,round=0;

    //Copy the input PlainText to state array.

    for(i=0;i<4;i++)

    {

        for(j=0;j<4;j++)

        {

            state[j][i] = in[i*4 + j];

        }

    }

    // Add the First round key to the state before starting the rounds.

    AddRoundKey(0);

    // There will be Nr rounds.

    // The first Nr-1 rounds are identical.

    // These Nr-1 rounds are executed in the loop below.

    for(round=1;round<Nr;round++)

    {

        SubBytes();

        ShiftRows();

        MixColumns();

        AddRoundKey(round);

    }

    // The last round is given below.

    // The MixColumns function is not here in the last round.

    SubBytes();

    ShiftRows();

    AddRoundKey(Nr);

    // The encryption process is over.

    // Copy the state array to output array.

    for(i=0;i<4;i++)

    {

        for(j=0;j<4;j++)

        {

            out[i*4+j]=state[j][i];

        }

    }

}

void main()

{

    int i;

    // Receive the length of key here.

    while(Nr!=128 && Nr!=192 && Nr!=256)

    {

        printf("Enter the length of Key(128, 192 or 256 only): ");

        scanf("%d",&Nr);

    }

    // Calculate Nk and Nr from the received value.

    Nk = Nr / 32;

    Nr = Nk + 6;

// Part 1 is for demonstrative purpose. The key and plaintext are given in the program itself.

//     Part 1: ********************************************************

    // The array temp stores the key.

    // The array temp2 stores the plaintext.

    unsigned char temp[16] = {0x00  ,0x01  ,0x02  ,0x03  ,0x04  ,0x05  ,0x06  ,0x07  ,0x08  ,0x09  ,0x0a  ,0x0b  ,0x0c  ,0x0d  ,0x0e  ,0x0f};

    unsigned char temp2[16]= {0x00  ,0x11  ,0x22  ,0x33  ,0x44  ,0x55  ,0x66  ,0x77  ,0x88  ,0x99  ,0xaa  ,0xbb  ,0xcc  ,0xdd  ,0xee  ,0xff};

    // Copy the Key and PlainText

    for(i=0;i<Nk*4;i++)

    {

        Key[i]=temp[i];

        in[i]=temp2[i];

    }

//           *********************************************************

// Uncomment Part 2 if you need to read Key and PlainText from the keyboard.

//     Part 2: ********************************************************

/*

    //Clear the input buffer

    flushall();

    //Recieve the Key from the user

    printf("Enter the Key in hexadecimal: ");

    for(i=0;i<Nk*4;i++)

    {

        scanf("%x",&Key[i]);

    }

    printf("Enter the PlainText in hexadecimal: ");

    for(i=0;i<Nb*4;i++)

    {

        scanf("%x",&in[i]);

    }

*/

//             ********************************************************

    // The KeyExpansion routine must be called before encryption.

    KeyExpansion();

    // The next function call encrypts the PlainText with the Key using AES algorithm.

    Cipher();

    // Output the encrypted text.

    printf("\nText after encryption:\n");

    for(i=0;i<Nk*4;i++)

    {

        printf("%02x ",out[i]);

    }

    printf("\n\n");

}

– End of Source code –

License: No license. You are free to use this as you like.

Anyway if you use this source code, it would be nice if you could link back to us or give credit to the author.

Lot of work has gone into the development of this work. Anyway, thank you for visiting.

Author: Niyaz PK

Problem: IIS not working: default website (or the www service) not starting (1717: interface not known)

Solution:

First enable the event log service and run it. Then try to run the www service

Data Compression and Decompression is often referred to as coding, where coding is a very general term encompassing any special representation of data which satisfies a given need. Information theory is defined to be the study of effective coding and its consequences, in the form of speed of transmission and probability of errors. Data compression may be viewed as a branch of information theory in which the primary objective is to minimize the amount of memory that is to be used to store the data. The purpose of this is to present a data compression and decompression software to reduce the amount memory used for storing data

There are mainly two types of compression methods are used: lossless compression and lossy compression

In lossless compression there is no loss of data during compression and decompression. It is mainly used in compressing text documents because in documents if it losses even a bit of data or if there is a change in word it becomes a large change in the meaning. Example for lossless compression is  Arithmetic coding, Substitutional Compressors, Huffman coding etc.

In lossy compression there is a lose of data during compression. It is mainly used in video compression etc.. In this, we change some features of the picture or video for compression so there a loss of actual data. So we cant get the exact decompressed file. Eg: Audio compression, Fractal compression etc. In lossy compression the compression rate is higher than that of lossless compression. But it is least efficient

There are many compression techniques used for many applications but only the most commonly used and simplest compression and decompression technique that is  LZW compression algorithm is explained here.

1.  LZW Compression and Decompression

This is the most commonly used and the simplest type of compression and decompression algorithm. The original Lempel Ziv approach to data was published in 1977.Terry Welch’s refinements to the algorithm were published in 1984. This algorithm starts with a dictionary of characters. In this algorithm, it replaces strings of characters with single codes.

There are mainly two types of implementations in LZW compression. They are: Static and Dynamic.

1.1.   Static Compression

It use when we use a static number of bits to make the compression. The total number of bits we have to our disposal is 32, which gives a total of 232 that is 4,294,967,295 possible entries in the dictionary. But in almost all cases we don’t get that much entries so most of the cases we use a constant number of bits commonly set the number of bits as 14. In 14 bit format ‘A ‘ is represented by 00000001000001.

1.2.   Dynamic Compression

Dynamic compression changes the number of bits used to compress the data. It starts with 9 bits for each new value, and goes up until it reaches 32 or until the file ends. In this type of compression we can set the size of the dictionary we have. The dictionary begins with all the 256 ASCII codes. In dynamic compression there is only one leading 0 in front of each number. In dynamic compression ‘A’ is represented as 001000001.If we change the character in the ASCII to a string (group of characters) it changes the number of bits used to represent the string. Because when we use 9 bits only up to 255 is possible.

Advantage of dynamic compression over static compression is that we get a more compressed file when we use the former. The disadvantage is that the dynamic compression takes more time to compress a file. Even if it takes more time, the most commonly used method is dynamic compression.

2.  ALGORITHMS:

2.1.   LZW Algorithm for Compression

The LZW Compression algorithm starts with a “Dictionary” of all the single characters with indexes 0-255. It then starts to expand the dictionary as information get sent through. The redundant strings will be coded as a single bit so the compression has occurred.

Algorithm

STRING = get input character

WHILE there are still input characters DO

CHARACTER = get input character

IF STRING + CHARACTER is in the string table then

STRING = STRING + CHARACTER

ELSE

output the code for STRING

add STRING + CHARACTER to the string table

STRING = CHARACTER

END of IF

END of WHILE

output the code for STRING

The program reads one character at a time. If the code is in the dictionary, then it adds the character to the current work string, and waits for the next one. This occurs on the first character as well. If the work string is not in the dictionary, (such as when the second character comes across), it adds the work string to the dictionary and sends over the wire the work string without the new character. It then sets the work string to the new character.

Explanation with Example

A sample string used to demonstrate the algorithm is shown in Figure 1. Add all ASCII characters in the table from 0-255. you can see that the first pass through the loop, a check is performed to see if the string “/A” is in the table. Since it isn’t, the code for ‘/’ is output, and the string “/A” is added to the table. Since we have 256 characters already defined for codes 0-255, the first string definition can be assigned to code 256. After the third letter, ‘B’, has been read in, the second string code, “AB” is added to the table, and the code for letter ‘A’ is output. This continues until in the second word, the characters ‘/’ and ‘A’ are read in, matching string number 256. In this case, the code 256 is output, and a three character string is added to the string table. The process continues until the string is exhausted and all of the codes have been output.

The sample output for the string is shown in Figure 1 along with the resulting string table. As can be seen, the string table fills up rapidly, since a new string is added to the table each time a code is output. In this highly redundant input, 5 code substitutions were output, along with 7 characters. If we were using 9 bit codes for output, the 19 character input string would be reduced to a 13.5 byte output string. Of course, this example was carefully chosen to demonstrate code substitution. In real world examples, compression usually doesn’t begin until a sizable table has been built, usually after at least one hundred or so bytes have been read in.

2.2   LZW Algorithm for Decompression

Algorithm

Read OLD_CODE

output OLD_CODE

WHILE there are still input characters DO

Read NEW_CODE

STRING = get translation of NEW_CODE

output STRING

CHARACTER = first character in STRING

add OLD_CODE + CHARACTER to the translation table

OLD_CODE = NEW_CODE

END of WHILE

To read a file after compression it must be decompressed. In LZW this has a companion algorithm for decompression. It needs to be able to take the stream of codes output from the compression algorithm, and use them to exactly recreate the input stream. The decompressor builds its own dictionary on its side, that matches exactly the compressor’s, so that only the codes need to be sent.

Explanation with example

The algorithm is shown in Figure2. Just like the compression algorithm, it adds a new string to the string table each time it reads in a new code. All it needs to do in addition to that is translate each incoming code into a string and send it to the output.

Figure 2 shows the output of the algorithm given the input created by the compression earlier in the article. The output string is identical to the input string from the compression algorithm. Note that the first 256 codes are already defined to translate to single character strings, just like in the compression code.

The decompression algorithm shown in Figure 2 is just a little too simple. There is a single exception case in the LZW compression algorithm when there is a string consisting of a (STRING,CHARACTER) pair already defined in the table, and the input stream then sees a sequence of STRING, CHARACTER, STRING, CHARACTER, STRING, the compression algorithm will output a code before the decompressor gets a chance to define it.

A simple example will illustrate the point. Imagine the the string MNOPQ is defined in the table as code 280. Later on, the sequence MNOPQMNOPQMNOP occurs in the table. The compression output will look like that shown in Figure 3.

When the decompression algorithm sees this input stream, it first decodes the code 280 and outputs the MNOPQ string. After doing the output, it will add the definition for code 299 to the table, whatever that may be. It then reads the next input code, 300, and finds that it is not in the table. Fortunately, this is the only case where the decompression algorithm will encounter an undefined code. Since it is in fact the only case, we can add an exception handler to the algorithm. The modified algorithm just looks for the special case of an undefined code, and handles it. In the example in Figure3, the decompression routine sees a code of 300, which is undefined. Since it is undefined, it translates the value of OLD_CODE, which is code 300. It then adds the CHARACTER value, which is ‘M’, to the string. This results in the correct translation of code 300 to string “MNOPQMN”.

If we want to create a compression and decompression software it is most important to calculate the CRC32 values. It is used to check whether there is any lose of data during compression and also used to check the data lose during transmission. For that first calculate the CRC32 of the original file and store it in somewhere in memory and then compress the file and when reading the decompressed file, find the CRC32 of the decompressed file and check whether the both CRC‘s are equal. If these are same the data decompressed correctly because for all files even the words it have its own CRC32 value. It is unique value.

The Modified Decompression Algorithm:

Read OLD_CODE

output OLD_CODE

CHARACTER = OLD_CODE

WHILE there are still input characters DO

Read NEW_CODE

IF NEW_CODE is not in the translation table THEN

STRING = get translation of OLD_CODE

STRING = STRING + CHARACTER

ELSE

STRING = get translation of NEW_CODE

END of IF

output STRING

CHARACTER = first character in STRING

add OLD_CODE + CHARACTER to the translation table

OLD_CODE = NEW_CODE

END of WHILE

References:

(1) Some parts of the text and examples taken from: Mark Nelson’s Pages. The page contains example implementation of LZW in C.

(2) Visit the Wikipedia page for compression: http://en.wikipedia.org/wiki/Data_compression

A hash function is called secure when it is computationally infeasible to:

1) find a message that corresponds to a given hash, and

2) find two different messages that produce the same hash.

Also, any change to a message will most probably result in a different hash.

The implementations given here is in C / C++. It is given as an aid for beginners to get acquainted with the algorithm and can be used as a base for actual implementation. The main feature of this SHA-1 implementation is not efficiency; It is simplicity and readability.

Get the source codes here:

SHA-1 Secure Hash Algorithm source code in C/C++

Comments are provided as needed to understand the program. But the user must read sufficient SHA documentation to understand the underlying theory correctly. It is not possible to describe the design of the SHA algorithm in detail here. For the complete description of the algorithm, point your browser to:

http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf

(The document also contains description of SHA-2 variants viz. SHA-224, SHA-256, SHA-384, and SHA-512)

Find the Wikipedia page of SHA at:

http://en.wikipedia.org/wiki/SHA_hash_functions

SHA-1 is employed in several widely used security applications and protocols, including TLS and SSL, PGP, SSH, S/MIME, and IPsec. It was considered to be the successor to MD5, an earlier, widely-used hash function. The other variants of the algorithm collectively called SHA-2 are also in wide use now.

License

No license. This is an open source and free website. Use the resources as you like. Please link to this page and give credits if you can. And promote open source.

Author: Niyaz PK

In this article, Handwritten character recognition using artificial neural networks is discussed. The article is written in a manner to enable readers to write programs using artificial neural networks instantly. Even though the article emphasizes character recognition, the ideas can be applied to other problems also.

Introduction to Artificial Neural Networks (ANNs)

We begin with some questions posed by beginners in the field, and the answers to those questions.

What is an artificial neural network?

An artificial neural network is a software or hardware that tries to simulate the working of the human brain. An artificial neural network is an interconnected network of many artificial neurons. These artificial neurons are objects used to simulate the neurons in the human brain.

What are artificial neural networks used for?

Artificial neural networks are used widely in machine learning applications. They are usually used for classification problems or for problems that require some type of cognitive ability. Some examples are: Optical Character Recognition (OCR), Speech Synthesis, Data Classification etc. Neural Networks are used for many more exciting applications and it is an active research field.

How does a neural network work?

It is very important to understand how a neural network works. If we understand the basics correctly, it is easy to implement a working neural network. Here is how our character recognition neural network work:

The image pattern containing a single character is given to the neural network as the input. This input is received by the input layer of the network. Each neuron in the input layer processes its inputs and produces one output each. The outputs from the neurons in the input layer becomes the inputs to the next layer in the neural network. So this process continues till the output from the output layer is obtained. This output is expected to be the character contained in the image.

When running a neural network for the first time, the output to an arbitrary input may not be correct. There will be errors in the output. That is, the neural network may recognize a character incorrectly. So to increase the accuracy of recognition, we must train a neural network before actual use.

What is meant by ‘Training a neural network’?

A neural network before training can be thought of as the brain of a child who does not know to read alphabets. So to teach the child, we show him some alphabets and tell him what they are. We do this again and again to increase the ability of the child to read the alphabets. Likewise, an untrained neural network does not know how to recognize characters. If we give it an input, it most probably will give the wrong output. So we train the neural network with patterns which we would like it to recognize. A neural network learns from this training and becomes good in recognition.

What is the algorithm used for handwriting recognition?

Many beginners have the misconception that there should be some algorithm to recognize a character in an OCR program using neural networks. Actually, using a neural network saves us from having to find out an algorithm for recognition. Thus there is no need for any complicated recognition algorithm if we are using neural networks. A neural network works by itself to help us recognize the character. We just have to implement the neural network and train it properly. This is why neural networks are considered as demonstrating traits of real Artificial Intelligence (AI).

Note that there may be different algorithms or methods to implement a neural network. These are usually simple algorithms that are part of the neural network and they are not directly related to the problem in hand. For example, the type of neural network we use in this article is called BackPropagation Neural Network.

Human Neurons:

First let us look how the human neurons work. This will help us in the study of artificial neural networks. Human neurons are biological structures that receive signals from other neurons and pass them to some other neurons.

Human Neuron

The signals that dendrites receive are passed to the other neurons through the axon. But it is not actually a simple transfer of signals. There is some processing of signals involved before passing it to other neurons. A neuron collects the signals through the dendrites and transfers the signal only if the signals received add up to a specific threshold. Thus noise and other unwanted signals are removed.

Artificial Neuron:

The artificial neuron is designed to simulate the working of a human neuron in mind. Let us discuss the details of an artificial neural network. After that we will discuss how to implement this neural networks in actual program.

The artificial neural network will consist of artificial neurons. Artificial neurons are thus the building blocks of any neural network. We can design a neuron in many ways. We will discuss only the type of neuron and neural network which we need for our handwriting recognition software.

An artificial neuron will have many inputs and one output. Each input will be given different priorities. This priority is denoted by weights. Look at the figure below for more details:

Artificial Neuron

In the figure, Xi denotes the ith input to the neuron. Wi denotes the weight of the ith input. In effect the value of the ith input will become: Wi * Xi

So, each neuron receives many inputs and gives out a single output. The output must reflect the values of the input. So we add all the inputs (Wi * Xi) and then if the total value of the inputs is more than a threshold, the output is fired. So the output will be 0 (if sum(Wi * Xi) < Threshold) or 1 (if sum(Wi * Xi) > Threshold) if we are using this policy. The weights are part of a neuron. They are property of a neuron and not a property of the input values. So whatever Xi arrives at an input of a neuron, the Xi is multiplied by the corresponding Wi at that input node.

Now according to our definition, the output of a neuron will be either 0 or 1. But this is not very good for practical implementations. WE would like to have an output that

The rest of the article coming soon…Check back after some time.

Insert + or – sign anywhere between the digits 123456789 in such a way that the expression evaluates to 100. The condition is that the order of the digits must not be changed.

e.g.: 1 + 2 + 3 – 4 + 5 + 6 + 78 + 9 = 100

Programming Problem:

Write a program in C/C++/Java which outputs all possible solutions of the above problem.

Before reading the solution, please try to solve the problem on your own as it can improve your logical and analytical skills a lot. Also, readers are requested to find at least 4 solutions using paper and pencil so as to understand deeply about the problem.

Solution:

Analysis of the problem:

The problem may seem very easy at first sight. But we will understand that it is not so. Actually solving this problem become very difficult for some one who has not seen problems pertaining to this specific class. Whenever we try to find a solution for the problem using paper and pencil, we may only find some simple solutions, and may not be able to get all the solutions.

Also after finding a number of solutions, we may not know whether any other solution exits or not.

Thus in essence, it is difficult to list all the solutions of the problem using pencil and paper. So we will use a computer to solve the problem. We have to write a program for this.

Solution:

Let us illustrate the basic problem statement in a more computer friendly way:

_1 _ 2_ 3 _4 _5 _6 _7 _8 _9

We must either fill the blanks above with +/- or we must remove the blanks such that the digits on either side of the blank combine to form a single number.

E.g.: _ 1 _ 2_ 3 _4 _5 _6 _7 _8 _9

becomes

123 – 4 + 5 + 67 – 89

Then we must evaluate the resulting expression to find whether it is equal to 100. If it equals 100, we may output the expression.

Now, there are three possible ways we may deal with a blank:

(1) Remove the blank

(2) Put a + sign in the blank

(3) Put a – sign in the blank

We may denote these three cases using three numbers:

Removing blank

We can see that there are 9 blanks altogether. So we can state the problem as filling these blanks using any of these three numbers and then executing the expression accordingly.

E.g.:

0 1 1 2 2 3 0 4 1 5 1 6 1 7 2 8 1 9

becomes

1 + 2 -34 + 5 + 6 +7 – 8 + 9

which calculates to -12 (hence this is not a solution of the problem)

So when we write a program, we must write it in such a way that it can find all the permutations of the three cases in all the blanks. Three cases means 0,1, and 2

number of blanks = 9

The program must find all permutations of 0,1 and 2 for 9 digits, and use each of these permutation to construct the expression and find if it equal to 100.

The easiest way to do this is consider 0,1 and 2 as the digits of a base 3 number (Eg:102,210,122210 etc……….) an find all base three up to a digit i.e. we have to find base 3 numbers from 000000000 to 222222222 i.e. in base 10 from 0 to 19682 (i.e. 39-1)

The C source code for getting all the solutions of the problem is given below:

#include<stdio.h>

#include<conio.h>

// This function is used to generate number between 0 and 2

int findnumber(int i,int j)

{

int k;

int n;

for(k = 0; k < j; k++)

{

n = i % 3;

i = i / 3;

}

return n;

}

void main()

{

int i, j, k, current, result, operation;

clrscr();

for(i = 0; i < 19683; i++)

{

if(i%3 == 0)

continue;

current = 0;

result = 0;

for(j = 1; j < 10; j++)

{

k = findnumber(i,j);

if(k==0)

{

current = current * 10 + j;

}

else

{

result = result + (operation == 1 ? current : -current);

current = j;

operation = k;

}

}

result = result + (operation == 1 ? current : -current);

if(result == 100)

{

for(j = 1; j < 10; j++)

{

k = findnumber(i,j);

if(k==0)

printf(“%d”,j);

else

printf(“%c%d”,k==1?’+':’-',j);

}

printf(“\n”);

}

}

getch();

}

The source code can also be downloaded from the Downloads section

Trace the source code to understand its working in detail.

The solutions are listed below:

+ 123 – 45 – 67 + 89
+ 12 – 3 – 4 + 5 – 6 + 7 + 89
+ 12 + 3 + 4 + 5 – 6 – 7 + 89
+ 123 + 4 – 5 + 67 – 89
- 1 + 2 – 3 + 4 + 5 + 6 + 78 + 9
+ 1 + 2 + 3 – 4 + 5 + 6 + 78 + 9
+ 12 + 3 – 4 + 5 + 67 + 8 + 9
+ 1 + 23 – 4 + 56 + 7 + 8 + 9
+ 1 + 2 + 34 – 5 + 67 – 8 + 9
+ 1 + 23 – 4 + 5 + 6 + 78 – 9
+ 123 + 45 – 67 + 8 – 9
+ 123 – 4 – 5 – 6 – 7 + 8 – 9

Author: Niyaz PK

The implementations given here is in C / C++. It is given as an aid for beginners to get acquainted with the algorithm and can be used as a base for actual implementation. The main feature of this AES implementation is not efficiency; It is simplicity and readability.

The implementation is provided in two parts. One for encryption and other for decryption. Both are stand alone programs. Please note that classes or any other OOP construct is not used in this implementation. It is advised not to use classes or high end data structures in the implementations since that can affect the performance of the algorithm seriously.

Get the source codes here:

(1) AES Encryption source code in C/C++

(2) AES Decryption source code in C/C+

Comments are provided as needed to understand the program. But the user must read some AES documentation to understand the underlying theory correctly. It is not possible to describe the complete AES algorithm in detail here. For the complete description of the algorithm, point your browser to: http://www.csrc.nist.gov/publications/fips/fips197/fips-197.pdf

Find the Wikipedia page of AES at:

http://en.wikipedia.org/wiki/Advanced_Encryption_Standard

The bandwidths of networks are increasing overwhelmingly these days. So we need better computer systems, network architectures and software which can effectively use the available bandwidth to the maximum. This text is about an operating system that can use the high bandwidth to its maximum.

DynaOS is an operating system that uses remote storage for its working. This seminar is intended to share an overall picture of the system with as much details as possible. This seminar explains the features, design, user interface and other details of the system.

DynaOS has many advantages over today’s computer operating systems. The main feature of DynaOS is that it uses remote storage not only for user files, but for operating system files too. So a computer that needs to boot from DynaOS does not need any software or operating system inside it. It just haves to have a connection to the internet or any other private network that can host DynaOS. The system can then download the system files from the boot server in the network and then can access the personal files of the user stored in the server.

CONTENTS

No:         Topic

1              Introduction

2              DynaOS

2.1          History and Background

2.2          Present Scenario

2.4          What is DynaOS?

2.5          Implementation

2.6          Packages in DynaOS

3              General Behaviour

4              Setup Required

5              Technical Framework

6              Advantages

7              Disadvantages

8               Legal Issues

9              Conclusion

10           References

1. Introduction

Remote storage is getting popular among internet and corporate users due to the availability of high bandwidth of computer networks. The bandwidths between computer networks are increasing and the costs are reducing. For instance, according to a news, the internet connectivity in Japan is made available to the normal people for a cost as low as Rupees 90.00 (2$) per month. This is for a broadband connection with a speed of 70Mbps using VDSL technology.

The speed specified above has a peculiarity. It is comparable to the speed of a current day hard disk (with 5400-7200 rpm). So this is a historical point in the history of computing. The point where network bandwidth can match the bandwidth of a local hard disk and at the same time be affordable to the common man. There are so many services already in the internet which provide remote storage for users. The storage space provided by these services is from 200 Megabytes to unlimited. Some of the services are paid services while some others are free of cost.

All these points mentioned above predicts a future for computing where remote storage may be the buzzword. This conclusion led to the evolution of the central idea on which this seminar is rooted. The seminar discusses a new breed of operating system called DynaOS.

DynaOS is an operating system that uses remote storage for its working. This seminar is intended to share an overall picture of the system with as much details as possible. This seminar explains the features, design, user interface and other details of the system.

2. DynaOS

2.1 History and Background

Client

A client is a computer system that accesses a (remote) service on another computer by some kind of network. The term was first applied to devices that were not capable of running their own stand-alone programs, but could interact with remote computers via a network. These dumb terminals were clients of the time-sharing mainframe computer.

The client-server model is still used today on the Internet, where a user may connect to a service operating on a remote system through the internet protocol suite. Web browsers are clients that connect to web servers and retrieve web pages for display. Most people use e-mail clients to retrieve their e-mail from their internet service provider’s mail storage servers. Online chat uses a variety of clients, which vary depending on the chat protocol being used. Game Clients usually refer to the software that is the game in only multiplayer online games for the computer. Increasingly, existing large client applications are being switched to websites, making the browser a sort of universal client. This avoids the hassle of downloading a large piece of software onto any computer you want to use the application on. An example of this is the rise of webmail.

Clients are generally classified as “fat clients”, “thin clients”, or “hybrid clients”.

Local storage

Local processing

Fat Client             Yes         Yes

Hybrid Client      No          Yes

Thin Client           No          No

Fat client

A fat client (also known as a thick client or rich client) is a client that performs the bulk of any data processing operations itself, and does not necessarily rely on the server. The fat client is most common in the form of a personal computer, as the personal computers or laptops can operate independently. Programming environments for rich clients include Curl, Delphi, Droplets, Java, win32 and X11.

Thin client

A thin client is a minimal sort of client. Thin clients use the resources of the host computer. A thin client’s job is generally just to graphically display pictures provided by an application server, which performs the bulk of any required data processing. Programming environments for thin clients include JavaScript/AJAX (client side automation), ASP, JSP and PHP (server side HTML generation).

Hybrid client

A hybrid client is a mixture of the above two client models. Similar to a fat client, it processes locally, but relies on the server for storage data. This approach offers features from both the fat client (multimedia support, high performance) and the thin client (high manageability, flexibility).

2.2 Present Scenario

Now in India, the government is planning to implement Fiber-To-The-Home (FTTH) technology, which offers very high transfer rates to the end user, compared to VDSL, and has no distance limitations like VDSL. Meaning, the bandwidth limitation issue, sooner or later, is going to be an issue of the past.

There are many points that favor the arrival of DynaOS. Some of the main and influential points are:

• Bandwidth is no more a problem.

• Remote storage is growing popular.

• Web applications are getting more sophisticated.

• Data availability is a big problem.

2.3 What is DynaOS?

The term “DynaOS” is the short form of Dynamic Operating system. So DynaOS is a Dynamic Operating System.

It’s like a web application

The entire system can be compared to the working of a web application where it delivers the right content to the user depending upon the type of user and his privileges. The user can then play around in the interface given to him/her.

Consider Gmail as a mail client application (like Ms Outlook), but unlike Outlook it’s always there in the net ready to use. You don’t have to use the same system for accessing your personal mails. Consider a guy using Outlook to check mail from net cafes, who need to setup his connection to the mail server every time before reading his mails. Normally no one will be trying that kind of a thing to check mails on a regular basis and outlook is not targeting that kind of users. But on the other side, in Gmail you get almost all the features supported by outlook like clients, accessible from anywhere in the world, always up, running and up to date with the latest version, of course no offline reading of messages.

Imagine getting both the things at a place. Gmail is successful because they are using brilliant JavaScript to create that user friendly interface and features like conversation, chat, etc at a reasonable download time. It happens like the software is downloaded from the server, each time, before it is run. And this works of course because the total size of the scripts and HTML that Gmail uses to create the interface is not too large.

Think about downloading and running an application like Ms Outlook each time for checking mails. It was not actually possible in the past, considering the bandwidth requirements. But, what if, the bandwidth is not a problem? DynaOS is an operating system which is designed to give users full advantage of the bandwidth they have, and the bandwidth that is poised to be available to users all around the world in a short while.

2.4 Implementation

To implement the system, the user must posses a computer with an NIC having a provision for plugging a boot ROM in it. This boot ROM will contain the basic program for finding a boot server, supplying authentication information collected from user to the boot server, get the system files from the boot server that are either not present in the local cache or newer than the cache and transfer the control to the system file(s) downloaded.

The basic diagram of the network model of DynaOS is given below:

Figure 1.1

The server must posses an OS for itself. It must also possess system files for the client. The server must also contain highly sophisticated account management system. The main system file will then take control of the system and will download additional system files based on checking the version of the files or checking if the files in cache are corrupted or not. When the necessary system files are loaded, the user configuration files and user data files will be downloaded as needed and the system will be ready to use. So the entire process goes like this:

Booting

The major steps of the booting process are:

• Authentication

• Get system files

• Get user files

• Share processing power

The most significant difference of this model comes at the time of booting itself. The booting process is rather complicated. It can be compared to the booting process of diskless nodes or the working of a web application where it delivers the appropriate content and/or the custom user interface to the user, but still there are a lot of differences. The booting will be via the NIC (Network Interface Card) in your PC. Knowledge of the working of diskless nodes can be helpful in understanding this concept in more detail.

There will be boot ROM in the NIC containing some loading program that when executed broadcasts requests to network for getting an IP address and a bootable HDD. When it gets an IP and a bootable drive, it boots from there. The situation is somewhat like that here also. But little more complicated tasks are included like authentication and booting from a custom image provided by the boot server.

Definitions of Boot Server and Boot Client

The boot client is the machine which is trying to boot.

The boot server is the machine which provides all software resources for the boot client for booting.

Steps in System Booting

(1) POST (Power-On Self Test) completed.

(2) BIOS identifies the loader in the boot ROM and transfer control to it.

(3) The boot program in ROM loads and collects authentication information from user (a universal user ID and password).

(4) It checks if a boot server is available by making broadcast requests.

(5) If no boot server is found:

(5.1) The system tries to boot to the cache (created during last boot) in the local storage.

(5.2) It invokes the basic system files in cache and gives authentication information to it.

(5.3) If the system files loaded from cache authenticates the user (checking stored authentication info of previous users booted in that machine) the system boots from the local cache, but with a lot of limitations and threats like corrupted files. In this mode, it works like current day PC operating systems like Microsoft Windows.

(5.4) If the system files loaded from cache rejects authentication, the boot loader comes back to the user authentication section.

(6) If a boot server accepts request:

(6.1) It sends the authentication information to the boot server, along with information like NIC physical address and all.

(6.2) If the server authenticates user the boot process continues with downloading of system files and user preferences.

(6.3) If the server rejects authentication, the boot loader comes back to the user authentication section.

(7) System booted.

What does the boot server do?

The boot server, getting a broadcasted request from a boot client, sees if the system is safe to boot (server is not overloaded, has no corrupted files and other security and network issues), then acknowledges the request, giving the client an IP address and all if necessary.

Then the server authenticates the user checking the information with the directory stored either locally or a remote. If the authentication information is correct, and the server is safe to boot at the instant, the server collects the user privileges and preferences from the directory and supplies system files according to that. It can also supply data stored in its storage for user as per request. Normally the user configuration files, application settings and personal files (like address book) will be stored in remote storage servers. The user can make use of the local storage too, for huge files and all, but will not be accessible globally.

The server will be able to control the client at any point, with the user’s permission. For example the server can ask the client to shutdown or reboot, because it found a fatal bug in the system file it supplied. The Root boot sever can thus ask all the systems to update a particular file that is updated in the system. The user at the client can reject such orders from the boot server but this may cause the boot server to disconnect the client, leaving it to work like a stand alone machine with further boot clients under it.

The boot client can act as a boot server once it’s booted up. The hierarchy can be compared to a family, where, a parent is giving commands to his grown up children and the children normally obeying it. If the child decides to disobey, the parent will rethink about caring the child as before. The child will also become a parent once it’s grown up.

2.5 Packages in DynaOS

A package is a collection of programs, executables, libraries, related resources and sub packages. There are three types of packages:

1. Private

2. Protected

3. Public

Each type of package has its own properties and privileges. Packages are used mainly t implement security and authenticity to users and files.

Each type of package is described briefly below:

Private

All the programs and executables that are used by the server and only by the server fall in to this category. The server is not willing to share it to any machine connected to it (boot clients, other servers, siblings) or inherit it to the clients booting from it.

Protected

This type of programs is given to the boot clients booting from the server. Normally the DynaOS Kernel falls in to this category. There are exceptions when a DynaOS loaded machine decides not to allow booting from it but provide other service or stay as stand alone machine. Certain applications like a company’s internal information system can also fall in to this type.

Public

Here come items that are given to every one. Normally a DynaOS loaded machine in web server mode will provide the public documents and executables in this type. In DynaOS world, there will be no websites serving static HTML documents but every website will be providing a very interactive web application!!!

3. General Behaviour

DynaOS is an online operating system that makes use of remote storage. It acts as any usual operating system and provides all the functionalities of a complete operating system. The user interface and usage of DynaOS will be similar to that existing in any modern day operating system.

DynaOS needs high speed broadband network to operate on. It can manage any number of clients by the mechanism of giving the functionality of a boot server to a client which completed it booting procedure.

All the user files including settings and preferences will be stored remotely. Each user will have to pay a certain amount as fee for using DynaOS. The amount will be calculated according to the usage of DynaOS and other softwares installed in the DynaOS.

4. Setup Required

For implementing DynaOS in a large scale, at least the following are required:

(1) A server loaded with DynaOS

The server must at least be having 1 Terabytes of secondary storage memory to cater to the needs of the users. It must also be able to process a large number of user requests at the same time.

(2) The server must be connected to a high speed network

(3) The network must have a bandwidth of at least 50Mbps.

Even if the bandwidth of the network is lesser than this specified amount, DynaOS may work, but the bandwidth specified is the minimum required for optimum performance.

(4) Clients that are connected to the network are also required.

(5) The clients and the server must be able to send or receive data in the network at least at the rate of 50Mbps.

(6) The clients must have a Network Interface Card (NIC) in them. There must be provision in the NIC to plug in a boot ROM into it.

(7) The Boot ROM containing a lightweight program to connect to the boot server, authenticate the user and download the initial system files should be plugged into the NIC.

5. Technical Framework

DynaOS contains a network of servers and clients. There will be a root boot server. The clients boot from this root boot server. After booting, a client can act as a boot server. So some other new client can boot from this boot server. This gives a distributed nature to DynaOS.

The clients may be connected to the servers using DHCP (Dynamic Host Configuration Protocol). After establishing a connection to the server, the client may use any reliable protocol (e.g.: TCP/IP) to communicate with the server.

6. Advantages of using DynaOS

• Reliable

“Always ready to run”

DynaOS can boot in any client from the root boot servers or from other boot servers. Whenever a client boots into DynaOS, after the system files are downloaded, the client becomes a boot server which can provide system files for other computers which want to boot into DynaOS.

• Up-to-date

“Push or Pull”

The operating system downloads the latest files from the boot server during booting and executes it. So the operating system running on a client is always up-to-date. Even after downloading the system files from the server, the client can check whether the files have been modified in the server after the last download. If the files have been modified, the client downloads the new and updated files from the server. Also, if some critical change has been made on any file in the server by the developers or any security flaw has been fixed, the server can inform this to the client and the files can be updated in the client to. Thus updating of files can take place by the pull of the client or the push of the server.

• Virus safe

“Be good… for good”

No user can push a virus or worm to the system since the DynaOS servers are protected by firewalls. Also the user who tries to introduce any malicious program into the system can be identified with the user ID and can be caught. Latest antivirus software can be installed in DynaOS so that viruses can be prevented and cured. The antivirus software can be updated in the system frequently and the user need not search for the latest updates of the antivirus software.

• Computing power sharing

“Stay idle…Make money”

Users of DynaOS can make money by renting the processing power of their computers to other users who are in need of more processing power. There will be users who have low end computers which are not able to do the processing they require. These users may benefit from this feature of DynaOS. Also, users who need to do many heavy scientific or mathematical calculations may need processing power. Some users may require processing power for image processing or video editing. Whatever may be the reason, users can get enough processing power they need from the computers that are sitting idle in the DynaOS network.

• No piracy

“Keeping pirates at bay”

You cannot get DynaOS in a compact disc or any other removable storage medium. So chances of piracy are rare. Also, even if a cracker is able to get a copy of DynaOS system files in some removable storage medium, he will only be having the system files from some client. So when he tries to boot from the copy he has, the system files will try to connect to the server and boot from there. So actually, even the concept of piracy is invalid in DynaOS.

• Cheap

“Don’t buy, just rent”

Since a large number of users will be using DynaOS, the cost will be very less per person. DynaOS does not have the concept of buying software. You just rent software for some time and you pay according to the time used and the software used. Many major softwares are having a big price tag because of the losses occurring to the developers of it due to piracy. Since there is no piracy in DynaOS, all softwares in it will be very low priced.

• All software is available

“Everything is here”

All major software will be available in DynaOS. DynaOS prevents piracy and that will be a very big point concerning developers of other software. Since they get very high profit by renting their software through DynaOS, they will develop the software for DynaOS platform.

• Universally accessible online desktop for users

“Always with you”

Each user has a unique user ID and password. Whenever he enters using his credentials, he gets his personal desktop. This is irrespective of the computer he uses or his location. So for users there is no need of carrying their files with them. They can access their data from anywhere in the world.

• Less storage required

“Link them up”

Since DynaOS does not create separate system files for each user, the total storage space required is very less compared to other networking mechanisms. Also for files which are used for entertainment (music, pictures and movies), the same file is not stored for each user. Only one copy is stored in the server. For all users using the file, links will be placed instead of the actual file.

• Low cost of ownership/maintenance

“Low cost system”

A DynaOS client can have a secondary memory (usually hard disks) with less memory and speed since no data is to be stored in the local storage. Also, since all the software is available in DynaOS, there is no need to purchase software from the market spending huge amount of money. Users only need to pay money as they use. Thus total cost of ownership is reduced. Also, since maintenance of DynaOS is done by the DynaOS team, the user need not do any maintenance work and so the maintenance costs are also reduced.

7. Disadvantages

DynaOS is an operating system that needs high bandwidth. Thus it may not be useful in low bandwidth scenarios. Other flaws in the system must be exposed by detailed study by experts in the field of computers and networking.

8. Legal Issues

Copyright laws in all the territories using DynaOS must be followed while using DynaOS. This poses a great challenge for the developers since the law in different places may be different. Sharing copyrighted files live video clips, movies and music must be strictly filtered. Also usage of copyrighted software must be monitored.

Another issue that may arise is the issue of privacy. Many people will be prevented from using DynaOS by the fear of privacy issues. A good comprehensive privacy policy must be maintained to solve this problem.

9. Conclusion

This concept can be considered as nothing more than a day dream. But if handled seriously, I believe that it has got the potential to revolutionize the world of computers and thus the world we live in. As discussed earlier, flaws in the system must be exposed and handled correctly to develop the concept of DynaOS.

10. References

1. http://www.dynaos.blogspot.com/. This is the basic text containing the text and ideas about DynaOS. Text written by Faiz VP, a former student of RIT.

2. http://www.wikipedia.org/. The details about clients, thin clients, thick clients etc were taken from the Wikipedia website.

Author: Niyaz PK