gnunet-svn
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[gnunet] branch master updated (56b8101fe -> 18bf1b905)


From: gnunet
Subject: [gnunet] branch master updated (56b8101fe -> 18bf1b905)
Date: Thu, 20 Jan 2022 15:17:07 +0100

This is an automated email from the git hooks/post-receive script.

martin-schanzenbach pushed a change to branch master
in repository gnunet.

    from 56b8101fe - fix dist
     new 54554ca53 GNS: Towards NFC
     new 18bf1b905 UTIL: Add UTF-8 NFC test

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 src/gnsrecord/gnsrecord_crypto.c         | 207 ++++++++++++++++++-------------
 src/gnsrecord/gnsrecord_misc.c           |  14 ++-
 src/include/gnunet_gnsrecord_lib.h       |   9 ++
 src/include/gnunet_strings_lib.h         |  12 ++
 src/namestore/gnunet-service-namestore.c |   4 +-
 src/util/strings.c                       |  17 +++
 src/util/test_strings.c                  |   7 ++
 7 files changed, 174 insertions(+), 96 deletions(-)

diff --git a/src/gnsrecord/gnsrecord_crypto.c b/src/gnsrecord/gnsrecord_crypto.c
index feb60ade9..fe7db88b9 100644
--- a/src/gnsrecord/gnsrecord_crypto.c
+++ b/src/gnsrecord/gnsrecord_crypto.c
@@ -447,28 +447,36 @@ GNUNET_GNSRECORD_block_create (const struct 
GNUNET_IDENTITY_PrivateKey *key,
                                unsigned int rd_count)
 {
   struct GNUNET_IDENTITY_PublicKey pkey;
+  struct GNUNET_GNSRECORD_Block *res = NULL;
+  char *norm_label;
+
   GNUNET_IDENTITY_key_get_public (key,
                                   &pkey);
+  norm_label = GNUNET_GNSRECORD_string_normalize (label);
+
   switch (ntohl (key->type))
   {
-  case GNUNET_GNSRECORD_TYPE_PKEY:
-    return block_create_ecdsa (&key->ecdsa_key,
-                               &pkey.ecdsa_key,
-                               expire,
-                               label,
-                               rd,
-                               rd_count);
-  case GNUNET_GNSRECORD_TYPE_EDKEY:
-    return block_create_eddsa (&key->eddsa_key,
-                               &pkey.eddsa_key,
-                               expire,
-                               label,
-                               rd,
-                               rd_count);
-  default:
-    GNUNET_assert (0);
+    case GNUNET_GNSRECORD_TYPE_PKEY:
+      res = block_create_ecdsa (&key->ecdsa_key,
+                                &pkey.ecdsa_key,
+                                expire,
+                                norm_label,
+                                rd,
+                                rd_count);
+      break;
+    case GNUNET_GNSRECORD_TYPE_EDKEY:
+      res = block_create_eddsa (&key->eddsa_key,
+                                &pkey.eddsa_key,
+                                expire,
+                                norm_label,
+                                rd,
+                                rd_count);
+      break;
+    default:
+      GNUNET_assert (0);
   }
-  return NULL;
+  GNUNET_free (norm_label);
+  return res;
 }
 
 
@@ -510,6 +518,10 @@ GNUNET_GNSRECORD_block_create2 (const struct 
GNUNET_IDENTITY_PrivateKey *pkey,
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *key;
   struct GNUNET_CRYPTO_EddsaPublicKey edpubkey;
+  struct GNUNET_GNSRECORD_Block *res = NULL;
+  char *norm_label;
+
+  norm_label = GNUNET_GNSRECORD_string_normalize (label);
 
   if (GNUNET_IDENTITY_TYPE_ECDSA == ntohl (pkey->type))
   {
@@ -529,25 +541,26 @@ GNUNET_GNSRECORD_block_create2 (const struct 
GNUNET_IDENTITY_PrivateKey *pkey,
                                           &line->pkey);
     }
 #undef CSIZE
-    return block_create_ecdsa (key,
-                               &line->pkey,
-                               expire,
-                               label,
-                               rd,
-                               rd_count);
+    res = block_create_ecdsa (key,
+                              &line->pkey,
+                              expire,
+                              norm_label,
+                              rd,
+                              rd_count);
   }
   else if (GNUNET_IDENTITY_TYPE_EDDSA == ntohl (pkey->type))
   {
     GNUNET_CRYPTO_eddsa_key_get_public (&pkey->eddsa_key,
                                         &edpubkey);
-    return block_create_eddsa (&pkey->eddsa_key,
-                               &edpubkey,
-                               expire,
-                               label,
-                               rd,
-                               rd_count);
+    res = block_create_eddsa (&pkey->eddsa_key,
+                              &edpubkey,
+                              expire,
+                              norm_label,
+                              rd,
+                              rd_count);
   }
-  return NULL;
+  GNUNET_free (norm_label);
+  return res;
 }
 
 
@@ -563,20 +576,20 @@ GNUNET_GNSRECORD_block_verify (const struct 
GNUNET_GNSRECORD_Block *block)
 {
   switch (ntohl (block->type))
   {
-  case GNUNET_GNSRECORD_TYPE_PKEY:
-    return GNUNET_CRYPTO_ecdsa_verify_ (
-      GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
-      &block->ecdsa_block.purpose,
-      &block->ecdsa_block.signature,
-      &block->ecdsa_block.derived_key);
-  case GNUNET_GNSRECORD_TYPE_EDKEY:
-    return GNUNET_CRYPTO_eddsa_verify_ (
-      GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
-      &block->eddsa_block.purpose,
-      &block->eddsa_block.signature,
-      &block->eddsa_block.derived_key);
-  default:
-    return GNUNET_NO;
+    case GNUNET_GNSRECORD_TYPE_PKEY:
+      return GNUNET_CRYPTO_ecdsa_verify_ (
+                                          
GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
+                                          &block->ecdsa_block.purpose,
+                                          &block->ecdsa_block.signature,
+                                          &block->ecdsa_block.derived_key);
+    case GNUNET_GNSRECORD_TYPE_EDKEY:
+      return GNUNET_CRYPTO_eddsa_verify_ (
+                                          
GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN,
+                                          &block->eddsa_block.purpose,
+                                          &block->eddsa_block.signature,
+                                          &block->eddsa_block.derived_key);
+    default:
+      return GNUNET_NO;
   }
 }
 
@@ -590,8 +603,8 @@ block_decrypt_ecdsa (const struct 
GNUNET_GNSRECORD_EcdsaBlock *block,
                      void *proc_cls)
 {
   size_t payload_len = ntohl (block->purpose.size)
-                       - sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
-                       - sizeof(struct GNUNET_TIME_AbsoluteNBO);
+    - sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
+    - sizeof(struct GNUNET_TIME_AbsoluteNBO);
   unsigned char ctr[GNUNET_CRYPTO_AES_KEY_LENGTH / 2];
   unsigned char key[GNUNET_CRYPTO_AES_KEY_LENGTH];
 
@@ -718,8 +731,8 @@ block_decrypt_eddsa (const struct 
GNUNET_GNSRECORD_EddsaBlock *block,
                      void *proc_cls)
 {
   size_t payload_len = ntohl (block->purpose.size)
-                       - sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
-                       - sizeof(struct GNUNET_TIME_AbsoluteNBO);
+    - sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
+    - sizeof(struct GNUNET_TIME_AbsoluteNBO);
   unsigned char nonce[crypto_secretbox_NONCEBYTES];
   unsigned char key[crypto_secretbox_KEYBYTES];
 
@@ -856,17 +869,25 @@ GNUNET_GNSRECORD_block_decrypt (const struct 
GNUNET_GNSRECORD_Block *block,
                                 GNUNET_GNSRECORD_RecordCallback proc,
                                 void *proc_cls)
 {
+  enum GNUNET_GenericReturnValue res = GNUNET_SYSERR;
+  char *norm_label;
+
+  norm_label = GNUNET_GNSRECORD_string_normalize (label);
   switch (ntohl (zone_key->type))
   {
-  case GNUNET_IDENTITY_TYPE_ECDSA:
-    return block_decrypt_ecdsa (&block->ecdsa_block,
-                                &zone_key->ecdsa_key, label, proc, proc_cls);
-  case GNUNET_IDENTITY_TYPE_EDDSA:
-    return block_decrypt_eddsa (&block->eddsa_block,
-                                &zone_key->eddsa_key, label, proc, proc_cls);
-  default:
-    return GNUNET_SYSERR;
+    case GNUNET_IDENTITY_TYPE_ECDSA:
+      res = block_decrypt_ecdsa (&block->ecdsa_block,
+                                 &zone_key->ecdsa_key, norm_label, proc, 
proc_cls);
+      break;
+    case GNUNET_IDENTITY_TYPE_EDDSA:
+      res = block_decrypt_eddsa (&block->eddsa_block,
+                                 &zone_key->eddsa_key, norm_label, proc, 
proc_cls);
+      break;
+    default:
+      return GNUNET_SYSERR;
   }
+  GNUNET_free (norm_label);
+  return res;
 }
 
 
@@ -883,21 +904,25 @@ GNUNET_GNSRECORD_query_from_private_key (const struct
                                          const char *label,
                                          struct GNUNET_HashCode *query)
 {
+  char *norm_label;
   struct GNUNET_IDENTITY_PublicKey pub;
+
+  norm_label = GNUNET_GNSRECORD_string_normalize (label);
   switch (ntohl (zone->type))
   {
-  case GNUNET_GNSRECORD_TYPE_PKEY:
-  case GNUNET_GNSRECORD_TYPE_EDKEY:
-
-    GNUNET_IDENTITY_key_get_public (zone,
-                                    &pub);
-    GNUNET_GNSRECORD_query_from_public_key (&pub,
-                                            label,
-                                            query);
-    break;
-  default:
-    GNUNET_assert (0);
+    case GNUNET_GNSRECORD_TYPE_PKEY:
+    case GNUNET_GNSRECORD_TYPE_EDKEY:
+
+      GNUNET_IDENTITY_key_get_public (zone,
+                                      &pub);
+      GNUNET_GNSRECORD_query_from_public_key (&pub,
+                                              norm_label,
+                                              query);
+      break;
+    default:
+      GNUNET_assert (0);
   }
+  GNUNET_free (norm_label);
 }
 
 
@@ -915,33 +940,37 @@ GNUNET_GNSRECORD_query_from_public_key (const struct
                                         const char *label,
                                         struct GNUNET_HashCode *query)
 {
+  char *norm_label;
   struct GNUNET_IDENTITY_PublicKey pd;
 
+  norm_label = GNUNET_GNSRECORD_string_normalize (label);
+
   switch (ntohl (pub->type))
   {
-  case GNUNET_GNSRECORD_TYPE_PKEY:
-    pd.type = pub->type;
-    GNUNET_CRYPTO_ecdsa_public_key_derive (&pub->ecdsa_key,
-                                           label,
-                                           "gns",
-                                           &pd.ecdsa_key);
-    GNUNET_CRYPTO_hash (&pd.ecdsa_key,
-                        sizeof (pd.ecdsa_key),
-                        query);
-    break;
-  case GNUNET_GNSRECORD_TYPE_EDKEY:
-    pd.type = pub->type;
-    GNUNET_CRYPTO_eddsa_public_key_derive (&pub->eddsa_key,
-                                           label,
-                                           "gns",
-                                           &(pd.eddsa_key));
-    GNUNET_CRYPTO_hash (&pd.eddsa_key,
-                        sizeof (pd.eddsa_key),
-                        query);
-    break;
-  default:
-    GNUNET_assert (0);
+    case GNUNET_GNSRECORD_TYPE_PKEY:
+      pd.type = pub->type;
+      GNUNET_CRYPTO_ecdsa_public_key_derive (&pub->ecdsa_key,
+                                             norm_label,
+                                             "gns",
+                                             &pd.ecdsa_key);
+      GNUNET_CRYPTO_hash (&pd.ecdsa_key,
+                          sizeof (pd.ecdsa_key),
+                          query);
+      break;
+    case GNUNET_GNSRECORD_TYPE_EDKEY:
+      pd.type = pub->type;
+      GNUNET_CRYPTO_eddsa_public_key_derive (&pub->eddsa_key,
+                                             norm_label,
+                                             "gns",
+                                             &(pd.eddsa_key));
+      GNUNET_CRYPTO_hash (&pd.eddsa_key,
+                          sizeof (pd.eddsa_key),
+                          query);
+      break;
+    default:
+      GNUNET_assert (0);
   }
+  GNUNET_free (norm_label);
 }
 
 
diff --git a/src/gnsrecord/gnsrecord_misc.c b/src/gnsrecord/gnsrecord_misc.c
index 8d3a6421f..c6f07ccd0 100644
--- a/src/gnsrecord/gnsrecord_misc.c
+++ b/src/gnsrecord/gnsrecord_misc.c
@@ -37,11 +37,6 @@
 
 #define LOG(kind, ...) GNUNET_log_from (kind, "gnsrecord", __VA_ARGS__)
 
-/**
- * Convert a UTF-8 string to UTF-8 lowercase
- * @param src source string
- * @return converted result
- */
 char *
 GNUNET_GNSRECORD_string_to_lowercase (const char *src)
 {
@@ -52,6 +47,15 @@ GNUNET_GNSRECORD_string_to_lowercase (const char *src)
   return res;
 }
 
+char *
+GNUNET_GNSRECORD_string_normalize (const char *src)
+{
+  char *res;
+  res = GNUNET_strdup (src);
+  GNUNET_STRINGS_utf8_tolower (src, res);
+  GNUNET_STRINGS_utf8_normalize (src, res);
+  return res;
+}
 
 /**
  * Convert a zone key to a string (for printing debug messages).
diff --git a/src/include/gnunet_gnsrecord_lib.h 
b/src/include/gnunet_gnsrecord_lib.h
index f00a5d0f8..94e20323d 100644
--- a/src/include/gnunet_gnsrecord_lib.h
+++ b/src/include/gnunet_gnsrecord_lib.h
@@ -417,6 +417,15 @@ int
 GNUNET_GNSRECORD_is_expired (const struct GNUNET_GNSRECORD_Data *rd);
 
 
+/**
+ * Normalize a UTF-8 string to UTF-8 NFC
+ * @param src source string
+ * @return converted result
+ */
+char *
+GNUNET_GNSRECORD_string_normalize (const char *src);
+
+
 /**
  * Convert a UTF-8 string to UTF-8 lowercase
  * @param src source string
diff --git a/src/include/gnunet_strings_lib.h b/src/include/gnunet_strings_lib.h
index ef9d5ac58..9dd2f733e 100644
--- a/src/include/gnunet_strings_lib.h
+++ b/src/include/gnunet_strings_lib.h
@@ -157,6 +157,18 @@ GNUNET_STRINGS_to_utf8 (const char *input,
                         const char *charset);
 
 
+/**
+ * Normalize the utf-8 input string to NFC.
+ * Output needs to be allocated appropriately.
+ *
+ * @param input input string
+ * @param output output buffer
+ */
+void
+GNUNET_STRINGS_utf8_normalize (const char *input,
+                               char *output);
+
+
 /**
  * Convert the len bytes-long UTF-8 string
  * given in input to the given charset.
diff --git a/src/namestore/gnunet-service-namestore.c 
b/src/namestore/gnunet-service-namestore.c
index cd953492e..cf1b555a5 100644
--- a/src/namestore/gnunet-service-namestore.c
+++ b/src/namestore/gnunet-service-namestore.c
@@ -1366,7 +1366,7 @@ handle_record_lookup (void *cls, const struct 
LabelLookupMessage *ll_msg)
               "Received NAMESTORE_RECORD_LOOKUP message for name `%s'\n",
               name_tmp);
 
-  conv_name = GNUNET_GNSRECORD_string_to_lowercase (name_tmp);
+  conv_name = GNUNET_GNSRECORD_string_normalize (name_tmp);
   if (NULL == conv_name)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -1490,7 +1490,7 @@ handle_record_store (void *cls, const struct 
RecordStoreMessage *rp_msg)
     }
 
     /* Extracting and converting private key */
-    conv_name = GNUNET_GNSRECORD_string_to_lowercase (name_tmp);
+    conv_name = GNUNET_GNSRECORD_string_normalize (name_tmp);
     if (NULL == conv_name)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
diff --git a/src/util/strings.c b/src/util/strings.c
index 76125b92e..ece096f72 100644
--- a/src/util/strings.c
+++ b/src/util/strings.c
@@ -426,6 +426,23 @@ GNUNET_STRINGS_from_utf8 (const char *input,
 }
 
 
+void
+GNUNET_STRINGS_utf8_normalize (const char *input,
+                               char *output)
+{
+  uint8_t *tmp;
+  size_t len;
+
+  tmp = u8_normalize (UNINORM_NFC,
+                      (uint8_t *) input,
+                      strlen ((char*) input),
+                      NULL,
+                      &len);
+  GNUNET_memcpy (output, tmp, len);
+  output[len] = '\0';
+  free (tmp);
+}
+
 void
 GNUNET_STRINGS_utf8_tolower (const char *input,
                              char *output)
diff --git a/src/util/test_strings.c b/src/util/test_strings.c
index d986486d0..1ecd31464 100644
--- a/src/util/test_strings.c
+++ b/src/util/test_strings.c
@@ -111,6 +111,13 @@ main (int argc, char *argv[])
     GNUNET_break (0);
     return 1;
   }
+  /* Normalization */
+  r = "q\u0307\u0323"; /* Non-canonical order */
+
+  GNUNET_STRINGS_utf8_normalize (r,
+                                 buf);
+  GNUNET_assert (0 == strcmp ("q\u0323\u0307", buf));
+
   b = GNUNET_STRINGS_to_utf8 ("TEST", 4, "ASCII");
   WANT ("TEST", b);
 

-- 
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.



reply via email to

[Prev in Thread] Current Thread [Next in Thread]