023_密码学基础实战：十六进制与ASCII转换全解析与应用指南

hex_str = "48656C6C6F20576F726C64"
ascii_str = bytes.fromhex(hex_str).decode('ascii')
print(ascii_str)  # 输出: Hello World

import binascii

hex_str = "48656C6C6F20576F726C64"
ascii_str = binascii.unhexlify(hex_str).decode('ascii')
print(ascii_str)  # 输出: Hello World

def hex_to_ascii(hex_str):
    result = []
    # 确保字符串长度为偶数
    if len(hex_str) % 2 != 0:
        hex_str = '0' + hex_str
    # 每两个字符转换一次
    for i in range(0, len(hex_str), 2):
        # 提取两个字符并转换为十进制
        byte_value = int(hex_str[i:i+2], 16)
        # 添加对应的ASCII字符
        result.append(chr(byte_value))
    return ''.join(result)

hex_str = "48656C6C6F20576F726C64"
ascii_str = hex_to_ascii(hex_str)
print(ascii_str)  # 输出: Hello World

function hexToAscii(hex) {
    let str = '';
    for (let i = 0; i < hex.length; i += 2) {
        str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
    }
    return str;
}

const hexStr = "48656C6C6F20576F726C64";
const asciiStr = hexToAscii(hexStr);
console.log(asciiStr);  // 输出: Hello World

function hexToAscii(hex) {
    return hex.match(/.{2}/g).map(byte => String.fromCharCode(parseInt(byte, 16))).join('');
}

const hexStr = "48656C6C6F20576F726C64";
const asciiStr = hexToAscii(hexStr);
console.log(asciiStr);  // 输出: Hello World

public class HexToAscii {
    public static String hexToAscii(String hex) {
        StringBuilder result = new StringBuilder();
        // 确保字符串长度为偶数
        if (hex.length() % 2 != 0) {
            hex = "0" + hex;
        }
        // 每两个字符转换一次
        for (int i = 0; i < hex.length(); i += 2) {
            String str = hex.substring(i, i + 2);
            result.append((char) Integer.parseInt(str, 16));
        }
        return result.toString();
    }
    
    public static void main(String[] args) {
        String hexStr = "48656C6C6F20576F726C64";
        String asciiStr = hexToAscii(hexStr);
        System.out.println(asciiStr);  // 输出: Hello World
    }
}

function hex_to_ascii($hex) {
    $ascii = '';
    // 每两个字符转换一次
    for ($i = 0; $i < strlen($hex); $i += 2) {
        $ascii .= chr(hexdec(substr($hex, $i, 2)));
    }
    return $ascii;
}

$hexStr = "48656C6C6F20576F726C64";
$asciiStr = hex_to_ascii($hexStr);
echo $asciiStr;  // 输出: Hello World

// 使用PHP内置函数
$asciiStr2 = pack("H*", $hexStr);
echo $asciiStr2;  // 输出: Hello World

# 将十六进制转换为ASCII并输出
echo "48656C6C6F20576F726C64" | xxd -r -p
# 输出: Hello World

# 将十六进制写入文件并读取
echo "48656C6C6F20576F726C64" > hex.txt
xxd -r -p hex.txt > ascii.txt
cat ascii.txt  # 输出: Hello World

# 使用printf命令
printf "\\x48\\x65\\x6C\\x6C\\x6F\\x20\\x57\\x6F\\x72\\x6C\\x64\n"
# 输出: Hello World

# PowerShell命令
$hexStr = "48656C6C6F20576F726C64"
$asciiStr = [System.Text.Encoding]::ASCII.GetString([System.Convert]::FromHexString($hexStr))
Write-Host $asciiStr  # 输出: Hello World

:: 创建包含十六进制的文件
echo 48656C6C6F20576F726C64 > hex.txt

:: 使用certutil解码（需要特定格式）
:: 首先创建正确格式的文件
echo -----BEGIN CERTIFICATE----- > temp.txt
echo 48656C6C6F20576F726C64 >> temp.txt
echo -----END CERTIFICATE----- >> temp.txt

:: 解码
certutil -decode temp.txt ascii.txt
type ascii.txt  # 输出: Hello World

:: 清理临时文件
del temp.txt hex.txt

ascii_str = "Hello World"
hex_str = ascii_str.encode('ascii').hex()
print(hex_str)  # 输出: 48656c6c6f20576f726c64

import binascii

ascii_str = "Hello World"
hex_str = binascii.hexlify(ascii_str.encode('ascii')).decode('ascii')
print(hex_str)  # 输出: 48656c6c6f20576f726c64

def ascii_to_hex(ascii_str):
    result = []
    for char in ascii_str:
        # 获取字符的ASCII值并转换为十六进制
        hex_value = hex(ord(char))[2:]  # [2:] 移除'0x'前缀
        # 确保每个字节使用两个十六进制字符表示
        if len(hex_value) == 1:
            hex_value = '0' + hex_value
        result.append(hex_value)
    return ''.join(result)

ascii_str = "Hello World"
hex_str = ascii_to_hex(ascii_str)
print(hex_str)  # 输出: 48656c6c6f20576f726c64

function asciiToHex(str) {
    let hex = '';
    for (let i = 0; i < str.length; i++) {
        const hexCode = str.charCodeAt(i).toString(16);
        // 确保每个字节使用两个十六进制字符表示
        hex += hexCode.length === 1 ? '0' + hexCode : hexCode;
    }
    return hex;
}

const asciiStr = "Hello World";
const hexStr = asciiToHex(asciiStr);
console.log(hexStr);  // 输出: 48656c6c6f20576f726c64

function asciiToHex(str) {
    return str.split('').map(char => {
        const hex = char.charCodeAt(0).toString(16);
        return hex.length === 1 ? '0' + hex : hex;
    }).join('');
}

const asciiStr = "Hello World";
const hexStr = asciiToHex(asciiStr);
console.log(hexStr);  // 输出: 48656c6c6f20576f726c64

public class AsciiToHex {
    public static String asciiToHex(String ascii) {
        StringBuilder hex = new StringBuilder();
        for (int i = 0; i < ascii.length(); i++) {
            // 获取字符的ASCII值
            int asciiValue = (int) ascii.charAt(i);
            // 转换为十六进制并确保两个字符
            String hexValue = Integer.toHexString(asciiValue);
            if (hexValue.length() == 1) {
                hex.append('0');
            }
            hex.append(hexValue);
        }
        return hex.toString();
    }
    
    public static void main(String[] args) {
        String asciiStr = "Hello World";
        String hexStr = asciiToHex(asciiStr);
        System.out.println(hexStr);  // 输出: 48656c6c6f20576f726c64
    }
}

function ascii_to_hex($ascii) {
    $hex = '';
    for ($i = 0; $i < strlen($ascii); $i++) {
        $hex .= dechex(ord($ascii[$i]));
    }
    return $hex;
}

$asciiStr = "Hello World";
$hexStr = ascii_to_hex($asciiStr);
echo $hexStr;  // 输出: 48656c6c6f20576f726c64

// 使用PHP内置函数
$hexStr2 = bin2hex($asciiStr);
echo $hexStr2;  // 输出: 48656c6c6f20576f726c64

# 将ASCII转换为十六进制并输出
echo -n "Hello World" | xxd -p
# 输出: 48656c6c6f20576f726c64

# 将ASCII写入文件并转换
echo -n "Hello World" > ascii.txt
xxd -p ascii.txt > hex.txt
cat hex.txt  # 输出: 48656c6c6f20576f726c64

# 使用hexdump命令
echo -n "Hello World" | hexdump -v -e '/1 "%02x"'
echo  # 换行
# 输出: 48656c6c6f20576f726c64

# PowerShell命令
$asciiStr = "Hello World"
$hexStr = [System.BitConverter]::ToString([System.Text.Encoding]::ASCII.GetBytes($asciiStr)) -replace "-", ""
Write-Host $hexStr  # 输出: 48656C6C6F20576F726C64

:: 创建包含ASCII的文件
echo Hello World > ascii.txt

:: 使用certutil编码
certutil -encodehex ascii.txt hex.txt 0x40000001
:: 0x40000001 选项表示小写十六进制，无空格

:: 查看结果
type hex.txt
:: 需要注意的是，certutil会在输出中添加额外信息

# ASCII到十六进制
def ascii_to_hex(text):
    # 方法1: 使用encode和hex
    return text.encode('ascii').hex()
    
    # 方法2: 使用列表推导式
    # return ''.join(f'{ord(c):02x}' for c in text)
    
    # 方法3: 使用binascii
    # import binascii
    # return binascii.hexlify(text.encode('ascii')).decode('ascii')

# 十六进制到ASCII
def hex_to_ascii(hex_str):
    # 方法1: 使用fromhex和decode
    return bytes.fromhex(hex_str).decode('ascii')
    
    # 方法2: 使用binascii
    # import binascii
    # return binascii.unhexlify(hex_str).decode('ascii')

# 示例
text = "Hello, World!"
hex_str = ascii_to_hex(text)
print(f"ASCII: {text}")
print(f"Hex: {hex_str}")

restored_text = hex_to_ascii(hex_str)
print(f"Restored: {restored_text}")
print(f"Match: {text == restored_text}")

def ascii_to_hex_formatted(text, separator="", uppercase=False):
    result = []
    for char in text:
        hex_value = format(ord(char), '02x')
        if uppercase:
            hex_value = hex_value.upper()
        result.append(hex_value)
    return separator.join(result)

# 示例
text = "Hello World"
print(ascii_to_hex_formatted(text))  # 48656c6c6f20576f726c64
print(ascii_to_hex_formatted(text, " "))  # 48 65 6c 6c 6f 20 57 6f 72 6c 64
print(ascii_to_hex_formatted(text, ":"))  # 48:65:6c:6c:6f:20:57:6f:72:6c:64
print(ascii_to_hex_formatted(text, "-", True))  # 48-65-6C-6C-6F-20-57-6F-72-6C-64

def safe_hex_to_ascii(hex_str):
    try:
        # 清理输入，移除非十六进制字符
        clean_hex = ''.join(c for c in hex_str if c.isalnum() or c in "-:")
        # 移除分隔符
        clean_hex = clean_hex.replace("-", "").replace(":", "")
        # 确保长度为偶数
        if len(clean_hex) % 2 != 0:
            clean_hex = '0' + clean_hex
        # 转换
        return bytes.fromhex(clean_hex).decode('ascii')
    except Exception as e:
        return f"Error: {str(e)}"

# 示例
print(safe_hex_to_ascii("48 65 6C 6C 6F"))  # Hello
print(safe_hex_to_ascii("48:65:6C:6C:6F"))  # Hello
print(safe_hex_to_ascii("48-65-6C-6C-6F"))  # Hello
print(safe_hex_to_ascii("4865"))  # He
print(safe_hex_to_ascii("48656"))  # 自动补零后转换为 Hel
print(safe_hex_to_ascii("4865ZZ"))  # 错误处理

// ASCII到十六进制
function asciiToHex(text) {
    let hex = '';
    for (let i = 0; i < text.length; i++) {
        const hexCode = text.charCodeAt(i).toString(16);
        hex += hexCode.length === 1 ? '0' + hexCode : hexCode;
    }
    return hex;
}

// 十六进制到ASCII
function hexToAscii(hexStr) {
    let text = '';
    // 确保长度为偶数
    if (hexStr.length % 2 !== 0) {
        hexStr = '0' + hexStr;
    }
    for (let i = 0; i < hexStr.length; i += 2) {
        text += String.fromCharCode(parseInt(hexStr.substr(i, 2), 16));
    }
    return text;
}

// 示例
const text = "Hello, World!";
const hexStr = asciiToHex(text);
console.log(`ASCII: ${text}`);
console.log(`Hex: ${hexStr}`);

const restoredText = hexToAscii(hexStr);
console.log(`Restored: ${restoredText}`);
console.log(`Match: ${text === restoredText}`);

function asciiToHexFormatted(text, separator="", uppercase=false) {
    const hexArray = [];
    for (let i = 0; i < text.length; i++) {
        let hexCode = text.charCodeAt(i).toString(16);
        if (hexCode.length === 1) {
            hexCode = '0' + hexCode;
        }
        if (uppercase) {
            hexCode = hexCode.toUpperCase();
        }
        hexArray.push(hexCode);
    }
    return hexArray.join(separator);
}

// 示例
const text = "Hello World";
console.log(asciiToHexFormatted(text));  // 48656c6c6f20576f726c64
console.log(asciiToHexFormatted(text, " "));  // 48 65 6c 6c 6f 20 57 6f 72 6c 64
console.log(asciiToHexFormatted(text, ":"));  // 48:65:6c:6c:6f:20:57:6f:72:6c:64
console.log(asciiToHexFormatted(text, "-", true));  // 48-65-6C-6C-6F-20-57-6F-72-6C-64

// 使用Buffer对象
function asciiToHexNode(text) {
    return Buffer.from(text, 'ascii').toString('hex');
}

function hexToAsciiNode(hexStr) {
    return Buffer.from(hexStr, 'hex').toString('ascii');
}

// 示例
const text = "Hello, World!";
const hexStr = asciiToHexNode(text);
console.log(`ASCII: ${text}`);
console.log(`Hex: ${hexStr}`);

const restoredText = hexToAsciiNode(hexStr);
console.log(`Restored: ${restoredText}`);
console.log(`Match: ${text === restoredText}`);

public class HexAsciiConverter {
    // ASCII到十六进制
    public static String asciiToHex(String ascii) {
        StringBuilder hex = new StringBuilder();
        for (char c : ascii.toCharArray()) {
            hex.append(String.format("%02x", (int) c));
        }
        return hex.toString();
    }
    
    // 十六进制到ASCII
    public static String hexToAscii(String hex) {
        StringBuilder ascii = new StringBuilder();
        
        // 确保长度为偶数
        if (hex.length() % 2 != 0) {
            hex = "0" + hex;
        }
        
        for (int i = 0; i < hex.length(); i += 2) {
            String hexPair = hex.substring(i, i + 2);
            char c = (char) Integer.parseInt(hexPair, 16);
            ascii.append(c);
        }
        
        return ascii.toString();
    }
    
    public static void main(String[] args) {
        String text = "Hello, World!";
        String hexStr = asciiToHex(text);
        System.out.println("ASCII: " + text);
        System.out.println("Hex: " + hexStr);
        
        String restoredText = hexToAscii(hexStr);
        System.out.println("Restored: " + restoredText);
        System.out.println("Match: " + text.equals(restoredText));
    }
}

import java.util.stream.Collectors;

public class HexAsciiConverterJava8 {
    // ASCII到十六进制
    public static String asciiToHex(String ascii) {
        return ascii.chars()
                   .mapToObj(c -> String.format("%02x", c))
                   .collect(Collectors.joining());
    }
    
    // 十六进制到ASCII
    public static String hexToAscii(String hex) {
        // 确保长度为偶数
        if (hex.length() % 2 != 0) {
            hex = "0" + hex;
        }
        
        StringBuilder ascii = new StringBuilder();
        for (int i = 0; i < hex.length(); i += 2) {
            String hexPair = hex.substring(i, i + 2);
            char c = (char) Integer.parseInt(hexPair, 16);
            ascii.append(c);
        }
        
        return ascii.toString();
    }
    
    public static void main(String[] args) {
        String text = "Hello, World!";
        String hexStr = asciiToHex(text);
        System.out.println("ASCII: " + text);
        System.out.println("Hex: " + hexStr);
        
        String restoredText = hexToAscii(hexStr);
        System.out.println("Restored: " + restoredText);
        System.out.println("Match: " + text.equals(restoredText));
    }
}

import org.apache.commons.codec.binary.Hex;

public class HexAsciiConverterApache {
    // ASCII到十六进制
    public static String asciiToHex(String ascii) {
        return Hex.encodeHexString(ascii.getBytes());
    }
    
    // 十六进制到ASCII
    public static String hexToAscii(String hex) {
        try {
            return new String(Hex.decodeHex(hex));
        } catch (Exception e) {
            throw new RuntimeException("Invalid hex string", e);
        }
    }
    
    public static void main(String[] args) {
        String text = "Hello, World!";
        String hexStr = asciiToHex(text);
        System.out.println("ASCII: " + text);
        System.out.println("Hex: " + hexStr);
        
        String restoredText = hexToAscii(hexStr);
        System.out.println("Restored: " + restoredText);
        System.out.println("Match: " + text.equals(restoredText));
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// ASCII到十六进制
char* ascii_to_hex(const char* ascii) {
    int len = strlen(ascii);
    // 每个字符转换为两个十六进制字符，加1保存结束符
    char* hex = (char*)malloc(len * 2 + 1);
    if (!hex) return NULL;
    
    for (int i = 0; i < len; i++) {
        // 使用sprintf将字符转换为两个十六进制字符
        sprintf(hex + i * 2, "%02x", (unsigned char)ascii[i]);
    }
    hex[len * 2] = '\0'; // 添加结束符
    return hex;
}

// 十六进制到ASCII
char* hex_to_ascii(const char* hex) {
    int len = strlen(hex);
    // 每两个十六进制字符转换为一个ASCII字符
    int ascii_len = len / 2;
    char* ascii = (char*)malloc(ascii_len + 1);
    if (!ascii) return NULL;
    
    for (int i = 0; i < ascii_len; i++) {
        // 提取两个十六进制字符
        char hex_pair[3];
        hex_pair[0] = hex[i * 2];
        hex_pair[1] = hex[i * 2 + 1];
        hex_pair[2] = '\0';
        // 转换为十进制并映射到ASCII
        ascii[i] = (char)strtol(hex_pair, NULL, 16);
    }
    ascii[ascii_len] = '\0'; // 添加结束符
    return ascii;
}

int main() {
    const char* text = "Hello, World!";
    char* hex_str = ascii_to_hex(text);
    printf("ASCII: %s\n", text);
    printf("Hex: %s\n", hex_str);
    
    char* restored_text = hex_to_ascii(hex_str);
    printf("Restored: %s\n", restored_text);
    printf("Match: %s\n", strcmp(text, restored_text) == 0 ? "Yes" : "No");
    
    // 释放动态分配的内存
    free(hex_str);
    free(restored_text);
    
    return 0;
}

#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>

// ASCII到十六进制
std::string ascii_to_hex(const std::string& ascii) {
    std::stringstream ss;
    for (char c : ascii) {
        ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(static_cast<unsigned char>(c));
    }
    return ss.str();
}

// 十六进制到ASCII
std::string hex_to_ascii(const std::string& hex) {
    std::string ascii;
    // 确保长度为偶数
    std::string adjusted_hex = hex;
    if (adjusted_hex.length() % 2 != 0) {
        adjusted_hex = "0" + adjusted_hex;
    }
    
    for (size_t i = 0; i < adjusted_hex.length(); i += 2) {
        std::string hex_pair = adjusted_hex.substr(i, 2);
        char c = static_cast<char>(std::stoi(hex_pair, nullptr, 16));
        ascii.push_back(c);
    }
    return ascii;
}

int main() {
    std::string text = "Hello, World!";
    std::string hex_str = ascii_to_hex(text);
    std::cout << "ASCII: " << text << std::endl;
    std::cout << "Hex: " << hex_str << std::endl;
    
    std::string restored_text = hex_to_ascii(hex_str);
    std::cout << "Restored: " << restored_text << std::endl;
    std::cout << "Match: " << (text == restored_text ? "Yes" : "No") << std::endl;
    
    return 0;
}

xxd [options] [infile [outfile]]

# 转换字符串
echo -n "Hello World" | xxd -p
# 输出: 48656c6c6f20576f726c64

# 转换文件内容
xxd -p input.txt > output.hex

# 格式化输出，每行显示16个字节，使用空格分隔
echo -n "Hello World! This is a test." | xxd -p -c 16 | xargs -I{} echo {} | sed 's/\(..\)/\1 /g'
# 输出格式化的十六进制

# 转换十六进制字符串
echo "48656c6c6f20576f726c64" | xxd -r -p
# 输出: Hello World

# 转换十六进制文件
xxd -r -p input.hex > output.txt

# 处理带偏移量和ASCII部分的标准xxd输出
xxd input.txt | xxd -r > output.txt  # 恢复原始文件

hexdump [options] [file ...]

# 转换字符串
echo -n "Hello World" | hexdump -v -e '/1 "%02x"'
echo  # 换行
# 输出: 48656c6c6f20576f726c64

# 格式化输出，每行16字节，使用空格分隔
echo -n "Hello World! This is a test." | hexdump -v -e '16/1 "%02x " "\n"'
# 输出格式化的十六进制

# 十六进制和ASCII混合显示
echo -n "Hello World!" | hexdump -C
# 输出带有ASCII部分的十六进制

# hexdump主要用于查看，转换通常使用xxd -r
# 但可以通过以下方式间接实现：
echo "48656c6c6f20576f726c64" | xxd -r -p | hexdump -C

od [options] [file ...]

# 以十六进制格式显示
echo -n "Hello World" | od -A n -t x1 | tr -d ' ' | tr -d '\n'
echo  # 换行
# 输出: 48656c6c6f20576f726c64

# 同时显示十六进制和字符
echo -n "Hello World" | od -t x1c
# 输出混合格式

# 使用转义序列输出ASCII字符
printf "\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\n"
# 输出: Hello World

# 将字符串转换为十六进制表示
printf "%x\n" "'H'"  # 输出单个字符的十六进制值

# 使用循环处理字符串
text="Hello" && for ((i=0; i<${#text}; i++)); do printf "%02x" "'${text:$i:1}'"; done; echo

# 基本转换
$text = "Hello World"
$hex = -join ($text.ToCharArray() | ForEach-Object { '{0:x2}' -f [int]$_ })
Write-Host $hex  # 输出: 48656c6c6f20576f726c64

# 使用BitConverter
$bytes = [System.Text.Encoding]::ASCII.GetBytes($text)
$hex = [System.BitConverter]::ToString($bytes) -replace '-', ''
Write-Host $hex  # 输出: 48656C6C6F20576F726C64

# 格式化输出（带空格分隔）
$formattedHex = [System.BitConverter]::ToString($bytes)
Write-Host $formattedHex  # 输出: 48-65-6C-6C-6F-20-57-6F-72-6C-64

# 使用Convert类（.NET Core 3.0+）
# $hex = [System.Convert]::ToHexString($bytes)
# Write-Host $hex

# 基本转换
$hex = "48656c6c6f20576f726c64"
$bytes = for ($i = 0; $i -lt $hex.Length; $i += 2) {
    [byte]::Parse($hex.Substring($i, 2), [System.Globalization.NumberStyles]::HexNumber)
}
$text = [System.Text.Encoding]::ASCII.GetString($bytes)
Write-Host $text  # 输出: Hello World

# 处理带分隔符的十六进制
$hexWithSeparators = "48-65-6C-6C-6F-20-57-6F-72-6C-64"
$bytes = [System.Convert]::FromHexString($hexWithSeparators.Replace("-", ""))
$text = [System.Text.Encoding]::ASCII.GetString($bytes)
Write-Host $text  # 输出: Hello World

# 使用Convert类（.NET Core 3.0+）
# $bytes = [System.Convert]::FromHexString($hex)
# $text = [System.Text.Encoding]::ASCII.GetString($bytes)
# Write-Host $text

# 定义函数
function Convert-AsciiToHex {
    param(
        [string]$Text,
        [string]$Separator = "",
        [switch]$Uppercase
    )
    
    $bytes = [System.Text.Encoding]::ASCII.GetBytes($Text)
    $hex = [System.BitConverter]::ToString($bytes)
    
    if ($Separator -ne "-") {
        $hex = $hex -replace '-', $Separator
    }
    
    if ($Uppercase) {
        return $hex.ToUpper()
    } else {
        return $hex.ToLower()
    }
}

function Convert-HexToAscii {
    param(
        [string]$Hex
    )
    
    # 清理输入，移除所有非十六进制字符
    $cleanHex = [regex]::Replace($Hex, '[^0-9A-Fa-f]', '')
    
    # 确保长度为偶数
    if ($cleanHex.Length % 2 -ne 0) {
        $cleanHex = "0" + $cleanHex
    }
    
    try {
        $bytes = [byte[]]::new($cleanHex.Length / 2)
        for ($i = 0; $i -lt $cleanHex.Length; $i += 2) {
            $bytes[$i / 2] = [byte]::Parse($cleanHex.Substring($i, 2), [System.Globalization.NumberStyles]::HexNumber)
        }
        return [System.Text.Encoding]::ASCII.GetString($bytes)
    } catch {
        throw "无效的十六进制字符串: $_"
    }
}

# 使用函数
$text = "Hello World"
$hex = Convert-AsciiToHex -Text $text -Separator " " -Uppercase
Write-Host "Formatted Hex: $hex"  # 输出: 48 65 6C 6C 6F 20 57 6F 72 6C 64

$restoredText = Convert-HexToAscii -Hex "48656c6c6f20576f726c64"
Write-Host "Restored Text: $restoredText"  # 输出: Hello World

:: ASCII到十六进制
:: 创建包含ASCII的文件
echo Hello World > ascii.txt

:: 使用certutil编码为十六进制
certutil -encodehex ascii.txt hex.txt 0x40000001
:: 0x40000001 选项表示小写十六进制，无空格

:: 查看结果
type hex.txt

:: 十六进制到ASCII
:: 创建包含十六进制的文件（格式需要注意）
echo 48656c6c6f20576f726c64 > hex.txt

:: 使用certutil解码需要特定格式，比较复杂
:: 通常使用PowerShell更简单

@echo off

:: 简单的十六进制到ASCII转换脚本（有限功能）
setlocal enabledelayedexpansion
set "hex=%1"
set "result="

:: 确保长度为偶数
if "%~1"=="" (
    echo 用法: %0 hex_string
    exit /b 1
)

:: 简单转换（仅支持小写）
for /l %%i in (0,2,%%~len(hex)) do (
    set "byte=!hex:~%%i,2!"
    for /f "tokens=2 delims==" %%j in ('powershell -command "[char][System.Convert]::ToInt32('!byte!', 16)"') do (
        set "result=!result!%%j"
    )
)

echo %result%
endlocal

# 安装WSL
wsl --install

# 安装后，在WSL中使用Linux命令
wsl echo -n "Hello World" | xxd -p
# 输出: 48656c6c6f20576f726c64

# ASCII到十六进制
$text = "Hello World"
$hex = wsl bash -c "echo -n '$text' | xxd -p"
Write-Host $hex  # 输出: 48656c6c6f20576f726c64

# 十六进制到ASCII
$hex = "48656c6c6f20576f726c64"
$text = wsl bash -c "echo '$hex' | xxd -r -p"
Write-Host $text  # 输出: Hello World

# 使用strings命令提取二进制文件中的ASCII字符串
strings malicious.exe > extracted_strings.txt

# 使用十六进制编辑器或脚本分析非ASCII字符串
hexdump -C malicious.exe | grep -A 5 "\x68\x74\x74\x70"  # 搜索HTTP相关字节

# 内存分析脚本示例
import re

# 读取内存转储文件
with open('memory_dump.bin', 'rb') as f:
    memory_data = f.read()

# 搜索可能的URL模式（十六进制表示）
http_pattern = re.compile(b'\x68\x74\x74\x70\x73?\x3a\x2f\x2f')
match_positions = [m.start() for m in re.finditer(http_pattern, memory_data)]

# 提取并转换URL
for pos in match_positions:
    # 从匹配位置开始读取最多200个字节
    url_bytes = memory_data[pos:pos+200]
    # 查找字符串结束位置（NULL字节或非打印字符）
    try:
        url_end = url_bytes.index(b'\x00')
        url_bytes = url_bytes[:url_end]
    except ValueError:
        pass  # 没有找到NULL字节，使用全部内容
    # 尝试转换为ASCII
    try:
        url = url_bytes.decode('ascii')
        print(f"Found URL: {url}")
    except UnicodeDecodeError:
        print(f"Found possible URL but could not decode at position {pos}")

# 使用tcpdump捕获网络流量
sudo tcpdump -i eth0 -w capture.pcap port 80

# 使用Wireshark分析捕获的流量
# 在Wireshark中，使用过滤器查找特定的十六进制模式
# 如：tcp contains 41:42:43  # 搜索ASCII "ABC"

# 提取HTTP请求中的数据
strings capture.pcap | grep -i "password"

# 生成缓冲区溢出载荷示例
import sys

# 缓冲区大小
buffer_size = 1000
# NOP指令（十六进制：0x90）
nop_sled = b'\x90' * 200
# Shellcode（十六进制表示）
shellcode = b'\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80'
# 填充字符
padding = b'A' * (buffer_size - len(nop_sled) - len(shellcode) - 4)
# 返回地址（十六进制：\x41\x41\x41\x41，这里只是示例）
return_address = b'\x41\x41\x41\x41'

# 构造最终载荷
payload = nop_sled + shellcode + padding + return_address

# 保存为二进制文件
with open('exploit.bin', 'wb') as f:
    f.write(payload)

print(f"Exploit payload created: {len(payload)} bytes")
print(f"NOP sled: {len(nop_sled)} bytes")
print(f"Shellcode: {len(shellcode)} bytes")
print(f"Padding: {len(padding)} bytes")
print(f"Return address: {len(return_address)} bytes")

# URL编码示例
import urllib.parse

# 编码字符串
original = "Hello, World! 中文测试"
encoded = urllib.parse.quote(original)
print(f"Original: {original}")
print(f"Encoded: {encoded}")

# 解码
restored = urllib.parse.unquote(encoded)
print(f"Restored: {restored}")
print(f"Match: {original == restored}")

# 手动编码（仅ASCII部分）
def url_encode_ascii(text):
    result = []
    for char in text:
        if ord(char) < 128 and char.isalnum() or char in '-_.~':
            result.append(char)
        else:
            result.append(f"%{ord(char):02X}")
    return ''.join(result)

print(url_encode_ascii("Hello, World!"))  # Hello%2C%20World%21

# 使用tcpdump捕获TCP SYN数据包并显示十六进制内容
sudo tcpdump -i eth0 -n -XX 'tcp[tcpflags] & (tcp-syn) != 0' -c 1

# 输出示例分析：
# 0x0000:  4500 003c 0000 4000 4006 0000 c0a8 0101  E..<..@.@.......
# 0x0010:  c0a8 0102 0014 0050 0000 0000 0000 0000  .......P........
# 0x0020:  0000 0000 6002 2000 ffff 0000 0204 05b4  ....`...........
# 0x0030:  0402 080a 0000 0000 0000 0000 0103 0307  ................

# 其中：
# 45: IP版本4，头部长度5
# 00: 服务类型
# 003c: 总长度 (60字节)
# 0014: 源端口 (20)
# 0050: 目标端口 (80)
# 6002: TCP标志位 (SYN设置)

// WebSocket二进制消息处理示例
const socket = new WebSocket('ws://example.com');

socket.onopen = function(event) {
    // 发送二进制数据
    const arrayBuffer = new ArrayBuffer(5);
    const uint8Array = new Uint8Array(arrayBuffer);
    uint8Array[0] = 0x48; // H
    uint8Array[1] = 0x65; // e
    uint8Array[2] = 0x6C; // l
    uint8Array[3] = 0x6C; // l
    uint8Array[4] = 0x6F; // o
    socket.send(arrayBuffer);
};

socket.onmessage = function(event) {
    if (event.data instanceof ArrayBuffer) {
        // 处理二进制数据
        const uint8Array = new Uint8Array(event.data);
        // 转换为十六进制字符串
        const hexString = Array.from(uint8Array)
            .map(byte => byte.toString(16).padStart(2, '0'))
            .join('');
        console.log('Received binary data (hex):', hexString);
        // 转换为ASCII
        const text = Array.from(uint8Array)
            .map(byte => String.fromCharCode(byte))
            .join('');
        console.log('Received binary data (ASCII):', text);
    }
};

import base64

# 二进制数据
binary_data = b'Hello, World! 这是一个测试'

# Base64编码
base64_encoded = base64.b64encode(binary_data)
print(f"Base64 encoded: {base64_encoded.decode('ascii')}")

# Base64解码
base64_decoded = base64.b64decode(base64_encoded)
print(f"Base64 decoded: {base64_decoded}")
print(f"Match: {binary_data == base64_decoded}")

# Base64与十六进制的关系
# Base64编码使用A-Z, a-z, 0-9, '+', '/'字符，'='作为填充
# 十六进制使用0-9, A-F字符
# 两者都是将二进制数据转换为可打印ASCII字符的方法

import json
import base64

# 二进制数据
image_data = b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR...'  # 简化示例

# 方法1: Base64编码
base64_image = base64.b64encode(image_data).decode('ascii')
json_data = {
    "image": base64_image,
    "type": "png",
    "encoding": "base64"
}

# 方法2: 十六进制字符串（对于小数据更简单）
hex_image = image_data.hex()
json_data_hex = {
    "image": hex_image,
    "type": "png",
    "encoding": "hex"
}

# 序列化到JSON
json_string = json.dumps(json_data, indent=2)
json_string_hex = json.dumps(json_data_hex, indent=2)

print("Base64 JSON:")
print(json_string)

print("\nHex JSON:")
print(json_string_hex)

# 反序列化
parsed_data = json.loads(json_string)
restored_image = base64.b64decode(parsed_data["image"])
print(f"\nImage data restored successfully: {len(restored_image)} bytes")

# 简单的内存转储分析工具
import struct

def analyze_memory_dump(dump_file, search_pattern):
    """搜索内存转储文件中的特定模式"""
    try:
        with open(dump_file, 'rb') as f:
            dump_data = f.read()
        
        # 转换搜索模式为二进制
        if isinstance(search_pattern, str):
            # 尝试解析十六进制字符串
            if search_pattern.startswith('0x'):
                search_pattern = search_pattern[2:]  # 移除0x前缀
            # 确保长度为偶数
            if len(search_pattern) % 2 != 0:
                search_pattern = '0' + search_pattern
            # 转换为字节
            pattern_bytes = bytes.fromhex(search_pattern)
        elif isinstance(search_pattern, bytes):
            pattern_bytes = search_pattern
        else:
            raise ValueError("搜索模式必须是字符串或字节")
        
        # 搜索模式
        positions = []
        pos = 0
        while True:
            pos = dump_data.find(pattern_bytes, pos)
            if pos == -1:
                break
            positions.append(pos)
            pos += 1
        
        return positions
    except Exception as e:
        print(f"分析错误: {str(e)}")
        return []

# 使用示例
# positions = analyze_memory_dump('memory.dmp', '48656c6c6f')  # 搜索"Hello"
# if positions:
#    print(f"找到{len(positions)}个匹配:")
#    for pos in positions:
#        print(f"  位置: 0x{pos:x}")

import logging

# 配置日志
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger('binary_logger')

def log_binary_data(data, description="Binary data"):
    """记录二进制数据的十六进制和ASCII表示"""
    if isinstance(data, str):
        data = data.encode('utf-8')
    
    # 转换为十六进制字符串
    hex_str = data.hex()
    
    # 尝试转换为ASCII（忽略不可打印字符）
    ascii_str = ''
    for byte in data:
        if 32 <= byte <= 126:  # 可打印ASCII
            ascii_str += chr(byte)
        else:
            ascii_str += '.'
    
    # 格式化输出
    formatted_output = []
    formatted_output.append(f"{description}:")
    formatted_output.append(f"  长度: {len(data)}字节")
    
    # 格式化十六进制输出（每行16字节）
    hex_lines = []
    for i in range(0, len(data), 16):
        chunk = data[i:i+16]
        # 十六进制部分
        hex_part = ' '.join(f"{b:02x}" for b in chunk)
        # ASCII部分
        ascii_part = ''.join(chr(b) if 32 <= b <= 126 else '.' for b in chunk)
        hex_lines.append(f"  0x{i:08x}: {hex_part.ljust(47)}  {ascii_part}")
    
    formatted_output.extend(hex_lines)
    logger.debug('\n'.join(formatted_output))

# 使用示例
# binary_data = b'Hello, World!\x00\x01\x02\x03\xFF'
# log_binary_data(binary_data, "示例二进制数据")

def identify_file_type(file_path):
    """通过文件头识别文件类型"""
    file_signatures = {
        b'\xFF\xD8\xFF': 'JPEG',
        b'\x89\x50\x4E\x47': 'PNG',
        b'\x47\x49\x46\x38': 'GIF',
        b'\x25\x50\x44\x46': 'PDF',
        b'\x50\x4B\x03\x04': 'ZIP',
        b'\x52\x61\x72\x21': 'RAR',
        b'\x7F\x45\x4C\x46': 'ELF',
        b'\x4D\x5A': 'PE/EXE',
    }
    
    try:
        with open(file_path, 'rb') as f:
            header = f.read(12)  # 读取文件头前12字节
        
        # 检查每个签名
        for signature, file_type in file_signatures.items():
            if header.startswith(signature):
                return file_type
        
        return 'Unknown'
    except Exception as e:
        print(f"错误: {str(e)}")
        return 'Error'

# 使用示例
# file_type = identify_file_type('example.jpg')
# print(f"文件类型: {file_type}")

def modify_binary_file(file_path, offset, new_bytes):
    """修改二进制文件中的特定位置"""
    try:
        with open(file_path, 'r+b') as f:
            # 移动到指定偏移量
            f.seek(offset)
            # 写入新的字节
            f.write(new_bytes)
        return True
    except Exception as e:
        print(f"修改文件错误: {str(e)}")
        return False

# 使用示例
# 修改示例
# success = modify_binary_file('data.bin', 10, b'\x41\x42\x43')  # 在偏移量10处写入"ABC"
# if success:
#    print("文件修改成功")

# 使用chardet检测编码
import chardet

def detect_encoding(text):
    if isinstance(text, str):
        # 对于字符串，先转换为字节
        text = text.encode('utf-8')
    result = chardet.detect(text)
    return result

# 示例
# encoded_text = b'Hello, World!'
# encoding_info = detect_encoding(encoded_text)
# print(f"编码: {encoding_info['encoding']}, 置信度: {encoding_info['confidence']:.2f}")

# 处理非ASCII字符
text_with_unicode = "Hello, World! 你好，世界！"

# 尝试ASCII编码（会失败）
try:
    ascii_bytes = text_with_unicode.encode('ascii')
except UnicodeEncodeError as e:
    print(f"ASCII编码失败: {e}")

# 使用错误处理策略
ascii_bytes_replace = text_with_unicode.encode('ascii', errors='replace')
ascii_bytes_ignore = text_with_unicode.encode('ascii', errors='ignore')
ascii_bytes_backslash = text_with_unicode.encode('ascii', errors='backslashreplace')

print(f"替换错误字符: {ascii_bytes_replace.decode('ascii')}")
print(f"忽略错误字符: {ascii_bytes_ignore.decode('ascii')}")
print(f"反斜杠转义: {ascii_bytes_backslash.decode('ascii')}")

# 使用UTF-8编码
utf8_bytes = text_with_unicode.encode('utf-8')
print(f"UTF-8十六进制: {utf8_bytes.hex()}")

def safe_hex_to_bytes(hex_str):
    """安全地将十六进制字符串转换为字节"""
    # 清理输入，移除空格和分隔符
    hex_str = hex_str.replace(' ', '').replace('-', '').replace(':', '')
    
    # 处理奇数长度
    if len(hex_str) % 2 != 0:
        print(f"警告: 奇数长度的十六进制字符串 '{hex_str}'，在前面补零")
        hex_str = '0' + hex_str
    
    try:
        return bytes.fromhex(hex_str)
    except ValueError as e:
        print(f"转换错误: {e}")
        return b''

# 示例
print(safe_hex_to_bytes("48656c6c6").decode('ascii', errors='replace'))  # 在前面补零

import re

def clean_hex_string(hex_str):
    """清理十六进制字符串，只保留有效的十六进制字符"""
    # 只保留有效的十六进制字符（不区分大小写）
    cleaned = re.sub(r'[^0-9A-Fa-f]', '', hex_str)
    return cleaned

def validate_hex_string(hex_str):
    """验证十六进制字符串是否有效"""
    # 检查是否只包含有效的十六进制字符
    return bool(re.match(r'^[0-9A-Fa-f]+$', hex_str))

# 示例
invalid_hex = "4865Xc6c6f!@#$%^&*()"
cleaned_hex = clean_hex_string(invalid_hex)
print(f"原始字符串: {invalid_hex}")
print(f"清理后: {cleaned_hex}")
print(f"有效: {validate_hex_string(cleaned_hex)}")

# 转换清理后的字符串
try:
    result = bytes.fromhex(cleaned_hex).decode('ascii')
    print(f"转换结果: {result}")
except Exception as e:
    print(f"转换错误: {e}")

def process_large_file(file_path, chunk_size=8192):
    """分块处理大型文件"""
    try:
        with open(file_path, 'rb') as f:
            while True:
                chunk = f.read(chunk_size)
                if not chunk:
                    break  # 文件读取完毕
                
                # 处理当前块
                hex_chunk = chunk.hex()
                # 这里可以进行其他处理...
                
                # 为了示例，只打印前几个字符
                if len(hex_chunk) > 20:
                    print(f"处理块: {hex_chunk[:20]}...")
                else:
                    print(f"处理块: {hex_chunk}")
    except Exception as e:
        print(f"处理文件错误: {e}")

# 使用示例
# process_large_file('large_data.bin')

# 性能优化示例：使用查找表进行ASCII到十六进制的快速转换

# 预构建查找表
ASCII_TO_HEX = {}
for i in range(256):
    ASCII_TO_HEX[chr(i)] = f"{i:02x}"

def fast_ascii_to_hex(text):
    """使用查找表进行快速的ASCII到十六进制转换"""
    # 仅适用于ASCII字符
    return ''.join(ASCII_TO_HEX[c] for c in text if ord(c) < 256)

# 与标准方法比较
import time

def benchmark():
    text = "Hello, World!" * 10000  # 创建一个较大的测试字符串
    
    # 测试标准方法
    start_time = time.time()
    result1 = text.encode('ascii').hex()
    standard_time = time.time() - start_time
    
    # 测试快速方法
    start_time = time.time()
    result2 = fast_ascii_to_hex(text)
    fast_time = time.time() - start_time
    
    # 验证结果
    matches = result1 == result2
    
    print(f"标准方法时间: {standard_time:.6f}秒")
    print(f"快速方法时间: {fast_time:.6f}秒")
    print(f"结果匹配: {matches}")
    print(f"加速比: {standard_time/fast_time:.2f}倍")

# 使用示例
# benchmark()

import struct

class BinaryProtocolMessage:
    def __init__(self, message_type, payload):
        self.message_type = message_type  # 1字节
        self.payload_length = len(payload)  # 2字节
        self.payload = payload
    
    def serialize(self):
        """将消息序列化为二进制格式"""
        # 使用struct.pack进行二进制序列化
        # '!BH'表示网络字节序（大端序），1字节无符号字符，2字节无符号短整数
        header = struct.pack('!BH', self.message_type, self.payload_length)
        return header + self.payload
    
    @classmethod
    def deserialize(cls, data):
        """从二进制数据反序列化消息"""
        if len(data) < 3:  # 头部长度为3字节
            raise ValueError("数据太短，无法解析消息")
        
        # 解析头部
        header = struct.unpack('!BH', data[:3])
        message_type = header[0]
        payload_length = header[1]
        
        # 验证数据长度
        if len(data) < 3 + payload_length:
            raise ValueError("数据不完整，缺少有效载荷")
        
        # 提取有效载荷
        payload = data[3:3+payload_length]
        
        return cls(message_type, payload)
    
    def __str__(self):
        return f"Message(type=0x{self.message_type:02x}, length={self.payload_length}, payload=0x{self.payload.hex()[:20]}{'...' if len(self.payload) > 20 else ''})"

# 使用示例
# 创建消息
message = BinaryProtocolMessage(0x01, b'Hello, World!')
print(f"原始消息: {message}")

# 序列化
binary_data = message.serialize()
print(f"二进制表示: 0x{binary_data.hex()}")

# 反序列化
restored_message = BinaryProtocolMessage.deserialize(binary_data)
print(f"恢复的消息: {restored_message}")

class ProtocolParser:
    def __init__(self):
        self.parsers = {
            # 注册不同协议的解析函数
            'http': self._parse_http,
            'dns': self._parse_dns,
            'custom': self._parse_custom
        }
    
    def parse(self, protocol, data):
        """根据协议类型解析数据"""
        if protocol in self.parsers:
            return self.parsers[protocol](data)
        else:
            raise ValueError(f"不支持的协议: {protocol}")
    
    def _parse_http(self, data):
        """解析HTTP协议数据"""
        try:
            # 尝试将数据转换为ASCII字符串进行分析
            text = data.decode('ascii', errors='replace')
            
            # 简单的HTTP解析
            lines = text.split('\r\n')
            if lines:
                first_line = lines[0].strip()
                if first_line.startswith(('GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'OPTIONS')):
                    return {"type": "HTTP Request", "first_line": first_line}
                elif first_line.startswith(('HTTP/1.0', 'HTTP/1.1', 'HTTP/2.0')):
                    return {"type": "HTTP Response", "status_line": first_line}
            
            return {"type": "HTTP Unknown", "data": text[:100] + ('...' if len(text) > 100 else '')}
        except Exception as e:
            return {"type": "HTTP Error", "error": str(e)}
    
    def _parse_dns(self, data):
        """简单的DNS协议解析"""
        if len(data) < 12:  # DNS消息至少12字节
            return {"type": "Invalid DNS", "error": "消息太短"}
        
        # 解析DNS头部的前两个字节（标识）
        identifier = int.from_bytes(data[:2], byteorder='big')
        
        return {"type": "DNS Message", "identifier": identifier, "length": len(data)}
    
    def _parse_custom(self, data):
        """解析自定义协议"""
        # 这里可以实现特定协议的解析逻辑
        return {"type": "Custom Protocol", "hex": data.hex()[:40] + ('...' if len(data) > 20 else '')}

# 使用示例
# parser = ProtocolParser()
# http_data = b'GET /index.html HTTP/1.1\r\nHost: example.com\r\n\r\n'
# result = parser.parse('http', http_data)
# print(result)

import os
import hashlib
import base64

class KeyManager:
    @staticmethod
    def generate_key(key_size=32):
        """生成随机密钥"""
        return os.urandom(key_size)  # 使用操作系统的安全随机数生成器
    
    @staticmethod
    def derive_key(password, salt=None, key_size=32, iterations=100000):
        """从密码派生密钥"""
        if salt is None:
            salt = os.urandom(16)
        
        # 使用PBKDF2进行密钥派生
        key = hashlib.pbkdf2_hmac(
            'sha256',  # 哈希算法
            password.encode('utf-8'),  # 密码
            salt,  # 盐值
            iterations  # 迭代次数
        )
        
        # 截取需要的密钥长度
        return key[:key_size], salt
    
    @staticmethod
    def key_to_hex(key):
        """将密钥转换为十六进制字符串"""
        return key.hex()
    
    @staticmethod
    def hex_to_key(hex_str):
        """将十六进制字符串转换为密钥"""
        return bytes.fromhex(hex_str)
    
    @staticmethod
    def key_to_base64(key):
        """将密钥转换为Base64字符串"""
        return base64.b64encode(key).decode('ascii')
    
    @staticmethod
    def base64_to_key(base64_str):
        """将Base64字符串转换为密钥"""
        return base64.b64decode(base64_str)

# 使用示例
# 生成随机密钥
# random_key = KeyManager.generate_key()
# print(f"随机密钥 (十六进制): 0x{KeyManager.key_to_hex(random_key)}")
# print(f"随机密钥 (Base64): {KeyManager.key_to_base64(random_key)}")

# 从密码派生密钥
# password = "my_secure_password"
# derived_key, salt = KeyManager.derive_key(password)
# print(f"派生密钥 (十六进制): 0x{KeyManager.key_to_hex(derived_key)}")
# print(f"盐值 (十六进制): 0x{KeyManager.key_to_hex(salt)}")

# 导入/导出密钥
# hex_key = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
# imported_key = KeyManager.hex_to_key(hex_key)
# print(f"导入的密钥长度: {len(imported_key)}字节")

import json
import base64
from datetime import datetime

class EncryptedData:
    def __init__(self, ciphertext, iv, algorithm, key_id=None, metadata=None):
        self.ciphertext = ciphertext  # 密文（字节）
        self.iv = iv  # 初始化向量（字节）
        self.algorithm = algorithm  # 加密算法
        self.key_id = key_id  # 密钥标识符
        self.metadata = metadata or {}  # 元数据
        self.timestamp = datetime.now().isoformat()  # 时间戳
    
    def to_json(self):
        """将加密数据序列化为JSON"""
        data = {
            "ciphertext": base64.b64encode(self.ciphertext).decode('ascii'),
            "iv": base64.b64encode(self.iv).decode('ascii'),
            "algorithm": self.algorithm,
            "timestamp": self.timestamp,
        }
        
        if self.key_id:
            data["key_id"] = self.key_id
        
        if self.metadata:
            data["metadata"] = self.metadata
        
        return json.dumps(data, indent=2)
    
    @classmethod
    def from_json(cls, json_str):
        """从JSON反序列化加密数据"""
        data = json.loads(json_str)
        
        ciphertext = base64.b64decode(data["ciphertext"])
        iv = base64.b64decode(data["iv"])
        algorithm = data["algorithm"]
        key_id = data.get("key_id")
        metadata = data.get("metadata", {})
        
        # 创建对象
        obj = cls(ciphertext, iv, algorithm, key_id, metadata)
        obj.timestamp = data.get("timestamp", datetime.now().isoformat())
        
        return obj
    
    def __str__(self):
        return f"EncryptedData(algorithm={self.algorithm}, length={len(self.ciphertext)} bytes, key_id={self.key_id})"

## 十六进制和ASCII在数字取证中的应用

数字取证是计算机安全和法律调查的重要领域，十六进制和ASCII转换在其中有着关键应用。

### 15.1 磁盘镜像分析

在数字取证中，分析磁盘镜像文件需要理解二进制数据表示。

#### 15.1.1 文件恢复与数据提取

**应用场景**：
- 恢复已删除的文件
- 提取隐藏或加密的数据
- 分析文件碎片
- 重建文件系统结构

**分析示例**：
```python
import os

def recover_deleted_files(disk_image_path, output_dir):
    """从磁盘镜像中恢复已删除的文件"""
    # 创建输出目录
    os.makedirs(output_dir, exist_ok=True)
    
    try:
        with open(disk_image_path, 'rb') as f:
            disk_image = f.read()
        
        # 常见文件头签名
        file_signatures = {
            b'\xFF\xD8\xFF': ('jpg', 'JPEG图像'),
            b'\x89\x50\x4E\x47': ('png', 'PNG图像'),
            b'\x47\x49\x46\x38': ('gif', 'GIF图像'),
            b'\x25\x50\x44\x46': ('pdf', 'PDF文档'),
            b'\x50\x4B\x03\x04': ('zip', 'ZIP压缩文件'),
            b'\x4D\x5A': ('exe', '可执行文件'),
        }
        
        recovered_count = 0
        
        # 搜索每种文件类型的签名
        for signature, (ext, description) in file_signatures.items():
            pos = 0
            while True:
                pos = disk_image.find(signature, pos)
                if pos == -1:
                    break
                
                print(f"找到{description}，偏移量: 0x{pos:x} (十进制: {pos})")
                
                # 尝试提取文件（简化示例，实际需要更多逻辑）
                # 这里我们只提取签名后的数据，直到下一个签名或文件结束
                next_pos = pos + len(signature)
                # 简化处理，只保存签名后面的一部分数据
                file_data = disk_image[pos:pos+min(1024*1024, len(disk_image)-pos)]  # 最多1MB
                
                # 保存提取的数据
                file_path = os.path.join(output_dir, f"recovered_{recovered_count:04d}.{ext}")
                with open(file_path, 'wb') as out_file:
                    out_file.write(file_data)
                
                print(f"已保存到: {file_path}")
                recovered_count += 1
                pos += len(signature)
        
        return recovered_count
    except Exception as e:
        print(f"恢复文件错误: {str(e)}")
        return 0

# 使用示例
# recovered = recover_deleted_files('disk_image.dd', 'recovered_files')
# print(f"总共恢复了{recovered}个文件")