| #ifndef _PRAGMA_COPYRIGHT_ |
| #define _PRAGMA_COPYRIGHT_ |
| #pragma comment(copyright, "%Z% %I% %W% %D% %T%\0") |
| #endif /* _PRAGMA_COPYRIGHT_ */ |
| /**************************************************************************** |
| |
| * Copyright (c) 2008, 2010 IBM Corporation. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0s |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| |
| Classes: SshFunc |
| |
| Description: ssh functions |
| |
| Author: Tu HongJ |
| |
| History: |
| Date Who ID Description |
| -------- --- --- ----------- |
| 10/06/08 tuhongj Initial code (D16661) |
| 11/26/10 ronglli Modified the ssh functions |
| |
| ****************************************************************************/ |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| #include <dlfcn.h> |
| #include <assert.h> |
| #include <string.h> |
| #include <stdio.h> |
| #include <stdarg.h> |
| #include <arpa/inet.h> |
| |
| #include "sshfunc.hpp" |
| #include "tools.hpp" |
| #include "log.hpp" |
| |
| SshFunc *SshFunc::instance = NULL; |
| |
| SshFunc * SshFunc::getInstance() |
| { |
| if (instance == NULL) { |
| instance = new SshFunc(); |
| int rc = instance->load(); |
| if (rc != 0) { |
| return NULL; |
| } |
| } |
| return instance; |
| } |
| |
| SshFunc::SshFunc() |
| : sshAuth(false), dlopen_file(NULL), mdlhndl(0), set_auth_module_hndlr(NULL), get_id_token_hndlr(NULL), verify_id_token_hndlr(NULL), get_id_from_token_hndlr(NULL), free_id_token_hndlr(NULL), get_key_from_token_hndlr(NULL), sign_data_hndlr(NULL), verify_data_hndlr(NULL), free_signature_hndlr(NULL) |
| { |
| string out_val = ""; |
| char * envp = NULL; |
| int rc; |
| |
| user_token.iov_base = NULL; |
| user_token.iov_len = 0; |
| |
| rc = SysUtil::read_config("SCI_ENABLE_SSHAUTH", out_val); |
| if(rc == 0) { |
| if (out_val == "yes") { |
| sshAuth = true; |
| } else if (out_val == "no") { |
| sshAuth = false; |
| } else { |
| log_warn("Wrong value of \"SCI_ENABLE_SSHAUTH\": %s\n", out_val.c_str()); |
| } |
| } |
| |
| envp = ::getenv("SCI_ENABLE_SSHAUTH"); |
| if(envp != NULL) { |
| if (strcasecmp(envp, "yes") == 0) { |
| sshAuth = true; |
| } else if (strcasecmp(envp, "no") == 0) { |
| sshAuth = false; |
| } |
| } |
| } |
| |
| SshFunc::~SshFunc() |
| { |
| if (dlopen_file) { |
| ::dlclose(dlopen_file); |
| } |
| free_id_token(&user_token); |
| } |
| |
| #ifdef PSEC_OPEN_SSL |
| int SshFunc::load(char * libPath) |
| { |
| int rc = -1; |
| string path = ""; |
| string auth_mod = ""; |
| |
| if (!sshAuth) |
| return 0; |
| |
| if (libPath) { |
| path = libPath; |
| } else { |
| #if defined(_SCI_LINUX) || defined(__APPLE__) |
| #ifdef __64BIT__ // 64-bit |
| #ifdef INSTALL_PATH |
| path = string(INSTALL_PATH) + "/lib/sci64/libpsec.so"; // default library name on Linux |
| auth_mod = string(INSTALL_PATH) + "/lib/sci64/libpsec_ossh.so"; |
| #else |
| path = "libpsec.so"; // default library name on Linux |
| auth_mod = "/usr/lib64/libpsec_ossh.so"; |
| #endif |
| #else // 32-bit |
| #ifdef INSTALL_PATH |
| path = string(INSTALL_PATH) + "/lib/sci32/libpsec.so"; // default library name on Linux |
| auth_mod = string(INSTALL_PATH) + "/lib/sci32/libpsec_ossh.so"; |
| #else |
| path = "libpsec.so"; // default library name on Linux |
| auth_mod = "/usr/lib/libpsec_ossh.so"; |
| #endif |
| #endif |
| #else //AIX |
| #ifdef __64BIT__ |
| #ifdef INSTALL_PATH |
| path = string(INSTALL_PATH) + "/lib/libpsec.a(shr_64.o)"; |
| auth_mod = string(INSTALL_PATH) + "/lib/libpsec_ossh64.so"; |
| #else |
| path = "libpsec.a(shr_64.o)"; |
| auth_mod = "/usr/lib/libpsec_ossh64.so"; |
| #endif |
| #else // 32-bit |
| #ifdef INSTALL_PATH |
| path = string(INSTALL_PATH) + "/lib/libpsec.a(shr.o)"; |
| auth_mod = string(INSTALL_PATH) + "/lib/libpsec_ossh.so"; |
| #else |
| path = "libpsec.a(shr.o)"; |
| auth_mod = "/usr/lib/libpsec_ossh.so"; |
| #endif |
| #endif |
| #endif |
| } |
| |
| #if defined(_SCI_LINUX) |
| dlopen_file = ::dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL); |
| #elif defined(__APPLE__) |
| dlopen_file = ::dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL); |
| #else // aix |
| dlopen_file = ::dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL | RTLD_MEMBER); |
| #endif |
| if (NULL == dlopen_file) { |
| return -1; |
| } |
| |
| set_auth_module_hndlr = (psec_set_auth_module_hndlr *) ::dlsym(dlopen_file, "psec_set_auth_module"); |
| if (NULL == set_auth_module_hndlr) { |
| return -1; |
| } |
| get_id_token_hndlr = (psec_get_id_token_hndlr *) ::dlsym(dlopen_file, "psec_get_id_token"); |
| if (NULL == get_id_token_hndlr) { |
| return -1; |
| } |
| verify_id_token_hndlr = (psec_verify_id_token_hndlr *) ::dlsym(dlopen_file, "psec_verify_id_token"); |
| if (NULL == verify_id_token_hndlr) { |
| return -1; |
| } |
| get_id_from_token_hndlr = (psec_get_id_from_token_hndlr *) ::dlsym(dlopen_file, "psec_get_id_from_token"); |
| if (NULL == get_id_from_token_hndlr) { |
| return -1; |
| } |
| free_id_token_hndlr = (psec_free_id_token_hndlr *) ::dlsym(dlopen_file, "psec_free_id_token"); |
| if (NULL == free_id_token_hndlr) { |
| return -1; |
| } |
| |
| get_key_from_token_hndlr = (psec_get_key_from_token_hndlr *) ::dlsym(dlopen_file, "psec_get_key_from_token"); |
| if (NULL == get_key_from_token_hndlr) { |
| return -1; |
| } |
| |
| sign_data_hndlr = (psec_sign_data_hndlr *) ::dlsym(dlopen_file, "psec_sign_data"); |
| if(NULL == sign_data_hndlr) { |
| return -1; |
| } |
| |
| verify_data_hndlr = (psec_verify_data_hndlr *) ::dlsym(dlopen_file, "psec_verify_data"); |
| if(NULL == verify_data_hndlr) { |
| return -1; |
| } |
| |
| free_signature_hndlr = (psec_free_signature_hndlr *) ::dlsym(dlopen_file, "psec_free_signature"); |
| if(NULL == free_signature_hndlr) { |
| return -1; |
| } |
| |
| rc = set_auth_module(NULL, (char *)auth_mod.c_str(), "m[t=-1]"); |
| if (rc == 0) { |
| get_id_token(NULL, NULL, &user_token); |
| key_len = sizeof(session_key); |
| get_key_from_token(NULL, &user_token, session_key, &key_len); |
| } |
| |
| return rc; |
| } |
| |
| int SshFunc::set_auth_module(char *name, char *fpath, char *opts) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| return set_auth_module_hndlr(name, fpath, opts, &mdlhndl); |
| } |
| |
| int SshFunc::get_id_token(char *tname, char *thost, psec_idbuf_t idtok) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| return get_id_token_hndlr(mdlhndl, tname, thost, idtok); |
| } |
| |
| int SshFunc::verify_id_token(char *uname, psec_idbuf_t idtok) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| return verify_id_token_hndlr(mdlhndl, uname, idtok); |
| } |
| |
| int SshFunc::get_id_from_token(psec_idbuf_t idtok, char *usrid, size_t *usridlen) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| return get_id_from_token_hndlr(mdlhndl, idtok, usrid, usridlen); |
| } |
| |
| int SshFunc::free_id_token(psec_idbuf_t id) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| return free_id_token_hndlr(mdlhndl, id); |
| } |
| |
| int SshFunc::get_key_from_token(char *uname, psec_idbuf_t idtok , char *key, size_t *keylen) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| return get_key_from_token_hndlr(mdlhndl, uname, idtok, key, keylen); |
| } |
| |
| int SshFunc::sign_data(char *key, size_t keylen, struct iovec *inbufs, int num_bufs, struct iovec *sigbufs) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| return sign_data_hndlr(mdlhndl, key, keylen, inbufs, num_bufs, sigbufs); |
| } |
| |
| int SshFunc::verify_data(char *key, size_t keylen, struct iovec *inbufs, int num_bufs, struct iovec *sigbufs) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| return verify_data_hndlr(mdlhndl, key, keylen, inbufs, num_bufs, sigbufs); |
| } |
| |
| int SshFunc::sign_data(struct iovec *inbufs, int num_bufs, struct iovec *sigbufs) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| return sign_data_hndlr(mdlhndl, session_key, key_len, inbufs, num_bufs, sigbufs); |
| } |
| |
| int SshFunc::verify_data(struct iovec *inbufs, int num_bufs, struct iovec *sigbufs) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| return verify_data_hndlr(mdlhndl, session_key, key_len, inbufs, num_bufs, sigbufs); |
| } |
| |
| int SshFunc::free_signature(struct iovec *sigbufs) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| return free_signature_hndlr(mdlhndl, sigbufs); |
| } |
| |
| int SshFunc::sign_data(char *key, size_t keylen, char *bufs[], int sizes[], int num_bufs, struct iovec *sigbufs) |
| { |
| int i, rc; |
| struct iovec *tmp_bufs; |
| |
| if (!sshAuth) |
| return 0; |
| |
| tmp_bufs = new struct iovec[num_bufs]; |
| for (i = 0; i < num_bufs; i++) { |
| tmp_bufs[i].iov_base = bufs[i]; |
| tmp_bufs[i].iov_len = sizes[i]; |
| } |
| rc = sign_data(key, keylen, tmp_bufs, num_bufs, sigbufs); |
| delete []tmp_bufs; |
| |
| return rc; |
| } |
| |
| int SshFunc::verify_data(char *key, size_t keylen, char *bufs[], int sizes[], int num_bufs, struct iovec *sigbufs) |
| { |
| int i, rc; |
| struct iovec *tmp_bufs; |
| |
| if (!sshAuth) |
| return 0; |
| |
| tmp_bufs = new struct iovec[num_bufs]; |
| for (i = 0; i < num_bufs; i++) { |
| tmp_bufs[i].iov_base = bufs[i]; |
| tmp_bufs[i].iov_len = sizes[i]; |
| } |
| rc = verify_data(key, keylen, tmp_bufs, num_bufs, sigbufs); |
| delete []tmp_bufs; |
| |
| return rc; |
| } |
| |
| int SshFunc::sign_data(char *bufs[], int sizes[], int num_bufs, struct iovec *sigbufs) |
| { |
| int i, rc; |
| struct iovec *tmp_bufs; |
| |
| if (!sshAuth) |
| return 0; |
| |
| tmp_bufs = new struct iovec[num_bufs]; |
| for (i = 0; i < num_bufs; i++) { |
| tmp_bufs[i].iov_base = bufs[i]; |
| tmp_bufs[i].iov_len = sizes[i]; |
| } |
| rc = sign_data(session_key, key_len, tmp_bufs, num_bufs, sigbufs); |
| delete []tmp_bufs; |
| |
| return rc; |
| } |
| |
| int SshFunc::verify_data(char *bufs[], int sizes[], int num_bufs, struct iovec *sigbufs) |
| { |
| int i, rc; |
| struct iovec *tmp_bufs; |
| |
| if (!sshAuth) |
| return 0; |
| |
| tmp_bufs = new struct iovec[num_bufs]; |
| for (i = 0; i < num_bufs; i++) { |
| tmp_bufs[i].iov_base = bufs[i]; |
| tmp_bufs[i].iov_len = sizes[i]; |
| } |
| rc = verify_data(session_key, key_len, tmp_bufs, num_bufs, sigbufs); |
| delete []tmp_bufs; |
| |
| return rc; |
| } |
| |
| int SshFunc::sign_data(char *key, size_t klen, struct iovec *sigbufs, char *fmt, ...) |
| { |
| int i, rc; |
| va_list argp; |
| char *para, *p, *pos; |
| size_t para_len; |
| int num_bufs = get_sizes(fmt); |
| struct iovec *tmp_bufs; |
| int *d_nums; |
| char *skey = key; |
| size_t sklen = klen; |
| |
| if (!sshAuth) |
| return 0; |
| |
| tmp_bufs = new struct iovec[num_bufs]; |
| d_nums = new int[num_bufs]; |
| if (key == NULL) { |
| skey = session_key; |
| sklen = key_len; |
| } |
| |
| va_start(argp, fmt); |
| pos = p = fmt; |
| i = -1; |
| while (*p != '\0') { |
| switch (*p) { |
| case 'd': |
| d_nums[i] = va_arg(argp, int); |
| d_nums[i] = htonl(d_nums[i]); |
| tmp_bufs[i].iov_len = sizeof(int); |
| tmp_bufs[i].iov_base = &d_nums[i]; |
| break; |
| case 's': |
| tmp_bufs[i].iov_base = va_arg(argp, char *); |
| if (*pos != 's') { |
| tmp_bufs[i].iov_len = atoi((const char *)pos); |
| } else { |
| tmp_bufs[i].iov_len = strlen((char *)tmp_bufs[i].iov_base) + 1; |
| } |
| break; |
| case '%': |
| pos = p + 1; |
| i++; |
| break; |
| } |
| p++; |
| } |
| va_end(argp); |
| |
| rc = sign_data(skey, key_len, tmp_bufs, num_bufs, sigbufs); |
| delete []d_nums; |
| delete []tmp_bufs; |
| |
| return rc; |
| } |
| |
| int SshFunc::get_sizes(char *fmt) |
| { |
| int num_bufs = 0; |
| char *p = fmt; |
| |
| if (!sshAuth) |
| return 0; |
| |
| while (*p != '\0') { |
| if (*p == '%') { |
| num_bufs++; |
| } |
| p++; |
| } |
| |
| return num_bufs; |
| } |
| |
| int SshFunc::verify_data(char *key, size_t klen, struct iovec *sigbufs, char *fmt, ...) |
| { |
| int i, rc; |
| va_list argp; |
| char *para, *p, *pos; |
| size_t para_len; |
| int num_bufs = get_sizes(fmt); |
| struct iovec *tmp_bufs; |
| int *d_nums; |
| char *skey = key; |
| size_t sklen = klen; |
| |
| if (!sshAuth) |
| return 0; |
| |
| tmp_bufs = new struct iovec[num_bufs]; |
| d_nums = new int[num_bufs]; |
| if (key == NULL) { |
| skey = session_key; |
| sklen = key_len; |
| } |
| va_start(argp, fmt); |
| pos = p = fmt; |
| i = -1; |
| while (*p != '\0') { |
| switch (*p) { |
| case 'd': |
| d_nums[i] = va_arg(argp, int); |
| d_nums[i] = ntohl(d_nums[i]); |
| tmp_bufs[i].iov_len = sizeof(int); |
| tmp_bufs[i].iov_base = &d_nums[i]; |
| break; |
| case 's': |
| tmp_bufs[i].iov_base = va_arg(argp, char *); |
| if (*pos != 's') { |
| tmp_bufs[i].iov_len = atoi((const char *)pos); |
| } else { |
| tmp_bufs[i].iov_len = strlen((char *)tmp_bufs[i].iov_base) + 1; |
| } |
| break; |
| case '%': |
| pos = p + 1; |
| i++; |
| break; |
| } |
| p++; |
| } |
| va_end(argp); |
| |
| rc = verify_data(skey, sklen, tmp_bufs, num_bufs, sigbufs); |
| delete []d_nums; |
| delete []tmp_bufs; |
| |
| return rc; |
| } |
| |
| int SshFunc::sign_data(struct iovec *sigbufs, int num_bufs, ...) |
| { |
| int i, rc; |
| va_list argp; |
| char *para; |
| size_t para_len; |
| struct iovec *tmp_bufs; |
| |
| if (!sshAuth) |
| return 0; |
| |
| tmp_bufs = new struct iovec[num_bufs]; |
| va_start(argp, num_bufs); |
| for (i = 0; i < num_bufs; i++) { |
| para = va_arg(argp, char *); |
| para_len = va_arg(argp, int); |
| tmp_bufs[i].iov_base = para; |
| tmp_bufs[i].iov_len = para_len; |
| } |
| va_end(argp); |
| rc = sign_data(session_key, key_len, tmp_bufs, num_bufs, sigbufs); |
| delete []tmp_bufs; |
| |
| return rc; |
| } |
| |
| int SshFunc::verify_data(struct iovec *sigbufs, int num_bufs, ...) |
| { |
| int i, rc; |
| va_list argp; |
| char *para; |
| size_t para_len; |
| struct iovec *tmp_bufs; |
| |
| if (!sshAuth) |
| return 0; |
| |
| tmp_bufs = new struct iovec[num_bufs]; |
| va_start(argp, num_bufs); |
| for (i = 0; i < num_bufs; i++) { |
| para = va_arg(argp, char *); |
| para_len = va_arg(argp, int); |
| tmp_bufs[i].iov_base = para; |
| tmp_bufs[i].iov_len = para_len; |
| } |
| va_end(argp); |
| rc = verify_data(session_key, key_len, tmp_bufs, num_bufs, sigbufs); |
| delete []tmp_bufs; |
| |
| return rc; |
| } |
| |
| int SshFunc::sign_data(char *key, size_t keylen, struct iovec *sigbufs, int num_bufs, ...) |
| { |
| int i, rc; |
| va_list argp; |
| char *para; |
| size_t para_len; |
| struct iovec *tmp_bufs; |
| |
| if (!sshAuth) |
| return 0; |
| |
| tmp_bufs = new struct iovec[num_bufs]; |
| va_start(argp, num_bufs); |
| for (i = 0; i < num_bufs; i++) { |
| para = va_arg(argp, char *); |
| para_len = va_arg(argp, int); |
| tmp_bufs[i].iov_base = para; |
| tmp_bufs[i].iov_len = para_len; |
| } |
| va_end(argp); |
| rc = sign_data(key, keylen, tmp_bufs, num_bufs, sigbufs); |
| delete []tmp_bufs; |
| |
| return rc; |
| } |
| |
| int SshFunc::verify_data(char *key, size_t keylen, struct iovec *sigbufs, int num_bufs, ...) |
| { |
| int i, rc; |
| va_list argp; |
| char *para; |
| size_t para_len; |
| struct iovec *tmp_bufs; |
| |
| if (!sshAuth) |
| return 0; |
| |
| tmp_bufs = new struct iovec[num_bufs]; |
| va_start(argp, num_bufs); |
| for (i = 0; i < num_bufs; i++) { |
| para = va_arg(argp, char *); |
| para_len = va_arg(argp, int); |
| tmp_bufs[i].iov_base = para; |
| tmp_bufs[i].iov_len = para_len; |
| } |
| va_end(argp); |
| rc = verify_data(key, keylen, tmp_bufs, num_bufs, sigbufs); |
| delete []tmp_bufs; |
| |
| return rc; |
| } |
| |
| int SshFunc::set_user_token(struct iovec *token) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| free_id_token(&user_token); |
| user_token.iov_len = token->iov_len; |
| user_token.iov_base = new char [token->iov_len]; |
| memcpy(user_token.iov_base, token->iov_base, token->iov_len); |
| get_key_from_token(NULL, &user_token, session_key, &key_len); |
| |
| return 0; |
| } |
| |
| int SshFunc::set_session_key(struct iovec *sskey) |
| { |
| if (!sshAuth) |
| return 0; |
| |
| key_len = sskey->iov_len; |
| memcpy(session_key, sskey->iov_base, key_len); |
| |
| return 0; |
| } |
| #else |
| int SshFunc::load(char *libPath) |
| { |
| return 0; |
| } |
| |
| int SshFunc::get_id_token(char *tname, char *thost, psec_idbuf_t idtok) |
| { |
| return 0; |
| } |
| |
| int SshFunc::verify_id_token(char *uname, psec_idbuf_t idtok) |
| { |
| return 0; |
| } |
| |
| int SshFunc::get_id_from_token(psec_idbuf_t idtok, char *usrid, size_t *usridlen) |
| { |
| return 0; |
| } |
| |
| int SshFunc::free_id_token(psec_idbuf_t id) |
| { |
| return 0; |
| } |
| |
| int SshFunc::get_key_from_token(char *uname, psec_idbuf_t idtok , char *key, size_t *keylen) |
| { |
| return 0; |
| } |
| |
| int SshFunc::sign_data(char *key, size_t keylen, struct iovec *inbufs, int num_bufs, struct iovec *sigbufs) |
| { |
| return 0; |
| } |
| |
| int SshFunc::verify_data(char *key, size_t keylen, struct iovec *inbufs, int num_bufs, struct iovec *sigbufs) |
| { |
| return 0; |
| } |
| |
| int SshFunc::free_signature(struct iovec *sigbufs) |
| { |
| return 0; |
| } |
| |
| int SshFunc::sign_data(char *key, size_t keylen, char *bufs[], int sizes[], int num_bufs, struct iovec *sigbufs) |
| { |
| return 0; |
| } |
| |
| int SshFunc::verify_data(char *key, size_t keylen, char *bufs[], int sizes[], int num_bufs, struct iovec *sigbufs) |
| { |
| return 0; |
| } |
| |
| int SshFunc::set_session_key(struct iovec *sskey) |
| { |
| return 0; |
| } |
| |
| int SshFunc::set_user_token(struct iovec *token) |
| { |
| return 0; |
| } |
| |
| int SshFunc::sign_data(struct iovec *inbufs, int num_bufs, struct iovec *sigbufs) |
| { |
| return 0; |
| } |
| |
| int SshFunc::verify_data(struct iovec *inbufs, int num_bufs, struct iovec *sigbufs) |
| { |
| return 0; |
| } |
| |
| int SshFunc::sign_data(char *bufs[], int sizes[], int num_bufs, struct iovec *sigbufs) |
| { |
| return 0; |
| } |
| |
| int SshFunc::verify_data(char *bufs[], int sizes[], int num_bufs, struct iovec *sigbufs) |
| { |
| return 0; |
| } |
| |
| int SshFunc::sign_data(struct iovec *sigbufs, int num_bufs, ...) |
| { |
| return 0; |
| } |
| |
| int SshFunc::verify_data(struct iovec *sigbufs, int num_bufs, ...) |
| { |
| return 0; |
| } |
| |
| int SshFunc::sign_data(char *key, size_t keylen, struct iovec *sigbufs, int num_bufs, ...) |
| { |
| return 0; |
| } |
| |
| int SshFunc::verify_data(char *key, size_t keylen, struct iovec *sigbufs, int num_bufs, ...) |
| { |
| return 0; |
| } |
| |
| int SshFunc::sign_data(char *key, size_t klen, struct iovec *sigbufs, char *fmt, ...) |
| { |
| return 0; |
| } |
| |
| int SshFunc::verify_data(char *key, size_t klen, struct iovec *sigbufs, char *fmt, ...) |
| { |
| return 0; |
| } |
| |
| #endif |