9776974779

Committed 03 Jul 2024 11:26AM UTC coverage: 71.594% (+0.1%) from 71.496%

Build # 9776974779

Build Type

Pull #243

github

Committed by

web-flow

Commit Message

Merge 6c8643865 into a22d3dd11

Pull Request Pull Request #243: fix(Castor): createPrismDID and resolveDID key id conflicts

Run Details

1356 of 2083 branches covered (65.1%)

Branch coverage included in aggregate %.

20 of 21 new or added lines in 4 files covered. (95.24%)

3 existing lines in 1 file now uncovered.

2722 of 3613 relevant lines covered (75.34%)

22.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.54

/src/domain/utils/DER.ts

/**
 * Fix around normalising DER signatures into their raw representation
 * @param derSignature Buffer
 * @returns Buffer
 */
export function normaliseDER(derSignature: Buffer): Buffer {
    // Ensure the DER signature starts with the correct sequence header
    if (derSignature[0] !== 0x30) {
        return derSignature;
    }
    // Get the length of the sequence
    let seqLength = derSignature[1];
    let offset = 2;
    if (seqLength & 0x80) {
        const lengthBytes = seqLength & 0x7f;
        seqLength = 0;
        for (let i = 0; i < lengthBytes; i++) {
            seqLength = (seqLength << 8) | derSignature[offset++];
        }
    }

    if (derSignature[offset++] !== 0x02) {
        throw new Error('Invalid DER signature: expected integer for r');
    }

    const rLength = derSignature[offset++];
    let r = derSignature.slice(offset, offset + rLength);
    offset += rLength;

    // Extract s value
    if (derSignature[offset++] !== 0x02) {
        throw new Error('Invalid DER signature: expected integer for s');
    }
    const sLength = derSignature[offset++];
    let s = derSignature.slice(offset, offset + sLength);

    // Normalize r and s to 32 bytes
    if (r.length > 32) {
        r = r.slice(-32); // truncate if r is longer than 32 bytes
    } else if (r.length < 32) {
        const paddedR = Buffer.alloc(32);
        r.copy(paddedR, 32 - r.length);
        r = paddedR; // left pad with zeros if r is shorter than 32 bytes
    }

    if (s.length > 32) {
        s = s.slice(-32); // truncate if s is longer than 32 bytes
    } else if (s.length < 32) {
        const paddedS = Buffer.alloc(32);
        s.copy(paddedS, 32 - s.length);
        s = paddedS; // left pad with zeros if s is shorter than 32 bytes
    }

    // Concatenate r and s to form the raw signature
    return Buffer.concat([r, s]);
}

/**
 * Converts a raw signature to DER format
 * @param rawSignature Buffer
 * @returns Buffer
 */
export function rawToDER(rawSignature: Buffer): Buffer {
    if (rawSignature.length !== 64) {
        return rawSignature;
    }

    let r = rawSignature.slice(0, 32);
    let s = rawSignature.slice(32, 64);

    r = removeLeadingZeros(r);
    s = removeLeadingZeros(s);

    // Ensure the integers are positive by prepending a zero byte if necessary
    if (r[0] & 0x80) {
        r = Buffer.concat([Buffer.from([0x00]), r]);
    }
    if (s[0] & 0x80) {
        s = Buffer.concat([Buffer.from([0x00]), s]);
    }

    const rLen = r.length;
    const sLen = s.length;

    const derSignature = Buffer.concat([
        Buffer.from([0x30, rLen + sLen + 4]), // Sequence tag and length
        Buffer.from([0x02, rLen]), // Integer tag and length for r
        r,
        Buffer.from([0x02, sLen]), // Integer tag and length for s
        s
    ]);

    return derSignature;
}

/**
 * Remove leading zeros from a buffer
 * @param buffer Buffer
 * @returns Buffer
 */
function removeLeadingZeros(buffer: Buffer): Buffer {
    const arr = Array.from(buffer)
    let i = 0;
    while (i < arr.length - 1 && arr[i] === 0) {
        i++;
    }
    return Buffer.from(arr.slice(i));
}

1	/**
2	* Fix around normalising DER signatures into their raw representation
3	* @param derSignature Buffer
4	* @returns Buffer
5	*/
6	export function normaliseDER(derSignature: Buffer): Buffer {
7	// Ensure the DER signature starts with the correct sequence header
8	if (derSignature[0] !== 0x30) {	53!
9	return derSignature;	×
10	}
11	// Get the length of the sequence
12	let seqLength = derSignature[1];	53✔
13	let offset = 2;	53✔
14	if (seqLength & 0x80) {	53!
15	const lengthBytes = seqLength & 0x7f;	×
16	seqLength = 0;	×
17	for (let i = 0; i < lengthBytes; i++) {	×
18	seqLength = (seqLength << 8) \| derSignature[offset++];	×
19	}
20	}
21
22	if (derSignature[offset++] !== 0x02) {	53!
23	throw new Error('Invalid DER signature: expected integer for r');	×
24	}
25
26	const rLength = derSignature[offset++];	53✔
27	let r = derSignature.slice(offset, offset + rLength);	53✔
28	offset += rLength;	53✔
29
30	// Extract s value
31	if (derSignature[offset++] !== 0x02) {	53!
32	throw new Error('Invalid DER signature: expected integer for s');	×
33	}
34	const sLength = derSignature[offset++];	53✔
35	let s = derSignature.slice(offset, offset + sLength);	53✔
36
37	// Normalize r and s to 32 bytes
38	if (r.length > 32) {	53✔
39	r = r.slice(-32); // truncate if r is longer than 32 bytes	15✔
40	} else if (r.length < 32) {	38✔
41	const paddedR = Buffer.alloc(32);	1✔
42	r.copy(paddedR, 32 - r.length);	1✔
43	r = paddedR; // left pad with zeros if r is shorter than 32 bytes	1✔
44	}
45
46	if (s.length > 32) {	53!
47	s = s.slice(-32); // truncate if s is longer than 32 bytes	×
48	} else if (s.length < 32) {	53!
UNCOV 49	const paddedS = Buffer.alloc(32);	×
UNCOV 50	s.copy(paddedS, 32 - s.length);	×
UNCOV 51	s = paddedS; // left pad with zeros if s is shorter than 32 bytes	×
52	}
53
54	// Concatenate r and s to form the raw signature
55	return Buffer.concat([r, s]);	53✔
56	}
57
58	/**
59	* Converts a raw signature to DER format
60	* @param rawSignature Buffer
61	* @returns Buffer
62	*/
63	export function rawToDER(rawSignature: Buffer): Buffer {
64	if (rawSignature.length !== 64) {	×
65	return rawSignature;	×
66	}
67
68	let r = rawSignature.slice(0, 32);	×
69	let s = rawSignature.slice(32, 64);	×
70
71	r = removeLeadingZeros(r);	×
72	s = removeLeadingZeros(s);	×
73
74	// Ensure the integers are positive by prepending a zero byte if necessary
75	if (r[0] & 0x80) {	×
76	r = Buffer.concat([Buffer.from([0x00]), r]);	×
77	}
78	if (s[0] & 0x80) {	×
79	s = Buffer.concat([Buffer.from([0x00]), s]);	×
80	}
81
82	const rLen = r.length;	×
83	const sLen = s.length;	×
84
85	const derSignature = Buffer.concat([	×
86	Buffer.from([0x30, rLen + sLen + 4]), // Sequence tag and length
87	Buffer.from([0x02, rLen]), // Integer tag and length for r
88	r,
89	Buffer.from([0x02, sLen]), // Integer tag and length for s
90	s
91	]);
92
93	return derSignature;	×
94	}
95
96	/**
97	* Remove leading zeros from a buffer
98	* @param buffer Buffer
99	* @returns Buffer
100	*/
101	function removeLeadingZeros(buffer: Buffer): Buffer {
102	const arr = Array.from(buffer)	×
103	let i = 0;	×
104	while (i < arr.length - 1 && arr[i] === 0) {	×
105	i++;	×
106	}
107	return Buffer.from(arr.slice(i));	×
108	}

input-output-hk / atala-prism-wallet-sdk-ts / 9776974779

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous