GitHub - ronin-dojo/string-x: Ferramenta modular de automatização desenvolvida para auxiliar analistas em OSINT, pentest e análise de dados através da manipulação dinâmica de strings em linhas de comando Linux. Sistema baseado em templates com processamento paralelo e módulos extensíveis.

Ferramenta de Automatização para Manipulação de Strings

Ferramenta modular de automatização desenvolvida para auxiliar analistas em OSINT, pentest e análise de dados através da manipulação dinâmica de strings em linhas de comando Linux. Sistema baseado em templates com processamento paralelo e módulos extensíveis.

✨ Características

🚀 Processamento Paralelo: Sistema de threads configurável para alta performance
🔧 Arquitetura Modular: Extensível através de módulos EXT, CLC, OUT e CON
🔄 Template Dinâmico: Sistema de substituição de strings com placeholder {STRING}
🛠️ Funções Integradas: Funções de hash, encoding, requests e geração de valores aleatórios
📁 Múltiplas Fontes: Suporte a arquivos, stdin e pipes
🎯 Filtragem Avançada: Sistema de filtros para processamento seletivo
💾 Output Flexível: Salvamento em arquivos com timestamp automático

📦 INSTALAÇÃO

Requisitos

Python 3.8+
Linux/MacOS
Bibliotecas listadas em requirements.txt

Instalação Rápida

# Clone o repositório
git clone https://github.com/MrCl0wnLab/string-x.git
cd string-x

# Instale as dependências
pip install -r requirements.txt

# Torne o arquivo executável
chmod +x strx

# Teste a instalação
./strx --help

🧠 CONCEITOS FUNDAMENTAIS

Sistema de Template {STRING}

A ferramenta utiliza o placeholder {STRING} como palavra-chave para substituição dinâmica de valores. Este sistema permite que cada linha de entrada seja processada individualmente, substituindo {STRING} pelo valor atual.

# Arquivo de entrada
host-01.com.br
host-02.com.br
host-03.com.br

# Comando com template
./strx -l hosts.txt -st "host '{STRING}'"

# Resultado gerado
host 'host-01.com.br'
host 'host-02.com.br'
host 'host-03.com.br'

Fluxo de Processamento

Entrada: Dados via arquivo (-l) ou stdin (pipe)
Template: Aplicação do template com {STRING}
Processamento: Execução de comandos/módulos
Pipe: Processamento adicional opcional (-p)
Saída: Resultado final (tela ou arquivo)

🏗️ ARQUITETURA MODULAR

String-X utiliza uma arquitetura modular extensível com quatro tipos principais de módulos:

Tipos de Módulos

Tipo	Código	Descrição	Localização
Extractor	`ext`	Extração de dados específicos (email, URL, domain, phone)	`utils/auxiliary/ext/`
Collector	`clc`	Coleta e agregação de informações (DNS, whois)	`utils/auxiliary/clc/`
Output	`out`	Formatação e envio de resultados (DB, API, files)	`utils/auxiliary/out/`
Connection	`con`	Conexões especializadas (SSH, FTP, etc)	`utils/auxiliary/con/`

Estrutura de Diretórios

string-x/
├── strx                   # Executável principal
├── config/                # Configurações globais
├── core/                  # Núcleo da aplicação
│   ├── command.py         # Processamento de comandos
│   ├── auto_module.py     # Carregamento dinâmico de módulos
│   ├── thread_process.py  # Sistema de threads
│   ├── format.py          # Formatação e encoding
│   └── style_cli.py       # Interface CLI estilizada
└── utils/
    ├── auxiliary/        # Módulos auxiliares
    │   ├── ext/          # Módulos extratores
    │   ├── clc/          # Módulos coletores
    │   ├── out/          # Módulos de saída
    │   └── con/          # Módulos de conexão
    └── helper/           # Funções auxiliares

🚀 USO DA FERRAMENTA

Ajuda e Parâmetros

./strx --help

Parâmetros Principais

Parâmetro	Descrição	Exemplo
`-l, --list`	Arquivo com strings para processamento	`-l hosts.txt`
`-st, --str`	Template de comando com `{STRING}`	`-st "curl {STRING}"`
`-o, --out`	Arquivo de saída para resultados	`-o results.txt`
`-p, --pipe`	Comando adicional via pipe	`-p "grep 200"`
`-v, --verbose`	Modo verboso com detalhes	`-v`
`-t, --thread`	Número de threads paralelas	`-t 50`
`-f, --filter`	Filtro para seleção de strings	`-f ".gov.br"`
`-module`	Seleção de módulo específico	`-module "ext:email"`
`-pm`	Mostrar apenas resultados do módulo	`-pm`
`-pf`	Mostrar apenas resultados de funções	`-pf`
`-of`	Salvar resultados de funções em arquivo	`-of`
`-sleep`	Delay entre threads (segundos)	`-sleep 2`

Interface da Aplicação

usage: strx [-h] [-list file] -str cmd [-out file] [-pipe cmd] [-verbose] 
            [-thread <10>] [-pf] [-of] [-filter value] [-sleep <5>] 
            [-module <type:module>] [-pm]

 
                                             _
                                            (T)          _
                                        _         .=.   (R)
                                       (S)   _   /\/(`)_         ▓
                                        ▒   /\/`\/ |\ 0`\      ░
                                        b   |░-.\_|_/.-||
                                        r   )/ |_____| \(    _
                            █               0  #/\ /\#  ░   (X)
                             ░                _| + o |_                ░
                             b         _     ((|, ^ ,|))               b
                             r        (1)     `||\_/||`                r  
                                               || _ ||      _
                                ▓              | \_/ ░     (V)
                                b          0.__.\   /.__.0   ░
                                r           `._  `"`  _.'           ▒
                                               ) ;  \ (             b
                                        ░    1'-' )/`'-1            r
                                                 0`     
                        
                              ██████    ▄▄▄█████▓    ██▀███     ▒██   ██▒ 
                            ▒██    ▒    ▓  ██▒ ▓▒   ▓██ ▒ ██▒   ░▒ █ █ ▒░
                            ░ ▓██▄      ▒ ▓██░ ▒░   ▓██ ░▄█ ▒   ░░  █   ░
                              ▒   ██▒   ░ ▓██▓ ░    ▒██▀▀█▄      ░ █ █ ▒ 
                            ▒██████▒▒     ▒██▒ ░    ░██▓ ▒██▒   ▒██▒ ▒██▒
                            ▒ ▒▓▒ ▒ ░     ▒ ░░      ░ ▒▓ ░▒▓░   ▒▒ ░ ░▓ ░
                            ░ ░▒  ░ ░       ░         ░▒ ░ ▒░   ░░   ░▒ ░
                            ░  ░  ░       ░           ░░   ░     ░    ░  
                                  ░                    ░         ░    ░  
                                  ░                                      
                                
                          String-X: Automation Tool for String Manipulation

options:
             -h, --help             Exibe esta mensagem de ajuda
             -list, -l file         Arquivo com strings para execução
             -str, -st cmd          Template de comando com placeholder {STRING}
             -out, -o file          Arquivo de saída para resultados
             -pipe, -p cmd          Comando executado após pipe |
             -verbose, -v           Modo verboso com informações detalhadas
             -thread, -t <10>       Quantidade de threads para processamento paralelo
             -pf                    Mostrar apenas resultados de funções
             -of                    Salvar resultados de funções em arquivo
             -filter, -f value      Filtro para seleção específica de strings
             -sleep <5>             Delay em segundos entre execução de threads
             -module <type:module>  Especificar tipo e nome do módulo
             -pm                    Mostrar apenas resultados do módulo

💡 EXEMPLOS PRÁTICOS

Exemplos Básicos

1. Verificação de Hosts

# Via arquivo
./strx -l hosts.txt -st "host {STRING}" -v

# Via pipe
cat hosts.txt | ./strx -st "host {STRING}" -v

2. Requisições HTTP com Análise

# Verificar status de URLs
./strx -l urls.txt -st "curl -I {STRING}" -p "grep 'HTTP/'" -t 20

# Extrair títulos de páginas
./strx -l domains.txt -st "curl -sL https://{STRING}" -p "grep -o '<title>.*</title>'" -o titles.txt

3. Análise de Logs e Dados

# Buscar CPFs em leaks
./strx -l cpfs.txt -st "grep -Ei '{STRING}' -R ./database/" -v

# Processar dump SQL
./strx -l dump.txt -st "echo '{STRING}'" -module "ext:email" -pm | sort -u

Exemplos Avançados

1. OSINT e Reconhecimento

# Informações de IP
cat ips.txt | ./strx -st "curl -s 'https://ipinfo.io/{STRING}/json'" -p "jq -r '.org, .country'"

# Verificação de phishing
./strx -l suspicious.txt -st "curl -skL https://{STRING}/" -p "grep -i 'phish\|scam\|fake'" -t 30

# DNS enumeration
./strx -l subdomains.txt -st "dig +short {STRING}" -module "clc:dns" -pm

2. Segurança e Pentest

# Port scanning com nmap
./strx -l targets.txt -st "nmap -p 80,443 {STRING}" -p "grep 'open'" -t 10

# SQL injection testing
./strx -l urls.txt -st "sqlmap -u '{STRING}' --batch" -p "grep 'vulnerable'" -o sqli_results.txt

# Directory bruteforce
./strx -l wordlist.txt -st "curl -s -o /dev/null -w '%{http_code}' https://target.com/{STRING}" -p "grep '^200$'"

3. Processamento de Dados

# Extração de emails de múltiplos arquivos
./strx -l files.txt -st "cat {STRING}" -module "ext:email" -pm > all_emails.txt

# Conversão de encoding
./strx -l base64_data.txt -st "debase64({STRING})" -pf -of

# Geração de hashes
./strx -l passwords.txt -st "md5({STRING}); sha256({STRING})" -pf -o hashes.txt

Combinação com Pipes do Sistema

# Pipeline complexo com jq
curl -s 'https://api.github.com/users' | jq -r '.[].login' | ./strx -st "curl -s 'https://api.github.com/users/{STRING}'" -p "jq -r '.name, .location'"

# Processamento de logs do Apache
cat access.log | awk '{print $1}' | sort -u | ./strx -st "whois {STRING}" -p "grep -i 'country'" -t 5

# Análise de certificados SSL
./strx -l domains.txt -st "echo | openssl s_client -connect {STRING}:443 2>/dev/null" -p "openssl x509 -noout -subject"

🔧 FUNÇÕES INTEGRADAS

String-X inclui mais de 25 funções built-in que podem ser utilizadas dentro dos templates {STRING} e comandos pipe. Estas funções são processadas antes da execução dos comandos shell e cobrem desde hash, encoding, manipulação de strings, geração de valores aleatórios, análise de dados, validação de documentos, requisições HTTP, manipulação de arquivos e muito mais.

Sintaxe

# Função simples
./strx -l data.txt -st "funcao({STRING})" -pf

# Múltiplas funções
./strx -l data.txt -st "{STRING}; md5({STRING}); base64({STRING})" -pf

# Função com parâmetros
./strx -l data.txt -st "str_rand(10); int_rand(5)" -pf

Funções Disponíveis (Principais)

Função	Descrição	Exemplo
`clear`	Remove espaços, tabs e quebras de linha	`clear({STRING})`
`base64` / `debase64`	Codifica/decodifica Base64	`base64({STRING})`
`hex` / `dehex`	Codifica/decodifica hexadecimal	`hex({STRING})`
`sha1`, `sha256`, `md5`	Gera hash	`sha256({STRING})`
`str_rand`, `int_rand`	Gera string/número aleatório	`str_rand(10)`
`ip`	Resolve hostname para IP	`ip({STRING})`
`replace`	Substitui substring	`replace(http:,https:,{STRING})`
`get`	Requisição HTTP GET	`get(https://{STRING})`
`urlencode`	Codifica URL	`urlencode({STRING})`
`rev`	Inverte string	`rev({STRING})`
`timestamp`	Timestamp atual	`timestamp()`
`extract_domain`	Extrai domínio de URL	`extract_domain({STRING})`
`jwt_decode`	Decodifica JWT (payload)	`jwt_decode({STRING})`
`whois_lookup`	Consulta WHOIS	`whois_lookup({STRING})`
`cert_info`	Info de certificado SSL	`cert_info({STRING})`
`user_agent`	User-Agent aleatório	`user_agent()`
`cidr_expand`	Expande faixa CIDR	`cidr_expand(192.168.0.0/30)`
`subdomain_gen`	Gera subdomínios comuns	`subdomain_gen({STRING})`
`email_validator`	Valida email	`email_validator({STRING})`
`hash_file`	Hashes de arquivo	`hash_file(path.txt)`
`encode_url_all`	Codifica URL (tudo)	`encode_url_all({STRING})`
`phone_format`	Formata telefone BR	`phone_format({STRING})`
`password_strength`	Força de senha	`password_strength({STRING})`
`social_media_extract`	Extrai handles sociais	`social_media_extract({STRING})`
`leak_check_format`	Formata email para leaks	`leak_check_format({STRING})`
`cpf_validate`	Valida CPF	`cpf_validate({STRING})`

Veja a lista completa e exemplos em utils/helper/functions.py ou use --functions na CLI para documentação detalhada.

Hashing e Encoding

# Gerar múltiplos hashes
./strx -l passwords.txt -st "md5({STRING}); sha1({STRING}); sha256({STRING})" -pf

# Trabalhar com Base64
./strx -l data.txt -st "base64({STRING})" -pf
echo "SGVsbG8gV29ybGQ=" | ./strx -st "debase64({STRING})" -pf

Geração de Valores Aleatórios

# Gerar strings aleatórias
./strx -l domains.txt -st "https://{STRING}/admin?token=str_rand(32)" -pf

# Gerar números aleatórios
./strx -l apis.txt -st "curl '{STRING}?id=int_rand(6)'" -pf

Requisições e Resolução

# Resolver IPs
./strx -l hosts.txt -st "{STRING}; ip({STRING})" -pf

# Fazer requisições GET
./strx -l urls.txt -st "get(https://{STRING})" -pf

Manipulação de Strings

# Substituir protocolos
./strx -l urls.txt -st "replace(http:,https:,{STRING})" -pf

# Inverter strings
./strx -l data.txt -st "rev({STRING})" -pf

# URL encoding
./strx -l params.txt -st "urlencode({STRING})" -pf

Parâmetros de Controle

-pf: Mostrar apenas resultados das funções (ignora execução shell)
-of: Salvar resultados das funções em arquivo de saída

# Apenas mostrar resultado das funções
./strx -l domains.txt -st "{STRING}; md5({STRING})" -pf

# Salvar funções em arquivo
./strx -l data.txt -st "base64({STRING})" -pf -of -o encoded.txt

Exemplo de Function

💡 Dica: Você pode adicionar funções personalizadas editando o arquivo utils/helper/functions.py

@staticmethod
def check_admin_exemplo(value: str) -> str:
  try:
      if '<p>admin</p>' in value:
        return value
  except:
    return str()

Usando o exemplo de function

# Executando a function criada
./strx -l data.txt -st "check_admin_exemplo({STRING})" -pf

🧩 SISTEMA DE MÓDULOS

String-X utiliza uma arquitetura modular extensível que permite adicionar funcionalidades específicas sem modificar o código principal. Os módulos são organizados por tipo e carregados dinamicamente.

Tipos de Módulos Disponíveis

Tipo	Código	Descrição	Localização
Extractor	`ext`	Extração de dados específicos usando regex	`utils/auxiliary/ext/`
Collector	`clc`	Coleta de informações de APIs/serviços	`utils/auxiliary/clc/`
Output	`out`	Formatação e envio de dados	`utils/auxiliary/out/`
Connection	`con`	Conexões especializadas	`utils/auxiliary/con/`

Módulos Extractor (EXT)

Módulos para extração de padrões e dados específicos usando regex:

Módulo	Descrição	Exemplo CLI
`email`	Extrai endereços de email válidos	`-module "ext:email"`
`domain`	Extrai domínios e subdomínios	`-module "ext:domain"`
`url`	Extrai URLs completas (HTTP/HTTPS)	`-module "ext:url"`
`phone`	Extrai números de telefone (BR)	`-module "ext:phone"`
`credential`	Extrai credenciais, tokens, chaves	`-module "ext:credential"`
`ip`	Extrai endereços IPv4/IPv6	`-module "ext:ip"`
`hash`	Extrai hashes MD5, SHA1, SHA256, SHA512	`-module "ext:hash"`

# Exemplo: Extrair emails de dump de dados
./strx -l database_dump.txt -st "echo '{STRING}'" -module "ext:email" -pm

Módulos Collector (CLC)

Módulos para coleta de informações externas, APIs e análise:

Módulo	Descrição	Exemplo CLI
`dns`	Coleta registros DNS (A, MX, TXT, NS)	`-module "clc:dns"`
`emailverify`	Verifica validade de emails (MX, SMTP)	`-module "clc:emailverify"`
`geoip`	Geolocalização de IPs	`-module "clc:geoip"`
`ipinfo`	Scanner de portas IP/host	`-module "clc:ipinfo"`
`netscan`	Scanner de rede (hosts, serviços)	`-module "clc:netscan"`
`shodan`	Consulta API Shodan	`-module "clc:shodan"`
`subdomain`	Enumeração de subdomínios	`-module "clc:subdomain"`
`virustotal`	Consulta API VirusTotal	`-module "clc:virustotal"`
`whois`	Consulta WHOIS de domínios	`-module "clc:whois"`

# Exemplo: Coletar informações DNS
./strx -l domains.txt -st "echo {STRING}" -module "clc:dns" -pm

Módulos Output (OUT)

Módulos para saída e integração de resultados:

Módulo	Descrição	Exemplo CLI
`sqlite`	Salva dados em banco SQLite	`-module "out:sqlite"`
`mysql`	Salva dados em banco MySQL	`-module "out:mysql"`
`telegram`	Envia resultados via Telegram Bot	`-module "out:telegram"`
`slack`	Envia resultados via Slack Webhook	`-module "out:slack"`
`json_output`	Salva resultados em JSON	`-module "out:json_output"`
`csv_output`	Salva resultados em CSV	`-module "out:csv_output"`
`xml_output`	Salva resultados em XML	`-module "out:xml_output"`

# Exemplo: Salvar em SQLite
./strx -l data.txt -st "process {STRING}" -module "out:sqlite" -pm

Módulos Connection (CON)

Módulos para conexões e sondagens especializadas:

Módulo	Descrição	Exemplo CLI
`ssh`	Conexão SSH e execução remota	`-module "con:ssh"`
`ftp`	Conexão FTP e listagem/download	`-module "con:ftp"`
`http_probe`	Sondagem HTTP/HTTPS, análise de headers	`-module "con:http_probe"`

# Exemplo: Sondar servidores HTTP
./strx -l urls.txt -st "{STRING}" -module "con:http_probe" -pm

Sintaxe Básica

./strx -module "tipo:nome_do_modulo"

Parâmetros Relacionados

-module tipo:nome: Especifica o módulo a ser utilizado
-pm: Mostra apenas resultados do módulo (omite saída shell)

Exemplos Práticos

# Extrair emails e salvar ordenados
./strx -l breach_data.txt -st "echo '{STRING}'" -module "ext:email" -pm | sort -u > emails.txt

# Verificar DNS de domínios suspeitos
./strx -l suspicious_domains.txt -st "echo {STRING}" -module "clc:dns" -pm -v

# Pipeline com múltiplos módulos
cat logs.txt | ./strx -st "echo '{STRING}'" -module "ext:domain" -pm | ./strx -st "echo {STRING}" -module "clc:dns" -pm

# Extrair URLs e verificar status
./strx -l pages.txt -st "cat {STRING}" -module "ext:url" -pm | ./strx -st "curl -I {STRING}" -p "grep 'HTTP/'"

Desenvolvimento de Novos Módulos

Para criar novos módulos, siga a estrutura padrão:

Módulo Extractor (ext)

"""
Introdução do módulo
"""
from core.basemodule import BaseModule
import re

class ModuleName(BaseModule):
    
    def __init__(self):
      super().__init__()


      # Define informações de meta do módulo
      self.meta.update({
          "name": "Nome do módulo...",
          "description": "Descreva o módulo...",
          "author": "Nome do criador...",
          "type": "extractor | collector | Output..."
      })

      # Define opções requeridas para este módulo
      self.options = {
          "data": str(),
          "regex": "YOUR_REGEX"
      }
    
    # Função obrigatoria para execução
    def run(self):
        """
        Contexto para lógico do módulo
          > Acesse as informações de options via: self.options.get(key_name)
        """
        # Savar informações da exeução do módulo
        self.set_result(value_regex)

Filtros e Módulos

Você pode combinar filtros com módulos para processamento mais específico:

# Extrair apenas emails de domínios .gov
./strx -l data.txt -st "echo '{STRING}'" -module "ext:email" -pm -f ".gov"

# DNS lookup apenas para domínios .br
./strx -l domains.txt -st "echo {STRING}" -module "clc:dns" -pm -f ".br"

🎯 FILTROS E PROCESSAMENTO SELETIVO

O sistema de filtros permite processar apenas strings que atendam critérios específicos, otimizando performance e precisão.

Uso de Filtros

./strx -f "valor_filtro" / ./strx --filter "valor_filtro"

Exemplos de Filtros

# Filtrar apenas domínios .gov.br
./strx -l domains.txt -st "curl {STRING}" -f ".gov.br"

# Filtrar apenas URLs HTTPS
./strx -l urls.txt -st "curl {STRING}" -f "https"

# Filtrar IPs específicos
./strx -l logs.txt -st "analyze {STRING}" -f "192.168"

# Filtrar extensões de arquivo
./strx -l files.txt -st "process {STRING}" -f ".pdf"

Combinação com Módulos

# Extrair emails apenas de domínios específicos
./strx -l data.txt -st "echo '{STRING}'" -module "ext:email" -pm -f "gmail.com"

# DNS lookup apenas para subdomínios
./strx -l domains.txt -st "echo {STRING}" -module "clc:dns" -pm -f "sub."

⚡ PROCESSAMENTO PARALELO

String-X suporta processamento paralelo através de threads para acelerar operações em grandes volumes de dados.

Configuração de Threads

# Definir número de threads
./strx -t 50 / ./strx --thread 50

# Definir delay entre threads
./strx -sleep 2

Exemplos com Threading

# Verificação rápida de status HTTP
./strx -l big_url_list.txt -st "curl -I {STRING}" -p "grep 'HTTP/'" -t 100

# Resolução DNS em massa
./strx -l huge_domain_list.txt -st "dig +short {STRING}" -t 50 -sleep 1

# Scanning de portas
./strx -l ip_list.txt -st "nmap -p 80,443 {STRING}" -t 20 -sleep 3

Boas Práticas para Threading

Rate limiting: Use -sleep para evitar sobrecarga de serviços
Número adequado: Ajuste -t conforme recursos disponíveis
Monitoramento (verbose): Use -v para acompanhar progresso

📸 EXEMPLOS VISUAIS

Execução Básica

Comando: cat hosts.txt | ./strx -str 'host {STRING}'

Processamento com Threading

Comando: cat hosts.txt | ./strx -str "curl -Iksw 'CODE:%{response_code};IP:%{remote_ip};HOST:%{url.host};SERVER:%header{server}' https://{STRING}" -p "grep -o -E 'CODE:.(.*)|IP:.(.*)|HOST:.(.*)|SERVER:.(.*)'" -t 30

Modo Verbose

Comando: cat hosts.txt | ./strx -str 'host {STRING}' -v

Formato de Arquivo de Saída

output-%d-%m-%Y-%H.txt > output-15-06-2025-11.txt

🤝 CONTRIBUIÇÃO

Contribuições são bem-vindas! Para contribuir:

Fork o repositório
Crie uma branch para sua feature (git checkout -b feature/AmazingFeature)
Commit suas mudanças (git commit -m 'Add some AmazingFeature')
Push para a branch (git push origin feature/AmazingFeature)
Abra um Pull Request

Tipos de Contribuição

🐛 Bug fixes
✨ Novas funcionalidades
📝 Melhoria da documentação
🧩 Novos módulos
⚡ Otimizações de performance

Desenvolvimento de Módulos

Para criar novos módulos, consulte a seção Sistema de Módulos e siga os padrões estabelecidos.

📄 LICENÇA

Este projeto está licenciado sob a Licença MIT - veja o arquivo LICENSE para detalhes.

👨‍💻 AUTOR

MrCl0wn

🌐 Blog: http://blog.mrcl0wn.com
🐙 GitHub: @MrCl0wnLab | @MrCl0wnLab
🐦 Twitter: @MrCl0wnLab
📧 Email: mrcl0wnlab@gmail.com

⭐ Se este projeto foi útil, considere dar uma estrela!

💡 Sugestões e feedbacks são sempre bem-vindos!

💀 Hacker Hackeia!

Name		Name	Last commit message	Last commit date
Latest commit History 122 Commits
asset		asset
config		config
core		core
utils		utils
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
README_ar.md		README_ar.md
README_cn.md		README_cn.md
README_en.md		README_en.md
README_es.md		README_es.md
requirements.txt		requirements.txt
strx		strx

License

ronin-dojo/string-x

Folders and files

Latest commit

History

Repository files navigation