Using Security in CORBA Applications

     Previous  Next    Open TOC in new window  Open Index in new window  View as PDF - New Window  Get Adobe Reader - New Window
Content starts here

Fundamentals of CORBA Security

This topic includes the following sections:

Notes: The Oracle Tuxedo CORBA Java client and Oracle Tuxedo CORBA Java client ORB were deprecated in Tuxedo 8.1 and are no longer supported. All Oracle Tuxedo CORBA Java client and Oracle Tuxedo CORBA Java client ORB text references, associated code samples, should only be used to help implement/run third party Java ORB libraries, and for programmer reference only.
Note: Technical support for third party CORBA Java ORBs should be provided by their respective vendors. Oracle Tuxedo does not provide any technical support or documentation for third party CORBA Java ORBs.

 


Link-Level Encryption

Link-Level Encryption (LLE) establishes data privacy for messages moving over the network links. The objective of LLE is to ensure confidentiality so that a network-based eavesdropper cannot learn the content of Oracle Tuxedo system messages or CORBA application-generated messages. It employs the symmetric key encryption technique (specifically, RC4), which uses the same key for encryption and decryption.

When LLE is being used, the Oracle Tuxedo system encrypts data before sending it over a network link and decrypts it as it comes off the link. The system repeats this encryption/decryption process at every link through which the data passes. For this reason, LLE is referred to as a point-to-point facility.

LLE can be used to encrypt communication between machines and/or domains in a CORBA application..

Note: LLE cannot be used to protect connections between remote CORBA client applications and the IIOP Listener/Handler.

There are three levels of LLE security: 0-bit (no encryption), 56-bit (Export), and 128-bit (Domestic). The Export LLE version allows 0-bit and 56-bit encryption. The Domestic LLE version allows 0, 56, and 128-bit encryption.

How LLE Works

LLE works in the following way:

  1. The system administrator sets parameters for any processes that want to use LLE to control the encryption strength.
    • The first configuration parameter is the minimum encryption level that a process will accept. It is expressed as a key length: 0, 56, or 128 bits.
    • The second configuration parameter is the maximum encryption level a process can support. It also is expressed as a key length: 0, 56, or 128 bits.
    • For convenience, the two parameters are denoted as (min, max). For example, the values (56, 128) for a process mean that the process accepts at least 56-bit encryption but can support up to 128-bit encryption.

  2. An initiator process begins the communication session.
  3. A target process receives the initial connection and starts to negotiate the encryption level to be used by the two processes to communicate.
  4. The two processes agree on the largest common key size supported by both.
  5. The configured maximum key size parameter is reduced to agree with the installed software's capabilities. This step must be done at link negotiation time, because at configuration time it may not be possible to verify a particular machine's installed encryption package.
  6. The processes exchange messages using the negotiated encryption level.

Figure 3-1 illustrates these steps.

Figure 3-1 How LLE Works

How LLE Works

Encryption Key Size Negotiation

When two processes at the opposite ends of a network link need to communicate, they must first agree on the size of the key to be used for encryption. This agreement is resolved through a two-step process of negotiation.

  1. Each process identifies its own min-max values.
  2. Together, the two processes find the largest key size supported by both.

Determining min-max Values

When either of the two processes starts up, the Oracle Tuxedo system (1) checks the bit-encryption capability of the installed LLE version by checking the LLE licensing information in the lic.txt file and (2) checks the LLE min-max values for the particular link type as specified in the two configuration files. The Oracle Tuxedo system then proceeds as follows:

Finding a Common Key Size

After the min-max values are determined for the two processes, the negotiation of key size begins. The negotiation process need not be encrypted or hidden. Once a key size is agreed upon, it remains in effect for the lifetime of the network connection.

Table 3-1 shows which key size, if any, is agreed upon by two processes when all possible combinations of min-max values are negotiated. The header row holds the min-max values for one process; the far left column holds the min-max values for the other.

Table 3-1 Interprocess Negotiation Results 
 
(0, 0)
(0, 56)
(0, 128)
(56, 56)
(56, 128)
(128, 128)
(0, 0)
0
0
0
ERROR
ERROR
ERROR
(0, 56)
0
56
56
56
56
ERROR
(0, 128)
0
56
128
56
128
128
(56, 56)
ERROR
56
56
56
56
ERROR
(56, 128)
ERROR
56
128
56
128
128
(128, 128)
ERROR
ERROR
128
ERROR
128
128

WSL/WSH Connection Timeout During Initialization

The length of time a Workstation client can take for initialization is limited. By default, this interval is 30 seconds in an application not using LLE, and 60 seconds in an application using LLE. The 60-second interval includes the time needed to negotiate an encrypted link. This time limit can be changed when LLE is configured by changing the value of the MAXINITTIME parameter for the Workstation Listener (WSL) server in the UBBCONFIG file, or the value of the TA_MAXINITTIME attribute in the T_WSL class of the WS_MIB(5).

Development Process

To use LLE in a CORBA application, you need to install a license that enables the use of LLE. For information about installing the license, see Installing the Oracle Tuxedo System.

The implementation of LLE is an administrative task. The system administrators for each CORBA application set min-max values in the UBBCONFIG file that control encryption strength. When the two CORBA applications establish communication, they negotiate what level of encryption to use to exchange messages. Once an encryption level is negotiated, it remains in effect for the lifetime of the network connection.

 


Password Authentication

The CORBA security environment supports a password mechanism to provide authentication to existing CORBA applications and to new CORBA applications that are not prepared to deploy a full Public Key Infrastructure (PKI). When using password authentication, the applications that initiate invocations on CORBA objects authenticate themselves to the Oracle Tuxedo domain using a defined username and password.

The following levels of password authentication are provided:

When using Password authentication, you have the option of using the Tobj::PrincipalAuthenticator::logon() or the SecurityLevel2::PrincipalAuthenticator::authenticate() methods in your client application.

If you use password authentication, the SSL protocol can be used to provide confidentiality and integrity to communication between applications. For more information, see The SSL Protocol.

How Password Authentication Works

Password authentication works in the following way:

  1. The initiating application accesses the Oracle Tuxedo domain in one of the following ways:
    • Through the CORBA Interoperable Naming Service (INS) Bootstrapping mechanism. Use this mechanism if you are using a client ORB from another vendor. For more information about using CORBA INS, see the CORBA Programming Reference in the Oracle Tuxedo online documentation
    • The Oracle Bootstrapping mechanism. Use this mechanism if you are using Oracle CORBA client applications.
  2. The initiating application obtains credentials for the user. The initiating application must provide proof material to be used by the Oracle Tuxedo domain to authenticate the user. This proof material consists of the name of the user and a password.
    • The initiating application creates the security context using a PrincipalAuthenticator object. The request for authentication is sent to the IIOP Listener/Handler. The proof material in the authentication request is securely relayed to the authentication server, which verifies the supplied information.
    • If the verification succeeds, the Oracle Tuxedo system constructs a Credentials object that is used by all future invocations. The Credentials object for the user is associated with the Current object that represents the security context.
  3. The initiating application invokes a CORBA object in the Oracle Tuxedo domain using an object reference. The request is packaged into an IIOP request and is forwarded to the IIOP Listener/Handler that associates the request with the previously established security context.
  4. The IIOP Listener/Handler receives the request from the initiating application.
  5. The IIOP Listener/Handler forwards the request, along with the credentials of the initiating application, to the appropriate CORBA object.

Figure 3-2 illustrates these steps.

Figure 3-2 How Password Authentication Works

How Password Authentication Works

Development Process for Password Authentication

Defining password authentication for a CORBA application includes administration and programming steps. Table 3-2 and Table 3-3 list the administration and programming steps for password authentication. For a detailed description of the administration steps for password authentication, see Configuring Authentication on page 7-1. For a complete description of the programming steps, see Writing a CORBA Application That Implements Security on page 9-1.

Table 3-2 Administration Steps for Password Authentication 
Step
Description
1
Set the SECURITY parameter in the UBBCONFIG file to APP_PW, USER_AUTH, ACL, or MANDATORY_ACL.
2
If you defined the SECURITY parameter as USER_AUTH, ACL, or MANDATORY_ACL, configure the authentication server (AUTHSRV) in the UBBCONFIG file.
3
Use the tpusradd and tpgrpadd commands to define lists of authorized users and groups including the IIOP Listener/Handler.
4
Use the tmloadcf command to load the UBBCONFIG file. When the UBBCONFIG file is loaded, the system administrator is prompted for a password. The password entered at this time becomes the password for the CORBA application.

Table 3-3 Programming Steps for Password Authentication
Step
Description
1
Write application code that uses the Bootstrap object to obtain a reference to the SecurityCurrent object or CORBA INS to obtain a reference to a PrincipalAuthenticator object in the Oracle Tuxedo domain.
2
Write application code that obtains the PrincipalAuthenticator object from the SecurityCurrent object.
3
Write application code that uses the Tobj::PrincipalAuthenticator::logon() or SecurityLevel2::PrincipalAuthenticator::authenticate() operation to establish a security context with the Oracle Tuxedo domain.
4
Write application code that prompts the user for the password defined when the UBBCONFIG file is loaded.

 


The SSL Protocol

The Oracle Tuxedo product provides the industry-standard SSL protocol to establish secure communications between client and server applications. When using the SSL protocol, principals use digital certificates to prove their identity to a peer.

The default behavior of the SSL protocol in the CORBA security environment is to have the IIOP Listener/Handler prove its identity to the principal who initiated the SSL connection using digital certificates. The digital certificates are verified to ensure that each of the digital certificates has not been tampered with or expired. If there is a problem with any of the digital certificates in the chain, the SSL connection is terminated. In addition, the issuer of a digital certificate is compared against a list of trusted certificate authorities to verify the digital certificate received from the IIOP Listener/Handler has been signed by a certificate authority that is trusted by the Oracle Tuxedo domain.

Like LLE, the SSL protocol can be used with password authentication to provide confidentiality and integrity to communication between the client application and the Oracle Tuxedo domain. When using the SSL protocol with password authentication, you are prompted for the password of the IIOP Listener/Handler defined by the SEC_PRINCIPAL_NAME parameter when you enter the tmloadcf command.

How the SSL Protocol Works

The SSL protocol works in the following manner:

  1. The IIOP Listener/Handler presents its digital certificate to the initiating application.
  2. The initiating application compares the digital certificate of the IIOP Listener/Handler against its list of trusted certificate authorities.
  3. If the initiating application validates the digital certificate of the IIOP Listener/Handler, the application and the IIOP Listener/Handler establish an SSL connection.
  4. The initiating application can then use either password or certificate authentication to authenticate itself to the Oracle Tuxedo domain.

Figure 3-3 illustrates how the SSL protocol works.

Figure 3-3 How the SSL Protocol Works in a CORBA Application

How the SSL Protocol Works in a CORBA Application

Requirements for Using the SSL Protocol

To use the SSL protocol in a CORBA application, you need to install a license that enables the use of the SSL protocol and PKI. For information about installing the license for the security features, see Installing the Oracle Tuxedo System.

The implementation of the SSL protocol is flexible enough to fit into most public key infrastructures. The Oracle Tuxedo product requires that digital certificates are stored in an LDAP-enabled directory. You can choose any LDAP-enabled directory service. You also need to choose the certificate authority from which to obtain digital certificates and private keys used in a CORBA application. You must have an LDAP-enabled directory service and a certificate authority in place before using the SSL protocol in a CORBA application.

Development Process for the SSL Protocol

Using the SSL protocol in a CORBA application is primarily an administration process. Table 3-4 lists the administration steps required to set up the infrastructure required to use the SSL protocol and configure the IIOP Listener/Handler for the SSL protocol. For a detailed description of the administration steps, see Managing Public Key Security on page 4-1 and Configuring the SSL Protocol on page 6-1.

Once the administration steps are complete, you can use either password authentication or certificate authentication in your CORBA application. For more information, see Writing a CORBA Application That Implements Security on page 9-1.

Note: If you are using the Oracle CORBA C++ ORB as a server application, the ORB can also be configured to use the SSL protocol. For more information, see Configuring the SSL Protocol on page 6-1.

If you use the SSL protocol with password authentication, you need to set the SECURITY parameter in the UBBCONFIG file to desired level of authentication and if appropriate, configure the Authentication Server (AUTHSRV). For information about the administration steps for password authentication, see Password Authentication.

Figure 3-4 illustrates the configuration of a CORBA application that uses the SSL protocol.

Figure 3-4 Configuration for Using the SSL Protocol in a CORBA Application

Configuration for Using the SSL Protocol in a CORBA Application

 


Certificate Authentication

Certificate authentication requires that each side of an SSL connection proves its identity to the other side of the connection. In the CORBA security environment, the IIOP Listener/Handler presents its digital certificate to the principal who initiated the SSL connection. The initiator then provides a chain of digital certificates that are used by the IIOP Listener/Handler to verify the identity of the initiator.

Once a chain of digital certificates is successfully verified, the IIOP Listener/Handler retrieves the value of the distinguished name from the subject of the digital certificate. The CORBA security environment uses the e-mail address element of the subject’s distinguished name as the identity of the principal. The IIOP Listener/Handler uses the identity of the principal to impersonate the principal and establish a security context between the initiating application and the Oracle Tuxedo domain.

Once the principal has been authenticated, the principal that initiated the request and the IIOP Listener/Handler agree on a cipher suite that represents the type and strength of encryption that they both support. They also agree on the encryption key and synchronize to start encrypting all subsequent messages.

Figure 3-5 provides a conceptual overview of the certificate authentication.

Figure 3-5 Certificate Authentication

Certificate Authentication

Commonly, X.509 V3 CA certificates are required to contain the Basic Constraints extension, marked as being from a Certificate Authority (CA), and marked as a critical extension (see IETF RFC 2459). Ensuring that V3 CA certificates protects against non-CA certificates from masquerading as intermediate CA certificates.

For more information, please refer to the following URL:

http://www.ietf.org/rfc/rfc2459.txt

Note: This default behavior will not check Basic Constraints on X.509 V1 and V2 certificates, as these versions of X.509 certificates do not support certificate extensions.

There is a mechanism provided to control the level of enforcement that will be performed in order to avoid problems with some customer's applications:

The mechanism is used by setting the value of the environment variable TUX_SSL_ENFORCECONSTRAINTS. The levels of enforcement are as follows:

0

This level disables the enforcement entirely. This is not recommended as a solution unless you really have no other choice.
For example, a customer has purchased certificates from a commercial CA and the chain does not pass the new checks. Most current commercial CA certificates should work under the default level 1 setting. TUX_SSL_ENFORCECONSTRAINTS=0

1

This level is the default. No checking is performed on V1 or V2 certificates in the certificate chain. The Basic Constraints for V3 CA certificates are checked and the certificates are verified to be CA certificates.
TUX_SSL_ENFORCECONSTRAINTS=1

2

This level does the same checking as level 1, and additionally enforces two more requirements:
This is not the default setting because a number of current commercially available V3 CA certificates do not mark the Basic Constraints as critical. TUX_SSL_ENFORCECONSTRAINTS=2

How Certificate Authentication Works

Certificate authentication works in the following manner:

  1. The initiating application accesses the Oracle Tuxedo domain in one of the following ways:
    • Through the CORBA INS Bootstrapping mechanism. Use this mechanism if you are using a client ORB from another vendor. For more information about using CORBA INS, see CORBA Programming Reference in the Oracle Tuxedo online documentation.
    • The Oracle Bootstrapping mechanism. Use this mechanism if you are using the Oracle client ORB.
  2. The initiating application instantiates the Bootstrap object with a URL in the form of corbaloc://host:port or corbalocs://host:port and controls the requirement for protection by setting attributes on the SecurityLevel2::Credentials object returned as a result of the SecurityLevel2::PrincipalAuthenticator::authenticate operation.
Note: You can also use the SecurityLevel2::Current::authenticate() method to secure the bootstrapping process and specify that certificate authentication is to be used.
  1. The initiating application obtains the digital certificates and the private key of the principal. Retrieval of this information may require proof material to be supplied to gain access to the principal’s private key and certificate. The proof material typically is a pass phrase rather than a password.
  2. The security context is established as result of a SecurityLevel2::PrincipalAuthenticator::authenticate() method.

    The IIOP Listener/Handler receives and validates the application’s digital certificate as part of the authentication process.

  3. If the verification succeeds, the Oracle Tuxedo system constructs a Credentials object. The Credentials object for the principal represents the security context for the current thread of execution.
  4. The initiating application invokes a CORBA object in the Oracle Tuxedo domain using an object reference.
  5. The request is packaged into an IIOP request and is forwarded to the IIOP Listener/Handler that associates the request with the established security context.
  6. The request is digitally signed and encrypted before it is sent to the IIOP Listener/Handler. The Oracle Tuxedo system performs the signing and sealing of requests.
  7. The IIOP Listener/Handler receives the request from the initiating application. The request is decrypted.
  8. The IIOP Listener/Handler retrieves the e-mail component of the subjectDN of the principal’s and uses that as the identity of the user.
  9. The IIOP Listener/Handler forwards the request, along with the associated tokens of the principal, to the appropriate CORBA object.
  10. Figure 3-6 How Certificate Authentication Works


    How Certificate Authentication Works

Development Process for Certificate Authentication

To use certificate authentication in a CORBA application, you need to install a license that enables the use of the SSL protocol and PKI. For information about installing the license, see Installing the Oracle Tuxedo System.

Using certificate authentication in a CORBA application includes administration and programming steps. Table 3-5 and Table 3-6 list the administration and programming steps for certificate authentication. For a detailed description of the administration steps, see Managing Public Key Security on page 4-1 and Configuring the SSL Protocol on page 6-1.

Table 3-5 Administration Steps for Certificate Authentication 
Step
Description
1
Set up an LDAP-enabled directory service. You will be prompted for the name of the LDAP server during the installation of the Oracle Tuxedo product.
2
Install the license for the SSL protocol.
3
Obtain a digital certificate and private key for the IIOP Listener/Handler from a certificate authority.
4
Obtain digital certificates and private keys for the CORBA client applications from a certificate authority.
5
Store the private key files for the CORBA client applications and the IIOP Listener/Handler in the Home directory of the user or in $TUXDIR/udataobj/security/keys.
6
Publish the digital certificates for the IIOP Listener/Handler, the CORBA applications, and the certificate authority in the LDAP-enabled directory service.
7
Define the SEC_PRINCIPAL_NAME, SEC_PRINCIPAL_LOCATION, and SEC_PRINCIPAL_PASSVAR for the ISL server process in the UBBCONFIG file.
8
Set the SECURITY parameter in the UBBCONFIG file to USER_AUTH, ACL, or MANDATORY_ACL.
9
Configure the Authentication Server (AUTHSRV) in the UBBCONFIG file.
10
Use the tpusradd and tpgrpadd commands to define the authorized Users and Groups of your CORBA application.
11
Define a port for SSL communication on the IIOP Listener/Handler using the -S option of the ISL command.
12
Enable certificate authentication in the IIOP Listener/Handler using the -a option of the ISL command.
13
Create a Trusted Certificate Authority file (trust_ca.cer) that defines the certificate authorities trusted by the IIOP Listener/Handler.
12
Create a Trusted Certificate Authority file (trust_ca.cer) that defines the certificate authorities trusted by the CORBA client application.
13
Use the tmloadcf command to load the UBBCONFIG file. You will be prompted for the password of the IIOP Listener/Handler defined in the SEC_PRINCIPAL_NAME parameter.
14
Optionally, create a Peer Rules file (peer_val.rul) for both the CORBA client application and the IIOP Listener/Handler.
15
Optionally, modify the LDAP Search filter file to reflect the directory hierarchy in place in your enterprise.

Figure 3-7 illustrates the configuration of a CORBA application that uses certificate authentication.

Figure 3-7 Configuration for Using Certificate Authentication in a CORBA Application

Configuration for Using Certificate Authentication in a CORBA Application

Table 3-6 lists the programming steps for using certificate authentication in a CORBA application. For more information, see Writing a CORBA Application That Implements Security on page 9-1.

Table 3-6 Programming Steps for Certificate Authentication 
Step
Description
1
Write application code that uses the corbaloc or corbalocs URL address formats of the Bootstrap object. Note that the CommonName in the Distinguished Name of the certificate of the IIOP Listener/Handler must match exactly the host name provided in the URL address format. For more information on the URL address formats, see Using the Bootstrapping Mechanism.
You can also use the CORBA INS bootstrap mechanism to object a reference to a PrincipalAuthenticator object in the Oracle Tuxedo domain. For more information about using CORBA INS, see the CORBA Programming Reference.
2
Write application code that uses the authenticate() method of the SecurityLevel2::PrincipalAuthenticator interface to perform authentication. Specify Tobj::CertificateBased for the method argument and the pass phrase for the private key as the auth_data argument for Security::Opaque.

 


Using an Authentication Plug-in

The Oracle Tuxedo product allows the integration of authentication plug-ins into a CORBA application. The Oracle Tuxedo product can accommodate authentication plug-ins using various authentication technologies, including shared-secret password, one-time password, challenge-response, and Kerberos. The authentication interface is based on the generic security service (GSS) application programming interface (API) where applicable and assumes authentication plug-ins have been written to the GSSAPI.

If you chose to use an authentication plug-in, you must configure the authentication plug-in in the registry of the Oracle Tuxedo system. For more detail about the registry, see Configuring Security Plug-ins on page 8-1.

For more information about an authentication plug-ins, including installation and configuration procedures, see your Oracle account executive.

 


Authorization

Authorization allows system administrators to control access to CORBA applications. Specifically, an administrator can use authorization to allow or disallow principals to use resources or services provided by a CORBA application.

The CORBA security environment supports the integration of authorization plug-ins. Authorization decisions are based in part on the user identity represented by an authorization token. Authorization tokens are generated during the authentication process so coordination between the authentication plug-in and the authorization plug-in is required.

If you chose to use an authorization plug-in, you must configure the authorization plug-in the registry of the Oracle Tuxedo system. For more detail about the registry, see Configuring Security Plug-ins on page 8-1.

For more information about authorization plug-ins, including installation and configuration procedures, see your Oracle account executive.

 


Auditing

Auditing provides a means to collect, store, and distribute information about operating requests and their outcomes. Audit-trail records may be used to determine which principals performed, or attempted to perform, actions that violated the configured security policies of a CORBA application. They may also be used to determine which operations were attempted, which ones failed, and which ones successfully completed.

The current implementation of the auditing feature supports the recording of logon failures, impersonation failures, and disallowed operations into the ULOG file. In the case of disallowed operations, the value of the parameters to the operation are not provided because there is no way to know the order and data types of the parameter for an arbitrary operation. Audit entries for logon and impersonation include the identity of the principal attempting to be authenticated. For information about setting up the ULOG file, see Setting Up an Oracle Tuxedo Application.

You can enhance the auditing capabilities of your CORBA application by using an auditing plug-in. The Oracle Tuxedo system will invoke the auditing plug-in at predefined execution points, usually before an operation is attempted and then when potential security violations are detected or when operations are successfully completed. The actions taken to collect, process, protect, and distribute auditing information depend on the capabilities of the auditing plug-in. Care should be taken with the performance impact of audit information collection, especially successful operation audits, which may occur at a high rate.

Auditing decisions are based partly on user identity, which is stored in an auditing token. Because auditing tokens are generated by the authentication plug-in, providers of authentication and auditing plug-ins need to ensure that these plug-ins work together.

The purpose of an auditing request is to record an event. Each auditing plug-in returns one of two responses: success (the audit succeeded and the event was logged) or failure (the audit failed and the event was not logged the event). An auditing plug-in is called once before the operation is performed and once after the operation completes.

Multiple implementations of the auditing plug-in can be used in a CORBA application. Using multiple authorization plug-ins causes more than one preoperation and postoperation auditing operation to be performed.

When using multiple auditing plug-ins, all the plug-ins are placed under a single master auditing plug-in. Each subordinate authorization plug-in returns SUCCESS or FAILURE. If any plug-in fails the operation, the auditing master plug-in determines the outcome to be FAILURE. Other error returns are also considered FAILURE. Otherwise, SUCCESS is the outcome.

In addition, an Oracle Tuxedo system process may call an auditing plug-in when a potential security violation occurs. (Suspicion of a security violation arises when a preoperation or postoperation authorization check fails or when an attack on security is detected.) In response, the auditing plug-in performs a postoperation audit and returns whether the audit succeeded.

The auditing process is somewhat different for users of the auditing feature provided by the Oracle Tuxedo product and users of auditing plug-ins. The default auditing feature does not support preoperation audits. If the default auditing feature receives a preoperation audit request, it returns immediately and does nothing.

If you chose to use an auditing plug-in other than the default auditing plug-in, you must configure the auditing plug-in the registry of the Oracle Tuxedo system. For more detail about the registry, see Configuring Security Plug-ins on page 8-1.

For more information about auditing plug-ins, including installation and configuration procedures, see your Oracle account executive.

 


PKI Plug-ins

The Oracle Tuxedo product provides a PKI environment which includes the SSL protocol and the infrastructure needed to use digital certificates in a CORBA application. However, you can use the PKI interfaces to integrate a PKI plug-in that supplies custom message-based digital signature and message-based encryption to your CORBA applications. Table 3-7 describes the PKI interfaces.

Table 3-7 PKI Interfaces 
PKI Interface
Description
Public key initialization
Allows public key software to open public and private keys. For example, gateway processes may need to have access to a specific private key in order to decrypt messages before routing them.
Key management
Allows public key software to manage and use public and private keys. Note that message digests and session keys are encrypted and decrypted using this interface, but no bulk data encryption is performed using public key cryptography. Bulk data encryption is performed using symmetric key cryptography.
Certificate lookup
Allows public key software to retrieve X.509v3 digital certificates for a given principal. Digital certificates may be stored using any appropriate certificate repository, such as Lightweight Directory Access Protocol (LDAP).
Certificate parsing
Allows public key software to associate a simple principal name with an X.509v3 digital certificate. The parser analyzes a digital certificate to generate a principal name to be associated with the digital certificate.
Certificate validation
Allows public key software to validate an X.509v3 digital certificate in accordance with specific business logic.
Proof material mapping
Allows public key software to access the proof materials needed to open keys, provide authorization tokens, and provide auditing tokens.

The PKI interfaces support the following algorithms:

If you chose to use a PKI plug-in, you must configure the PKI plug-in in the registry of the Oracle Tuxedo system. For more detail about the registry, see Configuring Security Plug-ins on page 8-1.

For more information about PKI plug-ins, including installation and configuration procedures, see your Oracle account executive.

 


Commonly Asked Questions About the CORBA Security Features

The following sections answer some of the commonly asked questions about the CORBA security features.

Do I Have to Change the Security in an Existing CORBA Application?

The answer is no. If you are using security interfaces from previous versions of the WebLogic Enterprise product in your CORBA application there is no requirement for you to change your CORBA application. You can leave your current security scheme in place and your existing CORBA application will work with CORBA applications built with Oracle Tuxedo 8.0 or later.

For example, if your CORBA application consists of a set of server applications which provide general information to all client applications which connect to them, there is really no need to implement a stronger security scheme. If your CORBA application has a set of server applications which provide information to client applications on an internal network which provides enough security to detect sniffers, you do not need to implement the additional security features.

Can I Use the SSL Protocol in an Existing CORBA Application?

The answer is yes. You may want to take advantage of the extra security protection provided by the SSL protocol in your existing CORBA application. For example, if you have a CORBA server application which provides stock prices to a specific set of client applications, you can use the SSL protocol to make sure the client applications are connected to the correct CORBA server application and that they are not being routed to a fake CORBA server application with incorrect data. A username and password is sufficient proof material to authenticate the client application. However, by using the SSL protocol, the message request/reply information can be protected as an additional level of security.

The SSL protocol offers CORBA applications the following benefits:

To use the SSL protocol in a CORBA application, set up the infrastructure to use digital certificates, change the command-line options on the ISL server process to use the SSL protocol, and configure a port for secure communications on the IIOP Listener/Handler. If your existing CORBA application uses password authentication, you can use that code with the SSL protocol. If your CORBA C++ client application does not already catch the InvalidDomain exception when resolving initial references to the Bootstrap object and performing authentication, write code to handle this exception. For more information, see PKI Plug-ins on page 3-22.

When Should I Use Certificate Authentication?

You might be ready to migrate your existing CORBA application to use Internet connections between the CORBA application and Web browsers and commercial Web servers. For example, users of your CORBA application might be shopping over the Internet. The users must be confident that:

In these situations, the SSL protocol and certificate authentication offer CORBA applications the maximum level of protection. In addition to the benefits achieved through the use of the SSL protocol, certificate authentication offers CORBA applications:

For more information, see PKI Plug-ins on page 3-22.


  Back to Top       Previous  Next