Fixed public key decoding.

[silc.git] / lib / silccrypt / silcpkcs.c

diff --git a/lib/silccrypt/silcpkcs.c b/lib/silccrypt/silcpkcs.c
index a8a2a3a41f0dfb00b8754f836f14379394c89d5a..410845fce97c52d2f24127ba7754d6997ba9d94e 100644 (file)
--- a/lib/silccrypt/silcpkcs.c
+++ b/lib/silccrypt/silcpkcs.c
@@ -620,6 +620,7 @@ SilcPublicKey silc_pkcs_public_key_alloc(const char *name,
   public_key->name = strdup(name);
   public_key->pk_len = pk_len;
   public_key->pk = silc_calloc(pk_len, sizeof(*public_key->pk));
+  public_key->pk_type = SILC_SKE_PK_TYPE_SILC;
   memcpy(public_key->pk, pk, pk_len);
 
   if (!silc_utf8_valid(identifier, strlen(identifier))) {
@@ -630,7 +631,7 @@ SilcPublicKey silc_pkcs_public_key_alloc(const char *name,
   }
 
   public_key->identifier = strdup(identifier);
-  public_key->len = 4 + 2 + strlen(name) + 2 + strlen(identifier) + pk_len;
+  public_key->len = 2 + strlen(name) + 2 + strlen(identifier) + pk_len;
   silc_free(tmp);
 
   return public_key;
@@ -686,7 +687,7 @@ silc_pkcs_public_key_encode(SilcPublicKey public_key, SilcUInt32 *len)
   SilcBuffer buf;
   unsigned char *ret;
 
-  buf = silc_buffer_alloc(public_key->len);
+  buf = silc_buffer_alloc(public_key->len + 4);
   silc_buffer_pull_tail(buf, SILC_BUFFER_END(buf));
 
   silc_buffer_format(buf,
@@ -699,7 +700,7 @@ silc_pkcs_public_key_encode(SilcPublicKey public_key, SilcUInt32 *len)
                                          public_key->pk_len),
                     SILC_STR_END);
   if (len)
-    *len = public_key->len;
+    *len = public_key->len + 4;
 
   ret = silc_calloc(buf->len, sizeof(*ret));
   memcpy(ret, buf->data, buf->len);
@@ -719,8 +720,8 @@ silc_pkcs_public_key_data_encode(unsigned char *pk, SilcUInt32 pk_len,
   unsigned char *ret;
   SilcUInt32 totlen;
 
-  totlen = 4 + 2 + strlen(pkcs) + 2 + strlen(identifier) + pk_len;
-  buf = silc_buffer_alloc(totlen);
+  totlen = 2 + strlen(pkcs) + 2 + strlen(identifier) + pk_len;
+  buf = silc_buffer_alloc(totlen + 4);
   silc_buffer_pull_tail(buf, SILC_BUFFER_END(buf));
 
   silc_buffer_format(buf,
@@ -732,7 +733,7 @@ silc_pkcs_public_key_data_encode(unsigned char *pk, SilcUInt32 pk_len,
                     SILC_STR_UI_XNSTRING(pk, pk_len),
                     SILC_STR_END);
   if (len)
-    *len = totlen;
+    *len = totlen + 4;
 
   ret = silc_calloc(buf->len, sizeof(*ret));
   memcpy(ret, buf->data, buf->len);
@@ -767,7 +768,12 @@ bool silc_pkcs_public_key_decode(unsigned char *data, SilcUInt32 data_len,
     return FALSE;
   }
 
-  if (totlen != data_len) {
+#if 1 /* Backwards support, remove! */
+  if (totlen == data_len)
+    totlen -= 4;
+#endif
+
+  if (totlen + 4 != data_len) {
     silc_buffer_free(buf);
     return FALSE;
   }
@@ -826,6 +832,7 @@ bool silc_pkcs_public_key_decode(unsigned char *data, SilcUInt32 data_len,
     (*public_key)->identifier = ident;
     (*public_key)->pk = key_data;
     (*public_key)->pk_len = key_len;
+    (*public_key)->pk_type = SILC_SKE_PK_TYPE_SILC;
   }
 
   silc_buffer_free(buf);
@@ -842,6 +849,88 @@ bool silc_pkcs_public_key_decode(unsigned char *data, SilcUInt32 data_len,
   return FALSE;
 }
 
+/* Encodes Public Key Payload for transmitting public keys and certificates. */
+
+SilcBuffer silc_pkcs_public_key_payload_encode(SilcPublicKey public_key)
+{
+  SilcBuffer buffer;
+  unsigned char *pk;
+  SilcUInt32 pk_len;
+
+  if (!public_key)
+    return NULL;
+
+  pk = silc_pkcs_public_key_encode(public_key, &pk_len);
+  if (!pk)
+    return NULL;
+
+  buffer = silc_buffer_alloc_size(4 + pk_len);
+  if (!buffer) {
+    silc_free(pk);
+    return NULL;
+  }
+
+  silc_buffer_format(buffer,
+                    SILC_STR_UI_SHORT(pk_len),
+                    SILC_STR_UI_SHORT(public_key->pk_type),
+                    SILC_STR_UI_XNSTRING(pk, pk_len),
+                    SILC_STR_END);
+
+  silc_free(pk);
+  return buffer;
+}
+
+/* Decode Public Key Payload and decodes the public key inside it to
+   to `payload'. */
+
+bool silc_pkcs_public_key_payload_decode(unsigned char *data,
+                                        SilcUInt32 data_len,
+                                        SilcPublicKey *public_key)
+{
+  SilcBufferStruct buf;
+  SilcUInt16 pk_len, pk_type;
+  unsigned char *pk;
+  int ret;
+
+  if (!public_key)
+    return FALSE;
+
+#if 1
+  /* XXX 1.1 version support.  Check whether the data is actually raw
+     public key and attempt to decode.  Remove this later! */
+  if (silc_pkcs_public_key_decode(data, data_len, public_key)) {
+    (*public_key)->pk_type = SILC_SKE_PK_TYPE_SILC;
+    return TRUE;
+  }
+#endif
+
+  silc_buffer_set(&buf, data, data_len);
+  ret = silc_buffer_unformat(&buf,
+                            SILC_STR_UI_SHORT(&pk_len),
+                            SILC_STR_UI_SHORT(&pk_type),
+                            SILC_STR_END);
+  if (ret < 0 || pk_len > data_len - 4)
+    return FALSE;
+
+  /* For now we support only SILC public keys */
+  if (pk_type != SILC_SKE_PK_TYPE_SILC)
+    return FALSE;
+
+  silc_buffer_pull(&buf, 4);
+  ret = silc_buffer_unformat(&buf,
+                            SILC_STR_UI_XNSTRING(&pk, pk_len),
+                            SILC_STR_END);
+  silc_buffer_push(&buf, 4);
+  if (ret < 0)
+    return FALSE;
+
+  if (!silc_pkcs_public_key_decode(pk, pk_len, public_key))
+    return FALSE;
+  (*public_key)->pk_type = SILC_SKE_PK_TYPE_SILC;
+
+  return TRUE;
+}
+
 /* Compares two public keys and returns TRUE if they are same key, and
    FALSE if they are not same. */
 
@@ -876,6 +965,7 @@ SilcPublicKey silc_pkcs_public_key_copy(SilcPublicKey public_key)
                                strlen(public_key->identifier));
   key->pk = silc_memdup(public_key->pk, public_key->pk_len);
   key->pk_len = public_key->pk_len;
+  key->pk_type = public_key->pk_type;
 
   return key;
 }