Home /Modules/gui/SLGuiCertificateStore.sleela

SLGuiCertificateStore.sleela

lib/gui/version-military/SLGuiCertificateStore.sleela · 149 line(s) · sleela

<< lib/gui/version-military/SLGuiCertificateStore.sleela
   SLeeLa Standard Library Definition.
   Definition: Defines SLGuiCertificateStore — a military-line COMPONENT that
     holds and presents public-key certificates (an X.509-style store). Each
     entry carries a subject, an issuer, a key algorithm, a fingerprint, a trust
     state (trusted / untrusted / revoked / expired), and whether it is a CA. The
     store lets the program import a certificate, mark trust, select one for use,
     and query validity. SLeeLa owns the store CONTENTS and trust STATE; the
     host/crypto layer performs chain building and signature verification and
     reports the result back as a trust state. It is fail-closed: a certificate
     is untrusted until explicitly trusted, and a revoked/expired certificate is
     never reported valid.
   
   Family: gui. A "certstore" node's backing model; partners SLGuiCryptoSelector
     and SLGuiAdminAuthority (an admin signature for Law may reference a cert). >>
#sleela 2.5
material;
class SLGuiCertificateStore {
  < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- >
  << Eleven catalogued attributes with getter/setter pairs, so a GUI, loader,
     or catalog can read and (where appropriate) override this record.
     Values are faithful to the subject's real origin where publicly known. >>
  String metaVersion = "1.0.0";
  int metaId = 11174;
  String metaAuthor = "Kiro Agent";
  String metaDate = "2026-10-16";
  String metaCopyright = "SLeeLa project";
  String metaTrademark = "none";
  String metaCorporation = "none";
  < metaOrigin: National | <nation> | International | Galactic >
  String metaOrigin = "International";
  String metaBirthDate = "2026-10-16";
  < metaScienceRating: maturity/robustness on a 1..10 scale >
  int metaScienceRating = 9;
  < metaNationalSchedule: a real, citable instrument or "none" >
  String metaNationalSchedule = "none";

  String getMetaVersion() { return metaVersion; }
  void setMetaVersion(String v) { metaVersion = v; }
  int getMetaId() { return metaId; }
  void setMetaId(int v) { metaId = v; }
  String getAuthor() { return metaAuthor; }
  void setAuthor(String v) { metaAuthor = v; }
  String getDate() { return metaDate; }
  void setDate(String v) { metaDate = v; }
  String getCopyright() { return metaCopyright; }
  void setCopyright(String v) { metaCopyright = v; }
  String getTrademark() { return metaTrademark; }
  void setTrademark(String v) { metaTrademark = v; }
  String getCorporation() { return metaCorporation; }
  void setCorporation(String v) { metaCorporation = v; }
  String getOrigin() { return metaOrigin; }
  void setOrigin(String v) { metaOrigin = v; }
  String getBirthDate() { return metaBirthDate; }
  void setBirthDate(String v) { metaBirthDate = v; }
  int getScienceRating() { return metaScienceRating; }
  void setScienceRating(int v) { metaScienceRating = v; }
  String getNationalSchedule() { return metaNationalSchedule; }
  void setNationalSchedule(String v) { metaNationalSchedule = v; }
  static final int MAX_CERTS = 64;

  < Trust state of an entry. >
  < present but not trusted (default) >
  static final int TRUST_UNTRUSTED = 0;
  < explicitly trusted by the operator >
  static final int TRUST_TRUSTED   = 1;
  < on a revocation list >
  static final int TRUST_REVOKED   = 2;
  < past its validity window >
  static final int TRUST_EXPIRED   = 3;

  < certificate subject (CN/O) >
  String[] subject;
  < issuing authority >
  String[] issuer;
  < e.g. "RSA-2048", "ECDSA-P256", "Ed25519", "ML-DSA-65" >
  String[] keyAlg;
  < host-supplied hash (e.g. SHA-256 hex) >
  String[] fingerprint;
  < TRUST_* >
  int[] trust;
  < 1 = certificate authority >
  int[] isCa;
  int count;

  < selected entry index (-1 = none) >
  int selected;

  void configure() {
    subject = new String[MAX_CERTS]; issuer = new String[MAX_CERTS];
    keyAlg = new String[MAX_CERTS]; fingerprint = new String[MAX_CERTS];
    trust = new int[MAX_CERTS]; isCa = new int[MAX_CERTS]; count = 0; selected = -1;
  }

  < Import a certificate. Fail-closed: blank subject/fingerprint is refused, and >
  < a new entry starts UNTRUSTED. Returns the new index, or -1 on refusal/full. >
  int importCert(String subj, String iss, String alg, String fp, boolean ca) {
    if (subj == null || subj == "" || fp == null || fp == "") { return -1; }
    if (count >= MAX_CERTS) { return -1; }
    subject[count] = subj; issuer[count] = (iss == null) ? "" : iss;
    keyAlg[count] = (alg == null) ? "" : alg; fingerprint[count] = fp;
    trust[count] = TRUST_UNTRUSTED; isCa[count] = ca ? 1 : 0;
    int idx = count; count = count + 1;
    return idx;
  }

  int certCount() { return count; }
  String subjectAt(int i) { return (i >= 0 && i < count) ? subject[i] : null; }
  String issuerAt(int i) { return (i >= 0 && i < count) ? issuer[i] : null; }
  String keyAlgAt(int i) { return (i >= 0 && i < count) ? keyAlg[i] : null; }
  String fingerprintAt(int i) { return (i >= 0 && i < count) ? fingerprint[i] : null; }
  int trustAt(int i) { return (i >= 0 && i < count) ? trust[i] : -1; }
  boolean isCaAt(int i) { return i >= 0 && i < count && isCa[i] == 1; }
  int indexOfFingerprint(String fp) {
    for (int i = 0; i < count; i = i + 1) { if (fingerprint[i] == fp) { return i; } }
    return -1;
  }

  < ---- trust (the operator / host chain-verifier sets these) -------------- >
  boolean trustCert(int i) { if (i < 0 || i >= count) { return false; } if (trust[i] == TRUST_REVOKED || trust[i] == TRUST_EXPIRED) { return false; } trust[i] = TRUST_TRUSTED; return true; }
  boolean untrustCert(int i) { if (i < 0 || i >= count) { return false; } trust[i] = TRUST_UNTRUSTED; return true; }
  < Host reports a revocation / expiry (irreversible trust downgrade). >
  void markRevoked(int i) { if (i >= 0 && i < count) { trust[i] = TRUST_REVOKED; if (selected == i) { selected = -1; } } }
  void markExpired(int i) { if (i >= 0 && i < count) { trust[i] = TRUST_EXPIRED; if (selected == i) { selected = -1; } } }

  < A certificate is VALID for use only when explicitly trusted (never when >
  < untrusted, revoked, or expired) — fail-closed. >
  boolean valid(int i) { return i >= 0 && i < count && trust[i] == TRUST_TRUSTED; }

  < ---- selection ---------------------------------------------------------- >
  < Select a certificate for use; only a valid (trusted) entry may be selected. >
  boolean select(int i) { if (!valid(i)) { return false; } selected = i; return true; }
  void clearSelection() { selected = -1; }
  boolean hasSelection() { return selected >= 0; }
  int selectedIndex() { return selected; }
  String selectedSubject() { return (selected >= 0) ? subject[selected] : ""; }
  String selectedFingerprint() { return (selected >= 0) ? fingerprint[selected] : ""; }

  < Count of certificates that are currently valid for use. >
  int validCount() { int n = 0; for (int i = 0; i < count; i = i + 1) { if (valid(i)) { n = n + 1; } } return n; }

  String trustName(int t) {
    if (t == TRUST_TRUSTED)   { return "trusted"; }
    if (t == TRUST_REVOKED)   { return "revoked"; }
    if (t == TRUST_EXPIRED)   { return "expired"; }
    return "untrusted";
  }
}