4. Abstract Service Interfaces (Interfacce di servizio astratte)

Questa sezione descrive le interfacce di servizio astratte tra i principali componenti dell'architettura SNMP. Queste interfacce sono definite utilizzando primitive astratte, che rappresentano le informazioni che devono essere passate tra i componenti senza specificare come vengono passate.

Le interfacce di servizio astratte sono organizzate in diverse categorie:

Primitive del dispatcher: Interfacce tra applicazioni e il dispatcher
Primitive del sottosistema di elaborazione dei messaggi: Interfacce tra il dispatcher e i modelli di elaborazione dei messaggi
Primitive del sottosistema di controllo degli accessi: Interfacce tra applicazioni e il sottosistema di controllo degli accessi
Primitive del sottosistema di sicurezza: Interfacce tra i modelli di elaborazione dei messaggi e i modelli di sicurezza

4.1. Dispatcher Primitives (Primitive del dispatcher)

Il dispatcher fornisce servizi alle applicazioni per l'invio e la ricezione di messaggi SNMP. Funge da punto centrale per l'instradamento di messaggi e PDU.

4.1.1. Generate Outgoing Request or Notification (Generare richiesta o notifica in uscita)

Le applicazioni utilizzano la primitiva sendPdu per richiedere al dispatcher di inviare un messaggio SNMP contenente una PDU.

Primitiva:

statusInformation =
  sendPdu(
    IN  transportDomain
    IN  transportAddress
    IN  messageProcessingModel
    IN  securityModel
    IN  securityName
    IN  securityLevel
    IN  contextEngineID
    IN  contextName
    IN  pduVersion
    IN  PDU
    IN  expectResponse
    IN  sendPduHandle
    OUT destTransportDomain
    OUT destTransportAddress
  )

Parametri:

transportDomain: Il protocollo di trasporto da utilizzare (ad es. UDP)
transportAddress: L'indirizzo di destinazione
messageProcessingModel: Il formato del messaggio da utilizzare
securityModel: Il modello di sicurezza da utilizzare
securityName: Il principal per conto del quale viene inviato il messaggio
securityLevel: Il livello di sicurezza (noAuthNoPriv, authNoPriv o authPriv)
contextEngineID: L'ID del motore di contesto
contextName: Il nome del contesto
pduVersion: La versione della PDU
PDU: La PDU da inviare
expectResponse: Se è prevista una risposta
sendPduHandle: Un handle per identificare questa richiesta
destTransportDomain: (OUT) Il dominio di trasporto effettivamente utilizzato
destTransportAddress: (OUT) L'indirizzo di trasporto effettivamente utilizzato
statusInformation: (OUT) Indicazione di successo o errore

4.1.2. Process Incoming Request or Notification PDU (Elaborare PDU di richiesta o notifica in entrata)

Il dispatcher utilizza la primitiva processPdu per consegnare una PDU di richiesta o notifica in entrata a un'applicazione.

Primitiva:

processPdu(
  IN  messageProcessingModel
  IN  securityModel
  IN  securityName
  IN  securityLevel
  IN  contextEngineID
  IN  contextName
  IN  pduVersion
  IN  PDU
  IN  maxSizeResponseScopedPDU
  IN  stateReference
)

Parametri:

messageProcessingModel: Il formato del messaggio utilizzato
securityModel: Il modello di sicurezza utilizzato
securityName: Il principal per conto del quale è stato inviato il messaggio
securityLevel: Il livello di sicurezza applicato al messaggio
contextEngineID: L'ID del motore di contesto
contextName: Il nome del contesto
pduVersion: La versione della PDU
PDU: La PDU ricevuta
maxSizeResponseScopedPDU: La dimensione massima per una risposta
stateReference: Riferimento alle informazioni di stato memorizzate nella cache

4.1.3. Generate Outgoing Response (Generare risposta in uscita)

Le applicazioni utilizzano la primitiva returnResponsePdu per richiedere al dispatcher di inviare un messaggio di risposta.

Primitiva:

result =
  returnResponsePdu(
    IN  messageProcessingModel
    IN  securityModel
    IN  securityName
    IN  securityLevel
    IN  contextEngineID
    IN  contextName
    IN  pduVersion
    IN  PDU
    IN  maxSizeResponseScopedPDU
    IN  stateReference
    IN  statusInformation
  )

Parametri:

messageProcessingModel: Il formato del messaggio da utilizzare (da processPdu)
securityModel: Il modello di sicurezza da utilizzare (da processPdu)
securityName: Il principal (da processPdu)
securityLevel: Il livello di sicurezza (da processPdu)
contextEngineID: L'ID del motore di contesto (da processPdu)
contextName: Il nome del contesto (da processPdu)
pduVersion: La versione della PDU (da processPdu)
PDU: La PDU di risposta da inviare
maxSizeResponseScopedPDU: Dimensione massima per la risposta (da processPdu)
stateReference: Informazioni di stato (da processPdu)
statusInformation: Informazioni di stato sull'elaborazione della richiesta
result: (OUT) Indicazione di successo o errore

4.1.4. Process Incoming Response PDU (Elaborare PDU di risposta in entrata)

Il dispatcher utilizza la primitiva processResponsePdu per consegnare una PDU di risposta a un'applicazione.

Primitiva:

processResponsePdu(
  IN  messageProcessingModel
  IN  securityModel
  IN  securityName
  IN  securityLevel
  IN  contextEngineID
  IN  contextName
  IN  pduVersion
  IN  PDU
  IN  statusInformation
  IN  sendPduHandle
)

Parametri:

messageProcessingModel: Il formato del messaggio utilizzato
securityModel: Il modello di sicurezza utilizzato
securityName: Il principal
securityLevel: Il livello di sicurezza applicato
contextEngineID: L'ID del motore di contesto
contextName: Il nome del contesto
pduVersion: La versione della PDU
PDU: La PDU di risposta ricevuta
statusInformation: Informazioni di stato sull'elaborazione del messaggio
sendPduHandle: L'handle dalla richiesta sendPdu originale

4.1.5. Registering Responsibility for Handling SNMP PDUs (Registrazione della responsabilità per la gestione delle PDU SNMP)

Le applicazioni devono registrarsi presso il dispatcher per ricevere determinati tipi di PDU.

Primitiva per la registrazione:

statusInformation =
  registerContextEngineID(
    IN  contextEngineID
    IN  pduType
  )

Primitiva per la deregistrazione:

unregisterContextEngineID(
  IN  contextEngineID
  IN  pduType
)

Parametri:

contextEngineID: L'ID del motore di contesto per cui registrarsi
pduType: Il tipo di PDU da ricevere (Get, GetNext, GetBulk, Set, Trap, InformRequest, ecc.)
statusInformation: (OUT) Indicazione di successo o errore

Solo un'applicazione può registrarsi per una determinata combinazione di contextEngineID e pduType alla volta.

4.2. Message Processing Subsystem Primitives (Primitive del sottosistema di elaborazione dei messaggi)

Il sottosistema di elaborazione dei messaggi fornisce servizi al dispatcher per preparare i messaggi ed estrarre dati dai messaggi.

4.2.1. Prepare Outgoing SNMP Request or Notification Message (Preparare messaggio di richiesta o notifica SNMP in uscita)

Il dispatcher utilizza la primitiva prepareOutgoingMessage per richiedere a un modello di elaborazione dei messaggi di preparare un messaggio per la trasmissione.

Primitiva:

statusInformation =
  prepareOutgoingMessage(
    IN  transportDomain
    IN  transportAddress
    IN  messageProcessingModel
    IN  securityModel
    IN  securityName
    IN  securityLevel
    IN  contextEngineID
    IN  contextName
    IN  pduVersion
    IN  PDU
    IN  expectResponse
    IN  sendPduHandle
    OUT destTransportDomain
    OUT destTransportAddress
    OUT outgoingMessage
    OUT outgoingMessageLength
  )

Parametri:

I parametri di input sono gli stessi di sendPdu
outgoingMessage: (OUT) Il messaggio pronto per la trasmissione
outgoingMessageLength: (OUT) La lunghezza del messaggio
statusInformation: (OUT) Indicazione di successo o errore

Il modello di elaborazione dei messaggi:

Crea una scopedPDU da contextEngineID, contextName e PDU
Chiama il modello di sicurezza per applicare l'elaborazione della sicurezza
Avvolge il messaggio protetto nel formato di messaggio appropriato
Restituisce il messaggio completo pronto per la trasmissione

4.2.2. Prepare an Outgoing SNMP Response Message (Preparare messaggio di risposta SNMP in uscita)

Il dispatcher utilizza la primitiva prepareResponseMessage per richiedere a un modello di elaborazione dei messaggi di preparare un messaggio di risposta per la trasmissione.

Primitiva:

result =
  prepareResponseMessage(
    IN  messageProcessingModel
    IN  securityModel
    IN  securityName
    IN  securityLevel
    IN  contextEngineID
    IN  contextName
    IN  pduVersion
    IN  PDU
    IN  maxSizeResponseScopedPDU
    IN  stateReference
    IN  statusInformation
    OUT destTransportDomain
    OUT destTransportAddress
    OUT outgoingMessage
    OUT outgoingMessageLength
  )

Parametri:

I parametri di input includono le informazioni di stato dalla richiesta originale
outgoingMessage: (OUT) Il messaggio di risposta preparato
outgoingMessageLength: (OUT) La lunghezza del messaggio
result: (OUT) Indicazione di successo o errore

Il modello di elaborazione dei messaggi:

Recupera le informazioni memorizzate nella cache utilizzando la stateReference
Crea una scopedPDU da contextEngineID, contextName e PDU
Chiama il modello di sicurezza per applicare l'elaborazione della sicurezza
Avvolge il messaggio protetto nel formato di messaggio appropriato
Restituisce il messaggio completo pronto per la trasmissione
Rilascia le informazioni di stato memorizzate nella cache

4.2.3. Prepare Data Elements from an Incoming SNMP Message (Preparare elementi di dati da un messaggio SNMP in entrata)

Il dispatcher utilizza la primitiva prepareDataElements per richiedere a un modello di elaborazione dei messaggi di estrarre dati da un messaggio ricevuto.

Primitiva:

result =
  prepareDataElements(
    IN  transportDomain
    IN  transportAddress
    IN  wholeMsg
    IN  wholeMsgLength
    OUT messageProcessingModel
    OUT securityModel
    OUT securityName
    OUT securityLevel
    OUT contextEngineID
    OUT contextName
    OUT pduVersion
    OUT PDU
    OUT pduType
    OUT sendPduHandle
    OUT maxSizeResponseScopedPDU
    OUT statusInformation
    OUT stateReference
  )

Parametri:

transportDomain: Il protocollo di trasporto su cui è arrivato il messaggio
transportAddress: L'indirizzo di origine
wholeMsg: Il messaggio ricevuto
wholeMsgLength: La lunghezza del messaggio
Tutti i parametri OUT contengono gli elementi di dati estratti
result: (OUT) Indicazione di successo o errore

Il modello di elaborazione dei messaggi:

Analizza il formato del messaggio
Chiama il modello di sicurezza per elaborare la sicurezza
Estrae la scopedPDU
Analizza la scopedPDU per estrarre contextEngineID, contextName e PDU
Memorizza nella cache le informazioni di stato se il messaggio richiede una risposta
Restituisce tutti gli elementi di dati estratti

4.3. Access Control Subsystem Primitives (Primitive del sottosistema di controllo degli accessi)

Il sottosistema di controllo degli accessi fornisce servizi alle applicazioni per determinare se l'accesso a un oggetto gestito dovrebbe essere consentito.

Primitiva:

statusInformation =
  isAccessAllowed(
    IN  securityModel
    IN  securityName
    IN  securityLevel
    IN  viewType
    IN  contextName
    IN  variableName
  )

Parametri:

securityModel: Il modello di sicurezza in uso
securityName: Il principal che tenta l'accesso
securityLevel: Il livello di sicurezza del messaggio
viewType: Il tipo di accesso (read, write o notify)
contextName: Il contesto a cui si accede
variableName: L'OID dell'oggetto gestito
statusInformation: (OUT) Consentito o negato

Il modello di controllo degli accessi determina se l'operazione specificata dovrebbe essere consentita in base alla sua politica configurata.

4.4. Security Subsystem Primitives (Primitive del sottosistema di sicurezza)

Il sottosistema di sicurezza fornisce servizi ai modelli di elaborazione dei messaggi per applicare e controllare la sicurezza.

4.4.1. Generate a Request or Notification Message (Generare un messaggio di richiesta o notifica)

I modelli di elaborazione dei messaggi utilizzano la primitiva generateRequestMsg per richiedere al sottosistema di sicurezza di applicare l'elaborazione della sicurezza a un messaggio di richiesta o notifica in uscita.

Primitiva:

statusInformation =
  generateRequestMsg(
    IN  messageProcessingModel
    IN  globalData
    IN  maxMessageSize
    IN  securityModel
    IN  securityEngineID
    IN  securityName
    IN  securityLevel
    IN  scopedPDU
    OUT securityParameters
    OUT wholeMsg
    OUT wholeMsgLength
  )

Parametri:

messageProcessingModel: Il formato del messaggio utilizzato
globalData: Dati di intestazione specifici del formato del messaggio
maxMessageSize: Dimensione massima del messaggio supportata
securityModel: Il modello di sicurezza da utilizzare
securityEngineID: L'ID del motore autorevole
securityName: Il principal
securityLevel: Il livello di sicurezza desiderato
scopedPDU: La scoped PDU da proteggere
securityParameters: (OUT) Parametri specifici del modello di sicurezza
wholeMsg: (OUT) Il messaggio protetto completo
wholeMsgLength: (OUT) La lunghezza del messaggio
statusInformation: (OUT) Indicazione di successo o errore

4.4.2. Process Incoming Message (Elaborare messaggio in entrata)

I modelli di elaborazione dei messaggi utilizzano la primitiva processIncomingMsg per richiedere al sottosistema di sicurezza di elaborare un messaggio in entrata.

Primitiva:

statusInformation =
  processIncomingMsg(
    IN  messageProcessingModel
    IN  maxMessageSize
    IN  securityParameters
    IN  securityModel
    IN  securityLevel
    IN  wholeMsg
    IN  wholeMsgLength
    OUT securityEngineID
    OUT securityName
    OUT scopedPDU
    OUT maxSizeResponseScopedPDU
    OUT securityStateReference
  )

Parametri:

messageProcessingModel: Il formato del messaggio utilizzato
maxMessageSize: Dimensione massima del messaggio supportata
securityParameters: Parametri specifici del modello di sicurezza dal messaggio
securityModel: Il modello di sicurezza indicato nel messaggio
securityLevel: Il livello di sicurezza desiderato
wholeMsg: Il messaggio ricevuto
wholeMsgLength: La lunghezza del messaggio
securityEngineID: (OUT) L'ID del motore autorevole
securityName: (OUT) Il principal
scopedPDU: (OUT) La scoped PDU estratta e verificata
maxSizeResponseScopedPDU: (OUT) Dimensione massima per una risposta
securityStateReference: (OUT) Riferimento allo stato di sicurezza memorizzato nella cache
statusInformation: (OUT) Indicazione di successo o errore

Il modello di sicurezza:

Verifica che il messaggio sia autentico (se è richiesta l'autenticazione)
Decrittografa il messaggio (se è richiesta la privacy)
Controlla la tempestività del messaggio (per prevenire attacchi di replay)
Estrae la scopedPDU
Memorizza nella cache lo stato di sicurezza se potrebbe essere necessaria una risposta
Restituisce tutti i dati estratti

4.4.3. Generate a Response Message (Generare un messaggio di risposta)

I modelli di elaborazione dei messaggi utilizzano la primitiva generateResponseMsg per richiedere al sottosistema di sicurezza di applicare l'elaborazione della sicurezza a un messaggio di risposta in uscita.

Primitiva:

statusInformation =
  generateResponseMsg(
    IN  messageProcessingModel
    IN  globalData
    IN  maxMessageSize
    IN  securityModel
    IN  securityEngineID
    IN  securityName
    IN  securityLevel
    IN  scopedPDU
    IN  securityStateReference
    OUT securityParameters
    OUT wholeMsg
    OUT wholeMsgLength
  )

Parametri:

Simile a generateRequestMsg, ma include securityStateReference
securityStateReference: Stato memorizzato nella cache dalla richiesta originale
Gli altri parametri sono simili a generateRequestMsg

Il modello di sicurezza utilizza lo stato di sicurezza memorizzato nella cache per applicare la stessa elaborazione della sicurezza alla risposta utilizzata per la richiesta.

4.5. Common Primitives (Primitive comuni)

4.5.1. Release State Reference Information (Rilasciare informazioni di riferimento allo stato)

I componenti utilizzano la primitiva stateRelease per rilasciare le informazioni di stato memorizzate nella cache.

Primitiva:

stateRelease(
  IN  stateReference
)

Parametri:

stateReference: Il riferimento allo stato memorizzato nella cache da rilasciare

Questa primitiva viene utilizzata per liberare risorse quando le informazioni di stato memorizzate nella cache non sono più necessarie. Viene tipicamente chiamata quando:

È stata inviata una risposta
Si è verificato un errore e non verrà inviata alcuna risposta
Si è verificato un timeout in attesa di una risposta

4.6. Scenario Diagrams (Diagrammi di scenario)

Questa sezione fornisce diagrammi di scenario che mostrano il flusso delle primitive per le operazioni comuni.

4.6.1. Command Generator or Notification Originator (Command Generator o Notification Originator)

Il seguente diagramma mostra il flusso quando un'applicazione avvia una richiesta o una notifica:

Application          Dispatcher       Message Processing    Security
                                      Model                 Model

sendPdu ----------->
                     prepareOutgoing
                     Message -------->
                                      generateRequestMsg -->
                                                            (applicare sicurezza)
                                      &lt;------------------
                     &lt;--------------
                     (inviare messaggio alla rete)

(più tardi, arriva la risposta)

                     (ricevere messaggio dalla rete)
                     prepareData
                     Elements ------->
                                      processIncomingMsg -->
                                                            (controllare sicurezza)
                                      &lt;------------------
                     &lt;--------------
processResponsePdu &lt;-

4.6.2. Scenario Diagram for a Command Responder Application (Diagramma di scenario per un'applicazione Command Responder)

Il seguente diagramma mostra il flusso quando un'applicazione risponde a una richiesta:

Application          Dispatcher       Message Processing    Security
                                      Model                 Model

                     (ricevere messaggio dalla rete)
                     prepareData
                     Elements ------->
                                      processIncomingMsg -->
                                                            (controllare sicurezza)
                                      &lt;------------------
                     &lt;--------------
processPdu &lt;--------

                     (applicazione elabora la richiesta)

returnResponsePdu ->
                     prepareResponse
                     Message -------->
                                      generateResponseMsg ->
                                                            (applicare sicurezza)
                                      &lt;------------------
                     &lt;--------------
                     (inviare messaggio alla rete)

Questi diagrammi illustrano il design modulare dell'architettura e la chiara separazione delle responsabilità tra i diversi sottosistemi.