File Encryption and Decryption using AES Symmetric key Cryptographic algorithm

In this work, i encrypt a web page by running EncryptFile.java, then host that encrypted file to the server. Then another client can download that file from the server and decrypt it by running DecryptFile.java if that client has secret key.

EncrypFile.java

 import java.security.*;  
 import java.io.*;  
 import javax.crypto.*;  
 import javax.crypto.spec.*;  
 public class EncryptFile {  
      public static void main(String args[]) {  
           if (args.length < 1) {  
                System.out.println("Usage: java EncryptFile <file name>");  
                System.exit(-1);  
           }  
           try {  
                File aesFile = new File("Encrypted Web Page.html");  
                FileInputStream fis;  
                FileOutputStream fos;  
                CipherInputStream cis;  
                 //Creation of Secret key  
                String key = "MySEcRetKeY";  
                int length=key.length();  
                if(length>16 && length!=16){  
                     key=key.substring(0, 15);  
                }  
                if(length<16 && length!=16){  
                     for(int i=0;i<16-length;i++){  
                          key=key+"0";  
                     }  
                }  
                SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(),"AES");  
                 //Creation of Cipher objects  
                Cipher encrypt =Cipher.getInstance("AES/ECB/PKCS5Padding", "SunJCE");  
                encrypt.init(Cipher.ENCRYPT_MODE, secretKey);  
                // Open the Plaintext file  
                try {  
                     fis = new FileInputStream(args[0]);  
                     cis = new CipherInputStream(fis,encrypt);  
                     // Write to the Encrypted file  
                     fos = new FileOutputStream(aesFile);  
                     byte[] b = new byte[8];  
                     int i = cis.read(b);  
                     while (i != -1) {  
                          fos.write(b, 0, i);  
                          i = cis.read(b);  
                     }  
                     fos.flush();  
                     fos.close();  
                     cis.close();  
                     fis.close();  
                } catch(IOException err) {  
                     System.out.println("Cannot open file!");  
                     System.exit(-1);  
                }  
           } catch(Exception e){  
                e.printStackTrace();  
           }  
      }  
 }  

DecryptFile.java

 import java.security.*;  
 import java.io.*;  
 import javax.crypto.*;  
 import javax.crypto.spec.*;  
 import java.net.*;  
 public class DecryptFile {  
      public static void main(String args[]) {  
           try {  
                File aesFile = new File("Downloaded Encrypted Web Page.html");  
                // if file doesnt exists, then create it  
                if (!aesFile.exists()) {  
                     aesFile.createNewFile();  
                }  
                aesFile=retrieve(args);  
                File aesFileBis = new File("Decrypted Web Page.html");  
                FileInputStream fis;  
                FileOutputStream fos;  
                CipherInputStream cis;  
                 //Creation of Secret key  
                String key = "MySEcRetKeY";  
                int length=key.length();  
                if(length>16 && length!=16){  
                     key=key.substring(0, 15);  
                }  
                if(length<16 && length!=16){  
                     for(int i=0;i<16-length;i++){  
                          key=key+"0";  
                     }  
                }  
                SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(),"AES");  
                 //Creation of Cipher objects  
                Cipher decrypt =Cipher.getInstance("AES/ECB/PKCS5Padding", "SunJCE");  
                decrypt.init(Cipher.DECRYPT_MODE, secretKey);  
                // Open the Encrypted file  
                fis = new FileInputStream(aesFile);  
                cis = new CipherInputStream(fis, decrypt);  
                // Write to the Decrypted file  
                fos = new FileOutputStream(aesFileBis);  
                byte[] b = new byte[8];  
                int i = cis.read(b);  
                while (i != -1) {  
                     fos.write(b, 0, i);  
                     i = cis.read(b);  
                }  
                fos.flush();  
                fos.close();  
                cis.close();  
                fis.close();  
           } catch(Exception e){  
                e.printStackTrace();  
           }  
      }  
      public static File retrieve(String args[]){  
           if (args.length!=1) {  
                System.out.println("Usage: UrlRetriever <URL>");  
                System.exit(-1);  
           }  
           File file = new File("Downloaded Encrypted Web Page.html");  
           try {  
                URL url=new URL(args[0]);  
                BufferedInputStream buffer=new  
                BufferedInputStream(url.openStream());  
                DataInputStream in= new DataInputStream(buffer);  
                String line;  
                // if file doesnt exists, then create it  
                if (!file.exists()) {  
                     file.createNewFile();  
                }  
                FileWriter fw = new FileWriter(file);  
                BufferedWriter bw = new BufferedWriter(fw);  
                while ((line=in.readLine())!=null){  
                     bw.write(line);  
                }  
                bw.close();  
                in.close();  
           } catch(MalformedURLException mue) {  
                System.out.println(args[0]+"is an invalid URL:"+mue);  
           }catch(IOException ioe) {  
                     System.out.println("IOException: "+ioe);  
           }  
           return file;  
      }  
 }  

You can download my work out HERE

Very Simple My Own Shell in C

Do you want to publish source codes in your blog or web site as follows.
Visit Source Code Formatter

 #include<stdio.h>  
 #include<stdlib.h>  
 #include<string.h>  
 int main(){  
       char buf[256]={0};  
       printf("\n\n\n");  
       while(1){  
            printf("\nMOSH : ");  
            if (fgets(buf, sizeof(buf), stdin) == NULL){  
                fprintf(stderr, "Invalid input command!\n");  
                exit(-1);  
              }  
              buf[strlen(buf)-1]='\0';  
            system(buf);  
       }       
       return 0;  
 }  

Maximum matching in bipartite graph using Hopcroft Karp algorithm in C ++

Do you want to publish source codes in your blog or web site as follows.
Visit Source Code Formatter

 /*******************************************************/  
 /*       2nd Takehome Assignment         */  
 /*Instructions :                    */  
 /*   Data should be input to the program using text */  
 /*     file (EX: test.txt)            */  
 /*   INPUT FORMAT:                 */  
 /*     4 5 5                   */  
 /*     1 8                    */  
 /*     1 5                    */  
 /*     2 6                    */  
 /*     3 9                    */  
 /*     4 7                    */  
 /*   first three integers (n,m and e)        */  
 /*     n: number of left hand nodes        */  
 /*     m: number of right hand node        */  
 /*     e: number of incedent edges        */  
 /*    next integer(g[u][v])            */  
 /*      g[u][v]: adjecent verteces        */  
 /*******************************************************/  
 #include <iostream>  
 #include <vector>  
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <string.h>  
 #include <queue>  
 #include <fstream>  
 using namespace std;  
 #define MAX 10000 //maximum allowed couples  
 #define NIL 0  
 #define INF (1<<28) //infinity  
 vector<int> G[MAX]; // G[0]= NIL u G1[G[1---n]] u G2[G[n+1---n+m]]  
 int n,m,e,match[MAX],dist[MAX];  
 //Breadth first search  
 bool bfs() {  
   int i, u, v, len;  
   queue<int> Q;  //an integer queue  
   for(i=1; i<=n; i++) {  
     if(match[i]==NIL) { //i is not matched  
       dist[i] = 0;  
       Q.push(i);  
     }  
     else dist[i] = INF;  
   }  
   dist[NIL] = INF;  
   while(!Q.empty()) {  
     u = Q.front();  
     Q.pop();  
     if(u!=NIL) {  
       len = G[u].size();  
       for(i=0; i<len; i++) {  
         v = G[u][i];  
         if(dist[match[v]]==INF) {  
           dist[match[v]] = dist[u] + 1;  
           Q.push(match[v]);  
         }  
       }  
     }  
   }  
   return (dist[NIL]!=INF);  
 }  
 //depth first search  
 bool dfs(int u) {  
   int i, v, len;  
   if(u!=NIL) {  
     len = G[u].size();  
     for(i=0; i<len; i++) {  
       v = G[u][i];  
       if(dist[match[v]]==dist[u]+1) {  
         if(dfs(match[v])) {  
           match[v] = u;  
           match[u] = v;  
           return true;  
         }  
       }  
     }  
     dist[u] = INF;  
     return false;  
   }  
   return true;  
 }  
 int hopcroft_karp() {  
   int matching = 0, i;  
   // match[] is assumed NIL for all vertex in G  
   while(bfs())  
     for(i=1; i<=n; i++)  
       if(match[i]==NIL && dfs(i))  
         matching++;  
   return matching;  
 }  
 //read data file in to an array  
 int openDataFile(char *filename){  
   int A, B;  
   ifstream infile(filename);  
   if (!infile) { //fill not found  
     printf("There was a problem opening file %s for reading.\n",filename);  
     return 0;  
   }  
   printf("Opened %s for reading.\n", filename); //file opened  
   infile >> n >> m >>e; // for perfect matching n=m  
   while (infile >> A >> B) { //read adjecent verteces  
     G[A].push_back(B);  
   }  
 }  
 //main method starts here  
 int main() {  
   printf("\n*******************************\n\tFind Stable Cuples\n*******************************\n");  
   char filename[256] = {0};  
   int NumOfMatches,i;  
   printf("Enter data file name : ");  
   scanf("%s",&filename);  
   openDataFile(filename);  
   while(1){  
     int choice;  
     printf("\n*******************************\n\tFind Stable Cuples\n*******************************\n");  
     printf("Enter 1 : Find Optimal Solution\n");  
     printf("Enter 2 : Add New Data File\n");  
     printf("Enter 0 : Exit\n");  
     printf("\nEnter :");  
     scanf("%d",&choice);  
     if(choice==1){  
       openDataFile(filename);  
       NumOfMatches=hopcroft_karp(); //find matching perfect matching couples  
       printf("Number of couples matched : %d\n",NumOfMatches);  
       for(i=1;i<=n;i++){  
         printf("%d matched with %d\n",i,match[i]);  
       }  
     }else if(choice==2){  
       printf("Enter data file name : ");  
       scanf("%s",&filename);  
     }  
     else if(choice==0){  
       printf("Program Terminated\n");  
       exit(0);  
     }  
     else{  
       printf("Error : Wrong Input\n");  
     }  
   }  
   return 0;  
 }  

Maximum matching in bipartite graph using Ford Fulkerson algorithm in C

Do you want to publish source codes in your blog or web site as follows.
Visit Source Code Formatter

 /*******************************************************/  
 /*       2nd Takehome Assignment         */  
 /*    Maximum matching marriage couples using   */  
 /*      Ford Fulkerson Algorithm         */  
 /*Instructions :                    */  
 /*   Data should be input to the program using text */  
 /*     file (EX: test.txt)            */  
 /*   INPUT FORMAT:                 */  
 /*     10 10                   */  
 /*     1 6                    */  
 /*     1 7                    */  
 /*     2 7                    */  
 /*     3 6                    */  
 /*     3 8                    */  
 /*     3 10                    */  
 /*     4 7                    */  
 /*     4 10                    */  
 /*     5 7                    */  
 /*     5 9                    */  
 /*   first two integers (n and e)          */  
 /*     n: number of nodes in the graph      */  
 /*     e: number of incedent edges        */  
 /*    next integer(u,v)              */  
 /*      g[u][v]: adjecent verteces        */  
 /*******************************************************/  
 #include <stdio.h>  
 #include <stdlib.h>  
 // Basic Definitions  
 #define WHITE 0   //nodes status  
 #define GRAY 1  
 #define BLACK 2  
 #define MAX_NODES 1000   //maximum allowed nodes  
 #define INFINITY 1000000000  
 // variable Declarations  
 int n; // number of nodes  
 int e; // number of edges  
 int capacity[MAX_NODES][MAX_NODES]; // capacity matrix  
 int flow[MAX_NODES][MAX_NODES];   // flow matrix  
 int color[MAX_NODES]; // store node status  
 int parent[MAX_NODES]; // array to store augmenting path  
 int min (int x, int y) {  
   return x<y ? x : y; // returns minimum of x and y  
 }  
 // A Queue for Breadth-First Search  
 int head,tail;  
 int q[MAX_NODES+2];  
 void enqueue (int x) { //add to queue  
   q[tail] = x;  
   tail++;  
   color[x] = GRAY;  
 }  
 int dequeue () {    //remove from queue  
   int x = q[head];  
   head++;  
   color[x] = BLACK;  
   return x;  
 }  
 // Breadth-First Search for an augmenting path  
 int bfs (int start, int target) {  
   int u,v;  
   for (u=0; u<n+2; u++) { //initialize node status  
     color[u] = WHITE;  
   }  
   head = tail = 0;  
   enqueue(start);  
   parent[start] = -1;  
   while (head!=tail) {  
     u = dequeue();  
     // Search all adjacent white nodes v. If the capacity  
     // from u to v in the residual network is positive,  
     // enqueue v.  
     for (v=0; v<n+2; v++) {  
       if (color[v]==WHITE && capacity[u][v]-flow[u][v]>0) {  
         enqueue(v);  
         parent[v] = u;  
       }  
     }  
   }  
   // If the color of the target node is black now,  
   // it means that we reached it.  
   //printf("%d\n",color[target]);  
   return color[target]==BLACK;  
 }  
 // Ford-Fulkerson Algorithm  
 int max_flow (int source, int sink) {  
   int i,j,u;  
   // Initialize empty flow.  
   int max_flow = 0;  
   for (i=0; i<n+2; i++) {  
     for (j=0; j<n+2; j++) {  
       flow[i][j] = 0;  
     }  
   }  
   // While there exists an augmenting path,  
   // increment the flow along this path.  
   printf("\nAugmented Path :\n");  
   while (bfs(source,sink)) {  
     // Determine the amount by which we can increment the flow.  
     int increment = INFINITY;  
     for (u=sink; parent[u]!=(-1); u=parent[u]) {  
       increment = min(increment,capacity[parent[u]][u]-flow[parent[u]][u]);  
     }  
     //printf("\n%d\n",increment);  
     // Now increment the flow.  
     for (u=sink; parent[u]!=(-1); u=parent[u]) {  
       flow[parent[u]][u] += increment;  
       flow[u][parent[u]] -= increment; // Reverse in residual  
     }  
     printf("\t");  
     // Path trace  
     for (u=sink; parent[u]!=(-1); u=parent[u]) {  
       printf("%d<-",u);  
     }  
     printf("%d adds %d incremental flow\n",source,increment);  
     max_flow += increment;  
     //printf("\n\n%d %d\n\n",source,sink);  
   }  
   //printf("%d\n",s);  
   // No augmenting path anymore. We are done.  
   return max_flow;  
 }  
 // Reading the input file and the main program  
 int read_input_file() {  
   int a,b,i,j;  
   char filename[256] = {0};  
   printf("Enter data file name : ");  
   scanf("%s",&filename);  
   FILE* input = fopen(filename,"r");  
   if(!input){  
     printf("There was a problem opening file %s for reading.\n",filename);  
     return 0;  
   }  
   // read number of nodes and edges  
   fscanf(input,"%d %d",&n,&e);  
   // initialize empty capacity matrix  
   for (i=0; i<n+2; i++) {  
     for (j=0; j<n+2; j++) {  
       capacity[i][j] = 0;  
     }  
   }  
   // read edge capacities  
   for (i=0; i<e; i++) {  
     fscanf(input,"%d %d",&a,&b);  
     if(a==b){  
       printf("ERROR : Graph is not bipartite");  
       return 0;  
     }  
     capacity[a][b]= 1; // Could have parallel edges  
   }  
   fclose(input);  
   for(i=0;i<n/2;i++){  
     capacity[0][i+1]= 1;  
     capacity[i+6][n+1]= 1;  
   }  
   return 1;  
 }  
 //Extra works  
 /*void read_input_file_w() {  
   int a,b,c,i,j;  
   FILE* input = fopen(filename,"a+");  
   // read number of nodes and edges  
   fscanf(input,"%d %d",&n,&e);  
   // initialize empty capacity matrix  
   for (i=0; i<n+2; i++) {  
     for (j=0; j<n+2; j++) {  
       capacity[i][j] = 0;  
     }  
   }  
   // read edge capacities  
   for (i=0; i<e; i++) {  
     fscanf(input,"%d %d",&a,&b);  
     capacity[b][a]= 1; // Could have parallel edges  
   }  
   fclose(input);  
   for(i=0;i<n/2;i++){  
     capacity[0][i+6]= 1;  
     capacity[i+1][n+1]= 1;  
   }  
 }  
 void printMatrix(){  
   int i,j;  
   for (i=0; i<=n+1; i++) {  
     for (j=0; j<=n+1; j++) {  
       printf("%d ",capacity[i][j]);  
     }  
     printf("\n");  
   }  
 }*/  
 int start(){  
   int isBipartite=0;  
   while(!isBipartite){  
     printf("\n*******************************\n\tFind Stable Cuples\n*******************************\n");  
     isBipartite=read_input_file();  
     //printMatrix();  
   }  
   return isBipartite;  
 }  
 int main () {  
   int i,j;  
   int isBipartite=0;  
   isBipartite=start();  
   while(isBipartite){  
     int choice;  
     printf("\n*******************************\n\tFind Stable Cuples\n*******************************\n");  
     printf("Enter 1 : Find Optimal Solution\n");  
     printf("Enter 2 : Add New Data File\n");  
     printf("Enter 0 : Exit\n");  
     printf("\nEnter :");  
     scanf("%d",&choice);  
     if(choice==1){  
       printf("\ntotal flow is %d\n",max_flow(0,n+1));  
       printf("\nMatched couples:\n");  
       for (i=1; i<=n; i++)  
           //printf("%d ",parent[i]);  
         for (j=1; j<=n; j++)  
           if (flow[i][j]>0)  
             printf("\tMen:%d matched with Women:%d\n",i,j);  
     }else if(choice==2){  
       isBipartite=start();  
       //printMatrix();  
     }  
     else if(choice==0){  
       printf("Program Terminated\n");  
       exit(0);  
     }  
     else{  
       printf("Error : Wrong Input\n");  
     }  
   }  
   return 0;  
 }  

Rabin Carp String Matching Algorithm

     Rabin Carp Algorithm is also one of the string matching algorithm. This algorithm is also an improved version of Naive or Brute Force String Matching Algorithm. Because this algorithm is the a very basic sub-string matching algorithm, but it’s good for some reasons. For example it doesn’t require preprocessing of the text or the pattern. The problem is that it’s very slow. That is why in many cases brute force matching can’t be very useful.

     Michael O. Rabin and Richard M. Karp came up with the idea of hashing the pattern and to check it against a hashed sub-string from the text in 1987.Rabin Carp algorithm is one of the better string matching algorithm than Brute Force algorithm. This algorithm avoid comparison of every character of pattern with characters of text in each position. To do that this algorithm uses hashing. Hashing is the process of converting our data in to numerical value. To convert data in to numerical value we should have assign a numerical value for each text in the alphabet and using any hashing functions we can calculate hash value of any pattern. 

As an example if our pattern P=AABCB and we get ascii values of characters.

Then ascii value of A=65,B=66,C=67 and we can get hash value of above pattern using any hashing functions.

Hash function 1

     hash value h(P) = 65+65+66+67+66 = 329

Hash function 2

     hash value h(P) = 65*1+65*2+66*3+67*4+66*5 =991

Like above you can use any hash functions to calculate hash values.

We can say that if two strings are equal, then hash values of these two string must be same. But if hash values of two strings are equal then we can't say these two strings are equal. I may be or not.  This is the basic idea of the Rabin Carp algorithm.

Algorithm

 Compute hash value of pattern[h(P)]  
    Compute hash value of sub string of text[h(t)]  
    If h(P)=h(t)  
      Compare pattern and sub string character by character  
      If mismatch found  
         move by one position and go to second step  
      Else  
         matching sub string found in the text  
    Else  
      move by one position and go to second step  

Lets learn the algorithm using an example.
     Alphabet S = {A,B,C,D,E,F,G,H}
     Text T = AABDCFFACGABBCABHGADEAADG
     Pattern P = BBCABHG

Here i am going to assign value of character in the alphabet instead of assigning ascii values.
Value(A) = 1
Value(B) = 2
Value(C) = 3
Value(D) = 4
Value(E) = 5
Value(F) = 6
Value(G) = 7
Value(H) = 8
     Then hash value of pattern  h(P) = 2+2+3+1+2+8+7 = 25

Hash value of [AABDCFF] is 23. Hash values are not equal. Sub string is not matched. Move by one position.

Hash value of [ABDCFFA] is 23. Hash values are not equal. Sub string is not matched. Move by one position. 

Hash value of [BDCFFAC] is 25. Hash values are equal. Sub string may be matched. Compare pattern with sub string in the text.

First letter B matched with sub string. But second one mismatched. Move by one position.

Hash value of [DCFFACG] is 29. Hash values are not equal. Sub string is not matched. Move by one position. 

Hash value of [CFFACGA] is 26. Hash values are not equal. Sub string is not matched. Move by one position. 

Hash value of [FFACGAB] is 25. Hash values are equal. Sub string may be matched. Compare pattern with sub string in the text.

First letter B  mismatched. Move by one position. Like these you can find matching sub string.

C implementation of Rabin Carp Algorithm

Complexity

The Rabin-Karp algorithm has the complexity of O(nm) where n, of course, is the length of the text, while m is the length of the pattern. So where it is compared to brute-force matching? Well, brute force matching complexity is O(nm), so as it seems there’s no much gain in performance. However it’s considered that Rabin-Karp’s complexity is O(n+m) in practice, and that makes it a bit faster, as shown on the chart below.

Rabin-Karp's complexity is O(nm), but in practice it's O(n+m)!

Note that the Rabin-Karp algorithm also needs O(m) preprocessing time.

Advantages

1. Not faster than brute force matching in theory, but in practice its complexityis O(n+m)
2. Good hashing function it can be quite effective and it’s easy to implement!
3. Multiple pattern matching support
4. Good for plagiarism, because it can deal with multiple pattern matching!

Disadvantages

1. There are lots of string matching algorithms that are faster than O(n+m)
2. It’s practically as slow as brute force matching and it requires additional space

Rabin-Karp is a great algorithm for one simple reason – it can be used to match against multiple pattern. This makes it perfect to detect plagiarism even for larger phrases.

Computer Boot Up Process

What is computer booting?
        Process of bringing up the operating system for users is called computer boot.
This is a simple classification. But behind this word called computer boot, there are sequence of activities done by your computer.
Following is  booting process of Linux operating systems.
What happen when you press the power button of your computer?
        After pressing power button, first of all power is going to power unit of your machine. Then power unit provide amount of power need by each device in mother board and sends a signal to BIOS (Basic Input Output System) chip in mother board. Then BIOS chip starts a process called POST (Power On Self Test). Under this POST process BIOS chip,

1. Check whether all the devices receives right amount of power and memory is corrupted.
2. Then check boot order and according to the boot order find boot loader.

Boot loader is a small program and it is in the first sector or in first 512 bytes in your external memory. It may be floppy drive, CD ROM or hard disk. Here is a simple boot loader in assembly. visit
If BIOS found boot loader in external memory, first sector or first 512 bytes of that external memory device loaded in to the main memory(RAM) as first instruction of the boot loader is in 0x7C00 memory address in RAM.
After loading boot loader in to the RAM , address of the first instruction(0x7C00) of boot loader send to PC(Program Counter). Then CPU will execute the boot loader. When boot loader running, it search for the Kernal inside the hard disk. If it is found, then it will loaded in to the RAM and address of first instruction of the kernal send to PC. Then CPU will start execution of the Kernal.
Then kernal load user program called "INIT" and hands over the machine to the user. INIT is the parent process of all the other processes.
INIT process' first job is to make sure your disks are working normally. Then INIT will start several deamons. Deamons are some programs. As a first deamon, INIT will start a program called "GETTY". This program will prepare the machine for users. Nowadays INIT will start several copies of "GETTY"(7 or 8). Therefore you have several virtual consoles. Then INIT will start several deamons like networking and other services.
The most important deamon is xserver. xserver program will manage your display, key board and mouse. Also xservers' main job is to produce color pixel graphics which you normally see on your screen. Last part of the boot process is graphical login. That produces by a program called  "Display Manager".