Common Interface to Cryptographic Modules (CICM) Channel Management

This memo defines a programming interface for the management of cryptographic channels as outlined in draft-lanz-cicm-lm-00 and required by draft-lanz-cicm-02 including creating and negotiating channels for encryption, decryption, bypass, data integrity, or to generate random data.

Comments are solicited and should be addressed to the mailing list at cicm@ietf.org.

Status of this Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at http://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as “work in progress.”

This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License.

1. Introduction
    1.1. Requirements Language
    1.2. Definition Language
    1.3. Conformance and Extension Language
2. CICM Dependencies
    2.1. Namespaces
    2.2. Types
    2.3. Interfaces
3. Channel Namespaces
4. Channel Abstractions
    4.1. Algorithm Types
    4.2. State Vector
    4.3. Integrity Buffers
    4.4. Interface CICM::ChannelManager
    4.5. Interface CICM::Channel
    4.6. Interface CICM::Conduit
    4.7. Interface CICM::Controller
    4.8. Interface CICM::Stream
5. Conduit Abstractions
    5.1. Interface CICM::AbstractMACConduit
    5.2. Interface CICM::AbstractSignConduit
    5.3. Interface CICM::AbstractVerifyConduit
    5.4. Interface CICM::AbstractMACVerifyConduit
    5.5. Interface CICM::AbstractSigVerifyConduit
6. Stream Abstractions
    6.1. Interface CICM::WriteStream
    6.2. Interface CICM::ReadStream
7. Controller Abstractions
    7.1. Interface CICM::MultiDomainController
    7.2. Interface CICM::SymKeyController
    7.3. Interface CICM::AsymKeyController
    7.4. Interface CICM::NegotiatedController
    7.5. Interface CICM::SetVectorController
    7.6. Interface CICM::GenVectorController
    7.7. Interface CICM::ResyncController
8. Channel Negotiation
    8.1. Negotiating Channels and Controllers
    8.2. Interface CICM::Negotiator
    8.3. Interface CICM::PeerInfo
9. Encryption
    9.1. Interface CICM::Encrypt::ChannelManager
    9.2. Interface CICM::Encrypt::Stream
    9.3. Interface CICM::Encrypt::KeyWrapStream
    9.4. Interface CICM::Encrypt::Controller
    9.5. Interface CICM::Encrypt::NegotiatedController
    9.6. Interface CICM::Encrypt::Conduit
    9.7. Interface CICM::Encrypt::NegotiatedConduit
    9.8. Interface CICM::Encrypt::WithMACConduit
    9.9. Interface CICM::Encrypt::WithMACNegotiatedConduit
    9.10. Interface CICM::Encrypt::WithSignConduit
    9.11. Interface CICM::Encrypt::WithSignNegotiatedConduit
    9.12. Interface CICM::Encrypt::KeyWrapConduit
    9.13. Interface CICM::Encrypt::ControllerNegotiator
    9.14. Interface CICM::Encrypt::Negotiator
    9.15. Interface CICM::Encrypt::WithMACNegotiator
    9.16. Interface CICM::Encrypt::WithSignNegotiator
10. Decryption
    10.1. Interface CICM::Decrypt::ChannelManager
    10.2. Interface CICM::Decrypt::Stream
    10.3. Interface CICM::Decrypt::KeyUnwrapStream
    10.4. Interface CICM::Decrypt::Controller
    10.5. Interface CICM::Decrypt::NegotiatedController
    10.6. Interface CICM::Decrypt::Conduit
    10.7. Interface CICM::Decrypt::NegotiatedConduit
    10.8. Interface CICM::Decrypt::WithMACConduit
    10.9. Interface CICM::Decrypt::WithMACNegotiatedConduit
    10.10. Interface CICM::Decrypt::WithVerifyConduit
    10.11. Interface CICM::Decrypt::WithVerifyNegotiatedConduit
    10.12. Interface CICM::Decrypt::KeyUnwrapConduit
    10.13. Interface CICM::Decrypt::Negotiator
    10.14. Interface CICM::Decrypt::ControllerNegotiator
    10.15. Interface CICM::Decrypt::WithMACNegotiator
    10.16. Interface CICM::Decrypt::WithVerifyNegotiator
11. Duplex
    11.1. Interface CICM::Duplex::ChannelManager
    11.2. Interface CICM::Duplex::Stream
    11.3. Interface CICM::Duplex::Controller
    11.4. Interface CICM::Duplex::NegotiatedController
    11.5. Interface CICM::Duplex::Conduit
    11.6. Interface CICM::Duplex::NegotiatedConduit
    11.7. Interface CICM::Duplex::ControllerNegotiator
    11.8. Interface CICM::Duplex::Negotiator
12. Bypass (Send)
    12.1. Interface CICM::BypassWrite::ChannelManager
    12.2. Interface CICM::BypassWrite::Stream
    12.3. Interface CICM::BypassWrite::Controller
    12.4. Interface CICM::BypassWrite::Conduit
13. Bypass (Read)
    13.1. Interface CICM::BypassRead::ChannelManager
    13.2. Interface CICM::BypassRead::Stream
    13.3. Interface CICM::BypassRead::Controller
    13.4. Interface CICM::BypassRead::Conduit
14. Encryption with Selective Bypass
    14.1. Interface CICM::EncryptBypass::ChannelManager
    14.2. Interface CICM::EncryptBypass::Stream
    14.3. Interface CICM::EncryptBypass::NegotiatedController
    14.4. Interface CICM::EncryptBypass::Controller
    14.5. Interface CICM::EncryptBypass::Conduit
    14.6. Interface CICM::EncryptBypass::NegotiatedConduit
    14.7. Interface CICM::EncryptBypass::ControllerNegotiator
    14.8. Interface CICM::EncryptBypass::Negotiator
15. Decryption with Selective Bypass
    15.1. Interface CICM::DecryptBypass::ChannelManager
    15.2. Interface CICM::DecryptBypass::Stream
    15.3. Interface CICM::DecryptBypass::Controller
    15.4. Interface CICM::DecryptBypass::NegotiatedController
    15.5. Interface CICM::DecryptBypass::Conduit
    15.6. Interface CICM::DecryptBypass::NegotiatedConduit
    15.7. Interface CICM::DecryptBypass::ControllerNegotiator
    15.8. Interface CICM::DecryptBypass::Negotiator
16. Random, Pseudorandom and Keystream
    16.1. Interface CICM::Emit::ChannelManager
    16.2. Interface CICM::Emit::GetStream
    16.3. Interface CICM::Emit::Controller
    16.4. Interface CICM::Emit::RandomController
    16.5. Interface CICM::Emit::RandomConduit
    16.6. Interface CICM::Emit::PseudoRandomController
    16.7. Interface CICM::Emit::PseudoRandomConduit
    16.8. Interface CICM::Emit::KeyStreamGenController
    16.9. Interface CICM::Emit::KeyStreamGenConduit
17. Data Integrity
    17.1. Interface CICM::Answer::ChannelManager
    17.2. Interface CICM::Answer::PutStream
    17.3. Interface CICM::Answer::HashConduit
    17.4. Interface CICM::Answer::MACConduit
    17.5. Interface CICM::Answer::MACVerifyConduit
    17.6. Interface CICM::Answer::SignConduit
    17.7. Interface CICM::Answer::SignHashConduit
    17.8. Interface CICM::Answer::VerifyConduit
    17.9. Interface CICM::Answer::VerifyHashConduit
18. Single-Domain
    18.1. Interface CICM::Coprocessor::ChannelManager
    18.2. Interface CICM::Coprocessor::Stream
    18.3. Interface CICM::Coprocessor::EncryptConduit
    18.4. Interface CICM::Coprocessor::EncryptWithMACConduit
    18.5. Interface CICM::Coprocessor::EncryptWithSignConduit
    18.6. Interface CICM::Coprocessor::DecryptConduit
    18.7. Interface CICM::Coprocessor::DecryptWithMACConduit
    18.8. Interface CICM::Coprocessor::DecryptWithVerifyConduit
19. Channel Events
    19.1. Interface CICM::ChannelEventManager
    19.2. Interface CICM::ChannelEventListener
20. Channel Groups
    20.1. Interface CICM::ControllerGroup
21. IANA Considerations
22. Security Considerations
    22.1. Confidentiality
    22.2. Bypass
    22.3. Data Integrity
    22.4. Peer Entity Authentication
23. References
    23.1. Normative References
    23.2. Informative References
Appendix A. IDL Definitions
§ Authors' Addresses

1. Introduction

1.1. Requirements Language

1.2. Definition Language

1.3. Conformance and Extension Language

2. CICM Dependencies

This document depends on type definitions and interfaces that are defined in other CICM documents.

2.1. Namespaces

2.2. Types

2.3. Interfaces

3. Channel Namespaces

Due to the large number of potential configurations, the definitions of the channel types and their operations are divided into ten namespaces which group together similar or related types of channels.

4. Channel Abstractions

4.1. Algorithm Types

Value that indicates that the encryption algorithm is implicit in the key being provided to the module.

Value that indicates that the signature algorithm is implicit in the key being provided to the module.

Unique key wrap algorithm identifier, incorporating both the algorithm and the mode.

Value that indicates that the key wrap algorithm is implicit in the key being provided to the module.

Unique symmetric encryption algorithm identifier, incorporating both the algorithm and the mode.

Value that indicates that the encryption algorithm is implicit in the key being provided to the module.

Value that indicates that the MAC algorithm is implicit in the key being provided to the module.

Value that indicates that the key agreement protocol is implicit in the message being provided to the module.

4.2. State Vector

State vector, used to represent initialization vectors, synchronization vectors, counter values, and time-of-day values.

4.3. Integrity Buffers

4.4. Interface CICM::ChannelManager

CICM::ChannelManager supports the creation and negotiation of cryptographic channels. It is accessed from CICM::CryptoModule via the CICM::CryptoModule::channel_manager attribute. CICM::ChannelManager enables a variety of different channel types to be constructed.

4.4.1. CICM::ChannelManager Inheritance

CICM::ChannelManager inherits from: CICM::Answer::ChannelManager, CICM::BypassRead::ChannelManager, CICM::BypassWrite::ChannelManager, CICM::Coprocessor::ChannelManager, CICM::Decrypt::ChannelManager, CICM::DecryptBypass::ChannelManager, CICM::Duplex::ChannelManager, CICM::Emit::ChannelManager, CICM::Encrypt::ChannelManager and CICM::EncryptBypass::ChannelManager.

4.4.2. CICM::ChannelManager Methods

4.5. Interface CICM::Channel

Defines the logical path through the module. Interface from which all conduit, streams and controllers inherit. Channels are created via the CICM::ChannelManager interface.

4.5.1. CICM::Channel Attributes

4.6. Interface CICM::Conduit

Interface from which all other conduits are inherited. A conduit is a combination of a stream and controller.

4.6.1. CICM::Conduit Inheritance

4.7. Interface CICM::Controller

Interface from which all other controllers are inherited. Controls general characteristics of a cryptographic transformation, but does not provide data to be transformed.

4.7.1. CICM::Controller Inheritance

4.7.2. CICM::Controller Methods

4.8. Interface CICM::Stream

Interface from which all streams inherit. Streams manage the flow of data on a channel, but not its attributes.

4.8.1. CICM::Stream Inheritance

5. Conduit Abstractions

5.1. Interface CICM::AbstractMACConduit

5.1.1. CICM::AbstractMACConduit Inheritance

5.1.2. CICM::AbstractMACConduit Attributes

5.1.3. CICM::AbstractMACConduit Methods

Direct the module to compute and output the MAC value, and reset the channel to accept additional data.

5.2. Interface CICM::AbstractSignConduit

5.2.1. CICM::AbstractSignConduit Inheritance

5.2.2. CICM::AbstractSignConduit Attributes

5.2.3. CICM::AbstractSignConduit Methods

Direct the module to compute and output the signature, and reset the conduit to accept additional data.

5.3. Interface CICM::AbstractVerifyConduit

5.3.1. CICM::AbstractVerifyConduit Inheritance

5.3.2. CICM::AbstractVerifyConduit Types and Constants

5.4. Interface CICM::AbstractMACVerifyConduit

5.4.1. CICM::AbstractMACVerifyConduit Inheritance

5.4.2. CICM::AbstractMACVerifyConduit Attributes

5.4.3. CICM::AbstractMACVerifyConduit Methods

Direct the module to compute and output the MAC verification status, and reset the channel to accept additional data for verification.

5.5. Interface CICM::AbstractSigVerifyConduit

5.5.1. CICM::AbstractSigVerifyConduit Inheritance

5.5.2. CICM::AbstractSigVerifyConduit Attributes

5.5.3. CICM::AbstractSigVerifyConduit Methods

Direct the module to compute and output the verification status, and reset the channel to accept additional data for verification.

6. Stream Abstractions

6.1. Interface CICM::WriteStream

6.1.1. CICM::WriteStream Inheritance

6.1.2. CICM::WriteStream Types and Constants

6.2. Interface CICM::ReadStream

6.2.1. CICM::ReadStream Inheritance

6.2.2. CICM::ReadStream Types and Constants

7. Controller Abstractions

7.1. Interface CICM::MultiDomainController

Interface from which any other multi-domain-related controller or conduit inherits.

7.1.1. CICM::MultiDomainController Inheritance

7.1.2. CICM::MultiDomainController Attributes

7.2. Interface CICM::SymKeyController

7.2.1. CICM::SymKeyController Inheritance

7.2.2. CICM::SymKeyController Attributes

7.2.3. CICM::SymKeyController Methods

Cryptographically update the key associated with this controller using the key's native algorithm.

Cryptographically update the key associated with this controller using the specified algorithm.

7.3. Interface CICM::AsymKeyController

7.3.1. CICM::AsymKeyController Inheritance

7.3.2. CICM::AsymKeyController Attributes

7.4. Interface CICM::NegotiatedController

Interface from which all other negotiated controllers inherit. A controller that uses a negotiated key.

7.4.1. CICM::NegotiatedController Inheritance

CICM::NegotiatedController inherits from: CICM::MultiDomainController, CICM::AsymKeyController and CICM::Negotiator.

7.4.2. CICM::NegotiatedController Attributes

7.4.3. CICM::NegotiatedController Methods

7.5. Interface CICM::SetVectorController

7.5.1. CICM::SetVectorController Inheritance

7.5.2. CICM::SetVectorController Attributes

7.5.3. CICM::SetVectorController Methods

7.6. Interface CICM::GenVectorController

7.6.1. CICM::GenVectorController Inheritance

7.6.2. CICM::GenVectorController Methods

7.7. Interface CICM::ResyncController

7.7.1. CICM::ResyncController Inheritance

7.7.2. CICM::ResyncController Methods

Resynchronize the channel, using the specified synchronization vector (required by certain operating modes to initiate a resync).

8. Channel Negotiation

8.1. Negotiating Channels and Controllers

When creating an encryption or decryption channel using an asymmetric keyset, a negotiation process must be initiated between the two communicating entities, resulting in an ephemeral symmetric key held by each entity. The following details the steps in the negotiation process:

8.2. Interface CICM::Negotiator

CICM::Negotiator is an abstraction inherited by controllers and CICM::KeyProtocolSender to assist in the management of the negotiation process.

8.2.1. CICM::Negotiator Methods

Retrieve remote peer identification information. The peer information must be displayed to the local user to enable determination to be made as to whether negotiation should continue or be aborted. If the decision is made to abort negotiation, the CICM::Negotiator::abort_negotiation method MUST be called to destroy any protocol session state.

Abort negotiation or renegotiation. This method must be called in the event the identification information for the remote host does not correspond to the expected host.

8.3. Interface CICM::PeerInfo

8.3.1. CICM::PeerInfo Attributes

Highest security classification level at which the remote entity participating in the key agreement protocol is capable of communicating.

Message to be displayed regarding the remote entities' participation in key agreement protocol.

9. Encryption

The CICM::Encrypt namespace contains interfaces that support encryption operations between two independent security domains.

9.1. Interface CICM::Encrypt::ChannelManager

CICM::Encrypt::ChannelManager is an abstraction inherited by CICM::ChannelManager that supports the creation of encryption negotiators, conduits, controllers, and streams. See CICM::ChannelManager for additional information.

9.1.1. CICM::Encrypt::ChannelManager Methods

Initiate a negotiation to establish a shared key with a peer. The channel that results will encrypt a stream of data.

Initiate a negotiation to establish a shared key with a peer. The channel that results will MAC and encrypt a stream of data.

Initiate a negotiation to establish a shared key with a peer. The channel that results will sign and encrypt a stream of data.

Initiate a negotiation to establish a shared key with a peer, resulting in a controller to manage an encryption channel.

Create stream associated with previously created controller to accept data for transformation.

9.2. Interface CICM::Encrypt::Stream

CICM::Encrypt::Stream supports encryption operations between two independent security domains. The resulting stream is capable of accepting data for transformation, but not managing the channel. It is created by calling CICM::ChannelManager::get_encrypt_stream.

9.2.1. CICM::Encrypt::Stream Inheritance

9.2.2. CICM::Encrypt::Stream Methods

Registers a buffer of data to be sent to the module for encryption and then immediately returns control to the caller. The length of the data is encapsulated in the buffer parameter. The caller may use the CICM::Encrypt::Stream::encrypt_poll method to proactively poll the channel to determine the status of the operation. The caller is responsible for maintaining any necessary metadata associated with the transaction_id parameter. Memory responsibilities and calling conventions MUST follow the appropriate IDL language mapping conventions.

Returns the status of the non-blocking encryption operation specified by the transaction_id parameter. Memory responsibilities and calling conventions shall follow the appropriate IDL language mapping conventions.

9.3. Interface CICM::Encrypt::KeyWrapStream

CICM::Encrypt::KeyWrapStream is an abstraction that allows key material to be presented to a stream for wrapping prior to passing into a different security domain.

9.3.1. CICM::Encrypt::KeyWrapStream Inheritance

9.3.2. CICM::Encrypt::KeyWrapStream Methods

9.4. Interface CICM::Encrypt::Controller

CICM::Encrypt::Controller supports encryption operations between two independent security domains. The resulting controller is capable of managing the channel, but not accepting data for transformation. It is created by calling CICM::ChannelManager::create_encrypt_controller.

9.4.1. CICM::Encrypt::Controller Inheritance

CICM::Encrypt::Controller inherits from: CICM::MultiDomainController, CICM::SymKeyController, CICM::GenVectorController and CICM::ResyncController.

9.5. Interface CICM::Encrypt::NegotiatedController

CICM::Encrypt::NegotiatedController is the negotiated version of CICM::Encrypt::Controller. It is the result of a successful negotiation by CICM::Encrypt::ControllerNegotiator.

9.5.1. CICM::Encrypt::NegotiatedController Inheritance

CICM::Encrypt::NegotiatedController inherits from: CICM::NegotiatedController, CICM::GenVectorController and CICM::ResyncController.

9.6. Interface CICM::Encrypt::Conduit

CICM::Encrypt::Conduit supports encryption operations between two independent security domains. The resulting conduit is capable of both managing the channel and accepting data for transformation. It is created by calling CICM::ChannelManager::create_encrypt_conduit.

9.6.1. CICM::Encrypt::Conduit Inheritance

CICM::Encrypt::Conduit inherits from: CICM::Conduit, CICM::Encrypt::Controller and CICM::Encrypt::Stream.

9.7. Interface CICM::Encrypt::NegotiatedConduit

CICM::Encrypt::NegotiatedConduit is the negotiated version of CICM::Encrypt::Conduit. It is the result of a successful negotiation by CICM::Encrypt::Negotiator.

9.7.1. CICM::Encrypt::NegotiatedConduit Inheritance

CICM::Encrypt::NegotiatedConduit inherits from: CICM::Conduit, CICM::Encrypt::NegotiatedController and CICM::Encrypt::Stream.

9.8. Interface CICM::Encrypt::WithMACConduit

CICM::Encrypt::WithMACConduit supports encryption operations between two independent security domains with the receipt of a MAC value in the initiating domain. The resulting conduit is capable of both managing the channel and accepting data for transformation. It is created by calling CICM::ChannelManager::create_encrypt_with_mac_conduit.

9.8.1. CICM::Encrypt::WithMACConduit Inheritance

CICM::Encrypt::WithMACConduit inherits from: CICM::AbstractMACConduit and CICM::Encrypt::Conduit.

9.9. Interface CICM::Encrypt::WithMACNegotiatedConduit

CICM::Encrypt::WithMACNegotiatedConduit is the negotiated version of CICM::Encrypt::WithMACConduit. It is the result of a successful negotiation by CICM::Encrypt::WithMACNegotiator.

9.9.1. CICM::Encrypt::WithMACNegotiatedConduit Inheritance

CICM::Encrypt::WithMACNegotiatedConduit inherits from: CICM::AbstractMACConduit and CICM::Encrypt::NegotiatedConduit.

9.10. Interface CICM::Encrypt::WithSignConduit

CICM::Encrypt::WithSignConduit supports encryption operations between two independent security domains with the receipt of a signature value in the initiating domain. The resulting conduit is capable of both managing the channel and accepting data for transformation. It is created by calling CICM::ChannelManager::create_encrypt_with_sign_conduit.

9.10.1. CICM::Encrypt::WithSignConduit Inheritance

CICM::Encrypt::WithSignConduit inherits from: CICM::AbstractSignConduit and CICM::Encrypt::Conduit.

9.11. Interface CICM::Encrypt::WithSignNegotiatedConduit

CICM::Encrypt::WithSignNegotiatedConduit is the negotiated version of CICM::Encrypt::WithSignConduit. It is the result of a successful negotiation by CICM::Encrypt::WithSignNegotiator.

9.11.1. CICM::Encrypt::WithSignNegotiatedConduit Inheritance

CICM::Encrypt::WithSignNegotiatedConduit inherits from: CICM::AbstractSignConduit and CICM::Encrypt::NegotiatedConduit.

9.12. Interface CICM::Encrypt::KeyWrapConduit

CICM::Encrypt::KeyWrapConduit supports key wrapping operations between two independent security domains. The resulting conduit is capable of both managing the channel and accepting keys for transformation. It is created by calling CICM::ChannelManager::create_key_wrap_conduit.

9.12.1. CICM::Encrypt::KeyWrapConduit Inheritance

CICM::Encrypt::KeyWrapConduit inherits from: CICM::Encrypt::Controller and CICM::Encrypt::KeyWrapStream.

9.13. Interface CICM::Encrypt::ControllerNegotiator

CICM::Encrypt::ControllerNegotiator initiates a negotiation to establish a shared key with a remote entity that is used to support encryption operations between two independent security domains. The result of a successful negotiation is a CICM::Encrypt::NegotiatedController which is capable of managing the channel, but not accepting data for transformation. CICM::Encrypt::ControllerNegotiator is created by calling CICM::ChannelManager::negotiate_encrypt_controller.

9.13.1. CICM::Encrypt::ControllerNegotiator Inheritance

9.13.2. CICM::Encrypt::ControllerNegotiator Methods

9.14. Interface CICM::Encrypt::Negotiator

CICM::Encrypt::Negotiator initiates a negotiation to establish a shared key with a remote entity that is used to support encryption operations between two independent security domains. The result of a successful negotiation is a CICM::Encrypt::NegotiatedConduit which is capable of both managing the channel and accepting data for transformation. CICM::Negotiator is created by calling CICM::Encrypt::ChannelManager::negotiate_encrypt_conduit.

9.14.1. CICM::Encrypt::Negotiator Inheritance

9.14.2. CICM::Encrypt::Negotiator Methods

9.15. Interface CICM::Encrypt::WithMACNegotiator

CICM::Encrypt::WithMACNegotiator initiates a negotiation to establish a shared key with a remote entity that is used to support encryption operations between two independent security domains. Additionally, a message authentication code (MAC) is received in the initiating domain. The result of a successful negotiation is a CICM::Encrypt::WithMACNegotiatedConduit which is capable of both managing the channel and accepting data for transformation. CICM::Encrypt::WithMACNegotiator is created by calling CICM::ChannelManager::negotiate_encrypt_with_mac_conduit.

9.15.1. CICM::Encrypt::WithMACNegotiator Inheritance

9.15.2. CICM::Encrypt::WithMACNegotiator Methods

9.16. Interface CICM::Encrypt::WithSignNegotiator

CICM::Encrypt::WithSignNegotiator initiates a negotiation to establish a shared key with a remote entity that is used to support encryption operations between two independent security domains. Additionally, a signature value is received in the initiating domain. The result of a successful negotiation is a CICM::Encrypt::WithSignNegotiatedConduit which is capable of both managing the channel and accepting data for transformation. CICM::Encrypt::WithSignNegotiator is created by calling CICM::ChannelManager::negotiate_encrypt_with_sign_conduit.

9.16.1. CICM::Encrypt::WithSignNegotiator Inheritance

9.16.2. CICM::Encrypt::WithSignNegotiator Methods

10. Decryption

The CICM::Decrypt namespace contains interfaces that support decryption operations between two independent security domains.

10.1. Interface CICM::Decrypt::ChannelManager

CICM::Decrypt::ChannelManager is an abstraction inherited by CICM::ChannelManager that supports the creation of decryption negotiators, conduits, controllers, and streams. See CICM::ChannelManager for additional information.

10.1.1. CICM::Decrypt::ChannelManager Methods

Creates a negotiator that, upon successful negotiation, results in a CICM::Decrypt::NegotiatedConduit.

Creates a negotiator that, upon successful negotiation, results in a CICM::Decrypt::MACNegotiatedConduit.

Initiate a negotiation to establish a shared key with a peer. The channel that results will decrypt and verify a stream of data.

Initiate a negotiation to establish a shared key with a peer, resulting in a controller to manage a decryption channel.

Create channel to unwrap a key. This type of channel may be used to bulk unwrap key material originating at a key infrastructure component or from a peer cryptographic module. Note that, to unwrap individual keys already in the module, use CICM::Symkey::unwrap or CICM::Asymkey::unwrap.

Create stream associated with previously created controller to receive transformed data.

10.2. Interface CICM::Decrypt::Stream

CICM::Decrypt::Stream supports decryption operations between two independent security domains. The resulting stream is capable of accepting transformed data, but not managing the channel. It is created by calling CICM::ChannelManager::get_decrypt_stream.

10.2.1. CICM::Decrypt::Stream Inheritance

10.2.2. CICM::Decrypt::Stream Methods

Read plaintext data off of decrypt channel stream. The method blocks until data becomes available.

Registers a buffer into which plaintext resulting from the decryption operation will be copied, and then immediately returns control to the caller. The size of the allocated buffer and length of the resulting plaintext is encapsulated in the buffer parameter. The caller may use the CICM::Decrypt::Stream::decrypt_poll method to proactively poll the channel to determine the status of the operation. The caller is responsible for maintaining any necessary metadata associated with the transaction_id parameter. Memory responsibilities and calling conventions shall follow the appropriate IDL language mapping conventions.

Returns the status of the non-blocking decryption operation specified by the transaction_id parameter. Upon completion of the operation, the caller must use the metadata associated with the transaction_id parameter to determine which buffer has been populated. Memory responsibilities and calling conventions shall follow the appropriate IDL language mapping conventions.

10.3. Interface CICM::Decrypt::KeyUnwrapStream

CICM::Decrypt::KeyUnwrapStream is an abstraction that allows unwrapped key material received from another domain to be retrieved.

10.3.1. CICM::Decrypt::KeyUnwrapStream Inheritance

10.3.2. CICM::Decrypt::KeyUnwrapStream Methods

Read one unwrapped symmetric key off of channel stream and return a reference to the key. The method blocks until a key becomes available.

Read one unwrapped asymmetric key off of channel stream and return a reference to the key. The method blocks until a key becomes available.

10.4. Interface CICM::Decrypt::Controller

CICM::Decrypt::Controller supports decryption operations between two independent security domains. The resulting controller is capable of managing the channel, but not accepting transformed data. It is created by calling CICM::ChannelManager::create_decrypt_controller.

10.4.1. CICM::Decrypt::Controller Inheritance

CICM::Decrypt::Controller inherits from: CICM::MultiDomainController, CICM::SymKeyController, CICM::SetVectorController and CICM::ResyncController.

10.5. Interface CICM::Decrypt::NegotiatedController

CICM::Decrypt::NegotiatedController is the negotiated version of CICM::Decrypt::Controller. It is the result of a successful negotiation by CICM::Decrypt::ControllerNegotiator.

10.5.1. CICM::Decrypt::NegotiatedController Inheritance

CICM::Decrypt::NegotiatedController inherits from: CICM::NegotiatedController, CICM::SetVectorController and CICM::ResyncController.

10.6. Interface CICM::Decrypt::Conduit

CICM::Decrypt::Conduit supports decryption operations between two independent security domains. The resulting conduit is capable of both managing the channel and accepting transformed data. It is created by calling CICM::ChannelManager::create_decrypt_conduit.

10.6.1. CICM::Decrypt::Conduit Inheritance

CICM::Decrypt::Conduit inherits from: CICM::Conduit, CICM::Decrypt::Controller and CICM::Decrypt::Stream.

10.7. Interface CICM::Decrypt::NegotiatedConduit

CICM::Decrypt::NegotiatedConduit is the negotiated version of CICM::Decrypt::Conduit. It is the result of a successful negotiation by CICM::Decrypt::Negotiator.

10.7.1. CICM::Decrypt::NegotiatedConduit Inheritance

CICM::Decrypt::NegotiatedConduit inherits from: CICM::Conduit, CICM::Decrypt::NegotiatedController and CICM::Decrypt::Stream.

10.8. Interface CICM::Decrypt::WithMACConduit

CICM::Decrypt::WithMACConduit supports decryption operations between two independent security domains with the receipt of an indication as to whether MAC verification succeeded or failed in the initiating domain. The resulting conduit is capable of both managing the channel and accepting data for transformation. It is created by calling CICM::ChannelManager::create_decrypt_with_mac_conduit.

10.8.1. CICM::Decrypt::WithMACConduit Inheritance

CICM::Decrypt::WithMACConduit inherits from: CICM::AbstractMACVerifyConduit and CICM::Decrypt::Conduit.

10.9. Interface CICM::Decrypt::WithMACNegotiatedConduit

CICM::Decrypt::WithMACNegotiatedConduit is the negotiated version of CICM::Decrypt::WithMACConduit. It is the result of a successful negotiation by CICM::Decrypt::WithMACNegotiator.

10.9.1. CICM::Decrypt::WithMACNegotiatedConduit Inheritance

CICM::Decrypt::WithMACNegotiatedConduit inherits from: CICM::AbstractMACVerifyConduit and CICM::Decrypt::NegotiatedConduit.

10.10. Interface CICM::Decrypt::WithVerifyConduit

CICM::Decrypt::WithVerifyConduit supports decryption operations between two independent security domains with the receipt of an indication as to whether signature verification succeeded or failed in the initiating domain. The resulting conduit is capable of both managing the channel and accepting transformed data. It is created by calling CICM::ChannelManager::create_decrypt_with_verify_conduit.

10.10.1. CICM::Decrypt::WithVerifyConduit Inheritance

CICM::Decrypt::WithVerifyConduit inherits from: CICM::AbstractSigVerifyConduit and CICM::Decrypt::Conduit.

10.11. Interface CICM::Decrypt::WithVerifyNegotiatedConduit

CICM::Decrypt::WithVerifyNegotiatedConduit is the negotiated version of CICM::Decrypt::WithVerifyConduit. It is the result of a successful negotiation by CICM::Decrypt::WithVerifyNegotiator.

10.11.1. CICM::Decrypt::WithVerifyNegotiatedConduit Inheritance

CICM::Decrypt::WithVerifyNegotiatedConduit inherits from: CICM::AbstractSigVerifyConduit and CICM::Decrypt::NegotiatedConduit.

10.12. Interface CICM::Decrypt::KeyUnwrapConduit

CICM::Decrypt::KeyUnwrapConduit supports key unwrapping operations between two independent security domains. The resulting conduit is capable of both managing the channel and accepting transformed keys. It is created by calling CICM::ChannelManager::create_key_unwrap_conduit.

10.12.1. CICM::Decrypt::KeyUnwrapConduit Inheritance

CICM::Decrypt::KeyUnwrapConduit inherits from: CICM::Decrypt::Controller and CICM::Decrypt::KeyUnwrapStream.

10.13. Interface CICM::Decrypt::Negotiator

CICM::Decrypt::Negotiator initiates a negotiation to establish a shared key with a remote entity that is used to support encryption operations between two independent security domains. The result of a successful negotiation is a CICM::Decrypt::NegotiatedConduit which is capable of both managing the channel and accepting data for transformation. CICM::Decrypt::Negotiator is created by calling CICM::ChannelManager::negotiate_decrypt_conduit.

10.13.1. CICM::Decrypt::Negotiator Inheritance

10.13.2. CICM::Decrypt::Negotiator Methods

10.14. Interface CICM::Decrypt::ControllerNegotiator

CICM::Decrypt::ControllerNegotiator initiates a negotiation to establish a shared key with a remote entity that is used to support decryption operations between two independent security domains. The result of a successful negotiation is a CICM::Decrypt::NegotiatedController which is capable of managing the channel, but not accepting data for transformation. CICM::Decrypt::ControllerNegotiator is created by calling CICM::ChannelManager::negotiate_decrypt_controller.

10.14.1. CICM::Decrypt::ControllerNegotiator Inheritance

10.14.2. CICM::Decrypt::ControllerNegotiator Methods

10.15. Interface CICM::Decrypt::WithMACNegotiator

CICM::Decrypt::WithMACNegotiator initiates a negotiation to establish a shared key with a remote entity that is used to support decryption operations between two independent security domains. Additionally, a message authentication code is received in the initiating domain. The result of a successful negotiation is a CICM::Decrypt::WithMACNegotiatedConduit which is capable of both managing the channel and accepting data for transformation. CICM::Decrypt::WithMACNegotiator is created by calling CICM::ChannelManager::negotiate_decrypt_with_mac_conduit.

10.15.1. CICM::Decrypt::WithMACNegotiator Inheritance

10.15.2. CICM::Decrypt::WithMACNegotiator Methods

10.16. Interface CICM::Decrypt::WithVerifyNegotiator

CICM::Decrypt::WithVerifyNegotiator initiates a negotiation to establish a shared key with a remote entity that is used to support decryption operations between two independent security domains. Additionally, an indication as to whether verification succeeded or failed is received in the initiating domain. The result of a successful negotiation is a CICM::Decrypt::WithVerifyNegotiatedConduit which is capable of both managing the channel and accepting data for transformation. CICM::Decrypt::WithVerifyNegotiator is created by calling CICM::ChannelManager::negotiate_decrypt_with_verify_conduit.

10.16.1. CICM::Decrypt::WithVerifyNegotiator Inheritance

10.16.2. CICM::Decrypt::WithVerifyNegotiator Methods

11. Duplex

The CICM::Duplex namespace contains interfaces that support encryption/decryption operations between two independent security domains.

11.1. Interface CICM::Duplex::ChannelManager

CICM::Duplex::ChannelManager is an abstraction inherited by CICM::ChannelManager that supports the creation of encryption/decryption negotiators, conduits, controllers, and streams. See CICM::ChannelManager for additional information.

11.1.1. CICM::Duplex::ChannelManager Methods

Initiate a negotiation to establish a shared key with a peer, resulting in a conduit that results will encrypt/decrypt data.

Initiate a negotiation to establish a shared key with a peer, resulting in a controller to manage a duplex channel.

Create stream associated with previously created controller to accept data for transformation.

11.2. Interface CICM::Duplex::Stream

CICM::Duplex::Stream supports encryption/decryption operations between two independent security domains. The resulting stream is capable of accepting data for transformation and receiving transformed data, but not managing the channel. It is created by calling CICM::ChannelManager::get_duplex_stream.

11.2.1. CICM::Duplex::Stream Inheritance

CICM::Duplex::Stream inherits from: CICM::Encrypt::Stream and CICM::Decrypt::Stream.

11.3. Interface CICM::Duplex::Controller

CICM::Duplex::Controller supports encryption/decryption operations between two independent security domains. The resulting controller is capable of managing the channel, but not accepting data for transformation and receiving transformed data. It is created by calling CICM::ChannelManager::create_duplex_controller.

11.3.1. CICM::Duplex::Controller Inheritance

CICM::Duplex::Controller inherits from: CICM::Encrypt::Controller and CICM::Decrypt::Controller.

11.4. Interface CICM::Duplex::NegotiatedController

CICM::Duplex::NegotiatedController is the negotiated version of CICM::Duplex::Controller. It is the result of a successful negotiation by CICM::Duplex::ControllerNegotiator.

11.4.1. CICM::Duplex::NegotiatedController Inheritance

CICM::Duplex::NegotiatedController inherits from: CICM::Encrypt::NegotiatedController and CICM::Decrypt::NegotiatedController.

11.5. Interface CICM::Duplex::Conduit

CICM::Duplex::Conduit supports encryption/decryption operations between two independent security domains. The resulting conduit is capable of both managing the channel and accepting data for transformation and receiving transformed data. It is created by calling CICM::ChannelManager::create_duplex_conduit.

11.5.1. CICM::Duplex::Conduit Inheritance

CICM::Duplex::Conduit inherits from: CICM::Conduit, CICM::Duplex::Controller and CICM::Duplex::Stream.

11.6. Interface CICM::Duplex::NegotiatedConduit

CICM::Duplex::NegotiatedConduit is the negotiated version of CICM::Duplex::Conduit. It is the result of a successful negotiation by CICM::Duplex::Negotiator.

11.6.1. CICM::Duplex::NegotiatedConduit Inheritance

CICM::Duplex::NegotiatedConduit inherits from: CICM::Duplex::NegotiatedController and CICM::Duplex::Stream.

11.7. Interface CICM::Duplex::ControllerNegotiator

CICM::Duplex::ControllerNegotiator initiates a negotiation to establish a shared key with a remote entity that is used to support encryption/decryption operations between two independent security domains. The result of a successful negotiation is a CICM::Duplex::NegotiatedController which is capable of managing the channel, but not accepting data for transformation. CICM::Duplex::ControllerNegotiator is created by calling CICM::ChannelManager::negotiate_duplex_controller.

11.7.1. CICM::Duplex::ControllerNegotiator Inheritance

11.7.2. CICM::Duplex::ControllerNegotiator Methods

11.8. Interface CICM::Duplex::Negotiator

CICM::Duplex::Negotiator initiates a negotiation to establish a shared key with a remote entity that is used to support encryption/decryption operations between two independent security domains. The result of a successful negotiation is a CICM::Duplex::NegotiatedConduit which is capable of both managing the channel and accepting data for transformation. CICM::Duplex::Negotiator is created by calling CICM::ChannelManager::negotiate_duplex_conduit.

11.8.1. CICM::Duplex::Negotiator Inheritance

11.8.2. CICM::Duplex::Negotiator Methods

12. Bypass (Send)

The CICM::BypassWrite namespace contains channels that support full bypass write operations between two independent security domains.

12.1. Interface CICM::BypassWrite::ChannelManager

CICM::BypassWrite::ChannelManager is an abstraction inherited by CICM::ChannelManager that supports the creation of full bypass conduits, controllers, and streams for writing. See CICM::ChannelManager for additional information.

12.1.1. CICM::BypassWrite::ChannelManager Methods

Returns the stream corresponding to a pre-existing controller on the given local port.

12.2. Interface CICM::BypassWrite::Stream

CICM::BypassWrite::Stream supports full bypass between two independent security domains. The resulting stream is capable of accepting data for bypass, but not managing the channel. It is created by calling CICM::ChannelManager::get_bypass_write_stream.

12.2.1. CICM::BypassWrite::Stream Inheritance

12.2.2. CICM::BypassWrite::Stream Methods

Write bypass data to a channel stream. The method blocks until the data has been sent.

Registers a buffer of data to be sent to the module for bypass and then immediately returns control to the caller. The length of the data is encapsulated in the buffer parameter. The caller may use the CICM::BypassWrite::Stream::write_bypass_poll method to proactively poll the channel to determine the status of the operation. The caller is responsible for maintaining any necessary metadata associated with the transaction_id parameter. Memory responsibilities and calling conventions shall follow the appropriate IDL language mapping conventions.

Returns the status of the non-blocking bypass operation specified by the transaction_id parameter. Memory responsibilities and calling conventions shall follow the appropriate IDL language mapping conventions.

12.3. Interface CICM::BypassWrite::Controller

CICM::BypassWrite::Controller supports full bypass between two independent security domains. The resulting controller is capable of managing the channel, but not accepting data for bypass. It is created by calling CICM::ChannelManager::create_bypass_write_controller.

12.3.1. CICM::BypassWrite::Controller Inheritance

12.4. Interface CICM::BypassWrite::Conduit

CICM::BypassWrite::Conduit supports full bypass between two security domains. The resulting conduit is capable of both managing the channel and accepting data for bypass. It is created by calling CICM::ChannelManager::create_bypass_write_conduit.

12.4.1. CICM::BypassWrite::Conduit Inheritance

CICM::BypassWrite::Conduit inherits from: CICM::Conduit, CICM::BypassWrite::Controller and CICM::BypassWrite::Stream.

13. Bypass (Read)

The CICM::BypassRead namespace contains channels that support full bypass read operations between two independent security domains.

13.1. Interface CICM::BypassRead::ChannelManager

CICM::BypassRead::ChannelManager is an abstraction inherited by CICM::ChannelManager that supports the creation of full bypass conduits, controllers, and streams for reading. See CICM::ChannelManager for additional information.

13.1.1. CICM::BypassRead::ChannelManager Methods

Returns the stream corresponding to a pre-existing controller on the given local port.

13.2. Interface CICM::BypassRead::Stream

CICM::BypassRead::Stream supports full bypass between two independent security domains. The resulting stream is capable of accepting bypassed data, but not managing the channel. It is created by calling CICM::ChannelManager::get_bypass_read_stream.

13.2.1. CICM::BypassRead::Stream Inheritance

13.2.2. CICM::BypassRead::Stream Methods

Read bypass data off of channel stream. The method blocks until data becomes available.

Registers a buffer into which bypass data will be copied, and then immediately returns control to the caller. The size of the allocated buffer and length of the resulting bypassed data is encapsulated in the buffer parameter. The caller may use the CICM::BypassRead::Stream::read_bypass_poll method to proactively poll the channel to determine the status of the operation. The caller is responsible for maintaining any necessary metadata associated with the transaction_id parameter. Memory responsibilities and calling conventions shall follow the appropriate IDL language mapping conventions.

Returns the status of the non-blocking bypass operation specified by the transaction_id parameter. Upon completion of the operation, the caller must use the metadata associated with the transaction_id parameter to determine which buffer has been populated. Memory responsibilities and calling conventions shall follow the appropriate IDL language mapping conventions.

13.3. Interface CICM::BypassRead::Controller

CICM::BypassRead::Controller supports full bypass between two independent security domains. The resulting controller is capable of managing the channel, but not accepting bypassed data. It is created by calling CICM::ChannelManager::create_bypass_read_controller.

13.3.1. CICM::BypassRead::Controller Inheritance

13.4. Interface CICM::BypassRead::Conduit

CICM::BypassRead::Conduit supports full bypass between two independent security domains. The resulting conduit is capable of both managing the channel and accepting bypassed data. It is created by calling CICM::ChannelManager::create_bypass_read_conduit.

13.4.1. CICM::BypassRead::Conduit Inheritance

CICM::BypassRead::Conduit inherits from: CICM::Conduit, CICM::BypassRead::Controller and CICM::BypassRead::Stream.

14. Encryption with Selective Bypass

The CICM::EncryptBypass namespace contains interfaces that support encryption with selective bypass operations between two indepenent security domains.

14.1. Interface CICM::EncryptBypass::ChannelManager

CICM::EncryptBypass::ChannelManager is an abstraction inherited by CICM::ChannelManager that supports the creation of encryption with selective bypass negotiators, conduits, controllers, and streams. See CICM::ChannelManager for additional information.

14.1.1. CICM::EncryptBypass::ChannelManager Methods

Initiate a negotiation to establish a shared key with a peer. The channel that results will selectively encrypt or bypass a stream of data.

Method CICM::EncryptBypass::ChannelManager::negotiate_encrypt_bypass_controller()

Initiate a negotiation to establish a shared key with a peer, resulting in a controller to manage an encrypt with bypass channel.

Create stream associated with previously created controller to accept data for transformation.

14.2. Interface CICM::EncryptBypass::Stream

CICM::EncryptBypass::Stream supports encryption and selective bypass operations between two independent security domains. The resulting stream is capable of accepting data for transformation, but not managing the channel. It is created by calling CICM::ChannelManager::get_encrypt_bypass_stream.

14.2.1. CICM::EncryptBypass::Stream Inheritance

CICM::EncryptBypass::Stream inherits from: CICM::Encrypt::Stream and CICM::BypassWrite::Stream.

14.3. Interface CICM::EncryptBypass::NegotiatedController

CICM::EncryptBypass::NegotiatedController is the negotiated version of CICM::EncryptBypass::Controller. It is the result of a successful negotiation by CICM::EncryptBypass::ControllerNegotiator.

14.3.1. CICM::EncryptBypass::NegotiatedController Inheritance

CICM::EncryptBypass::NegotiatedController inherits from: CICM::Encrypt::NegotiatedController.

14.4. Interface CICM::EncryptBypass::Controller

CICM::EncryptBypass::Controller supports encryption and selective bypass operations between two independent security domains. The resulting controller is capable of managing the channel, but not accepting data for transformation/bypass. It is created by calling CICM::ChannelManager::create_encrypt_bypass_controller.

14.4.1. CICM::EncryptBypass::Controller Inheritance

14.5. Interface CICM::EncryptBypass::Conduit

CICM::EncryptBypass::Conduit supports encryption and selective bypass operations between two independent security domains. The resulting conduit is capable of both managing the channel and accepting data for transformation/bypass. It is created by calling CICM::ChannelManager::create_encrypt_bypass_conduit.

14.5.1. CICM::EncryptBypass::Conduit Inheritance

CICM::EncryptBypass::Conduit inherits from: CICM::Encrypt::Conduit and CICM::EncryptBypass::Stream.

14.6. Interface CICM::EncryptBypass::NegotiatedConduit

CICM::EncryptBypass::NegotiatedConduit is the negotiated version of CICM::EncryptBypass::Conduit. It is the result of a successful negotiation by CICM::EncryptBypass::Negotiator.

14.6.1. CICM::EncryptBypass::NegotiatedConduit Inheritance

CICM::EncryptBypass::NegotiatedConduit inherits from: CICM::Encrypt::NegotiatedController and CICM::EncryptBypass::Stream.

14.7. Interface CICM::EncryptBypass::ControllerNegotiator

CICM::EncryptBypass::ControllerNegotiator initiates a negotiation to establish a shared key with a remote entity that is used to support encryption and selective bypass operations between two independent security domains. The result of a successful negotiation is a CICM::EncryptBypass::NegotiatedController which is capable of managing the channel, but not accepting data for transformation/bypass. CICM::EncryptBypass::ControllerNegotiator is created by calling CICM::ChannelManager::negotiate_encrypt_bypass_controller.

14.7.1. CICM::EncryptBypass::ControllerNegotiator Inheritance

14.7.2. CICM::EncryptBypass::ControllerNegotiator Methods

Complete negotiation and retrieve a negotiated encrypt bypass control-only channel.

14.8. Interface CICM::EncryptBypass::Negotiator

CICM::EncryptBypass::Negotiator initiates a negotiation to establish a shared key with a remote entity that is used to support encryption and bypass operations between two independent security domains. Additionally, selective bypass is supported on the same conduit. The result of a successful negotiation is a CICM::EncryptBypass::NegotiatedConduit which is capable of both managing the channel and accepting data for transformation/bypass. CICM::EncryptBypass::Negotiator is created by calling CICM::ChannelManager::negotiate_encrypt_bypass_conduit.

14.8.1. CICM::EncryptBypass::Negotiator Inheritance

14.8.2. CICM::EncryptBypass::Negotiator Methods

15. Decryption with Selective Bypass

The CICM::DecryptBypass namespace contains interfaces that support decryption with selective bypass operations between two independent security domains.

15.1. Interface CICM::DecryptBypass::ChannelManager

CICM::DecryptBypass::ChannelManager is an abstraction inherited by CICM::ChannelManager that supports the creation of decryption with selective bypass negotiators, conduits, controllers, and streams. See CICM::ChannelManager for additional information.

15.1.1. CICM::DecryptBypass::ChannelManager Methods

Initiate a negotiation to establish a shared key with a peer. The channel that results will selectively decrypt or bypass a stream of data.

Method CICM::DecryptBypass::ChannelManager::negotiate_decrypt_bypass_controller()

Initiate a negotiation to establish a shared key with a peer, resulting in a controller to manage a decrypt with bypass channel.

Create stream associated with previously created controller to receive transformed data.

15.2. Interface CICM::DecryptBypass::Stream

CICM::DecryptBypass::Stream supports decryption and selective bypass operations between two independent security domains. The resulting stream is capable of accepting transformed/bypassed data, but not managing the channel. It is created by calling CICM::ChannelManager::get_decrypt_bypass_stream.

15.2.1. CICM::DecryptBypass::Stream Inheritance

15.3. Interface CICM::DecryptBypass::Controller

CICM::DecryptBypass::Controller supports decryption and selective bypass operations between two independent security domains. The resulting controller is capable of managing the channel, but not accepting transformed/bypassed data. It is created by calling CICM::ChannelManager::create_decrypt_bypass_controller.

15.3.1. CICM::DecryptBypass::Controller Inheritance

15.4. Interface CICM::DecryptBypass::NegotiatedController

CICM::DecryptBypass::NegotiatedController is the negotiated version of CICM::DecryptBypass::Controller. It is the result of a successful negotiation by CICM::DecryptBypass::ControllerNegotiator.

15.4.1. CICM::DecryptBypass::NegotiatedController Inheritance

CICM::DecryptBypass::NegotiatedController inherits from: CICM::Decrypt::NegotiatedController.

15.5. Interface CICM::DecryptBypass::Conduit

CICM::DecryptBypass::Conduit supports decryption and selective bypass operations between two independent security domains. The resulting conduit is capable of both managing the channel and accepting transformed/bypassed data. It is created by calling CICM::ChannelManager::create_decrypt_bypass_conduit.

15.5.1. CICM::DecryptBypass::Conduit Inheritance

CICM::DecryptBypass::Conduit inherits from: CICM::Decrypt::Conduit, CICM::DecryptBypass::Controller and CICM::DecryptBypass::Stream.

15.6. Interface CICM::DecryptBypass::NegotiatedConduit

CICM::DecryptBypass::NegotiatedConduit is the negotiated version of CICM::DecryptBypass::Conduit. It is the result of a successful negotiation by CICM::DecryptBypass::Negotiator.

15.6.1. CICM::DecryptBypass::NegotiatedConduit Inheritance

CICM::DecryptBypass::NegotiatedConduit inherits from: CICM::Decrypt::NegotiatedConduit, CICM::DecryptBypass::NegotiatedController and CICM::DecryptBypass::Stream.

15.7. Interface CICM::DecryptBypass::ControllerNegotiator

CICM::DecryptBypass::ControllerNegotiator initiates a negotiation to establish a shared key with a remote entity that is used to support encryption and selective bypass operations between two independent security domains. The result of a successful negotiation is a CICM::DecryptBypass::NegotiatedController which is capable of managing the channel, but not accepting data for transformation. CICM::DecryptBypass::ControllerNegotiator is created by calling CICM::ChannelManager::negotiate_decrypt_bypass_controller.

15.7.1. CICM::DecryptBypass::ControllerNegotiator Inheritance

15.7.2. CICM::DecryptBypass::ControllerNegotiator Methods

Complete negotiation and retrieve a negotiated control-only decrypt bypass channel.

15.8. Interface CICM::DecryptBypass::Negotiator

CICM::DecryptBypass::Negotiator initiates a negotiation to establish a shared key with a remote entity that is used to support encryption operations between two independent security domains. Additionally, selective bypass is supported on the same conduit. The result of a successful negotiation is a CICM::DecryptBypass::NegotiatedConduit which is capable of both managing the channel and accepting data for transformation. CICM::DecryptBypass::Negotiator is created by calling CICM::ChannelManager::negotiate_decrypt_bypass_conduit.

15.8.1. CICM::DecryptBypass::Negotiator Inheritance

15.8.2. CICM::DecryptBypass::Negotiator Methods

16. Random, Pseudorandom and Keystream

The CICM::Emit namespace contains interfaces that generate data originating in a cryptographic module such as random, pseudorandom, and keystream data.

16.1. Interface CICM::Emit::ChannelManager

CICM::Emit::ChannelManager is an abstraction inherited by CICM::ChannelManager that supports the creation of conduits and controllers to generate keystream, pseudorandom, and random data. See CICM::ChannelManager for additional information.

16.1.1. CICM::Emit::ChannelManager Methods

16.2. Interface CICM::Emit::GetStream

CICM::Emit::GetStream is an abstraction inherited by conduits in the CICM::Emit namespace that allows data to be read from the stream.

16.2.1. CICM::Emit::GetStream Inheritance

16.2.2. CICM::Emit::GetStream Methods

Reads a buffer of data from the module. The method blocks until data becomes available.

Registers a buffer into which transformed data will be copied, and then control immediately returns to the caller. The size of the allocated buffer and length of the resulting transformed data is encapsulated in the buffer parameter. The caller may use the CICM::Emit::GetStream::get_poll method to proactively poll the channel to determine the status of the operation. The caller is responsible for maintaining any necessary metadata associated with the transaction_id parameter. Memory responsibilities and calling conventions shall follow the appropriate IDL language mapping conventions.

Returns the status of the non-blocking get operation specified by the transaction_id parameter. Upon completion of the operation, the caller must use the metadata associated with the transaction_id parameter to determine which buffer has been populated. Memory responsibilities and calling conventions shall follow the appropriate IDL language mapping conventions.

16.3. Interface CICM::Emit::Controller

CICM::Emit::Controller is an abstraction from which all other controllers in the CICM::Emit namespace inherit.

16.3.1. CICM::Emit::Controller Inheritance

16.3.2. CICM::Emit::Controller Attributes

16.4. Interface CICM::Emit::RandomController

CICM::Emit::RandomController supports creating a channel to read random data from a module. The resulting controller is capable of managing the channel, but not reading random data. It is created by calling CICM::ChannelManager::create_random_controller.

16.4.1. CICM::Emit::RandomController Inheritance

16.5. Interface CICM::Emit::RandomConduit

CICM::Emit::RandomConduit supports reading random data from a module. The resulting conduit is capable of both managing the channel and reading random data. It is created by calling CICM::ChannelManager::create_random_conduit.

16.5.1. CICM::Emit::RandomConduit Inheritance

CICM::Emit::RandomConduit inherits from: CICM::Conduit and CICM::Emit::GetStream.

16.6. Interface CICM::Emit::PseudoRandomController

CICM::Emit::PseudoRandomController supports creating a channel to read pseudorandom data from a module. The resulting controller is capable of managing the channel, but not reading pseudorandom data. It is created by calling CICM::ChannelManager::create_pseudorandom_controller.

16.6.1. CICM::Emit::PseudoRandomController Inheritance

CICM::Emit::PseudoRandomController inherits from: CICM::SymKeyController and CICM::Emit::Controller.

16.7. Interface CICM::Emit::PseudoRandomConduit

CICM::Emit::PseudoRandomConduit supports reading pseudorandom data from a module. The resulting conduit is capable of both managing the channel and reading pseudorandom data. It is created by calling CICM::ChannelManager::create_pseudorandom_conduit.

16.7.1. CICM::Emit::PseudoRandomConduit Inheritance

CICM::Emit::PseudoRandomConduit inherits from: CICM::Conduit, CICM::SymKeyController and CICM::Emit::GetStream.

16.8. Interface CICM::Emit::KeyStreamGenController

CICM::Emit::KeyStreamGenController supports creating a channel to read keystream from a module. The resulting controller is capable of managing the channel, but not reading keystream. It is created by calling CICM::ChannelManager::create_key_stream_gen_controller.

16.8.1. CICM::Emit::KeyStreamGenController Inheritance

CICM::Emit::KeyStreamGenController inherits from: CICM::SymKeyController, CICM::GenVectorController and CICM::Emit::Controller.

16.9. Interface CICM::Emit::KeyStreamGenConduit

CICM::Emit::KeyStreamGenConduit supports reading keystream from a module. The resulting conduit is capable of both managing the channel and reading keystream. It is created by calling CICM::ChannelManager::create_key_stream_gen_conduit.

16.9.1. CICM::Emit::KeyStreamGenConduit Inheritance

CICM::Emit::KeyStreamGenConduit inherits from: CICM::Conduit, CICM::SymKeyController, CICM::GenVectorController and CICM::Emit::GetStream.

17. Data Integrity

The CICM::Answer namespace contains interfaces that support cryptographic operations that return an "answer" such a hash or a signature within a single security domain.

17.1. Interface CICM::Answer::ChannelManager

CICM::Answer::ChannelManager is an abstraction inherited by CICM::ChannelManager that supports the creation of conduits to sign, MAC, and hash data. See CICM::ChannelManager for additional information.

17.1.1. CICM::Answer::ChannelManager Methods

Create conduit to calculate and generate a signature accepting a previously generated hash value as input.

Create conduit to verify a signature accepting a previously generated hash value as input.

17.2. Interface CICM::Answer::PutStream

17.2.1. CICM::Answer::PutStream Inheritance

17.2.2. CICM::Answer::PutStream Methods

17.3. Interface CICM::Answer::HashConduit

CICM::Answer::HashConduit supports hashing operations within a single security domain. It is created by calling CICM::ChannelManager::create_hash_conduit.

17.3.1. CICM::Answer::HashConduit Inheritance

CICM::Answer::HashConduit inherits from: CICM::Conduit and CICM::Answer::PutStream.

17.3.2. CICM::Answer::HashConduit Attributes

17.3.3. CICM::Answer::HashConduit Methods

Direct the module to compute and output the message digest value, and reset the conduit to accept additional data.

17.4. Interface CICM::Answer::MACConduit

CICM::Answer::MACConduit supports message authentication code operations within a single security domain. It is created by calling CICM::ChannelManager::create_mac_conduit.

17.4.1. CICM::Answer::MACConduit Inheritance

CICM::Answer::MACConduit inherits from: CICM::AbstractMACConduit and CICM::Answer::PutStream.

17.5. Interface CICM::Answer::MACVerifyConduit

CICM::Answer::MACVerifyConduit supports message authentication code verification operations within a single security domain. It is created by calling CICM::ChannelManager::create_mac_verify_conduit.

17.5.1. CICM::Answer::MACVerifyConduit Inheritance

CICM::Answer::MACVerifyConduit inherits from: CICM::AbstractMACVerifyConduit and CICM::Answer::PutStream.

17.6. Interface CICM::Answer::SignConduit

CICM::Answer::SignConduit supports signature operations within a single security domain. It is created by calling CICM::ChannelManager::create_sign_conduit.

17.6.1. CICM::Answer::SignConduit Inheritance

CICM::Answer::SignConduit inherits from: CICM::AbstractSignConduit and CICM::Answer::PutStream.

17.7. Interface CICM::Answer::SignHashConduit

CICM::Answer::SignHashConduit supports signature operations accepting a pre-generated hash value within a single security domain. It is created by calling CICM::ChannelManager::create_sign_hash_conduit.

17.7.1. CICM::Answer::SignHashConduit Inheritance

17.8. Interface CICM::Answer::VerifyConduit

CICM::Answer::VerifyConduit supports verification operations within a single security domain. It is created by calling CICM::ChannelManager::create_verify_conduit.

17.8.1. CICM::Answer::VerifyConduit Inheritance

CICM::Answer::VerifyConduit inherits from: CICM::AbstractSigVerifyConduit and CICM::Answer::PutStream.

17.9. Interface CICM::Answer::VerifyHashConduit

CICM::Answer::VerifyHashConduit supports verification operations accepting a pre-generated hash value within a single security domain. It is created by calling CICM::ChannelManager::create_verify_hash_conduit.

17.9.1. CICM::Answer::VerifyHashConduit Inheritance

18. Single-Domain

The CICM::Coprocessor namespace contains interfaces that support encryption/decryption operations within a single security domain.

18.1. Interface CICM::Coprocessor::ChannelManager

CICM::Coprocessor::ChannelManager is an abstraction inherited by CICM::ChannelManager that supports the creation of conduits to encrypt and decrypt data within a single security domain. See CICM::ChannelManager for additional information.

18.1.1. CICM::Coprocessor::ChannelManager Methods

Method CICM::Coprocessor::ChannelManager::create_coprocessor_encrypt_with_mac_conduit()

Create conduit to MAC and encrypt a stream of data within a single security domain.

Method CICM::Coprocessor::ChannelManager::create_coprocessor_encrypt_with_sign_conduit()

Create conduit to sign and encrypt a stream of data within a single security domain.

Method CICM::Coprocessor::ChannelManager::create_coprocessor_decrypt_with_mac_conduit()

Create conduit to MAC verify and decrypt a stream of data within a single security domain.

Method CICM::Coprocessor::ChannelManager::create_coprocessor_decrypt_with_verify_conduit()

Create conduit to verify and decrypt a stream of data within a single security domain.

18.2. Interface CICM::Coprocessor::Stream

CICM::Coprocessor::Stream is an abstraction inherited by all conduits in the CICM::Coprocessor namespace.

18.2.1. CICM::Coprocessor::Stream Inheritance

18.2.2. CICM::Coprocessor::Stream Methods

Returns the final block of transformed data, if available. The method blocks until data becomes available.

18.3. Interface CICM::Coprocessor::EncryptConduit

CICM::Coprocessor::EncryptConduit supports encryption operations within a single security domain. The resulting conduit is capable of managing the channel, accepting data for transformation, and receiving the result. It is created by calling CICM::ChannelManager::create_coprocessor_encrypt_conduit.

18.3.1. CICM::Coprocessor::EncryptConduit Inheritance

CICM::Coprocessor::EncryptConduit inherits from: CICM::Conduit, CICM::SymKeyController, CICM::GenVectorController, CICM::ResyncController and CICM::Coprocessor::Stream.

18.3.2. CICM::Coprocessor::EncryptConduit Methods

Send plaintext to the module to be encrypted, receiving the ciphertext resulting from the transformation as the result.

18.4. Interface CICM::Coprocessor::EncryptWithMACConduit

CICM::Coprocessor::EncryptWithMACConduit supports encryption with MAC operations within a single security domain. The resulting conduit is capable of managing the channel, accepting data for transformation, and receiving the result (both ciphertext and a MAC value). It is created by calling CICM::ChannelManager::create_coprocessor_encrypt_with_mac_conduit.

18.4.1. CICM::Coprocessor::EncryptWithMACConduit Inheritance

CICM::Coprocessor::EncryptWithMACConduit inherits from: CICM::AbstractMACConduit and CICM::Coprocessor::EncryptConduit.

18.5. Interface CICM::Coprocessor::EncryptWithSignConduit

CICM::Coprocessor::EncryptWithSignConduit supports encryption with signature operations within a single security domain. The resulting conduit is capable of managing the channel, accepting data for transformation, and receiving the result (both ciphertext and a signature). It is created by calling CICM::ChannelManager::create_coprocessor_encrypt_with_sign_conduit.

18.5.1. CICM::Coprocessor::EncryptWithSignConduit Inheritance

CICM::Coprocessor::EncryptWithSignConduit inherits from: CICM::AbstractSignConduit and CICM::Coprocessor::EncryptConduit.

18.6. Interface CICM::Coprocessor::DecryptConduit

CICM::Coprocessor::DecryptConduit supports decryption operations within a single security domain. The resulting conduit is capable of managing the channel, accepting data for transformation, and receiving the result. It is created by calling CICM::ChannelManager::create_coprocessor_decrypt_conduit.

18.6.1. CICM::Coprocessor::DecryptConduit Inheritance

CICM::Coprocessor::DecryptConduit inherits from: CICM::Conduit, CICM::SymKeyController, CICM::SetVectorController, CICM::ResyncController and CICM::Coprocessor::Stream.

18.6.2. CICM::Coprocessor::DecryptConduit Methods

Send ciphertext to the module to be decrypted, receiving the plaintext resulting from the transformation as the result.

18.7. Interface CICM::Coprocessor::DecryptWithMACConduit

CICM::Coprocessor::DecryptWithMACConduit supports encryption with MAC verification operations within a single security domain. The resulting conduit is capable of managing the channel, accepting data for transformation, and receiving the result (both plaintext and an indication as to whether verification succeeded or failed). It is created by calling CICM::ChannelManager::create_coprocessor_decrypt_with_mac_conduit.

18.7.1. CICM::Coprocessor::DecryptWithMACConduit Inheritance

CICM::Coprocessor::DecryptWithMACConduit inherits from: CICM::AbstractMACVerifyConduit and CICM::Coprocessor::DecryptConduit.

18.8. Interface CICM::Coprocessor::DecryptWithVerifyConduit

CICM::Coprocessor::DecryptWithVerifyConduit supports encryption with signature verification operations within a single security domain. The resulting conduit is capable of managing the channel, accepting data for transformation, and receiving the result (both plaintext and an indication as to whether verification succeeded or failed). It is created by calling CICM::ChannelManager::create_coprocessor_decrypt_with_verify_conduit.

18.8.1. CICM::Coprocessor::DecryptWithVerifyConduit Inheritance

CICM::Coprocessor::DecryptWithVerifyConduit inherits from: CICM::AbstractSigVerifyConduit and CICM::Coprocessor::DecryptConduit.

19. Channel Events

19.1. Interface CICM::ChannelEventManager

CICM::ChannelEventManager supports registering and unregistering user-defined channel event listeners (CICM::ChannelEventListener) for specific channel events. It is accessed from any channel via its CICM::Channel::event_manager attribute.

19.1.1. CICM::ChannelEventManager Methods

19.2. Interface CICM::ChannelEventListener

CICM::ChannelEventListener is unlike other CICM interfaces in that the interface is implemented by the developer of the client program to service a specific channel event and is then registered via the CICM::ChannelEventManager.

19.2.1. CICM::ChannelEventListener Types and Constants

Cryptographic synchronization with remote peer has been lost; this may not be detectable by the cryptographic module.

Remote peer is no longer available; this may not be detectable by the cryptographic module.

19.2.2. CICM::ChannelEventListener Methods

Method implemented by client program that receives a message about a channel event that occurred. An opaque data field with additional information about the event in a module-specific format may optionally be provided with the event itself.

20. Channel Groups

20.1. Interface CICM::ControllerGroup

20.1.1. CICM::ControllerGroup Methods

21. IANA Considerations

22. Security Considerations

22.1. Confidentiality

This document defines several channels that provide confidentiality services such encryption and decryption as defined in the CICM::Encrypt, CICM::Decrypt, CICM::Duplex, CICM::EncryptBypass, CICM::DecryptBypass, and CICM::Coprocessor namespaces. Note, however, that the CICM::EncryptBypass and CICM::DecryptBypass namespaces are capable of sending unencrypted data (see Bypass below).

22.2. Bypass

This document defines four namespaces related to sending and receiving bypass data. CICM::BypassWrite and CICM::BypassRead are for full bypass while CICM::EncryptBypass and CICM::DecryptBypass are for selective bypass.

Unintentional sending of bypass data is typically considered a comprimise in the confidentiality of a system, and therefore implementors are urged to consider their security policies carefully.

To mitigate against accidental programming errors related to bypass, this document ensures that:

22.3. Data Integrity

This document defines several data integrity services either as stand-alone or hybrid channels. The CICM::Answer namespace contains channels for hashing, signing, and verifying signed data. Similarly, CICM::Encrypt, CICM::Decrypt, CICM::Coprocessor have channels that, in addition to encrypting or decrypting, sign or verify the transmitted data.

22.4. Peer Entity Authentication

This document defines a CICM::Negotiator which defines the basic peer-entity authentication mechanism. Channels defined in the CICM::Encrypt, CICM::Decrypt, CICM::Duplex, CICM::EncryptBypass, and CICM::DecryptBypass namespaces define negotiated versions of most of the channels. See Channel Negotiation (Section 8 (Channel Negotiation)) for more information.

23. References

23.1. Normative References

23.2. Informative References

Appendix A. IDL Definitions

module CICM {
  typedef CICM::Buffer MACBuffer;
  typedef CICM::Buffer SigBuffer;
  typedef CICM::Buffer HashBuffer;
  typedef CICM::Buffer Vector;

  typedef CICM::UInt32 TransId;

  typedef CICM::CharString HashAlgorithmId;

  typedef CICM::CharString AsymEncrAlgorithmId;
  const CICM::AsymEncrAlgorithmId IMPLICIT_ASYM_ENCR_ALGO = "IMPLICIT";

  typedef CICM::CharString AsymSigAlgorithmId;
  const CICM::AsymSigAlgorithmId IMPLICIT_ASYM_SIG_ALGO = "IMPLICIT";

  typedef CICM::CharString SymEncrAlgorithmId;
  const CICM::SymEncrAlgorithmId IMPLICIT_SYM_ENCR_ALGO = "IMPLICIT";

  typedef CICM::CharString SymMacAlgorithmId;
  const CICM::SymMacAlgorithmId IMPLICIT_SYM_MAC_ALGO = "IMPLICIT";

  typedef CICM::CharString KeyWrapAlgorithmId;
  const CICM::KeyWrapAlgorithmId IMPLICIT_KEY_WRAP_ALGO = "IMPLICIT";

  typedef CICM::CharString ProtocolId;
  const CICM::ProtocolId IMPLICIT_PROTOCOL_ID = "IMPLICIT";

  interface PeerInfo {
    readonly attribute CICM::CharString peer_name;
    readonly attribute CICM::Classification classification;
    readonly attribute CICM::CharString compartment;
    readonly attribute CICM::CharString message;
  };

  interface Negotiator {
    CICM::Status get_remote_info(
      out CICM::PeerInfo peer_info );

    CICM::Status abort_negotiation();
  };

  interface ChannelEventListener {
    typedef CICM::UInt32 ChannelEvent;
    const CICM::ChannelEventListener::ChannelEvent
      C_CHANNEL_DATA_AVAILABLE = 0x00004001;

    const CICM::ChannelEventListener::ChannelEvent
      C_CHANNEL_ERROR = 0x00004002;

    const CICM::ChannelEventListener::ChannelEvent
      C_CHANNEL_INSUFFICIENT_ENTROPY = 0x00004004;

    const CICM::ChannelEventListener::ChannelEvent
      C_CHANNEL_LOST_SYNC = 0x00004007;

    const CICM::ChannelEventListener::ChannelEvent
      C_CHANNEL_PEER_RESET = 0x00004008;

    void event_occurred(
      in  CICM::ChannelEventListener::ChannelEvent event,
      in  CICM::Buffer event_data );
  };

  interface ChannelEventManager {
    CICM::Status register(
      in  CICM::ChannelEventListener::ChannelEvent event,
      in  CICM::ChannelEventListener listener );

    CICM::Status unregister(
      in  CICM::ChannelEventListener::ChannelEvent event );
  };

  interface Channel {
    readonly attribute CICM::ChannelEventManager event_manager;
  };

  interface Stream : CICM::Channel {};

  interface WriteStream : CICM::Stream {
    typedef CICM::UInt32 WriteStatus;
    const CICM::WriteStream::WriteStatus C_WRITE_NOT_READY = 0x00006067;
    const CICM::WriteStream::WriteStatus C_WRITE_READY = 0x00006068;
  };

  interface ReadStream : CICM::Stream {
    typedef CICM::UInt32 ReadStatus;
    const CICM::ReadStream::ReadStatus C_READ_NOT_READY = 0x0000605E;
    const CICM::ReadStream::ReadStatus C_READ_READY = 0x00006061;
  };

  interface Controller : CICM::Channel {
    CICM::Status destroy();
  };

  interface MultiDomainController : CICM::Controller {
    readonly attribute CICM::LocalPort local_port;
    readonly attribute CICM::RemotePort remote_port;
  };

  interface SymKeyController : CICM::Controller {
    readonly attribute CICM::SymKey key;

    CICM::Status update_key();

    CICM::Status update_key_with_algo(
      in  CICM::SymEncrAlgorithmId algorithm );

    CICM::Status rollover_key();

    CICM::Status rollover_key_with_key(
      in  CICM::SymKey next_key );
  };

  interface AsymKeyController : CICM::Controller {
    readonly attribute CICM::AsymKey key;
  };

  interface NegotiatedController :
    CICM::MultiDomainController,
    CICM::AsymKeyController,
    CICM::Negotiator {

    readonly attribute CICM::Classification negotiated_grade;

    CICM::Status renegotiate();

    CICM::Status initiate_grade_change(
      in  CICM::Classification new_grade );

    CICM::Status acknowledge_grade_change();
  };

  interface SetVectorController : CICM::Controller {
    readonly attribute CICM::Vector vec;

    CICM::Status set_vector(
      in  CICM::Vector vec );

    CICM::Status set_vector_no_check(
      in  CICM::Vector vec );

    CICM::Status reset_vector();
  };

  interface GenVectorController : CICM::SetVectorController {
    CICM::Status generate_vector();
    CICM::Status generate_vector_existing_state();
  };

  interface ResyncController : CICM::Controller {
    CICM::Status resync();
    CICM::Status resync_with_sync_vector(
      in  CICM::Vector vec );
  };

  interface ControllerGroup {
    CICM::Status add(
      in CICM::Controller controller_ref );
  };

  interface Conduit :
    CICM::Controller,
    CICM::Stream {
  };

  interface AbstractMACConduit : CICM::Conduit {
    readonly attribute CICM::SymKey mac_key;
    readonly attribute CICM::SymMacAlgorithmId mac_algorithm;

    CICM::Status end_get_mac(
      out CICM::MACBuffer mac );
  };

  interface AbstractSignConduit : CICM::Conduit {
    readonly attribute CICM::AsymKey sign_key;
    readonly attribute CICM::AsymSigAlgorithmId sign_algorithm;

    CICM::Status end_get_signature(
      out CICM::SigBuffer signature );
  };

  interface AbstractVerifyConduit : CICM::Conduit {
    typedef CICM::UInt32 VerifyStatus;
    const CICM::AbstractVerifyConduit::VerifyStatus
      C_DATA_VERIFIED = 0x00006025;

    const CICM::AbstractVerifyConduit::VerifyStatus
      C_DATA_NOT_VERIFIED = 0x00006026;

  };

  interface AbstractMACVerifyConduit : CICM::AbstractVerifyConduit {
    readonly attribute CICM::SymKey verify_key;
    readonly attribute CICM::SymMacAlgorithmId verify_algorithm;

    CICM::Status end_get_verified(
      in  CICM::MACBuffer mac,
      out CICM::AbstractVerifyConduit::VerifyStatus status );
  };

  interface AbstractSigVerifyConduit : CICM::AbstractVerifyConduit {
    readonly attribute CICM::AsymKey verify_key;
    readonly attribute CICM::AsymSigAlgorithmId verify_algorithm;

    CICM::Status end_get_verified(
      in  CICM::SigBuffer signature,
      out CICM::AbstractVerifyConduit::VerifyStatus status );
  };

  module Encrypt {
    interface Stream : CICM::WriteStream {
      CICM::Status encrypt(
        in  CICM::Buffer buffer );

      CICM::Status encrypt_non_blocking(
        in  CICM::Buffer buffer,
        in  CICM::TransId transaction_id );

      CICM::Status encrypt_poll(
        in  CICM::TransId transaction_id,
        out CICM::WriteStream::WriteStatus status );
    };

    interface KeyWrapStream : CICM::Stream {
      CICM::Status wrap_key(
        in CICM::Key key_ref );
    };

    interface Controller :
      CICM::MultiDomainController,
      CICM::SymKeyController,
      CICM::GenVectorController,
      CICM::ResyncController {};

    interface NegotiatedController :
      CICM::NegotiatedController,
      CICM::GenVectorController,
      CICM::ResyncController {};

    interface Conduit :
      CICM::Conduit,
      CICM::Encrypt::Controller,
      CICM::Encrypt::Stream {};

    interface NegotiatedConduit :
      CICM::Conduit,
      CICM::Encrypt::NegotiatedController,
      CICM::Encrypt::Stream {};

    interface WithMACConduit :
      CICM::AbstractMACConduit,
      CICM::Encrypt::Conduit {};

    interface WithMACNegotiatedConduit :
      CICM::AbstractMACConduit,
      CICM::Encrypt::NegotiatedConduit {};

    interface WithSignConduit :
      CICM::AbstractSignConduit,
      CICM::Encrypt::Conduit {};

    interface WithSignNegotiatedConduit :
      CICM::AbstractSignConduit,
      CICM::Encrypt::NegotiatedConduit {};

    interface KeyWrapConduit :
      CICM::Encrypt::Controller,
      CICM::Encrypt::KeyWrapStream {};

    interface ControllerNegotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::Encrypt::NegotiatedController controller_ref );
    };

    interface Negotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::Encrypt::NegotiatedConduit conduit_ref );
    };

    interface WithMACNegotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::Encrypt::WithMACNegotiatedConduit conduit_ref );
    };

    interface WithSignNegotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::Encrypt::WithSignNegotiatedConduit conduit_ref );
    };

    interface ChannelManager {
      CICM::Status negotiate_encrypt_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey key_ref,
        out CICM::Encrypt::Negotiator negotiator_ref );

      CICM::Status negotiate_encrypt_with_mac_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::SymKey mac_key_ref,
        in  CICM::AsymKey nego_key_ref,
        in  CICM::SymMacAlgorithmId mac_algorithm,
        out CICM::Encrypt::WithMACNegotiator negotiator_ref );

      CICM::Status negotiate_encrypt_with_sign_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey sign_key_ref,
        in  CICM::AsymKey nego_key_ref,
        in  CICM::AsymSigAlgorithmId sign_algorithm,
        out CICM::Encrypt::WithSignNegotiator negotiator_ref );

      CICM::Status negotiate_encrypt_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey key_ref,
        out CICM::Encrypt::ControllerNegotiator negotiator_ref );

      CICM::Status create_encrypt_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::Encrypt::Conduit conduit_ref );

      CICM::Status create_encrypt_with_mac_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey mac_key_ref,
        in  CICM::SymKey encrypt_key_ref,
        in  CICM::SymMacAlgorithmId mac_algorithm,
        in  CICM::SymEncrAlgorithmId encr_algorithm,
        out CICM::Encrypt::WithMACConduit conduit_ref );

      CICM::Status create_encrypt_with_sign_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::AsymKey sign_key_ref,
        in  CICM::SymKey encrypt_key_ref,
        in  CICM::AsymSigAlgorithmId sign_algorithm,
        in  CICM::SymEncrAlgorithmId encr_algorithm,
        out CICM::Encrypt::WithSignConduit conduit_ref );
      CICM::Status create_key_wrap_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey kek_ref,
        in  CICM::KeyWrapAlgorithmId algorithm,
        out CICM::Encrypt::KeyWrapConduit conduit_ref );

      CICM::Status create_encrypt_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::Encrypt::Controller controller_ref );

      CICM::Status get_encrypt_stream(
        in  CICM::LocalPort local_port,
        out CICM::Encrypt::Stream stream_ref );
    };
  };

  module Decrypt {
    interface Stream : CICM::ReadStream {
      CICM::Status decrypt(
        out CICM::Buffer buffer );

      CICM::Status decrypt_non_blocking(
        out CICM::Buffer buffer,
        in  CICM::TransId transaction_id );

      CICM::Status decrypt_poll(
        in  CICM::TransId transaction_id,
        out CICM::ReadStream::ReadStatus status );
    };

    interface KeyUnwrapStream : CICM::Stream {
      CICM::Status unwrap_sym_key(
        out CICM::SymKey key_ref );

      CICM::Status unwrap_asym_key(
        out CICM::AsymKey key_ref );
    };

    interface Controller :
      CICM::MultiDomainController,
      CICM::SymKeyController,
      CICM::SetVectorController,
      CICM::ResyncController {};

    interface NegotiatedController :
      CICM::NegotiatedController,
      CICM::SetVectorController,
      CICM::ResyncController {};

    interface Conduit :
      CICM::Conduit,
      CICM::Decrypt::Controller,
      CICM::Decrypt::Stream {};

    interface NegotiatedConduit :
      CICM::Conduit,
      CICM::Decrypt::NegotiatedController,
      CICM::Decrypt::Stream {};

    interface WithMACConduit :
      CICM::AbstractMACVerifyConduit,
      CICM::Decrypt::Conduit {};

    interface WithMACNegotiatedConduit :
      CICM::AbstractMACVerifyConduit,
      CICM::Decrypt::NegotiatedConduit {};

    interface WithVerifyConduit :
      CICM::AbstractSigVerifyConduit,
      CICM::Decrypt::Conduit {};

    interface WithVerifyNegotiatedConduit :
      CICM::AbstractSigVerifyConduit,
      CICM::Decrypt::NegotiatedConduit {};

    interface KeyUnwrapConduit :
      CICM::Decrypt::Controller,
      CICM::Decrypt::KeyUnwrapStream {};

    interface Negotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::Decrypt::NegotiatedConduit conduit_ref );
    };

    interface ControllerNegotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::Decrypt::NegotiatedController controller_ref );
    };

    interface WithMACNegotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::Decrypt::WithMACNegotiatedConduit conduit_ref );
    };

    interface WithVerifyNegotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::Decrypt::WithVerifyNegotiatedConduit conduit_ref );
    };

    interface ChannelManager {
      CICM::Status negotiate_decrypt_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey key_ref,
        out CICM::Decrypt::Negotiator negotiator_ref );

      CICM::Status negotiate_decrypt_with_mac_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::SymKey verify_key_ref,
        in  CICM::AsymKey nego_key_ref,
        in  CICM::SymMacAlgorithmId verify_algorithm,
        out CICM::Decrypt::WithMACNegotiator negotiator_ref );

      CICM::Status negotiate_decrypt_with_verify_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey verify_key_ref,
        in  CICM::AsymKey nego_key_ref,
        in  CICM::AsymSigAlgorithmId verify_algorithm,
        out CICM::Decrypt::WithVerifyNegotiator negotiator_ref );

      CICM::Status negotiate_decrypt_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey key_ref,
        out CICM::Decrypt::ControllerNegotiator negotiator_ref );

      CICM::Status create_decrypt_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::Decrypt::Conduit conduit_ref );

      CICM::Status create_decrypt_with_mac_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey verify_key_ref,
        in  CICM::SymKey decrypt_key_ref,
        in  CICM::SymMacAlgorithmId verify_algorithm,
        in  CICM::SymEncrAlgorithmId decrypt_algorithm,
        out CICM::Decrypt::WithMACConduit conduit_ref );

      CICM::Status create_decrypt_with_verify_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::AsymKey verify_key_ref,
        in  CICM::SymKey decrypt_key_ref,
        in  CICM::AsymSigAlgorithmId verify_algorithm,
        in  CICM::SymEncrAlgorithmId decrypt_algorithm,
        out CICM::Decrypt::WithVerifyConduit conduit_ref );

      CICM::Status create_key_unwrap_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey kek_ref,
        in  CICM::KeyWrapAlgorithmId algorithm,
        out CICM::Decrypt::KeyUnwrapConduit conduit_ref );

      CICM::Status create_decrypt_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::Decrypt::Controller controller_ref );

      CICM::Status get_decrypt_stream(
        in  CICM::LocalPort local_port,
        out CICM::Decrypt::Stream stream_ref );
    };
  };

  module Duplex {
    interface Stream :
      CICM::Encrypt::Stream,
      CICM::Decrypt::Stream {};

    interface Controller :
      CICM::Encrypt::Controller,
      CICM::Decrypt::Controller {};

    interface NegotiatedController :
      CICM::Encrypt::NegotiatedController,
      CICM::Decrypt::NegotiatedController {};

    interface Conduit :
      CICM::Conduit,
      CICM::Duplex::Controller,
      CICM::Duplex::Stream {};

    interface NegotiatedConduit :
      CICM::Duplex::NegotiatedController,
      CICM::Duplex::Stream {};

    interface ControllerNegotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::Duplex::NegotiatedController controller_ref );
    };

    interface Negotiator : CICM::Negotiator {
       CICM::Status complete(
        out CICM::Duplex::NegotiatedConduit conduit_ref );
    };

    interface ChannelManager {
      CICM::Status negotiate_duplex_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey key_ref,
        out CICM::Duplex::Negotiator negotiator_ref );

      CICM::Status negotiate_duplex_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey key_ref,
        out CICM::Duplex::ControllerNegotiator negotiator_ref );

      CICM::Status create_duplex_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::Duplex::Conduit conduit_ref );

      CICM::Status create_duplex_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::Duplex::Controller controller_ref );

      CICM::Status get_duplex_stream(
        in  CICM::LocalPort local_port,
        out CICM::Duplex::Stream stream_ref );
    };
  };

  module BypassWrite {
    interface Stream : CICM::WriteStream {
      CICM::Status write_bypass(
        in  CICM::Buffer buffer );

      CICM::Status write_bypass_non_blocking(
        in  CICM::Buffer buffer,
        in  CICM::TransId transaction_id );

      CICM::Status write_bypass_poll(
        in  CICM::TransId transaction_id,
        out CICM::WriteStream::WriteStatus status );
    };

    interface Controller : CICM::MultiDomainController {};

    interface Conduit :
      CICM::Conduit,
      CICM::BypassWrite::Controller,
      CICM::BypassWrite::Stream {};

    interface ChannelManager {
      CICM::Status create_bypass_write_conduit(
        in  CICM::RemotePort remote_port,
        out CICM::BypassWrite::Conduit conduit_ref );

      CICM::Status create_bypass_write_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        out CICM::BypassWrite::Controller controller_ref );

      CICM::Status get_bypass_write_stream(
        in  CICM::LocalPort local_port,
        out CICM::BypassWrite::Stream stream_ref );
    };
  };

  module BypassRead {
    interface Stream : CICM::ReadStream {
      CICM::Status read_bypass(
        out CICM::Buffer buffer );

      CICM::Status read_bypass_non_blocking(
        out CICM::Buffer buffer,
        in   CICM::TransId transaction_id );

      CICM::Status read_bypass_poll(
        in  CICM::TransId transaction_id,
        out CICM::ReadStream::ReadStatus status );
    };

    interface Controller : CICM::MultiDomainController {};

    interface Conduit :
      CICM::Conduit,
      CICM::BypassRead::Controller,
      CICM::BypassRead::Stream {};

    interface ChannelManager {
      CICM::Status create_bypass_read_conduit(
        in  CICM::RemotePort remote_port,
        out CICM::BypassRead::Conduit conduit_ref );

      CICM::Status create_bypass_read_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        out CICM::BypassRead::Controller controller_ref );

      CICM::Status get_bypass_read_stream(
        in  CICM::LocalPort local_port,
        out CICM::BypassRead::Stream stream_ref );
    };
  };

  module EncryptBypass {
    interface Stream :
      CICM::Encrypt::Stream,
      CICM::BypassWrite::Stream {
    };

    interface NegotiatedController :
      CICM::Encrypt::NegotiatedController {};

    interface Controller : CICM::Encrypt::Controller {};

    interface Conduit :
      CICM::Encrypt::Conduit,
      CICM::EncryptBypass::Stream {};

    interface NegotiatedConduit :
      CICM::Encrypt::NegotiatedController,
      CICM::EncryptBypass::Stream {};

    interface ControllerNegotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::EncryptBypass::NegotiatedController controller_ref );
    };

    interface Negotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::EncryptBypass::NegotiatedConduit conduit_ref );
    };

    interface ChannelManager {
      CICM::Status negotiate_encrypt_bypass_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey key_ref,
        out CICM::EncryptBypass::Negotiator negotiator_ref );

      CICM::Status negotiate_encrypt_bypass_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey key_ref,
        out CICM::EncryptBypass::ControllerNegotiator negotiator_ref );

      CICM::Status create_encrypt_bypass_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::EncryptBypass::Conduit conduit_ref );

      CICM::Status create_encrypt_bypass_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::EncryptBypass::Controller controller_ref );

      CICM::Status get_encrypt_bypass_stream(
        in  CICM::LocalPort local_port,
        out CICM::EncryptBypass::Stream stream_ref );
    };
  };

  module DecryptBypass {
    interface Stream : CICM::Decrypt::Stream {};

    interface NegotiatedController :
      CICM::Decrypt::NegotiatedController {};

    interface Controller : CICM::Encrypt::Controller {};

    interface Conduit :
      CICM::Decrypt::Conduit,
      CICM::DecryptBypass::Controller,
      CICM::DecryptBypass::Stream {};

    interface NegotiatedConduit :
      CICM::Decrypt::NegotiatedConduit,
      CICM::DecryptBypass::NegotiatedController,
      CICM::DecryptBypass::Stream {};

    interface ControllerNegotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::DecryptBypass::NegotiatedController controller_ref );
    };

    interface Negotiator : CICM::Negotiator {
      CICM::Status complete(
        out CICM::DecryptBypass::NegotiatedConduit conduit_ref );
    };

    interface ChannelManager {
      CICM::Status negotiate_decrypt_bypass_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey key_ref,
        out CICM::DecryptBypass::Negotiator negotiator_ref );

      CICM::Status negotiate_decrypt_bypass_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        in  CICM::ProtocolId protocol,
        in  CICM::AsymKey key_ref,
        out CICM::DecryptBypass::ControllerNegotiator negotiator_ref );

      CICM::Status create_decrypt_bypass_conduit(
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::DecryptBypass::Conduit conduit_ref );

      CICM::Status create_decrypt_bypass_controller(
        in  CICM::LocalPort local_port,
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::DecryptBypass::Controller controller_ref );

      CICM::Status get_decrypt_bypass_stream(
        in  CICM::LocalPort local_port,
        out CICM::DecryptBypass::Stream stream_ref );
    };
  };

  module Emit {
    interface GetStream : CICM::ReadStream {
      CICM::Status get(
        in  CICM::UInt32 length,
        out CICM::Buffer buffer );

      CICM::Status get_non_blocking(
        in  CICM::UInt32 length,
        out CICM::Buffer buffer,
        in  CICM::TransId transaction_id );

      CICM::Status get_poll(
        in  CICM::TransId transaction_id,
        out CICM::ReadStream::ReadStatus status );
    };

    interface Controller : CICM::Controller {
      readonly attribute CICM::RemotePort remote_port;
    };

    interface KeyStreamGenController :
      CICM::SymKeyController,
      CICM::GenVectorController,
      CICM::Emit::Controller {};

    interface PseudoRandomController :
      CICM::SymKeyController,
      CICM::Emit::Controller {};

    interface RandomController : CICM::Emit::Controller {};

    interface KeyStreamGenConduit :
      CICM::Conduit,
      CICM::SymKeyController,
      CICM::GenVectorController,
      CICM::Emit::GetStream {};

    interface PseudoRandomConduit :
      CICM::Conduit,
      CICM::SymKeyController,
      CICM::Emit::GetStream {};

    interface RandomConduit :
      CICM::Conduit,
      CICM::Emit::GetStream {};

    interface ChannelManager {
      CICM::Status create_key_stream_gen_controller(
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::Emit::KeyStreamGenController controller_ref );

      CICM::Status create_pseudorandom_controller(
        in  CICM::RemotePort remote_port,
        in  CICM::SymKey seed,
        out CICM::Emit::PseudoRandomController controller_ref );

      CICM::Status create_random_controller(
        in  CICM::RemotePort remote_port,
        out CICM::Emit::RandomController controller_ref );

      CICM::Status create_key_stream_gen_conduit(
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::Emit::KeyStreamGenConduit conduit_ref );

      CICM::Status create_pseudorandom_conduit(
        in  CICM::SymKey seed,
        out CICM::Emit::PseudoRandomConduit conduit_ref );

      CICM::Status create_random_conduit(
        out CICM::Emit::RandomConduit conduit_ref );
    };
  };

  module Answer {
    interface PutStream : CICM::Stream {
      CICM::Status put(
        in  CICM::Buffer buffer );
    };

    interface HashConduit :
      CICM::Conduit,
      CICM::Answer::PutStream {

      readonly attribute CICM::HashAlgorithmId algorithm;

      CICM::Status end_get_hash(
        out HashBuffer hash );
    };

    interface MACConduit :
      CICM::AbstractMACConduit,
      CICM::Answer::PutStream {};

    interface MACVerifyConduit :
      CICM::AbstractMACVerifyConduit,
      CICM::Answer::PutStream {};

    interface SignConduit :
      CICM::AbstractSignConduit,
      CICM::Answer::PutStream {};

    interface SignHashConduit : CICM::Answer::SignConduit {};

    interface VerifyConduit :
      CICM::AbstractSigVerifyConduit,
      CICM::Answer::PutStream {};

    interface VerifyHashConduit : CICM::Answer::VerifyConduit {};

    interface ChannelManager {
      CICM::Status create_hash_conduit(
        in  CICM::HashAlgorithmId algorithm,
        out CICM::Answer::HashConduit conduit_ref );

      CICM::Status create_mac_conduit(
        in  CICM::SymKey key_ref,
        in  CICM::SymMacAlgorithmId algorithm,
        out CICM::Answer::MACConduit conduit_ref );

      CICM::Status create_mac_verify_conduit(
        in  CICM::SymKey key_ref,
        in  CICM::SymMacAlgorithmId algorithm,
        out CICM::Answer::MACVerifyConduit conduit_ref );

      CICM::Status create_sign_conduit(
        in  CICM::AsymKey key_ref,
        in  CICM::AsymSigAlgorithmId algorithm,
        out CICM::Answer::SignConduit conduit_ref );

      CICM::Status create_sign_hash_conduit(
        in  CICM::AsymKey key_ref,
        in  CICM::AsymSigAlgorithmId algorithm,
        out CICM::Answer::SignHashConduit conduit_ref );

      CICM::Status create_verify_conduit(
        in  CICM::AsymKey key_ref,
        in  CICM::AsymSigAlgorithmId algorithm,
        out CICM::Answer::VerifyConduit conduit_ref );

      CICM::Status create_verify_hash_conduit(
        in  CICM::AsymKey key_ref,
        in  CICM::AsymSigAlgorithmId algorithm,
        out CICM::Answer::VerifyHashConduit conduit_ref );
    };
  };

  module Coprocessor {
    interface Stream : CICM::Stream {
      CICM::Status get_final_buffer(
        out CICM::Buffer buffer );
    };

    interface EncryptConduit :
      CICM::Conduit,
      CICM::SymKeyController,
      CICM::GenVectorController,
      CICM::ResyncController,
      CICM::Coprocessor::Stream {

      CICM::Status encrypt(
        in  CICM::Buffer plaintext,
        out CICM::Buffer ciphertext );
    };

    interface EncryptWithMACConduit :
      CICM::AbstractMACConduit,
      CICM::Coprocessor::EncryptConduit {};

    interface EncryptWithSignConduit :
      CICM::AbstractSignConduit,
      CICM::Coprocessor::EncryptConduit {};

    interface DecryptConduit :
      CICM::Conduit,
      CICM::SymKeyController,
      CICM::SetVectorController,
      CICM::ResyncController,
      CICM::Coprocessor::Stream {

      CICM::Status decrypt(
        in  CICM::Buffer ciphertext,
        out CICM::Buffer plaintext );
    };

    interface DecryptWithMACConduit :
      CICM::AbstractMACVerifyConduit,
      CICM::Coprocessor::DecryptConduit {};

    interface DecryptWithVerifyConduit :
      CICM::AbstractSigVerifyConduit,
      CICM::Coprocessor::DecryptConduit {};

    interface ChannelManager {
      CICM::Status create_coprocessor_encrypt_conduit(
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::Coprocessor::EncryptConduit conduit_ref );

      CICM::Status create_coprocessor_encrypt_with_mac_conduit(
        in  CICM::SymKey mac_key_ref,
        in  CICM::SymKey encrypt_key_ref,
        in  CICM::SymMacAlgorithmId mac_algorithm,
        in  CICM::SymEncrAlgorithmId encrypt_algorithm,
        out CICM::Coprocessor::EncryptWithMACConduit conduit_ref );

      CICM::Status create_coprocessor_encrypt_with_sign_conduit(
        in  CICM::AsymKey sign_key_ref,
        in  CICM::SymKey encrypt_key_ref,
        in  CICM::AsymSigAlgorithmId sign_algorithm,
        in  CICM::SymEncrAlgorithmId encrypt_algorithm,
        out CICM::Coprocessor::EncryptWithSignConduit conduit_ref );

      CICM::Status create_coprocessor_decrypt_conduit(
        in  CICM::SymKey key_ref,
        in  CICM::SymEncrAlgorithmId algorithm,
        out CICM::Coprocessor::DecryptConduit conduit_ref );

      CICM::Status create_coprocessor_decrypt_with_mac_conduit(
        in  CICM::SymKey mac_key_ref,
        in  CICM::SymKey decrypt_key_ref,
        in  CICM::SymMacAlgorithmId mac_algorithm,
        in  CICM::SymEncrAlgorithmId encrypt_algorithm,
        out CICM::Coprocessor::DecryptWithMACConduit conduit_ref );

      CICM::Status create_coprocessor_decrypt_with_verify_conduit(
        in  CICM::AsymKey verify_key_ref,
        in  CICM::SymKey decrypt_key_ref,
        in  CICM::AsymSigAlgorithmId verify_algorithm,
        in  CICM::SymEncrAlgorithmId decrypt_algorithm,
        out CICM::Coprocessor::DecryptWithVerifyConduit conduit_ref );
    };
  };

  interface ChannelManager :
    CICM::Answer::ChannelManager,
    CICM::BypassRead::ChannelManager,
    CICM::BypassWrite::ChannelManager,
    CICM::Coprocessor::ChannelManager,
    CICM::Decrypt::ChannelManager,
    CICM::DecryptBypass::ChannelManager,
    CICM::Duplex::ChannelManager,
    CICM::Emit::ChannelManager,
    CICM::Encrypt::ChannelManager,
    CICM::EncryptBypass::ChannelManager {

    CICM::Status create_controller_group(
      out CICM::ControllerGroup controller_group_ref );
  };
};

[CICM]	Lanz, D. and L. Novikov, “Common Interface to Cryptographic Modules (CICM) [RFC Editor: Please update the RFC reference and date prior to publication.],” January 2011.
[CICM-KM]	Lanz, D. and L. Novikov, “Common Interface to Cryptographic Modules (CICM) Key Management [RFC Editor: Please update the RFC reference and date prior to publication.],” January 2011.
[IDL]	International Standards Organization, “Information technology — Open Distributed Processing — Interface Definition Language,” ISO/IEC 14750:1999(E), March 1999.
[RFC2119]	Bradner, S., “Key words for use in RFCs to Indicate Requirement Levels,” BCP 14, RFC 2119, March 1997 (TXT, HTML, XML).

[CICM-LM]	Lanz, D. and L. Novikov, “Common Interface to Cryptographic Modules (CICM) Logical Model [RFC Editor: Please update the RFC reference and date prior to publication.],” January 2011.
[CORBA]	Object Management Group, “Common Object Request Broker Architecture (CORBA) Specification, Version 3.1,” January 2008.
[RFC3552]	Rescorla, E. and B. Korver, “Guidelines for Writing RFC Text on Security Considerations,” BCP 72, RFC 3552, July 2003 (TXT).

	Daniel J. Lanz
	The MITRE Corporation
Email:	dlanz@mitre.org

	Lev Novikov
	The MITRE Corporation
Email:	lnovikov@mitre.org

Common Interface to Cryptographic Modules (CICM) Channel Managementdraft-lanz-cicm-cm-00

Abstract

Status of this Memo

Copyright Notice

Table of Contents

1. Introduction

1.1. Requirements Language

1.2. Definition Language

1.3. Conformance and Extension Language

2. CICM Dependencies

2.1. Namespaces

2.2. Types

2.3. Interfaces

3. Channel Namespaces

4. Channel Abstractions

4.1. Algorithm Types

4.2. State Vector

4.3. Integrity Buffers

4.4. Interface CICM::ChannelManager

4.4.1. CICM::ChannelManager Inheritance

4.4.2. CICM::ChannelManager Methods

4.5. Interface CICM::Channel

4.5.1. CICM::Channel Attributes

4.6. Interface CICM::Conduit

4.6.1. CICM::Conduit Inheritance

4.7. Interface CICM::Controller

4.7.1. CICM::Controller Inheritance

4.7.2. CICM::Controller Methods

4.8. Interface CICM::Stream

4.8.1. CICM::Stream Inheritance

5. Conduit Abstractions

5.1. Interface CICM::AbstractMACConduit

5.1.1. CICM::AbstractMACConduit Inheritance

5.1.2. CICM::AbstractMACConduit Attributes

5.1.3. CICM::AbstractMACConduit Methods

5.2. Interface CICM::AbstractSignConduit

5.2.1. CICM::AbstractSignConduit Inheritance

5.2.2. CICM::AbstractSignConduit Attributes

5.2.3. CICM::AbstractSignConduit Methods

5.3. Interface CICM::AbstractVerifyConduit

5.3.1. CICM::AbstractVerifyConduit Inheritance

5.3.2. CICM::AbstractVerifyConduit Types and Constants

5.4. Interface CICM::AbstractMACVerifyConduit

5.4.1. CICM::AbstractMACVerifyConduit Inheritance

5.4.2. CICM::AbstractMACVerifyConduit Attributes

5.4.3. CICM::AbstractMACVerifyConduit Methods

5.5. Interface CICM::AbstractSigVerifyConduit

5.5.1. CICM::AbstractSigVerifyConduit Inheritance

5.5.2. CICM::AbstractSigVerifyConduit Attributes

5.5.3. CICM::AbstractSigVerifyConduit Methods

6. Stream Abstractions

6.1. Interface CICM::WriteStream

6.1.1. CICM::WriteStream Inheritance

6.1.2. CICM::WriteStream Types and Constants

6.2. Interface CICM::ReadStream

6.2.1. CICM::ReadStream Inheritance

6.2.2. CICM::ReadStream Types and Constants

7. Controller Abstractions

7.1. Interface CICM::MultiDomainController

7.1.1. CICM::MultiDomainController Inheritance

7.1.2. CICM::MultiDomainController Attributes

7.2. Interface CICM::SymKeyController

7.2.1. CICM::SymKeyController Inheritance

7.2.2. CICM::SymKeyController Attributes

7.2.3. CICM::SymKeyController Methods

7.3. Interface CICM::AsymKeyController

7.3.1. CICM::AsymKeyController Inheritance

7.3.2. CICM::AsymKeyController Attributes

7.4. Interface CICM::NegotiatedController

7.4.1. CICM::NegotiatedController Inheritance

7.4.2. CICM::NegotiatedController Attributes

7.4.3. CICM::NegotiatedController Methods

7.5. Interface CICM::SetVectorController

7.5.1. CICM::SetVectorController Inheritance

7.5.2. CICM::SetVectorController Attributes

7.5.3. CICM::SetVectorController Methods

7.6. Interface CICM::GenVectorController

7.6.1. CICM::GenVectorController Inheritance

7.6.2. CICM::GenVectorController Methods

7.7. Interface CICM::ResyncController

Common Interface to Cryptographic Modules (CICM) Channel Management
draft-lanz-cicm-cm-00