help with password generator in C

darkangel29 · 02-09-2009, 04:25 PM

I'm doing a password generator in C. The program is suppose to generate all the possible combinations for a specify length. I'm able to generate up to 3 characters or more if I keep programming. This is the code so far

Code:

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

int main ()
{
	int pass_digit = 0;
	int pw_length = 3;
	int i;
	int secondary_digit = 0;
	int counter = 0;
	int possibilities = 0;

	char char1, char2, char3;
	char secondary_char = '0';

	printf("\n.......:::Testing Password Possibility Generator:::........\n");
	printf("Specify Password Length (Max. 3):");
	scanf("%d",&pw_length);

	while (pw_length > 3)
	{
		printf("\nInvalid Length.\n");
		printf("Try again:");
		scanf("%d",&pw_length);
	}

	char pw[pw_length];

//	Loop to initialize the password string
//==========================================================================
	for (i = 0; i < pw_length; i++)
	{
		pw[i] = 0;
		
		if (i + 1 == pw_length)
			pw[i + 1] = '\0';
	}
//==========================================================================

	FILE * fstream;
	fstream = fopen("combos.txt", "w+");


	for (char1 = '0'; char1 <= 'z' ; char1++)
	{
		pw[pass_digit] = char1;
		fprintf(fstream,"%s\n", pw);

		if (char1 == '9')
			char1 = char1 + 7;

		if (char1 == 'Z')
			char1 = char1 + 6;

	}

	pass_digit++;

	if(pass_digit < pw_length)
	{

		for (char1 = '0'; char1 <= 'z' ; char1++)
		{
			pw[pass_digit-1] = char1;

			if (char1 == '9')
				char1 = char1 + 7;

			if (char1 == 'Z')
				char1 = char1 + 6;
			
			for (char2 = '0'; char2 <= 'z' ; char2++)
			{
				pw[pass_digit] = char2;
				fprintf(fstream,"%s\n",pw);

				if (char2 == '9')
					char2 = char2 + 7;

				if (char2 == 'Z')
					char2 = char2 + 6;
			}
		}

		pass_digit++;

		if (pass_digit < pw_length)
		{
			for (char1 = '0'; char1 <= 'z' ; char1++)
			{
				pw[pass_digit-2] = char1;

				if (char1 == '9')
					char1 = char1 + 7;

				if (char1 == 'Z')
					char1 = char1 + 6;
			
				for (char2 = '0'; char2 <= 'z' ; char2++)
				{
					pw[pass_digit-1] = char2;
					fprintf(fstream,"%s\n",pw);

					if (char2 == '9')
						char2 = char2 + 7;

					if (char2 == 'Z')
						char2 = char2 + 6;

					for (char3 = '0'; char3 <= 'z' ; char3++)
					{
						pw[pass_digit] = char3;
						fprintf(fstream,"%s\n",pw);

						if (char3 == '9')
							char3 = char3 + 7;

						if (char3 == 'Z')
							char3 = char3 + 6;
					}
				}
			}
		}
	}

	printf("Its done! Check the combos.txt\n\n");

	fclose(fstream);

	return 1;
}

I'm stuck at this point, I need that the user specify the length of the password and the program to generate all possible combinations. Any ideas how could this be done would be appreciate it. Thanks a lot!!!

jailbait · 02-09-2009, 04:33 PM

Sorry, I read the question incorrectly.
-------------------
Steve Stites

ErV · 02-09-2009, 05:20 PM

Quote:

Originally Posted by darkangel29

I'm stuck at this point, I need that the user specify the length of the password and the program to generate all possible combinations. Any ideas how could this be done would be appreciate it. Thanks a lot!!!

This will print all possible passwords for given length and characters that can be included into password:

Code:

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

void printAllPossiblePasswords(int length, const char* charset){
    char* str;
    const char** counters;
    int i;
    str = malloc(length+1);
    counters = malloc(sizeof(char*)*(length + 1));
    counters[length] = 0;
    str[length] = 0;
    for (i = 0; i < length; i++)
	counters[i] = charset;
    
    while(1){
	for (i = 0; i < length; i++)
	    str[i] = *(counters[i]);
	
	printf("%s\n", str);
	
	counters[0]++;
	for (i = 0; (i < length) && (*(counters[i]) == 0); i++){
	    counters[i] = charset;
	    counters[i+1]++;
	}
	
	if (i == length)
	    break;
    }
    
    free(str);
    free(counters);
}

int main(int argc, char** argv){
    /*printAllPossiblePasswords(8, "1234567890-=qwertyuiop[]asdfghjkl;'\\zxcvbnm,./!@#$%^&*()_+QWERTYUIOP{}ASDFGHJKL:\"|ZXCVBNM<>?~`");*/
    printAllPossiblePasswords(6, "1234567890qwertyuiopasdfghjklzxcvbnm");

    return 0;
}

in "genAllPossiblePasswords" charset is a string of characters that can be included into password. Any character can be included several times.
"length" is the length of password you want.
Notice that list will be huge even for small password length (number of possible passwords will be length^strlen(charset) times. This means that for 10 characters with length 3 there will be 1000 possible combinations).
Just compile and run program to understand how it works.

johnsfine · 02-09-2009, 05:59 PM

Quote:

Originally Posted by ErV

counters = malloc(sizeof(char*)*length + 1);

I expect you meant
counters = malloc(sizeof(char*)*(length + 1));

In case this was homework, I don't think it was appropriate to provide a nearly complete solution.

I assume the thing that was confusing the OP is how to nest a variable number of loops.

You have demonstrated the professional answer: use an array of loop control variables (your "counters").

But I think it would have been better in this case to suggest the easier method, which is a recursive function. That isn't a better method (I think your method is better) but it is easier to understand how it works and easier for a beginner to apply to a wider range of variable nested loops.

Also, the problem statement doesn't say which sequence the strings should come out in, but maybe lexical sequence is assumed.

You varied the leftmost position fastest and rightmost slowest, which makes things a little easier in either your structure or a recursive function, but maybe the extra effort for the more expected sequence would be worth it.

I'm happy to answer questions about the concepts for making this a recursive function if the OP requests, but I don't think doing it is appropriate. (Very likely easier to do than explain, just not as helpful).

Edit: After a look at darkangel29's other posts, this looks less like homework and more like a real attempt to learn, so I'll say more right away regarding the recursive approach, using the simpler version with leftmost char varying fastest.

1) The top level caller allocates a big enough destination buffer and stores the terminating null at the end of it and

2) calls the recursive routine passing a pointer to one character before that terminating null and a count of characters per password, and if you like ErV's idea of a char array to control the character set, pass that as well (otherwise the character set is determined in the code of recursive function).

3) The recursive function loops through each possible char value storing it where the pointer tells it to.

4) In each loop step, after storing the character, if the length it was passed was 1, it prints the string. If the length it was passed is not 1, it calls itself recursively, passing each of pointer and length as one less than the value it received.

ErV · 02-10-2009, 02:52 AM

Quote:

Originally Posted by johnsfine

I expect you meant
counters = malloc(sizeof(char*)*(length + 1));

Yeah. List of passwords was a bit too long, so I didn't notice possibility of "final crash". Fixed.

Quote:

Originally Posted by johnsfine

In case this was homework, I don't think it was appropriate to provide a nearly complete solution.

Well, problem looked like interesting exercise, so that's why nearly complete solution. On other hand, code isn't basic, so tearing it apart will take some time and will give few ideas/insights, some experience, etc.

Quote:

Originally Posted by johnsfine

You varied the leftmost position fastest and rightmost slowest, which makes things a little easier in either your structure or a recursive function, but maybe the extra effort for the more expected sequence would be worth it.

I thought about changing "rightmost" parameter first (last byte), but I decided that this approach will be a bit clumsy to handle within one loop. Also, it is quite easy to reverse string before printing it. Just change this

Code:

	for (i = 0; i < length; i++)
	    str[i] = *(counters[i]);

or

Code:

	for (i = 0; i < length; i++)
	    str[i] = *(counters[length - i - 1]);

johnsfine · 02-10-2009, 08:09 AM

Quote:

Originally Posted by ErV

Yeah. List of passwords was a bit too long, so I didn't notice possibility of "final crash". Fixed.

I'm sure you were using a version of malloc that rounds request sizes up to multiples of 8 on a system where pointers are 4 or 8 bytes. So I don't think there was any possibility of a crash there.

I commented because I was confident you meant that +1 to be inside () and because the way you had it would be confusing to a beginner, and maybe someone might want to run it under some tool that tests for allocation violations, which would report a violation even if no crash were possible.

ErV · 02-10-2009, 12:08 PM

Quote:

Originally Posted by johnsfine

I'm sure you were using a version of malloc that rounds request sizes up to multiples of 8 on a system where pointers are 4 or 8 bytes. So I don't think there was any possibility of a crash there.

I know about that, but it still wouldn't be "right".