Skip to content
Skills Library
Programming · Building & coding

micro-ecc-integration

/micro-ecc-integration

Use when integrating, porting, or debugging micro-ecc (uECC) ECDH, ECDSA, key generation, uECC_set_rng, signatures, curve selection, or key/signature byte formats on an MCU

Repository
aix-skills ↗
Licence
MIT
Last repository change
17.07.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 17.07.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when integrating, porting, or debugging micro-ecc (uECC) ECDH, ECDSA, key generation, uECC_set_rng, signatures, curve selection, or key/signature byte formats on an MCU

Original author description

Use when integrating, porting, or debugging micro-ecc (uECC) ECDH, ECDSA, key generation, uECC_set_rng, signatures, curve selection, or key/signature byte formats on an MCU

How it works

  1. Overview
  2. When To Use
  3. First Questions
  4. Integration Checklist
  5. Common Failures
  6. Verification
  7. Example
Original SKILL.md headings · 85 lines, 828 words
SKILL.md preview
---
name: micro-ecc-integration
description: Use when integrating, porting, or debugging micro-ecc (uECC) ECDH, ECDSA, key generation, uECC_set_rng, signatures, curve selection, or key/signature byte formats on an MCU
---

# micro-ecc Integration

## Overview

Use this skill to integrate micro-ecc (kmackay/micro-ecc, header `uECC.h`) by treating randomness, key storage, curve choice, and test vectors as security-critical. ECC that compiles but never called `uECC_set_rng()` or uses mismatched key byte formats is not working. The core key generation, signing, verification, and ECDH functions return `1` on success and `0` on failure (`uECC_verify` returns `1` only for a valid signature); the size-query helpers instead return a byte count, and `uECC_compress`/`uECC_decompress` return `void`.

## When To Use

Use this skill when:

- The user wants ECDH (`uECC_shared_secret`), ECDSA (`uECC_sign`/`uECC_verify`), or key generation (`uECC_make_key`) on an MCU using micro-ecc.
- The issue involves `uECC_make_key`/`uECC_sign` returning `0`, bad signatures, key mismatch, RNG, curve selection, endian/format mismatch, or slow scalar multiplication.
- The project uses `uECC.h`, `uECC.c`, a `uECC_Curve`, or `uECC_set_rng`.

Do not use this skill for full TLS stacks. Use `mbedtls-integration` for TLS. For AES/SHA/HMAC primitives, use `tinycrypt-integration`.

## First Questions

Ask for:

- Curve and operation: `uECC_secp160r1`, `uECC_secp192r1`, `uECC_secp224r1`, `uECC_secp256r1`, or `uECC_secp256k1`; and ECDH vs ECDSA.
- Target MCU, compiler, and whether a hardware TRNG/crypto peripheral exists.
- The RNG source wired into `uECC_set_rng()` and the key storage policy.
- Public/private key byte format and endian expectations of the peer (`uECC_VLI_NATIVE_LITTLE_ENDIAN` setting, compressed vs uncompressed).
- Test vector, signature, or verification failure details, and the return code seen.

## Integration Checklist

1. Choose curve deliberately.
   Pick a `uECC_Curve` via `uECC_secp256r1()` (or the peer's curve) and enable it with the matching `uECC_SUPPORTS_secp256r1` macro. Disable unused curves to save flash.

1. Provide a real RNG first.
   Register `uECC_set_rng(uECC_RNG_Function fn)` where `fn` has signature `int fn(uint8_t *dest, unsigned size)` and returns `1` when `dest` is filled with good entropy, `0` otherwise. Without a valid RNG, both `uECC_make_key` and `uECC_sign` return `0`. Only `uECC_sign_deterministic` (RFC 6979-style deterministic nonce, needs a `uECC_HashContext`) works without an RNG.

1. Size every buffer from the curve.
   Always use `uECC_curve_private_key_size(curve)` and `uECC_curve_public_key_size(curve)` instead of hard-coded lengths or arithmetic on each other. The public key is `x||y` and equals `uECC_curve_public_key_size(curve)`; the private key equals `uECC_curve_private_key_size(curve)`. These are equal to 2x the field size and 1x the field size respectively for every curve EXCEPT `secp160r1`, where the private key is 21 bytes (the order needs an extra byte; the leading byte is often `0x00`) while the public key is 40 bytes. Never derive public-key or signature length from the private-key length.

1. Match key/signature byte format.
   Default is big-endian; public keys are raw `x||y` with NO `0x04` uncompressed prefix, so prepend `0x04` for SEC1/OpenSSL peers. If interop breaks, check `uECC_VLI_NATIVE_LITTLE_ENDIAN` matches both sides; keys/signatures across the two settings are incompatible. The signature is `r||s` and its length equals the public-key length (`uECC_curve_public_key_size(curve)`) -- for `secp160r1` that is 40 bytes, not `2 * private_key_size` (peers such as python-ecdsa may instead expect 42).

1. Sign the hash, not the message.
   `uECC_sign(private_key, hash, hash_size, signature, curve)` and `uECC_verify` take a message digest plus `hash_size`; hash the message yourself (e.g. SHA-256) and pass the digest. A hash longer than the curve order is truncated internally.

1. Handle compressed points if needed.
   With `uECC_SUPPORT_COMPRESSED_POINT`, use `uECC_compress`/`uECC_decompress`; a compressed point is one coordinate plus a leading parity byte, i.e. `(uECC_curve_public_key_size(curve) / 2) + 1` bytes. Validate imported keys with `uECC_valid_public_key`.

1. Protect secrets.
   Do not log private keys, the ECDSA nonce, or the shared secret from `uECC_shared_secret`.

## Common Failures

- `uECC_set_rng()` never called, so `uECC_make_key`/`uECC_sign` silently return `0`.
- RNG callback returns `0` (or returns success while producing weak/deterministic bytes) in production.
- Public key sent with or expecting a `0x04` prefix; micro-ecc uses raw `x||y` without it.
- `secp160r1` private key allocated as 20 bytes instead of 21, corrupting adjacent memory or the key.
- Deriving signature or public-key length from the private-key length; on `secp160r1` this over-allocates (42 vs 40) and breaks interop.
- `uECC_VLI_NATIVE_LITTLE_ENDIAN` mismatch between device and peer, so byte order flips and verify fails.
- Passing the raw message to `uECC_sign`/`uECC_verify` instead of the digest, or hashing inconsistently between the two sides.
- Curve mismatch: device built with `uECC_secp256r1` but server uses `secp256k1`.

## Verification

Before claiming micro-ecc works:

- State the `uECC_Curve`, operation, key/signature byte layout, and the RNG registered via `uECC_set_rng`.
- Confirm `uECC_make_key` returns `1` and buffers were sized with `uECC_curve_public_key_size`/`uECC_curve_private_key_size` (not derived from each other).
- Confirm known test vectors pass: `uECC_verify` returns `1` for a valid signature and `0` for tampered data/hash.
- For ECDH, confirm both peers derive the same `uECC_shared_secret`.
- Confirm secrets are not logged and storage policy is explicit.

## Example

User:

```text
micro-ecc 签名服务器验不过。
```

Agent:

1. Asks for the curve, whether the public key carries a `0x04` prefix, the hash input to `uECC_sign`, the RNG behind `uECC_set_rng`, and the `uECC_VLI_NATIVE_LITTLE_ENDIAN` setting on both sides.
1. Checks endian and that a digest (not the raw message) is passed, and reconstructs the peer's SEC1 format by prepending `0x04` to the `x||y` public key.
1. Verifies with a known vector via `uECC_verify` before changing protocol code.

Versions

The database has no other skills named micro-ecc-integration.

Database snapshot: 13.11.2026 · package version 58626e02155b (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 95bitcoin-libraries-secp256k1-rs
    rust-secp256k1: Rust bindings to libsecp256k1 (C). ECDSA, Schnorr, ECDH, key tweaking, MuSig2 (BIP327, since 0.33). USE WHEN: low-level crypto in Rust, working with raw secp256k1 operations.
  • 100nr-micro-shell-integration
    Use when integrating, porting, configuring, or debugging nr_micro_shell command consoles, UART shell input, command tables, or tiny embedded CLI behavior
  • 100applied-cryptography-asymmetric-rsa-ecc-ed25519
    Use this skill when implement secure digital signatures and key pairs using RSA-4096, ECDSA, and Ed25519.
  • 100tinymaix-integration
    Use when integrating, porting, configuring, or debugging TinyMaix MCU inference, model loading, tensor shapes, memory, quantization, or TinyML runtime issues
  • 95bitcoin-ecdsa
    ECDSA signatures over secp256k1: sign/verify, deterministic-k (RFC6979), low-s (BIP146), DER encoding, malleability, recoverable signatures. USE WHEN: signing legacy/SegWit-v0 inputs, verifying legacy signatures, debugging "non-canonical signature" errors.
  • 90implementing-digital-signatures-with-ed25519
    Implements digital signatures using the Ed25519 algorithm (Curve25519), covering key-pair generation, signing, signature verification, and security tradeoffs versus RSA and ECDSA. Use when adding message or artifact signing and authentication-integrity checks to a system, or…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.