# brute-force.py
import time

char_text = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "a", "b",
"c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "n", "m", "o", "p", 
"q", "r", "s", "t", "u", "v", "w", "x", "y", "z", " "]
prime_text = ["10037", "20101", "49121", "33151", "17029", "58013", "89867", "91199", "97259", "42683", "10061", "43487",
"49669", "74287", "98953", "75767", "74099", "12457", "32159", "53897", "41263", "60331", "33403", "91291", "43651", "40559", 
"13921", "40531", "37861", "76091", "77093", "80107", "79861", "91801", "93937", "90397", "99989"]

char_pass = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "a", "b", "c", "d", "e", 
"f", "g", "h", "i", "j", "k", "l", "n", "m", "o", "p", "q", "r", "s", "t", "u", "v", "w", 
"x", "y", "z", " "]
prime_pass = [89963, 85691, 79273, 49531, 30713, 63059, 59263, 70489, 26647, 39443, 59077, 77447, 46061, 20897, 48673, 
78571, 65963, 15161, 64399, 45497, 91129, 80429, 42013, 17377, 19183, 23099, 22699, 55457, 84871, 84659, 32569, 80777, 52289, 
86111, 86291, 37781, 94687]


#get_sum_password
#converts a given string password into a sum of prime numbers

def get_sum_password(password):
  sum = 0

  for i in password:
    #get the actual char's index and return the equivalent prime number
    sum += prime_pass[char_pass.index(i)]

  return sum


#get_str_text
#converts a given string text into a string of prime numbers

def get_str_text(text2hash):
  #initialize the list with the same len/size of the text 
  temp_arr = [""] * len(text2hash)

  for i, c in enumerate(text2hash): 
    #get the actual char's index and return the equivalent prime number
    temp_arr[i] = prime_text[char_text.index(c)]

  text = ""
  #convert the list into a string
  return text.join(temp_arr)


#get_text_str
#convert a given string hash into a text string

def get_text_str(hash2text):
  text = ""
  temp_prime = ""
  #catch all error below
  try:
    for c in range(0, len(hash2text), 5):
      #take a five-length string from the original
      temp_prime = hash2text[c:c+5]
      #get the actual prime number's index and return the equivalent char
      text += char_text[prime_text.index(temp_prime)]
    
    return text
  except:
    #return a empty string if a five-length string can not be converted
    return ""


#encrypt
#given a string text and a string password encrypt it

def encrypt(text, password):
  return int(get_str_text(text)) * get_sum_password(password)


#decrypt
#given a integer hash and a integer password decrypt it

def decrypt(hashed_text, password):
  return get_text_str(str(hashed_text // get_sum_password(password)))

#state2password:
#given a list of indexes convert it to a string

def state2password(state):
  password = ""

  for i in actual_state:
    password += char_pass[i]

  return password

#increment_state
#given a list of indexes increment one index a time

def increment_state(state):
  new_state = state

  #max index possible
  max_state = len(char_pass) - 1

  #increment by one last index
  new_state[len(new_state) - 1] += 1

  #iterate over the list
  for i in range(len(new_state) - 1, -1, -1):
    s = new_state[i]
    if (s > max_state):
      #if the max index possible is exceeded take action
      if (i == 0):
        #if actual index is the first redim the list adding one item and zero-initialize it 
        new_state = [0] * (len(state) + 1)
      else:
        #if actual index is not the first just set actual index to zero and increment previous item by one
        new_state[i] = 0
        new_state[i - 1] += 1

  return new_state

hashed_text = int(input("hash:"))

actual_state = [0]
attemps = 0
solved = False

initial_time = time.time()

while True:
  attemps += 1
  #string password
  temp_pass = state2password(actual_state)
  #prime-number-codified password
  temp_sum = get_sum_password(temp_pass)

  #there is two conditional to aprove the decryption
  #first decryption operation is multiple of 5
  if ((hashed_text // temp_sum) % 5):
    #second the function decrypt generate a valid string
    if decrypt(hashed_text, temp_pass) != "":
      solved = True
      final_time = time.time()
      break
  
  #every 10000 attemps print state
  if (0 == (attemps % 10000)):
    print("attemps: ", attemps, "state ", actual_state, "password: ", temp_pass)

  #update state
  actual_state = increment_state(actual_state)

print("------------------------------------------------------------------------------")
print("text decrypted: ", decrypt(hashed_text, temp_pass))
print(" ------ stats ------ ")
print("attemps: ", attemps)
print("state: ", actual_state)
print("password: ", temp_pass)
print("elapsed time: ", final_time - initial_time)
print("------------------------------------------------------------------------------")

#brute-force-mp.py

import multiprocessing as mp
import time

char_text = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "a", "b",
"c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "n", "m", "o", "p", 
"q", "r", "s", "t", "u", "v", "w", "x", "y", "z", " "]
prime_text = ["10037", "20101", "49121", "33151", "17029", "58013", "89867", "91199", "97259", "42683", "10061", "43487",
"49669", "74287", "98953", "75767", "74099", "12457", "32159", "53897", "41263", "60331", "33403", "91291", "43651", "40559", 
"13921", "40531", "37861", "76091", "77093", "80107", "79861", "91801", "93937", "90397", "99989"]

char_pass = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "a", "b", "c", "d", "e", 
"f", "g", "h", "i", "j", "k", "l", "n", "m", "o", "p", "q", "r", "s", "t", "u", "v", "w", 
"x", "y", "z", " "]
prime_pass = [89963, 85691, 79273, 49531, 30713, 63059, 59263, 70489, 26647, 39443, 59077, 77447, 46061, 20897, 48673, 
78571, 65963, 15161, 64399, 45497, 91129, 80429, 42013, 17377, 19183, 23099, 22699, 55457, 84871, 84659, 32569, 80777, 52289, 
86111, 86291, 37781, 94687]


#get_sum_password
#converts a given string password into a sum of prime numbers

def get_sum_password(password):
  sum = 0

  for i in password:
    #get the actual char's index and return the equivalent prime number
    sum += prime_pass[char_pass.index(i)]

  return sum


#get_str_text
#converts a given string text into a string of prime numbers

def get_str_text(text2hash):
  #initialize the list with the same len/size of the text 
  temp_arr = [""] * len(text2hash)

  for i, c in enumerate(text2hash): 
    #get the actual char's index and return the equivalent prime number
    temp_arr[i] = prime_text[char_text.index(c)]

  text = ""
  #convert the list into a string
  return text.join(temp_arr)


#get_text_str
#convert a given string hash into a text string

def get_text_str(hash2text):
  text = ""
  temp_prime = ""
  #catch all error below
  try:
    for c in range(0, len(hash2text), 5):
      #take a five-length string from the original
      temp_prime = hash2text[c:c+5]
      #get the actual prime number's index and return the equivalent char
      text += char_text[prime_text.index(temp_prime)]
    
    return text
  except:
    #return a empty string if a five-length string can not be converted
    return ""


#encrypt
#given a string text and a string password encrypt it

def encrypt(text, password):
  return int(get_str_text(text)) * get_sum_password(password)


#decrypt
#given a integer hash and a integer password decrypt it

def decrypt(hashed_text, password):
  return get_text_str(str(hashed_text // get_sum_password(password)))

#state2password:
#given a list of indexes convert it to a string

def state2password(actual_state):
  password = ""

  for i in actual_state:
    password += char_pass[i]

  return password

#increment_state
#given a list of indexes increment one index a time

def increment_state(state, min_value, max_value):
  new_state = state

  max_state = len(char_pass) - 1

  #increment by one last index
  new_state[len(new_state) - 1] += 1

  #iterate over the list
  for i in range(len(new_state) - 1, -1, -1):
    s = new_state[i]
    #si es el index 0
    if (0 == i):
      if (s > max_value):
        new_state = [0] * (len(state) + 1)
        new_state[0] = min_value
    else:
      if (s > max_state):
        new_state[i] = 0
        new_state[i - 1] += 1

  return new_state


def crack(ranges, hash):
  min_value = ranges[0]
  max_value = ranges[1]
  hashed_text = hash

  actual_state = [min_value]
  attemps = 0

  while True:
    attemps += 1
    #string password
    temp_pass = state2password(actual_state)
    #prime-number-codified password
    temp_sum = get_sum_password(temp_pass)

    #there is two conditional to aprove the decryption
    #first decryption operation is multiple of 5
    if ((hashed_text // temp_sum) % 5):
      #second the function decrypt generate a valid string
      if decrypt(hashed_text, temp_pass) != "":
        with solved.get_lock():
          solved.value += 1
          return [actual_state, True, attemps]
      #time.sleep(0.2)
      
    #every 10000 attemps print state
    if (0 == (attemps % 10000)):
      with solved.get_lock():
          if solved.value > 0:
            return [actual_state, False, attemps]

    #if (0 == (attemps % 100000)):
    #  print("attemps: ", attemps, "state ", actual_state, "password: ", temp_pass)

    #update state
    actual_state = increment_state(actual_state, min_value, max_value)


def pool_initializer(temp_solved):
  global solved
  solved = temp_solved
  

def main():
  #create a multiprocessing variable
  #hashed_text = 309224446557488409754066854545005782200040975244112
  hashed_text = int(input("hash: "))

  #number of virtual cpu cores
  pool_size = mp.cpu_count()

  #get the fixed size of distribution and the modulus for size compensation
  tentative_size = int(len(char_pass) // pool_size)
  modulus_size = len(char_pass) % pool_size

  ranges_for_cpu = [[0 for i in range(2)] for j in range(pool_size)]
  last_max = -1

  for i, _ in enumerate(ranges_for_cpu):
    ranges_for_cpu[i][0] = (last_max + 1)
    ranges_for_cpu[i][1] = (last_max + tentative_size)

    if modulus_size > 0:
      modulus_size -= 1
      ranges_for_cpu[i][1] += 1
    last_max = ranges_for_cpu[i][1]

  results = []
  temp_solved = mp.Value('i', 0)

  initial_time = time.time()

  pool = mp.Pool(processes=pool_size, initializer=pool_initializer, initargs=(temp_solved,))

  pool_output = [pool.apply_async(crack, args=(cpu_range, hashed_text)) for cpu_range in ranges_for_cpu]

  results = [r.get() for r in pool_output]

  pool.close()
  pool.join()

  final_time = time.time()
  final_attemps = 0
  final_state = ""

  for result in results:
    final_attemps += result[2]
    if True == result[1]:
      final_state = result[0]

  temp_pass = state2password(final_state)

  print("------------------------------------------------------------------------------")
  print("text decrypted: ", decrypt(hashed_text, temp_pass))
  print(" ------ stats ------ ")
  print("cores used:", pool_size)
  print("attemps: ", final_attemps)
  print("password: ", temp_pass)
  print("elapsed time: ", final_time - initial_time)
  print("------------------------------------------------------------------------------")


if __name__ == '__main__':
  main()

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

#define SIZE 37
#define PRIME_DIGITS 5

const char acList[SIZE] = {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'a', 'b',
'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'n', 'm', 'o', 'p', 
'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', ' '};

const char aacText[SIZE][PRIME_DIGITS + 1] = {"10037", "20101", "49121", "33151", "17029", "58013", "89867", "91199", "97259", "42683", "10061", "43487",
"49669", "74287", "98953", "75767", "74099", "12457", "32159", "53897", "41263", "60331", "33403", "91291", "43651", "40559", 
"13921", "40531", "37861", "76091", "77093", "80107", "79861", "91801", "93937", "90397", "99989"};

const unsigned int auPassword[SIZE] = {89963, 85691, 79273, 49531, 30713, 63059, 59263, 70489, 26647, 39443, 59077, 77447, 46061, 20897, 48673, 
78571, 65963, 15161, 64399, 45497, 91129, 80429, 42013, 17377, 19183, 23099, 22699, 55457, 84871, 84659, 32569, 80777, 52289, 
86111, 86291, 37781, 94687};

/*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  Function: CharInArrayChar

  Summary:  Search a given char in a given array char

  Args:    char cNeedle
              Char to be searched.
            char *acHaystack
              Array of char to be looped.
            unsigned int cacHaystack
              Size of array.

  Returns:  int
              If the char is founded returns the index, otherwise return -1.
-----------------------------------------------------------------F-F*/

int CharInArrayChar (const char cNeedle, const char *acHaystack, const unsigned int cacHaystack) {
    for (unsigned int i = 0; i < cacHaystack; i++) {
        if (acHaystack[i] == cNeedle) {
            return i;
        }
    }
    return -1;
}

/*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  Function: IntInArrayInt

  Summary:  Search a given integer in a given array integer

  Args:    char uNeedle
              Char to be searched.
            char *auHaystack
              Array of char to be looped.
            unsigned int cauHaystack
              Size of array.

  Returns:  int
              If the char is founded returns the index, otherwise return -1.
-----------------------------------------------------------------F-F*/

int IntInArrayInt (const unsigned int uNeedle, const unsigned int *auHaystack, const unsigned int cauHaystack) {
    for (unsigned int i = 0; i < cauHaystack; i++) {
        if (auHaystack[i] == uNeedle) {
            return i;
        }
    }
    return -1;
}

/*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  Function: StrInArrayStr

  Summary:  Search a given string in a given zero-terminated string array

  Args:    char acNeedle
              Char to be searched.
            char* aacHaystack
              Array of char to be looped.
            unsigned int caacHaystack
              Size of array.

  Returns:  int
              If the string is founded returns the index, otherwise return -1.
-----------------------------------------------------------------F-F*/

int StrInArrayStr (const char *acNeedle, const char aacHaystack[][PRIME_DIGITS + 1], const unsigned int caacHaystack) {
    for (unsigned int i = 0; i < caacHaystack; i++) {
        if (memcmp(acNeedle, aacHaystack[i], 5) == 0) {
            return i;
        }
    }
    return -1;
}

/*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  Function: SumPrimePassword

  Summary:  Convert a zero-terminated string into its sum of primes equivalent

  Args:    char *acPassword
              Char to be searched.
            unsigned int cbPassword
              Size of array.

  Returns:  int
              If the all the char in the password are valid return its sum, otherwise returns 0
-----------------------------------------------------------------F-F*/

long SumPrimePassword(const char *acPassword, unsigned int cbPassword) {
    unsigned int uIndex;
    long lSum = 0;

    for (unsigned int i = 0; i < cbPassword; i++) {
        uIndex = CharInArrayChar(acPassword[i], acList, SIZE);
        if (uIndex < 0) {
            return 0;
        }
        lSum += auPassword[uIndex];
    }

    return lSum;
}

/*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  Function: SumPrimeFromArray

  Summary:  Convert a unsigned int array containing char indexes into its sum of primes equivalent

  Args:    unsigned int *auState
              Array of char indexes.
            unsigned int csState
              Size of array.

  Returns:  int
              Return its sum
-----------------------------------------------------------------F-F*/

unsigned long SumPrimeFromArray(const unsigned int *auState, unsigned int cuState) {
    unsigned long lSum = 0;
    for (unsigned int i = 0; i < cuState; i++){
        lSum += auPassword[auState[i]];
    }
    return lSum;
}

/*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  Function: EncodeTextToPrime

  Summary:  Convert a zero-terminated string into a zero-terminated string of its prime numbers representation

  Args:    char **pcCodifiedText
              Pointer to the buffer where the final zero-terminated string is going to be stored.
            char *acTextToCrypt
              Zero terminated string to be converted.
            unsigned int cbTextToCrypt
              Size of string.

  Returns:  int
              If all the char are valid return the size of the representation, otherwise return 0
-----------------------------------------------------------------F-F*/

int EncodeTextToPrime(char **pcCodifiedText, const char *acTextToCrypt, unsigned int cbTextToCrypt) {
    unsigned int uIndex = 0, uCodifiedText = 0;
    uCodifiedText = (cbTextToCrypt * PRIME_DIGITS) + 1;
    *pcCodifiedText = (char*)calloc(uCodifiedText, sizeof(char));

    for (unsigned int i = 0; i < cbTextToCrypt; i++) {
        uIndex = CharInArrayChar(acTextToCrypt[i], acList, SIZE);
        if (uIndex < 0) {
            return 0;
        }
        strcat(*pcCodifiedText, aacText[uIndex]);
    }
    return uCodifiedText;
}

/*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  Function: DecodeTextToPrime

  Summary:  Convert a GMP number into a zero-terminated decodified string

  Args:    char *acDecodifiedText
              Pointer to char where the decodied text will be stored
            mpz_t mpzTextEncoded
              Pointer to a structure from GMP library containing the number to be decodified

  Returns:  int
              If all the char are valid return the size of the decodified text, otherwise return 0
-----------------------------------------------------------------F-F*/

int DecodePrimeToText(char *acDecodifiedText, const mpz_t mpzTextEncoded) {
    unsigned int cbEncodedText = mpz_sizeinbase(mpzTextEncoded, 10);
    int uIndex = 0;
    char *acEncodedText = (char *)malloc(cbEncodedText + 2);

    mpz_get_str(acEncodedText, 10, mpzTextEncoded);

    for (unsigned int i = 0; i < (cbEncodedText / 5); i++) {
        uIndex = StrInArrayStr(&acEncodedText[i * PRIME_DIGITS], aacText, SIZE);
        if (uIndex < 0) {
            return 0;
        }
        acDecodifiedText[i] = acList[uIndex];
    }
    free(acEncodedText);
    return cbEncodedText / 5;
}

/*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  Function: EncryptText

  Summary:  Encrypt a zero-terminated string using a zero-terminated password

  Args:    mpz_t mpzResult
              Pointer to a structure from GMP library that will contain the encrypted text
            char *acTextToCrypt
              Zero terminated string to be encrypted.
            unsigned int cbTextToCrypt
              Size of string.
            char *acPassword
              Zero terminated string containing the password.
            unsigned int cbPassword
              Size of string.

  Returns:  void
              (none)
-----------------------------------------------------------------F-F*/

void EncryptText(mpz_t mpzResult, const char *acTextToCrypt, int cbTextToCrypt, const char *acPassword, int cbPassword) {
    mpz_t pTempText;
    mpz_init(pTempText);

    char *acCodifiedText;
    int cbCodifiedText = EncodeTextToPrime(&acCodifiedText, acTextToCrypt, cbTextToCrypt);
    mpz_init_set_str(pTempText, acCodifiedText, 10);
    free(acCodifiedText);

    long lPassword = SumPrimePassword(acPassword, cbPassword);

    mpz_mul_si(mpzResult, pTempText, lPassword);
    mpz_clear(pTempText);
    return;
}

/*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  Function: DecryptText

  Summary:  Decrypt a zero-terminated string using a zero-terminated password

  Args:    char *acDecryptedText
              Pointer to the buffer where the decrypted text wil be stored
            char *acTextToDecrypt
              Zero terminated string to be decrypted.
            unsigned int cbTextToDecrypt
              Size of string.
            char *acPassword
              Zero terminated string containing the password.
            unsigned int cbPassword
              Size of string.

  Returns:  void
              (none)
-----------------------------------------------------------------F-F*/

void DecryptText(char *acDecryptedText, const char *acTextToDecrypt, int cbTextToDecrypt, const char *acPassword, int cbPassword) {
    unsigned long lRemainder;

    mpz_t pTempHash, mpzResult;
    mpz_init(pTempHash);
    mpz_init(mpzResult);

    long lPassword = SumPrimePassword(acPassword, cbPassword);

    mpz_init_set_str(pTempHash, acTextToDecrypt, 10);
    lRemainder = mpz_cdiv_q_ui(mpzResult, pTempHash, lPassword);
    DecodePrimeToText(acDecryptedText, mpzResult);

    mpz_clear(pTempHash);
    mpz_clear(mpzResult);

    return;
}

/*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  Function: ArrayByteToStr

  Summary:  Convert a array of indexes int it array of char representation

  Args:    char *acPassword
              Pointer to the buffer where the password
            unsigned int *auState
              Array containing indexes
            unsigned int cauState
              Size of array.

  Returns:  void
              (none)
-----------------------------------------------------------------F-F*/

void ArrayByteToStr(char *acPassword, const unsigned int *auState, const unsigned int cauState) {
    for (unsigned int i = 0; i < cauState; i++) {
        acPassword[i] = acList[auState[i]];
    }
    return;
}

/*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  Function: UpdateState

  Summary:  Function that permits the Brute Force

  Args:    unsigned int **pauState
              Pointer to the array of indexes
            unsigned int *pcalState
              Pointer to the size of the array

  Returns:  void
              (none)
-----------------------------------------------------------------F-F*/

void UpdateState(unsigned int **pauState, unsigned int *pcalState) {
    (*pauState)[*pcalState - 1]++;
    for (int i = *pcalState - 1; i > -1; i--) {
        if ((*pauState)[i] > (SIZE - 1)) {
            if (i == 0) {
                free(*pauState);
                (*pcalState)++;
                *pauState = (unsigned int *)calloc(*pcalState, sizeof(unsigned int));
                return;
            } else {
                (*pauState)[i] = 0;
                (*pauState)[i - 1]++;
            }
        }
    }
    return;
} 

int main() {
    char acText[254] = {NULL};

    printf("hash: ");
    scanf("%[^\n]%*c", acText);

    clock_t tElapsedClock;
    tElapsedClock = clock();

    unsigned int cbText = strlen(acText);

    unsigned long lAttemps = 0, lPassword, lRemainder, cacEncodedText, cacDecodedBuffer, lPrintable = 1000000;
    unsigned int cauState = 1;
    mpz_t pHash, pTemp;
    mpz_init(pHash);
    mpz_init(pTemp);

    mpz_init_set_str(pHash, acText, 10);

    unsigned int *auState = (unsigned int *)calloc(cauState, sizeof(unsigned int));
    bool bSolved = false;
    char *acDecodedBuffer;

    while (0 == 0) {
        lAttemps++;

        lPassword = SumPrimeFromArray(auState, cauState);

        lRemainder = mpz_cdiv_q_ui(pTemp, pHash, lPassword);
        if (lRemainder == 0) {
            cacEncodedText = mpz_sizeinbase(pTemp, 10);
            acDecodedBuffer = (char *)calloc((cacEncodedText / 5) + 1, sizeof(char));
            cacDecodedBuffer = DecodePrimeToText(acDecodedBuffer, pTemp);
            if (cacDecodedBuffer > 0) {
                bSolved = true;
                break;
            } else {
                free(acDecodedBuffer);
            }
        }

        if (0 == (lAttemps % lPrintable)) {
            lPrintable *= 10;
            printf("attemps: %d\tpass len: %d\n", lAttemps, cauState);
        }

        UpdateState(&auState, &cauState);
    }

    char *acPassword = (char *)calloc(cauState, sizeof(char));
    ArrayByteToStr(acPassword, auState, cauState);
    tElapsedClock = clock() - tElapsedClock;
    double tElapsedTime = ((double)tElapsedClock) / CLOCKS_PER_SEC;

    printf("--------------------\n");
    printf("text: %s\n", acDecodedBuffer);
    printf("--------------------\n");
    printf("attemps: %d\ntime: %.2f s\npass: %s\n", lAttemps, tElapsedTime, acPassword);

    free(acDecodedBuffer);
    free(acPassword);

    return 0;
}