Metadata-Version: 2.4
Name: zikzakzik
Version: 1.0.0
Summary: Ultra stealth HTTP library - Make your Python code invisible
Home-page: https://github.com/DAXXTEAM/zikzakzik
Author: DAXX
Author-email: 
Project-URL: Bug Reports, https://github.com/DAXXTEAM/zikzakzik/issues
Project-URL: Source, https://github.com/DAXXTEAM/zikzakzik
Keywords: stealth http requests privacy security obfuscation evasion anti-detection
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Topic :: Internet :: WWW/HTTP
Classifier: Topic :: Security
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Operating System :: OS Independent
Requires-Python: >=3.7
Description-Content-Type: text/markdown
License-File: LICENSE
Provides-Extra: dev
Requires-Dist: pytest; extra == "dev"
Requires-Dist: black; extra == "dev"
Requires-Dist: flake8; extra == "dev"
Dynamic: author
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: keywords
Dynamic: license-file
Dynamic: project-url
Dynamic: provides-extra
Dynamic: requires-python
Dynamic: summary

# 🔒 ZIKZAKZIK

**Ultra Stealth HTTP Library for Python**

Make your code invisible. Zero dependencies. Maximum stealth.

---

## 🚀 Features

### ✅ **Core Capabilities**
- **Zero External Dependencies** - Pure Python, no `requests`, no `urllib3`
- **Drop-in Replacement** - Same API as `requests` library
- **Raw Socket Control** - Direct TCP/IP implementation
- **SSL/TLS Support** - Full HTTPS with fingerprint randomization

### 🕵️ **Stealth Features**
- **Request Flooding** - Hide 1 real request in 100,000 decoys
- **Traffic Obfuscation** - Polymorphic patterns, timing randomization
- **Browser Fingerprint Spoofing** - Realistic user agents & headers
- **TLS Fingerprint Randomization** - Evade SSL/TLS detection
- **Anti-Pattern Detection** - Break predictable behavior

### 🔐 **Security**
- **Response Encryption** - Optional encrypted responses
- **Memory-Safe Operations** - No disk traces
- **HMAC Authentication** - Verify data integrity
- **Steganography Support** - Hide data in noise

### ⚡ **Performance**
- **Async Support** - Multi-threaded decoy generation
- **Configurable Profiles** - Fast, Balanced, Paranoid, Stealth
- **Smart Caching** - Optimized for repeated requests

---

## 📦 Installation

```bash
pip install zikzakzik
```

**That's it!** Zero dependencies to install.

---

## 🎯 Quick Start

### Basic Usage (Like `requests`)

```python
import zikzakzik as zik

# Simple GET request
response = zik.get('https://api.example.com/data')
print(response.text)
print(response.status_code)

# POST with JSON
data = {'key': 'value'}
response = zik.post('https://api.example.com/users', json=data)
print(response.json())

# Custom headers
headers = {'Authorization': 'Bearer token123'}
response = zik.get('https://api.example.com/secure', headers=headers)
```

### Advanced - Session with Profile

```python
from zikzakzik import StealthSession

# Create session with stealth profile
session = StealthSession(profile='paranoid')

# This request is now hidden in 10,000 decoys!
response = session.get('https://api.example.com/data')
```

### Migration from `requests`

```python
# BEFORE
import requests
response = requests.get(url)

# AFTER (just change import!)
import zikzakzik as requests
response = requests.get(url)  # Now invisible!
```

---

## ⚙️ Configuration Profiles

### **Fast** (Minimal stealth, maximum speed)
```python
session = StealthSession(profile='fast')
# 100 decoy requests, minimal delays
```

### **Balanced** (Default - Good stealth, good speed)
```python
session = StealthSession(profile='balanced')
# 1,000 decoy requests, moderate delays
```

### **Paranoid** (Maximum stealth)
```python
session = StealthSession(profile='paranoid')
# 10,000 decoy requests, encrypted responses
```

### **Stealth** (EXTREME stealth)
```python
session = StealthSession(profile='stealth')
# 50,000 decoy requests, maximum obfuscation
```

### **Custom Configuration**
```python
import zikzakzik as zik

zik.configure(
    decoy_count=5000,
    timing_randomization=True,
    encrypt_response=True
)
```

---

## 🎓 Use Cases

### ✅ **Legitimate Uses**

1. **Web Scraping** - Bypass anti-bot systems
2. **Security Research** - Penetration testing (authorized)
3. **Privacy Protection** - Personal data privacy
4. **API Testing** - Load testing without detection
5. **Competitive Intelligence** - Market research
6. **Academic Research** - Security studies
7. **Censorship Bypass** - Access restricted content

### ❌ **DO NOT USE FOR**

- Illegal hacking
- DDoS attacks
- Unauthorized access
- Malicious activities
- Violating ToS/laws

---

## 📊 How It Works

### Request Flow
```
Your Code
    ↓
[ZIKZAKZIK]
    ↓
Real Request (1) + Decoy Requests (10,000)
    ↓
Randomized Headers, TLS Fingerprints, Timing
    ↓
Target Server (Can't tell which is real!)
    ↓
Response Extraction & Optional Encryption
    ↓
Your Code (Clean response)
```

### Detection Evasion Techniques

1. **Traffic Flooding** - Drown real request in noise
2. **Header Randomization** - Different headers each time
3. **TLS Fingerprint Variation** - Evade SSL/TLS detection
4. **Timing Jitter** - Break timing patterns
5. **Multi-Target Decoys** - Requests to different domains
6. **Realistic Payloads** - AI-like decoy data

---

## 🔬 Technical Details

### Zero Dependencies
```python
# Only uses Python standard library:
import socket      # Raw networking
import ssl         # TLS/SSL
import threading   # Concurrency
import hashlib     # Cryptography
import hmac        # Authentication
import random      # Randomization
import time        # Timing
import json        # Data handling
import base64      # Encoding
```

### Pure Python HTTP Implementation
- Raw TCP sockets
- Manual HTTP request building
- Chunked transfer encoding support
- Connection pooling
- SSL/TLS handshake

---

## 🛡️ Security Notice

**This tool is powerful. Use responsibly.**

```python
# ✅ GOOD - Authorized testing
session = StealthSession()
response = session.get('https://my-own-api.com/test')

# ❌ BAD - Unauthorized access
# DON'T DO THIS
```

**Legal Disclaimer:**
- Only use on systems you own or have permission to test
- Respect website ToS and robots.txt
- Follow local laws and regulations
- Author is not responsible for misuse

---

## 📈 Performance Benchmarks

| Profile | Decoys | Speed | Stealth | Use Case |
|---------|--------|-------|---------|----------|
| Fast | 100 | ⚡⚡⚡⚡⚡ | 🔒🔒 | Quick scraping |
| Balanced | 1,000 | ⚡⚡⚡⚡ | 🔒🔒🔒🔒 | General use |
| Paranoid | 10,000 | ⚡⚡⚡ | 🔒🔒🔒🔒🔒 | High security |
| Stealth | 50,000 | ⚡⚡ | 🔒🔒🔒🔒🔒🔒 | Maximum stealth |

---

## 🤝 Contributing

Contributions welcome! Please:
1. Fork the repository
2. Create feature branch
3. Add tests
4. Submit pull request

---

## 📄 License

MIT License - See LICENSE file

---

## 🎯 Why ZIKZAKZIK?

- **ZIK** - Zigzag pattern (evasion)
- **ZAK** - Attack/Action (stealth operations)
- **ZIK** - Zigzag back (return safely)

The name represents the zigzag evasion pattern used to hide your real traffic!

---

## 🔥 Examples

### Example 1: Simple Scraping
```python
import zikzakzik as zik

# Scrape without getting banned
for page in range(1, 100):
    url = f'https://example.com/products?page={page}'
    response = zik.get(url)
    # Process data...
```

### Example 2: API with Authentication
```python
from zikzakzik import StealthSession

session = StealthSession(profile='balanced')

# Login
login_data = {'username': 'user', 'password': 'pass'}
response = session.post('https://api.example.com/login', json=login_data)
token = response.json()['token']

# Authenticated requests
headers = {'Authorization': f'Bearer {token}'}
response = session.get('https://api.example.com/data', headers=headers)
```

### Example 3: Maximum Stealth
```python
from zikzakzik import StealthSession

# Create ultra-stealth session
session = StealthSession(profile='stealth')

# 50,000 decoy requests will be generated
# Response will be encrypted
response = session.get('https://sensitive-api.com/data')

# Response is automatically decrypted
print(response.json())
```

---

## 📚 API Reference

### Module Functions
- `get(url, **kwargs)` - HTTP GET
- `post(url, **kwargs)` - HTTP POST
- `put(url, **kwargs)` - HTTP PUT
- `delete(url, **kwargs)` - HTTP DELETE
- `patch(url, **kwargs)` - HTTP PATCH
- `head(url, **kwargs)` - HTTP HEAD
- `options(url, **kwargs)` - HTTP OPTIONS
- `request(method, url, **kwargs)` - Generic request

### Classes
- `StealthSession(profile='balanced')` - Session with stealth features
- `StealthResponse` - Response object

### Configuration
- `set_profile(name)` - Set global profile
- `get_profile()` - Get current profile
- `configure(**kwargs)` - Custom settings

---

## 💬 Support

- **Issues**: https://github.com/DAXXTEAM/zikzakzik/issues
- **Discussions**: https://github.com/DAXXTEAM/zikzakzik/discussions

---

## 🌟 Star History

If you find this useful, please ⭐ star the repo!

---

**Made with 🔥 by DAXX**

**Remember: With great power comes great responsibility!** 🕷️
