// CkDsaW.h: interface for the CkDsaW class. // ////////////////////////////////////////////////////////////////////// // This header is generated for Chilkat 11.3.0 #ifndef _CkDsaW_H #define _CkDsaW_H #include "chilkatDefs.h" #include "CkString.h" #include "CkWideCharBase.h" class CkByteData; class CkBinDataW; #if !defined(__sun__) && !defined(__sun) #pragma pack (push, 8) #endif // CLASS: CkDsaW class CK_VISIBLE_PUBLIC CkDsaW : public CkWideCharBase { private: // Don't allow assignment or copying these objects. CkDsaW(const CkDsaW &); CkDsaW &operator=(const CkDsaW &); public: CkDsaW(void); virtual ~CkDsaW(void); static CkDsaW *createNew(void); void CK_VISIBLE_PRIVATE inject(void *impl); // May be called when finished with the object to free/dispose of any // internal resources held by the object. void dispose(void); // BEGIN PUBLIC INTERFACE // ---------------------- // Properties // ---------------------- // The group size (in bits) to be used in DSA key generation. The default value is // 160 and corresponds to the fact that SHA-1 is used in signature generation. This // property setting should not be changed. It exists for future expansion when // additional underlying hash algorithms are supported. int get_GroupSize(void); // The group size (in bits) to be used in DSA key generation. The default value is // 160 and corresponds to the fact that SHA-1 is used in signature generation. This // property setting should not be changed. It exists for future expansion when // additional underlying hash algorithms are supported. void put_GroupSize(int newVal); // The G part of a public or private DSA key returned as a hex-encoded SSH1-format // bignum. The G is the generator. DSA key params consist of G, P, and Q. void get_HexG(CkString &str); // The G part of a public or private DSA key returned as a hex-encoded SSH1-format // bignum. The G is the generator. DSA key params consist of G, P, and Q. const wchar_t *hexG(void); // The P part of a public or private DSA key returned as a hex-encoded SSH1-format // bignum. The P is a large prime. DSA key params consist of G, P, and Q. void get_HexP(CkString &str); // The P part of a public or private DSA key returned as a hex-encoded SSH1-format // bignum. The P is a large prime. DSA key params consist of G, P, and Q. const wchar_t *hexP(void); // The Q part of a public or private DSA key returned as a hex-encoded SSH1-format // bignum. DSA key params consist of G, P, and Q. void get_HexQ(CkString &str); // The Q part of a public or private DSA key returned as a hex-encoded SSH1-format // bignum. DSA key params consist of G, P, and Q. const wchar_t *hexQ(void); // The X part of a DSA private key returned as a hex-encoded SSH1-format bignum. void get_HexX(CkString &str); // The X part of a DSA private key returned as a hex-encoded SSH1-format bignum. const wchar_t *hexX(void); // The Y part of a DSA public key returned as a hex-encoded SSH1-format bignum. // (The Y value is also accessible w/ a private key, but the X value is not // available in a DSA public key.) void get_HexY(CkString &str); // The Y part of a DSA public key returned as a hex-encoded SSH1-format bignum. // (The Y value is also accessible w/ a private key, but the X value is not // available in a DSA public key.) const wchar_t *hexY(void); // This is a catch-all property to be used for uncommon needs. This property // defaults to the empty string and should typically remain empty. void get_UncommonOptions(CkString &str); // This is a catch-all property to be used for uncommon needs. This property // defaults to the empty string and should typically remain empty. const wchar_t *uncommonOptions(void); // This is a catch-all property to be used for uncommon needs. This property // defaults to the empty string and should typically remain empty. void put_UncommonOptions(const wchar_t *newVal); // ---------------------- // Methods // ---------------------- // Loads a DSA private key from in-memory DSA DER-encoded bytes. bool FromDer(CkByteData &derData); // Loads a DSA private key from DER contained in bd. bool FromDerBd(CkBinDataW &bd); // Loads a DSA private key from a DER-encoded file. bool FromDerFile(const wchar_t *path); // Loads a DSA private key from an in-memory encrypted PEM-formatted string. If the // PEM passed to this method is unencrypted, the password is ignored and the PEM is // simply loaded. bool FromEncryptedPem(const wchar_t *password, const wchar_t *pemData); // Loads a DSA private key from an in-memory unencrypted PEM-formatted string. bool FromPem(const wchar_t *pemData); // Loads a DSA public key from an in-memory DER-encoded byte array. bool FromPublicDer(CkByteData &derData); // Loads a DSA public key from an DER-encoded data in bd. bool FromPublicDerBd(CkBinDataW &bd); // Loads a DSA public key from a DER-encoded file. bool FromPublicDerFile(const wchar_t *path); // Loads a DSA public-key from an in-memory PEM string. bool FromPublicPem(const wchar_t *pemData); // Loads a DSA public or private key from an in-memory XML string. bool FromXml(const wchar_t *xmlKey); // Generates a new DSA key that is numBits bits in length. The numBits should be at least // 1024 bits and a multiple of 64. Typical values are 1024 and 2048. The newly // generated key may be exported by calling one of the To* methods. bool GenKey(int numBits); // Generates a new DSA key that is keyLenBits bits in length with a modulus of size modLenBits // bits. The keyLenBits should be at least 1024 bits and a multiple of 64. FIPS 186-4 // specifies the key length (bits) and modulus size (bits) to have one of the // values: (1024, 160), (2048, 224), (2048, 256), or (3072, 256). bool GenKey2(int keyLenBits, int modLenBits); // Generates a new DSA key from in-memory DER parameters created by OpenSSL. The // newly generated key may be exported by calling one of the To* methods. bool GenKeyFromParamsDer(CkByteData &derBytes); // Generates a new DSA key using the binary OpenSSL formatted DER parameters in // bd. The key can be exported using any of the To* methods. bool GenKeyFromParamsDerBd(CkBinDataW &bd); // Generates a new DSA key from a DER-format parameters file created by OpenSSL. An // example of using OpenSSL to generate DSA parameters in DER format is:openssl dsaparam -outform DER 1024 dsaparam.der // The newly generated key may be exported by calling one of the To* methods. bool GenKeyFromParamsDerFile(const wchar_t *path); // Generates a new DSA key from parameters (PEM formatted string) created by // OpenSSL. The newly generated key may be exported by calling one of the To* // methods. bool GenKeyFromParamsPem(const wchar_t *pem); // Generates a new DSA key from a PEM parameters file created by OpenSSL. The newly // generated key may be exported by calling one of the To* methods. // // OpenSSL provides the ability to generate DSA key parameters. For example:openssl dsaparam 1024 dsaparam.pem // // Here is a sample DSA parameters PEM: // -----BEGIN DSA PARAMETERS----- // MIIBHgKBgQCXIAx4XzLVZ5ZqOFzdsYWVyH/6E/mVPw4TgMZS6Wxajnbdn1/CUBzE // RWTUp8SguTSDpjC1Q/nyno0G6Q96VoW+PUXv8qUph8vbSaEdsjYO/8jSfzkGfvsa // cucr1ythfNyk63aZAKzxeutOmsVe77l6pZI96ROjWF5iizuUB4WgmwIVANxM70wH // 8iPPYVzPZqtXCB66I2SnAoGAIbW2VYRjRdoA7trJgmnfWakghKwV1WyaYrotqeDE // 07/dipp0cNuY0IAJgSmqLHlAkNa2ZNI/c1mNxcwhYzZrnn8CXIqrYmtI33w0PYCx // KHPqj7puhddFwYS/rFiyWAN0jtCMHlfCVzFGbSzach5QQraPV9YApJXy+ORJ8VPU // /zo= // -----END DSA PARAMETERS----- // bool GenKeyFromParamsPemFile(const wchar_t *path); // Generates a new DSA key from pre-chosen P, Q, and G params. bool GenKeyFromPQG(const wchar_t *pHex, const wchar_t *qHex, const wchar_t *gHex); // Returns the bytes of the Hash property as a hex or base64 encoded string. The // encoding should be set to either hex or base64 . bool GetEncodedHash(const wchar_t *encoding, CkString &outStr); // Returns the bytes of the Hash property as a hex or base64 encoded string. The // encoding should be set to either hex or base64 . const wchar_t *getEncodedHash(const wchar_t *encoding); // Returns the bytes of the Hash property as a hex or base64 encoded string. The // encoding should be set to either hex or base64 . const wchar_t *encodedHash(const wchar_t *encoding); // Returns the bytes of the Signature property as a hex or base64 encoded string. // The encoding should be set to either hex or base64 . The Signature property is set // when SignHash is called. bool GetEncodedSignature(const wchar_t *encoding, CkString &outStr); // Returns the bytes of the Signature property as a hex or base64 encoded string. // The encoding should be set to either hex or base64 . The Signature property is set // when SignHash is called. const wchar_t *getEncodedSignature(const wchar_t *encoding); // Returns the bytes of the Signature property as a hex or base64 encoded string. // The encoding should be set to either hex or base64 . The Signature property is set // when SignHash is called. const wchar_t *encodedSignature(const wchar_t *encoding); // Convenience method to load the entire contents of a text file into a string. It // is assumed that the text contains ANSI encoded character data. bool LoadText(const wchar_t *path, CkString &outStr); // Convenience method to load the entire contents of a text file into a string. It // is assumed that the text contains ANSI encoded character data. const wchar_t *loadText(const wchar_t *path); // Convenience method to save a string to a text file. The text is saved using the // ANSI character encoding. bool SaveText(const wchar_t *strToSave, const wchar_t *path); // Provides a way to set the Hash property by passing an encoded string. The encoding // can be hex or base64 . The encodedHash contains the encoded bytes of the hash that will // be signed or verified via the SignHash and Verify methods. bool SetEncodedHash(const wchar_t *encoding, const wchar_t *encodedHash); // Sets the bytes of the Signature property. (The signature must be specified prior // to calling the Verify method.) This method allows for the signature to be set // via a hex or base64 encoded string. The encoding should be set to either hex or // base64 . bool SetEncodedSignature(const wchar_t *encoding, const wchar_t *encodedSig); // Sets the bytes of the Signature property by providing the R and S values in // encoded form. (The signature must be specified prior to calling the Verify // method.) The R and S values may be set via a hex or base64 encoded string. The // encoding should be set to either hex or base64 . bool SetEncodedSignatureRS(const wchar_t *encoding, const wchar_t *encodedR, const wchar_t *encodedS); // Sets the DSA object's private key from explicitly provided pHex, qHex, gHex, and // xHex values. The groupSizeInBytes specifies the group size (in bytes). It is typically equal // to 20, which is the length of the underlying hash function (SHA-1) for signing. // The pHex, qHex, gHex, and xHex values are hex-encoded SSH1-format bignums. bool SetKeyExplicit(int groupSizeInBytes, const wchar_t *pHex, const wchar_t *qHex, const wchar_t *gHex, const wchar_t *xHex); // Sets the DSA object's private key from explicitly provided pHex, qHex, gHex, and // yHex values. The groupSizeInBytes specifies the group size (in bytes). It is typically equal // to 20, which is the length of the underlying hash function (SHA-1) for signing. // The pHex, qHex, gHex, and yHex values are hex-encoded SSH1-format bignums. bool SetPubKeyExplicit(int groupSizeInBytes, const wchar_t *pHex, const wchar_t *qHex, const wchar_t *gHex, const wchar_t *yHex); // Signs a hash using the digital signature algorithm. Before calling this method, // set the hash to be signed by either calling SetEncodedHash or by setting the // Hash property. If SignHash returns true, the signature may be retrieved by // either calling GetEncodedHash, or by accessing the Signature property. bool SignHash(void); // Writes the DSA private key to a DER-encoded byte array. bool ToDer(CkByteData &outBytes); // Writes the DSA private key to DER-encoded bytes in the bd. bool ToDerBd(CkBinDataW &bd); // Writes the DSA private key to a DER-format file. bool ToDerFile(const wchar_t *path); // Writes the DSA private key to an in-memory encrypted PEM string. bool ToEncryptedPem(const wchar_t *password, CkString &outStr); // Writes the DSA private key to an in-memory encrypted PEM string. const wchar_t *toEncryptedPem(const wchar_t *password); // Writes the DSA private key to an in-memory PEM string. bool ToPem(CkString &outStr); // Writes the DSA private key to an in-memory PEM string. const wchar_t *toPem(void); // Writes the DSA public key to a DER-encoded byte array. bool ToPublicDer(CkByteData &outBytes); // Writes the DSA public key to a DER-encoded bytes in bd. bool ToPublicDerBd(CkBinDataW &bd); // Writes the DSA public key to a DER-format file. bool ToPublicDerFile(const wchar_t *path); // Writes the DSA public key to an in-memory PEM string. bool ToPublicPem(CkString &outStr); // Writes the DSA public key to an in-memory PEM string. const wchar_t *toPublicPem(void); // Writes the DSA private or public key to an in-memory XML string. The bPublicOnly // determines whether the public or private key is written. bool ToXml(bool bPublicOnly, CkString &outStr); // Writes the DSA private or public key to an in-memory XML string. The bPublicOnly // determines whether the public or private key is written. const wchar_t *toXml(bool bPublicOnly); // Verifies a DSA signature. The Hash and Signature properties must be set prior to // calling this method. (These properties may also be set via the SetEncodedHash // and SetEncodedSignature methods.) bool Verify(void); // Verifies that the public or private key contained in the calling Dsa object is // valid. Returns true if valid, otherwise returns false. bool VerifyKey(void); // END PUBLIC INTERFACE }; #if !defined(__sun__) && !defined(__sun) #pragma pack (pop) #endif #endif