semvec/pypi-packages huggingface dataset:
pyhulul 1.0.1
Cool package.

ï»¿# sss
>An API Management tool written in Python.

[![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-license.org/)
![PyPI](https://img.shields.io/badge/pypi-v1.0.0-blue)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/requests.svg)
![PyPI - Wheel](https://img.shields.io/pypi/wheel/pywol.svg)
![CircleCI branch](https://img.shields.io/circleci/project/github/erberlin/pywol/master.svg)

pystob allows for API Authorization Management and allows to build REST-Based API with custom JSON syntax.
pystob can be used as a plugin for many API Repository such as [FRPC](https://github.com/seznam/fastrpc) and many others.

## Installation

```console
$ pip install pystob
```

## Usage examples
As an API Management Tool :
```console
$ pywool -u api.redacted.com -t "FRPC_BASED" -l -vv
Retrieve list from [api.redacted.com] | AUTHORIZATION: None | BASED: FRPC_TECH
$
$ pywool -u api.redacted.com -t "REST_BASED" -d "JSON" -auth <AUTH_EXAMPLE> -l -vv
Retrieve list from [api.redacted.com] | AUTHORIZATION: <AUTH_EXAMPLE> | BASED: REST_API
$
$ pywool --help
Usage: pywool -u API_URL [OPTIONS]

  API Management for the Pywool package.

  Please don't type any hypertext protocol such as "https://" or "http://" because they can 
  corrupt the results. The standard URL_TYPE is <SUBDOMAIN>.<BASE>.<DOMAIN>:<PORT>

Options:
  -u, --url URL  Please respect the standards described above
  -p, --port PORT      Target port.
  -vv, --verbose
  -t, --technology OPTIONS
  -l, --list
  -b, --build URL Please check documentation to build your own API with Pywool Tool
  -d, --data OPTIONS
  --help                   Show this message and exit.
```
## Why create API Builder and Manager ?
I needed one and this was an opportunity to learn some stuff.

## Meta

 Kevin Jonsson- jonsson.dev@gmail.com

Distributed under the MIT license. See ``LICENSE`` for more information.
python-fortress 1.1.0
A Python module to securely interact with passfortress.com API for retrieving and loading environment variables from a remote .env file.

# Python Fortress

Python Fortress is a library designed to facilitate interaction with an API to retrieve an .env file and load its values into your environment variables. It's designed for securely and efficiently loading environment variables from a remote source.

[![codecov](https://codecov.io/gh/magestree/python_fortress/branch/develop/graph/badge.svg)](https://codecov.io/gh/magestree/python_fortress)

## Features

- Easy loading and configuration.
- Secure retrieval of the `.env` file content from [passfortress.com](https://www.passfortress.com) API.
- Simple and efficient usage with intuitive methods.

## Installation

To install the project dependencies, run:

```bash
pip install -r requirements.txt
```

## Basic usage

The main module `fortress.py` provides the `Fortress` class and a convenience function `configure()` and `load_env()`.
You just need configure your `Fortress` instance and then, call the `load_env()` method with desired envfile `id`.

## Example:

```python
from python_fortress.fortress import Fortress

credentials = {
    "api_key": "<YOUR_API_KEY>",
    "access_token": "<YOUR_ACCESS_TOKEN>",
    "master_key": "<YOUR_MASTER_KEY>"
}

fortress = Fortress()
fortress.configure(**credentials)
fortress.load_env(envfile_id="<YOUR_ENVFILE_ID>")
```

## Tests
The project comes with a set of tests to ensure everything works as expected. You can run the tests using pytest:

```bash
pip install -r requirements_dev.txt
pytest
```

To obtain a coverage report:
```bash
coverage run -m pytest
coverage report
```

## CI/CD
Thanks to GitHub Actions, each push or pull request will trigger the CI pipeline which will run tests and calculate code coverage.


## Contribution
If you're interested in contributing to the project, please follow these steps:

1. Fork repository.
2. Create a new branch for your feature or fix.
3. Implement your change or fix.
4. Run the tests to make sure everything is working as expected.
5. Open a pull request.


## Licencia
MIT
bl-bfg 1.0.4
A password guessing framework.
Requires Python: >=3.9.2

# Big Friggin Gun (BFG)

BFG is a simple modular framework to perform brute-force attacks. It uses
the [BruteLoops](https://github.com/arch4ngel/BruteLoops) library for the
brute force and database management logic.

![command-example](docs/resources/command-output.png)

# Features

- *SQLite Datastore*
  - Authentication data/requests are maintained in an SQLite database.
  - Query capabilities enable granular timing configurations.
  - Facilitates safe, resumable attacks.
  - **Database management tools are embedded in BFG via BruteLoops**
    - Run `bfg cli manage-db --help`.
- *BruteLoops Capabilities*
  - Resumable attacks that _do not repeat previous guesses_.
  - Simultaneous support for password spraying and credential stuffing.
  - Parallel guessing.
  - Lockout avoidance via two layers of jitter configurations.
  - User/password prioritization.
  - Universal protocol/application capabilities.
  - Granular logging:
    - Lockouts happen. It's part of life.
    - BruteLoops provides a log record for each guess, along with timestamp.
    - Allows operators to reconstruct a timeline of events if things go bad.
- *Modular Framework*
  - Simple class-based modules provide reusable arguments/components.
- *YAML Attack/Database Profiles*
  - YAML files can be used to supply configuration values to BFG.
  - Avoids complex command line flags.

# Docker Support

A compose file is available for this project. See [this document](docs/docker.md) for more information.

# Supported Platforms

Only Linux is supported at the moment, however a Docker implementation will
soon follow.

# Quick Install

```bash
pip3 install bl-bfg
```

Then confirm installation:

```bash
bfg --help
```

# Documentation

See the docs directory for additional documentation:

- [Installation](docs/Installation.md)
- [Example Attack](<docs/Example Attack.md>)
- [YAML Attack Profiles](<docs/YAML Attack Profiles.md>)
- [Docker](<docs/Docker Container.md>)
- [FAQs](<docs/faqs.md>)

# Current Attack Modules

Below are the attack modules currently in BFG.

Most people will be interested in `http.o365_graph` as it can be used to attack
`login.microsoftonline.com`.

```
http.accellion_ftp  Accellion FTP HTTP interface login module
http.adfs           Active Directory Federated Services
http.basic_digest   Generic HTTP basic digest auth
http.basic_ntlm     Generic HTTP basic NTLM authentication
http.global_protect Global Protect web interface
http.lync           Brute force Microsoft Lync.
http.mattermost     Mattermost login web interface
http.netwrix        Netwrix web login
http.o365_graph     Office365 Graph API
http.okta           Okta JSON API
http.owa2010        OWA 2010 web interface
http.owa2016        OWA 2016 web interface
http.sap_webdynpro  SAP Netweaver Webdynpro, ver. 7.3007.20120613105137.0000
smb.smb             Target a single SMB server
testing.fake        Fake authentication module for training/testing
```