3v4l.org

run code in 300+ PHP versions simultaneously
#Author : Burtay # #Site : http://Burtay.Org # #Date : 09.06.2011 # #Location : Istanbul , Turkey # #Thanks : RmX,F0RTYS3V3N,silnt hill # ################################################### error_reporting(0); set_time_limit(0); if($argc <=2 or $argc>=4) die("\nSomethins Wrong\nusage php wp-hash.php HASH WORDLIST.TXT\n#Coded By Burtay\n#Burtay.Org | hack-book.Net | Tryag.cc | xp10.com\n"); $wp_hasher_burtay = new PasswordHash(8, TRUE); $aranan = $argv[1]; $wordlist = $argv[2]; $oku = file($wordlist); foreach($oku as $tek) { if($wp_hasher_burtay->CheckPassword(trim($tek), $aranan)) { echo "[+]FOUND Ohhh Shit->".$tek."\n"; die("\nCoded By Burtay\Burtay.Org | hack-book.Net | Tryag.cc | xp10.com\n"); } else { echo "[+]Testing -> ".trim($tek)."\n"; } } ?> <?php # # Written by Solar Designer <solar at openwall.com> in 2004-2006 and placed in # the public domain. # # There's absolutely no warranty. # # Please be sure to update the Version line if you edit this file in any way. # It is suggested that you leave the main version number intact, but indicate # your project name (after the slash) and add your own revision information. # # Please do not change the "private" password hashing method implemented in # here, thereby making your hashes incompatible. However, if you must, please # change the hash type identifier (the "$P$") to something different. # # Obviously, since this code is in the public domain, the above are not # requirements (there can be none), but merely suggestions. # class PasswordHash { var $itoa64; var $iteration_count_log2; var $portable_hashes; var $random_state; function PasswordHash($iteration_count_log2, $portable_hashes) { $this->itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'; if ($iteration_count_log2 < 4 || $iteration_count_log2 > 31) $iteration_count_log2 = 8; $this->iteration_count_log2 = $iteration_count_log2; $this->portable_hashes = $portable_hashes; $this->random_state = microtime() . uniqid(rand(), TRUE); // removed getmypid() for compability reasons } function get_random_bytes($count) { $output = ''; if ( @is_readable('/dev/urandom') && ($fh = @fopen('/dev/urandom', 'rb'))) { $output = fread($fh, $count); fclose($fh); } if (strlen($output) < $count) { $output = ''; for ($i = 0; $i < $count; $i += 16) { $this->random_state = md5(microtime() . $this->random_state); $output .= pack('H*', md5($this->random_state)); } $output = substr($output, 0, $count); } return $output; } function encode64($input, $count) { $output = ''; $i = 0; do { $value = ord($input[$i++]); $output .= $this->itoa64[$value & 0x3f]; if ($i < $count) $value |= ord($input[$i]) << 8; $output .= $this->itoa64[($value >> 6) & 0x3f]; if ($i++ >= $count) break; if ($i < $count) $value |= ord($input[$i]) << 16; $output .= $this->itoa64[($value >> 12) & 0x3f]; if ($i++ >= $count) break; $output .= $this->itoa64[($value >> 18) & 0x3f]; } while ($i < $count); return $output; } function gensalt_private($input) { $output = '$P$'; $output .= $this->itoa64[min($this->iteration_count_log2 + ((PHP_VERSION >= '5') ? 5 : 3), 30)]; $output .= $this->encode64($input, 6); return $output; } function crypt_private($password, $setting) { $output = '*0'; if (substr($setting, 0, 2) == $output) $output = '*1'; if (substr($setting, 0, 3) != '$P$') return $output; $count_log2 = strpos($this->itoa64, $setting[3]); if ($count_log2 < 7 || $count_log2 > 30) return $output; $count = 1 << $count_log2; $salt = substr($setting, 4, 8); if (strlen($salt) != 8) return $output; # We're kind of forced to use MD5 here since it's the only # cryptographic primitive available in all versions of PHP # currently in use. To implement our own low-level crypto # in PHP would result in much worse performance and # consequently in lower iteration counts and hashes that are # quicker to crack (by non-PHP code). if (PHP_VERSION >= '5') { $hash = md5($salt . $password, TRUE); do { $hash = md5($hash . $password, TRUE); } while (--$count); } else { $hash = pack('H*', md5($salt . $password)); do { $hash = pack('H*', md5($hash . $password)); } while (--$count); } $output = substr($setting, 0, 12); $output .= $this->encode64($hash, 16); return $output; } function gensalt_extended($input) { $count_log2 = min($this->iteration_count_log2 + 8, 24); # This should be odd to not reveal weak DES keys, and the # maximum valid value is (2**24 - 1) which is odd anyway. $count = (1 << $count_log2) - 1; $output = '_'; $output .= $this->itoa64[$count & 0x3f]; $output .= $this->itoa64[($count >> 6) & 0x3f]; $output .= $this->itoa64[($count >> 12) & 0x3f]; $output .= $this->itoa64[($count >> 18) & 0x3f]; $output .= $this->encode64($input, 3); return $output; } function gensalt_blowfish($input) { # This one needs to use a different order of characters and a # different encoding scheme from the one in encode64() above. # We care because the last character in our encoded string will # only represent 2 bits. While two known implementations of # bcrypt will happily accept and correct a salt string which # has the 4 unused bits set to non-zero, we do not want to take # chances and we also do not want to waste an additional byte # of entropy. $itoa64 = './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'; $output = '$2a$'; $output .= chr(ord('0') + $this->iteration_count_log2 / 10); $output .= chr(ord('0') + $this->iteration_count_log2 % 10); $output .= '$'; $i = 0; do { $c1 = ord($input[$i++]); $output .= $itoa64[$c1 >> 2]; $c1 = ($c1 & 0x03) << 4; if ($i >= 16) { $output .= $itoa64[$c1]; break; } $c2 = ord($input[$i++]); $c1 |= $c2 >> 4; $output .= $itoa64[$c1]; $c1 = ($c2 & 0x0f) << 2; $c2 = ord($input[$i++]); $c1 |= $c2 >> 6; $output .= $itoa64[$c1]; $output .= $itoa64[$c2 & 0x3f]; } while (1); return $output; } function HashPassword($password) { $random = ''; if (CRYPT_BLOWFISH == 1 && !$this->portable_hashes) { $random = $this->get_random_bytes(16); $hash = crypt($password, $this->gensalt_blowfish($random)); if (strlen($hash) == 60) return $hash; } if (CRYPT_EXT_DES == 1 && !$this->portable_hashes) { if (strlen($random) < 3) $random = $this->get_random_bytes(3); $hash = crypt($password, $this->gensalt_extended($random)); if (strlen($hash) == 20) return $hash; } if (strlen($random) < 6) $random = $this->get_random_bytes(6); $hash = $this->crypt_private($password, $this->gensalt_private($random)); if (strlen($hash) == 34) return $hash; # Returning '*' on error is safe here, but would _not_ be safe # in a crypt(3)-like function used _both_ for generating new # hashes and for validating passwords against existing hashes. return '*'; } function CheckPassword($password, $stored_hash) { $hash = $this->crypt_private($password, $stored_hash); if ($hash[0] == '*') $hash = crypt($password, $stored_hash); return $hash == $stored_hash; } } ?>
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/bYsNU
function name:  (null)
number of ops:  2
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
    1     0  E >   ECHO                                                     '%23Author+++%3A+Burtay+++++++++++++++++++++++++++++++++++++++++++++++++++++++%23%0A%23Site+++++++++++%3A+http%3A%2F%2FBurtay.Org+++++++++++++++++++++++++++++++%23%0A%23Date+++++++++++%3A+09.06.2011+++++++++++++++++++++++++++++++++++++++++++++%23%0A%23Location+++++++%3A+Istanbul+%2C+Turkey+++++++++++++++++++++++++++++++%23%0A%23Thanks+++%3A+RmX%2CF0RTYS3V3N%2Csilnt+hill+++++++++++++%23%0A%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0Aerror_reporting%280%29%3B%0Aset_time_limit%280%29%3B%0Aif%28%24argc+%3C%3D2+or+%24argc%3E%3D4%29%0Adie%28%22%5CnSomethins+Wrong%5Cnusage+php+wp-hash.php+HASH+WORDLIST.TXT%5Cn%23Coded+By+Burtay%5Cn%23Burtay.Org+%7C+hack-book.Net+%7C+Tryag.cc+%7C+xp10.com%5Cn%22%29%3B%0A%24wp_hasher_burtay+%3D+new+PasswordHash%288%2C+TRUE%29%3B%0A%24aranan+++++++++%3D+++++++%24argv%5B1%5D%3B%0A%24wordlist+++++++%3D+++++++%24argv%5B2%5D%3B%0A%24oku++++++++++++%3D+++++++file%28%24wordlist%29%3B%0Aforeach%28%24oku+as+%24tek%29%0A%7B+++%0A++++++++if%28%24wp_hasher_burtay-%3ECheckPassword%28trim%28%24tek%29%2C+%24aranan%29%29%0A++++++++%7B%0A+++++++++++echo+%22%5B%2B%5DFOUND+Ohhh+Shit-%3E%22.%24tek.%22%5Cn%22%3B%0A+++++++++++die%28%22%5CnCoded+By+Burtay%5CBurtay.Org+%7C+hack-book.Net+%7C+Tryag.cc+%7C+xp10.com%5Cn%22%29%3B%0A++++++++%7D%0A++++++++else%0A++++++++%7B%0A+++++++++++echo+%22%5B%2B%5DTesting+-%3E+%22.trim%28%24tek%29.%22%5Cn%22%3B%0A++++++++%7D%0A%7D%0A%3F%3E%0A'
  233     1      > RETURN                                                   1

Class PasswordHash:
Function passwordhash:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 47) Position 1 = 6, Position 2 = 8
Branch analysis from position: 6
2 jumps found. (Code = 43) Position 1 = 9, Position 2 = 10
Branch analysis from position: 9
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 10
Branch analysis from position: 8
filename:       /in/bYsNU
function name:  PasswordHash
number of ops:  26
compiled vars:  !0 = $iteration_count_log2, !1 = $portable_hashes
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   53     0  E >   RECV                                             !0      
          1        RECV                                             !1      
   55     2        ASSIGN_OBJ                                               'itoa64'
          3        OP_DATA                                                  '.%2F0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
   56     4        IS_SMALLER                                       ~3      !0, 4
          5      > JMPNZ_EX                                         ~3      ~3, ->8
          6    >   IS_SMALLER                                       ~4      31, !0
          7        BOOL                                             ~3      ~4
          8    > > JMPZ                                                     ~3, ->10
   57     9    >   ASSIGN                                                   !0, 8
   58    10    >   ASSIGN_OBJ                                               'iteration_count_log2'
         11        OP_DATA                                                  !0
   59    12        ASSIGN_OBJ                                               'portable_hashes'
         13        OP_DATA                                                  !1
   60    14        INIT_FCALL                                               'microtime'
         15        DO_ICALL                                         $9      
         16        INIT_FCALL                                               'uniqid'
         17        INIT_FCALL                                               'rand'
         18        DO_ICALL                                         $10     
         19        SEND_VAR                                                 $10
         20        SEND_VAL                                                 <true>
         21        DO_ICALL                                         $11     
         22        CONCAT                                           ~12     $9, $11
         23        ASSIGN_OBJ                                               'random_state'
         24        OP_DATA                                                  ~12
   61    25      > RETURN                                                   null

End of function passwordhash

Function get_random_bytes:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 46) Position 1 = 8, Position 2 = 16
Branch analysis from position: 8
2 jumps found. (Code = 43) Position 1 = 17, Position 2 = 25
Branch analysis from position: 17
2 jumps found. (Code = 43) Position 1 = 28, Position 2 = 58
Branch analysis from position: 28
1 jumps found. (Code = 42) Position 1 = 50
Branch analysis from position: 50
2 jumps found. (Code = 44) Position 1 = 52, Position 2 = 31
Branch analysis from position: 52
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 31
2 jumps found. (Code = 44) Position 1 = 52, Position 2 = 31
Branch analysis from position: 52
Branch analysis from position: 31
Branch analysis from position: 58
Branch analysis from position: 25
Branch analysis from position: 16
filename:       /in/bYsNU
function name:  get_random_bytes
number of ops:  60
compiled vars:  !0 = $count, !1 = $output, !2 = $fh, !3 = $i
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   62     0  E >   RECV                                             !0      
   64     1        ASSIGN                                                   !1, ''
   65     2        BEGIN_SILENCE                                    ~5      
          3        INIT_FCALL                                               'is_readable'
          4        SEND_VAL                                                 '%2Fdev%2Furandom'
          5        DO_ICALL                                         $6      
          6        END_SILENCE                                              ~5
          7      > JMPZ_EX                                          ~7      $6, ->16
   66     8    >   BEGIN_SILENCE                                    ~8      
          9        INIT_FCALL                                               'fopen'
         10        SEND_VAL                                                 '%2Fdev%2Furandom'
         11        SEND_VAL                                                 'rb'
         12        DO_ICALL                                         $9      
         13        END_SILENCE                                              ~8
         14        ASSIGN                                           ~10     !2, $9
         15        BOOL                                             ~7      ~10
         16    > > JMPZ                                                     ~7, ->25
   67    17    >   INIT_FCALL                                               'fread'
         18        SEND_VAR                                                 !2
         19        SEND_VAR                                                 !0
         20        DO_ICALL                                         $11     
         21        ASSIGN                                                   !1, $11
   68    22        INIT_FCALL                                               'fclose'
         23        SEND_VAR                                                 !2
         24        DO_ICALL                                                 
   70    25    >   STRLEN                                           ~14     !1
         26        IS_SMALLER                                               ~14, !0
         27      > JMPZ                                                     ~15, ->58
   71    28    >   ASSIGN                                                   !1, ''
   72    29        ASSIGN                                                   !3, 0
         30      > JMP                                                      ->50
   74    31    >   INIT_FCALL                                               'md5'
         32        INIT_FCALL                                               'microtime'
         33        DO_ICALL                                         $19     
         34        FETCH_OBJ_R                                      ~20     'random_state'
         35        CONCAT                                           ~21     $19, ~20
         36        SEND_VAL                                                 ~21
         37        DO_ICALL                                         $22     
   73    38        ASSIGN_OBJ                                               'random_state'
   74    39        OP_DATA                                                  $22
   76    40        INIT_FCALL                                               'pack'
         41        SEND_VAL                                                 'H%2A'
         42        INIT_FCALL                                               'md5'
         43        FETCH_OBJ_R                                      ~23     'random_state'
         44        SEND_VAL                                                 ~23
         45        DO_ICALL                                         $24     
         46        SEND_VAR                                                 $24
         47        DO_ICALL                                         $25     
         48        ASSIGN_OP                                     8          !1, $25
   72    49        ASSIGN_OP                                     1          !3, 16
         50    >   IS_SMALLER                                               !3, !0
         51      > JMPNZ                                                    ~28, ->31
   78    52    >   INIT_FCALL                                               'substr'
         53        SEND_VAR                                                 !1
         54        SEND_VAL                                                 0
         55        SEND_VAR                                                 !0
         56        DO_ICALL                                         $29     
         57        ASSIGN                                                   !1, $29
   80    58    > > RETURN                                                   !1
   81    59*     > RETURN                                                   null

End of function get_random_bytes

Function encode64:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 16, Position 2 = 22
Branch analysis from position: 16
2 jumps found. (Code = 43) Position 1 = 30, Position 2 = 31
Branch analysis from position: 30
1 jumps found. (Code = 42) Position 1 = 55
Branch analysis from position: 55
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 31
2 jumps found. (Code = 43) Position 1 = 33, Position 2 = 39
Branch analysis from position: 33
2 jumps found. (Code = 43) Position 1 = 47, Position 2 = 48
Branch analysis from position: 47
1 jumps found. (Code = 42) Position 1 = 55
Branch analysis from position: 55
Branch analysis from position: 48
2 jumps found. (Code = 44) Position 1 = 55, Position 2 = 4
Branch analysis from position: 55
Branch analysis from position: 4
Branch analysis from position: 39
Branch analysis from position: 22
filename:       /in/bYsNU
function name:  encode64
number of ops:  57
compiled vars:  !0 = $input, !1 = $count, !2 = $output, !3 = $i, !4 = $value
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   82     0  E >   RECV                                             !0      
          1        RECV                                             !1      
   84     2        ASSIGN                                                   !2, ''
   85     3        ASSIGN                                                   !3, 0
   87     4    >   INIT_FCALL                                               'ord'
          5        POST_INC                                         ~7      !3
          6        FETCH_DIM_R                                      ~8      !0, ~7
          7        SEND_VAL                                                 ~8
          8        DO_ICALL                                         $9      
          9        ASSIGN                                                   !4, $9
   88    10        BW_AND                                           ~12     !4, 63
         11        FETCH_OBJ_R                                      ~11     'itoa64'
         12        FETCH_DIM_R                                      ~13     ~11, ~12
         13        ASSIGN_OP                                     8          !2, ~13
   89    14        IS_SMALLER                                               !3, !1
         15      > JMPZ                                                     ~15, ->22
   90    16    >   INIT_FCALL                                               'ord'
         17        FETCH_DIM_R                                      ~16     !0, !3
         18        SEND_VAL                                                 ~16
         19        DO_ICALL                                         $17     
         20        SL                                               ~18     $17, 8
         21        ASSIGN_OP                                     9          !4, ~18
   91    22    >   SR                                               ~21     !4, 6
         23        BW_AND                                           ~22     ~21, 63
         24        FETCH_OBJ_R                                      ~20     'itoa64'
         25        FETCH_DIM_R                                      ~23     ~20, ~22
         26        ASSIGN_OP                                     8          !2, ~23
   92    27        POST_INC                                         ~25     !3
         28        IS_SMALLER_OR_EQUAL                                      !1, ~25
         29      > JMPZ                                                     ~26, ->31
   93    30    > > JMP                                                      ->55
   94    31    >   IS_SMALLER                                               !3, !1
         32      > JMPZ                                                     ~27, ->39
   95    33    >   INIT_FCALL                                               'ord'
         34        FETCH_DIM_R                                      ~28     !0, !3
         35        SEND_VAL                                                 ~28
         36        DO_ICALL                                         $29     
         37        SL                                               ~30     $29, 16
         38        ASSIGN_OP                                     9          !4, ~30
   96    39    >   SR                                               ~33     !4, 12
         40        BW_AND                                           ~34     ~33, 63
         41        FETCH_OBJ_R                                      ~32     'itoa64'
         42        FETCH_DIM_R                                      ~35     ~32, ~34
         43        ASSIGN_OP                                     8          !2, ~35
   97    44        POST_INC                                         ~37     !3
         45        IS_SMALLER_OR_EQUAL                                      !1, ~37
         46      > JMPZ                                                     ~38, ->48
   98    47    > > JMP                                                      ->55
   99    48    >   SR                                               ~40     !4, 18
         49        BW_AND                                           ~41     ~40, 63
         50        FETCH_OBJ_R                                      ~39     'itoa64'
         51        FETCH_DIM_R                                      ~42     ~39, ~41
         52        ASSIGN_OP                                     8          !2, ~42
  100    53        IS_SMALLER                                               !3, !1
         54      > JMPNZ                                                    ~44, ->4
  101    55    > > RETURN                                                   !2
  102    56*     > RETURN                                                   null

End of function encode64

Function gensalt_private:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 5, Position 2 = 7
Branch analysis from position: 5
1 jumps found. (Code = 42) Position 1 = 8
Branch analysis from position: 8
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 7
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/bYsNU
function name:  gensalt_private
number of ops:  22
compiled vars:  !0 = $input, !1 = $output
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  103     0  E >   RECV                                             !0      
  105     1        ASSIGN                                                   !1, '%24P%24'
  106     2        INIT_FCALL                                               'min'
          3        FETCH_OBJ_R                                      ~4      'iteration_count_log2'
  107     4      > JMPZ                                                     <true>, ->7
          5    >   QM_ASSIGN                                        ~5      5
          6      > JMP                                                      ->8
          7    >   QM_ASSIGN                                        ~5      3
          8    >   ADD                                              ~6      ~4, ~5
          9        SEND_VAL                                                 ~6
         10        SEND_VAL                                                 30
         11        DO_ICALL                                         $7      
  106    12        FETCH_OBJ_R                                      ~3      'itoa64'
  107    13        FETCH_DIM_R                                      ~8      ~3, $7
         14        ASSIGN_OP                                     8          !1, ~8
  108    15        INIT_METHOD_CALL                                         'encode64'
         16        SEND_VAR_EX                                              !0
         17        SEND_VAL_EX                                              6
         18        DO_FCALL                                      0  $10     
         19        ASSIGN_OP                                     8          !1, $10
  109    20      > RETURN                                                   !1
  110    21*     > RETURN                                                   null

End of function gensalt_private

Function crypt_private:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 10, Position 2 = 11
Branch analysis from position: 10
2 jumps found. (Code = 43) Position 1 = 18, Position 2 = 19
Branch analysis from position: 18
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 19
2 jumps found. (Code = 47) Position 1 = 28, Position 2 = 30
Branch analysis from position: 28
2 jumps found. (Code = 43) Position 1 = 31, Position 2 = 32
Branch analysis from position: 31
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 32
2 jumps found. (Code = 43) Position 1 = 43, Position 2 = 44
Branch analysis from position: 43
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 44
2 jumps found. (Code = 43) Position 1 = 45, Position 2 = 60
Branch analysis from position: 45
2 jumps found. (Code = 44) Position 1 = 59, Position 2 = 51
Branch analysis from position: 59
1 jumps found. (Code = 42) Position 1 = 80
Branch analysis from position: 80
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 51
Branch analysis from position: 60
2 jumps found. (Code = 44) Position 1 = 80, Position 2 = 69
Branch analysis from position: 80
Branch analysis from position: 69
Branch analysis from position: 30
Branch analysis from position: 11
filename:       /in/bYsNU
function name:  crypt_private
number of ops:  93
compiled vars:  !0 = $password, !1 = $setting, !2 = $output, !3 = $count_log2, !4 = $count, !5 = $salt, !6 = $hash
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  111     0  E >   RECV                                             !0      
          1        RECV                                             !1      
  113     2        ASSIGN                                                   !2, '%2A0'
  114     3        INIT_FCALL                                               'substr'
          4        SEND_VAR                                                 !1
          5        SEND_VAL                                                 0
          6        SEND_VAL                                                 2
          7        DO_ICALL                                         $8      
          8        IS_EQUAL                                                 !2, $8
          9      > JMPZ                                                     ~9, ->11
  115    10    >   ASSIGN                                                   !2, '%2A1'
  116    11    >   INIT_FCALL                                               'substr'
         12        SEND_VAR                                                 !1
         13        SEND_VAL                                                 0
         14        SEND_VAL                                                 3
         15        DO_ICALL                                         $11     
         16        IS_NOT_EQUAL                                             $11, '%24P%24'
         17      > JMPZ                                                     ~12, ->19
  117    18    > > RETURN                                                   !2
  118    19    >   INIT_FCALL                                               'strpos'
         20        FETCH_OBJ_R                                      ~13     'itoa64'
         21        SEND_VAL                                                 ~13
         22        FETCH_DIM_R                                      ~14     !1, 3
         23        SEND_VAL                                                 ~14
         24        DO_ICALL                                         $15     
         25        ASSIGN                                                   !3, $15
  119    26        IS_SMALLER                                       ~17     !3, 7
         27      > JMPNZ_EX                                         ~17     ~17, ->30
         28    >   IS_SMALLER                                       ~18     30, !3
         29        BOOL                                             ~17     ~18
         30    > > JMPZ                                                     ~17, ->32
  120    31    > > RETURN                                                   !2
  121    32    >   SL                                               ~19     1, !3
         33        ASSIGN                                                   !4, ~19
  122    34        INIT_FCALL                                               'substr'
         35        SEND_VAR                                                 !1
         36        SEND_VAL                                                 4
         37        SEND_VAL                                                 8
         38        DO_ICALL                                         $21     
         39        ASSIGN                                                   !5, $21
  123    40        STRLEN                                           ~23     !5
         41        IS_NOT_EQUAL                                             ~23, 8
         42      > JMPZ                                                     ~24, ->44
  124    43    > > RETURN                                                   !2
  131    44    > > JMPZ                                                     <true>, ->60
  132    45    >   INIT_FCALL                                               'md5'
         46        CONCAT                                           ~25     !5, !0
         47        SEND_VAL                                                 ~25
         48        SEND_VAL                                                 <true>
         49        DO_ICALL                                         $26     
         50        ASSIGN                                                   !6, $26
  134    51    >   INIT_FCALL                                               'md5'
         52        CONCAT                                           ~28     !6, !0
         53        SEND_VAL                                                 ~28
         54        SEND_VAL                                                 <true>
         55        DO_ICALL                                         $29     
         56        ASSIGN                                                   !6, $29
  135    57        PRE_DEC                                          ~31     !4
         58      > JMPNZ                                                    ~31, ->51
         59    > > JMP                                                      ->80
  137    60    >   INIT_FCALL                                               'pack'
         61        SEND_VAL                                                 'H%2A'
         62        INIT_FCALL                                               'md5'
         63        CONCAT                                           ~32     !5, !0
         64        SEND_VAL                                                 ~32
         65        DO_ICALL                                         $33     
         66        SEND_VAR                                                 $33
         67        DO_ICALL                                         $34     
         68        ASSIGN                                                   !6, $34
  139    69    >   INIT_FCALL                                               'pack'
         70        SEND_VAL                                                 'H%2A'
         71        INIT_FCALL                                               'md5'
         72        CONCAT                                           ~36     !6, !0
         73        SEND_VAL                                                 ~36
         74        DO_ICALL                                         $37     
         75        SEND_VAR                                                 $37
         76        DO_ICALL                                         $38     
         77        ASSIGN                                                   !6, $38
  140    78        PRE_DEC                                          ~40     !4
         79      > JMPNZ                                                    ~40, ->69
  142    80    >   INIT_FCALL                                               'substr'
         81        SEND_VAR                                                 !1
         82        SEND_VAL                                                 0
         83        SEND_VAL                                                 12
         84        DO_ICALL                                         $41     
         85        ASSIGN                                                   !2, $41
  143    86        INIT_METHOD_CALL                                         'encode64'
         87        SEND_VAR_EX                                              !6
         88        SEND_VAL_EX                                              16
         89        DO_FCALL                                      0  $43     
         90        ASSIGN_OP                                     8          !2, $43
  144    91      > RETURN                                                   !2
  145    92*     > RETURN                                                   null

End of function crypt_private

Function gensalt_extended:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/bYsNU
function name:  gensalt_extended
number of ops:  38
compiled vars:  !0 = $input, !1 = $count_log2, !2 = $count, !3 = $output
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  146     0  E >   RECV                                             !0      
  148     1        INIT_FCALL                                               'min'
          2        FETCH_OBJ_R                                      ~4      'iteration_count_log2'
          3        ADD                                              ~5      ~4, 8
          4        SEND_VAL                                                 ~5
          5        SEND_VAL                                                 24
          6        DO_ICALL                                         $6      
          7        ASSIGN                                                   !1, $6
  151     8        SL                                               ~8      1, !1
          9        SUB                                              ~9      ~8, 1
         10        ASSIGN                                                   !2, ~9
  152    11        ASSIGN                                                   !3, '_'
  153    12        BW_AND                                           ~13     !2, 63
         13        FETCH_OBJ_R                                      ~12     'itoa64'
         14        FETCH_DIM_R                                      ~14     ~12, ~13
         15        ASSIGN_OP                                     8          !3, ~14
  154    16        SR                                               ~17     !2, 6
         17        BW_AND                                           ~18     ~17, 63
         18        FETCH_OBJ_R                                      ~16     'itoa64'
         19        FETCH_DIM_R                                      ~19     ~16, ~18
         20        ASSIGN_OP                                     8          !3, ~19
  155    21        SR                                               ~22     !2, 12
         22        BW_AND                                           ~23     ~22, 63
         23        FETCH_OBJ_R                                      ~21     'itoa64'
         24        FETCH_DIM_R                                      ~24     ~21, ~23
         25        ASSIGN_OP                                     8          !3, ~24
  156    26        SR                                               ~27     !2, 18
         27        BW_AND                                           ~28     ~27, 63
         28        FETCH_OBJ_R                                      ~26     'itoa64'
         29        FETCH_DIM_R                                      ~29     ~26, ~28
         30        ASSIGN_OP                                     8          !3, ~29
  157    31        INIT_METHOD_CALL                                         'encode64'
         32        SEND_VAR_EX                                              !0
         33        SEND_VAL_EX                                              3
         34        DO_FCALL                                      0  $31     
         35        ASSIGN_OP                                     8          !3, $31
  158    36      > RETURN                                                   !3
  159    37*     > RETURN                                                   null

End of function gensalt_extended

Function gensalt_blowfish:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 33, Position 2 = 36
Branch analysis from position: 33
1 jumps found. (Code = 42) Position 1 = 63
Branch analysis from position: 63
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis f

Generated using Vulcan Logic Dumper, using php 8.0.0


preferences:
157.48 ms | 1428 KiB | 39 Q