sshc.h

Go to the documentation of this file.

/*
 * sshc.h
 *
 * SSH Client Developer API
 *
 * Copyright 2019-2024 DigiCert, Inc. All Rights Reserved.
 * Proprietary and Confidential Material.
 *
 */

#ifndef __SSHC_HEADER__
#define __SSHC_HEADER__

#include "../../common/mtcp.h"
#include "../../crypto/pubcrypto.h"

#ifdef __cplusplus
extern "C" {
#endif

#define SSHC_SFTP_MAX_READ_BYTES                (MAX_SESSION_WINDOW_SIZE - (4 + 4 + 1 + 4))
#define SSHC_BUFFER_SIZE                        (SSHC_MAX_BUFFER_SIZE)

#define CONNECT_CLOSING                         -1
#define CONNECT_DISABLED                        0
#define CONNECT_CLOSED                          1
#define CONNECT_NEGOTIATE                       2
#define CONNECT_OPEN                            3

#define SSH_BYTE_SIZE                           1
#define SSH_UINT64_FIELD_SIZE                   8


/*------------------------------------------------------------------*/

/* timeouts in milliseconds (zero indicates no timeout) */
#if 1
 #define TIMEOUT_SSHC_OPEN                       (2000)
 #ifdef __ENABLE_MOCANA_QS__
    #define TIMEOUT_SSHC_KEX                     (120000)
 #elif defined(__FSL_MSS_FIX_ENABLED__)
    #define TIMEOUT_SSHC_KEX                     (40000)
 #else
    #define TIMEOUT_SSHC_KEX                     (10000)
 #endif

 #define TIMEOUT_SSHC_NEWKEYS                    (15000)
#ifdef __ENABLE_MOCANA_QS__
 #define TIMEOUT_SSHC_SERVICE_REQUEST            (120000)
#else
 #define TIMEOUT_SSHC_SERVICE_REQUEST            (30000)
#endif
 #define TIMEOUT_SSHC_OPEN_STATE                 (30000)
 #define TIMEOUT_SSHC_UPPER_LAYER                (15000)
 #define TIMEOUT_SSHC_PORTFWD_MESG               (500)
 #define TIMEOUT_SSHC_PORTFWD_START              (1000)
#else
#define TIMEOUT_SSHC_OPEN                       (0)
#define TIMEOUT_SSHC_KEX                        (0)
#define TIMEOUT_SSHC_NEWKEYS                    (0)
#define TIMEOUT_SSHC_SERVICE_REQUEST            (0)
#define TIMEOUT_SSHC_OPEN_STATE                 (0)
#define TIMEOUT_SSHC_UPPER_LAYER                (0)
#endif


/* the most interesting of these values, the amount of time we allow the user to authenticate */
#ifdef __ENABLE_MOCANA_QS__
 #define TIMEOUT_SSHC_AUTH_LOGON                 (1000 * 60 * 200)
#else
 #define TIMEOUT_SSHC_AUTH_LOGON                 (1000 * 60 * 10)
#endif

/* suggested by SSHv2 standard, max number of authentication attempts */
#define MAX_SSHC_AUTH_ATTEMPTS                  (20)

/* sizes */
#if 1
  #ifndef SSHC_MAX_BUFFER_SIZE
    #ifdef __ENABLE_MOCANA_QS__
        #define SSHC_MAX_BUFFER_SIZE            (2097152)
    #elif defined(__FSL_MSS_FIX_ENABLED__)
        #define SSHC_MAX_BUFFER_SIZE            (2200)
    #else
        #define SSHC_MAX_BUFFER_SIZE            (1024*4)
    #endif
  #endif

  #ifdef __FSL_MSS_FIX_ENABLED__
    #define MAX_SESSION_WINDOW_SIZE             (2500)
  #else
    #define MAX_SESSION_WINDOW_SIZE             (1024*2)
  #endif

  #define SSHC_SYNC_BUFFER_SIZE                 (1000)
  #define SSHC_SFTP_GetMaxBytesToRead()         (SSHC_SYNC_BUFFER_SIZE)
#else
/* fast sizes */
  #ifndef SSHC_MAX_BUFFER_SIZE
    #define SSHC_MAX_BUFFER_SIZE                (16000)
  #endif

  #define MAX_SESSION_WINDOW_SIZE               (15000)
  #define SSHC_SYNC_BUFFER_SIZE                 (8192)
  #define SSHC_SFTP_GetMaxBytesToRead()           (SSHC_SYNC_BUFFER_SIZE)
#endif

/* SSH Key Blob Types */
#define SSH_PUBLIC_KEY_BLOB                     1
#define SSH_PRIVATE_KEY_BLOB                    2

/* SSH Advertised Authentication Methods (OR for multiple types) */
#define MOCANA_SSH_AUTH_PUBLIC_KEY              0x80
#define MOCANA_SSH_AUTH_PASSWORD                0x40
#define MOCANA_SSH_AUTH_NONE                    0x10
#define MOCANA_SSH_AUTH_KEYBOARD_INTERACTIVE    0x20
#define MOCANA_SSH_AUTH_CERT                    0x100

/* OCSP responders */
#define MAX_OCSP_TRUSTED_RESPONDERS             3

#define SSH_MAX_RPF_HOSTS                       16
#define SSH_MAX_REMOTE_PORT_FWD_CHANNEL         64

/* authentication keyboard interactive */
#define AUTH_ECHO                               (1)
#define AUTH_NO_ECHO                            (0)

#ifndef AUTH_MAX_NUM_PROMPTS
#define AUTH_MAX_NUM_PROMPTS                    3
#endif

#ifndef MAX_SSH_DH_SIZE
#define MAX_SSH_DH_SIZE                         (8192)
#endif

/*------------------------------------------------------------------*/

/* message types */
enum sshcSessionTypes
{
    SSH_SESSION_NOTHING,
    SSH_SESSION_OPEN,
    SSH_SESSION_PTY_REQUEST,
    SSH_SESSION_OPEN_SHELL,
    SSH_SESSION_OPEN_SFTP,
    SSH_SESSION_OPEN_PTY,
    SSH_SESSION_WINDOW_CHANGE,
    SSH_SESSION_DATA,
    SSH_SESSION_STDERR,
    SSH_SESSION_EOF,
    SSH_SESSION_CLOSED,
    SSH_SESSION_BREAK_OP
};

enum pfType
{
    SSH_LOCAL_PORT_FORWARDING,
    SSH_REMOTE_PORT_FORWARDING
};

/*------------------------------------------------------------------*/

typedef struct
{
    ubyte4          width;
    ubyte4          height;
    ubyte4          pixelWidth;
    ubyte4          pixelHeight;

    sbyte*          pTerminalEnvironment;
    ubyte4          terminalEnvironmentLength;

    sbyte*          pEncodedTerminalModes;
    ubyte4          encodedTerminalModes;

    ubyte4          breakLength;

} clientTerminalState;


/*------------------------------------------------------------------*/

#ifdef __ENABLE_MOCANA_SSH_FTP_CLIENT__

typedef struct
{
    intBoolean              isFileHandleInUse;
    void*                   pHandleName;
    void*                   cookie;                 /* not used for directories */

    sbyte4                  readLocation;           /* current position / total bytes read */
    sbyte*                  pReadBuffer;
    sbyte4                  readBufferSize;

    sbyte4                  writeLocation;          /* current position / total bytes written */
    sbyte*                  pWriteBuffer;
    sbyte4                  writeBufferSize;

    sbyte4                  clientWrtLoc;           /* internal use */
    ubyte4                  requestID;              /* current pending request id */
    ubyte                   request;                /* not sure if needed */
    ubyte4                  requestStatusResponse;  /* the status response for the request */
    sbyte4                  response;               /* response message type for our request */

    /* for realpath */
    struct ATTRClient*      pATTR;                  /* used by SSH_FXP_NAME */
    void*                   pFilename;              /* used by SSH_FXP_NAME */

    /* for file listings */
    ubyte*                  pFileListingPayload;    /* used by SSH_FXP_NAME */
    ubyte4                  fileListingCount;
    ubyte4                  fileListingPosition;
    ubyte4                  fileListingBufIndex;
    ubyte4                  fileListingPayloadLen;

} sftpcFileHandleDescr;
#endif /* __ENABLE_MOCANA_SSH_FTP_CLIENT__ */

typedef struct
{
    sbyte*          pPrompt;
    ubyte4          promptLen;
    ubyte4          echo;

} keyIntPrompt;

typedef struct keyIntInfoReq
{
    sbyte4          cookie;                             /* for flexiblity, useful for marking things as static or dynamic, etc */

    sbyte*          pName;
    ubyte4          nameLen;
    sbyte*          pInstruction;
    ubyte4          instructionLen;

    ubyte4          numPrompts;
    keyIntPrompt*   prompts[AUTH_MAX_NUM_PROMPTS];

} keyIntInfoReq;

typedef struct
{
    ubyte*          pResponse;
    ubyte4          responseLen;

} keyIntResp;

typedef struct
{
    ubyte4          numResponses;
    keyIntResp*     responses[AUTH_MAX_NUM_PROMPTS];    /* contains responses to prompts */

} keyIntInfoResp;
struct certChain;
typedef struct certChain* certChainPtr;

/*------------------------------------------------------------------*/

typedef struct
{
    sbyte4          sshMaxConnections;

    ubyte4          sshMaxAuthAttempts;

    ubyte4          sshTimeOutOpen;

    ubyte4          sshTimeOutKeyExchange;

    ubyte4          sshTimeOutNewKeys;

    ubyte4          sshTimeOutServiceRequest;

    ubyte4          sshTimeOutAuthentication;

    ubyte4          sshTimeOutDefaultOpenState;

#if ((defined(__ENABLE_MOCANA_SSH_OCSP_SUPPORT__)) && (defined(__ENABLE_MOCANA_OCSP_CLIENT__)))

    ubyte4          trustedResponderCount;
    certDescriptor  ocspTrustedResponderCerts[MAX_OCSP_TRUSTED_RESPONDERS];
#endif

    MSTATUS (*funcPtrSessionOpen)    (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen);

    MSTATUS (*funcPtrPtyRequest)     (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen);

    MSTATUS (*funcPtrOpenShell)      (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen);

    MSTATUS (*funcPtrOpenSftp)       (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen);

    MSTATUS (*funcPtrWindowChange)   (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen);

    MSTATUS (*funcPtrReceivedData)   (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen);

    MSTATUS (*funcPtrStdErr)         (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen);

    MSTATUS (*funcPtrEof)            (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen);

    MSTATUS (*funcPtrClosed)         (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen);

    MSTATUS (*funcPtrBreakOp)        (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen);

    /* general purpose upcalls */

    void(*funcPtrStartTimer)     (sbyte4 connectionInstance, ubyte4 msTimerExpire, sbyte4 boolUserAuthenticated);


    sbyte4(*funcPtrRetrieveNakedAuthKeys)(sbyte4 connectionInstance, ubyte **ppRetKeyBlob,  ubyte4 *pRetKeyBlobLength);

    sbyte4(*funcPtrReleaseNakedAuthKeys) (sbyte4 connectionInstance, ubyte **ppFreeKeyBlob);

    /* for SSH_MSG_USERAUTH_REQUEST (50). pMethod can be one of MOCANA_SSH_AUTH_PUBLIC_KEY or MOCANA_SSH_AUTH_PASSWORD. */

    sbyte4(*funcPtrServerPubKeyAuth)           (sbyte4 connectionInstance, const ubyte *pPubKey,   ubyte4 pubKeyLength);

    sbyte4(*funcPtrRetrieveUserAuthRequestInfo)(sbyte4 connectionInstance, ubyte *pAuthNameList, ubyte4 authNameListLen, ubyte **ppUserName, ubyte4 *pUserNameLength, ubyte4 *pMethod);


#ifdef __ENABLE_MOCANA_SSH_AUTH_KEYBOARD_INTERACTIVE__
    sbyte4(*funcPtrKeyIntAuthResp)(sbyte4 connectionInstance, keyIntInfoReq* pRequestInfo, keyIntInfoResp* pResponseInfo);

    sbyte4(*funcPtrReleaseKeyIntAuthResp)(sbyte4 connectionInstance, keyIntInfoResp *pResponse);
#endif

    sbyte4(*funcPtrRetrieveUserAuthRequestInfoEx)(sbyte4 connectionInstance, ubyte messageCode, ubyte4 methodType, ubyte *pAuthNameList, ubyte4 authNameListLen, ubyte **ppUserName, ubyte4 *pUserNameLength, ubyte4 *pMethod, intBoolean *pSendSignature);

    sbyte4(*funcPtrCertStatus)      (sbyte4 connectionInstance,
                         sbyte4 cert_status, ubyte *pCertificate, ubyte4 certLen,
                         certChainPtr pCertChain, const ubyte *pAnchorCert, ubyte4 anchorCertLen);

    sbyte4(*funcPtrRetrieveUserPassword)       (sbyte4 connectionInstance, ubyte *pUserName, ubyte4 userNameLength, ubyte **ppUserPassword, ubyte4 *pUserPasswordLength);

    void(*funcPtrAuthOpen)                     (sbyte4 connectionInstance);

    sbyte4(*funcPtrSessionOpenFail) (sbyte4 connectionInstance, ubyte *pInfo, ubyte4 infoLength, ubyte *pLanguage, ubyte4 languageLength);

#ifdef __ENABLE_MOCANA_SSH_PORT_FORWARDING__

    void(*funcPtrPortFwdSessionOpen) (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen, ubyte4 channel);

    sbyte4(*funcPtrPortFwdSessionOpenFail) (sbyte4 connectionInstance, ubyte *pInfo, ubyte4 infoLength, ubyte *pLanguage, ubyte4 languageLength, sbyte4 channel);

    void(*funcPtrPortForwardClosed) (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen, ubyte4 channel);

    void(*funcPtrPortForwardEof) (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen, ubyte4 channel);

    void(*funcPtrPortFwdReceivedData) (sbyte4 connectionInstance, enum sshcSessionTypes sessionEvent, ubyte *pMesg, ubyte4 mesgLen, ubyte4 channel );

    sbyte4(*funcPtrPortForwardConnect) (sbyte4 connectionInstance, enum pfType, sbyte *pHostAddr, ubyte4 hostPort, ubyte *pIgnoreRequest, ubyte4 channel );

    void(*funcPtrRemotePortReqStatus) (sbyte4 status, ubyte4 port );

#endif /* __ENABLE_MOCANA_SSH_PORT_FORWARDING__ */

#ifdef __ENABLE_MOCANA_SSH_AUTH_BANNER__

    sbyte4(* funcPtrDisplayBanner)(sbyte4 connectionInstance, ubyte *pBanner, ubyte4 length, ubyte *pMsgLanguageTag);
#endif

    void(* funcPtrDisconnectMsg)(sbyte4 connectionInstance, ubyte4 reasonCode, ubyte *pMsg, ubyte4 msgLength, ubyte *pMsgLanguageTag);

  MSTATUS (*funcPtrSessionReKey)   (sbyte4 connectionInstance, intBoolean initiatedByRemote);

} sshClientSettings;

/*
 * SSHC_FuncPtrProtocolTest functions should return true iff the doProtocolXXX() loop
 * should exit/unwind.
 */


/*------------------------------------------------------------------*/

struct certStore;

MOC_EXTERN sshClientSettings *SSHC_sshClientSettings(void);

MOC_EXTERN sbyte4 SSHC_init(sbyte4 numClientConnections);

MOC_EXTERN sbyte4 SSHC_shutdown(void);

MOC_EXTERN sbyte4 SSHC_connect(TCP_SOCKET tempSocket, sbyte4 *pConnectionInstance, sbyte *pCommonName, struct certStore *pCertStore);

MOC_EXTERN sbyte4 SSHC_useThisCipher(sbyte4 connectionInstance, ubyte *pCipher);

MOC_EXTERN sbyte4 SSHC_useThisHmac(sbyte4 connectionInstance, ubyte *pHmac);

MOC_EXTERN sbyte4 SSHC_negotiateConnection(sbyte4 connectionInstance);

MOC_EXTERN sbyte4 SSHC_negotiateSession(sbyte4 connectionInstance);

MOC_EXTERN sbyte4 SSHC_negotiateCloseChannel(sbyte4 connectionInstance, sbyte4 channelNumber);

MOC_EXTERN sbyte4 SSHC_negotiateSubsystemSFTPChannelRequest(sbyte4 connectionInstance);

MOC_EXTERN sbyte4 SSHC_negotiateSFTPHello(sbyte4 connectionInstance);

MOC_EXTERN sbyte4 SSHC_negotiatePtyTerminalChannelRequest(sbyte4 connectionInstance);

MOC_EXTERN sbyte4 SSHC_negotiateShellChannelRequest(sbyte4 connectionInstance);

MOC_EXTERN sbyte4 SSHC_sendMessage(sbyte4 connectionInstance, ubyte *pBuffer, ubyte4 bufferSize, ubyte4 *pBytesSent);

MOC_EXTERN sbyte4 SSHC_recvMessage(sbyte4 connectionInstance, sbyte4 *pMessageType, sbyte *pRetMessage, sbyte4 *pNumBytesReceived, ubyte4 timeout);

MOC_EXTERN sbyte4 SSHC_setTerminalTextWindowSize(sbyte4 connectionInstance, ubyte4 width, ubyte4 height);

MOC_EXTERN void SSHC_close(sbyte4 connectionInstance);

MOC_EXTERN sbyte4 SSHC_initiateReKey(sbyte4 connectionInstance, ubyte4 msAllowToComply);

MOC_EXTERN sbyte4 SSHC_numBytesTransmitted(sbyte4 connectionInstance, ubyte8 *pRetNumBytes);

MOC_EXTERN sbyte4 SSHC_getCookie(sbyte4 connectionInstance, void **pRetCookie);

MOC_EXTERN sbyte4 SSHC_setCookie(sbyte4 connectionInstance, void* cookie);

/*------------------------------------------------------------------*/

#ifdef __ENABLE_MOCANA_SSH_PORT_FORWARDING__

MOC_EXTERN sbyte4 SSHC_lpfRegisterConnection( sbyte4 connectionInstance, ubyte4* pChannel);

MOC_EXTERN sbyte4 SSHC_lpfStartConnection( sbyte4 connectionInstance, ubyte4 channel,
                                       ubyte* pConnectHost, ubyte4 connectPort,
                                       ubyte* pSrcHost, ubyte4 srcPort);

MOC_EXTERN sbyte4 SSHC_lpfStopConnection( sbyte4 connectionInstance, ubyte4 channel);

MOC_EXTERN sbyte4 SSHC_lpfSendMessage(sbyte4 connectionInstance, ubyte4 channel, sbyte *pBuffer, sbyte4 bufferSize, sbyte4 *pBytesSent);

MOC_EXTERN sbyte4 SSHC_doProtocolProcessPortForwardSession(sbyte4 connectionInstance, intBoolean useTimeout, ubyte4 timeout);
extern MSTATUS
SSHC_startRemotePortForwarding(sbyte4 connectionInstance, sbyte *pBindAddr, ubyte4 bindPort, sbyte *pHostAddr, ubyte4 hostPort);
extern MSTATUS
SSHC_cancelRemotePortForwarding(sbyte4 connectionInstance, sbyte *pHostAddr, ubyte4 hostPort);
#endif /*__ENABLE_MOCANA_SSH_PORT_FORWARDING__*/
/*------------------------------------------------------------------*/

#ifdef __ENABLE_MOCANA_SSH_FTP_CLIENT__

MOC_EXTERN sbyte4 SSHC_openFile(sbyte4 connectionInstance, ubyte* pFName, ubyte4 pFNameLen, sbyte4 readOrWrite, sftpcFileHandleDescr **pp_retSftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_readFile(sbyte4 connectionInstance, sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_writeFile(sbyte4 connectionInstance, sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_closeFile(sbyte4 connectionInstance, sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_openDirectory(sbyte4 connectionInstance, ubyte *pPath, ubyte4 pathLen, sftpcFileHandleDescr** pp_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_readDirectory(sbyte4 connectionInstance, sftpcFileHandleDescr* p_sftpFileHandleDescr, ubyte **ppRetFilename, ubyte4 *pRetFilenameLen);

MOC_EXTERN sbyte4 SSHC_closeDirectory(sbyte4 connectionInstance, sftpcFileHandleDescr* p_sftpFileHandleDescr);

MOC_EXTERN void   SSHC_sftpGetDirEntryFileSize(sbyte4 connectionInstance, sftpcFileHandleDescr *p_sftpFileHandleDescr, ubyte4 *pRetFileSize, intBoolean *pRetIsPresent);

MOC_EXTERN void   SSHC_sftpGetDirEntryFileType(sbyte4 connectionInstance, sftpcFileHandleDescr *p_sftpFileHandleDescr, ubyte4 *pRetFileType, intBoolean *pRetIsPresent);

MOC_EXTERN void   SSHC_sftpGetDirEntryFilePermission(sbyte4 connectionInstance, sftpcFileHandleDescr *p_sftpFileHandleDescr, ubyte4 *pRetFilePermission, intBoolean *pRetIsPresent);

MOC_EXTERN void   SSHC_sftpSetCookie(sftpcFileHandleDescr *p_sftpFileHandleDescr, void* sftpCookie);

MOC_EXTERN void*  SSHC_sftpGetCookie(sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_sftpRequestStatusCode(sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_freeHandle(sbyte4 connectionInstance, sftpcFileHandleDescr** pp_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_freeFilename(sbyte4 connectionInstance, ubyte **ppFreeFilename);

MOC_EXTERN sbyte4 SSHC_sftpReadLocation(sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte* SSHC_sftpReadBuffer(sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_sftpReadBufferSize(sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_sftpNumBytesRead(sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_sftpWriteLocation(sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte* SSHC_sftpWriteBuffer(sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_sftpWriteBufferSize(sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_sftpNumBytesWritten(sftpcFileHandleDescr *p_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_getFileStat(sbyte4 connectionInstance, ubyte *pGetStatFile, ubyte4 getStatFileLen, sftpcFileHandleDescr** pp_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_realpath(sbyte4 connectionInstance, ubyte *pRealpath, ubyte4 realpathLen, sftpcFileHandleDescr** pp_sftpFileHandleDescr, ubyte **ppRetRealpath, ubyte4 *pRetRealpathLen);

MOC_EXTERN sbyte4 SSHC_removeFile(sbyte4 connectionInstance, ubyte *pRemoveFileName, ubyte4 removeFileNameLen, sftpcFileHandleDescr** pp_sftpFileHandleDescr);

MOC_EXTERN sbyte4 SSHC_mkdir(sbyte4 connectionInstance, ubyte *pNewDirName, ubyte4 newDirNameLen, sftpcFileHandleDescr** pp_sftpFileHandleDescr, void *pFuture);

MOC_EXTERN sbyte4 SSHC_rmdir(sbyte4 connectionInstance, ubyte *pRemoveDirName, ubyte4 removeDirNameLen, sftpcFileHandleDescr** pp_sftpFileHandleDescr);

MOC_EXTERN MSTATUS SSHC_generateServerAuthKeyFile(ubyte *pKeyBlob, ubyte4 keyBlobLen, ubyte **ppRetEncodedAuthKey, ubyte4 *pRetEncodedAuthKeyLen);

MOC_EXTERN MSTATUS SSHC_parseServerAuthKeyFile(ubyte* pKeyFile, ubyte4 keyFileLen,
    AsymmetricKey *pAsymKey);

MOC_EXTERN MSTATUS SSHC_parsePublicKeyBuffer(ubyte* pKeyFile, ubyte4 keyFileLen,
    AsymmetricKey *pAsymKey);

MOC_EXTERN MSTATUS SSHC_freeGenerateServerAuthKeyFile(ubyte **ppFreeEncodedAuthKey);

#endif

#ifdef __cplusplus
}
#endif

#endif /* __SSHC_HEADER__ */