package core:crypto/ecdsa
Source

⌘K
Ctrl+K
or
/

    Types

    Curve ¶
    Source

    Curve :: enum int {
	Invalid, 
	SECP256R1, 
	SECP384R1, 
}
     

    Curve the curve identifier associated with a given Private_Key or Public_Key

    Related Procedures With Parameters
    Related Procedures With Returns

    Private_Key ¶
    Source

    Private_Key :: struct {
	// WARNING: All of the members are to be treated as internal (ie:
	// the Private_Key structure is intended to be opaque).
	_curve:   Curve,
	_impl:    union {
		field_scalarp256r1.Montgomery_Domain_Field_Element, 
		field_scalarp384r1.Montgomery_Domain_Field_Element, 
	},
	_pub_key: Public_Key,
}
     

    Private_Key is an ECDSA private key.

    Related Procedures With Parameters

    Public_Key ¶
    Source

    Public_Key :: struct {
	// WARNING: All of the members are to be treated as internal (ie:
	// the Public_Key structure is intended to be opaque).
	_curve: Curve,
	_impl:  union {
		_weierstrass.Point_p256r1, 
		_weierstrass.Point_p384r1, 
	},
}
     

    Public_Key is an ECDSA public key.

    Related Procedures With Parameters

    Constants

    This section is empty.

    Variables

    CURVE_NAMES ¶
    Source

    CURVE_NAMES: [Curve]string = …
     

    CURVE_NAMES is the Curve to curve name string.

    PRIVATE_KEY_SIZES ¶
    Source

    PRIVATE_KEY_SIZES: [Curve]int = …
     

    PRIVATE_KEY_SIZES is the Curve to private key size in bytes.

    PUBLIC_KEY_SIZES ¶
    Source

    PUBLIC_KEY_SIZES: [Curve]int = …
     

    PUBLIC_KEY_SIZES is the Curve to public key size in bytes.

    RAW_SIGNATURE_SIZES ¶
    Source

    RAW_SIGNATURE_SIZES: [Curve]int = …
     

    RAW_SIGNATURE_SIZES is the Curve to "raw" signature size in bytes.

    Procedures

    curve ¶
    Source

    curve :: proc(k: ^$T) -> Curve {…}
     

    curve returns the Curve used by a Private_Key or Public_Key instance.

    key_size ¶
    Source

    key_size :: proc(k: ^$T) -> int {…}
     

    key_size returns the key size of a Private_Key or Public_Key in bytes.

    private_key_bytes ¶
    Source

    private_key_bytes :: proc(priv_key: ^Private_Key, dst: []u8) {…}
     

    private_key_bytes sets dst to byte-encoding of priv_key.

    private_key_clear ¶
    Source

    private_key_clear :: proc "contextless" (priv_key: ^Private_Key) {…}
     

    private_key_clear clears priv_key to the uninitialized state.

    private_key_equal ¶
    Source

    private_key_equal :: proc(p, q: ^Private_Key) -> bool {…}
     

    private_key_equal returns true iff the private keys are equal, in constant time.

    private_key_generate ¶
    Source

    private_key_generate :: proc(priv_key: ^Private_Key, curve: Curve) -> bool {…}
     

    private_key_generate uses the system entropy source to generate a new Private_Key. This will only fail iff the system entropy source is missing or broken.

    private_key_public_bytes ¶
    Source

    private_key_public_bytes :: proc(priv_key: ^Private_Key, dst: []u8) {…}
     

    private_key_public_bytes sets dst to the byte-encoding of the public key corresponding to priv_key.

    private_key_set ¶
    Source

    private_key_set :: proc(priv_key, src: ^Private_Key) {…}
     

    private_key_set sets priv_key to src.

    private_key_set_bytes ¶
    Source

    private_key_set_bytes :: proc(priv_key: ^Private_Key, curve: Curve, b: []u8) -> bool {…}
     

    private_key_set_bytes decodes a byte-encoded private key, and returns true iff the operation was successful.

    public_key_bytes ¶
    Source

    public_key_bytes :: proc(pub_key: ^Public_Key, dst: []u8) {…}
     

    public_key_bytes sets dst to byte-encoding of pub_key.

    public_key_clear ¶
    Source

    public_key_clear :: proc "contextless" (pub_key: ^Public_Key) {…}
     

    public_key_clear clears pub_key to the uninitialized state.

    public_key_equal ¶
    Source

    public_key_equal :: proc(p, q: ^Public_Key) -> bool {…}
     

    public_key_equal returns true iff the public keys are equal, in constant time.

    public_key_set ¶
    Source

    public_key_set :: proc(pub_key, src: ^Public_Key) {…}
     

    public_key_set sets pub_key to src.

    public_key_set_bytes ¶
    Source

    public_key_set_bytes :: proc(pub_key: ^Public_Key, curve: Curve, b: []u8) -> bool {…}
     

    public_key_set_bytes decodes a byte-encoded public key, and returns true iff the operation was successful.

    public_key_set_priv ¶
    Source

    public_key_set_priv :: proc(pub_key: ^Public_Key, priv_key: ^Private_Key) {…}
     

    public_key_set_priv sets pub_key to the public component of priv_key.

    sign_asn1 ¶
    Source

    sign_asn1 :: proc(priv_key: ^Private_Key, hash_algo: crypto_hash.Algorithm, msg: []u8, allocator: runtime.Allocator, deterministic: bool = !crypto.HAS_RAND_BYTES) -> ([]u8, bool) {…}
     

    sign_asn1 returns the signature by priv_key over msg hased using hash_algo using the signing procedure as specified in SEC 1, Version 2.0, Section 4.1.3. ASN.1 DER requires minimal encoding, and the format is clunky and variable-length so for simplicity we allocate the signature.

    The signature format is ASN1. SEQUECE { r INTEGER, s INTEGER }`.

    sign_raw ¶
    Source

    sign_raw :: proc(priv_key: ^Private_Key, hash_algo: crypto_hash.Algorithm, msg, sig: []u8, deterministic: bool = !crypto.HAS_RAND_BYTES) -> bool {…}
     

    sign_raw writes the signature by priv_key over msg hased using hash_algo to sig, using the signing procedure as specified in SEC 1, Version 2.0, Section 4.1.3.

    The signature format is r | s.

    verify_asn1 ¶
    Source

    verify_asn1 :: proc(pub_key: ^Public_Key, hash_algo: crypto_hash.Algorithm, msg, sig: []u8) -> bool {…}
     

    verify_asn1 returns true iff sig is a valid signature by pub_key over msg, hased using hash_algo, per the verification procedure specifed in SEC 1, Version 2.0, Section 4.1.4.

    The signature format is ASN.1 SEQUENCE { r INTEGER, s INTEGER }.

    verify_raw ¶
    Source

    verify_raw :: proc(pub_key: ^Public_Key, hash_algo: crypto_hash.Algorithm, msg, sig: []u8) -> bool {…}
     

    verify_raw returns true iff sig is a valid signature by pub_key over msg, hased using hash_algo, per the verification procedure specifed in SEC 1, Version 2.0, Section 4.1.4.

    The signature format is r | s.

    Procedure Groups

    This section is empty.

    Source Files

    Generation Information

    Generated with odin version dev-2026-06 (vendor "odin") Windows_amd64 @ 2026-06-02 22:54:54.123552000 +0000 UTC