Struct Point

pub struct Point { /* private fields */ }

P-224 elliptic curve point in affine coordinates (x, y)

Represents points on the NIST P-224 curve. The special point at infinity (identity element) is represented with is_identity = true.

Implementations

impl Point

pub fn new_uncompressed(x: &[u8; 28], y: &[u8; 28]) -> Result<Self>

Create a new elliptic curve point from uncompressed coordinates

Validates that the given (x, y) coordinates satisfy the P-224 curve equation: y² = x³ - 3x + b (mod p)

Returns an error if the point is not on the curve.

pub fn identity() -> Self

Create the identity element (point at infinity)

The identity element serves as the additive neutral element for the elliptic curve group operation.

pub fn is_identity(&self) -> bool

Check if this point is the identity element

pub fn x_coordinate_bytes(&self) -> [u8; 28]

Get the x-coordinate as a byte array in big-endian format

pub fn y_coordinate_bytes(&self) -> [u8; 28]

Get the y-coordinate as a byte array in big-endian format

pub fn detect_format(bytes: &[u8]) -> Result<PointFormat>

Detect point format from serialized bytes

Analyzes the leading byte and length to determine the serialization format. Useful for handling points that could be in either compressed or uncompressed form.

Returns

• Ok(PointFormat) indicating the detected format
• Err if the format is invalid or unrecognized

pub fn serialize_uncompressed(&self) -> [u8; 57]

Serialize point to uncompressed format: 0x04 || x || y

The uncompressed point format is:

• 1 byte: 0x04 (uncompressed indicator)
• 28 bytes: x-coordinate (big-endian)
• 28 bytes: y-coordinate (big-endian)

The identity point is represented as all zeros.

pub fn deserialize_uncompressed(bytes: &[u8]) -> Result<Self>

Deserialize point from uncompressed byte format

Supports the standard uncompressed format (0x04 || x || y) and recognizes the all-zeros encoding for the identity element.

pub fn serialize_compressed(&self) -> [u8; 29]

Serialize point to SEC 1 compressed format (0x02/0x03 || x)

The compressed format uses:

• 0x02 prefix if y-coordinate is even
• 0x03 prefix if y-coordinate is odd
• Followed by the x-coordinate in big-endian format

The identity point is encoded as 29 zero bytes for consistency with the uncompressed format.

This format reduces storage/transmission size by ~50% compared to uncompressed points while maintaining full recoverability.

pub fn deserialize_compressed(bytes: &[u8]) -> Result<Self>

Deserialize SEC 1 compressed point

Recovers the full point from compressed format by:

1. Extracting the x-coordinate
2. Computing y² = x³ - 3x + b
3. Finding the square root of y²
4. Selecting the root with correct parity based on the prefix

Errors

Returns an error if:

• The prefix is not 0x02 or 0x03
• The x-coordinate is not in the valid field range
• The x-coordinate corresponds to a non-residue (not on curve)

pub fn add(&self, other: &Self) -> Self

Elliptic curve point addition using the group law

Implements the abelian group operation for P-224 points. Converts to projective coordinates for efficient computation, then converts back to affine form.

pub fn double(&self) -> Self

Elliptic curve point doubling: 2 * self

Computes the sum of a point with itself, which has a more efficient formula than general point addition.

pub fn mul(&self, scalar: &Scalar) -> Result<Self>

Scalar multiplication: compute scalar * self

Uses the binary method (double-and-add) with constant-time execution to prevent timing attacks. Processes scalar bits from most significant to least significant for efficiency.

Returns the identity element if scalar is zero.

Trait Implementations

impl Clone for Point

fn clone(&self) -> Point

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Point

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Point

fn eq(&self, other: &Self) -> bool

Constant-time equality comparison for elliptic curve points

Handles the special case where either point is the identity element. For regular points, compares both x and y coordinates.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.