primarysource 0.1.0__py3-none-any.whl

primarysource/c2sp/library.py

@@ -0,0 +1,309 @@
+"""Read, outline, search and cite the installed C2SP specifications. Local files only; nothing here fetches.
+
+A ref is `c2sp:static-ct-api@09f3e51§Log Entries¶2`, with the `c2sp:` prefix and the `@<commit prefix>` both
+optional (no `@` means the newest import). `§` names a section by its heading text, or by its GitHub-style slug
+(`log-entries`) when the heading contains `:`, `#`, `¶` or `§`, or when two headings read alike. `¶n` is the nth
+block of that section's span (see `markdown.py`). A ref with no section is the whole document.
+"""
+
+from __future__ import annotations
+
+import difflib
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from primarysource import budget, cursor
+from primarysource.c2sp import markdown
+from primarysource.c2sp._fetch import sha256
+from primarysource.c2sp.catalogue import DOC_ID
+from primarysource.c2sp.catalogue import catalogue as packaged_catalogue
+from primarysource.errors import LibError
+from primarysource.home import collection_home
+from primarysource.model import span_hash
+from primarysource.refs import Ref, RefGrammar
+from primarysource.render import render
+
+PREFIX = "c2sp:"
+IMPORT = "primarysource c2sp import"
+_COMMIT_PREFIX = re.compile(r"[0-9a-f]{7,40}")
+_UNSAFE_IN_REF = re.compile(r"[:#¶§]")
+_HEADING_LINE = re.compile(r"#{1,6}(?: |$)")
+_TERM = re.compile(r"\w+", re.UNICODE)
+MAX_QUERY_TERMS = 16
+
+
+def grammar() -> RefGrammar:
+    from primarysource.c2sp import C2SP_DOC, C2SP_SECTION
+
+    return RefGrammar(C2SP_DOC, C2SP_SECTION)
+
+
+@dataclass(frozen=True, slots=True)
+class Loaded:
+    """One installed specification, parsed."""
+
+    id: str
+    commit: str
+    title: str
+    document: markdown.MarkdownDocument
+
+    @property
+    def short(self) -> str:
+        return self.commit[:7]
+
+
+def default_home() -> Path:
+    return collection_home("c2sp")
+
+
+def installs(home: Path) -> list[tuple[str, dict[str, object]]]:
+    """Every install under `home` as (commit, record), newest import first. A directory without a readable
+    `install.json` is not an install."""
+    found: list[tuple[str, dict[str, object]]] = []
+    if home.is_dir():
+        for child in home.iterdir():
+            record = child / "install.json"
+            if child.is_dir() and re.fullmatch(r"[0-9a-f]{40}", child.name) and record.is_file():
+                try:
+                    loaded = json.loads(record.read_text(encoding="utf-8"))
+                except (ValueError, OSError):
+                    continue
+                if isinstance(loaded, dict) and loaded.get("commit") == child.name:
+                    found.append((child.name, loaded))
+    found.sort(key=lambda item: str(item[1].get("imported", "")), reverse=True)
+    return found
+
+
+def _split_doc(token: str) -> tuple[str, str | None]:
+    doc, _, version = token.partition("@")
+    if not DOC_ID.fullmatch(doc):
+        raise LibError(f"not a C2SP specification id: {doc!r}", "c2sp_docs lists the specification ids")
+    if version and not _COMMIT_PREFIX.fullmatch(version):
+        raise LibError(f"not a commit prefix: {version!r}", "use at least 7 lowercase hex digits of the commit")
+    return doc, version or None
+
+
+def load(token: str, home: Path | None = None) -> Loaded:
+    """Load `doc[@commit-prefix]`, verifying the file against the install record's sha256."""
+    home = home or default_home()
+    doc_id, version = _split_doc(token)
+    available = installs(home)
+    if not available:
+        raise LibError("no C2SP specifications are imported", "c2sp_docs lists the catalogue", IMPORT)
+    for commit, record in available:
+        if version and not commit.startswith(version):
+            continue
+        files = record.get("files")
+        pin = files.get(doc_id) if isinstance(files, dict) else None
+        if not isinstance(pin, str):
+            continue
+        data = (home / commit / f"{doc_id}.md").read_bytes() if (home / commit / f"{doc_id}.md").is_file() else None
+        if data is None:
+            continue
+        if sha256(data) != pin:
+            raise LibError(f"{doc_id}@{commit[:7]} on disk does not match its recorded sha256", "", IMPORT)
+        parsed = markdown.parse(data)
+        return Loaded(doc_id, commit, parsed.title or doc_id, parsed)
+    have = ", ".join(f"{c[:7]}" for c, _ in available)
+    what = f"{doc_id}@{version}" if version else doc_id
+    raise LibError(f"{what} is not imported (imported commits: {have})", "c2sp_docs lists what is imported", IMPORT)
+
+
+def parse_ref(text: str) -> Ref:
+    """Parse a c2sp ref, accepting the optional `c2sp:` prefix."""
+    body = text.strip()
+    if body.lower().startswith(PREFIX):
+        body = body[len(PREFIX) :]
+    body, doc_para = cursor.split_doc_para(body)
+    ref = grammar().parse(body)
+    if doc_para is not None:
+        ref = Ref(ref.doc, None, doc_para, None, None)
+    if ref.lines is not None:
+        raise LibError(f"not a c2sp ref: {text!r}", "c2sp refs address headings and blocks, not line ranges")
+    if ref.anchor is not None:
+        raise LibError(f"not a c2sp ref: {text!r}", "c2sp has no #anchor; name the heading after §")
+    if ref.doc is None:
+        raise LibError(f"not a c2sp ref: {text!r}", "start with the specification id, e.g. static-ct-api")
+    return Ref(ref.doc, ref.section.strip() if ref.section else None, ref.para, None, None)
+
+
+def find_heading(doc: Loaded, name: str) -> tuple[markdown.Heading, str]:
+    """The heading `name` names, and a warning ("" if none). Exact title, then slug, then case-folded title."""
+    headings = doc.document.headings
+    wanted = name.strip()
+    for match in (
+        [h for h in headings if h.title == wanted],
+        [h for h in headings if h.slug == wanted.lower()],
+        [h for h in headings if h.title.casefold() == wanted.casefold()],
+    ):
+        if match:
+            warning = ""
+            if len(match) > 1:
+                slugs = ", ".join(h.slug for h in match)
+                warning = f"{len(match)} headings are titled {wanted!r}; this is the first. Use a slug: {slugs}"
+            return match[0], warning
+    close = difflib.get_close_matches(wanted, [h.title for h in headings], n=3, cutoff=0.5)
+    hint = f"did you mean: {', '.join(close)}" if close else f"c2sp_outline('{doc.id}') lists the headings"
+    raise LibError(f"no section {wanted!r} in {doc.id}@{doc.short}", hint)
+
+
+def section_ref(doc: Loaded, heading: markdown.Heading) -> str:
+    """The canonical ref of a heading: its title, or its slug if the title cannot appear in a ref."""
+    same = [h for h in doc.document.headings if h.title == heading.title]
+    use_slug = _UNSAFE_IN_REF.search(heading.title) is not None or len(same) > 1
+    return f"{doc.id}@{doc.short}§{heading.slug if use_slug else heading.title}"
+
+
+def _cite_text(doc: Loaded, heading: markdown.Heading | None, para: int | str | None) -> str:
+    where = f", §{heading.title}" if heading else ""
+    if para:
+        where += f" ¶{para}"
+    return (
+        f"C2SP, {doc.id} ({doc.title}), commit {doc.short}{where}. CC BY 4.0. "
+        f"https://github.com/C2SP/C2SP/blob/{doc.commit}/{doc.id}.md"
+    )
+
+
+def _doc(ref: Ref) -> str:
+    """The document of a parsed ref; `parse_ref` has already refused a ref without one."""
+    if ref.doc is None:
+        raise LibError("the ref names no document", "start with the document id")
+    return ref.doc
+
+
+def _select(ref: Ref, home: Path | None) -> tuple[Loaded, markdown.Heading | None, tuple[str, ...], str]:
+    doc = load(_doc(ref), home)
+    if ref.section is None:
+        return doc, None, doc.document.units(), ""
+    heading, warning = find_heading(doc, ref.section)
+    return doc, heading, heading.units, warning
+
+
+def read(ref_text: str, max_tokens: int = 2000, home: Path | None = None) -> str:
+    """The text of a ref, cut at block boundaries within `max_tokens`. A `¶n` ref starts at block n and runs to the
+    end of its scope; the `next:` footer is the ref that reads the next page."""
+    ref = parse_ref(ref_text)
+    doc, heading, units, warning = _select(ref, home)
+    if not units:
+        raise LibError(f"{ref_text}: that section has no text of its own", "read its subsections, see c2sp_outline")
+    first = cursor.first_unit(ref.para, len(units), "blocks", ref_text)
+    chosen = budget.page(units, start=first, max_tokens=max_tokens)
+    body = "\n\n".join(chosen.units)
+    scope = section_ref(doc, heading) if heading else f"{doc.id}@{doc.short}"
+    footer = {
+        "cite": _cite_text(doc, heading, cursor.para_label(ref.para, chosen)),
+        "unit": "block",
+        "span": span_hash(body),
+        "next": cursor.read_next(scope, chosen),
+        "warning": warning,
+    }
+    return render(body, footer)
+
+
+def outline(token: str, home: Path | None = None) -> str:
+    """The headings of one specification, indented by level, each with the ref that reads it."""
+    doc = load(token, home)
+    lines = [f"{doc.title}  [{doc.id}@{doc.short}]"]
+    for heading in doc.document.headings:
+        indent = "  " * (heading.level - 1)
+        lines.append(f"{indent}{heading.title}  {section_ref(doc, heading)}  ({len(heading.units)} blocks)")
+    return "\n".join(lines)
+
+
+def _terms(query: str) -> list[str]:
+    terms = [t for t in _TERM.findall(query.casefold()) if len(t) <= 64]
+    if not terms:
+        raise LibError("the query has no searchable words", "use words or identifiers, e.g. 'checkpoint origin'")
+    return terms[:MAX_QUERY_TERMS]
+
+
+def _snippet(text: str, terms: list[str]) -> str:
+    flat = " ".join(text.split())
+    low = flat.casefold()
+    at = min((i for i in (low.find(t) for t in terms) if i >= 0), default=0)
+    begin = max(0, at - 60)
+    return ("..." if begin else "") + flat[begin : begin + 160] + ("..." if begin + 160 < len(flat) else "")
+
+
+def search(
+    query: str,
+    doc: str | None = None,
+    limit: int = 10,
+    start: int = 0,
+    home: Path | None = None,
+) -> str:
+    """Blocks containing every query word (else at least half of them, flagged `relaxed`), best first: one line
+    per hit, `<ref>¶n: <snippet>`. Ranked by term frequency with a bonus for a match in the heading."""
+    terms = _terms(query)
+    home = home or default_home()
+    available = installs(home)
+    if not available:
+        raise LibError("no C2SP specifications are imported", "c2sp_docs lists the catalogue", IMPORT)
+    ids: list[str] = []
+    if doc:
+        ids = [doc]
+    else:
+        record_files = available[0][1].get("files")
+        ids = sorted(record_files) if isinstance(record_files, dict) else []
+    scored: list[tuple[float, int, str, str]] = []
+    relaxed = False
+    for need_all in (True, False):
+        for order, token in enumerate(ids):
+            loaded = load(token, home)
+            for heading in loaded.document.headings:
+                title = heading.title.casefold()
+                for index, block in enumerate(heading.units, start=1):
+                    if _HEADING_LINE.match(block):
+                        break  # what follows belongs to a subsection, which is searched under its own heading
+                    words = _TERM.findall(block.casefold())
+                    hits = [words.count(t) for t in terms]
+                    present = sum(1 for h in hits if h)
+                    if present == 0 or (need_all and present < len(terms)) or present * 2 < len(terms):
+                        continue
+                    score = sum(hits) + 3 * present + sum(2 for t in terms if t in title)
+                    ref = f"{section_ref(loaded, heading)}¶{index}"
+                    scored.append((-score, order, ref, _snippet(block, terms)))
+        if scored:
+            relaxed = not need_all
+            break
+    if not scored:
+        return render("no matches", {})
+    scored.sort()
+    shown, nxt = cursor.window(scored, start, limit)
+    body = "\n".join(f"{ref}: {snip}" for _, _, ref, snip in shown)
+    return render(body, {"next": nxt, "relaxed": "only some query words matched" if relaxed else ""})
+
+
+def cite(ref_text: str, home: Path | None = None) -> str:
+    """The citation string for a ref, with the span hash of the exact text cited."""
+    ref = parse_ref(ref_text)
+    doc, heading, units, warning = _select(ref, home)
+    if ref.para is not None:
+        if ref.para > len(units):
+            raise LibError(f"{ref_text}: the span has {len(units)} blocks", f"use ¶1 to ¶{len(units)}")
+        units = (units[ref.para - 1],)
+    footer = {
+        "cite": _cite_text(doc, heading, ref.para),
+        "unit": "block",
+        "span": span_hash("\n\n".join(units)),
+        "warning": warning,
+    }
+    return render(f"{doc.id}@{doc.short}" + (f"§{heading.title}" if heading else ""), footer)
+
+
+def docs(home: Path | None = None) -> str:
+    """The catalogue with what is imported: one line per specification."""
+    home = home or default_home()
+    cat = packaged_catalogue()
+    present: set[str] = set()
+    commits = installs(home)
+    for _, record in commits:
+        files = record.get("files")
+        if isinstance(files, dict):
+            present.update(files)
+    lines = [f"commit {cat.commit[:7]} ({cat.terms.licence}, placement {cat.terms.placement})"]
+    for spec in cat.specs:
+        lines.append(f"{'imported' if spec.id in present else 'not imported':<13} {spec.id}  {spec.title}")
+    return "\n".join(lines)

primarysource/c2sp/markdown.py

@@ -0,0 +1,31 @@
+"""The c2sp collection's Markdown reader: a re-export of the core's `primarysource.readers.markdown`.
+
+The reader moved to the core (`cl.reader_markdown`); this module keeps `primarysource.c2sp.markdown` importable so
+the importer, the library and their tests are unchanged.
+"""
+
+from __future__ import annotations
+
+from primarysource.readers.markdown import (
+    MAX_BYTES,
+    MAX_LINE,
+    MAX_SECTIONS,
+    Heading,
+    MarkdownDocument,
+    decode,
+    parse,
+    plain,
+    slugify,
+)
+
+__all__ = [
+    "MAX_BYTES",
+    "MAX_LINE",
+    "MAX_SECTIONS",
+    "Heading",
+    "MarkdownDocument",
+    "decode",
+    "parse",
+    "plain",
+    "slugify",
+]

primarysource/c2sp/server.py

@@ -0,0 +1,68 @@
+"""MCP server for the c2sp collection: `primarysource mcp --collection c2sp`.
+
+Imported only when served, so `mcp` (the `[mcp]` extra) is needed only then. Tools carry the `c2sp_` prefix,
+answer in text with the fixed footer, and turn a `LibError` into an MCP tool error naming the remedy. Every tool
+reads local files only; none writes or fetches.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from mcp.server.mcpserver import MCPServer
+from mcp.types import ToolAnnotations
+
+from primarysource import __version__
+from primarysource.c2sp import library
+from primarysource.scaffold import add_tools
+
+READ_ONLY = ToolAnnotations(read_only_hint=True, idempotent_hint=True, destructive_hint=False, open_world_hint=False)
+
+INSTRUCTIONS = (
+    "C2SP specifications (CC BY 4.0) at a pinned commit: static-ct-api, tlog-tiles, tlog-checkpoint, signed-note, "
+    "and the rest of the C2SP repository's top-level documents. Loop: c2sp_search('<words>') -> c2sp_read('<ref>'). "
+    "Refs: 'static-ct-api§Log Entries' (a heading by its text or slug), '...¶2' (its 2nd block), "
+    "'static-ct-api@09f3e51§...' to pin a commit. c2sp_outline('<doc>') lists headings as refs; c2sp_cite('<ref>') "
+    "gives the citation and the hash of the cited text. If nothing is imported, the error says how."
+)
+
+
+def c2sp_read(ref: str, max_tokens: int = 2000) -> str:
+    """Read C2SP text by ref, cut at block boundaries within max_tokens. A 'next: <ref>' footer line is the ref
+    that reads the next page: pass it back as ref.
+
+    ref: 'static-ct-api' (whole document) | 'static-ct-api§Log Entries' (a section, subsections included) |
+      '...§Log Entries¶2' (from its 2nd block) | 'static-ct-api@09f3e51§...' (pinned commit). A 'c2sp:' prefix is
+      allowed. c2sp_cite gives exactly one block."""
+    return library.read(ref, max_tokens=max_tokens)
+
+
+def c2sp_search(query: str, doc: str | None = None, limit: int = 10, start: int = 0) -> str:
+    """Find blocks containing the query words (all of them, else at least half, flagged 'relaxed'). One line per
+    hit: '<ref>¶n: <snippet>'. doc restricts to one specification. A 'next: start=N' footer line means call again
+    with start=N (a 0-based offset)."""
+    return library.search(query, doc=doc, limit=limit, start=start)
+
+
+def c2sp_outline(doc: str) -> str:
+    """List a specification's headings, indented by level, each with the ref that reads it. doc: 'tlog-tiles'."""
+    return library.outline(doc)
+
+
+def c2sp_cite(ref: str) -> str:
+    """The citation string for a ref, with the sha256 prefix of the exact text cited (cite: and span: lines)."""
+    return library.cite(ref)
+
+
+def c2sp_docs() -> str:
+    """List the catalogued specifications and whether each is imported."""
+    return library.docs()
+
+
+def _build() -> Any:
+    built = MCPServer("primarysource-c2sp", version=__version__, instructions=INSTRUCTIONS)
+    add_tools(built, (c2sp_read, c2sp_search, c2sp_outline, c2sp_cite, c2sp_docs), annotations=READ_ONLY)
+    return built
+
+
+server = _build()

primarysource/cavp/__init__.py

@@ -0,0 +1,42 @@
+"""NIST cryptographic test vectors as a primarysource collection: CAVP `.rsp` files and ACVP JSON vector sets.
+
+Vectors are not documents: the unit is a case, and the ref names set, group and case
+(`nist:cavp/ecdsa/SigVer.rsp#[P-256,SHA-256]/3`), so this is its own collection rather than part of `nist`.
+Importing this package needs only the standard library; `mcp` is imported only by `server.py` when served.
+`docs/cavp.md` is the user-facing description.
+"""
+
+from __future__ import annotations
+
+from primarysource.cavp.model import format_ref, parse_ref
+from primarysource.errors import LibError
+from primarysource.model import Unit
+from primarysource.refs import Ref
+from primarysource.registry import Collection
+
+
+class CavpRefs:
+    """The collection's `RefParser`, over `model.parse_ref`: the set id is `doc`, the group `section` and the case
+    `anchor` (`nist:cavp/ecdsa/SigVer.rsp#[P-256,SHA-256]/3`)."""
+
+    def parse(self, text: str) -> Ref:
+        ref = parse_ref(text)
+        return Ref(ref.set_id, ref.group, None, ref.case)
+
+    def format(self, ref: Ref) -> str:
+        if ref.doc is None or ref.para is not None or ref.lines is not None:
+            raise LibError(f"not a vector ref: {ref!r}", "a vector ref is a set, optionally a group and a case")
+        return format_ref(ref.doc, ref.section, ref.anchor)
+
+
+COLLECTION = Collection(
+    name="cavp",
+    title="NIST cryptographic test vectors (CAVP .rsp, ACVP JSON), pinned by sha256",
+    prefix="cavp_",
+    unit=Unit.BLOCK,
+    grammar=CavpRefs(),
+    server="primarysource.cavp.server:cavp_server",
+    cli="primarysource.cavp.cli:main",
+)
+
+__all__ = ["COLLECTION"]

primarysource/cavp/cli.py

@@ -0,0 +1,84 @@
+"""`primarysource cavp ...`: the collection's own commands.
+
+primarysource cavp fetch [id ...]                         download the pinned sources in vectors.toml, import them
+primarysource cavp import <id> <file> [<expected-file>]   import files you already have, under the same pins
+primarysource cavp pin <file>                             print the sha256 to pin
+primarysource cavp sets [query]
+primarysource cavp groups <set-ref>
+primarysource cavp read <ref> [--max-tokens N]
+primarysource cavp find <set-ref> <field> <value> [--group G]
+primarysource cavp cite <ref>
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from primarysource.cavp import importer, tools
+from primarysource.cavp.model import sha256_bytes
+from primarysource.cavp.paths import open_store
+from primarysource.errors import LibError
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="primarysource cavp", description="NIST CAVP/ACVP test vectors")
+    sub = parser.add_subparsers(dest="command", required=True)
+    sub.add_parser("fetch", help="download and import the pinned sources").add_argument("ids", nargs="*")
+    imp = sub.add_parser("import", help="import local files under a vectors.toml pin")
+    imp.add_argument("id")
+    imp.add_argument("file", type=Path)
+    imp.add_argument("expected", type=Path, nargs="?")
+    sub.add_parser("pin", help="print a file's sha256").add_argument("file", type=Path)
+    sub.add_parser("sets").add_argument("query", nargs="?")
+    sub.add_parser("groups").add_argument("ref")
+    read = sub.add_parser("read")
+    read.add_argument("ref")
+    read.add_argument("--max-tokens", type=int, default=2000)
+    find = sub.add_parser("find")
+    find.add_argument("ref")
+    find.add_argument("field")
+    find.add_argument("value")
+    find.add_argument("--group")
+    sub.add_parser("cite").add_argument("ref")
+    return parser
+
+
+def _say(text: str) -> int:
+    sys.stdout.write(text if text.endswith("\n") else text + "\n")
+    return 0
+
+
+def main(argv: Sequence[str]) -> int:
+    args = _parser().parse_args(list(argv))
+    store = open_store()
+    try:
+        if args.command == "pin":
+            return _say(sha256_bytes(args.file.read_bytes()))
+        if args.command in ("fetch", "import"):
+            known = {s.id: s for s in importer.load_sources()}
+            wanted = args.ids if args.command == "fetch" else [args.id]
+            unknown = [i for i in wanted if i not in known]
+            if unknown:
+                raise LibError(f"not in vectors.toml: {', '.join(unknown)}", f"known: {', '.join(known)}")
+            for source in (known[i] for i in (wanted or list(known))):
+                if args.command == "fetch":
+                    entry = importer.fetch(store, source)
+                else:
+                    entry = importer.import_files(store, source, args.file, args.expected)
+                print(f"{entry.id}: {entry.groups} groups, {entry.cases} cases, sha256 {entry.sha256}")
+            return 0
+        if args.command == "sets":
+            return _say(tools.sets(store, args.query))
+        if args.command == "groups":
+            return _say(tools.groups(store, args.ref))
+        if args.command == "read":
+            return _say(tools.read(store, args.ref, args.max_tokens))
+        if args.command == "find":
+            return _say(tools.find(store, args.ref, args.field, args.value, args.group))
+        return _say(tools.cite(store, args.ref))
+    except LibError as exc:
+        print(exc.as_text(), file=sys.stderr)
+        return 1

primarysource/cavp/data/vectors.toml

@@ -0,0 +1,47 @@
+# Vector sets `primarysource cavp fetch` may download. Each entry pins the sha256 of the artifact it downloads (the
+# zip, or the ACVP prompt.json), measured 2026-11-13. No vector data is stored in this repository.
+#
+# CAVP zips are the ones CSRC lists on its "Digital Signatures" CAVP page for FIPS 186-4; the RSA zip is named
+# 186-3 upstream and holds the FIPS 186-4 RSA SigVer response files. ACVP files are pinned to a commit of
+# usnistgov/ACVP-Server (master at 2026-08-12), never to a branch.
+
+[[vector]]
+id = "cavp/ecdsa/SigVer.rsp"
+kind = "cavp"
+algorithm = "ECDSA"
+url = "https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/dss/186-4ecdsatestvectors.zip"
+sha256 = "fe47cc92b4cee418236125c9ffbcd9bb01c8c34e74a4ba195d954bcb72824752"
+member = "186-4ecdsatestvectors/SigVer.rsp"
+
+[[vector]]
+id = "cavp/rsa/SigVer15_186-3.rsp"
+kind = "cavp"
+algorithm = "RSA"
+url = "https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/dss/186-3rsatestvectors.zip"
+sha256 = "8405aeb3572a4f98ed4b1a3ccb3f2f49e725462dd28ec4759d6a15d88855d19c"
+member = "SigVer15_186-3.rsp"
+
+[[vector]]
+id = "cavp/rsa/SigVerPSS_186-3.rsp"
+kind = "cavp"
+algorithm = "RSA"
+url = "https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/dss/186-3rsatestvectors.zip"
+sha256 = "8405aeb3572a4f98ed4b1a3ccb3f2f49e725462dd28ec4759d6a15d88855d19c"
+member = "SigVerPSS_186-3.rsp"
+
+[[vector]]
+id = "cavp/rsa/SigVer931_186-3.rsp"
+kind = "cavp"
+algorithm = "RSA"
+url = "https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/dss/186-3rsatestvectors.zip"
+sha256 = "8405aeb3572a4f98ed4b1a3ccb3f2f49e725462dd28ec4759d6a15d88855d19c"
+member = "SigVer931_186-3.rsp"
+
+[[vector]]
+id = "acvp/ECDSA-SigVer-1.0"
+kind = "acvp"
+algorithm = "ECDSA"
+url = "https://raw.githubusercontent.com/usnistgov/ACVP-Server/975de31eb83d87039ec88934fdc47d8c312b892d/gen-val/json-files/ECDSA-SigVer-1.0/prompt.json"
+sha256 = "eb41243f151f14ecb8e906d5d20a2809262fa9d8442a48cb4299ced5e6f30f8b"
+expected_url = "https://raw.githubusercontent.com/usnistgov/ACVP-Server/975de31eb83d87039ec88934fdc47d8c312b892d/gen-val/json-files/ECDSA-SigVer-1.0/expectedResults.json"
+expected_sha256 = "8a2b5e18f08cfa4846dcbc64c5f38bde94127c9549feeb42130acc4fcfa5f97e"