Changeset 432

Timestamp:

04/29/08 19:08:46 (3 months ago)

Author:

bellmich

Message:

added support for MD5 and real authentication

Files:

• trunk/libsyncml/objects/sml_auth.c (modified) (3 diffs)
• trunk/libsyncml/objects/sml_auth.h (modified) (2 diffs)
• trunk/libsyncml/objects/sml_auth_internals.h (modified) (2 diffs)
• trunk/libsyncml/parser/sml_xml_assm.c (modified) (7 diffs)
• trunk/libsyncml/parser/sml_xml_assm.h (modified) (1 diff)
• trunk/libsyncml/parser/sml_xml_assm_internals.h (modified) (1 diff)
• trunk/libsyncml/parser/sml_xml_parse.c (modified) (5 diffs)
• trunk/libsyncml/sml_elements.c (modified) (7 diffs)
• trunk/libsyncml/sml_elements.h (modified) (2 diffs)
• trunk/libsyncml/sml_elements_internals.h (modified) (2 diffs)
• trunk/libsyncml/sml_manager.c (modified) (1 diff)
• trunk/libsyncml/sml_parse.c (modified) (1 diff)
• trunk/libsyncml/sml_parse.h (modified) (2 diffs)
• trunk/libsyncml/sml_session.c (modified) (11 diffs)
• trunk/libsyncml/sml_session.h (modified) (1 diff)
• trunk/libsyncml/sml_session_internals.h (modified) (2 diffs)
• trunk/libsyncml/sml_transport.c (modified) (1 diff)
• trunk/libsyncml/transports/http_client.c (modified) (1 diff)
• trunk/tests/check_manager.c (modified) (1 diff)

trunk/libsyncml/objects/sml_auth.c

@@ -54 +54 @@
-        unsigned int buffersize = 0;
-        
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-                
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-        } else {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                                } else {
-
+
+
+
+
+
-                                        auth->state = SML_ERROR_AUTH_REJECTED;
-                                }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-                }
-        }
@@ -132 +138 @@
-        smlErrorDeref(&error);
-        return;
+}
+
+char *smlAuthGetCredString(
+        SmlAuthType type,
+        const char *username,
+        const char *password,
+        const char *b64_nonce,
+        SmlError **error)
+{
+        smlTrace(TRACE_ENTRY, "%s", __func__);
+        char *cred = NULL;
+
+        switch (type) {
+                case SML_AUTH_TYPE_BASIC:
+
+                        smlTrace(TRACE_INTERNAL, "%s - SML_AUTH_TYPE_BASIC", __func__);
+                        char *plain = g_strjoin(":", username, password, NULL);
+                        if (!smlBase64EncodeBinary(plain, strlen(plain), &cred, error))
+                        {
+                                smlTrace(TRACE_INTERNAL, "%s - base64 failed", __func__);
+                                smlSafeCFree(&plain);
+                                goto error;
+                        }
+                        smlSafeCFree(&plain);
+
+                        break;
+                case SML_AUTH_TYPE_MD5:
+
+                        smlTrace(TRACE_INTERNAL, "%s - SML_AUTH_TYPE_MD5", __func__);
+                        /* How does syncml:auth-md5 works?
+                         *
+                         * base64(
+                         *        md5(
+                         *            base64(
+                         *                   md5(
+                         *                       username + ":" + password
+                         *                      )
+                         *                  ) +
+                         *            ":" + nonce
+                         *           )
+                         *       )
+                         */
+
+                        /* Let's determine the string for the comparison. */
+                        ;
+                        char *auth = g_strjoin (":", username, password, NULL);
+                        unsigned char digest[16];
+                        smlMD5GetDigest (auth, strlen(auth), digest);
+                        smlSafeCFree(&auth);
+                        if (!smlBase64EncodeBinary(digest, 16, &cred, error))
+                        {
+                                smlTrace(TRACE_INTERNAL, "%s - base64 failed", __func__);
+                                if (cred)
+                                        smlSafeCFree(&cred);
+                                goto error;
+                        }
+                        auth = g_strjoin (":", cred, b64_nonce, NULL);
+                        smlSafeCFree(&cred);
+                        smlMD5GetDigest (auth, strlen(auth), digest);
+                        smlSafeCFree(&auth);
+                        if (!smlBase64EncodeBinary(digest, 16, &cred, error))
+                        {
+                                smlTrace(TRACE_INTERNAL, "%s - base64 failed %s", __func__, smlErrorPrint(error));
+                                if (cred)
+                                        smlSafeCFree(&cred);
+                                goto error;
+                        }
+
+                        break;
+                default:
+                        smlTrace(TRACE_ERROR, "%s - unknown authentication type", __func__);
+                        smlErrorSet(error, SML_ERROR_GENERIC, "Unknown auth format");
+                        goto error;
+        }
+
+        smlTrace(TRACE_EXIT, "%s", __func__);
+        return cred;
+error:
+        smlTrace(TRACE_EXIT_ERROR, "%s - cannot create credential string");
+        if (*error == NULL)
+                smlErrorSet(error, SML_ERROR_GENERIC, "Cannot create credential string for user %s.",
+                        username);
+        return NULL;
+}
+
+SmlBool smlAuthVerify(SmlChal *chal, SmlCred *cred, const char *username, const char *password, SmlError **error)
+{
+        smlTrace(TRACE_ENTRY, "%s", __func__);
+
+        /* If no Chal is send to the client but the client offers a Cred
+         * then we accept it. Theoretically this is not 100% perfect if
+         * syncml:auth-md5 is used but if the client offers it then we
+         * accept it because some implementations like UIQ 3 are broken
+         * and implemented the protocol in a wrong way if we answer with
+         * error 407 and a fresh nonce.
+         *
+         * SECURITY NOTE: This part of the code makes libsyncml vulnerable
+         * SECURITY NOTE: against replay attacks.
+         *
+         */
+        if (chal && chal->type != cred->type)
+        {
+                if (chal->type == SML_AUTH_TYPE_BASIC &&
+                    cred->type == SML_AUTH_TYPE_MD5)
+                {
+                        /* This is an upgrade to more security.
+                         * So it is acceptable.
+                         */
+                        smlTrace(TRACE_INTERNAL, "%s - replace syncml:auth-basic by syncml:auth-md5", __func__);
+                } else {
+                        /* This is a security event. */
+                        smlErrorSet(error, SML_ERROR_AUTH_REJECTED,
+                                "The type of the authentication was changed to a lower security level.");
+                        goto error;
+                }
+        }
+        smlTrace(TRACE_INTERNAL, "%s - authentication security policy ok", __func__);
+
+        char *wanted = NULL;
+        switch (cred->type) {
+                case SML_AUTH_TYPE_BASIC:
+                        smlTrace(TRACE_INTERNAL, "%s - SML_AUTH_TYPE_BASIC", __func__);
+                        wanted = smlAuthGetCredString(SML_AUTH_TYPE_BASIC, username, password, NULL, error);
+                        break;
+                case SML_AUTH_TYPE_MD5:
+                        smlTrace(TRACE_INTERNAL, "%s - SML_AUTH_TYPE_MD5", __func__);
+                        if (chal)
+                                wanted = smlAuthGetCredString(
+                                                SML_AUTH_TYPE_MD5,
+                                                username, password,
+                                                chal->nonce_b64, error);
+                        else
+                                wanted = smlAuthGetCredString(
+                                                SML_AUTH_TYPE_MD5,
+                                                username, password,
+                                                "", error);
+                        break;
+                default:
+                        smlTrace(TRACE_ERROR, "%s - unknown authentication type", __func__);
+                        smlErrorSet(error, SML_ERROR_GENERIC, "Unknown auth format");
+                        goto error;
+        }
+        smlTrace(TRACE_INTERNAL, "%s - credential string calculated", __func__);
+
+        /* compare the authentication string */
+        if (strcmp(wanted, cred->data))
+        {
+                smlTrace(TRACE_INTERNAL, "%s - credentials mismatch", __func__);
+                smlSafeCFree(&wanted);
+                goto error;
+        }
+        smlSafeCFree(&wanted);
+                        
+        smlTrace(TRACE_EXIT, "%s", __func__);
+        return TRUE;
+error:
+        smlTrace(TRACE_EXIT_ERROR, "%s - auth rejected");
+        if (*error == NULL)
+                smlErrorSet(error, SML_ERROR_AUTH_REJECTED, "Authentication rejected for username %s.",
+                        username);
+        return FALSE;
-}
-
@@ -210 +377 @@
-        
-        if (code == SML_ERROR_AUTH_REJECTED || code == SML_ERROR_AUTH_REQUIRED) {
-TryMalloc0(sizeof(SmlChal)
+ChalNew(code
-                if (!reply->chal)
-                        goto error_free_reply;
-
-
-
+
+
-        }
-        

trunk/libsyncml/objects/sml_auth.h

@@ -23 +23 @@
-
-typedef struct SmlAuthenticator SmlAuthenticator;
-void (* SmlAuthVerifyCb)(SmlAuthenticator *auth, const char *username, const char *password, void *userdata, SmlErrorType *reply
+SmlBool (* SmlAuthVerifyCb)(SmlChal *chal, SmlCred *cred, const char *username, void *userdata, SmlError **error
-
-SmlAuthenticator *smlAuthNew(SmlError **error);
@@ -34 +34 @@
-SmlBool smlAuthIsEnabled(SmlAuthenticator *auth);
-
+/* This can be used from within the SmlAuthVerifyCb to do the authentication itself. */
+SmlBool smlAuthVerify(SmlChal *chal, SmlCred *cred, const char *username, const char *password, SmlError **error);
+
-#endif //_SML_AUTH_H_

trunk/libsyncml/objects/sml_auth_internals.h

@@ -22 +22 @@
-#define _SML_AUTH_INTERNALS_H_
-
+#include "sml_auth.h"
+
-struct SmlAuthenticator {
-        SmlErrorType state;
@@ -29 +31 @@
-};
-
+char *smlAuthGetCredString(
+        SmlAuthType type,
+        const char *username,
+        const char *password,
+        const char *b64_nonce,
+        SmlError **error);
+
-#endif //_SML_AUTH_INTERNALS_H_

trunk/libsyncml/parser/sml_xml_assm.c

@@ -741 +741 @@
-        if (!smlLocationAssemble(session->source, assm, SML_ELEMENT_SOURCE, error))
-                goto error_free_writer;
-
-
+
+
+
+
+
-                if (!smlCredAssemble(session->cred, assm, error))
-                        goto error_free_writer;
@@ -1171 +1174 @@
-                                        goto error;
-                                
-red
+hal
-                                        case SML_AUTH_TYPE_BASIC:
-                                                if (!_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_TYPE, SML_NAMESPACE_METINF, SML_AUTH_BASIC, error))
@@ -1178 +1181 @@
-                                        case SML_AUTH_TYPE_MD5:
-                                                if (!_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_TYPE, SML_NAMESPACE_METINF, SML_AUTH_MD5, error))
+                                                        goto error;
+                                                if (status->chal->nonce_b64 &&
+                                                    !_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_NEXTNONCE, SML_NAMESPACE_METINF, status->chal->nonce_b64, error))
-                                                        goto error;
-                                                break;
@@ -1287 +1293 @@
-        
-        flush_list(assm->commands);
+        flush_list(assm->last_commands);
-
-        g_mutex_free(assm->mutex);
@@ -1327 +1334 @@
-        g_list_free(s2);
-        
-
-
+
+
+
+
+
+
+
+
-        assm->commands = NULL;
-        
@@ -1724 +1737 @@
-        functions->next_cmdref = (SmlAssemblerNextCmdRefFunction)smlXmlAssemblerNextCmdRef;
-        functions->flush = (SmlAssemblerFlushFunction)smlXmlAssemblerFlush;
+        functions->restore_cmds = (SmlAssemblerRestoreCommandsFunction)smlXmlAssemblerRestoreCommands;
-        
-        smlTrace(TRACE_EXIT, "%s: %p", __func__, assm);
@@ -2313 +2327 @@
-}
-
+void smlXmlAssemblerRestoreCommands(SmlXmlAssembler *assm)
+{
+        smlTrace(TRACE_ENTRY, "%s", __func__);
+        smlAssert(assm->commands == NULL);
+
+        assm->commands = assm->last_commands;
+        assm->last_commands = NULL;
+
+        smlTrace(TRACE_EXIT, "%s", __func__);
+}
+
-/*@}*/

trunk/libsyncml/parser/sml_xml_assm.h

@@ -40 +40 @@
-SmlBool smlXmlDevInfAssemble(SmlDevInf *devinf, SmlDevInfVersion version, char **data, unsigned int *size, SmlError **error);
-
+/* This is necessary if the first message results in an error 407.
+ * This error means authentication required.
+ * After such an error the previous commands must be sent again.
+ */
+void smlXmlAssemblerRestoreCommands(SmlXmlAssembler *assm);
+
-#endif //_SML_XML_ASSM_H_

trunk/libsyncml/parser/sml_xml_assm_internals.h

@@ -62 +62 @@
-        GList *statuses;
-        GList *commands;
+        GList *last_commands;
-        GList *parent_commands;
-        GList *parent_buffers;

trunk/libsyncml/parser/sml_xml_parse.c

@@ -819 +819 @@
-        char *format = NULL;
-        char *type = NULL;
-
-
-
-
+
-        
-        while (1) {
-                if (!_smlXmlParserStep(parser)) {
-                        smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes");
-_free_chal
+
-                }
-                
@@ -835 +832 @@
-                } else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
-                        smlErrorSet(error, SML_ERROR_GENERIC, "Not a start node");
-_free_chal
+
-                }
-                
-                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) {
-chal->
-_free_chal
+
+
-                } else {
-                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node %s", xmlTextReaderConstName(parser->reader));
-
-
-
-
-
-
-
+
+
+
+
+
-                smlErrorSet(error, SML_ERROR_GENERIC, "Unknown format");
-
-
-
+
+
+
+
-        if (!type || !strcmp(type, SML_AUTH_BASIC)) {
-chal->type
+auth
-        } else if (!strcmp(type, SML_AUTH_MD5)) {
-chal->type
+auth
-        } else {
-                smlErrorSet(error, SML_ERROR_GENERIC, "Unknown type");
-_free_chal
-
-
+
+
+
-        if (format)
-                smlSafeCFree(&format);
-        if (type)
-                smlSafeCFree(&type);
-
+
+
+
+
+
+
+
+
+
+
+
+
-        smlTrace(TRACE_EXIT, "%s: %p", __func__, chal);
-        return chal;
-
-error_free_chal:
-        smlChalFree(chal);
-error:
-        if (format)
@@ -878 +883 @@
-        if (type)
-                smlSafeCFree(&type);
+        if (nonce)
+                smlSafeCFree(&nonce);
-        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
-        return NULL;
@@ -1759 +1766 @@
-        char *locURI = NULL;
-        SmlItem *item = NULL;
-        SmlChal *chal = NULL;
-        
-        /* Lets check if the next node is a command node */
@@ -1884 +1890 @@
-                                goto error_free_status;
-                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CHAL)) {
-
-
+(*status)->
+(*status)->
-                                goto error_free_status;
-                } else {

trunk/libsyncml/sml_elements.c

@@ -581 +581 @@
-{
-        smlTrace(TRACE_ENTRY, "%s(%d, %s, %p)", __func__, type, username, error);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-
-        smlTrace(TRACE_EXIT, "%s", __func__);
-        return cred;
-error:
-data
-CFree(&data
+cred
+Free((gpointer *)&cred
-        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
-        return NULL;    
@@ -632 +616 @@
-        cred->data = g_strdup(data);
-        if (username)
-locN
+usern
-        else
-locN
+usern
-        cred->refCount = 1;
-
@@ -642 +626 @@
-        if (cred->data)
-                smlSafeCFree(&(cred->data));
-locN
-locN
+usern
+usern
-        if (cred)
-                smlSafeFree((gpointer *)&cred);
@@ -650 +634 @@
-}
-
-SmlCred *
+void 
-{
-        smlTrace(TRACE_ENTRY, "%s(%p)", __func__, cred);
@@ -658 +642 @@
-        
-        smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, cred->refCount);
-        return cred;
-}
-
@@ -671 +654 @@
-                if (cred->data)
-                        smlSafeCFree(&(cred->data));
-
-
+
+
+
+
-                        
-                smlSafeFree((gpointer *)&cred);
@@ -686 +671 @@
-}
-
+SmlChal *smlChalNew(SmlAuthType type, SmlError **error)
+{
+        smlTrace(TRACE_ENTRY, "%s", __func__);
+        SmlChal *chal = NULL;
+
+        /* allocate memory */
+        smlAssert(type != SML_AUTH_TYPE_UNKNOWN);
+        chal = smlTryMalloc0(sizeof(SmlChal), error);
+        if (!chal)
+                goto error;
+        chal->refCount = 1;
+        chal->type = type;
+        chal->format = SML_FORMAT_TYPE_BASE64;
+
+        if (type == SML_AUTH_TYPE_MD5)
+        {
+                /* A nonce must be generated for this type.
+                 *     minimum strength:  2^128
+                 *     strength per byte: 2^6 - 2 > 2^5
+                 *     needed bytes:      128 / 5 < 130 / 5 = 26
+                 */
+                chal->nonce_plain = smlRandStr(26, TRUE);
+                chal->nonce_length = 26;
+                if (!smlBase64EncodeBinary(chal->nonce_plain, chal->nonce_length,
+                                           &(chal->nonce_b64), error))
+                        goto error;
+        }
+
+        smlTrace(TRACE_EXIT, "%s", __func__);
+        return chal;
+error:
+        if (chal->nonce_plain)
+                smlSafeCFree(&(chal->nonce_plain));
+        if (chal->nonce_b64)
+                smlSafeCFree(&(chal->nonce_b64));
+        if (chal)
+                smlSafeFree((gpointer *)&chal);
+        smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(error));
+        return NULL;
+}
+
+SmlChal *smlChalNewFromBinary(
+                SmlAuthType type,
+                const char *nonce,
+                size_t length,
+                SmlError **error)
+{
+        smlTrace(TRACE_ENTRY, "%s", __func__);
+        SmlChal *chal = NULL;
+
+        /* only syncml:auth-md5 needs a nonce */
+        smlAssert(type == SML_AUTH_TYPE_MD5);
+
+        /* allocate memory */
+        chal = smlTryMalloc0(sizeof(SmlChal), error);
+        if (!chal)
+                goto error;
+        chal->refCount = 1;
+
+        /* copy nonce */
+        chal->type = SML_AUTH_TYPE_MD5;
+        chal->format = SML_FORMAT_TYPE_BASE64;
+        chal->nonce_plain = g_strndup(nonce, length);
+        chal->nonce_length = length;
+
+        /* create base64 nonce */
+        if (!smlBase64EncodeBinary(nonce, length, &(chal->nonce_b64), error))
+                goto error;
+
+        smlTrace(TRACE_EXIT, "%s", __func__);
+        return chal;
+error:
+        smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(error));
+        return NULL;
+}
+
+SmlChal *smlChalNewFromBase64(
+                SmlAuthType type,
+                const char *nonce,
+                SmlError **error)
+{
+        smlTrace(TRACE_ENTRY, "%s", __func__);
+        SmlChal *chal = NULL;
+
+        /* only syncml:auth-md5 needs a nonce */
+        smlAssert(type == SML_AUTH_TYPE_MD5);
+
+        /* allocate memory */
+        chal = smlTryMalloc0(sizeof(SmlChal), error);
+        if (!chal)
+                goto error;
+        chal->refCount = 1;
+
+        /* copy nonce */
+        chal->type = SML_AUTH_TYPE_MD5;
+        chal->format = SML_FORMAT_TYPE_BASE64;
+        chal->nonce_b64 = g_strdup(nonce);
+
+        /* create binary nonce */
+        if (!smlBase64Decode(nonce, &(chal->nonce_plain), &(chal->nonce_length), error))
+                goto error;
+
+        smlTrace(TRACE_EXIT, "%s", __func__);
+        return chal;
+error:
+        smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(error));
+        return NULL;
+}
+
+void smlChalRef(SmlChal *chal)
+{
+        smlTrace(TRACE_ENTRY, "%s", __func__);
+        smlAssert(chal);
+        
+        g_atomic_int_inc(&(chal->refCount));
+        
+        smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, chal->refCount);
+}
+
+void smlChalUnref(SmlChal *chal)
+{
+        smlTrace(TRACE_ENTRY, "%s", __func__);
+        smlAssert(chal);
+        
+        if (g_atomic_int_dec_and_test(&(chal->refCount))) {
+                smlTrace(TRACE_INTERNAL, "Refcount == 0!");
+                
+                if (chal->nonce_plain)
+                        smlSafeCFree(&(chal->nonce_plain));
+
+                if (chal->nonce_b64)
+                        smlSafeCFree(&(chal->nonce_b64));
+
+                smlSafeFree((gpointer *)&chal);
+        }
+        
+        smlTrace(TRACE_EXIT, "%s", __func__);
+}
+
+/* FIXME: DEPRECATED */
-void smlChalFree(SmlChal *chal)
-{
-
-
-
-
-
-
-
-
-
+
-}
-

trunk/libsyncml/sml_elements.h

@@ -37 +37 @@
-SmlCred *smlCredNewAuth(SmlAuthType type, const char *username, const char *password, SmlError **error);
-SmlCred *smlCredNew(SmlAuthType type, SmlFormatType format, const char *data, const char*username, SmlError **error);
-SmlCred *
+void 
-void smlCredUnref(SmlCred *cred);
-void smlCredFree(SmlCred *cred) LIBSYNCML_DEPRECATED; /* expire date: 20090120 */
@@ -62 +62 @@
-void smlHeade