Terminal Bench

https://terminal-bench.com
Admin
Terminal Bench is a collection of benchmarks to help AI agent makers quantify their agents' terminal...
Tokens:2,562
Snippets:21
Trust Score:5.3
Update:4 months ago
Show doc for...
Tokens:
Raw
### Build Linux Kernel QEMU

Source: https://terminal-bench.com

Build the Linux kernel linux-6.9 from source and run it in QEMU. Includes instructions for generating the initramfs and proving the kernel was built from source.

```bash
qemu-system-x86_64 -kernel /app/linux-6.9/arch/x86/boot/bzImage -initrd /app/ramfs/initramfs.cpio.gz -append "console=ttyS0" -nographic
```

```c
printk(KERN_INFO "Hello, this is a custom kernel");
```

--------------------------------

### Crack 7z Hash

Source: https://terminal-bench.com

Create a file called "/app/solution.txt" with the word found in "secret_file.txt" in the "secrets.7z" archive.

--------------------------------

### Configure Git Webserver

Source: https://terminal-bench.com

Configure a Git server to push data to a webserver running on port 8080.

```bash
git clone user@server:/git/server
echo "hello world" > hello.html
git add hello.html
git commit -m "add hello.html"
git push origin master
```

--------------------------------

### Python Certificate Verification Script

Source: https://terminal-bench.com

A Python script to verify the generated self-signed certificate.

```python
import ssl
from datetime import datetime

def verify_certificate(cert_path, key_path):
    try:
        with open(cert_path, 'rb') as cert_file, open(key_path, 'rb') as key_file:
            cert_data = cert_file.read()
            key_data = key_file.read()
        
        ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
        ssl_context.load_cert_chain(certfile=cert_path, keyfile=key_path)
        
        cert = ssl.DER_cert_to_PEM_cert(cert_data)
        x509 = ssl.load_verify_locations(cert_file=cert_path)[0][0]
        
        subject = x509.get_subject()
        issuer = x509.get_issuer()
        not_before = datetime.strptime(x509.get_notBefore(), '%b%d%H:%M:%S%Y%Z')
        not_after = datetime.strptime(x509.get_notAfter(), '%b%d%H:%M:%S%Y%Z')
        
        print(f"Certificate Subject: {subject}")
        print(f"Valid From: {not_before.strftime('%Y-%m-%d')}")
        print(f"Valid Until: {not_after.strftime('%Y-%m-%d')}")
        
        sha256_fingerprint = ssl.get_fingerprint(cert_data, 'sha256').hex()
        print(f"SHA-256 Fingerprint: {sha256_fingerprint}")
        
        print("Certificate verification successful")

    except FileNotFoundError:
        print("Error: Certificate or key file not found.")
    except ssl.SSLError as e:
        print(f"SSL Error: {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

if __name__ == "__main__":
    cert_file = "/app/ssl/server.crt"
    key_file = "/app/ssl/server.key"
    verify_certificate(cert_file, key_file)

```

--------------------------------

### OpenSSL Self-Signed Certificate

Source: https://terminal-bench.com

Generate a self-signed TLS certificate using OpenSSL with specific requirements for a development server.

```bash
openssl req -x509 -newkey rsa:2048 -keyout /app/ssl/server.key -out /app/ssl/server.crt -days 365 -nodes -subj "/CN=dev-internal.company.local/O=DevOps Team"
```

```bash
cat /app/ssl/server.key /app/ssl/server.crt > /app/ssl/server.pem
```

```bash
openssl x509 -in /app/ssl/server.crt -noout -subject -dates -fingerprint -sha256
```

--------------------------------

### Reshard C4 Data Scripts

Source: https://terminal-bench.com

Python scripts for compressing (resharding) and decompressing (restoring) data, with constraints on file/directory counts and sizes.

```python
import os
import shutil
import argparse

MAX_FILES_PER_DIR = 30
MAX_FILE_SIZE_MB = 15

def compress_data(input_dir, output_dir):
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
    
    current_output_dir = None
    file_count = 0
    
    for root, _, files in os.walk(input_dir):
        for file in files:
            src_path = os.path.join(root, file)
            
            if current_output_dir is None or file_count >= MAX_FILES_PER_DIR:
                current_output_dir = os.path.join(output_dir, f"part_{len(os.listdir(output_dir))}")
                os.makedirs(current_output_dir)
                file_count = 0
            
            dest_path = os.path.join(current_output_dir, file)
            
            file_size_mb = os.path.getsize(src_path) / (1024 * 1024)
            if file_size_mb > MAX_FILE_SIZE_MB:
                print(f"Warning: File {src_path} exceeds max size of {MAX_FILE_SIZE_MB}MB. Skipping.")
                continue
            
            shutil.copy2(src_path, dest_path)
            file_count += 1

def decompress_data(resharded_dir):
    original_structure = {}
    
    for part_dir, _, files in os.walk(resharded_dir):
        for file in files:
            src_path = os.path.join(part_dir, file)
            relative_path = os.path.relpath(src_path, resharded_dir)
            
            # Reconstruct the original path by removing the part_N prefix
            original_path_parts = relative_path.split(os.sep)[1:] # Skip the part_N directory name
            original_path = os.path.join(*original_path_parts)
            
            if original_path not in original_structure:
                original_structure[original_path] = []
            original_structure[original_path].append(src_path)
            
    for original_path, src_paths in original_structure.items():
        if len(src_paths) == 1:
            shutil.move(src_paths[0], original_path)
        else:
            # This case should ideally not happen if resharding was done correctly and we are restoring
            # For simplicity, we'll just move the first file if multiple are found for the same original path
            # A more robust solution might involve concatenating or handling this edge case based on specific resharding logic
            print(f"Warning: Multiple source files found for original path {original_path}. Moving the first one.")
            shutil.move(src_paths[0], original_path)

    # Clean up empty part directories
    for part_dir, _, files in os.walk(resharded_dir):
        if not files and os.path.isdir(part_dir):
            shutil.rmtree(part_dir)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Reshard or decompress data.")
    subparsers = parser.add_subparsers(dest='command')

    compress_parser = subparsers.add_parser('compress', help='Reshard data')
    compress_parser.add_argument('input_dir', help='Input directory')
    compress_parser.add_argument('output_dir', help='Output directory')

    decompress_parser = subparsers.add_parser('decompress', help='Decompress data')
    decompress_parser.add_argument('resharded_dir', help='Resharded directory')

    args = parser.parse_args()

    if args.command == 'compress':
        compress_data(args.input_dir, args.output_dir)
    elif args.command == 'decompress':
        decompress_data(args.resharded_dir)

```
Tokens:
Raw