void sx_async_ecdsa_generate_end(sx_pk_accel *req, sx_op *r,
      sx_op *s)

Finish asynchronous (non-blocking) ECDSA generation. Get the output operands of the ECDSA signature generation and release the reserved resources. The operation on the accelerator must be finished before calling this function.

None

int sx_ecdsa_generate(
        const struct sx_pk_ecurve *curve,
        const sx_op *d,
        const sx_op *k,
        const sx_op *h,
        sx_op *r,
        sx_op *s)

Generate an ECDSA signature on an elliptic curve

The signature generation has the following steps : 1. P(x1, y1) = k * G 2. r = x1 mod n 3. if r == 0 then report failure 4. w = k ^{-1 mod n 5. s = k} -1 * (h + d * r) mod n 6. if s == 0 then report failure 7. signature is the r and s

sx_async_ecdsa_generate_go(), sx_async_ecdsa_generate_end() for an asynchronous version

SX_OK SX_ERR_INVALID_PARAM SX_ERR_NOT_INVERTIBLE SX_ERR_INVALID_SIGNATURE SX_ERR_OUT_OF_RANGE SX_ERR_UNKNOWN_ERROR SX_ERR_BUSY SX_ERR_NOT_IMPLEMENTED SX_ERR_OPERAND_TOO_LARGE SX_ERR_PLATFORM_ERROR SX_ERR_EXPIRED

struct sx_pk_dreq sx_async_ecdsa_verify_go(
      const struct sx_pk_ecurve *curve,
      const sx_op *qx,
      const sx_op *qy,
      const sx_op *r,
      const sx_op *s,
      const sx_op *h)

Asynchronous (non-blocking) ECDSA verification. Start an ECDSA signature verification on the accelerator and return immediately. When the operation finishes on the accelerator, call SX_PK_RELEASE_REQ()

Acquired acceleration request for this application

int sx_ecdsa_verify(
        const struct sx_pk_ecurve *curve,
        const sx_op *qx,
        const sx_op *qy,
        const sx_op *r,
        const sx_op *s,
        const sx_op *h)

Verify ECDSA signature on an elliptic curve

The verification has the following steps: 1. check qx and qy are smaller than q from the domain 2. Check that Q lies on the elliptic curve from the domain 3. Check that r and s are smaller than n 4. w = s ^ -1 mod n 5. u1 = h * w mod n 6. u2 = r * w mod n 7. X(x1, y1) = u1 * G + u2 * Q 8. If X is invalid, then the signature is invalid 9. v = x1 mod n 10. Accept signature if and only if v == r

sx_async_ecdsa_verify_go() for an asynchronous version

SX_OK SX_ERR_INVALID_PARAM SX_ERR_NOT_INVERTIBLE SX_ERR_INVALID_SIGNATURE SX_ERR_OUT_OF_RANGE SX_ERR_UNKNOWN_ERROR SX_ERR_BUSY SX_ERR_NOT_IMPLEMENTED SX_ERR_OPERAND_TOO_LARGE SX_ERR_PLATFORM_ERROR SX_ERR_EXPIRED

struct sx_pk_dreq sx_async_ecp_mult_go(
      const struct sx_pk_ecurve *curve,
      const sx_op *k,
      const sx_op *Px,
      const sx_op *Py)

AAsynchronous EC point multiplication.

Starts an EC point multiplication on the accelerator and return immediately. When the operation finishes on the accelerator, call sx_async_ecp_mult_end()

Acquired acceleration request for this application

void sx_async_ecp_mult_end(
      sx_pk_accel *req,
      sx_op *Rx,
      sx_op *Ry)

Finish asynchronous EC point multiplication.

Get the output operands of the EC point multiplication and release the reserved resources. The operation on the accelerator must be finished before calling this function.

None

int sx_ecp_ptmult(
        const struct sx_pk_ecurve *curve,
        const sx_op *k,
        const sx_op *Px,
        const sx_op *Py,
        sx_op *Rx,
        sx_op *Ry)

Compute point multiplication on an elliptic curve (Rx, Ry) = k * (Px, Py)

sx_async_ecp_mult_go(), sx_async_ecp_mult_end() for an asynchronous versions

SX_OK SX_ERR_NOT_INVERTIBLE SX_ERR_OUT_OF_RANGE SX_ERR_POINT_NOT_ON_CURVE SX_ERR_INVALID_PARAM SX_ERR_UNKNOWN_ERROR SX_ERR_BUSY SX_ERR_NOT_IMPLEMENTED SX_ERR_OPERAND_TOO_LARGE SX_ERR_PLATFORM_ERROR SX_ERR_EXPIRED

struct sx_pk_dreq sx_async_ecp_double_go(
        const struct sx_pk_ecurve *curve,
        const sx_op *px,
        const sx_op *py)

Asynchronous EC point doubling. Starts an EC point doubling on the accelerator and return immediately. When the operation finishes on the accelerator, call sx_async_ecp_double_end()

Acquired acceleration request for this operation

void sx_async_ecp_double_end(
      sx_pk_accel *req,
      sx_op *rx,
      sx_op *ry)

Finish asynchronous EC point doubling. Get the output operands of the EC point doubling and release the reserved resources. The operation on the accelerator must be finished before calling this function

None

int sx_ecp_double(
        const struct sx_pk_ecurve *curve,
        const sx_op *px,
        const sx_op *py,
        sx_op *rx,
        sx_op *ry)

Compute point doubling on an elliptic curve

(Rx, Ry) = 2 * (Px, Py)

sx_async_ecp_double_go(), sx_async_ecp_double_end() for an asynchronous verion

SX_OK SX_ERR_NOT_INVERTIBLE SX_ERR_OUT_OF_RANGE SX_ERR_POINT_NOT_ON_CURVE SX_ERR_INVALID_PARAM SX_ERR_UNKNOWN_ERROR SX_ERR_BUSY SX_ERR_NOT_IMPLEMENTED SX_ERR_OPERAND_TOO_LARGE SX_ERR_PLATFORM_ERROR SX_ERR_EXPIRED

struct sx_pk_dreq sx_async_ec_ptoncurve_go(
      const struct sx_pk_ecurve *curve,
      const sx_op *px,
      const sx_op *py)

Asynchronous (non-blocking) EC point on curve check. Starts an EC point on curve check on the accelerator and return immediately. When the operation finishes on the accelerator, call SX_PK_RELEASE_REQ()

Acquired acceleration request for this operation

int sx_ec_ptoncurve(
        const struct sx_pk_ecurve *curve,
        const sx_op *px,
        const sx_op *py)

Check if the given point is on the given elliptic curve

It succeeds if the following checks pass: For GF(p):

1. px < p
2. py < p
3. py^{2 == px}3 + a * px + b mod p For GF(2^{m), where q = 2}m
4. px < q
5. py < q
6. py^{2 + px * py == px}3 + a * px^2 + b mod q

SX_OK SX_ERR_NOT_INVERTIBLE SX_ERR_OUT_OF_RANGE SX_ERR_POINT_NOT_ON_CURVE SX_ERR_INVALID_PARAM SX_ERR_UNKNOWN_ERROR SX_ERR_BUSY SX_ERR_NOT_IMPLEMENTED SX_ERR_OPERAND_TOO_LARGE SX_ERR_PLATFORM_ERROR SX_ERR_EXPIRED

struct sx_pk_dreq sx_async_ec_pt_decompression_go(
      const struct sx_pk_ecurve *curve,
      const sx_op *x,
      const int y_lsb)

Asynchronous (non-blocking) EC point decompression.

Starts an EC point decompression on the accelerator and return immediately. When the operation finishes on the accelerator, call sx_async_ec_pt_decompression_end()

Acquired acceleration request for this operation

void sx_async_ec_pt_decompression_end(
      sx_pk_accel *req,
      sx_op *y)

Finish asynchronous (non-blocking) EC point decompression. Get the output operand of the EC point decompression and release the reserved resources. The operation on the accelerator must be finished before calling this function.

None

void sx_async_ec_pt_decompression_end(
      sx_pk_accel *req,
      sx_op *y)

Finish asynchronous (non-blocking) EC point decompression. Get the output operand of the EC point decompression and release the reserved resources. The operation on the accelerator must be finished before calling this function.

None

int sx_ec_pt_decompression(
        const struct sx_pk_ecurve *curve,
        const sx_op *x,
        const int y_lsb,
        sx_op *y)

ECC point decompression Recover the y coordinate of a point using x value and LSB of y: 1. y = sqrt(x^3 + a * x + b) 2. if (y & 1) != y_lsb then y = p - y with a and p the curve parameters 3. else return ::SX_ERR_NOT_QUADRATIC_RESIDUE

Point decompression is supported for GF(p) only

SX_OK SX_ERR_NOT_QUADRATIC_RESIDUE SX_ERR_INVALID_PARAM SX_ERR_UNKNOWN_ERROR SX_ERR_BUSY SX_ERR_NOT_IMPLEMENTED SX_ERR_OPERAND_TOO_LARGE SX_ERR_PLATFORM_ERROR SX_ERR_EXPIRED

struct sx_pk_dreq sx_async_ecp_add_go(
      const struct sx_pk_ecurve *curve,
      const sx_op *p1x,
      const sx_op *p1y,
      const sx_op *p2x,
      const sx_op *p2y)

Asynchronous (non-blocking) EC point addition. Start an EC point addition on the accelerator and return immediately. When the operation finishes on the accelerator, call sx_async_ecp_add_end()

Acquired acceleration request for this operation

void sx_async_ecp_add_end(
      sx_pk_accel *req,
      sx_op *rx,
      sx_op *ry)

Finish asynchronous (non-blocking) EC point addition.

Get the output operands of the EC point addition and release the reserved resources. The operation on the accelerator must be finished before calling this function.

None

int sx_ecp_ptadd(
        const struct sx_pk_ecurve *curve,
        const sx_op *p1x,
        const sx_op *p1y,
        const sx_op *p2x,
        const sx_op *p2y,
        sx_op *rx,
        sx_op *ry)

Compute point addition on an elliptic curve (Rx, Ry) = P1 + P2

If P1 == P2 returns an SX_ERR_NOT_INVERTIBLE error Use point doubling operation for the addition of equal points

Use point doubling for the addition of equal points sx_ecp_double()

SX_OK SX_ERR_NOT_INVERTIBLE SX_ERR_OUT_OF_RANGE SX_ERR_POINT_NOT_ON_CURVE SX_ERR_INVALID_PARAM SX_ERR_UNKNOWN_ERROR SX_ERR_BUSY SX_ERR_NOT_IMPLEMENTED SX_ERR_OPERAND_TOO_LARGE SX_ERR_PLATFORM_ERROR SX_ERR_EXPIRED