'),
17 | title: 'Code',
18 | }
19 |
20 | export const heading1 = {
21 | icon: 'H1',
22 | result: () => exec(formatBlock, ''),
23 | title: 'Heading 1',
24 | }
25 |
26 | export const heading2 = {
27 | icon: 'H2',
28 | result: () => exec(formatBlock, ''),
29 | title: 'Heading 2',
30 | }
31 |
32 | export const image = {
33 | icon: '📷',
34 | result: () => {
35 | const url = window.prompt('Enter the image URL')
36 | if (url) exec('insertImage', url)
37 | },
38 | title: 'Image',
39 | }
40 |
41 | export const italic = {
42 | icon: 'I',
43 | result: () => exec('italic'),
44 | state: () => queryCommandState('italic'),
45 | title: 'Italic',
46 | }
47 |
48 | export const line = {
49 | icon: '―',
50 | result: () => exec('insertHorizontalRule'),
51 | title: 'Horizontal Line',
52 | }
53 |
54 | export const link = {
55 | icon: '🔗',
56 | result: () => {
57 | const url = window.prompt('Enter the link URL')
58 | if (url) exec('createLink', url)
59 | },
60 | title: 'Link',
61 | }
62 |
63 | export const olist = {
64 | icon: '#',
65 | result: () => exec('insertOrderedList'),
66 | title: 'Ordered List',
67 | }
68 |
69 | export const paragraph = {
70 | icon: '¶',
71 | result: () => exec(formatBlock, '
'),
72 | title: 'Paragraph',
73 | }
74 |
75 | export const quote = {
76 | icon: '“ ”',
77 | result: () => exec(formatBlock, '
'),
78 | title: 'Quote',
79 | }
80 |
81 | export const strikethrough = {
82 | icon: 'S',
83 | result: () => exec('strikeThrough'),
84 | state: () => queryCommandState('strikeThrough'),
85 | title: 'Strike-through',
86 | }
87 |
88 | export const ulist = {
89 | icon: '•',
90 | result: () => exec('insertUnorderedList'),
91 | title: 'Unordered List',
92 | }
93 |
94 | export const underline = {
95 | icon: 'U',
96 | result: () => exec('underline'),
97 | state: () => queryCommandState('underline'),
98 | title: 'Underline',
99 | }
100 |
101 | export const defaultActions = {
102 | bold,
103 | code,
104 | heading1,
105 | heading2,
106 | image,
107 | italic,
108 | line,
109 | link,
110 | olist,
111 | paragraph,
112 | quote,
113 | strikethrough,
114 | ulist,
115 | underline,
116 | }
117 |
--------------------------------------------------------------------------------
/lib/pell/pell.css:
--------------------------------------------------------------------------------
1 | .pell {
2 | border: 1px solid rgba(10, 10, 10, 0.1);
3 | box-sizing: border-box;
4 | }
5 |
6 | .pell-content {
7 | box-sizing: border-box;
8 | height: 300px;
9 | outline: 0;
10 | overflow-y: auto;
11 | padding: 10px;
12 | }
13 |
14 | .pell-actionbar {
15 | background-color: #FFF;
16 | border-bottom: 1px solid rgba(10, 10, 10, 0.1);
17 | }
18 |
19 | .pell-button {
20 | background-color: transparent;
21 | border: none;
22 | cursor: pointer;
23 | height: 30px;
24 | outline: 0;
25 | width: 30px;
26 | vertical-align: bottom;
27 | }
28 |
29 | .pell-button-selected {
30 | background-color: #F0F0F0;
31 | }
32 |
--------------------------------------------------------------------------------
/lib/pell/pell.js:
--------------------------------------------------------------------------------
1 | import {
2 | defaultActions,
3 | } from './actions.js'
4 |
5 | import {
6 | addEventListener,
7 | appendChild,
8 | createElement,
9 | defaultParagraphSeparatorString,
10 | exec,
11 | formatBlock,
12 | queryCommandValue,
13 | } from './utilities.js'
14 |
15 | const defaultClasses = {
16 | actionbar: 'pell-actionbar',
17 | button: 'pell-button',
18 | content: 'pell-content',
19 | selected: 'pell-button-selected',
20 | }
21 |
22 | export const init = settings => {
23 | const actions = settings.actions
24 | ? (
25 | settings.actions.map(action => {
26 | if (typeof action === 'string') return defaultActions[action]
27 | else if (defaultActions[action.name]) return { ...defaultActions[action.name], ...action }
28 | return action
29 | })
30 | )
31 | : Object.keys(defaultActions).map(action => defaultActions[action])
32 |
33 | const classes = { ...defaultClasses, ...settings.classes }
34 |
35 | const defaultParagraphSeparator = settings[defaultParagraphSeparatorString] || 'div'
36 |
37 | const actionbar = createElement('div')
38 | actionbar.className = classes.actionbar
39 | appendChild(settings.element, actionbar)
40 |
41 | const content = settings.element.content = createElement('div')
42 | content.contentEditable = true
43 | content.className = classes.content
44 | content.oninput = ({ target: { firstChild } }) => {
45 | if (firstChild && firstChild.nodeType === 3) exec(formatBlock, `<${defaultParagraphSeparator}>`)
46 | else if (content.innerHTML === '
') content.innerHTML = ''
47 | settings.onChange(content.innerHTML)
48 | }
49 | content.onkeydown = event => {
50 | if (event.key === 'Enter' && queryCommandValue(formatBlock) === 'blockquote') {
51 | setTimeout(() => exec(formatBlock, `<${defaultParagraphSeparator}>`), 0)
52 | }
53 | }
54 | appendChild(settings.element, content)
55 |
56 | actions.forEach(action => {
57 | const button = createElement('button')
58 | button.className = classes.button
59 | button.innerHTML = action.icon
60 | button.title = action.title
61 | button.setAttribute('type', 'button')
62 | button.onclick = () => action.result() && content.focus()
63 |
64 | if (action.state) {
65 | const handler = () => button.classList[action.state() ? 'add' : 'remove'](classes.selected)
66 | addEventListener(content, 'keyup', handler)
67 | addEventListener(content, 'mouseup', handler)
68 | addEventListener(button, 'click', handler)
69 | }
70 |
71 | appendChild(actionbar, button)
72 | })
73 |
74 | if (settings.styleWithCSS) exec('styleWithCSS')
75 | exec(defaultParagraphSeparatorString, defaultParagraphSeparator)
76 |
77 | return settings.element
78 | }
79 |
80 | export default {
81 | init, exec
82 | }
83 |
--------------------------------------------------------------------------------
/lib/pell/utilities.js:
--------------------------------------------------------------------------------
1 | export const addEventListener = (parent, type, listener) => parent.addEventListener(type, listener)
2 |
3 | export const appendChild = (parent, child) => parent.appendChild(child)
4 |
5 | export const createElement = tag => document.createElement(tag)
6 |
7 | export const defaultParagraphSeparatorString = 'defaultParagraphSeparator'
8 |
9 | export const exec = (command, value = null) => document.execCommand(command, false, value)
10 |
11 | export const formatBlock = 'formatBlock'
12 |
13 | export const queryCommandState = command => document.queryCommandState(command)
14 |
15 | export const queryCommandValue = command => document.queryCommandValue(command)
16 |
--------------------------------------------------------------------------------
/manifest.json:
--------------------------------------------------------------------------------
1 | {
2 | "short_name": "CDEncrypt",
3 | "name": "CDEncrypt",
4 | "icons": [
5 | {
6 | "src":"img/icon.png",
7 | "sizes": "180x180"
8 | }
9 | ],
10 | "start_url": "/",
11 | "display": "standalone"
12 | }
13 |
--------------------------------------------------------------------------------
/src/app.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Software License Agreement (MIT License)
3 | *
4 | * Author: Duke Fong
5 | */
6 |
7 | /* Message format: 'cde|' + msgpack('message body...') or msgpack:
8 | * {
9 | * b: 'message body...',
10 | * f: {
11 | * file_name: {type: 'image/jpeg', data: Uint8Array}
12 | * },
13 | * // v: 0, // version
14 | * // fonts: {
15 | * // font_name: Uint8Array
16 | * // }
17 | * }
18 | */
19 |
20 | import pell from '../lib/pell/pell.js'
21 | import { L } from './lang/lang.js'
22 | import {
23 | sha256, aes256, aes256_blk0_d,
24 | dat2hex, dat2str, str2dat,
25 | escape_html, date2num,
26 | read_file, download,
27 | readable_size, linkable } from './utils/helper.js'
28 | import { Idb } from './utils/idb.js';
29 |
30 |
31 | let first_install = false;
32 | let editor;
33 | let in_plaintext_ori = ''; // before convert links by anchorme
34 |
35 | let db = null;
36 | let pw_list = []; // password list
37 | let pw_def = null; // default password
38 |
39 | let in_prj = { b: '', f: {} };
40 | let in_prj_url_map = {};
41 |
42 | let out_pw = null; // password for edit & reply
43 | let out_prj = { b: '', f: {} };
44 | let out_prj_url_map = {}; // filename: blob_url
45 |
46 |
47 | function html_blob_conv(html, url_map, cde2blob=true) {
48 | let parser = new DOMParser()
49 | let doc = parser.parseFromString(html, "text/html");
50 | for (let a of ['src', 'href', 'poster']) {
51 | for (let elem of doc.querySelectorAll(`[${a}]`)) {
52 | let url = elem.getAttribute(a);
53 | if (cde2blob) {
54 | if (url.search("cde:") == 0) {
55 | let name = url.slice(4);
56 | if (!url_map[name]) {
57 | console.warn(`lost file: ${name}`);
58 | continue;
59 | }
60 | elem.setAttribute(a, url_map[name]);
61 | }
62 | } else {
63 | if (url.search("blob:") == 0) {
64 | let filtered = Object.entries(url_map).filter(([k,v]) => v == url);
65 | let fname = filtered.length ? filtered[0][0] : null;
66 | elem.setAttribute(a, `cde:${fname}`);
67 | }
68 | }
69 | }
70 | }
71 | return doc.body.innerHTML;
72 | }
73 |
74 | async function to_local() {
75 | let parser = new DOMParser()
76 | let doc = parser.parseFromString(editor.content.innerHTML, "text/html");
77 | for (let a of ['src', 'href', 'poster']) {
78 | for (let elem of doc.querySelectorAll(`[${a}]`)) {
79 | let url = elem.getAttribute(a);
80 | if (url.search("blob:") == 0)
81 | continue;
82 | console.log('to_local:', url);
83 | try {
84 | let loc = new URL(url);
85 | if (loc.protocol == 'http:') {
86 | console.log(`to_local: force https: ${loc.href}`)
87 | loc.protocol = 'https:';
88 | }
89 | const response = await fetch(loc);
90 | const blob = await response.blob();
91 | const ab = await new Response(blob).arrayBuffer();
92 | const u8a = new Uint8Array(ab);
93 | let sha = await sha256(u8a);
94 | let name = `_${Object.keys(out_prj.f).length+1}.${blob.type.split('/')[1]}`;
95 | out_prj_url_map[name] = URL.createObjectURL(blob);
96 | out_prj.f[name] = {'type': blob.type, 'data': u8a};
97 | elem.setAttribute(a, out_prj_url_map[name]);
98 | } catch (e) {
99 | if (!confirm(`${L('Download resource error, continue?\n(Please try browser plug-ins e.g. CORS Unblock.)')}\n${url}: ${e}`))
100 | return;
101 | }
102 | }
103 | }
104 | editor.content.innerHTML = doc.body.innerHTML;
105 | out_prj.b = html_blob_conv(editor.content.innerHTML, out_prj_url_map, false);
106 | await db.set('tmp', 'b', out_prj.b);
107 | await db.set('tmp', 'f', out_prj.f);
108 | update_out_files();
109 | alert(L('OK'));
110 | }
111 |
112 |
113 | window.addEventListener('load', async function() {
114 | console.log("load app");
115 | db = await new Idb();
116 | pw_list = await db.get('var', 'pw_list');
117 | pw_def = await db.get('var', 'pw_def');
118 | if (!pw_list) {
119 | first_install = true;
120 | pw_list = [];
121 | await db.set('var', 'pw_list', pw_list);
122 | }
123 | if (!pw_def && pw_list.length) {
124 | pw_def = pw_list[0];
125 | await db.set('var', 'pw_def', pw_def);
126 | }
127 | out_pw = pw_def; // use default passwd
128 | update_out_pw();
129 |
130 | out_prj.b = await db.get('tmp', 'b') || '';
131 | out_prj.f = await db.get('tmp', 'f') || {};
132 | for (let name in out_prj.f) {
133 | let f = out_prj.f[name];
134 | let blob = new Blob([f['data']], {type: f['type']});
135 | out_prj_url_map[name] = URL.createObjectURL(blob);
136 | }
137 |
138 | editor = pell.init({
139 | element: document.getElementById('editor'),
140 | onChange: async html => {
141 | out_prj.b = html_blob_conv(html, out_prj_url_map, false);
142 | await db.set('tmp', 'b', out_prj.b);
143 | },
144 | defaultParagraphSeparator: 'p',
145 | styleWithCSS: false,
146 | actions: [
147 | 'bold',
148 | 'code',
149 | 'heading1',
150 | 'heading2',
151 | 'image',
152 | 'italic',
153 | 'line',
154 | 'link',
155 | 'olist',
156 | 'paragraph',
157 | 'quote',
158 | 'strikethrough',
159 | 'ulist',
160 | 'underline',
161 | {
162 | name: 'backColor',
163 | icon: 'A',
164 | title: 'Highlight Color',
165 | result: () => pell.exec('backColor', 'pink')
166 | },
167 | {
168 | name: 'default',
169 | icon: '',
170 | title: 'Remove Format',
171 | result: () => pell.exec('removeFormat')
172 | }
173 | ],
174 | classes: {
175 | actionbar: 'pell-actionbar',
176 | button: 'pell-button',
177 | content: 'pell-content',
178 | selected: 'pell-button-selected'
179 | }
180 | });
181 |
182 | editor.content.innerHTML = html_blob_conv(out_prj.b, out_prj_url_map);
183 | update_out_files();
184 |
185 | update_modal_passwd_list();
186 | update_modal_passwd_sel();
187 |
188 | if (location.protocol != 'https:' && location.hostname != 'localhost') {
189 | alert(L('Error: only support https'));
190 | location.href = location.href.replace("http://", "https://");
191 | }
192 |
193 | await decrypt(location.hash.slice(1));
194 | init_sw();
195 | });
196 |
197 | document.getElementById('clean_all').onclick = async function() {
198 | if (!confirm(L('Are you sure you want to clean all?')))
199 | return;
200 | await db.clear('var');
201 | await db.clear('tmp');
202 | alert(L('Clean all finished'));
203 | location = location.origin + location.pathname;
204 | };
205 |
206 | document.getElementById('out_add_file').onchange = async function() {
207 | for (let file of this.files) {
208 | let dat = await read_file(file);
209 | out_prj.f[file.name] = {'type': file.type, 'data': dat};
210 | out_prj_url_map[file.name] = URL.createObjectURL(file);
211 | }
212 | update_out_files();
213 | await db.set('tmp', 'f', out_prj.f);
214 | this.value = '';
215 | };
216 |
217 | function update_out_files() {
218 | let list = document.getElementById('out_files');
219 | list.innerHTML = '';
220 |
221 | for (let name in out_prj.f) {
222 | let name_e = escape_html(name);
223 | let is_image = out_prj.f[name]['type'].startsWith('image');
224 | let is_video = out_prj.f[name]['type'].startsWith('video');
225 | let html = `
226 | `;
238 | list.insertAdjacentHTML('beforeend', html);
239 | list.lastElementChild.getElementsByTagName("button")[0].onclick = function() {
240 | if (is_image) {
241 | pell.exec('insertImage', out_prj_url_map[name]);
242 | } else if (is_video) {
243 | let html = ``;
244 | pell.exec('insertHTML', html)
245 | }
246 | };
247 | list.lastElementChild.getElementsByTagName("button")[1].onclick = async function() {
248 | URL.revokeObjectURL(out_prj_url_map[name]);
249 | delete out_prj.f[name];
250 | delete out_prj_url_map[name];
251 | await db.set('tmp', 'f', out_prj.f);
252 | update_out_files();
253 | };
254 | }
255 | }
256 |
257 | function update_in_files() {
258 | let list = document.getElementById('in_files');
259 | list.innerHTML = '';
260 | for (let name in in_prj.f) {
261 | let f = in_prj.f[name];
262 | let blob_url = in_prj_url_map[name];
263 | list.innerHTML += `
264 | `;
272 | }
273 | }
274 |
275 | function update_modal_passwd_list() {
276 | let list = document.getElementById('passwd_list');
277 | list.innerHTML = '';
278 |
279 | for (let i = 0; i < pw_list.length; i++) { // escape
280 | let pw = pw_list[i];
281 | let html = `
282 | `;
290 | list.insertAdjacentHTML('beforeend', html);
291 | list.lastElementChild.getElementsByTagName("button")[0].onclick = async function() {
292 | pw_list = pw_list.filter(val => val != pw);
293 | await db.set('var', 'pw_list', pw_list);
294 | if (pw_def == pw) {
295 | pw_def = null;
296 | if (pw_list.length)
297 | pw_def = pw_list[0];
298 | await db.set('var', 'pw_def', pw_def);
299 | }
300 | if (out_pw == pw) {
301 | out_pw = pw_def;
302 | update_out_pw();
303 | }
304 | update_modal_passwd_list();
305 | update_modal_passwd_sel();
306 | };
307 | }
308 | }
309 |
310 | function update_modal_passwd_sel() {
311 | let list = document.getElementById('passwd_sel');
312 | list.innerHTML = '';
313 |
314 | for (let i = 0; i < pw_list.length; i++) { // escape
315 | let pw = pw_list[i];
316 | let html = `
317 | `;
325 | list.insertAdjacentHTML('beforeend', html);
326 | list.lastElementChild.getElementsByTagName("button")[0].onclick = async function() {
327 | out_pw = pw_def = pw;
328 | await db.set('var', 'pw_def', pw_def);
329 | modal_close('modal_passwd_sel');
330 | update_out_pw();
331 | };
332 | }
333 | }
334 |
335 | async function _add_passwd(pw) {
336 | // remove exist first: move exist to top
337 | pw_list = pw_list.filter(val => val != pw);
338 | pw_list.unshift(pw);
339 | await db.set('var', 'pw_list', pw_list);
340 | update_modal_passwd_list();
341 | update_modal_passwd_sel();
342 | if (!out_pw)
343 | out_pw = pw;
344 | update_out_pw();
345 | }
346 |
347 | window.add_passwd = async () => {
348 | let pw = prompt(L('New password:'));
349 | if (!pw)
350 | return;
351 | await _add_passwd(pw);
352 | };
353 |
354 | function update_out_pw() {
355 | if (out_pw) {
356 | let pw_e = escape_html(out_pw.slice(0,3));
357 | let i = pw_list.findIndex(val => val == out_pw);
358 | document.getElementById('out_pw').innerHTML = `#${i}: ${pw_e}…`;
359 | } else {
360 | document.getElementById('out_pw').innerHTML = `--`;
361 | }
362 | }
363 |
364 | // share_url, show_url, share_file, download_file
365 | async function encrypt(method='show_url') {
366 | if (!out_pw) {
367 | alert(L('Please set password'));
368 | return;
369 | }
370 | if (!out_prj.b && !Object.keys(out_prj.f).length) {
371 | alert(L('Please input text'));
372 | return;
373 | }
374 | if (method.startsWith('share') && !navigator.share) {
375 | alert(L('Sharing is not supported'));
376 | return;
377 | }
378 |
379 | const key = await sha256(str2dat(out_pw));
380 | const header = str2dat('cde|');
381 | const content = msgpack.encode(Object.keys(out_prj.f).length ? out_prj : out_prj.b);
382 | const combined = new Uint8Array([...header, ...content]);
383 | const out = await aes256(combined, key);
384 | document.getElementById('show_out_url').innerHTML = '';
385 |
386 | if (method.search('url') >= 0 && out.length >= 4000) {
387 | if (!confirm(L('Data is too large for URL encoding, continue?')))
388 | return;
389 | }
390 |
391 | if (method == 'share_url') {
392 | let b64 = base64js.fromByteArray(out);
393 | navigator.share({ url: `${location.origin+location.pathname}#${b64}` });
394 | return;
395 | }
396 |
397 | if (method == 'show_url') {
398 | let b64 = base64js.fromByteArray(out);
399 | let url = `${location.origin+location.pathname}#${b64}`;
400 | document.getElementById('show_out_url').innerHTML = url;
401 | navigator.clipboard.writeText(url).then(function() {
402 | alert(L('Copy to clipboard successed'));
403 | }, function() {
404 | alert(L('Copy to clipboard failed'));
405 | });
406 | return;
407 | }
408 |
409 | let fname = document.getElementById('out_fname').value;
410 | if (!fname)
411 | fname = date2num();
412 |
413 | if (method == 'share_file') {
414 | fname += '.txt';
415 |
416 | let file = new File([out], fname, {type: 'text/plain'});
417 | console.log("share file:", file);
418 | let data = {files: [file]};
419 |
420 | if (!navigator.canShare || !navigator.canShare(data)) {
421 | // Search: Web Share API - Level 2, permitted extensions
422 | // only image, video, audio and text files can be shared
423 | alert(L('File sharing is not supported'));
424 | return;
425 | }
426 |
427 | navigator.share(data)
428 | .then(() => {
429 | console.log('Successfully sent share');
430 | })
431 | .catch((err) => {
432 | console.log('Error sharing: ', err);
433 | });
434 | return;
435 | }
436 |
437 | if (method == 'download_file') {
438 | download(out, fname);
439 | return;
440 | }
441 | };
442 |
443 | async function _decrypt(dat, pw) {
444 | let key = await sha256(str2dat(pw));
445 | let content;
446 | try {
447 | let blk0 = await aes256_blk0_d(dat.slice(0, 16), key); // try to decrypt the first block
448 | let header = blk0.slice(0, 4);
449 | if (dat2str(header) != 'cde|')
450 | return null;
451 | let combined = await aes256(dat, key, 'decrypt');
452 | content = combined.slice(4);
453 | } catch (e) {
454 | console.log('decrypt err');
455 | return null;
456 | }
457 |
458 | try {
459 | return msgpack.decode(content);
460 | } catch (e) {
461 | console.log('msgpack decode err');
462 | return null;
463 | }
464 | }
465 |
466 | async function decrypt(dat) {
467 | if (typeof dat == 'string') {
468 | let str = dat;
469 | /*
470 | if (!str) {
471 | let c = await navigator.clipboard.readText();
472 | let hash_pos = c.search('#');
473 | if (hash_pos < 0)
474 | return;
475 | str = c.slice(hash_pos + 1);
476 | } */
477 | if (!str)
478 | return;
479 | if (str.startsWith(':')) {
480 | if (str.startsWith(':http') || str.startsWith(':/') || str.startsWith(':.'))
481 | await fetch_remote(str.slice(1));
482 | else
483 | await fetch_remote('https://' + str.slice(1));
484 | return;
485 | }
486 |
487 | try {
488 | dat = base64js.toByteArray(str);
489 | } catch (e) {
490 | alert(L('The Base64 string is invalid'));
491 | return;
492 | }
493 | }
494 |
495 | let pw = null;
496 | let pw_index = -1;
497 | let ret;
498 | for (let i = 0; i < pw_list.length; i++) {
499 | pw = pw_list[i];
500 | ret = await _decrypt(dat, pw);
501 | if (ret) {
502 | pw_index = i;
503 | break;
504 | }
505 | }
506 | if (pw_index == -1) {
507 | while (true) {
508 | pw = prompt(L('No password suitable, add new password:'));
509 | if (!pw)
510 | return;
511 | ret = await _decrypt(dat, pw);
512 | if (ret) {
513 | modal_close('modal_fetch');
514 | break;
515 | }
516 | }
517 | await _add_passwd(pw);
518 | pw_index = 0;
519 | }
520 |
521 | if (typeof ret == 'string')
522 | in_prj = { b: ret, f: {} }
523 | else
524 | in_prj = ret;
525 | let pw_e = escape_html(pw.slice(0,3));
526 | let i = pw_list.findIndex(val => val == pw);
527 | document.getElementById('in_cur_pw').innerHTML = `#${i}: ${pw_e}…`;
528 | out_pw = pw;
529 | update_out_pw();
530 |
531 | in_prj_url_map = {};
532 | let list = document.getElementById('in_files');
533 | list.innerHTML = '';
534 | for (let name in in_prj.f) {
535 | let f = in_prj.f[name];
536 | let blob = new Blob([f['data']], {type: f['type']});
537 | in_prj_url_map[name] = URL.createObjectURL(blob);
538 | }
539 | update_in_files();
540 | in_plaintext_ori = html_blob_conv(in_prj.b, in_prj_url_map);
541 | document.getElementById('in_plaintext').innerHTML = in_plaintext_ori;
542 | linkable(document.getElementById('in_plaintext'));
543 | }
544 |
545 | async function fetch_remote(url) {
546 | modal_open('modal_fetch');
547 | let controller = new AbortController();
548 | document.getElementById('fetch_progress').value = 0;
549 | document.getElementById('fetch_progress_text').innerHTML = '0%';
550 | document.getElementById('fetch_size').innerHTML = '';
551 | document.getElementById('fetch_status').innerHTML = '';
552 | document.getElementById("fetch_ok").disabled = true;
553 | for (let elem of document.getElementsByName('fetch_cancel')) {
554 | elem.onclick = () => {
555 | modal_close('modal_fetch');
556 | controller.abort();
557 | }
558 | }
559 | let response;
560 | try {
561 | console.log(`fetch_remote: ${url}`);
562 | response = await fetch(url, {signal: controller.signal});
563 | } catch (e) {
564 | document.getElementById('fetch_status').innerHTML = `${L('Error')}: ${e}`;
565 | return;
566 | }
567 | const reader = response.body.getReader();
568 | const total_len = +response.headers.get('Content-Length');
569 | let received_len = 0;
570 | let chunks = [];
571 | while(true) {
572 | try {
573 | const {done, value} = await reader.read();
574 | if (done)
575 | break;
576 | chunks.push(value);
577 | received_len += value.length;
578 | if (total_len > 0) {
579 | let progress = Math.round(received_len / total_len * 100);
580 | document.getElementById('fetch_progress').value = progress;
581 | document.getElementById('fetch_progress_text').innerHTML = `${progress}%`;
582 | }
583 | document.getElementById('fetch_size').innerHTML =
584 | `${L('Received')} ${readable_size(received_len)} / ${readable_size(total_len)}`;
585 | } catch (e) {
586 | console.log('fetch read catch', e);
587 | document.getElementById('fetch_status').innerHTML = `| ${L('Error')}: ${e}`;
588 | return;
589 | }
590 | }
591 | if (response.status !== 200) {
592 | document.getElementById('fetch_status').innerHTML = `| ${L('Error')}: ${response.status}`;
593 | return;
594 | }
595 | let dat = new Uint8Array(received_len);
596 | let pos = 0;
597 | for(let chunk of chunks) {
598 | dat.set(chunk, pos);
599 | pos += chunk.length;
600 | }
601 | document.getElementById('fetch_status').innerHTML = `| ${L('Done!')}`;
602 | document.getElementById("fetch_ok").disabled = false;
603 | document.getElementById("fetch_ok").onclick = async () => {
604 | await decrypt(dat);
605 | modal_close('modal_fetch');
606 | };
607 | }
608 |
609 | document.getElementById('in_add_file').onchange = async function() {
610 | if (!this.files.length)
611 | return;
612 | let dat = await read_file(this.files[0]);
613 | await decrypt(dat);
614 | this.value = '';
615 | };
616 |
617 | document.getElementById('in_add_text').onclick = async function() {
618 | let str = prompt(L('Input URL or Base64 string:'));
619 | if (!str)
620 | return;
621 | let hash_pos = str.search('#');
622 | if (hash_pos >= 0)
623 | str = str.slice(hash_pos + 1);
624 | await decrypt(str);
625 | };
626 |
627 | document.getElementById('re_edit').onclick = async function() {
628 | out_prj_url_map = in_prj_url_map;
629 | out_prj = in_prj;
630 | editor.content.innerHTML = in_plaintext_ori;
631 | update_out_files();
632 | await db.set('tmp', 'b', out_prj.b);
633 | await db.set('tmp', 'f', out_prj.f);
634 | alert(L('OK'));
635 | };
636 |
637 | document.getElementById('preview').onclick = async function() {
638 | in_prj_url_map = out_prj_url_map;
639 | in_prj = out_prj;
640 | in_plaintext_ori = editor.content.innerHTML;
641 | document.getElementById('in_plaintext').innerHTML = in_plaintext_ori;
642 | linkable(document.getElementById('in_plaintext'));
643 | update_in_files();
644 | document.getElementById('in_cur_pw').innerHTML = '--';
645 | alert(L('OK'));
646 | };
647 |
648 |
649 | document.getElementById('share_url').onclick = async () => await encrypt('share_url');
650 | document.getElementById('show_url').onclick = async () => await encrypt('show_url');
651 | document.getElementById('share_file').onclick = async () => await encrypt('share_file');
652 | document.getElementById('download_file').onclick = async () => await encrypt('download_file');
653 | document.getElementById('to_local').onclick = async () => await to_local();
654 |
655 | window.modal_open = id => document.getElementById(id).classList.add('is-active');
656 | window.modal_close = id => document.getElementById(id).classList.remove('is-active');
657 |
658 | function init_sw() {
659 | console.log('init_sw...');
660 | if ('serviceWorker' in navigator) {
661 | navigator.serviceWorker.register('/sw.js', {
662 | scope: '/'
663 | }).then(function(reg) {
664 | if (reg.installing) {
665 | console.log('Service worker installing');
666 | } else if (reg.waiting) {
667 | console.log('Service worker installed');
668 | } else if (reg.active) {
669 | console.log('Service worker active');
670 | }
671 | }).catch(function(error) {
672 | console.log('Registration failed with ' + error);
673 | });
674 |
675 | navigator.serviceWorker.addEventListener('controllerchange', () => {
676 | if (!first_install) {
677 | alert(L('Switching APP to new version.'));
678 | location.reload();
679 | }
680 | });
681 | }
682 | }
683 |
--------------------------------------------------------------------------------
/src/lang/lang.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Software License Agreement (MIT License)
3 | *
4 | * Author: Duke Fong
5 | */
6 |
7 | let trans_hk = {
8 | 'Passwords': '密碼',
9 | 'Open File': '文件導入',
10 | 'Input Text': '字符導入',
11 | 'Reload Page': '刷新頁面',
12 | 'Clean All': '清除所有數據',
13 |
14 | 'Plaintext': '明文',
15 | 'Use password': '使用密碼',
16 | 'Content': '內容',
17 | 'Files': '文件',
18 | 'Edit': '編輯',
19 | 'Preview': '預覽',
20 |
21 | 'Reply': '回覆',
22 | 'Add File': '添加文件',
23 | 'Save Resources Locally': '保存資源到本地',
24 | 'Share URL': '分享鏈接',
25 | 'Show URL': '顯示鏈接',
26 | 'Share File': '分享文件',
27 | 'Download File': '下載文件',
28 |
29 | 'Password List': '密碼列表',
30 | 'Add': '添加',
31 | 'Cancel': '取消',
32 | 'Password Select': '選擇密碼',
33 |
34 | 'Set': '選擇',
35 | 'Password': '密碼',
36 | 'Insert': '插入',
37 | 'Remove': '刪除',
38 |
39 | 'Download Progress': '下載進度',
40 | 'Received': '已接收',
41 | 'Done!': '完成！',
42 | 'Error': '出錯',
43 |
44 | 'Download resource error, continue?\n(Please try browser plug-ins e.g. CORS Unblock.)': '下載資源出錯，繼續？\n（請嘗試瀏覽器插件例如 CORS Unblock.）',
45 | 'Error: only support https': '錯誤：只支持 https',
46 | 'The Base64 string is invalid': 'Base64 字符串無效',
47 | 'File name, use date if empty': '文件名，留空使用日期',
48 | 'Are you sure you want to clean all?': '是否確認清除所有數據？',
49 | 'Clean all finished': '全部清除成功',
50 | 'Please set password': '請設置密碼',
51 | 'Please input text': '請輸入文字',
52 | 'Sharing is not supported': '不支持分享',
53 | 'Data is too large for URL encoding, continue?': '數據對於 URL 編碼過大，是否繼續？',
54 | 'Copy to clipboard successed': '成功複製到剪切板',
55 | 'Copy to clipboard failed': '複製到剪切板失敗',
56 | 'File sharing is not supported': '不支持的文件分享',
57 | 'No password suitable, add new password:': '無匹配的密碼，增加新密碼：',
58 | 'Input URL or Base64 string:': '請輸入 URL 或 Base64 字串：',
59 | 'New password:': '新密碼：',
60 |
61 | 'OK': '好',
62 | 'Switching APP to new version.': '切換 APP 至新版本'
63 | };
64 |
65 | // cat lang.js | cconv -f UTF8 -t UTF8-CN
66 | let trans_cn = {
67 | 'Passwords': '密码',
68 | 'Open File': '文件导入',
69 | 'Input Text': '字符导入',
70 | 'Reload Page': '刷新页面',
71 | 'Clean All': '清除所有数据',
72 |
73 | 'Plaintext': '明文',
74 | 'Use password': '使用密码',
75 | 'Content': '内容',
76 | 'Files': '文件',
77 | 'Edit': '编辑',
78 | 'Preview': '预览',
79 |
80 | 'Reply': '回覆',
81 | 'Add File': '添加文件',
82 | 'Save Resources Locally': '保存资源到本地',
83 | 'Share URL': '分享链接',
84 | 'Show URL': '显示链接',
85 | 'Share File': '分享文件',
86 | 'Download File': '下载文件',
87 |
88 | 'Password List': '密码列表',
89 | 'Add': '添加',
90 | 'Cancel': '取消',
91 | 'Password Select': '选择密码',
92 |
93 | 'Set': '选择',
94 | 'Password': '密码',
95 | 'Insert': '插入',
96 | 'Remove': '删除',
97 |
98 | 'Download Progress': '下载进度',
99 | 'Received': '已接收',
100 | 'Done!': '完成！',
101 | 'Error': '出错',
102 |
103 | 'Download resource error, continue?\n(Please try browser plug-ins e.g. CORS Unblock.)': '下载资源出错，继续？\n（请尝试浏览器插件例如 CORS Unblock.）',
104 | 'Error: only support https': '错误：只支持 https',
105 | 'The Base64 string is invalid': 'Base64 字符串无效',
106 | 'File name, use date if empty': '文件名，留空使用日期',
107 | 'Are you sure you want to clean all?': '是否确认清除所有数据？',
108 | 'Clean all finished': '全部清除成功',
109 | 'Please set password': '请设置密码',
110 | 'Please input text': '请输入文字',
111 | 'Sharing is not supported': '不支持分享',
112 | 'Data is too large for URL encoding, continue?': '数据对于 URL 编码过大，是否继续？',
113 | 'Copy to clipboard successed': '成功复制到剪切板',
114 | 'Copy to clipboard failed': '复制到剪切板失败',
115 | 'File sharing is not supported': '不支持的文件分享',
116 | 'No password suitable, add new password:': '无匹配的密码，增加新密码：',
117 | 'Input URL or Base64 string:': '请输入 URL 或 Base64 字串：',
118 | 'New password:': '新密码：',
119 |
120 | 'OK': '好',
121 | 'Switching APP to new version.': '切换 APP 至新版本'
122 | };
123 |
124 |
125 | let lang = 'en';
126 | if (navigator.language.startsWith('zh')) {
127 | lang = 'hk';
128 | if (navigator.language.includes('CN'))
129 | lang = 'cn';
130 | }
131 |
132 | function L(ori, mark=null) {
133 | if (lang == 'en')
134 | return ori;
135 | if (!mark)
136 | mark = ori;
137 | let ret = lang == 'hk' ? trans_hk[mark] : trans_cn[mark];
138 | return ret || ori;
139 | }
140 |
141 | export { L };
142 |
--------------------------------------------------------------------------------
/src/utils/helper.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Software License Agreement (MIT License)
3 | *
4 | * Author: Duke Fong
5 | */
6 |
7 | async function read_file(file) {
8 | return await new Promise((resolve, reject) => {
9 | let reader = new FileReader();
10 |
11 | reader.onload = () => {
12 | resolve(new Uint8Array(reader.result));
13 | };
14 | reader.onerror = reject;
15 | reader.readAsArrayBuffer(file);
16 | })
17 | }
18 |
19 | async function load_img(img, url) {
20 | let ret = -1;
21 | await new Promise(resolve => {
22 | img.src = url;
23 | img.onload = () => { ret = 0; resolve(); };
24 | img.onerror = () => { console.error(`load_img: ${url}`); resolve(); };
25 | });
26 | return ret;
27 | }
28 |
29 | function date2num() {
30 | let d = (new Date()).toLocaleString('en-GB');
31 | let s = d.split(/[^0-9]/);
32 | return `${s[2]}${s[1]}${s[0]}${s[4]}${s[5]}${s[6]}`;
33 | }
34 |
35 | async function sha256(dat) {
36 | const hashBuffer = await crypto.subtle.digest('SHA-256', dat);
37 | return new Uint8Array(hashBuffer);
38 | }
39 |
40 | async function aes256(dat, key, type='encrypt') {
41 | let iv = new Uint8Array(16); // zeros
42 | let _key = await crypto.subtle.importKey('raw', key, {name: 'AES-CBC'}, false, ['encrypt', 'decrypt']);
43 |
44 | if (type == 'encrypt')
45 | return new Uint8Array(await crypto.subtle.encrypt({name: 'AES-CBC', iv: iv}, _key, dat));
46 | else
47 | return new Uint8Array(await crypto.subtle.decrypt({name: 'AES-CBC', iv: iv}, _key, dat));
48 | }
49 |
50 | // decrypt the first block and trick the padding check
51 | async function aes256_blk0_d(dat, key) {
52 | let iv = new Uint8Array(16); // zeros
53 | let _key = await crypto.subtle.importKey('raw', key, {name: 'AES-CBC'}, false, ['encrypt', 'decrypt']);
54 |
55 | let pad_dat = new Uint8Array(16);
56 | for (let i = 0; i < 16; i++)
57 | pad_dat[i] = 16; // PKCS#7
58 | let pad_tmp = new Uint8Array(await crypto.subtle.encrypt({name: 'AES-CBC', iv: dat}, _key, pad_dat));
59 | let pad = pad_tmp.slice(0, 16);
60 | let dat_pad = new Uint8Array([...dat, ...pad]);
61 | return new Uint8Array(await crypto.subtle.decrypt({name: 'AES-CBC', iv: iv}, _key, dat_pad));
62 | }
63 |
64 | function dat2hex(dat, join='') {
65 | const dat_array = Array.from(dat);
66 | return dat_array.map(b => b.toString(16).padStart(2, '0')).join(join);
67 | }
68 |
69 | function dat2str(dat) {
70 | return new TextDecoder().decode(dat);
71 | }
72 |
73 | function str2dat(str) {
74 | let encoder = new TextEncoder();
75 | return encoder.encode(str);
76 | }
77 |
78 | // list: ['x', 'y']
79 | // map: {'rotation': 'r'}
80 | function cpy(dst, src, list, map = {}) {
81 | for (let i of list) {
82 | if (i in src)
83 | dst[i] = src[i];
84 | }
85 | for (let i in map) {
86 | if (i in src)
87 | dst[map[i]] = src[i];
88 | }
89 | }
90 |
91 | function download_url(data, fileName) {
92 | var a;
93 | a = document.createElement('a');
94 | a.href = data;
95 | a.download = fileName;
96 | document.body.appendChild(a);
97 | a.style = 'display: none';
98 | a.click();
99 | a.remove();
100 | };
101 |
102 | function download(data, fileName='dat.bin', mimeType='application/octet-stream') {
103 | var blob, url;
104 | blob = new Blob([data], {type: mimeType});
105 | url = window.URL.createObjectURL(blob);
106 | download_url(url, fileName);
107 | setTimeout(function() { return window.URL.revokeObjectURL(url); }, 1000);
108 | };
109 |
110 | function escape_html(unsafe) {
111 | return unsafe
112 | .replace(/&/g, "&")
113 | .replace(//g, ">")
115 | .replace(/"/g, """)
116 | .replace(/'/g, "'");
117 | }
118 |
119 | function readable_size(bytes, fixed=3, si=true) {
120 | var thresh = si ? 1000 : 1024;
121 | if(Math.abs(bytes) < thresh) {
122 | return bytes + ' B';
123 | }
124 | var units = si
125 | ? ['kB','MB','GB','TB','PB','EB','ZB','YB']
126 | : ['KiB','MiB','GiB','TiB','PiB','EiB','ZiB','YiB'];
127 | var u = -1;
128 | do {
129 | bytes /= thresh;
130 | ++u;
131 | } while(Math.abs(bytes) >= thresh && u < units.length - 1);
132 | return bytes.toFixed(fixed)+' '+units[u];
133 | }
134 |
135 | function walk(el, fn) {
136 | for (let i = 0, len = el.childNodes.length; i < len; i++) {
137 | let node = el.childNodes[i];
138 | if (node.nodeType === 3)
139 | fn(node);
140 | else if (node.nodeType === 1 && node.nodeName !== "SCRIPT")
141 | walk(node, fn);
142 | }
143 | }
144 |
145 | function linkable(el) {
146 | walk(el, function(n) {
147 | let replacementNode = document.createElement('span');
148 | let newHtml = anchorme(n.textContent);
149 | n.parentNode.insertBefore(replacementNode, n);
150 | n.parentNode.removeChild(n);
151 | replacementNode.outerHTML = newHtml;
152 | });
153 | }
154 |
155 | export {
156 | read_file, load_img, date2num,
157 | sha256, aes256, aes256_blk0_d,
158 | dat2hex, dat2str, str2dat,
159 | cpy,
160 | download,
161 | escape_html, readable_size,
162 | walk, linkable
163 | };
164 |
--------------------------------------------------------------------------------
/src/utils/idb.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Software License Agreement (MIT License)
3 | *
4 | * Author: Duke Fong
5 | */
6 |
7 | class Idb {
8 | constructor(db_name = 'cde', store_list = ['var', 'tmp']) {
9 |
10 | let _dbp = new Promise((resolve, reject) => {
11 | const openreq = indexedDB.open(db_name, 1);
12 | openreq.onerror = () => reject(openreq.error);
13 | openreq.onsuccess = () => resolve(openreq.result);
14 | // First time setup: create an empty object store
15 | openreq.onupgradeneeded = () => {
16 | console.log(`db: ${db_name}: create stores: ${store_list}`);
17 | for (let i in store_list)
18 | openreq.result.createObjectStore(store_list[i]);
19 | };
20 | });
21 |
22 | return (async () => {
23 | this.db = await _dbp;
24 | return this;
25 | })();
26 | }
27 |
28 | trans(store_name, type) {
29 | let store;
30 | let _sp = new Promise((resolve, reject) => {
31 | const transaction = this.db.transaction(store_name, type);
32 | transaction.oncomplete = () => resolve();
33 | transaction.onabort = transaction.onerror = () => reject(transaction.error);
34 | store = transaction.objectStore(store_name);
35 | });
36 | return {_sp, store};
37 | }
38 |
39 | async get(store_name, key) {
40 | let {_sp, store} = this.trans(store_name, 'readonly');
41 | let req = store.get(key);
42 | await _sp;
43 | return req.result;
44 | }
45 | async set(store_name, key, value) {
46 | let {_sp, store} = this.trans(store_name, 'readwrite');
47 | store.put(value, key);
48 | await _sp;
49 | }
50 | async del(store_name, key) {
51 | let {_sp, store} = this.trans(store_name, 'readwrite');
52 | store.delete(key);
53 | await _sp;
54 | }
55 | async clear(store_name) {
56 | let {_sp, store} = this.trans(store_name, 'readwrite');
57 | store.clear();
58 | await _sp;
59 | }
60 | async keys(store_name) {
61 | let {_sp, store} = this.trans(store_name, 'readonly');
62 | let req = store.getAllKeys();
63 | await _sp;
64 | return req.result;
65 | }
66 |
67 | stores() {
68 | return this.db.objectStoreNames;
69 | }
70 | }
71 |
72 | export { Idb };
73 |
--------------------------------------------------------------------------------
/sw.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Software License Agreement (MIT License)
3 | *
4 | * Author: Duke Fong
5 | */
6 |
7 | // update file list by tool gen_sw.sh under tools/
8 |
9 | var cache_name = 'cde-1.20';
10 | var cache_files = {
11 | "/img/icon/fontello.css" : "9143594ce27fc81648d345becdd74ba85cec2b2836908f12789d70e18e38174e",
12 | "/img/icon/fontello.woff2" : "c6f250032c14345783273890e92bb27611ffc2690afc851a138ac9fe2e275a44",
13 | "/img/icon.png" : "7160ad0053e77a16333b06123d567195777c67813dfe87d6c17e4df9d6f791b9",
14 | "/manifest.json" : "02e874ad409a13334237157db7f34026542ec5cc3c5745c7fc0f216c1981af00",
15 | "/src/lang/lang.js" : "dfebd527a1c59df65abfcf25c51b4c946b7d702712e9b7d5e2f70f775ca06567",
16 | "/src/utils/helper.js" : "6e16f8705d2d690ed26ffbc9bb852246ce689bb966756ea0f0fc0bf3aadc728f",
17 | "/src/utils/idb.js" : "c277349bf34bdf1f8610a9d4cb0bcd6aadb5ae22300861cd87e9597ab597d796",
18 | "/src/app.js" : "3c62c88af2d4cd2a5c82a5eb43a7ec0f6223d893b9463673a18ddd811a6bfa8a",
19 | "/lib/pell/pell.css" : "dd7012f74f875db0c7f6aa447ec86812914991e07cb8b32cd8db669b531f2e27",
20 | "/lib/pell/actions.js" : "2ad31c233702a0f9a5aa8cb9c66741b7aec7ae110a3dc94c22a2b8b867bc959a",
21 | "/lib/pell/utilities.js" : "73d5066c77258f034b604863824e1aa9b96304bbf36c906148def635300da60c",
22 | "/lib/pell/pell.js" : "b862bb1b70e255e886347fd49e1608965b62241ff2b110e812d8600dfcf84245",
23 | "/lib/bulma.min.css" : "0fd339cab543a859656bb9e510b0da6192295df1560f2b50b6257e4da1fa1752",
24 | "/lib/anchorme.min.js" : "87de70486f3fcaded74ac742724f8bf3cefd08b636323c90ee3619f35e958463",
25 | "/lib/msgpack.min.js" : "c670cb2d82b1285c0b12640ad52919f48ec8c268dd794446b57524ff45a74d1a",
26 | "/lib/base64js.min.js" : "f549a4c1d0eb4a6140081aea9c009cfff6fc2d0c289336d9e4542a03bf6281f5",
27 | "/" : "13c7de9fe4cd4bf6626e4f08c134ab70c16dd738075f21d6d3dde5d9e0dcee56"
28 | };
29 |
30 |
31 | async function sha256(dat) {
32 | const hashBuffer = await crypto.subtle.digest('SHA-256', dat);
33 | return new Uint8Array(hashBuffer);
34 | }
35 |
36 | function dat2hex(dat, join='') {
37 | const dat_array = Array.from(dat);
38 | return dat_array.map(b => b.toString(16).padStart(2, '0')).join(join);
39 | }
40 |
41 | async function resp_sha(resp) {
42 | const reader = resp.body.getReader();
43 | let dat = new Uint8Array();
44 | while (true) {
45 | const ret = await reader.read();
46 | if (ret.value && ret.value.length)
47 | dat = new Uint8Array([ ...dat, ...ret.value ]);
48 | if (ret.done)
49 | break;
50 | }
51 | const sha = await sha256(dat);
52 | return dat2hex(sha);
53 | }
54 |
55 |
56 | async function cache_all(event) {
57 | let r = Math.random();
58 | console.log(`sw: cache add all, r: ${r}`);
59 | let cache = await caches.open(cache_name);
60 | for (let k in cache_files) {
61 | let response = await fetch(`${k}?r=${r}`, {cache: 'no-store'});
62 | const sha = await resp_sha(response.clone());
63 | if (sha == cache_files[k])
64 | cache.put(k, response);
65 | else
66 | console.warn(`sw: ${k} hash error: ${sha} != ${cache_files[k]}`);
67 | }
68 | console.log('sw: cache add all finished');
69 | }
70 |
71 | async function handle_request(event) {
72 | let loc = new URL(event.request.url);
73 | let k = loc.pathname;
74 |
75 | let cache = await caches.open(cache_name);
76 | let response = await cache.match(loc.host == location.host ? k : event.request);
77 | if (response)
78 | return response;
79 |
80 | if (loc.host == location.host && (k in cache_files)) {
81 | let r = Math.random();
82 | response = await fetch(`${k}?r=${r}`, {cache: 'no-store'});
83 | const sha = await resp_sha(response.clone());
84 | if (sha == cache_files[k]) {
85 | console.log(`sw: add ${k} to cache`);
86 | cache.put(k, response.clone());
87 | } else {
88 | console.warn(`sw: ${k} hash still error: ${sha} != ${cache_files[k]}`);
89 | }
90 | } else {
91 | if (loc.protocol == 'http:') {
92 | console.log(`sw: force https: ${loc.href}`)
93 | loc.protocol = 'https:';
94 | response = await fetch(loc);
95 | } else {
96 | console.log(`sw: fetch: ${event.request.url}`);
97 | response = await fetch(event.request);
98 | }
99 | }
100 | return response;
101 | }
102 |
103 | async function handle_activate(event) {
104 | let c_keys = await caches.keys();
105 | for (let c of c_keys) {
106 | if (c != cache_name) {
107 | console.log(`sw: del: ${c}`);
108 | await caches.delete(c);
109 | } else {
110 | console.log(`sw: retain: ${c}`);
111 | }
112 | }
113 | }
114 |
115 |
116 | self.addEventListener('install', event => {
117 | event.waitUntil(cache_all(event));
118 | self.skipWaiting();
119 | });
120 |
121 | self.addEventListener('fetch', event => {
122 | event.respondWith(handle_request(event));
123 | });
124 |
125 | self.addEventListener('activate', event => {
126 | event.waitUntil(handle_activate(event));
127 | event.waitUntil(clients.claim());
128 | });
129 |
130 |
--------------------------------------------------------------------------------
/tools/aes:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | echo "Usage: $0 passwd input out [-d] # -d for decryption"
3 | set -e
4 |
5 | [[ "$#" != "3" && "$#" != "4" ]] && exit
6 |
7 | echo "passwd: $1"
8 | KEY=$(echo -n "$1" | sha256sum)
9 | KEY=${KEY:0:64}
10 | echo "KEY: $KEY"
11 |
12 | echo "in: $2"
13 | echo "out: $3"
14 | echo "addition: $4"
15 |
16 | echo "processing..."
17 | openssl enc -aes-256-cbc -nosalt $4 -K "$KEY" -iv "00000000000000000000000000000000" -in "$2" -out "$3"
18 |
19 |
--------------------------------------------------------------------------------
/tools/aes-mount.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | #
3 | # Software License Agreement (MIT License)
4 | #
5 | # Author: Duke Fong
6 | #
7 | # Image file <--> Directory, on-the-fly encryption tool
8 | #
9 | # Format: aes-cbc-plain
10 | # KEY: sha256sum of password string
11 | # IV: sector index (little-endian, sector size: 512 bytes)
12 |
13 | XTERM=xterm
14 | which gnome-terminal &> /dev/null && XTERM="gnome-terminal"
15 | which xfce4-terminal &> /dev/null && XTERM="xfce4-terminal"
16 |
17 | tty -s; [ $? -ne 0 ] && { $XTERM -e "bash -c \"$0 $@\""; exit; }
18 | [ $UID -ne 0 ] && { echo "restart as root"; sudo _uid=$UID "$0" "$@"; exit $?; }
19 | [ "$_uid" == "" ] && _uid=0
20 | set -e
21 |
22 | function exe() { echo "\$ $@"; "$@"; }
23 |
24 | function anykey_exit() {
25 | [ "$1" == 0 ] && ecode=0 || ecode=1
26 | read -n1 -r -p "press any key to exit ($ecode)..."
27 | [ "$ecode" == 0 ] && exit || exit 1
28 | }
29 |
30 | if [[ "$1" == "" || "$1" == "-h" || "$1" == "--help" ]]; then
31 | echo "Usage:"
32 | echo " $0 FILE : Toggle mount"
33 | echo " $0 FILE [u]mount [PATH] : Mount / umount, or mount to PATH"
34 | echo " $0 FILE new SIZE : Create image file, units: K/M/G"
35 | echo " $0 FILE shrink : Shrink file size"
36 | echo " $0 FILE expand SIZE : Expand file to size"
37 | echo " $0 FILE passwd : Change file password"
38 | echo ""
39 | echo "You can drag an image file onto the script to run the toggle command."
40 | exit
41 | fi
42 |
43 | FILE_PATH="$(readlink -f "$1")"
44 | FILE_DIR="$(dirname "$FILE_PATH")"
45 | FILE_NAME="$(basename "$FILE_PATH")"
46 | NAME="${FILE_NAME%.*}" # remove file extention
47 |
48 | CMD="$2"
49 | MAP_EXIST=0
50 | MOUNT_DIR=""
51 | if [ -b "/dev/mapper/$NAME" ]; then
52 | INFO="$(cryptsetup status "$NAME")"
53 | [[ ! "$INFO" =~ "$FILE_PATH" ]] && { echo "Name $NAME conflict!"; exit 1; }
54 | MAP_EXIST=1
55 | MOUNT_DIR="$(lsblk -o MOUNTPOINT -nr "/dev/mapper/$NAME")"
56 | fi
57 | [ "$NAME" == "" ] && { echo "Name empty!"; exit 1; }
58 |
59 |
60 | if [ "$CMD" == "new" ]; then
61 | file_sz=`numfmt --from=iec "$3"`
62 | file_sz_iec=`numfmt --to=iec $file_sz`
63 | echo "new $FILE_PATH, size: $file_sz ($file_sz_iec)"
64 | [ "$((file_sz))" == "0" ] && { echo "file_sz wrong: $file_sz"; exit 1; }
65 | [ "$((file_sz % 512))" != "0" ] && { echo "file_sz is not multiple of 512"; exit 1; }
66 | exe dd if=/dev/zero of="$FILE_PATH" bs=512 count=0 seek=$((file_sz/512))
67 | exe cryptsetup create "$NAME" "$FILE_PATH" --hash sha256 --cipher aes-cbc-plain --key-size 256
68 | exe mkfs.ext4 /dev/mapper/"$NAME"
69 | exe cryptsetup remove "$NAME"
70 | echo "done"
71 | exit
72 | fi
73 |
74 |
75 | if [ "$CMD" == "shrink" ]; then
76 | [ "$MAP_EXIST" == "1" ] && { echo "please umount first"; exit 1; }
77 | exe cryptsetup create "$NAME" "$FILE_PATH" --hash sha256 --cipher aes-cbc-plain --key-size 256
78 | dumpe2fs "/dev/mapper/$NAME" > /dev/null || { exe cryptsetup remove "$NAME"; exit 1; }
79 | block_size=`dumpe2fs "/dev/mapper/$NAME" 2>&1 | grep "Block size:"`
80 | block_size=${block_size##* }
81 | block_count=`dumpe2fs "/dev/mapper/$NAME" 2>&1 | grep "Block count:"`
82 | block_count=${block_count##* }
83 | exe e2fsck -f "/dev/mapper/$NAME"
84 | exe resize2fs -M "/dev/mapper/$NAME"
85 | block_count_m=`dumpe2fs "/dev/mapper/$NAME" 2>&1 | grep "Block count:"`
86 | block_count_m=${block_count_m##* }
87 | exe cryptsetup remove "$NAME"
88 | echo "shrink: block_size: ${block_size}, block_count: ${block_count} -> ${block_count_m}"
89 | read -p "continue (Y/n)? "
90 | if [[ "$REPLY" =~ ^[Yy]$ || "$REPLY" == "" ]]; then
91 | exe dd if=/dev/zero of="$FILE_PATH" bs=${block_size} count=0 seek=${block_count_m}
92 | echo "done"
93 | fi
94 | exit
95 | fi
96 |
97 | if [[ "$CMD" == "expand" && "$3" != "" ]]; then
98 | file_sz=`stat -c '%s' $FILE_PATH`
99 | tgt_sz=`numfmt --from=iec $3`
100 | file_sz_iec=`numfmt --to=iec $file_sz`
101 | tgt_sz_iec=`numfmt --to=iec $tgt_sz`
102 | echo "expand: file_sz: $file_sz ($file_sz_iec) -> tgt_sz: $tgt_sz ($tgt_sz_iec)"
103 | [ "$MAP_EXIST" == "1" ] && { echo "please umount first"; exit 1; }
104 | [ "$((file_sz))" == "0" ] && { echo "file_sz wrong: $file_sz"; exit 1; }
105 | [ "$((file_sz % 512))" != "0" ] && echo "file_sz is not multiple of 512"
106 | [ "$((tgt_sz))" == "0" ] && { echo "tgt_sz wrong: $tgt_sz"; exit 1; }
107 | [ "$((tgt_sz % 512))" != "0" ] && { echo "file_sz is not multiple of 512"; exit 1; }
108 | [ "$((tgt_sz >= file_sz))" == "0" ] && { echo "tgt_sz must larger than file_sz"; exit 1; }
109 |
110 | read -p "continue (Y/n)? "
111 | if [[ "$REPLY" =~ ^[Yy]$ || "$REPLY" == "" ]]; then
112 | exe dd if=/dev/zero of="$FILE_PATH" bs=512 count=0 seek=$((tgt_sz/512))
113 | exe cryptsetup create "$NAME" "$FILE_PATH" --hash sha256 --cipher aes-cbc-plain --key-size 256
114 | exe e2fsck -f "/dev/mapper/$NAME"
115 | exe resize2fs "/dev/mapper/$NAME" # without -M
116 | exe cryptsetup remove "$NAME"
117 | echo "done"
118 | fi
119 | exit
120 | fi
121 |
122 | if [ "$CMD" == "passwd" ]; then
123 | file_sz=`stat -c '%s' $FILE_PATH`
124 | [ "$MOUNT_DIR" == "" ] && { echo "please mount first"; exit 1; }
125 | [ "$((file_sz))" == "0" ] && { echo "file_sz wrong: $file_sz"; exit 1; }
126 | [ "$((file_sz % 512))" != "0" ] && { echo "file_sz is not multiple of 512"; exit 1; }
127 | exe dd if=/dev/zero of="$FILE_PATH".tmp bs=512 count=0 seek=$((file_sz/512))
128 | echo "change passwd, please input new passwd:"
129 | exe cryptsetup create "$NAME".tmp "$FILE_PATH".tmp --hash sha256 --cipher aes-cbc-plain --key-size 256
130 | exe mkfs.ext4 /dev/mapper/"$NAME".tmp
131 | exe mkdir "$MOUNT_DIR".tmp
132 | exe mount "/dev/mapper/$NAME".tmp "$MOUNT_DIR".tmp
133 | exe cp -a "$MOUNT_DIR"/. "$MOUNT_DIR".tmp/ # include hidden files
134 | sync
135 | exe umount "$MOUNT_DIR".tmp
136 | exe cryptsetup remove "$NAME".tmp
137 | exe umount "$MOUNT_DIR"
138 | exe cryptsetup remove "$NAME"
139 | exe mv "$FILE_PATH" "$FILE_PATH".old
140 | exe mv "$FILE_PATH".tmp "$FILE_PATH"
141 | [ "$(ls -A "$MOUNT_DIR")" == "" ] && exe rm -r "$MOUNT_DIR"
142 | [ "$(ls -A "$MOUNT_DIR".tmp)" == "" ] && exe rm -r "$MOUNT_DIR".tmp
143 | echo "done"
144 | exit
145 | fi
146 |
147 | # toggle mount
148 | [ "$CMD" == "" ] && { [ "$MAP_EXIST" == "0" ] && CMD="mount" || CMD="umount"; }
149 | [ "$CMD" == "mount" ] && { [ "$3" != "" ] && MOUNT_DIR="$3" || MOUNT_DIR="$FILE_DIR/$NAME"; }
150 |
151 | if [ "$CMD" == "mount" ]; then
152 | echo "do mount"
153 | [ "$MAP_EXIST" == "1" ] && { echo "/dev/mapper/$NAME already exist!"; anykey_exit; }
154 | [ ! -d "$MOUNT_DIR" ] && { exe mkdir "$MOUNT_DIR" || anykey_exit; }
155 | exe cryptsetup create "$NAME" "$FILE_PATH" --hash sha256 --cipher aes-cbc-plain --key-size 256
156 | exe mount "/dev/mapper/$NAME" "$MOUNT_DIR" && ret=0 || ret=1
157 | if [ $ret == 0 ]; then
158 | exe chown $_uid "$MOUNT_DIR"
159 | echo "succeeded"
160 | else
161 | [ "$(ls -A "$MOUNT_DIR")" == "" ] && exe rm -r "$MOUNT_DIR"
162 | exe cryptsetup remove "$NAME"
163 | anykey_exit
164 | fi
165 |
166 | elif [ "$CMD" == "umount" ]; then
167 | echo "do umount"
168 | sync
169 | if [ "$MOUNT_DIR" != "" ]; then
170 | exe umount "$MOUNT_DIR" || anykey_exit
171 | [ "$(ls -A "$MOUNT_DIR")" == "" ] && exe rm -r "$MOUNT_DIR"
172 | else
173 | [[ -d "$FILE_DIR/$NAME" && "$(ls -A "$FILE_DIR/$NAME")" == "" ]] && exe rm -r "$FILE_DIR/$NAME"
174 | fi
175 | exe cryptsetup remove "$NAME"
176 | echo "done"
177 | fi
178 |
179 | anykey_exit 0
180 |
181 |
--------------------------------------------------------------------------------
/tools/gen_sw.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | # for subdir: ./gen_sw.sh /cde
4 |
5 | cd "$(dirname "$0")/.."
6 |
7 | files="$(find ./ -not -path '*/\.*' -type f)"
8 |
9 | echo "$files" | while read -r line; do
10 | line="${line:1}"
11 | file="$line"
12 | [[ "$line" == "/httpd.conf" ]] && continue
13 | [[ "$line" == "/Readme.md" ]] && continue
14 | [[ "$line" == "/sw.js" ]] && continue
15 | [[ "$line" =~ ^"/tools/" ]] && continue
16 | [[ "$line" =~ ^"/cgi-bin/" ]] && continue
17 | [[ "$line" == "/index.html" ]] && line="/"
18 | echo " \"$1$line\" : \"$(sha256sum "./$file" | awk '{ print $1 }')\","
19 | done
20 |
21 |
--------------------------------------------------------------------------------