622 строки
20 KiB
C
622 строки
20 KiB
C
/***************************************************************************
|
|
* _ _ ____ _
|
|
* Project ___| | | | _ \| |
|
|
* / __| | | | |_) | |
|
|
* | (__| |_| | _ <| |___
|
|
* \___|\___/|_| \_\_____|
|
|
*
|
|
* Copyright (C) 2012 - 2014, Daniel Stenberg, <daniel@haxx.se>, et al.
|
|
*
|
|
* This software is licensed as described in the file COPYING, which
|
|
* you should have received as part of this distribution. The terms
|
|
* are also available at http://curl.haxx.se/docs/copyright.html.
|
|
*
|
|
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
|
* copies of the Software, and permit persons to whom the Software is
|
|
* furnished to do so, under the terms of the COPYING file.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
* RFC2195 CRAM-MD5 authentication
|
|
* RFC2831 DIGEST-MD5 authentication
|
|
* RFC4422 Simple Authentication and Security Layer (SASL)
|
|
* RFC4616 PLAIN authentication
|
|
* RFC6749 OAuth 2.0 Authorization Framework
|
|
* Draft LOGIN SASL Mechanism <draft-murchison-sasl-login-00.txt>
|
|
*
|
|
***************************************************************************/
|
|
|
|
#include "curl_setup.h"
|
|
|
|
#include <curl/curl.h>
|
|
#include "urldata.h"
|
|
|
|
#include "curl_base64.h"
|
|
#include "curl_md5.h"
|
|
#include "vtls/vtls.h"
|
|
#include "curl_hmac.h"
|
|
#include "curl_ntlm_msgs.h"
|
|
#include "curl_sasl.h"
|
|
#include "warnless.h"
|
|
#include "curl_memory.h"
|
|
|
|
#ifdef USE_NSS
|
|
#include "vtls/nssg.h" /* for Curl_nss_force_init() */
|
|
#endif
|
|
|
|
#define _MPRINTF_REPLACE /* use our functions only */
|
|
#include <curl/mprintf.h>
|
|
|
|
/* The last #include file should be: */
|
|
#include "memdebug.h"
|
|
|
|
#ifndef CURL_DISABLE_CRYPTO_AUTH
|
|
/* Retrieves the value for a corresponding key from the challenge string
|
|
* returns TRUE if the key could be found, FALSE if it does not exists
|
|
*/
|
|
static bool sasl_digest_get_key_value(const char *chlg,
|
|
const char *key,
|
|
char *value,
|
|
size_t max_val_len,
|
|
char end_char)
|
|
{
|
|
char *find_pos;
|
|
size_t i;
|
|
|
|
find_pos = strstr(chlg, key);
|
|
if(!find_pos)
|
|
return FALSE;
|
|
|
|
find_pos += strlen(key);
|
|
|
|
for(i = 0; *find_pos && *find_pos != end_char && i < max_val_len - 1; ++i)
|
|
value[i] = *find_pos++;
|
|
value[i] = '\0';
|
|
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Curl_sasl_create_plain_message()
|
|
*
|
|
* This is used to generate an already encoded PLAIN message ready
|
|
* for sending to the recipient.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* data [in] - The session handle.
|
|
* userp [in] - The user name.
|
|
* passdwp [in] - The user's password.
|
|
* outptr [in/out] - The address where a pointer to newly allocated memory
|
|
* holding the result will be stored upon completion.
|
|
* outlen [out] - The length of the output message.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_sasl_create_plain_message(struct SessionHandle *data,
|
|
const char *userp,
|
|
const char *passwdp,
|
|
char **outptr, size_t *outlen)
|
|
{
|
|
CURLcode result;
|
|
char *plainauth;
|
|
size_t ulen;
|
|
size_t plen;
|
|
|
|
ulen = strlen(userp);
|
|
plen = strlen(passwdp);
|
|
|
|
plainauth = malloc(2 * ulen + plen + 2);
|
|
if(!plainauth) {
|
|
*outlen = 0;
|
|
*outptr = NULL;
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
|
|
/* Calculate the reply */
|
|
memcpy(plainauth, userp, ulen);
|
|
plainauth[ulen] = '\0';
|
|
memcpy(plainauth + ulen + 1, userp, ulen);
|
|
plainauth[2 * ulen + 1] = '\0';
|
|
memcpy(plainauth + 2 * ulen + 2, passwdp, plen);
|
|
|
|
/* Base64 encode the reply */
|
|
result = Curl_base64_encode(data, plainauth, 2 * ulen + plen + 2, outptr,
|
|
outlen);
|
|
Curl_safefree(plainauth);
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Curl_sasl_create_login_message()
|
|
*
|
|
* This is used to generate an already encoded LOGIN message containing the
|
|
* user name or password ready for sending to the recipient.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* data [in] - The session handle.
|
|
* valuep [in] - The user name or user's password.
|
|
* outptr [in/out] - The address where a pointer to newly allocated memory
|
|
* holding the result will be stored upon completion.
|
|
* outlen [out] - The length of the output message.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_sasl_create_login_message(struct SessionHandle *data,
|
|
const char *valuep, char **outptr,
|
|
size_t *outlen)
|
|
{
|
|
size_t vlen = strlen(valuep);
|
|
|
|
if(!vlen) {
|
|
/* Calculate an empty reply */
|
|
*outptr = strdup("=");
|
|
if(*outptr) {
|
|
*outlen = (size_t) 1;
|
|
return CURLE_OK;
|
|
}
|
|
|
|
*outlen = 0;
|
|
return CURLE_OUT_OF_MEMORY;
|
|
}
|
|
|
|
/* Base64 encode the value */
|
|
return Curl_base64_encode(data, valuep, vlen, outptr, outlen);
|
|
}
|
|
|
|
#ifndef CURL_DISABLE_CRYPTO_AUTH
|
|
/*
|
|
* Curl_sasl_decode_cram_md5_message()
|
|
*
|
|
* This is used to decode an already encoded CRAM-MD5 challenge message.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* chlg64 [in] - Pointer to the base64 encoded challenge message.
|
|
* outptr [in/out] - The address where a pointer to newly allocated memory
|
|
* holding the result will be stored upon completion.
|
|
* outlen [out] - The length of the output message.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_sasl_decode_cram_md5_message(const char *chlg64, char **outptr,
|
|
size_t *outlen)
|
|
{
|
|
CURLcode result = CURLE_OK;
|
|
size_t chlg64len = strlen(chlg64);
|
|
|
|
*outptr = NULL;
|
|
*outlen = 0;
|
|
|
|
/* Decode the challenge if necessary */
|
|
if(chlg64len && *chlg64 != '=')
|
|
result = Curl_base64_decode(chlg64, (unsigned char **) outptr, outlen);
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Curl_sasl_create_cram_md5_message()
|
|
*
|
|
* This is used to generate an already encoded CRAM-MD5 response message ready
|
|
* for sending to the recipient.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* data [in] - The session handle.
|
|
* chlg [in] - The challenge.
|
|
* userp [in] - The user name.
|
|
* passdwp [in] - The user's password.
|
|
* outptr [in/out] - The address where a pointer to newly allocated memory
|
|
* holding the result will be stored upon completion.
|
|
* outlen [out] - The length of the output message.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_sasl_create_cram_md5_message(struct SessionHandle *data,
|
|
const char *chlg,
|
|
const char *userp,
|
|
const char *passwdp,
|
|
char **outptr, size_t *outlen)
|
|
{
|
|
CURLcode result = CURLE_OK;
|
|
size_t chlglen = 0;
|
|
HMAC_context *ctxt;
|
|
unsigned char digest[MD5_DIGEST_LEN];
|
|
char *response;
|
|
|
|
if(chlg)
|
|
chlglen = strlen(chlg);
|
|
|
|
/* Compute the digest using the password as the key */
|
|
ctxt = Curl_HMAC_init(Curl_HMAC_MD5,
|
|
(const unsigned char *) passwdp,
|
|
curlx_uztoui(strlen(passwdp)));
|
|
if(!ctxt)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
/* Update the digest with the given challenge */
|
|
if(chlglen > 0)
|
|
Curl_HMAC_update(ctxt, (const unsigned char *) chlg,
|
|
curlx_uztoui(chlglen));
|
|
|
|
/* Finalise the digest */
|
|
Curl_HMAC_final(ctxt, digest);
|
|
|
|
/* Generate the response */
|
|
response = aprintf(
|
|
"%s %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
|
|
userp, digest[0], digest[1], digest[2], digest[3], digest[4],
|
|
digest[5], digest[6], digest[7], digest[8], digest[9], digest[10],
|
|
digest[11], digest[12], digest[13], digest[14], digest[15]);
|
|
if(!response)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
/* Base64 encode the response */
|
|
result = Curl_base64_encode(data, response, 0, outptr, outlen);
|
|
|
|
Curl_safefree(response);
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Curl_sasl_decode_digest_md5_message()
|
|
*
|
|
* This is used to decode an already encoded DIGEST-MD5 challenge message.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* chlg64 [in] - Pointer to the base64 encoded challenge message.
|
|
* nonce [in/out] - The buffer where the nonce will be stored.
|
|
* nlen [in] - The length of the nonce buffer.
|
|
* realm [in/out] - The buffer where the realm will be stored.
|
|
* rlen [in] - The length of the realm buffer.
|
|
* alg [in/out] - The buffer where the algorithm will be stored.
|
|
* alen [in] - The length of the algorithm buffer.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_sasl_decode_digest_md5_message(const char *chlg64,
|
|
char *nonce, size_t nlen,
|
|
char *realm, size_t rlen,
|
|
char *alg, size_t alen)
|
|
{
|
|
CURLcode result = CURLE_OK;
|
|
unsigned char *chlg = NULL;
|
|
size_t chlglen = 0;
|
|
size_t chlg64len = strlen(chlg64);
|
|
|
|
if(chlg64len && *chlg64 != '=') {
|
|
result = Curl_base64_decode(chlg64, &chlg, &chlglen);
|
|
if(result)
|
|
return result;
|
|
}
|
|
|
|
/* Ensure we have a valid challenge message */
|
|
if(!chlg)
|
|
return CURLE_BAD_CONTENT_ENCODING;
|
|
|
|
/* Retrieve nonce string from the challenge */
|
|
if(!sasl_digest_get_key_value((char *)chlg, "nonce=\"", nonce, nlen, '\"')) {
|
|
Curl_safefree(chlg);
|
|
return CURLE_BAD_CONTENT_ENCODING;
|
|
}
|
|
|
|
/* Retrieve realm string from the challenge */
|
|
if(!sasl_digest_get_key_value((char *)chlg, "realm=\"", realm, rlen, '\"')) {
|
|
/* Challenge does not have a realm, set empty string [RFC2831] page 6 */
|
|
strcpy(realm, "");
|
|
}
|
|
|
|
/* Retrieve algorithm string from the challenge */
|
|
if(!sasl_digest_get_key_value((char *)chlg, "algorithm=", alg, alen, ',')) {
|
|
Curl_safefree(chlg);
|
|
return CURLE_BAD_CONTENT_ENCODING;
|
|
}
|
|
|
|
Curl_safefree(chlg);
|
|
|
|
return CURLE_OK;
|
|
}
|
|
|
|
/*
|
|
* Curl_sasl_create_digest_md5_message()
|
|
*
|
|
* This is used to generate an already encoded DIGEST-MD5 response message
|
|
* ready for sending to the recipient.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* data [in] - The session handle.
|
|
* nonce [in] - The nonce.
|
|
* realm [in] - The realm.
|
|
* userp [in] - The user name.
|
|
* passdwp [in] - The user's password.
|
|
* service [in] - The service type such as www, smtp, pop or imap.
|
|
* outptr [in/out] - The address where a pointer to newly allocated memory
|
|
* holding the result will be stored upon completion.
|
|
* outlen [out] - The length of the output message.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_sasl_create_digest_md5_message(struct SessionHandle *data,
|
|
const char *nonce,
|
|
const char *realm,
|
|
const char *userp,
|
|
const char *passwdp,
|
|
const char *service,
|
|
char **outptr, size_t *outlen)
|
|
{
|
|
#ifndef DEBUGBUILD
|
|
static const char table16[] = "0123456789abcdef";
|
|
#endif
|
|
CURLcode result = CURLE_OK;
|
|
size_t i;
|
|
MD5_context *ctxt;
|
|
char *response = NULL;
|
|
unsigned char digest[MD5_DIGEST_LEN];
|
|
char HA1_hex[2 * MD5_DIGEST_LEN + 1];
|
|
char HA2_hex[2 * MD5_DIGEST_LEN + 1];
|
|
char resp_hash_hex[2 * MD5_DIGEST_LEN + 1];
|
|
|
|
char nonceCount[] = "00000001";
|
|
char cnonce[] = "12345678"; /* will be changed */
|
|
char method[] = "AUTHENTICATE";
|
|
char qop[] = "auth";
|
|
char uri[128];
|
|
|
|
#ifndef DEBUGBUILD
|
|
/* Generate 64 bits of random data */
|
|
for(i = 0; i < 8; i++)
|
|
cnonce[i] = table16[Curl_rand(data)%16];
|
|
#endif
|
|
|
|
/* So far so good, now calculate A1 and H(A1) according to RFC 2831 */
|
|
ctxt = Curl_MD5_init(Curl_DIGEST_MD5);
|
|
if(!ctxt)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
Curl_MD5_update(ctxt, (const unsigned char *) userp,
|
|
curlx_uztoui(strlen(userp)));
|
|
Curl_MD5_update(ctxt, (const unsigned char *) ":", 1);
|
|
Curl_MD5_update(ctxt, (const unsigned char *) realm,
|
|
curlx_uztoui(strlen(realm)));
|
|
Curl_MD5_update(ctxt, (const unsigned char *) ":", 1);
|
|
Curl_MD5_update(ctxt, (const unsigned char *) passwdp,
|
|
curlx_uztoui(strlen(passwdp)));
|
|
Curl_MD5_final(ctxt, digest);
|
|
|
|
ctxt = Curl_MD5_init(Curl_DIGEST_MD5);
|
|
if(!ctxt)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
Curl_MD5_update(ctxt, (const unsigned char *) digest, MD5_DIGEST_LEN);
|
|
Curl_MD5_update(ctxt, (const unsigned char *) ":", 1);
|
|
Curl_MD5_update(ctxt, (const unsigned char *) nonce,
|
|
curlx_uztoui(strlen(nonce)));
|
|
Curl_MD5_update(ctxt, (const unsigned char *) ":", 1);
|
|
Curl_MD5_update(ctxt, (const unsigned char *) cnonce,
|
|
curlx_uztoui(strlen(cnonce)));
|
|
Curl_MD5_final(ctxt, digest);
|
|
|
|
/* Convert calculated 16 octet hex into 32 bytes string */
|
|
for(i = 0; i < MD5_DIGEST_LEN; i++)
|
|
snprintf(&HA1_hex[2 * i], 3, "%02x", digest[i]);
|
|
|
|
/* Prepare the URL string */
|
|
snprintf(uri, sizeof(uri), "%s/%s", service, realm);
|
|
|
|
/* Calculate H(A2) */
|
|
ctxt = Curl_MD5_init(Curl_DIGEST_MD5);
|
|
if(!ctxt)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
Curl_MD5_update(ctxt, (const unsigned char *) method,
|
|
curlx_uztoui(strlen(method)));
|
|
Curl_MD5_update(ctxt, (const unsigned char *) ":", 1);
|
|
Curl_MD5_update(ctxt, (const unsigned char *) uri,
|
|
curlx_uztoui(strlen(uri)));
|
|
Curl_MD5_final(ctxt, digest);
|
|
|
|
for(i = 0; i < MD5_DIGEST_LEN; i++)
|
|
snprintf(&HA2_hex[2 * i], 3, "%02x", digest[i]);
|
|
|
|
/* Now calculate the response hash */
|
|
ctxt = Curl_MD5_init(Curl_DIGEST_MD5);
|
|
if(!ctxt)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
Curl_MD5_update(ctxt, (const unsigned char *) HA1_hex, 2 * MD5_DIGEST_LEN);
|
|
Curl_MD5_update(ctxt, (const unsigned char *) ":", 1);
|
|
Curl_MD5_update(ctxt, (const unsigned char *) nonce,
|
|
curlx_uztoui(strlen(nonce)));
|
|
Curl_MD5_update(ctxt, (const unsigned char *) ":", 1);
|
|
|
|
Curl_MD5_update(ctxt, (const unsigned char *) nonceCount,
|
|
curlx_uztoui(strlen(nonceCount)));
|
|
Curl_MD5_update(ctxt, (const unsigned char *) ":", 1);
|
|
Curl_MD5_update(ctxt, (const unsigned char *) cnonce,
|
|
curlx_uztoui(strlen(cnonce)));
|
|
Curl_MD5_update(ctxt, (const unsigned char *) ":", 1);
|
|
Curl_MD5_update(ctxt, (const unsigned char *) qop,
|
|
curlx_uztoui(strlen(qop)));
|
|
Curl_MD5_update(ctxt, (const unsigned char *) ":", 1);
|
|
|
|
Curl_MD5_update(ctxt, (const unsigned char *) HA2_hex, 2 * MD5_DIGEST_LEN);
|
|
Curl_MD5_final(ctxt, digest);
|
|
|
|
for(i = 0; i < MD5_DIGEST_LEN; i++)
|
|
snprintf(&resp_hash_hex[2 * i], 3, "%02x", digest[i]);
|
|
|
|
/* Generate the response */
|
|
response = aprintf("username=\"%s\",realm=\"%s\",nonce=\"%s\","
|
|
"cnonce=\"%s\",nc=\"%s\",digest-uri=\"%s\",response=%s",
|
|
userp, realm, nonce,
|
|
cnonce, nonceCount, uri, resp_hash_hex);
|
|
if(!response)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
/* Base64 encode the response */
|
|
result = Curl_base64_encode(data, response, 0, outptr, outlen);
|
|
|
|
Curl_safefree(response);
|
|
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
#ifdef USE_NTLM
|
|
/*
|
|
* Curl_sasl_create_ntlm_type1_message()
|
|
*
|
|
* This is used to generate an already encoded NTLM type-1 message ready for
|
|
* sending to the recipient.
|
|
*
|
|
* Note: This is a simple wrapper of the NTLM function which means that any
|
|
* SASL based protocols don't have to include the NTLM functions directly.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* userp [in] - The user name in the format User or Domain\User.
|
|
* passdwp [in] - The user's password.
|
|
* ntlm [in/out] - The ntlm data struct being used and modified.
|
|
* outptr [in/out] - The address where a pointer to newly allocated memory
|
|
* holding the result will be stored upon completion.
|
|
* outlen [out] - The length of the output message.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_sasl_create_ntlm_type1_message(const char *userp,
|
|
const char *passwdp,
|
|
struct ntlmdata *ntlm,
|
|
char **outptr, size_t *outlen)
|
|
{
|
|
return Curl_ntlm_create_type1_message(userp, passwdp, ntlm, outptr, outlen);
|
|
}
|
|
|
|
/*
|
|
* Curl_sasl_decode_ntlm_type2_message()
|
|
*
|
|
* This is used to decode an already encoded NTLM type-2 message.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* data [in] - Pointer to session handle.
|
|
* type2msg [in] - Pointer to the base64 encoded type-2 message.
|
|
* ntlm [in/out] - The ntlm data struct being used and modified.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_sasl_decode_ntlm_type2_message(struct SessionHandle *data,
|
|
const char *type2msg,
|
|
struct ntlmdata *ntlm)
|
|
{
|
|
#ifdef USE_NSS
|
|
CURLcode result;
|
|
|
|
/* make sure the crypto backend is initialized */
|
|
result = Curl_nss_force_init(data);
|
|
if(result)
|
|
return result;
|
|
#endif
|
|
|
|
return Curl_ntlm_decode_type2_message(data, type2msg, ntlm);
|
|
}
|
|
|
|
/*
|
|
* Curl_sasl_create_ntlm_type3_message()
|
|
*
|
|
* This is used to generate an already encoded NTLM type-3 message ready for
|
|
* sending to the recipient.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* data [in] - Pointer to session handle.
|
|
* userp [in] - The user name in the format User or Domain\User.
|
|
* passdwp [in] - The user's password.
|
|
* ntlm [in/out] - The ntlm data struct being used and modified.
|
|
* outptr [in/out] - The address where a pointer to newly allocated memory
|
|
* holding the result will be stored upon completion.
|
|
* outlen [out] - The length of the output message.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_sasl_create_ntlm_type3_message(struct SessionHandle *data,
|
|
const char *userp,
|
|
const char *passwdp,
|
|
struct ntlmdata *ntlm,
|
|
char **outptr, size_t *outlen)
|
|
{
|
|
return Curl_ntlm_create_type3_message(data, userp, passwdp, ntlm, outptr,
|
|
outlen);
|
|
}
|
|
#endif /* USE_NTLM */
|
|
|
|
/*
|
|
* Curl_sasl_create_xoauth2_message()
|
|
*
|
|
* This is used to generate an already encoded OAuth 2.0 message ready for
|
|
* sending to the recipient.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* data [in] - The session handle.
|
|
* user [in] - The user name.
|
|
* bearer [in] - The bearer token.
|
|
* outptr [in/out] - The address where a pointer to newly allocated memory
|
|
* holding the result will be stored upon completion.
|
|
* outlen [out] - The length of the output message.
|
|
*
|
|
* Returns CURLE_OK on success.
|
|
*/
|
|
CURLcode Curl_sasl_create_xoauth2_message(struct SessionHandle *data,
|
|
const char *user,
|
|
const char *bearer,
|
|
char **outptr, size_t *outlen)
|
|
{
|
|
CURLcode result = CURLE_OK;
|
|
char *xoauth = NULL;
|
|
|
|
/* Generate the message */
|
|
xoauth = aprintf("user=%s\1auth=Bearer %s\1\1", user, bearer);
|
|
if(!xoauth)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
/* Base64 encode the reply */
|
|
result = Curl_base64_encode(data, xoauth, strlen(xoauth), outptr, outlen);
|
|
|
|
Curl_safefree(xoauth);
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Curl_sasl_cleanup()
|
|
*
|
|
* This is used to cleanup any libraries or curl modules used by the sasl
|
|
* functions.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* conn [in] - Pointer to the connection data.
|
|
* authused [in] - The authentication mechanism used.
|
|
*/
|
|
void Curl_sasl_cleanup(struct connectdata *conn, unsigned int authused)
|
|
{
|
|
#ifdef USE_NTLM
|
|
/* Cleanup the ntlm structure */
|
|
if(authused == SASL_MECH_NTLM) {
|
|
Curl_ntlm_sspi_cleanup(&conn->ntlm);
|
|
}
|
|
(void)conn;
|
|
#else
|
|
/* Reserved for future use */
|
|
(void)conn;
|
|
(void)authused;
|
|
#endif
|
|
}
|