Compressed public key to uncompressed

[NotStatilko]

Hello! How can I get the full public key from compressed? Couldn't find an exact answer.

For example from this X point (secp256k1)

0329908081367423272746086114569421970207888665320998202915346633185016778189308

Thanks!

[tomato42]

It's not supported yet, see proposed PR #118

duplicate of #1

[tomato42]

regarding the "confused" emoji: see PR #118, check if it implements what you need

I don't know what encoding you want the public key in, but the hex encoding can be achieved like this:

from ecdsa.keys import VerifyingKey
from ecdsa.curves import SECP256k1
key = # hex encoding of the key 
vk = VerifyingKey.from_string(bytes.fromhex(key), curve=SECP256k1)
pub_key = vk.to_string('uncompressed')
print(pub_key.hex())

(it won't work with your example key as it's incorrect size)

[NotStatilko]

Thanks for your quick reply

I tried run this code with compressed public key

03F028892BAD7ED57D2FB57BF33081D5CFCF6F9ED3D3D7F159C2E2FFF579DC341A

But it throws this error:

python3.7/site-packages/ecdsa/keys.py", line 37, in from_string
                                       (len(string), curve.verifying_key_length)
           AssertionError: (33, 64)

Code:

from ecdsa.keys import VerifyingKey
from ecdsa.curves import SECP256k1

key = '03F028892BAD7ED57D2FB57BF33081D5CFCF6F9ED3D3D7F159C2E2FFF579DC341A'
vk = VerifyingKey.from_string(bytes.fromhex(key), curve=SECP256k1)
pub_key = vk.to_string('uncompressed')

print(pub_key.hex())

Do you know what the problem is?

[tomato42]

AssertionError: (33, 64)

Do you know what the problem is?

you're not using the code from the PR #118

[NotStatilko]

Thank you very much! It's really helps me a lot!

[NotStatilko]

If anyone need, here is my code

from ecdsa.numbertheory import square_root_mod_prime
from ecdsa.util import string_to_number, number_to_string
from ecdsa.ellipticcurve import Point
from ecdsa.curves import SECP256k1
from ecdsa import ecdsa

class MalformedPoint(Exception):
    pass

def compress(x: int, y: int) -> bytes:
    e_x = number_to_string(x,SECP256k1.order) #encoded x
    return (b'\x03' + e_x) if y % 2 else (b'\x02' + e_x)


def uncompress(string: bytes, curve=SECP256k1) -> Point:
    if string[:1] not in (b'\x02', b'\x03'):
        raise MalformedPoint("Malformed compressed point encoding")
            
    is_even = string[:1] == b'\x02'
    x = string_to_number(string[1:])
    order = curve.order
    p = curve.curve.p()
    alpha = (pow(x, 3, p) + (curve.curve.a() * x) + curve.curve.b()) % p
    try:
        beta = square_root_mod_prime(alpha, p)
    except SquareRootError as e:
        raise MalformedPoint(
            "Encoding does not correspond to a point on curve", e
        )                                 
    if is_even == bool(beta & 1):
        y = p - beta
    else:
        y = beta
    if not ecdsa.point_is_valid(curve.generator, x, y):
        raise MalformedPoint("Point does not lie on curve")
    return Point(curve.curve, x, y, order)