密码学#

1
// 1. 有限域运算
2
class PrimeField {
3
    constructor(prime) {
4
        this.prime = BigInt(prime);
5
    }
6

7
    // 加法
8
    add(a, b) {
9
        return (BigInt(a) + BigInt(b)) % this.prime;
10
    }
11

12
    // 乘法
13
    multiply(a, b) {
14
        return (BigInt(a) * BigInt(b)) % this.prime;
15
    }
16

17
    // 幂运算
18
    power(a, b) {
19
        return this.modPow(BigInt(a), BigInt(b));
20
    }
21

22
    // 模幂运算
23
    modPow(base, exponent) {
24
        let result = 1n;
25
        base = base % this.prime;
26

27
        while (exponent > 0n) {
28
            if (exponent % 2n === 1n) {
29
                result = (result * base) % this.prime;
30
            }
31
            exponent = exponent >> 1n;
32
            base = (base * base) % this.prime;
33
        }
34

35
        return result;
36
    }
37
}
38

39
// 2. 使用示例
40
const field = new PrimeField(21888242871839275222246405745257275088548364400416034343698204186575808495617n);
41
const result = field.add(5, 3); // 8

1
// 1. 椭圆曲线定义
2
class EllipticCurve {
3
    constructor(field, a, b) {
4
        this.field = field;
5
        this.a = a;
6
        this.b = b;
7
    }
8

9
    // 点加法
10
    pointAdd(p1, p2) {
11
        if (p1.isInfinity()) return p2;
12
        if (p2.isInfinity()) return p1;
13

14
        if (p1.x === p2.x) {
15
            if (p1.y === p2.y) {
16
                return this.pointDouble(p1);
17
            } else {
18
                return Point.infinity();
19
            }
20
        }
21

22
        const slope = this.field.multiply(
23
            this.field.add(p2.y, -p1.y),
24
            this.field.inverse(this.field.add(p2.x, -p1.x))
25
        );
26

27
        const x3 = this.field.add(
28
            this.field.multiply(slope, slope),
29
            -p1.x - p2.x
30
        );
31

32
        const y3 = this.field.add(
33
            this.field.multiply(slope, this.field.add(p1.x, -x3)),
34
            -p1.y
35
        );
36

37
        return new Point(x3, y3);
38
    }
39

40
    // 点倍乘
41
    pointDouble(p) {
42
        if (p.isInfinity()) return p;
43

44
        const slope = this.field.multiply(
45
            this.field.add(
46
                this.field.multiply(3n, this.field.multiply(p.x, p.x)),
47
                this.a
48
            ),
49
            this.field.inverse(this.field.multiply(2n, p.y))
50
        );
51

52
        const x3 = this.field.add(
53
            this.field.multiply(slope, slope),
54
            -this.field.multiply(2n, p.x)
55
        );
56

57
        const y3 = this.field.add(
58
            this.field.multiply(slope, this.field.add(p.x, -x3)),
59
            -p.y
60
        );
61

62
        return new Point(x3, y3);
63
    }
64
}
65

66
// 2. 点类定义
67
class Point {
68
    constructor(x, y) {
69
        this.x = x;
70
        this.y = y;
71
    }
72

73
    isInfinity() {
74
        return this.x === 0n && this.y === 0n;
75
    }
76

77
    static infinity() {
78
        return new Point(0n, 0n);
79
    }
80
}

1
const crypto = require('crypto');
2

3
// 1. 基本哈希
4
function sha256(data) {
5
    const hash = crypto.createHash('sha256');
6
    hash.update(data);
7
    return hash.digest('hex');
8
}
9

10
// 2. 多次哈希
11
function doubleSha256(data) {
12
    return sha256(sha256(data));
13
}
14

15
// 3. 哈希链
16
function hashChain(data, iterations) {
17
    let result = data;
18
    for (let i = 0; i < iterations; i++) {
19
        result = sha256(result);
20
    }
21
    return result;
22
}
23

24
// 4. 使用示例
25
const message = "Hello, World!";
26
const hash = sha256(message);
27
console.log("SHA-256:", hash);

1
// 1. 区块哈希
2
function calculateBlockHash(block) {
3
    const data = JSON.stringify({
4
        index: block.index,
5
        timestamp: block.timestamp,
6
        previousHash: block.previousHash,
7
        data: block.data,
8
        nonce: block.nonce
9
    });
10
    return sha256(data);
11
}
12

13
// 2. Merkle树根
14
function calculateMerkleRoot(transactions) {
15
    if (transactions.length === 0) return null;
16
    if (transactions.length === 1) return transactions[0];
17

18
    const nextLevel = [];
19
    for (let i = 0; i < transactions.length; i += 2) {
20
        const left = transactions[i];
21
        const right = transactions[i + 1] || transactions[i];
22
        nextLevel.push(sha256(left + right));
23
    }
24

25
    return calculateMerkleRoot(nextLevel);
26
}
27

28
// 3. 地址生成
29
function generateAddress(publicKey) {
30
    const hash = sha256(publicKey);
31
    return '0x' + hash.slice(-40);
32
}

1
const secp256k1 = require('secp256k1');
2
const crypto = require('crypto');
3

4
// 1. 生成私钥
5
function generatePrivateKey() {
6
    let privateKey;
7
    do {
8
        privateKey = crypto.randomBytes(32);
9
    } while (!secp256k1.privateKeyVerify(privateKey));
10

11
    return privateKey;
12
}
13

14
// 2. 从私钥生成公钥
15
function generatePublicKey(privateKey) {
16
    return secp256k1.publicKeyCreate(privateKey);
17
}
18

19
// 3. 生成密钥对
20
function generateKeyPair() {
21
    const privateKey = generatePrivateKey();
22
    const publicKey = generatePublicKey(privateKey);
23

24
    return { privateKey, publicKey };
25
}

1
// 1. 签名消息
2
function signMessage(message, privateKey) {
3
    const messageHash = crypto.createHash('sha256').update(message).digest();
4
    const signature = secp256k1.ecdsaSign(messageHash, privateKey);
5
    return signature.signature;
6
}
7

8
// 2. 验证签名
9
function verifySignature(message, signature, publicKey) {
10
    const messageHash = crypto.createHash('sha256').update(message).digest();
11
    return secp256k1.ecdsaVerify(signature, messageHash, publicKey);
12
}
13

14
// 3. 使用示例
15
const { privateKey, publicKey } = generateKeyPair();
16
const message = "Hello, World!";
17
const signature = signMessage(message, privateKey);
18
const isValid = verifySignature(message, signature, publicKey);
19
console.log("Signature valid:", isValid);

1
// 1. 交易结构
2
class Transaction {
3
    constructor(from, to, amount, nonce) {
4
        this.from = from;
5
        this.to = to;
6
        this.amount = amount;
7
        this.nonce = nonce;
8
    }
9

10
    // 2. 计算交易哈希
11
    hash() {
12
        const data = JSON.stringify({
13
            from: this.from,
14
            to: this.to,
15
            amount: this.amount,
16
            nonce: this.nonce
17
        });
18
        return crypto.createHash('sha256').update(data).digest();
19
    }
20

21
    // 3. 签名交易
22
    sign(privateKey) {
23
        const hash = this.hash();
24
        const signature = secp256k1.ecdsaSign(hash, privateKey);
25
        this.signature = signature.signature;
26
        return this;
27
    }
28

29
    // 4. 验证交易
30
    verify() {
31
        if (!this.signature) return false;
32

33
        const hash = this.hash();
34
        return secp256k1.ecdsaVerify(this.signature, hash, this.from);
35
    }
36
}

1
// 1. 多重签名钱包
2
class MultiSigWallet {
3
    constructor(publicKeys, threshold) {
4
        this.publicKeys = publicKeys;
5
        this.threshold = threshold;
6
        this.signatures = new Map();
7
    }
8

9
    // 2. 添加签名
10
    addSignature(signer, signature) {
11
        if (!this.publicKeys.includes(signer)) {
12
            throw new Error('Invalid signer');
13
        }
14

15
        this.signatures.set(signer, signature);
16
    }
17

18
    // 3. 验证签名
19
    verify(message) {
20
        const validSignatures = [];
21

22
        for (const [signer, signature] of this.signatures) {
23
            if (secp256k1.ecdsaVerify(signature, message, signer)) {
24
                validSignatures.push(signer);
25
            }
26
        }
27

28
        return validSignatures.length >= this.threshold;
29
    }
30
}

1
const crypto = require('crypto');
2

3
// 1. AES加密
4
function aesEncrypt(data, key) {
5
    const cipher = crypto.createCipher('aes-256-cbc', key);
6
    let encrypted = cipher.update(data, 'utf8', 'hex');
7
    encrypted += cipher.final('hex');
8
    return encrypted;
9
}
10

11
// 2. AES解密
12
function aesDecrypt(encryptedData, key) {
13
    const decipher = crypto.createDecipher('aes-256-cbc', key);
14
    let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
15
    decrypted += decipher.final('utf8');
16
    return decrypted;
17
}
18

19
// 3. 使用示例
20
const data = "Sensitive data";
21
const key = "my-secret-key";
22
const encrypted = aesEncrypt(data, key);
23
const decrypted = aesDecrypt(encrypted, key);
24
console.log("Original:", data);
25
console.log("Decrypted:", decrypted);

1
// 1. 私钥加密存储
2
class SecureKeyStore {
3
    constructor(password) {
4
        this.password = password;
5
        this.encryptedKeys = new Map();
6
    }
7

8
    // 2. 加密私钥
9
    encryptPrivateKey(privateKey) {
10
        const key = crypto.scryptSync(this.password, 'salt', 32);
11
        const cipher = crypto.createCipher('aes-256-cbc', key);
12
        let encrypted = cipher.update(privateKey, 'utf8', 'hex');
13
        encrypted += cipher.final('hex');
14
        return encrypted;
15
    }
16

17
    // 3. 解密私钥
18
    decryptPrivateKey(encryptedKey) {
19
        const key = crypto.scryptSync(this.password, 'salt', 32);
20
        const decipher = crypto.createDecipher('aes-256-cbc', key);
21
        let decrypted = decipher.update(encryptedKey, 'hex', 'utf8');
22
        decrypted += decipher.final('utf8');
23
        return decrypted;
24
    }
25
}

1
const crypto = require('crypto');
2

3
// 1. 生成RSA密钥对
4
function generateRSAKeyPair() {
5
    const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
6
        modulusLength: 2048,
7
        publicKeyEncoding: {
8
            type: 'spki',
9
            format: 'pem'
10
        },
11
        privateKeyEncoding: {
12
            type: 'pkcs8',
13
            format: 'pem'
14
        }
15
    });
16

17
    return { publicKey, privateKey };
18
}
19

20
// 2. RSA加密
21
function rsaEncrypt(data, publicKey) {
22
    const encrypted = crypto.publicEncrypt(publicKey, Buffer.from(data));
23
    return encrypted.toString('hex');
24
}
25

26
// 3. RSA解密
27
function rsaDecrypt(encryptedData, privateKey) {
28
    const decrypted = crypto.privateDecrypt(privateKey, Buffer.from(encryptedData, 'hex'));
29
    return decrypted.toString('utf8');
30
}

1
// 1. 简单零知识证明示例
2
class SimpleZKProof {
3
    constructor() {
4
        this.secret = Math.floor(Math.random() * 1000);
5
        this.publicValue = this.secret * this.secret;
6
    }
7

8
    // 2. 生成证明
9
    generateProof() {
10
        const r = Math.floor(Math.random() * 1000);
11
        const commitment = r * r;
12
        const challenge = Math.floor(Math.random() * 2);
13

14
        let response;
15
        if (challenge === 0) {
16
            response = r;
17
        } else {
18
            response = r + this.secret;
19
        }
20

21
        return { commitment, challenge, response };
22
    }
23

24
    // 3. 验证证明
25
    verifyProof(proof) {
26
        const { commitment, challenge, response } = proof;
27

28
        if (challenge === 0) {
29
            return response * response === commitment;
30
        } else {
31
            return (response * response - this.publicValue) === commitment;
32
        }
33
    }
34
}

1
// 1. 隐私交易证明
2
class PrivacyTransactionProof {
3
    constructor() {
4
        this.circuit = new SimpleZKProof();
5
    }
6

7
    // 2. 生成交易证明
8
    generateTransactionProof(transaction) {
9
        const proof = this.circuit.generateProof();
10
        return {
11
            transaction,
12
            proof,
13
            publicSignals: [transaction.amount, transaction.to]
14
        };
15
    }
16

17
    // 3. 验证交易证明
18
    verifyTransactionProof(proofData) {
19
        const { proof, publicSignals } = proofData;
20
        return this.circuit.verifyProof(proof);
21
    }
22
}

1
// 1. Diffie-Hellman密钥交换
2
class DiffieHellman {
3
    constructor(prime, generator) {
4
        this.prime = BigInt(prime);
5
        this.generator = BigInt(generator);
6
    }
7

8
    // 2. 生成私钥
9
    generatePrivateKey() {
10
        return BigInt(Math.floor(Math.random() * Number(this.prime)));
11
    }
12

13
    // 3. 生成公钥
14
    generatePublicKey(privateKey) {
15
        return this.modPow(this.generator, privateKey);
16
    }
17

18
    // 4. 计算共享密钥
19
    computeSharedSecret(privateKey, otherPublicKey) {
20
        return this.modPow(BigInt(otherPublicKey), privateKey);
21
    }
22

23
    // 5. 模幂运算
24
    modPow(base, exponent) {
25
        let result = 1n;
26
        base = base % this.prime;
27

28
        while (exponent > 0n) {
29
            if (exponent % 2n === 1n) {
30
                result = (result * base) % this.prime;
31
            }
32
            exponent = exponent >> 1n;
33
            base = (base * base) % this.prime;
34
        }
35

36
        return result;
37
    }
38
}

1
// 1. 安全通信
2
class SecureCommunication {
3
    constructor() {
4
        this.dh = new DiffieHellman(23, 5); // 使用小素数示例
5
        this.privateKey = this.dh.generatePrivateKey();
6
        this.publicKey = this.dh.generatePublicKey(this.privateKey);
7
    }
8

9
    // 2. 建立安全通道
10
    establishSecureChannel(otherPublicKey) {
11
        const sharedSecret = this.dh.computeSharedSecret(this.privateKey, otherPublicKey);
12
        return sharedSecret;
13
    }
14

15
    // 3. 加密消息
16
    encryptMessage(message, sharedSecret) {
17
        const key = sharedSecret.toString();
18
        return aesEncrypt(message, key);
19
    }
20

21
    // 4. 解密消息
22
    decryptMessage(encryptedMessage, sharedSecret) {
23
        const key = sharedSecret.toString();
24
        return aesDecrypt(encryptedMessage, key);
25
    }
26
}

1
// 1. 数字证书
2
class DigitalCertificate {
3
    constructor(subject, issuer, publicKey, validityPeriod) {
4
        this.subject = subject;
5
        this.issuer = issuer;
6
        this.publicKey = publicKey;
7
        this.validityPeriod = validityPeriod;
8
        this.issuedAt = new Date();
9
        this.expiresAt = new Date(this.issuedAt.getTime() + validityPeriod);
10
    }
11

12
    // 2. 签名证书
13
    sign(privateKey) {
14
        const data = JSON.stringify({
15
            subject: this.subject,
16
            issuer: this.issuer,
17
            publicKey: this.publicKey,
18
            issuedAt: this.issuedAt,
19
            expiresAt: this.expiresAt
20
        });
21

22
        this.signature = signMessage(data, privateKey);
23
        return this;
24
    }
25

26
    // 3. 验证证书
27
    verify(issuerPublicKey) {
28
        if (new Date() > this.expiresAt) {
29
            return false;
30
        }
31

32
        const data = JSON.stringify({
33
            subject: this.subject,
34
            issuer: this.issuer,
35
            publicKey: this.publicKey,
36
            issuedAt: this.issuedAt,
37
            expiresAt: this.expiresAt
38
        });
39

40
        return verifySignature(data, this.signature, issuerPublicKey);
41
    }
42
}

1
// 1. 防侧信道攻击
2
class SideChannelResistant {
3
    constructor() {
4
        this.constantTime = true;
5
    }
6

7
    // 2. 常数时间比较
8
    constantTimeCompare(a, b) {
9
        if (a.length !== b.length) {
10
            return false;
11
        }
12

13
        let result = 0;
14
        for (let i = 0; i < a.length; i++) {
15
            result |= a[i] ^ b[i];
16
        }
17

18
        return result === 0;
19
    }
20

21
    // 3. 常数时间选择
22
    constantTimeSelect(condition, a, b) {
23
        const mask = condition ? 0xFFFFFFFF : 0x00000000;
24
        return (a & mask) | (b & ~mask);
25
    }
26
}

1
// 1. 防时序攻击
2
class TimingAttackResistant {
3
    constructor() {
4
        this.minExecutionTime = 100; // 最小执行时间（毫秒）
5
    }
6

7
    // 2. 固定时间执行
8
    async fixedTimeExecution(operation) {
9
        const startTime = Date.now();
10
        const result = await operation();
11
        const executionTime = Date.now() - startTime;
12

13
        if (executionTime < this.minExecutionTime) {
14
            await this.delay(this.minExecutionTime - executionTime);
15
        }
16

17
        return result;
18
    }
19

20
    // 3. 延迟函数
21
    delay(ms) {
22
        return new Promise(resolve => setTimeout(resolve, ms));
23
    }
24
}

1
// 1. 安全密钥管理
2
class SecureKeyManagement {
3
    constructor() {
4
        this.keys = new Map();
5
        this.encryptionKey = this.generateEncryptionKey();
6
    }
7

8
    // 2. 生成加密密钥
9
    generateEncryptionKey() {
10
        return crypto.randomBytes(32);
11
    }
12

13
    // 3. 存储密钥
14
    storeKey(keyId, privateKey) {
15
        const encrypted = this.encryptPrivateKey(privateKey);
16
        this.keys.set(keyId, encrypted);
17
    }
18

19
    // 4. 检索密钥
20
    retrieveKey(keyId) {
21
        const encrypted = this.keys.get(keyId);
22
        if (!encrypted) {
23
            throw new Error('Key not found');
24
        }
25
        return this.decryptPrivateKey(encrypted);
26
    }
27

28
    // 5. 加密私钥
29
    encryptPrivateKey(privateKey) {
30
        const cipher = crypto.createCipher('aes-256-cbc', this.encryptionKey);
31
        let encrypted = cipher.update(privateKey, 'utf8', 'hex');
32
        encrypted += cipher.final('hex');
33
        return encrypted;
34
    }
35

36
    // 6. 解密私钥
37
    decryptPrivateKey(encryptedKey) {
38
        const decipher = crypto.createDecipher('aes-256-cbc', this.encryptionKey);
39
        let decrypted = decipher.update(encryptedKey, 'hex', 'utf8');
40
        decrypted += decipher.final('utf8');
41
        return decrypted;
42
    }
43
}

1
// 1. 安全随机数生成
2
class SecureRandomGenerator {
3
    constructor() {
4
        this.entropyPool = [];
5
        this.minEntropy = 256; // 最小熵值
6
    }
7

8
    // 2. 添加熵
9
    addEntropy(data) {
10
        this.entropyPool.push(data);
11
    }
12

13
    // 3. 生成随机数
14
    generateRandom(length) {
15
        if (this.entropyPool.length < this.minEntropy) {
16
            throw new Error('Insufficient entropy');
17
        }
18

19
        const random = crypto.randomBytes(length);
20
        this.entropyPool = []; // 清空熵池
21
        return random;
22
    }
23

24
    // 4. 生成随机整数
25
    generateRandomInt(min, max) {
26
        const random = this.generateRandom(4);
27
        const value = random.readUInt32BE(0);
28
        return min + (value % (max - min + 1));
29
    }
30
}

1
// 1. 快速幂运算
2
function fastModPow(base, exponent, modulus) {
3
    let result = 1n;
4
    base = base % modulus;
5

6
    while (exponent > 0n) {
7
        if (exponent % 2n === 1n) {
8
            result = (result * base) % modulus;
9
        }
10
        exponent = exponent >> 1n;
11
        base = (base * base) % modulus;
12
    }
13

14
    return result;
15
}
16

17
// 2. 预计算表
18
class PrecomputedTable {
19
    constructor(base, modulus, maxExponent) {
20
        this.base = base;
21
        this.modulus = modulus;
22
        this.table = new Map();
23
        this.precompute(maxExponent);
24
    }
25

26
    precompute(maxExponent) {
27
        for (let i = 0; i <= maxExponent; i++) {
28
            this.table.set(i, fastModPow(this.base, BigInt(i), this.modulus));
29
        }
30
    }
31

32
    lookup(exponent) {
33
        return this.table.get(Number(exponent));
34
    }
35
}

1
// 1. 批量签名
2
class BatchSigner {
3
    constructor() {
4
        this.pendingSignatures = [];
5
    }
6

7
    // 2. 添加签名任务
8
    addSignature(message, privateKey) {
9
        this.pendingSignatures.push({ message, privateKey });
10
    }
11

12
    // 3. 批量签名
13
    async batchSign() {
14
        const signatures = await Promise.all(
15
            this.pendingSignatures.map(({ message, privateKey }) =>
16
                signMessage(message, privateKey)
17
            )
18
        );
19

20
        this.pendingSignatures = [];
21
        return signatures;
22
    }
23
}

1
// 1. 对象池
2
class ObjectPool {
3
    constructor(createFn, resetFn, maxSize = 100) {
4
        this.createFn = createFn;
5
        this.resetFn = resetFn;
6
        this.maxSize = maxSize;
7
        this.pool = [];
8
    }
9

10
    // 2. 获取对象
11
    acquire() {
12
        if (this.pool.length > 0) {
13
            return this.pool.pop();
14
        }
15
        return this.createFn();
16
    }
17

18
    // 3. 释放对象
19
    release(obj) {
20
        if (this.pool.length < this.maxSize) {
21
            this.resetFn(obj);
22
            this.pool.push(obj);
23
        }
24
    }
25
}
26

27
// 4. 使用示例
28
const keyPool = new ObjectPool(
29
    () => new Array(32), // 创建函数
30
    (arr) => arr.fill(0), // 重置函数
31
    50 // 最大池大小
32
);

1
describe('Cryptography', () => {
2
    describe('Hash Functions', () => {
3
        it('should generate consistent hashes', () => {
4
            const data = 'test data';
5
            const hash1 = sha256(data);
6
            const hash2 = sha256(data);
7
            expect(hash1).toBe(hash2);
8
        });
9

10
        it('should generate different hashes for different data', () => {
11
            const hash1 = sha256('data1');
12
            const hash2 = sha256('data2');
13
            expect(hash1).not.toBe(hash2);
14
        });
15
    });
16

17
    describe('Digital Signatures', () => {
18
        it('should sign and verify messages', () => {
19
            const { privateKey, publicKey } = generateKeyPair();
20
            const message = 'test message';
21
            const signature = signMessage(message, privateKey);
22
            const isValid = verifySignature(message, signature, publicKey);
23
            expect(isValid).toBe(true);
24
        });
25

26
        it('should reject invalid signatures', () => {
27
            const { privateKey, publicKey } = generateKeyPair();
28
            const message = 'test message';
29
            const signature = signMessage(message, privateKey);
30
            const isValid = verifySignature('different message', signature, publicKey);
31
            expect(isValid).toBe(false);
32
        });
33
    });
34
});

1
describe('Security', () => {
2
    it('should prevent timing attacks', async () => {
3
        const timingResistant = new TimingAttackResistant();
4
        const startTime = Date.now();
5

6
        await timingResistant.fixedTimeExecution(() => {
7
            // 快速操作
8
            return 'result';
9
        });
10

11
        const executionTime = Date.now() - startTime;
12
        expect(executionTime).toBeGreaterThanOrEqual(100);
13
    });
14

15
    it('should generate secure random numbers', () => {
16
        const generator = new SecureRandomGenerator();
17
        generator.addEntropy('entropy1');
18
        generator.addEntropy('entropy2');
19

20
        const random1 = generator.generateRandom(32);
21
        const random2 = generator.generateRandom(32);
22

23
        expect(random1).not.toEqual(random2);
24
        expect(random1.length).toBe(32);
25
    });
26
});

1
describe('End-to-End', () => {
2
    it('should complete full transaction flow', async () => {
3
        // 1. 生成密钥对
4
        const { privateKey, publicKey } = generateKeyPair();
5

6
        // 2. 创建交易
7
        const transaction = new Transaction(
8
            publicKey,
9
            '0x...',
10
            1000,
11
            0
12
        );
13

14
        // 3. 签名交易
15
        transaction.sign(privateKey);
16

17
        // 4. 验证交易
18
        const isValid = transaction.verify();
19
        expect(isValid).toBe(true);
20
    });
21
});