189 lines
6.0 KiB
Python
189 lines
6.0 KiB
Python
"""
|
|
cURL command parser module.
|
|
"""
|
|
|
|
import re
|
|
import shlex
|
|
from dataclasses import dataclass, field
|
|
from typing import Optional
|
|
|
|
|
|
@dataclass
|
|
class ParsedCurl:
|
|
url: str = ""
|
|
method: str = "GET"
|
|
headers: dict = field(default_factory=dict)
|
|
data: Optional[str] = None
|
|
auth: Optional[tuple] = None
|
|
content_type: Optional[str] = None
|
|
insecure: bool = False
|
|
|
|
|
|
class CurlParser:
|
|
def __init__(self, curl_command: str):
|
|
self.curl_command = curl_command
|
|
|
|
def parse(self) -> ParsedCurl:
|
|
"""Parse a cURL command and return structured data."""
|
|
result = ParsedCurl()
|
|
|
|
command = self._normalize_command()
|
|
tokens = self._tokenize(command)
|
|
|
|
i = 0
|
|
while i < len(tokens):
|
|
token = tokens[i]
|
|
|
|
if token == 'curl':
|
|
i += 1
|
|
continue
|
|
|
|
if token.startswith('-'):
|
|
if token in ['-X', '--request']:
|
|
i += 1
|
|
result.method = tokens[i].upper() if i < len(tokens) else 'GET'
|
|
elif token in ['-H', '--header']:
|
|
i += 1
|
|
header = ""
|
|
if i < len(tokens):
|
|
header = tokens[i]
|
|
if header.endswith(':'):
|
|
i += 1
|
|
while i < len(tokens) and not tokens[i].startswith('-'):
|
|
if '://' in tokens[i]:
|
|
i -= 1
|
|
break
|
|
header += ' ' + tokens[i]
|
|
i += 1
|
|
if header:
|
|
self._parse_header(header, result)
|
|
continue
|
|
elif token in ['-d', '--data', '--data-raw', '--data-binary']:
|
|
i += 1
|
|
result.data = tokens[i] if i < len(tokens) else ''
|
|
if not result.method or result.method == 'GET':
|
|
result.method = 'POST'
|
|
continue
|
|
elif token in ['-u', '--user']:
|
|
i += 1
|
|
if i < len(tokens):
|
|
auth = tokens[i]
|
|
if ':' in auth:
|
|
parts = auth.split(':', 1)
|
|
result.auth = (parts[0], parts[1])
|
|
i += 1
|
|
continue
|
|
elif token == '--url':
|
|
i += 1
|
|
result.url = tokens[i] if i < len(tokens) else ''
|
|
continue
|
|
elif token in ['-b', '--cookie', '--cookie-jar']:
|
|
i += 1
|
|
cookie = tokens[i]
|
|
if '=' in cookie:
|
|
name, value = cookie.split('=', 1)
|
|
result.headers['Cookie'] = value
|
|
continue
|
|
elif token in ['-A', '--user-agent']:
|
|
i += 1
|
|
result.headers['User-Agent'] = tokens[i] if i < len(tokens) else ''
|
|
continue
|
|
elif token == '--compressed':
|
|
result.headers['Accept-Encoding'] = 'gzip, deflate'
|
|
elif token in ['-k', '--insecure']:
|
|
result.insecure = True
|
|
i += 1
|
|
else:
|
|
if not result.url:
|
|
result.url = token
|
|
i += 1
|
|
|
|
return result
|
|
|
|
def _normalize_command(self) -> str:
|
|
"""Normalize the cURL command for parsing."""
|
|
command = self.curl_command.strip()
|
|
command = re.sub(r'\\\n', '', command)
|
|
command = re.sub(r'\s+', ' ', command)
|
|
return command
|
|
|
|
def _tokenize(self, command: str) -> list:
|
|
"""Tokenize the cURL command."""
|
|
tokens = []
|
|
current = ""
|
|
in_quote = False
|
|
quote_char = None
|
|
|
|
i = 0
|
|
while i < len(command):
|
|
char = command[i]
|
|
|
|
if char in ['"', "'"] and not in_quote:
|
|
in_quote = True
|
|
quote_char = char
|
|
i += 1
|
|
continue
|
|
elif char == quote_char and in_quote:
|
|
in_quote = False
|
|
quote_char = None
|
|
i += 1
|
|
continue
|
|
|
|
if in_quote:
|
|
if char == '\\' and i + 1 < len(command):
|
|
current += char
|
|
current += command[i + 1]
|
|
i += 2
|
|
continue
|
|
elif char == ' ':
|
|
if current:
|
|
tokens.append(current)
|
|
current = ""
|
|
i += 1
|
|
continue
|
|
|
|
if char == ' ' and not in_quote:
|
|
if current:
|
|
tokens.append(current)
|
|
current = ""
|
|
i += 1
|
|
continue
|
|
|
|
current += char
|
|
i += 1
|
|
|
|
if current:
|
|
tokens.append(current)
|
|
|
|
unescaped_tokens = []
|
|
for token in tokens:
|
|
token = token.replace('\\:', ':')
|
|
token = token.replace('\\"', '"')
|
|
token = token.replace("\\'", "'")
|
|
token = token.replace('\\n', '\n')
|
|
unescaped_tokens.append(token)
|
|
|
|
return unescaped_tokens
|
|
|
|
def _parse_header(self, header: str, result: ParsedCurl):
|
|
"""Parse a header string and update the result."""
|
|
if ':' in header:
|
|
parts = header.split(':', 1)
|
|
key = parts[0].strip()
|
|
value = parts[1].strip()
|
|
result.headers[key] = value
|
|
|
|
if key.lower() == 'content-type':
|
|
result.content_type = value
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
parser = CurlParser(' '.join(sys.argv[1:]))
|
|
result = parser.parse()
|
|
print(f"URL: {result.url}")
|
|
print(f"Method: {result.method}")
|
|
print(f"Headers: {result.headers}")
|
|
print(f"Data: {result.data}")
|
|
print(f"Auth: {result.auth}")
|