13832902924

Committed 13 Mar 2025 10:54AM CUT coverage: 99.579% (+0.001%) from 99.578%

Build # 13832902924

Build Type

Pull #359

github

Committed by

web-flow

Commit Message

Merge 658ddc81b into 3c5df06ae

Pull Request Pull Request #359: add release notes for 0.19.1 release

Run Details

2560 of 2571 branches covered (99.57%)

Branch coverage included in aggregate %.

6663 of 6691 relevant lines covered (99.58%)

19.18 hits per line

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

96.92

/src/ecdsa/ssh.py

import binascii
from . import der
from ._compat import compat26_str, int_to_bytes

_SSH_ED25519 = b"ssh-ed25519"
_SK_MAGIC = b"openssh-key-v1\0"
_NONE = b"none"


def _get_key_type(name):
    if name == "Ed25519":
        return _SSH_ED25519
    else:
        raise ValueError("Unsupported key type")


class _Serializer:
    def __init__(self):
        self.bytes = b""

    def put_raw(self, val):
        self.bytes += val

    def put_u32(self, val):
        self.bytes += int_to_bytes(val, length=4, byteorder="big")

    def put_str(self, val):
        self.put_u32(len(val))
        self.bytes += val

    def put_pad(self, blklen=8):
        padlen = blklen - (len(self.bytes) % blklen)
        self.put_raw(bytearray(range(1, 1 + padlen)))

    def encode(self):
        return binascii.b2a_base64(compat26_str(self.bytes))

    def tobytes(self):
        return self.bytes

    def topem(self):
        return der.topem(self.bytes, "OPENSSH PRIVATE KEY")


def serialize_public(name, pub):
    serial = _Serializer()
    ktype = _get_key_type(name)
    serial.put_str(ktype)
    serial.put_str(pub)
    return b" ".join([ktype, serial.encode()])


def serialize_private(name, pub, priv):
    # encode public part
    spub = _Serializer()
    ktype = _get_key_type(name)
    spub.put_str(ktype)
    spub.put_str(pub)

    # encode private part
    spriv = _Serializer()
    checksum = 0
    spriv.put_u32(checksum)
    spriv.put_u32(checksum)
    spriv.put_raw(spub.tobytes())
    spriv.put_str(priv + pub)
    comment = b""
    spriv.put_str(comment)
    spriv.put_pad()

    # top-level structure
    main = _Serializer()
    main.put_raw(_SK_MAGIC)
    ciphername = kdfname = _NONE
    main.put_str(ciphername)
    main.put_str(kdfname)
    nokdf = 0
    main.put_u32(nokdf)
    nkeys = 1
    main.put_u32(nkeys)
    main.put_str(spub.tobytes())
    main.put_str(spriv.tobytes())
    return main.topem()

1	import binascii	20✔
2	from . import der	20✔
3	from ._compat import compat26_str, int_to_bytes	20✔
4
5	_SSH_ED25519 = b"ssh-ed25519"	20✔
6	_SK_MAGIC = b"openssh-key-v1\0"	20✔
7	_NONE = b"none"	20✔
8
9
10	def _get_key_type(name):	20✔
11	if name == "Ed25519":	20!
12	return _SSH_ED25519	20✔
13	else:
14	raise ValueError("Unsupported key type")	×
15
16
17	class _Serializer:	20✔
18	def __init__(self):	20✔
19	self.bytes = b""	20✔
20
21	def put_raw(self, val):	20✔
22	self.bytes += val	20✔
23
24	def put_u32(self, val):	20✔
25	self.bytes += int_to_bytes(val, length=4, byteorder="big")	20✔
26
27	def put_str(self, val):	20✔
28	self.put_u32(len(val))	20✔
29	self.bytes += val	20✔
30
31	def put_pad(self, blklen=8):	20✔
32	padlen = blklen - (len(self.bytes) % blklen)	20✔
33	self.put_raw(bytearray(range(1, 1 + padlen)))	20✔
34
35	def encode(self):	20✔
36	return binascii.b2a_base64(compat26_str(self.bytes))	20✔
37
38	def tobytes(self):	20✔
39	return self.bytes	20✔
40
41	def topem(self):	20✔
42	return der.topem(self.bytes, "OPENSSH PRIVATE KEY")	20✔
43
44
45	def serialize_public(name, pub):	20✔
46	serial = _Serializer()	20✔
47	ktype = _get_key_type(name)	20✔
48	serial.put_str(ktype)	20✔
49	serial.put_str(pub)	20✔
50	return b" ".join([ktype, serial.encode()])	20✔
51
52
53	def serialize_private(name, pub, priv):	20✔
54	# encode public part
55	spub = _Serializer()	20✔
56	ktype = _get_key_type(name)	20✔
57	spub.put_str(ktype)	20✔
58	spub.put_str(pub)	20✔
59
60	# encode private part
61	spriv = _Serializer()	20✔
62	checksum = 0	20✔
63	spriv.put_u32(checksum)	20✔
64	spriv.put_u32(checksum)	20✔
65	spriv.put_raw(spub.tobytes())	20✔
66	spriv.put_str(priv + pub)	20✔
67	comment = b""	20✔
68	spriv.put_str(comment)	20✔
69	spriv.put_pad()	20✔
70
71	# top-level structure
72	main = _Serializer()	20✔
73	main.put_raw(_SK_MAGIC)	20✔
74	ciphername = kdfname = _NONE	20✔
75	main.put_str(ciphername)	20✔
76	main.put_str(kdfname)	20✔
77	nokdf = 0	20✔
78	main.put_u32(nokdf)	20✔
79	nkeys = 1	20✔
80	main.put_u32(nkeys)	20✔
81	main.put_str(spub.tobytes())	20✔
82	main.put_str(spriv.tobytes())	20✔
83	return main.topem()	20✔

tlsfuzzer / python-ecdsa / 13832902924

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