NAME
   GenerateAlgorithmParams,
   CSSM_GenerateAlgorithmParams,
   CSP_GenerateAlgorithmParams  - Generate algorithm parameters (CDSA)

 SYNOPSIS
   # include <cssm.h>

    API:
        CSSM_RETURN CSSMAPI CSSM_GenerateAlgorithmParams
        (CSSM_CC_HANDLE CCHandle,
        uint32 ParamBits,
        CSSM_DATA_PTR Param)
    SPI:
        CSSM_RETURN CSSMCSPI CSP_GenerateAlgorithmParams
        (CSSM_CSP_HANDLE CSPHandle,
        CSSM_CC_HANDLE CCHandle,
        const CSSM_CONTEXT *Context,
        uint32 ParamBits,
        CSSM_DATA_PTR Param,
        uint32 *NumberOfUpdatedAttributes,
        CSSM_CONTEXT_ATTRIBUTE_PTR *UpdatedAttributes)

 LIBRARY
   Common Security Services Manager library (CDSA$INCSSM300_SHR.EXE)

 API PARAMETERS
   CCHandle (input)
           The handle that describes the context of this cryptographic
           operation used to link to the CSP-managed information.

   ParamBits (input)
           Used to generate parameters for the algorithm (for example,
           Diffie-Hellman).

   Param (output)
           Pointer to a CSSM_DATA structure used to provide information
           to the parameter generation process, or to receive information
           resulting from the generation process that is not required as
           a parameter to the algorithm.  For instance, phase 2 of the
           KEA algorithm requires a private random value, rA, and a
           public version, Ra, to be generated. The private value, rA,
           is added to the context and the public value, Ra, is returned
           to the caller. In some cases, when both input and output is
           required, a data structure is passed to the algorithm. In this
           situation, Param->Data references the structure and
           Param->Length is set to the length of the structure.

 SPI PARAMETERS
   CSPHandle (input)
           The handle that describes the add-in cryptographic service
           provider module used to perform up calls to CSSM for the
           memory functions managed by CSSM.

   Context (input)
           Pointer to CSSM_CONTEXT structure that describes the
           attributes with this context. Modifying this structure has
           no effect on the internal structure maintained by the CSSM.
           It is only a copy of the actual data. Changes to the context
           attributes must be returned using the UpdatedAttributes
           return parameter.

   NumberOfUpdatedAttributes (output)
           The number of CSSM_CONTEXT_ATTRIBUTE structures contained
           in the UpdatedAttributes array. If this value is zero,
           UpdatedAttributes should be set to NULL.

   UpdatedAttributes (output)
           An array of attributes that will be added to the context
           should be returned using this parameter. Memory for the
           attribute structures should be allocated using the
           CSSM_UPCALLS callbacks provided to the service provider
           module when CSSM_SPI_ModuleAttach() is called.

 DESCRIPTION
   This function generates algorithm parameters for the specified
   context.  These parameters include Diffie-Hellman key agreement
   parameters and DSA key generation parameters. In most cases the
   algorithm parameters will be added directly to the cryptographic
   context (by returning an array of CSSM_CONTEXT_ATTRIBUTE structures),
   but an algorithm may return some data to the caller via the Param
   parameter. The generated parameters are added to the context as an
   attribute of type CSSM_ATTRIBUTE_ALG_PARAMS.  Other attributes
   returned are added to the context, or replace existing values in
   the context.

 NOTES FOR API
   The output is returned to the caller either by filling the caller-
   specified buffer or by using the application's declared memory
   allocation functions to allocate buffer space. To specify a
   specific, pre-allocated output buffer, the caller must provide
   an array of one or more CSSM_DATA structures each, containing a
   Length field value greater than zero and a non-NULL data pointer
   field value. To specify automatic output buffer allocation by the
   CSP, the caller must provide an array of one or more CSSM_DATA
   structures, each containing a Length field value equal to zero and
   a NULL data pointer field value. The application is always
   responsible for deallocating the memory when it is no longer needed.

 NOTES FOR SPI
   The output is returned to the caller as specified in Buffer
   Management for Cryptographic Services.

 RETURN VALUE
   A CSSM_RETURN value indicating success or specifying a particular
   error condition. The value CSSM_OK indicates success. All other
   values represent an error condition.

 ERRORS
   Errors are described in the CDSA technical standard.  See CDSA.

   None specific to this call.

 SEE ALSO
   Books

   Intel CDSA Application Developer's Guide (see CDSA)

   Other Help Topics