Skip to content

Signing

Keypair

Source code in pyjamaz/signing.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
class Keypair:

    private_key: bytes
    public_key: bytes

    @classmethod
    def from_seed(cls, seed: bytes) -> 'Keypair':
        raise NotImplementedError

    @classmethod
    def from_mnemonic(cls: Type[T], mnemonic: str) -> T:
        """
        Create a Keypair from given mnemonic

        Parameters
        ----------
        mnemonic: string containing 12 or 24 word mnemonic

        Returns
        -------
        Ed25519Keypair
        """
        seed_array = bip39_to_mini_secret(mnemonic, "", 'en')
        return cls.from_seed(bytearray(seed_array))

    @classmethod
    def from_public_key(cls: Type[T], public_key: bytes) -> T:
        return cls(private_key=bytes(32), public_key=bytes(public_key))

    @classmethod
    def from_private_key(cls: Type[T], private_key: bytes) -> T:
        raise NotImplementedError

    def sign(self, data: bytes) -> bytes:
        raise NotImplementedError

    def verify(self, data: bytes, signature: bytes) -> bool:
        raise NotImplementedError

from_mnemonic(mnemonic: str) -> T classmethod

Create a Keypair from given mnemonic

Parameters:

Name Type Description Default
mnemonic str
required

Returns:

Type Description
Ed25519Keypair
Source code in pyjamaz/signing.py 
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
@classmethod
def from_mnemonic(cls: Type[T], mnemonic: str) -> T:
    """
    Create a Keypair from given mnemonic

    Parameters
    ----------
    mnemonic: string containing 12 or 24 word mnemonic

    Returns
    -------
    Ed25519Keypair
    """
    seed_array = bip39_to_mini_secret(mnemonic, "", 'en')
    return cls.from_seed(bytearray(seed_array))

BandersnatchKeypair dataclass

Bases: Serializable, Keypair

Source code in pyjamaz/signing.py 
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
@dataclass
class BandersnatchKeypair(Serializable, Keypair):
    private_key: bytes = field(metadata={'codec': H256})
    public_key: bytes = field(metadata={'codec': H256})

    @classmethod
    def from_seed(cls: Type[T], seed: bytes) -> T:
        """
        Creates a Keypair from seed bytes.

        Parameters
        ----------
        seed

        Returns
        -------
        Ed25519Keypair
        """
        private_key = bandersnatch_vrfs.secret_from_seed(seed)
        public_key = bandersnatch_vrfs.public_from_secret(private_key)
        return cls(private_key=private_key, public_key=public_key)

    @classmethod
    def from_public_key(cls: Type[T], public_key: bytes) -> T:
        return cls(private_key=bytes(32), public_key=public_key)

    def vrf_output(self, vrf_input: bytes) -> bytes:
        return bandersnatch_vrfs.vrf_output(self.private_key, vrf_input)

    def ietf_vrf_sign(self, vrf_input: bytes, aux_data: bytes) -> bytes:
        return bandersnatch_vrfs.ietf_vrf_sign(self.private_key, vrf_input, aux_data)

    def ietf_vrf_verify(self, vrf_input: bytes, aux_data: bytes, signature: bytes) -> bytes:
        return bandersnatch_vrfs.ietf_vrf_verify(
            bytes(self.public_key),
            vrf_input,
            aux_data,
            bytes(signature)
        )

from_seed(seed: bytes) -> T classmethod

Creates a Keypair from seed bytes.

Parameters:

Name Type Description Default
seed bytes
required

Returns:

Type Description
Ed25519Keypair
Source code in pyjamaz/signing.py 
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
@classmethod
def from_seed(cls: Type[T], seed: bytes) -> T:
    """
    Creates a Keypair from seed bytes.

    Parameters
    ----------
    seed

    Returns
    -------
    Ed25519Keypair
    """
    private_key = bandersnatch_vrfs.secret_from_seed(seed)
    public_key = bandersnatch_vrfs.public_from_secret(private_key)
    return cls(private_key=private_key, public_key=public_key)

Ed25519Keypair dataclass

Bases: Serializable, Keypair

Allows generation of Keypairs from a variety of input combination, such as a public/private key combination, mnemonic or URI containing soft and hard derivation paths. With these Keypairs data can be signed and verified

Parameters:

Name Type Description Default
private_key bytes
required
public_key bytes
required
Source code in pyjamaz/signing.py 
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
@dataclass
class Ed25519Keypair(Serializable, Keypair):
    """
    Allows generation of Keypairs from a variety of input combination, such as a public/private key combination,
    mnemonic or URI containing soft and hard derivation paths. With these Keypairs data can be signed and verified

    Parameters
    ----------
    private_key
    public_key
    """
    private_key: bytes = field(metadata={'codec': H256})
    public_key: bytes = field(metadata={'codec': H256})

    @classmethod
    def from_seed(cls: Type[T], seed: bytes) -> T:
        """
        Creates a Keypair from seed bytes.

        Parameters
        ----------
        seed

        Returns
        -------
        Ed25519Keypair
        """
        private_key, public_key = ed25519_zebra.ed_from_seed(seed)
        return cls(private_key=private_key, public_key=public_key)

    @classmethod
    def from_private_key(cls: Type[T], private_key: bytes) -> T:
        public_key = ed25519_zebra.ed_public_from_secret(private_key)
        return cls(private_key=private_key, public_key=public_key)

    def sign(self, data: bytes) -> bytes:
        """
        Creates a signature for given data

        Parameters
        ----------
        data

        Returns
        -------
        bytes
        """
        # if self.private_key == bytes(32):
        #     raise ValueError("Cannot sign, private key is not set")

        return ed25519_zebra.ed_sign(self.private_key, data)

    def verify(self, data: bytes, signature: bytes) -> bool:
        """
        Verifies data with specified signature

        Parameters
        ----------
        data
        signature

        Returns
        -------
        bool
        """
        return ed25519_zebra.ed_verify(signature, data, self.public_key)

from_seed(seed: bytes) -> T classmethod

Creates a Keypair from seed bytes.

Parameters:

Name Type Description Default
seed bytes
required

Returns:

Type Description
Ed25519Keypair
Source code in pyjamaz/signing.py 
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
@classmethod
def from_seed(cls: Type[T], seed: bytes) -> T:
    """
    Creates a Keypair from seed bytes.

    Parameters
    ----------
    seed

    Returns
    -------
    Ed25519Keypair
    """
    private_key, public_key = ed25519_zebra.ed_from_seed(seed)
    return cls(private_key=private_key, public_key=public_key)

sign(data: bytes) -> bytes

Creates a signature for given data

Parameters:

Name Type Description Default
data bytes
required

Returns:

Type Description
bytes
Source code in pyjamaz/signing.py 
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
def sign(self, data: bytes) -> bytes:
    """
    Creates a signature for given data

    Parameters
    ----------
    data

    Returns
    -------
    bytes
    """
    # if self.private_key == bytes(32):
    #     raise ValueError("Cannot sign, private key is not set")

    return ed25519_zebra.ed_sign(self.private_key, data)

verify(data: bytes, signature: bytes) -> bool

Verifies data with specified signature

Parameters:

Name Type Description Default
data bytes
required
signature bytes
required

Returns:

Type Description
bool
Source code in pyjamaz/signing.py 
148
149
150
151
152
153
154
155
156
157
158
159
160
161
def verify(self, data: bytes, signature: bytes) -> bool:
    """
    Verifies data with specified signature

    Parameters
    ----------
    data
    signature

    Returns
    -------
    bool
    """
    return ed25519_zebra.ed_verify(signature, data, self.public_key)