fix search index decryption

Author: unverbuggt

encryptcontent/decrypt-contents.tpl.js

@@ -147,33 +147,24 @@ function reload_js(src) {
 
 {% if experimental -%}
 /* Decrypt part of the search index and refresh it for search engine */
-function decrypt_search(key, path_location) {
+function decrypt_search(keys) {
     sessionIndex = sessionStorage.getItem('encryptcontent-index');
     let could_decrypt = false;
     if (sessionIndex) {
         sessionIndex = JSON.parse(sessionIndex);
         for (var i=0; i < sessionIndex.docs.length; i++) {
-            var doc = sessionIndex.docs[i];
-            if (doc.location.indexOf(path_location.replace('{{ site_path }}', '')) !== -1) {
-                // grab the ciphertext bundle and try to decrypt it
-                let title = decrypt_content_from_bundle(key, doc.title);
-                if (title !== false) {
-                    could_decrypt = true;
-                    doc.title = title;
-                    // any post processing on the decrypted search index should be done here
-                    let content = decrypt_content_from_bundle(key, doc.text);
-                    if (content !== false) {
-                        doc.text = content;
-                        let location_bundle = doc.location;
-                        let location_sep = location_bundle.indexOf(';')
-                        if (location_sep !== -1) {
-                            let toc_bundle = location_bundle.substring(location_sep+1)
-                            let location_doc = location_bundle.substring(0,location_sep)
-                            let toc_url = decrypt_content_from_bundle(key, toc_bundle);
-                            if (toc_url !== false) {
-                                doc.location = location_doc + toc_url;
-                            }
-                        }
+            let doc = sessionIndex.docs[i];
+            let location_sep = doc.location.indexOf(';');
+            if (location_sep !== -1) {
+                let location_id = doc.location.substring(0,location_sep);
+                let location_bundle = doc.location.substring(location_sep+1);
+                if (location_id in keys) {
+                    let key = keys[location_id];
+                    doc.location = decrypt_content_from_bundle(key, location_bundle);
+                    doc.text = decrypt_content_from_bundle(key, doc.text);
+                    doc.title = decrypt_content_from_bundle(key, doc.title);
+                    if (doc.title !== false) {
+                        could_decrypt = true;
                     }
                 }
             }
@@ -278,14 +269,14 @@ function decryptor_reaction(key_or_keys, password_input, fallback_used=false) {
             {% if remember_password -%}
             setKeys(key_or_keys);
             {%- endif %}
+            {% if experimental -%}
+            decrypt_search(key_or_keys);
+            {%- endif %}
         } else {
             key = key_or_keys;
         }
 
         // continue to decrypt others parts
-        {% if experimental -%}
-        //decrypt_search(key, location_path);
-        {%- endif %}
         {% if encrypted_something -%}
         let encrypted_something = {{ encrypted_something }};
         decrypt_somethings(key, encrypted_something);

encryptcontent/plugin.py

@@ -626,30 +626,36 @@ def on_page_markdown(self, markdown, page, config, **kwargs):
             del page.meta['encryption_info_message']
 
         if encryptcontent.get('password'):
-            if encryptcontent['password'] not in self.setup['password_keys']:
+            index = encryptcontent['password']
+            if index not in self.setup['password_keys']:
                 new_entry = {}
                 self.keystore_id += 1
                 new_entry['id'] = quote(self.config['remember_suffix'] + str(self.keystore_id), safe='~()*!\'')
                 new_entry['key'] = get_random_bytes(32)
-                self.__add_to_keystore__((KS_PASSWORD,password), new_entry['key'], new_entry['id'], encryptcontent['password'])
-                self.setup['password_keys'][encryptcontent['password']] = new_entry
+                self.__add_to_keystore__((KS_PASSWORD,index), new_entry['key'], new_entry['id'], index)
+                self.setup['password_keys'][index] = new_entry
             encryptcontent['type'] = 'password'
-            encryptcontent['key'] = self.setup['password_keys'][encryptcontent['password']]['key']
+            encryptcontent['key'] = self.setup['password_keys'][index]['key']
+            encryptcontent['id'] = self.setup['password_keys'][index]['id']
             setattr(page, 'encryptcontent', encryptcontent)
         elif encryptcontent.get('level'):
+            index = encryptcontent['level']
             encryptcontent['type'] = 'level'
-            encryptcontent['key'] = self.setup['level_keys'][encryptcontent['level']]['key']
+            encryptcontent['key'] = self.setup['level_keys'][index]['key']
+            encryptcontent['id'] = self.setup['level_keys'][index]['id']
             setattr(page, 'encryptcontent', encryptcontent)
         elif encryptcontent.get('obfuscate'):
-            if encryptcontent['obfuscate'] not in self.setup['obfuscate_keys']:
+            index = encryptcontent['obfuscate']
+            if index not in self.setup['obfuscate_keys']:
                 new_entry = {}
                 self.keystore_id += 1
                 new_entry['id'] = quote(self.config['remember_suffix'] + str(self.keystore_id), safe='~()*!\'')
                 new_entry['key'] = get_random_bytes(32)
-                self.__add_to_keystore__((KS_OBFUSCATE,encryptcontent['obfuscate']), new_entry['key'], new_entry['id'], encryptcontent['obfuscate'])
-                self.setup['obfuscate_keys'][encryptcontent['obfuscate']] = new_entry
+                self.__add_to_keystore__((KS_OBFUSCATE,index), new_entry['key'], new_entry['id'], index)
+                self.setup['obfuscate_keys'][index] = new_entry
             encryptcontent['type'] = 'obfuscate'
-            encryptcontent['key'] = self.setup['obfuscate_keys'][encryptcontent['obfuscate']]['key']
+            encryptcontent['key'] = self.setup['obfuscate_keys'][index]['key']
+            encryptcontent['id'] = self.setup['obfuscate_keys'][index]['id']
             setattr(page, 'encryptcontent', encryptcontent)
 
         return markdown
@@ -830,7 +836,7 @@ def on_post_page(self, output_content, page, config, **kwargs):
 
         if hasattr(page, 'encryptcontent'):
             location = page.url.lstrip('/')
-            self.setup['locations'][location] = page.encryptcontent['key']
+            self.setup['locations'][location] = (page.encryptcontent['key'], page.encryptcontent['id'])
             delattr(page, 'encryptcontent')
 
             if self.config['sign_files']:
@@ -891,20 +897,21 @@ def on_post_build(self, config, **kwargs):
             for entry in search_entries['docs'].copy(): #iterate through all entries of search_index
                 for location in self.setup['locations'].keys():
                     if entry['location'] == location or entry['location'].startswith(location+"#"): #find the ones located at encrypted pages
-                        page_key = self.setup['locations'][location]
+                        page_key = self.setup['locations'][location][0]
+                        page_id = self.setup['locations'][location][1]
                         if self.config['search_index'] == 'encrypted':
                             search_entries['docs'].remove(entry)
                         elif self.config['search_index'] == 'dynamically' and page_key is not None:
-                            #encrypt text/title/location(anchor only)
+                            #encrypt text/title/location
                             text = entry['text']
                             title = entry['title']
-                            toc_anchor = entry['location'].replace(location, '')
+                            location = entry['location']
+                            code = self.__encrypt_text__(location, page_key)
+                            entry['location'] = page_id + ';' + ';'.join(code) # add encryptcontent_id
                             code = self.__encrypt_text__(text, page_key )
                             entry['text'] = ';'.join(code)
                             code = self.__encrypt_text__(title, page_key)
                             entry['title'] = ';'.join(code)
-                            code = self.__encrypt_text__(toc_anchor, page_key)
-                            entry['location'] = location + ';' + ';'.join(code)
                         break
             self.setup['locations'].clear()