История одного генератора.

_Var6 = __time64((__time64_t *)0x0);
uStack_434 = (undefined4)((ulonglong)_Var6 >> 0x20);
FUN_107a89a6((int)_Var6 - _DAT_10cef548, uVar7, uVar2);
_DAT_10cef548 = _DAT_10cef548 + -0xe3a78;

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void __thiscall FUN_105e5390(int *param_1,int *param_2,int param_3,int param_4)

{
  short sVar1;
  uint uVar2;
  int iVar3;
  uint uVar4;
  short *psVar5;
  __time64_t _Var6;
  undefined4 uVar7;
  char *pcVar8;
  undefined1 auStack_454 [4];
  int local_450;
  int local_44c;
  int local_448;
  int local_444;
  int local_440;
  int local_43c;
  int local_438;
  undefined4 local_434;
  undefined4 local_430;
  int *local_42c;
  short local_428 [518];
  uint local_1c;
  void *local_14;
  undefined1 *puStack_10;
  undefined4 local_c;
 
  puStack_10 = &LAB_108d0ea2;
  local_14 = ExceptionList;
  local_1c = DAT_10cdbcf4 ^ (uint)auStack_454;
  uVar2 = DAT_10cdbcf4 ^ (uint)&stack0xfffffba0;
  ExceptionList = &local_14;
  local_c = 0;
  uVar7 = 0;
  local_42c = param_2;
  local_430 = 0;
  _Var6 = __time64((__time64_t *)0x0);
  local_434 = (undefined4)((ulonglong)_Var6 >> 0x20);
  FUN_107a89a6((int)_Var6 - _DAT_10cef548,uVar7,uVar2);
  _DAT_10cef548 = _DAT_10cef548 + -0xe3a78;
  if ((param_1[1] < 1) || (0x3f < param_1[1])) {
    FUN_10584ea0(".\\portable\\sib-password-gen.cpp",0x2f,0,0,1);
  }
  if (0x200 < param_3) {
    param_3 = 0x200;
  }
  local_43c = FUN_105847c0();
  local_43c = local_43c + 0x14;
  local_c = 2;
  local_448 = FUN_105847c0();
  local_448 = local_448 + 0x14;
  local_c._0_1_ = 4;
  local_44c = FUN_105847c0();
  local_44c = local_44c + 0x14;
  local_c._0_1_ = 6;
  local_438 = FUN_105847c0();
  local_438 = local_438 + 0x14;
  local_c = CONCAT31(local_c._1_3_,8);
  iVar3 = FUN_105e5260(0x20);
  if (iVar3 == 0) {
    FID_conflict:operator=("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
    FID_conflict:operator=("abcdefghijklmnopqrstuvwxyz");
    FID_conflict:operator=("0123456789");
    pcVar8 = "0123456789ABCDEF";
  }
  else {
    FID_conflict:operator=("ABCDEFGHJKLMNPQRSTUVWXYZ");
    FID_conflict:operator=("abcdefghijkmnopqrstuvwxyz");
    FID_conflict:operator=("23456789");
    pcVar8 = "23456789ABCDEF";
  }
  FID_conflict:operator=(pcVar8);
  local_450 = FUN_105847c0();
  local_450 = local_450 + 0x14;
  local_c = CONCAT31(local_c._1_3_,10);
  iVar3 = FUN_105e5260(1);
  if (iVar3 != 0) {
    FUN_10009040(local_43c,*(undefined4 *)(local_43c + -0x14));
  }
  iVar3 = FUN_105e5260(2);
  if (iVar3 != 0) {
    FUN_10009040(local_448,*(undefined4 *)(local_448 + -0x14));
  }
  iVar3 = FUN_105e5260(4);
  if (iVar3 != 0) {
    FUN_10009040(local_44c,*(undefined4 *)(local_44c + -0x14));
  }
  iVar3 = FUN_105e5260(8);
  if (iVar3 != 0) {
    FUN_10009040(*param_1,*(undefined4 *)(*param_1 + -0x14));
  }
  iVar3 = FUN_105e5260(0x10);
  if (iVar3 != 0) {
    FUN_10001b30(&local_438);
  }
  uVar2 = param_3 + 1;
  if (0 < (int)uVar2) {
    psVar5 = local_428;
    for (uVar4 = uVar2 >> 1; uVar4 != 0; uVar4 = uVar4 - 1) {
      psVar5[0] = 0;
      psVar5[1] = 0;
      psVar5 = psVar5 + 2;
    }
    for (uVar2 = (uint)((uVar2 & 1) != 0); uVar2 != 0; uVar2 = uVar2 - 1) {
      *psVar5 = 0;
      psVar5 = psVar5 + 1;
    }
  }
  if (param_3 < param_4) {
    param_4 = param_3;
  }
  local_444 = param_4;
  if (param_4 < 0) {
    local_444 = 0;
  }
  iVar3 = local_444;
  local_440 = param_3;
  if (0 < local_444) {
    do {
      FUN_105e52d0(local_428,&local_440,4,&local_44c,param_3);
      iVar3 = iVar3 + -1;
    } while (iVar3 != 0);
  }
  if (*(int *)(*param_1 + -0x14) != 0) {
    FUN_105e52d0(local_428,&local_440,8,param_1,param_3);
  }
  FUN_105e52d0(local_428,&local_440,1,&local_43c,param_3);
  FUN_105e52d0(local_428,&local_440,2,&local_448,param_3);
  if (local_444 == 0) {
    FUN_105e52d0(local_428,&local_440,4,&local_44c,param_3);
  }
  iVar3 = 0;
  if (0 < param_3) {
    do {
      if (local_428[iVar3] == 0) {
        sVar1 = FUN_105e5280(&local_450);
        local_428[iVar3] = sVar1;
      }
      iVar3 = iVar3 + 1;
    } while (iVar3 < param_3);
  }
  iVar3 = FUN_105847c0();
  *local_42c = iVar3 + 0x14;
  local_c._0_1_ = 0xb;
  uVar7 = FUN_10001c10(local_428);
  FUN_10001dd0(local_428,uVar7);
  local_430 = 1;
  local_c._0_1_ = 8;
  FUN_10584890();
  local_c._0_1_ = 6;
  FUN_10584890();
  local_c._0_1_ = 4;
  FUN_10584890();
  local_c = CONCAT31(local_c._1_3_,2);
  FUN_10584890();
  local_c = 0;
  FUN_10584890();
  ExceptionList = local_14;
  __security_check_cookie(local_1c ^ (uint)auStack_454);
  return;
}

import time
import datetime
import os
import sys


class roboform:
    seed = None
    seed_mod = None
    pass_length = None
    pass_length_ctr = None
    min_digits = None
    config = None
    password = None

    charset = {
        "upper": "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
        "upper_similar": "ABCDEFGHJKLMNPQRSTUVWXYZ",
        "lower": "abcdefghijklmnopqrstuvwxyz",
        "lower_similar": "abcdefghijkmnopqrstuvwxyz",
        "digit": "0123456789",
        "digit_similar": "23456789",
        "hex": "0123456789ABCDEF",
        "hex_similar": "23456789ABCDEF",
        "special": "!@#$%^&*"
    }
    charset_full = None

    def __init__(
        self,
        pass_length=8,
        chr_upper=True,
        chr_lower=True,
        chr_digits=True,
        chr_specials="!@#$%^&*",
        chr_similar=False,
        min_digits=1,
    ):
        self.seed_mod = 0

        if pass_length > 0x200:
            pass_length = 0x200
        self.pass_length = pass_length

        self.config = 0
        if chr_upper:
            self.config |= 0x01
        if chr_lower:
            self.config |= 0x02
        if chr_digits:
            self.config |= 0x04
        if chr_specials:
            self.config |= 0x08
        if chr_similar:
            self.config |= 0x20

        self.charset_full = ""
        if self.config & 0x01:
            if self.config & 0x20:
                self.charset_full += self.charset["upper_similar"]
            else:
                self.charset_full += self.charset["upper"]

        if self.config & 0x02:
            if self.config & 0x20:
                self.charset_full += self.charset["lower_similar"]
            else:
                self.charset_full += self.charset["lower"]

        if self.config & 0x04:
            if self.config & 0x20:
                self.charset_full += self.charset["digit_similar"]
            else:
                self.charset_full += self.charset["digit"]

        if self.config & 0x08:
            self.charset["special"] = chr_specials
            self.charset_full += self.charset["special"]

        if self.config & 0x10:
            if self.config & 0x20:
                self.charset_full = self.charset["hex_similar"]
            else:
                self.charset_full = self.charset["hex"]

        self.min_digits = min_digits

    def __del__(self):
        pass

    def srand(self, seed):
        self.seed = seed

    def rand(self):
        self.seed = ((0x000343FD * self.seed) + 0x00269EC3) & 0xFFFFFFFF
        return (self.seed >> 0x10) & 0x7FFF

    def rand_range(self, range):
        return (self.rand() * range) // 0x8000

    def rand_char(self, charset):
        return ord(charset[self.rand_range(len(charset))])

    def generate_character(self, flag, charset):
        if self.pass_length_ctr == 0:
            return
        if not (self.config & flag):
            return
        while True:
            idx = self.rand_range(self.pass_length)
            if self.password[idx] == 0:
                break
        self.password[idx] = self.rand_char(charset)
        self.pass_length_ctr -= 1

    def generate(self, time_seed):
        self.srand(time_seed - self.seed_mod)
        self.seed_mod -= 0x000E3A78

        self.password = bytearray(self.pass_length)
        self.pass_length_ctr = self.pass_length

        for i in range(self.min_digits):
            self.generate_character(0x04, self.charset["digit"])

        if len(self.charset["special"]):
            self.generate_character(0x08, self.charset["special"])

        self.generate_character(0x01, self.charset["upper"])
        self.generate_character(0x02, self.charset["lower"])

        if self.min_digits == 0:
            self.generate_character(0x04, self.charset["digit"])

        for i in range(self.pass_length):
            if self.password[i]:
                continue
            self.password[i] = self.rand_char(self.charset_full)

        return self.password.decode("utf-8")


#Настройки
PASS_LENGTH = 10
CHR_UPPER = True
CHR_LOWER = True
CHR_DIGITS = True
CHR_SPECIALS = ""
CHR_SIMILAR = False
MIN_DIGITS = 1


def make_rf():
    return roboform(
        pass_length=PASS_LENGTH,
        chr_upper=CHR_UPPER,
        chr_lower=CHR_LOWER,
        chr_digits=CHR_DIGITS,
        chr_specials=CHR_SPECIALS,
        chr_similar=CHR_SIMILAR,
        min_digits=MIN_DIGITS,
    )

def build_day_passwords(day_date, out_file="passwords.txt"):

    start = datetime.datetime(day_date.year, day_date.month, day_date.day, 0, 0, 0)
    end = start + datetime.timedelta(days=1)
    start_ts = int(time.mktime(start.timetuple()))
    end_ts = int(time.mktime(end.timetuple()))

    total = end_ts - start_ts
    print(f"Перебор дня {day_date} — {total} секунд")
    print(f"Диапазон timestamp: {start_ts} .. {end_ts - 1}")
    print(f"Сохранение в: {out_file}")
    print()

    start_time = time.time()
    with open(out_file, "w", encoding="utf-8") as f:
        for i, ts in enumerate(range(start_ts, end_ts)):
            rf = make_rf()
            pwd = rf.generate(ts)
            f.write(f"{ts}\t{pwd}\n")

            if i % 5000 == 0 and i > 0:
                elapsed = time.time() - start_time
                speed = i / elapsed if elapsed > 0 else 0
                remaining = (total - i) / speed if speed > 0 else 0
                print(f"  {i}/{total}  ({speed:.0f} пар/сек, осталось ~{remaining:.0f} сек)")

    elapsed = time.time() - start_time
    print()
    print(f"Сгенерировано {total} паролей за {elapsed:.1f} сек.")
    print(f"Файл: {os.path.abspath(out_file)}")

def find_password(target, in_file="passwords.txt"):
    target = target.strip()
    if not target:
        print("Пустой пароль, поиск отменён.")
        return None

    print(f"Ищу пароль: {target}")
    print()

    if not os.path.exists(in_file):
        print(f"Файл не найден. Сначала выполните перебор")
        return None

    found = []
    with open(in_file, "r", encoding="utf-8") as f:
        for line in f:
            line = line.rstrip("\n")
            if not line:
                continue
            ts_str, _, pwd = line.partition("\t")
            if pwd == target:
                found.append(int(ts_str))

    if found:
        print("СОВПАДЕНИЕ НАЙДЕНО")
        for ts in found:
            dt_local = datetime.datetime.fromtimestamp(ts)
            dt_utc = datetime.datetime.fromtimestamp(ts, datetime.UTC)
            print(f"  timestamp : {ts}")
            print(f"  local     : {dt_local}")
            print(f"  UTC       : {dt_utc}")
            print(f"  пароль    : {target}")
        return found[0]
    else:
        print("СОВПАДЕНИЙ НЕ НАЙДЕНО")
        return None

def main():
    today = datetime.date.today()
    out_file = "passwords.txt"

    if os.path.exists(out_file):
        print(f"Файл уже существует.")
        choice = input("Пересобрать заново? (y/n): ").strip().lower()
        if choice != "y":
            print("Использую существующий файл")
        else:
            build_day_passwords(today, out_file)
    else:
        build_day_passwords(today, out_file)

    print()
    print("ВВЕДИТЕ ПАРОЛЬ ОТ ROBOFORM")

    try:
        target = input("Пароль: ").strip()
    except (EOFError, KeyboardInterrupt):
        print("\nВвод прерван.")
        return

    if not target:
        print("Пустой ввод — поиск отменён.")
        return

    print()
    find_password(target, out_file)


if __name__ == "__main__":
    main()