Security Classification Ontology

FLOW ALGEBRA
Security Classification Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/administrative-metadata/security-classification-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "SecurityClassificationOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := AdministrativeMetadata
ONTOLOGY := SecurityClassificationOntology

ENTITY SecurityClassification {
    definition:
        "Administrative metadata assigning a protection, sensitivity or
         handling level to a resource, metadata object or information asset so
         that access, storage, transmission, disclosure, retention and other
         security controls can be applied consistently.";
    objectives: [
        SensitivityClassification,
        ProtectionLevelAssignment,
        AccessControlSupport,
        HandlingControl,
        DisclosureControl,
        SecurityGovernance,
        MachineInterpretability
    ];
}

ClassificationEntity := {
    SecurityClassification,
    ClassificationLevel,
    ClassificationScheme,
    ClassificationLabel,
    ClassificationIdentifier,
    ClassificationAssignment,
    ClassificationStatus,
    ClassifiedResource
};

SecurityEntity := {
    Confidentiality,
    Integrity,
    Availability,
    Sensitivity,
    Clearance,
    Compartment,
    HandlingInstruction,
    SecurityControl
};

PolicyEntity := {
    SecurityPolicy,
    AccessPolicy,
    DisclosurePolicy,
    RetentionPolicy,
    DeclassificationPolicy,
    ClassificationRule,
    ReviewRule
};

MetadataEntity := {
    MetadataRecord,
    Provenance,
    Version,
    Confidence,
    Timestamp,
    ResponsibleAuthority
};

SecurityClassification APPLIES_TO ClassifiedResource;
ClassificationScheme CONTAINS ClassificationLevel;
ClassificationAssignment ASSIGNS ClassificationLevel TO ClassifiedResource;
SecurityPolicy GOVERNS ClassificationAssignment;
Clearance MAY_AUTHORISE AccessTo ClassificationLevel;
HandlingInstruction DERIVES_FROM ClassificationLevel;
Provenance SUPPORTS ClassificationAssignment;

SecurityClassificationFlow :=
    Resource
    -> IdentifyInformationAsset
    -> SelectClassificationScheme
    -> EvaluateSensitivityAndRisk
    -> DetermineClassificationLevel
    -> AssignClassificationLabel
    -> IdentifyCompartmentsAndHandlingRules
    -> AttachAuthorityAndProvenance
    -> ValidateClassification
    -> ApplyAccessStorageAndDisclosureControls
    -> ScheduleReviewOrDeclassification
    -> AuditChanges
    -> MaintainAcrossLifecycle;

ClassifiedResource :=
    ResourceOrMetadataObjectAssignedSecurityClassification;

ClassifiedResource MAY_BE {
    Document,
    Dataset,
    File,
    Message,
    MetadataRecord,
    Model,
    SystemConfiguration,
    KnowledgeEntity,
    ResourceFragment
};

SecurityClassification :=
    AdministrativeAssignmentOfProtectionOrSensitivityLevel;

ClassificationScheme :=
    ManagedSetOfSecurityLevelsRulesAndHandlingRequirements;

ClassificationScheme MAY_BE {
    Organisational,
    Governmental,
    Regulatory,
    Contractual,
    Custom
};

ClassificationLevel :=
    DefinedProtectionOrSensitivityCategoryWithinScheme;

ClassificationLevel MAY_INCLUDE {
    Public,
    Internal,
    Confidential,
    Restricted,
    HighlyRestricted,
    CustomLevel
};

LevelNamesAndSemantics MUST_BE InterpretedWithinSpecificClassificationScheme;

SameLabel MAY_HAVE DifferentMeaningAcrossSchemes;

ClassificationIdentifier :=
    StableReferenceToClassificationLevelOrAssignment;

ClassificationIdentifier MAY_BE {
    URI,
    IRI,
    UUID,
    Code,
    InternalIdentifier
};

ClassificationLabel :=
    HumanOrMachineReadableMarkingRepresentingClassification;

ClassificationLabel MAY_INCLUDE {
    Level,
    Compartment,
    HandlingCode,
    Authority
};

ClassificationAssignment :=
    RelationshipAssigningSecurityLevelToResource;

ClassificationAssignment MAY_HAVE {
    AssignedBy,
    AssignedAt,
    EffectiveFrom,
    EffectiveTo,
    Reason,
    Confidence
};

ClassificationStatus MAY_BE {
    Proposed,
    Active,
    UnderReview,
    Superseded,
    Declassified,
    Downgraded,
    Upgraded
};

ProposedClassification SHOULD_NOT AutomaticallyControlProductionAccessUnlessPolicyAllows;

Sensitivity :=
    DegreeToWhichUnauthorisedDisclosureModificationLossOrUseCouldCauseHarm;

Sensitivity MAY_RELATE_TO {
    Confidentiality,
    Integrity,
    Availability,
    Privacy,
    CommercialSensitivity,
    OperationalSensitivity
};

Confidentiality :=
    RequirementToPreventUnauthorisedDisclosure;

Integrity :=
    RequirementToPreventUnauthorisedOrUndetectedModification;

Availability :=
    RequirementForAuthorisedAccessWhenNeeded;

SecurityClassification MAY_PRIMARILY ReflectConfidentiality
BUT Scheme MAY_INCLUDE OtherSecurityDimensions;

ClassificationCriterion :=
    ConditionUsedToDetermineAppropriateClassification;

Criterion MAY_INCLUDE {
    InformationType,
    HarmImpact,
    LegalRequirement,
    ContractRequirement,
    PrivacySensitivity,
    BusinessSensitivity
};

ClassificationRule :=
    IF ResourceAttributesAndContext
    THEN AssignOrSuggest ClassificationLevel;

ClassificationRule MAY_BE {
    Deterministic,
    PolicyBased,
    RiskBased,
    Assisted
};

ImpactAssessment :=
    EvaluationOfPotentialHarmFromSecurityFailure;

Impact MAY_BE {
    Low,
    Moderate,
    High,
    Severe,
    CustomImpact
};

RiskAssessment MAY_INFORM Classification
BUT Risk != ClassificationByDefinition;

ClassificationAuthority :=
    AgentOrRoleAuthorisedToAssignApproveOrChangeClassification;

ResponsibleAuthority :=
    AgentAccountableForClassificationDecision;

Classifier :=
    HumanSystemOrProcessApplyingClassificationRule;

AutomatedClassifier MAY_SUGGEST Classification
BUT AuthoritativeAssignment SHOULD_FOLLOW GovernancePolicy;

Clearance :=
    AuthorisedSecurityLevelOrSetOfLevelsAssociatedWithSubject;

SubjectClearance MAY_BE ComparedWith ResourceClassificationAccordingToAccessPolicy;

IF MandatoryPolicyRequiresClearance
AND SubjectClearanceInsufficient
THEN AccessDecision := Deny;

ClearanceLevelAlone MAY_BE InsufficientWhenCompartmentsOrNeedToKnowApply;

Compartment :=
    AdditionalSecurityDomainOrNeedToKnowCategoryRestrictingAccess;

CompartmentMembership :=
    Subject
    -> AUTHORISED_FOR
    -> Compartment;

ClassifiedResource MAY_REQUIRE OneOrMoreCompartments;

NeedToKnow :=
    PolicyRequirementThatSubjectNeedsLegitimateOperationalReasonInAdditionToClearance;

IF ClearanceSufficient
AND NeedToKnowNotSatisfied
THEN Access MAY_STILL_BE Denied;

HandlingInstruction :=
    OperationalRuleDerivedFromClassificationOrPolicy;

HandlingInstruction MAY_INCLUDE {
    StorageRequirement,
    EncryptionRequirement,
    TransmissionRestriction,
    PrintingRestriction,
    CopyingRestriction,
    DisposalRequirement,
    MarkingRequirement
};

StorageRequirement MAY_DEFINE {
    ApprovedRepository,
    EncryptionAtRest,
    PhysicalSecurity
};

TransmissionRequirement MAY_DEFINE {
    EncryptionInTransit,
    ApprovedChannel,
    RecipientVerification
};

DisclosureRestriction :=
    RuleLimitingWhoMayReceiveOrViewInformation;

DistributionList MAY_DEFINE AuthorisedRecipientGroups;

Marking :=
    VisibleOrMachineReadableIndicationOfSecurityClassification;

Marking MAY_APPEAR_ON {
    Document,
    Page,
    Header,
    Footer,
    MetadataRecord,
    File
};

Marking SHOULD_CORRESPOND_TO EffectiveClassification;

MismatchedMarking MAY_CREATE SecurityRiskOrOperationalConfusion;

PortionMarking :=
    ClassificationLabelAppliedToSpecificResourceComponentOrFragment;

Resource MAY_HAVE MixedClassificationAcrossComponents;

AggregateClassification :=
    ClassificationAppliedToCombinedResourceContainingMultipleComponents;

AggregateClassification MAY_BE DeterminedBy {
    HighestComponentLevel,
    PolicyRule,
    DerivedSensitivity
};

HighestClassificationRule :=
    AggregateLevel
    >=
    MaximumRequiredProtectionOfComponents
according_to scheme_ordering;

SchemeOrdering :=
    DefinedOrderingAmongClassificationLevels;

ClassificationLevel MAY_HAVE RankOrPrecedence;

Rank SHOULD_BE DefinedBySchemeNotInferredFromLabelText;

ClassificationInheritance :=
    PropagationOfClassificationFromParentToChildOrChildToParentAccordingToPolicy;

Inheritance MUST_NOT_BE AssumedWithoutExplicitPolicy;

DerivedResource :=
    ResourceCreatedFromOneOrMoreClassifiedSources;

DerivedClassification :=
    ClassificationAssignedBasedOnSourceClassificationAndTransformation;

Transformation MAY_REDUCE_OR_INCREASE SensitivityAccordingToPolicyAndContent;

Redaction :=
    RemovalOrMaskingOfSensitiveInformationToCreateLessRestrictedRepresentation;

RedactedResource MAY_HAVE LowerClassificationOnlyAfterValidation;

Sanitisation :=
    ControlledRemovalOfSensitiveInformationOrMetadata;

Declassification :=
    AuthorisedRemovalOfSecurityClassificationOrReductionToUnclassifiedStatus;

Downgrade :=
    AuthorisedChangeToLowerProtectionLevel;

Upgrade :=
    ChangeToHigherProtectionLevel;

Reclassification :=
    ReassessmentAndAssignmentOfDifferentClassificationLevel;

ClassificationReview :=
    PeriodicOrEventDrivenEvaluationOfClassificationValidity;

ReviewTrigger MAY_INCLUDE {
    ScheduledDate,
    ResourceChange,
    LegalChange,
    PolicyChange,
    Incident,
    ExpiryCondition
};

DeclassificationPolicy :=
    RulesDefiningWhenAndHowClassificationMayBeRemovedOrReduced;

AutomaticDeclassification SHOULD_BE UsedOnlyWherePolicyExplicitlyAuthorises;

ClassificationExpiry :=
    TimeOrConditionAfterWhichClassificationRequiresReviewOrEndsAccordingToPolicy;

SecurityClassificationHistory :=
    OrderedRecordOfClassificationAssignmentsAndChanges;

History SHOULD_PRESERVE {
    PreviousLevel,
    NewLevel,
    Authority,
    Reason,
    Timestamp,
    Version
};

ClassificationVersion :=
    IdentifiedRevisionOfClassificationAssignmentOrScheme;

SchemeVersion :=
    IdentifiedRevisionOfClassificationScheme;

SchemeChange MAY_REQUIRE RevalidationOfExistingAssignments;

SecurityClassificationValidation MAY_CHECK {
    ResourceIdentity,
    SchemeMembership,
    ClassificationLevel,
    Authority,
    EffectivePeriod,
    MarkingConsistency,
    HandlingRules
};

IF ClassificationLevelNotInScheme
THEN ValidationStatus := violation;

IF ClassifierNotAuthorisedForAssignment
THEN ClassificationStatus SHOULD_NOT BecomeAuthoritative;

IF EffectiveEndBeforeEffectiveStart
THEN TemporalValidation := violation;

SecurityClassificationCompleteness :=
    DegreeToWhichRequiredLevelAuthorityScopeAndHandlingMetadataArePresent;

SecurityClassificationConsistency :=
    DegreeToWhichClassificationMarkingsControlsAndPoliciesAgree;

SecurityClassificationIntegrity :=
    PreservationOfAuthorisedClassificationStateAndHistory;

SecurityClassificationQuality MAY_INCLUDE {
    Completeness,
    Consistency,
    Integrity,
    Timeliness,
    Provenance
};

ClassificationProvenance MAY_INCLUDE {
    Source,
    Classifier,
    Authority,
    Rule,
    Timestamp,
    SchemeVersion
};

ClassificationConfidence :=
    EstimatedSupportForSuggestedOrInferredClassification;

Confidence SHOULD_NOT ReplaceAuthoritativeClassificationDecision;

AI MAY_SUPPORT {
    SensitiveContentDetection,
    ClassificationSuggestion,
    PolicyMapping,
    AnomalyDetection,
    ReviewPrioritisation
};

AIGeneratedClassification SHOULD_HAVE {
    ModelVersion,
    Method,
    Confidence,
    ValidationStatus
};

AIGeneratedSecurityClassification SHOULD_NOT AutomaticallyDowngradeProtectionWithoutAuthorisedReview;

FalseNegativeClassification :=
    ResourceAssignedLowerProtectionThanRequired;

FalseNegative MAY_CREATE DisclosureRisk;

FalsePositiveClassification :=
    ResourceAssignedHigherProtectionThanRequired;

FalsePositive MAY_REDUCE AvailabilityAndOperationalEfficiency;

SecurityClassification SHOULD_BALANCE ProtectionAndAuthorisedAvailabilityAccordingToPolicy;

AccessControl MAY_USE SecurityClassificationAsResourceAttribute;

MandatoryAccessControl MAY_COMPARE ClassificationWithClearance;

AttributeBasedAccessControl MAY_USE {
    ClassificationLevel,
    Compartment,
    ResourceOwner,
    Context
};

AdministrativeMetadata MAY_STORE ClassificationAssignmentAndHistory;

ProvenanceMetadata MAY_RECORD ClassificationDecisionAndChanges;

StructuralMetadata MAY_DEFINE ComponentsWithDifferentPortionMarkings;

MetadataRepository MUST_ENFORCE ApplicableClassificationControls;

MetadataRegistry MAY_REGISTER ClassificationSchemesLevelsAndHandlingCodes;

KnowledgeGraph MAY_REPRESENT:
    Resource
    -> HAS_SECURITY_CLASSIFICATION
    -> ClassificationLevel;

AdditionalGraphRelationships MAY_INCLUDE {
    REQUIRES_CLEARANCE,
    REQUIRES_COMPARTMENT,
    GOVERNED_BY_POLICY,
    CLASSIFIED_BY
};

SecurityClassificationGraph SHOULD_PRESERVE SchemeVersionAndProvenance;

RDF MAY_REPRESENT SecurityClassificationRelationshipsAsTypedStatements;

JSONLD MAY_SERIALISE LinkedClassificationMetadata;

Search MUST_APPLY ClassificationAndClearanceRulesBeforeReturningProtectedResults;

SearchResultMetadata SHOULD_NOT LeakRestrictedResourceExistenceIfPolicyForbidsDisclosure;

SemanticSearch MUST_FILTER ProtectedContentBeforeResultGeneration;

RAG MUST_APPLY SecurityClassificationBeforeAddingResourceToModelContext;

ClassificationAwareRAG SHOULD_PRESERVE {
    SubjectClearanceContext,
    ResourceClassification,
    AccessDecision,
    Provenance
};

CachesIndexesAndEmbeddings MAY_CONTAIN DerivedRepresentationsOfClassifiedContent;

DerivedRepresentations SHOULD_BE ProtectedAtAppropriateClassificationAccordingToPolicy;

SecurityClassificationAccessControl MAY_APPLY_TO ClassificationMetadataItself;

ClassificationLabel MAY_BE SensitiveInSomeContexts;

SecurityClassificationSecurity MAY_INCLUDE {
    PolicyIntegrity,
    ClassificationIntegrity,
    AccessControl,
    Audit,
    ChangeAuthorisation,
    SecureMarking
};

MachineReadableSecurityClassification SHOULD_PRESERVE {
    ResourceIdentifier,
    ClassificationIdentifier,
    SchemeIdentifier,
    SchemeVersion,
    ClassificationLevel,
    Compartments,
    HandlingInstructions,
    Authority,
    EffectivePeriod,
    Provenance,
    Confidence
};

# ---------- SEMANTIC REASONING ----------
IF AdministrativeMetadataAssignsProtectionSensitivityOrHandlingLevelToResource
THEN SecurityClassificationClassification := supported;

IF SubjectClearanceBelowRequiredLevel
AND MandatoryPolicyApplies
THEN AccessDecision := Deny;

IF SubjectClearanceSufficient
BUT RequiredCompartmentMissing
THEN AccessDecision := Deny;

IF ResourceContainsComponentsWithDifferentLevels
THEN AggregateClassification SHOULD_FOLLOW ApplicableAggregationPolicy;

IF ResourceRedacted
THEN LowerClassification MUST_NOT_BE AssumedUntilValidated;

IF ClassificationAuthorityRevokesOrChangesAssignment
THEN AccessControlsIndexesCachesAndDerivedRepresentations MAY_REQUIRE Update;

IF ClassificationSchemeVersionChanges
THEN ExistingAssignments MAY_REQUIRE Revalidation;

IF ClassificationConfidenceLow
THEN SuggestedClassification SHOULD_REQUIRE ReviewBeforeAuthoritativeUse;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "security classification" ~= "information security classification";
    "classification level" ~= "security level" WHEN protection_context;
    "security label" ~= "classification label";
    "clearance" ~= "security clearance";
    "compartment" ~= "need-to-know compartment";
    "declassification" ~= "removal of security classification";
    "downgrade" ~= "classification level reduction";
    "portion marking" ~= "component security marking";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_RESOURCE(q) ->
    IDENTIFY_CLASSIFICATION_SCHEME(q) ->
    IDENTIFY_CLASSIFICATION_ASSIGNMENT(q) ->
    RESOLVE_CLASSIFICATION_LEVEL(q) ->
    IDENTIFY_COMPARTMENTS_AND_HANDLING_RULES(q) ->
    IDENTIFY_AUTHORITY_AND_EFFECTIVE_PERIOD(q) ->
    IDENTIFY_CLEARANCE_REQUIREMENTS(q) ->
    IDENTIFY_HISTORY_AND_PROVENANCE(q) ->
    VALIDATE_SECURITY_CLASSIFICATION(q) ->
    APPLY_ACCESS_AND_DISCLOSURE_POLICY(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_AUTHORISED_SECURITY_CLASSIFICATION_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        policy_authority,
        source_reliability,
        classification_rule_strength,
        scheme_consistency,
        provenance_quality,
        contextual_relevance
    );

CONFIDENCE >= 0.90 => HIGH;
CONFIDENCE >= 0.70 AND < 0.90 => MODERATE;
CONFIDENCE < 0.70 => REVIEW;

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: SecurityClassification;
    ontology: SecurityClassificationOntology;
    parse_entities: true;
    parse_relationships: true;
    preserve_relationship_direction: true;
    resolve_semantic_equivalence: true;
    execute_reasoning_rules: true;
    apply_confidence_weighting: true;
    preserve_provenance: true;
    enforce_security_policy: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_classification:
        identify_resource
        -> select_scheme
        -> evaluate_sensitivity
        -> assign_or_suggest_level
        -> identify_compartments
        -> derive_handling_rules
        -> attach_authority
        -> attach_provenance
        -> validate
        -> integrate;

    classification_revision:
        preserve_previous_version
        -> apply_authorised_level_or_scope_change
        -> update_markings_and_controls
        -> revalidate_access_rules
        -> audit_change
        -> invalidate_affected_caches
        -> regenerate_flow_hash;

    declassification_or_downgrade:
        verify_authority
        -> verify_policy_conditions
        -> validate_redaction_or_sanitisation_if_applicable
        -> preserve_history
        -> update_controls
        -> audit
        -> integrate;

    scheme_revision:
        preserve_previous_scheme
        -> apply_level_or_rule_changes
        -> identify_affected_resources
        -> revalidate_assignments
        -> integrate;

    conflict:
        preserve_all_classification_evidence
        -> compare_authority_rules_and_scope
        -> apply_precedence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + ClassificationEntity
    + SecurityEntity
    + PolicyEntity
    + MetadataEntity
    + SecurityClassification
    + ClassificationAssignment
    + SecurityClassificationValidation
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
SecurityClassificationOntology
    -> IdentifyProtectedInformationAsset
    -> SelectAuthoritativeClassificationScheme
    -> EvaluateSensitivityImpactAndPolicyCriteria
    -> AssignSecurityLevelLabelAndIdentifier
    -> DefineCompartmentsNeedToKnowAndHandlingInstructions
    -> AttachClassificationAuthorityProvenanceAndEffectivePeriod
    -> ValidateMarkingsSchemeMembershipAndPolicyConsistency
    -> ApplyAccessStorageTransmissionAndDisclosureControls
    -> ProtectIndexesCachesEmbeddingsAndDerivedRepresentations
    -> ReviewUpgradeDowngradeOrDeclassifyAccordingToPolicy
    -> PreserveClassificationHistoryAndAuditTrail
    -> SupportAuthorisedSearchRAGAndMachineConsumption
    -> MaintainReliableSecurityClassificationKnowledge;

END FLOW