text: /* Microsoft Reference Implementation for TPM 2.0
   *
   *  The copyright in this software is being made available under the BSD License,
   *  included below. This software may be subject to other third party and
   *  contributor rights, including patent rights, and no such rights are granted
   *  under this license.
   *
   *  Copyright (c) Microsoft Corporation
   *
   *  All rights reserved.
   *
   *  BSD License
   *
   *  Redistribution and use in source and binary forms, with or without modification,
   *  are permitted provided that the following conditions are met:
   *
   *  Redistributions of source code must retain the above copyright notice, this list
   *  of conditions and the following disclaimer.
   *
   *  Redistributions in binary form must reproduce the above copyright notice, this
   *  list of conditions and the following disclaimer in the documentation and/or
   *  other materials provided with the distribution.
   *
   *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
   *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   *  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
   *  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   *  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
   *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  /*(Auto-generated)
   *  Created by TpmPrototypes; Version 3.0 July 18, 2017
   *  Date: Aug 12, 2017  Time: 03:40:11PM
   */
  
  #ifndef    _CRYPTRSA_FP_H_
  #define    _CRYPTRSA_FP_H_
  
  #ifdef  TPM_ALG_RSA
  
  //*** CryptRsaInit()
  // Function called at _TPM_Init().
  BOOL
  CryptRsaInit(
      void
      );
  
  //*** CryptRsaStartup()
  // Function called at TPM2_Startup()
  BOOL
  CryptRsaStartup(
      void
      );
  
  void
  RsaInitializeExponent(
      privateExponent_t      *pExp
      );
  
  //*** CryptRsaSelectScheme()
  // This function is used by TPM2_RSA_Decrypt and TPM2_RSA_Encrypt.  It sets up
  // the rules to select a scheme between input and object default.
  // This function assume the RSA object is loaded.
  // If a default scheme is defined in object, the default scheme should be chosen,
  // otherwise, the input scheme should be chosen.
  // In the case that both the object and 'scheme' are not TPM_ALG_NULL, then
  // if the schemes are the same, the input scheme will be chosen.
  // if the scheme are not compatible, a NULL pointer will be returned.
  //
  // The return pointer may point to a TPM_ALG_NULL scheme.
  TPMT_RSA_DECRYPT*
  CryptRsaSelectScheme(
      TPMI_DH_OBJECT       rsaHandle,     // IN: handle of an RSA key
      TPMT_RSA_DECRYPT    *scheme         // IN: a sign or decrypt scheme
      );
  
  //*** CryptRsaLoadPrivateExponent()
  // This function is called to generate the private exponent of an RSA key. //
  // return type: TPM_RC
  //  TPM_RC_BINDING      public and private parts of 'rsaKey' are not matched
  TPM_RC
  CryptRsaLoadPrivateExponent(
      OBJECT          *rsaKey        // IN: the RSA key object
      );
  
  //*** CryptRsaEncrypt()
  // This is the entry point for encryption using RSA. Encryption is
  // use of the public exponent. The padding parameter determines what
  // padding will be used.
  //
  // The 'cOutSize' parameter must be at least as large as the size of the key.
  //
  // If the padding is RSA_PAD_NONE, 'dIn' is treated as a number. It must be
  // lower in value than the key modulus.
  // NOTE: If dIn has fewer bytes than cOut, then we don't add low-order zeros to
  //       dIn to make it the size of the RSA key for the call to RSAEP. This is
  //       because the high order bytes of dIn might have a numeric value that is
  //       greater than the value of the key modulus. If this had low-order zeros
  //       added, it would have a numeric value larger than the modulus even though
  //       it started out with a lower numeric value.
  //
  //  return type:    TPM_RC
  //      TPM_RC_VALUE     'cOutSize' is too small (must be the size
  //                        of the modulus)
  //      TPM_RC_SCHEME    'padType' is not a supported scheme
  //
  LIB_EXPORT TPM_RC
  CryptRsaEncrypt(
      TPM2B_PUBLIC_KEY_RSA        *cOut,          // OUT: the encrypted data
      TPM2B                       *dIn,           // IN: the data to encrypt
      OBJECT                      *key,           // IN: the key used for encryption
      TPMT_RSA_DECRYPT            *scheme,        // IN: the type of padding and hash
                                                  //     if needed
      const TPM2B                 *label,         // IN: in case it is needed
      RAND_STATE                  *rand           // IN: random number generator
                                                  //     state (mostly for testing)
      );
  
  //*** CryptRsaDecrypt()
  // This is the entry point for decryption using RSA. Decryption is
  // use of the private exponent. The "padType" parameter determines what
  // padding was used.
  //
  //  return type:    TPM_RC
  //      TPM_RC_SIZE        'cInSize' is not the same as the size of the public
  //                          modulus of 'key'; or numeric value of the encrypted
  //                          data is greater than the modulus
  //      TPM_RC_VALUE       'dOutSize' is not large enough for the result
  //      TPM_RC_SCHEME      'padType' is not supported
  //
  LIB_EXPORT TPM_RC
  CryptRsaDecrypt(
      TPM2B               *dOut,          // OUT: the decrypted data
      TPM2B               *cIn,           // IN: the data to decrypt
      OBJECT              *key,           // IN: the key to use for decryption
      TPMT_RSA_DECRYPT    *scheme,        // IN: the padding scheme
      const TPM2B         *label          // IN: in case it is needed for the scheme
      );
  
  //*** CryptRsaSign()
  // This function is used to generate an RSA signature of the type indicated in
  // 'scheme'.
  //
  //  return type: TPM_RC
  //      TPM_RC_SCHEME       'scheme' or 'hashAlg' are not supported
  //      TPM_RC_VALUE        'hInSize' does not match 'hashAlg' (for RSASSA)
  //
  LIB_EXPORT TPM_RC
  CryptRsaSign(
      TPMT_SIGNATURE      *sigOut,
      OBJECT              *key,           // IN: key to use
      TPM2B_DIGEST        *hIn,           // IN: the digest to sign
      RAND_STATE          *rand           // IN: the random number generator
                                          //      to use (mostly for testing)
      );
  
  //*** CryptRsaValidateSignature()
  // This function is used to validate an RSA signature. If the signature is valid
  // TPM_RC_SUCCESS is returned. If the signature is not valid, TPM_RC_SIGNATURE is
  // returned. Other return codes indicate either parameter problems or fatal errors.
  //
  // return type: TPM_RC
  //      TPM_RC_SIGNATURE    the signature does not check
  //      TPM_RC_SCHEME       unsupported scheme or hash algorithm
  //
  LIB_EXPORT TPM_RC
  CryptRsaValidateSignature(
      TPMT_SIGNATURE  *sig,           // IN: signature
      OBJECT          *key,           // IN: public modulus
      TPM2B_DIGEST    *digest         // IN: The digest being validated
      );
  
  //*** CryptRsaGenerateKey()
  // Generate an RSA key from a provided seed
  // return type: TPM_RC
  //  TPM_RC_CANCELED     operation was canceled
  //  TPM_RC_RANGE        public exponent is not supported
  //  TPM_RC_VALUE        could not find a prime using the provided parameters
  LIB_EXPORT TPM_RC
  CryptRsaGenerateKey(
      OBJECT              *rsaKey,            // IN/OUT: The object structure in which
                                              //          the key is created.
      RAND_STATE          *rand               // IN: if not NULL, the deterministic
                                              //     RNG state
      );
  #endif // TPM_ALG_RSA
  
  #endif  // _CRYPTRSA_FP_H_
  