├── .gitignore
├── extra
    ├── uglifyexcept.json
    ├── README.md
    ├── f5extract.min.js
    └── f5extract.js
├── uglifyexcept.json
├── package.json
├── Gruntfile.js
├── bin
    ├── stegodctdump
    ├── stegodcthist
    └── f5stego
├── LICENSE.txt
├── README.md
├── f5stego.min.js
└── f5stego.js


/.gitignore:
--------------------------------------------------------------------------------
1 | temp/
2 | tmp/
3 | node_modules/
4 | *.jpeg
5 | *.jpg
6 | 


--------------------------------------------------------------------------------
/extra/uglifyexcept.json:
--------------------------------------------------------------------------------
1 | {
2 |   "vars": ["f5extract"],
3 |   "props": ["subarray", "set", "push", "splice", "toFixed", "slice", "length", "ceil"]
4 | }
5 | 
6 | 


--------------------------------------------------------------------------------
/uglifyexcept.json:
--------------------------------------------------------------------------------
1 | {
2 |   "vars": [ "define", "module", "f5stego"],
3 |   "props": [ "f5stego", "subarray", "set", "push", "splice", "toFixed", "slice", "length", "ceil", "prototype", "amd", "exports", "stats", "app", "data", "capacity", "coeff_total", "coeff_large", "coeff_zero", "coeff_one", "coeff_one_ratio", "k", "embedded", "examined", "changed", "thrown", "efficiency", "analyze", "f5put", "f5get", "parse", "pack", "clearTail", "addTail", "getTail", "clearAPPs", "getAPPn", "setAPPn", "strip", "embed", "extract"]
4 | }
5 | 
6 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "f5stegojs",
 3 | 	"version": "0.1.2",
 4 | 	"description": "JPEG steganography for browser and node. F5 algo in pure javascript.",
 5 | 	"main": "f5stego.js",
 6 | 	"scripts": {
 7 | 		"test": "echo \"Error: no test specified\" && exit 1"
 8 | 	},
 9 | 	"bin": {
10 | 		"f5stego": "bin/f5stego",
11 | 		"stegodcthist": "bin/stegodcthist",
12 | 		"stegodctdump": "bin/stegodctdump"
13 | 
14 | 	},
15 | 	"repository": {
16 | 		"type": "git",
17 | 		"url": "git+https://github.com/desudesutalk/f5stegojs.git"
18 | 	},
19 | 	"keywords": [
20 | 		"jpeg",
21 | 		"steganography"
22 | 	],
23 | 	"author": "desudesutalk",
24 | 	"license": "MIT",
25 | 	"bugs": {
26 | 		"url": "https://github.com/desudesutalk/f5stegojs/issues"
27 | 	},
28 | 	"homepage": "https://github.com/desudesutalk/f5stegojs#readme",
29 | 	"devDependencies": {
30 | 		"grunt": "^1.0.1",
31 | 		"grunt-contrib-jshint": "^1.0.0",
32 | 		"grunt-contrib-uglify": "^2.0.0"
33 | 	},
34 | 	"dependencies": {
35 | 		"minimist": "^1.2.0"
36 | 	}
37 | }
38 | 


--------------------------------------------------------------------------------
/extra/README.md:
--------------------------------------------------------------------------------
 1 | f5extract.min.js
 2 | ================
 3 | 
 4 | 4.5kb of javascript what can decode Huffman-coded baseline and progressive jpegs and extract from them data hidden with f5 algorithm.
 5 | 
 6 | To use this function just include file
 7 | ```html
 8 | <script type="text/javascript" src="f5extract.min.js"></script>
 9 | ```
10 | or copy and paste its contents to your scripts.
11 | 
12 | Usage
13 | -----
14 | 
15 | ```js
16 | var stegKey = [1,2,3,4,5,6,7,8,9];
17 | 
18 | var f5get = f5extract(stegKey); // init stegger with key. Decoding function is returned.
19 | 
20 | //extract message from image
21 | var message = f5get(secretImage);
22 | ```
23 | 
24 | Here `stegKey` is an array of byte values which is used for initialization of f5 shuffle. `secretImage` is `Uint8Array` instances with cover jpeg image data. Extracted message will be also returned as `Uint8Array`.
25 | 
26 | Note: this function will throw in case of errors. And can return zero length array or array of garbage if image has no embedded message or incorrect `stegKey` was used.
27 | 
28 | For more information and license refer to [main readme](../README.md)
29 | 


--------------------------------------------------------------------------------
/Gruntfile.js:
--------------------------------------------------------------------------------
 1 | module.exports = function(grunt) {
 2 | 	grunt.loadNpmTasks('grunt-contrib-uglify');
 3 | 	grunt.loadNpmTasks('grunt-contrib-jshint');
 4 | 
 5 | 	grunt.initConfig({
 6 | 		pkg: grunt.file.readJSON('package.json'),
 7 | 
 8 | 		uglify: {
 9 | 			options: {
10 | 				mangle: {
11 | 					toplevel: true
12 | 				},
13 | 				compress: {
14 | 					drop_console: true
15 | 				},
16 | 				mangleProperties: 2,
17 | 				exceptionsFiles: [ 'uglifyexcept.json' ],
18 | 				screwIE8: true,
19 | 				banner: '/*! <%=pkg.name%> v<%=pkg.version%> | <%=pkg.license%> license | <%=pkg.homepage%> */\n'
20 | 			},
21 | 			default: {
22 | 				files: {
23 | 					"f5stego.min.js": ["f5stego.js"]
24 | 				}
25 | 			},
26 | 			extra: {
27 | 				options:{
28 | 					exceptionsFiles: [ 'extra/uglifyexcept.json' ]
29 | 				},
30 | 				files: {
31 | 					"extra/f5extract.min.js": ["extra/f5extract.js"]
32 | 				}
33 | 			}
34 | 		},
35 | 
36 | 		jshint: {
37 | 			all: ["f5stego.js", "extra/f5extract.js"],
38 | 			options: {
39 | 				strict: true,
40 | 				browser: true,
41 | 				devel: true,
42 | 				esversion: 5,
43 | 			}
44 | 		},
45 | 	});
46 | 
47 | 	grunt.registerTask('default', ['jshint', 'uglify']);
48 | }
49 | 


--------------------------------------------------------------------------------
/bin/stegodctdump:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | 
 3 | var f5stego = require('../'),
 4 | 	fs = require('fs');
 5 | 
 6 | function usage(){
 7 | 	console.log('  Dump DCT coefficients from JPEG images.\n\n'+
 8 | 				'  usage:\n\n'+
 9 | 				'    stegodctdump <image>\n\n'+
10 | 				'  output:\n\n'+
11 | 				'    For each component of image separate file with extension DCT_n will be created. Where n is ID of component\n'+
12 | 				'    Components are not dequantized or dezigzagged.\n'+
13 | 				'    Each component is two byte signed int.');
14 | }
15 | 
16 | var cover, j, out, out16, i, k, c;
17 | 
18 | if(!process.argv[2]){
19 | 	usage();
20 | 	process.exit(1);
21 | }
22 | 
23 | var imgfile = process.argv[2];
24 | 
25 | try{
26 | 	cover = fs.readFileSync(imgfile);
27 | }catch(e){
28 | 	console.error('Unable read image "' + imgfile.toString() + '".');
29 | 	console.error(e);
30 | 	process.exit(1);
31 | }
32 | 
33 | try{
34 | 	j = new f5stego([1,2,3]);
35 | 	j.parse(cover);
36 | }catch(e){
37 | 	console.error('Image parsing error.');
38 | 	console.error(e);
39 | 	process.exit(1);
40 | }
41 | 
42 | for (i = 0; i < j.frame.components.length; i++) {
43 | 	c = j.frame.components[i];
44 | 	out = new Uint8Array(c.blocks.length * 2);
45 | 	out16 = new Int16Array(out.buffer, out.byteOffset, c.blocks.length);
46 | 
47 | 	out16.set(c.blocks);
48 | 
49 | 	for (k = 0; k < c.blocksDC.length; k++) {
50 | 		out16[k*64] = c.blocksDC[k];
51 | 	}
52 | 
53 | 	try{
54 | 		fs.writeFileSync(imgfile + '.DCT_' + c.componentId, new Buffer(out));
55 | 	}catch(e){
56 | 		console.error('Unable to write output to "' + imgfile + '.DCT_' + c.componentId + '".');
57 | 		console.error(e);
58 | 		process.exit(1);
59 | 	}
60 | }
61 | 
62 | 


--------------------------------------------------------------------------------
/bin/stegodcthist:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | 
 3 | var f5stego = require('../'),
 4 | 	fs = require('fs');
 5 | 
 6 | function usage(){
 7 | 	console.log('  Dump DCT coefficients histogram from JPEG images.\n\n'+
 8 | 				'  usage:\n\n'+
 9 | 				'    stegodumpdct <image> [n]\n\n'+
10 | 				'    n  is optional parameter what controls maximum (absolute) value of counted coefficients\n'+
11 | 				'  output:\n\n'+
12 | 				'    For each component of image separate file with extension DCT_hist_n will be created. Where n is ID of component\n'+
13 | 				'    Components are not dequantized or dezigzagged.\n'+
14 | 				'    Each component is two byte signed int.');
15 | }
16 | 
17 | var cover, j, out, out16, i, k, c;
18 | 
19 | if(!process.argv[2]){
20 | 	usage();
21 | 	process.exit(1);
22 | }
23 | 
24 | var imgfile = process.argv[2];
25 | var n = parseInt(process.argv[3]) || 32768;
26 | 
27 | try{
28 | 	cover = fs.readFileSync(imgfile);
29 | }catch(e){
30 | 	console.error('Unable read image "' + imgfile.toString() + '".');
31 | 	console.error(e);
32 | 	process.exit(1);
33 | }
34 | 
35 | try{
36 | 	j = new f5stego([1,2,3]);
37 | 	j.parse(cover);
38 | }catch(e){
39 | 	console.error('Image parsing error.');
40 | 	console.error(e);
41 | 	process.exit(1);
42 | }
43 | 
44 | var cnt = new Uint32Array(65536);
45 | 
46 | for (i = 0; i < j.frame.components.length; i++) {
47 | 	cnt.fill(0);
48 | 
49 | 	c = j.frame.components[i];
50 | 
51 | 	for (k = 0; k < c.blocks.length; k++) {
52 | 		if(k%64 === 0) continue;
53 | 
54 | 		cnt[32768 + c.blocks[k]]++;
55 | 	}
56 | 
57 | 	s = [];
58 | 
59 | 	for(k = 32768 - n; k < 32768+n; k++){
60 | 		s.push(cnt[k]);
61 | 	}
62 | 
63 | 	console.log(k, n, s.length);
64 | 	try{
65 | 		fs.writeFileSync(imgfile + '.DCT_hist_' + c.componentId, s.join(';'));
66 | 	}catch(e){
67 | 		console.error('Unable to write output to "' + imgfile + '.DCT_hist_' + c.componentId + '".');
68 | 		console.error(e);
69 | 		process.exit(1);
70 | 	}
71 | }
72 | 
73 | 


--------------------------------------------------------------------------------
/bin/f5stego:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | 
  3 | var f5stego = require('../'),
  4 | 	fs = require('fs'),
  5 | 	argv = require('minimist')(process.argv.slice(2),{
  6 | 		strings: 'p',
  7 | 		boolean: ['x', 'e', 's', 'h'],
  8 | 		alias: {
  9 | 			'x': 'extract',
 10 | 			'e': 'embed',
 11 | 			'p': 'password',
 12 | 			's': 'strip',
 13 | 			'h': 'help'
 14 | 		}
 15 | 	});
 16 | 
 17 | function usage(){
 18 | 	console.log('  Embed and extract data from JPEG images using F5 algorithm.\n\n'+
 19 | 				'  usage:\n\n'+
 20 | 				'    embed:   f5stegojs -e -p password <cover image> <data> <output>\n'+
 21 | 				'    extract: f5stegojs -x -p password <cover image> <output>\n\n'+
 22 | 				'  options:\n\n'+
 23 | 				'    -p, --password   password for F5 algorithm shuffle. REQUIRED.\n'+
 24 | 				'    -e, --embed      hidde data in image.\n'+
 25 | 				'    -x, --extract    extract hidden data from image.\n'+
 26 | 				'    -s, --strip      strip metadata from image (e.g. EXIF).\n'+
 27 | 				'    -h, --help       show usage information.\n');
 28 | }
 29 | var cover, data, j, out, stats;
 30 | 
 31 | if(argv.embed){
 32 | 	if(!argv.password){
 33 | 		console.log('ERROR: you must provide password with -p option.\n\n');
 34 | 		usage();
 35 | 		process.exit(1);
 36 | 	}
 37 | 
 38 | 	if(argv._.length < 3){
 39 | 		console.log('ERROR: you must provide cover image, data for embedding and out file.\n\n');
 40 | 		usage();
 41 | 		process.exit(1);
 42 | 	}
 43 | 
 44 | 	try{
 45 | 		cover = fs.readFileSync(argv._[0]);
 46 | 	}catch(e){
 47 | 		console.error('Unable read cover image "' + argv._[0].toString() + '".');
 48 | 		console.error(e);
 49 | 		process.exit(1);
 50 | 	}
 51 | 
 52 | 	try{
 53 | 		data = fs.readFileSync(argv._[1]);
 54 | 	}catch(e){
 55 | 		console.error('Unable read data from "' + argv._[1].toString() + '".');
 56 | 		console.error(e);
 57 | 		process.exit(1);
 58 | 	}
 59 | 
 60 | 	try{
 61 | 		j = new f5stego(new Buffer(argv.password.toString(), 'utf8'));
 62 | 		j.parse(cover);
 63 | 		if(argv.strip){
 64 | 			j.strip();
 65 | 		}
 66 | 		s = j.f5put(data);
 67 | 		out = j.pack();
 68 | 	}catch(e){
 69 | 		console.error('Error while embedding.');
 70 | 		console.error(e);
 71 | 		process.exit(1);
 72 | 	}
 73 | 
 74 | 	try{
 75 | 		fs.writeFileSync(argv._[2].toString(), new Buffer(out));
 76 | 	}catch(e){
 77 | 		console.error('Unable to write output to "' + argv._[2].toString() + '".');
 78 | 		console.error(e);
 79 | 		process.exit(1);
 80 | 	}
 81 | 
 82 | 	console.log('Total bytes embedded: ' + s.embedded + ' (' +(100*s.embedded/s.stats.capacity[1]).toFixed(2) +'% of estimated capacity), coefficients changed: ' + s.changed + ' (' + s.thrown + ' thrown), efficiency: ' + s.efficiency + ' bits per change with '+((1<<s.k)-1)+','+s.k+' code.');
 83 | 	process.exit(0);
 84 | }else if(argv.extract){
 85 | 	if(!argv.password){
 86 | 		console.log('ERROR: you must provide password with -p option.\n\n');
 87 | 		usage();
 88 | 		process.exit(1);
 89 | 	}
 90 | 
 91 | 	if(argv._.length < 2){
 92 | 		console.log('ERROR: you must provide cover image, data for embedding and out file.\n\n');
 93 | 		usage();
 94 | 		process.exit(1);
 95 | 	}
 96 | 
 97 | 	try{
 98 | 		cover = fs.readFileSync(argv._[0]);
 99 | 	}catch(e){
100 | 		console.error('Unable read cover image "' + argv._[0].toString() + '".');
101 | 		console.error(e);
102 | 		process.exit(1);
103 | 	}
104 | 
105 | 	try{
106 | 		j = new f5stego(new Buffer(argv.password.toString(), 'utf8'));
107 | 		j.parse(cover);
108 | 		out = j.f5get();
109 | 	}catch(e){
110 | 		console.error('Error while extracting.');
111 | 		console.error(e);
112 | 		process.exit(1);
113 | 	}
114 | 
115 | 	try{
116 | 		fs.writeFileSync(argv._[1].toString(), new Buffer(out));
117 | 	}catch(e){
118 | 		console.error('Unable to write output to "' + argv._[1] + '".');
119 | 		console.error(e);
120 | 		process.exit(1);
121 | 	}
122 | 
123 | 	console.log(out.length + ' bytes was extracted to "' + argv._[1] + '".');
124 | 	process.exit(0);
125 | }else{
126 | 	usage();
127 | }
128 | 


--------------------------------------------------------------------------------
/extra/f5extract.min.js:
--------------------------------------------------------------------------------
1 | /*! f5stegojs v0.1.2 | MIT license | https://github.com/desudesutalk/f5stegojs#readme */
2 | function f5extract(a,b){"use strict";function c(a){var b,c;for(b=1;b<a.length;b++)c=l[b]%(b+1),c!=b&&(j=a[b],a[b]=a[c],a[c]=j);return new Uint8Array(k,4*a.length)}function d(a){for(var b,d=-1,e=0,f=a.length-1,g=c(a),h=0,i=0,j=new Uint8Array(a.length/8|0),k=0,l=0,m=0,n=0,o=0;m<4;)d++,0!==a[d]&&(e=1&a[d],a[d]<0&&(e=1-e),i|=e<<m,m++);if(i=(i^15&g[h++])+1,b=(1<<i)-1,m=0,1==i)for(;d<f;)d++,0!==a[d]&&(e=1&a[d],a[d]<0&&(e=1-e),k|=e<<m,m++,8==m&&(j[l++]=k^g[h++],k=0,m=0));else for(;d<f;)if(d++,0!==a[d]&&(e=1&a[d],a[d]<0&&(e=1-e),o^=e*++n,n==b))for(k|=o<<m,m+=i,n=0,o=0;m>=8;)j[l++]=255&k^g[h++],m-=8,k>>=8;for(;m>0;)j[l++]=255&k^g[h++],m-=8,k>>=8;var p=2,q=j[0];return 128&j[1]?(p++,q+=((127&j[1])<<8)+(j[2]<<15)):q+=j[1]<<8,j.subarray(p,p+q)}function e(a,b){for(var c=0,d=0,e=new Uint16Array(65536),f=0;f<16;f++){for(var g=0;g<a[f];g++){for(var h=c<<15-f,i=c+1<<15-f;h<i;h++)e[h]=b[d]+(f+1<<8);d++,c++}c*=2}return e}function f(a,b,c,d,e,f,g,h,i){function j(c){for(;u<16;)t=(t<<8)+(0|a[b]),u+=8,255==a[b]&&b++,b++;if(c=c[t>>>u-16&65535],!c)throw"invalid huffman sequence";return u-=c>>>8,255&c}function k(c){for(;u<c;)t=(t<<8)+a[b++],255==(255&t)&&b++,u+=8;var d=t>>u-c&(1<<c)-1;return u-=c,d<1<<c-1&&(d+=(-1<<c)+1),d}function l(c){for(;u<c;)t=(t<<8)+a[b++],255==(255&t)&&b++,u+=8;var d=t>>>u-c&(1<<c)-1;return u-=c,d}function m(){return u||(t=a[b++],255==t&&b++,u=8),t>>>--u&1}function n(a,b){var c=j(a.a),d=0;0!==c&&(d=k(c)),a.b+=d;for(var e,f,g=1;g<64;)if(e=j(a.c),f=e>>4,e&=15,0!==e)g+=f,a.d[b+g]=k(e),g++;else{if(f<15)break;g+=16}}function o(a){var b=0,c=j(a.a);0!==c&&(b=k(c)),a.b+=b<<i}function p(a,b){if(v>0)return void v--;for(var c,d,e=f;e<=g;)if(c=j(a.c),d=c>>4,c&=15,0!==c)e+=d,a.d[b+e]=k(c)*w,e++;else{if(15!=d){v=(1<<d)-1,d&&(v+=l(d));break}e+=16}}function q(a,b){var c,d,e=f;if(!v)for(;e<=g;){if(d=j(a.c),c=d>>4,d&=15){if(1!=d)throw"bad jpeg";d=m()?w:x}else if(15!=c){v=1<<c,c&&(v+=l(c));break}for(;e<=g;){if(a.d[b+e])a.d[b+e]+=m()*(a.d[b+e]>=0?w:x);else if(--c<0)break;e++}d&&(a.d[b+e]=d),e++}if(v){for(;e<=g;)a.d[b+e]&&(a.d[b+e]+=m()*(a.d[b+e]>=0?w:x)),e++;v--}}var r,s=b,t=0,u=0,v=0,w=1<<i,x=-1<<i;r=c.e?0===f?0===h?o:m:0===h?p:q:n;var y,z,A,B,C,D,E,F,G,H;if(1==d.length)for(E=d[0].f,F=d[0].g,z=F*E,e||(e=z),D=e,d[0].b=0,v=0,H=0;H<F;H++)for(G=0;G<E;G++){if(!D){if(D=e,d[0].b=0,v=0,b-=u/8|0,255==a[b-1]&&b--,u=0,y=a[b]<<8|a[b+1],!(y>=65488&&y<=65495)){if(y<=65280)throw"bad jpeg";break}b+=2}for(D--,A=0;A<d.length;A++)r(d[A],64*(H*d[A].h+G))}else{for(E=c.i,F=c.j,z=F*E,e||(e=z),D=e,A=0;A<d.length;A++)d[A].b=0;for(v=0,H=0;H<F;H++)for(G=0;G<E;G++){if(!D){for(D=e,A=0;A<d.length;A++)d[A].b=0;if(v=0,b-=u/8|0,255==a[b-1]&&b--,u=0,y=a[b]<<8|a[b+1],!(y>=65488&&y<=65495)){if(y<=65280)throw"bad jpeg";break}b+=2}for(D--,A=0;A<d.length;A++)for(B=0;B<d[A].k;B++)for(C=0;C<d[A].l;C++)r(d[A],64*((H*d[A].k+B)*d[A].h+G*d[A].l+C))}}return b-=u/8|0,255==a[b-1]&&b--,b-s}function g(a){function c(){var b=a[n]<<8|a[n+1];return n+=2,b}for(var g,j,k,l,m,n=0,o=[],p=[];;){if(n>=a.length)throw"unexpected EOF";if(j=a[n++],k=a[n++],255==j){if((k>=224&&k<240||254==k||219==k)&&(n+=c()),k>=192&&k<=194){if(g)throw"Only single frame JPEGs supported";if(g={},c(),n++,g.e=194===k,g.m=c(),g.n=c(),g.o=[],g.p={},g.m*g.n>b)throw"Image is too big.";var q,r=a[n++],s=0,t=0;for(h=0;h<r;h++){q=a[n];var u=a[n+1]>>4,v=15&a[n+1];s<u&&(s=u),t<v&&(t=v),g.p[q]=g.o.push({q:q,l:u,k:v})-1,n+=3}g.r=s,g.s=t;var w=Math.ceil(g.n/8/s),x=Math.ceil(g.m/8/t);for(h=0;h<g.o.length;h++){m=g.o[h];var y=Math.ceil(Math.ceil(g.n/8)*m.l/s),z=Math.ceil(Math.ceil(g.m/8)*m.k/t),A=w*m.l,B=x*m.k;m.d=new Int16Array(64*B*A),m.f=y,m.g=z,m.h=A,m.t=B}g.i=w,g.j=x}if(196==k){var C=c();for(h=2;h<C;){var D=a[n++],E=new Uint8Array(16),F=0;for(i=0;i<16;i++,n++)F+=E[i]=a[n];var G=new Uint8Array(F);for(i=0;i<F;i++,n++)G[i]=a[n];h+=17+F,(D>>4===0?p:o)[15&D]=e(E,G)}}if(221==k&&(l=c()),218==k){if(!g)throw"bad jpeg";c();var H=a[n++],I=[];for(h=0;h<H;h++){var J=g.p[a[n++]];m=g.o[J];var K=a[n++];m.a=p[K>>4],m.c=o[15&K],I.push(m)}var L=a[n++],M=a[n++],N=a[n++];n+=f(a,n,g,I,l,L,M,N>>4,15&N)}if(217==k)break}else{for(255==a[n-3]&&a[n-2]>=192&&a[n-2]<=254&&(n-=3);255!=a[n]&&n<a.length;)n++;if(255!=a[n])throw"bad jpeg "}}if(!g)throw"bad jpeg";if(m=g.o[0],1!=m.q)for(h=0;h<g.o.length;h++)if(1==g.o[h].q){m=g.o[h];break}return d(m.d)}b=b||16777216;var h,i,j,k=new ArrayBuffer(4.125*b),l=new Uint32Array(k),m=0,n=new Uint8Array(256),o=new Uint8Array(k);for(h=0,i=0,j=0,h=0;h<256;++h)n[h]=h;for(h=0;h<256;++h)i=i+n[h]+a[h%a.length]&255,j=n[h],n[h]=n[i],n[i]=j;for(h=0,i=0,m=0;m<4.125*b;++m)h=h+1&255,i=i+n[h]&255,j=n[h],n[h]=n[i],n[i]=j,o[m]=n[j+n[h]&255];return g}


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
  1 | This software is licensed under the MIT License.
  2 | 
  3 | Copyright (c) 2016 desudesutalk
  4 | 
  5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
  6 | this software and associated documentation files (the "Software"), to deal in
  7 | the Software without restriction, including without limitation the rights to
  8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  9 | the Software, and to permit persons to whom the Software is furnished to do so,
 10 | subject to the following conditions:
 11 | 
 12 | The above copyright notice and this permission notice shall be included in all
 13 | copies or substantial portions of the Software.
 14 | 
 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 21 | 
 22 | https://github.com/desudesutalk/f5stegojs
 23 | 
 24 | This library is based on https://github.com/owencm/js-steg by Owen Campbell-
 25 | Moore. Decoder and encoder was optimized for speed, F5 algorithm and metadata
 26 | manipulation utils was added to library.
 27 | 
 28 | Original code was released under MIT and Apache licenses, so here follows
 29 | original licenses of Owen code:
 30 | 
 31 | jpeg decoder license:
 32 | 
 33 | Modified JPEG decoder for Steganography by Owen Campbell-Moore, based on one
 34 | released by Adobe.
 35 | 
 36 | Copyright 2011 notmasteryet
 37 | 
 38 | Licensed under the Apache License, Version 2.0 (the "License"); you may not use
 39 | this file except in compliance with the License. You may obtain a copy of the
 40 | License at
 41 | 
 42 | http://www.apache.org/licenses/LICENSE-2.0
 43 | 
 44 | Unless required by applicable law or agreed to in writing, software distributed
 45 | under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 46 | CONDITIONS OF ANY KIND, either express or implied. See the License for the
 47 | specific language governing permissions and limitations under the License.
 48 | 
 49 | 
 50 | jpeg encoder license:
 51 | 
 52 | JPEG encoder ported to JavaScript, optimized by Andreas Ritter
 53 | (www.bytestrom.eu, 11/2009) and made suitable for steganography by Owen
 54 | Campbell-Moore (www.owencampbellmoore.com, 03/13)
 55 | 
 56 | Based on v 0.9a
 57 | 
 58 | Licensed under the MIT License
 59 | 
 60 | Copyright (c) 2009 Andreas Ritter
 61 | 
 62 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 63 | this software and associated documentation files (the "Software"), to deal in
 64 | the Software without restriction, including without limitation the rights to
 65 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 66 | the Software, and to permit persons to whom the Software is furnished to do so,
 67 | subject to the following conditions:
 68 | 
 69 | The above copyright notice and this permission notice shall be included in all
 70 | copies or substantial portions of the Software.
 71 | 
 72 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 73 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 74 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 75 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 76 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 77 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 78 | 
 79 | Copyright (c) 2008, Adobe Systems Incorporated All rights reserved.
 80 | 
 81 | Redistribution and use in source and binary forms, with or without modification,
 82 | are permitted provided that the following conditions are met:
 83 | 
 84 | Redistributions of source code must retain the above copyright notice, this list
 85 | of conditions and the following disclaimer.
 86 | 
 87 | Redistributions in binary form must reproduce the above copyright notice, this
 88 | list of conditions and the following disclaimer in the documentation and/or
 89 | other materials provided with the distribution.
 90 | 
 91 | Neither the name of Adobe Systems Incorporated nor the names of its contributors
 92 | may be used to endorse or promote products derived from this software without
 93 | specific prior written permission.
 94 | 
 95 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 96 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 97 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 98 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 99 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
100 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
101 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
102 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
103 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
104 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | f5stego.js
  2 | ==========
  3 | 
  4 | Port of [f5 steganographic algorithm](https://code.google.com/p/f5-steganography/) to JavaScript for modern browsers and Node.js.
  5 | 
  6 | [Simple online deomo](http://desudesutalk.github.io/f5stegojs/).
  7 | 
  8 | Documentation
  9 | =============
 10 | 
 11 | * [Overview](#overview)
 12 |   * [Security considerations](#security-considerations)
 13 | * [Installation](#installation)
 14 | * [Usage](#usage)
 15 |   * [Advanced usage](#advanced-usage)
 16 |   * [Metadata manipulation](#metadata-manipulation)
 17 |   * [CLI tool](#cli-tool)
 18 | * [Contributors](#contributors)
 19 | * [License](#license)
 20 | 
 21 | Overview
 22 | --------
 23 | 
 24 | This library implements jpeg codec capable of reading Huffman-coded baseline and progressive jpeg files and writing Huffman-coded baseline files. Decompression is done only up to raw DCT coefficients. They are not dequantized or dezigzagged. This coefficients are then used for embedding hidden messages with f5 algorithm.
 25 | 
 26 | I decided to make this library because for my projects I need small (this lib is 15kb minified and 5.5kb if gzipped) and fast code what is easy to maintain (and review). Speed mostly considered for extraction process as often I need to process many images at once.
 27 | 
 28 | Previously I was using [Eph5](https://github.com/Kleshni/Eph5) library. But now it looks unmaintained and I'm too lazy to get into that Emscripten things. And also Eph5 is 370kb and this Emscripten magic is not actually that performant. f5stego.js while being small has at least same performance as Eph5 and in some cases is 2x faster.
 29 | 
 30 | Another interest was to make tiny extract only version. You can find it in [extra](extra/) folder. Minified version of that extractor is only 4.5kb (2kb if gzipped).
 31 | 
 32 | Note: this implimentation is not compatible with [original code](https://code.google.com/p/f5-steganography/). It uses different shuffle algorithm and stores meatadata (used coding, data size) in a different way.
 33 | 
 34 | :warning: Work is still in progress.
 35 | 
 36 | ### Security considerations
 37 | 
 38 | First: this lib **does not encrypt** data it hides. If you need good security then encrypt your data with some strong algorithms before embedding. If you want my advice then take a look at [TweetNaCl-js](https://github.com/dchest/tweetnacl-js).
 39 | 
 40 | Yes, you need to provide key for data extraction. And if key is not correct, garbage will be extracted. This looks like encryption but actually this is just a side effect. This key is used for coefficients shuffling and data masking - all this is for making f5 less detectable, not encrypted.
 41 | 
 42 | Second: f5 **can be detected**. For example with [stegdetect](https://github.com/abeluck/stegdetect). Yep, this is not 100% guaranteed especially if you embed small messages into big images. But it is better to think what you hide your data from humans, not machines.
 43 | 
 44 | Installation
 45 | ------------
 46 | 
 47 | ```
 48 | npm install f5stegojs
 49 | ```
 50 | 
 51 | This package also provides simple cli tool which can be installed with
 52 | 
 53 | ```
 54 | npm install f5stegojs --global
 55 | ```
 56 | 
 57 | f5stego.js uses [typed arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays) so it will not work in environments where typed arrays are not present.
 58 | 
 59 | 
 60 | Usage
 61 | -----
 62 | In browser include minifed version
 63 | 
 64 | ```html
 65 | <script type="text/javascript" src="f5stego.min.js"></script>
 66 | ```
 67 | 
 68 | In Node use `require` to load module
 69 | 
 70 | ```js
 71 | var f5stego = require('f5stegojs');
 72 | ```
 73 | 
 74 | Simple usage will be like
 75 | 
 76 | ```js
 77 | var stegKey = [1,2,3,4,5,6,7,8,9];
 78 | 
 79 | var stegger = new f5stego(stegKey); // init stegger with key
 80 | 
 81 | //embed message into image
 82 | var secretImage = stegger.embed(imageArray, dataArray);
 83 | 
 84 | //extract message from image
 85 | var message = stegger.extract(secretImage);
 86 | ```
 87 | 
 88 | Here `stegKey` is an array of byte values which is used for initialization of f5 shuffle. `imageArray` and `dataArray` are `Uint8Array` instances with cover jpeg image and message to embed respectively.
 89 | 
 90 | f5stegojs waits for `Uint8Array` in its input and also returns `Uint8Array`. But in recent versions of Node `Buffer` is also instance of `Uint8Array` so buffers can be used as inputs but lib still return `Uint8Array`.
 91 | 
 92 | Also note that f5stegojs throws in case of errors, so use try-catch.
 93 | 
 94 | ### Advanced usage
 95 | 
 96 | f5stego has also several utility methods and expose a several functions what allow you to control a bit how data is embedded into image.
 97 | 
 98 | #### f5stego.prototype.analyze()
 99 | 
100 | Perform analyze of parsed jpeg for capacity. Returns object what looks like
101 | 
102 | ```js
103 | {
104 |   "capacity": [0,
105 |     18477,
106 |     13371,
107 |     9092,
108 |     5856,
109 |     3609,
110 |     2152,
111 |     1251,
112 |     713,
113 |     399,
114 |     220,
115 |     120,
116 |     63,
117 |     33,
118 |     16,
119 |     6,
120 |     3
121 |   ],
122 |   "coeff_total": 460800,
123 |   "coeff_large": 114241,
124 |   "coeff_zero": 270810,
125 |   "coeff_one": 68549,
126 |   "coeff_one_ratio": 0.37501504458668417
127 | }
128 | ```
129 | 
130 | Most interesting here is `capacity` array. It contains maximum capacity (in bytes) for different f5 coding modes. This library supports f5 matrix encodings from 1 to 16. As arrays are indexed from zero first element is not used.
131 | 
132 | #### f5stego.prototype.parse(jpeg)
133 | 
134 | Parses jpeg file. Jpeg is decompressed up to DCT coefficients and now ready for embedding/extracting f5 data.
135 | 
136 | #### f5stego.prototype.f5put(data)
137 | 
138 | Embeds `data` into image using most appropriate coding. Returns object with resulting statistics what looks like
139 | 
140 | ```js
141 | {
142 |   "k": 4,
143 |   "embedded": 5024,
144 |   "examined": 155976,
145 |   "changed": 14070,
146 |   "thrown": 5267,
147 |   "efficiency": "2.86",
148 |   "stats": { ... } // same object what was returned by analyze()
149 | }
150 | ```
151 | Here `k` shows what coding was used by f5 algorithm. `changed` shows how many DCT coefficients was changed and `thrown` shows how many of them was thrown (turned to zero). `efficiency` is how many bits of message was written by change of one DCT coefficient.
152 | 
153 | Value of `embedded` will be bigger than original message because it also counts additional bits what is embedded into image by this library (`k` value, data size. From 20 to 28 bits).
154 | 
155 | #### f5stego.prototype.f5put(data, k)
156 | 
157 | If you pass second argument to `f5put` then its value will be used as `k` in f5 algorithm. Returning object in this case will be like
158 | 
159 | ```js
160 | {
161 |   "k": 2,
162 |   "embedded": 5023.75,
163 |   "examined": 67931,
164 |   "changed": 20269,
165 |   "thrown": 7648,
166 |   "efficiency": "1.98"
167 | }
168 | ```
169 | 
170 | Here `k` equals to value you provided in `f5put` call. There is no `stats` property because image was not analyzed for finding best value of `k`.
171 | 
172 | #### f5stego.prototype.f5get()
173 | 
174 | Extracts hidden data from previously parsed jpeg and returns it as `Uint8Arrat`. Zero length array can be returned or array containing garbage (if image has no embedded message, or if wrong `stegoKey` was used).
175 | 
176 | #### f5stego.prototype.pack()
177 | 
178 | Compresses jpeg back and return resulting file as `Uint8Array`.
179 | 
180 | ### Metadata manipulation
181 | 
182 | This methods can be used to manipulate data what was stored in jpeg as `APPn` blocks or located after EOI marker.
183 | 
184 | #### f5stego.prototype.getTail()
185 | 
186 | Returns `Uint8Array` with data what was found after EOI marker.
187 | 
188 | #### f5stego.prototype.setTail(data)
189 | 
190 | Sets `data` as image tail. If tail data was already presented its old value will be returned. Otherwise `null` is returned.
191 | 
192 | #### f5stego.prototype.clearTail()
193 | 
194 | Clears image tail data.
195 | 
196 | #### f5stego.prototype.getAPPn(id, remove)
197 | 
198 | Returns data from `APPn` block `id`. jpeg uses ids from 0xE0 to 0xEF for `APPn` blocks and id 0xFE for comment. If `remove` evaluates to true, then block will be removed from image.
199 | 
200 | If there is no block with provided `id` then `null` will be returned.
201 | 
202 | #### f5stego.prototype.setAPPn(id, data)
203 | 
204 | Sets data as `APPn` block `id`. If such block was already presented in image its previous value will be returned. Otherwise `null` is returned.
205 | 
206 | #### f5stego.prototype.clearAPPs()
207 | 
208 | Removes all `AAPn` blocks from image and returns them. **Note**: JFIF block (with id 0xE0) will not be removed.
209 | 
210 | #### f5stego.prototype.strip()
211 | 
212 | Internally calls `clearAPPs` and `clearTail`. Always returns `true`.
213 | 
214 | ### CLI tool
215 | 
216 | This package also contains binary what allows you to embed and extract data from images in command line. This tool is very simple and naive. It can be installed globally with npm by command `npm install f5stegojs --global`.
217 | 
218 | To embed data execute something like
219 | ```
220 | f5stego -e -p SecreT cover.jpg message.txt output.jpeg
221 | ```
222 | 
223 | To extract
224 | ```
225 | f5stego -x -p SecreT cover.jpg output.txt
226 | ```
227 | 
228 | Note what password is required for both operations. It is used to initialize f5 shuffling.
229 | 
230 | Contributors
231 | ------------
232 | 
233 | Original f5 algorithm is by Andreas Westfeld. https://code.google.com/p/f5-steganography/
234 | 
235 | JavaScript port of f5 algorithm and jpeg codec optimizations by [desudesutalk](https://github.com/desudesutalk).
236 | 
237 | Code of this lib is based on [js-steg](https://github.com/owencm/js-steg) by Owen Campbell-Moore. js-steg uses code from:
238 | 
239 |  * [notmasteryet](https://github.com/notmasteryet/jpgjs) (jpeg decoding)
240 |  * Andreas Ritter (jpeg encoding)
241 | 
242 | License
243 | -------
244 | Released under MIT. See [LICENSE.txt](LICENSE.txt)


--------------------------------------------------------------------------------
/f5stego.min.js:
--------------------------------------------------------------------------------
1 | /*! f5stegojs v0.1.2 | MIT license | https://github.com/desudesutalk/f5stegojs#readme */
2 | !function(a,b){"use strict";"function"==typeof define&&define.amd?define([],b):"object"==typeof exports?module.exports=b():a.f5stego=b()}(this,function(){"use strict";function a(){for(var a=1,b=2,e=1;e<=15;e++){for(var f=a;f<b;f++)d[32767+f]=e,c[32767+f]=[],c[32767+f][1]=e,c[32767+f][0]=f;for(var g=-(b-1);g<=-a;g++)d[32767+g]=e,c[32767+g]=[],c[32767+g][1]=e,c[32767+g][0]=b-1+g;a<<=1,b<<=1}}function b(a,b){for(var c=0,d=0,e=[],f=1;f<=16;f++){for(var g=1;g<=a[f];g++)e[b[d]]=[],e[b[d]][0]=c,e[b[d]][1]=f,d++,c++;c*=2}return e}var f5stego=function(a,b){this.a=b||16777216,this.b(a)};f5stego.prototype.b=function(a){if(this.c=new ArrayBuffer(4.125*this.a),!a.length)throw"key needed";var b=0,c=0,d=0,e=0,f=new Uint8Array(256),g=new Uint8Array(this.c);for(b=0;b<256;++b)f[b]=b;for(b=0;b<256;++b)c=c+f[b]+a[b%a.length]&255,d=f[b],f[b]=f[c],f[c]=d;for(b=0,c=0,e=0;e<4.125*this.a;++e)b=b+1&255,c=c+f[b]&255,d=f[b],f[b]=f[c],f[c]=d,g[e]=f[d+f[b]&255]},f5stego.prototype.d=function(a){var b,c,d,e,f=new Uint32Array(this.c);if("number"==typeof a)for(c=a,a=new Uint32Array(c),d=1;d<c;d++)e=f[d]%(d+1),e!=d&&(a[d]=a[e]),a[e]=d;else for(c=a.length,d=1;d<c;d++)e=f[d]%(d+1),b=a[d],a[d]=a[e],a[e]=b;return{e:a,f:new Uint8Array(this.c,4*c)}},f5stego.prototype.g=function(a){var b,c,d,e,f,g,h,i,j=0,k=0;for(e=0;e<a.length;e++)e%64!==0&&(0===a[e]&&k++,1!=a[e]&&a[e]!=-1||j++);b=a.length-k-j-a.length/64,c=j/(b+j);var l={capacity:[0,(b+.49*j>>3)-1],coeff_total:a.length,coeff_large:b,coeff_zero:k,coeff_one:j,coeff_one_ratio:j/(b+j)};for(e=2;e<17;e++){for(f=(1<<e)-1,d=b+j,g=0;d>f;)h=d/f/(1<<e)/(1<<e)|0,d-=h*f,i=d*(1-c)/f*.96|0,d-=i*f,g+=i+h,f++;l.capacity[e]=(e*g>>3)-1}return l},f5stego.prototype.h=function(a,b,c){var d,e,f,g=a.length,h=0,i=0,j=0,k=0,l=0,m=this.d(g),n=m.f,o=0;m=m.e;var p=0,q=b.length,r=0,s=0;for(e=(1<<c)-1,q=c-1,q^=n[o++],p=1&q,q>>=1,s=3,f=0;f<g;f++)if(l=m[f],l%64!==0&&0!==a[l]){var t=a[l];if(j++,t>0&&(1&t)!=p?(a[l]--,h++):t<0&&(1&t)==p&&(a[l]++,h++),0!==a[l]){if(i++,0===s){if(1!=c||r>=b.length)break;q=b[r++],q^=n[o++],s=8}p=1&q,q>>=1,s--}else k++}if(1==c&&i<8*b.length)throw"capacity exceeded "+i/8+" "+b.length;if(1!=c)for(var u=!1,v=0;!u||0!==s&&u;){for(v=0,d=0;d<c;d++){if(0===s){if(r>=b.length){u=!0;break}q=b[r++],q^=n[o++],s=8}p=1&q,q>>=1,s--,v|=p<<d}var w=[],x=null;for(d=0;d<e;d++){for(;;){if(++f>=g)throw"capacity exceeded "+i/8;if(x=m[f],x%64!==0&&0!==a[x])break}w.push(x)}for(j+=e;;){var y,z=0;for(d=0;d<w.length;d++)y=a[w[d]]>0?1&a[w[d]]:1-(1&a[w[d]]),1==y&&(z^=d+1);if(d=z^v,!d){i+=c;break}if(d--,a[w[d]]+=a[w[d]]<0?1:-1,h++,0!==a[w[d]]){i+=c;break}for(k++,w.splice(d,1);;){if(++f>=g)throw"capacity exceeded "+i/8;if(x=m[f],x%64!==0&&0!==a[x])break}j++,w.push(x)}}return{k:c,embedded:i/8,examined:j,changed:h,thrown:k,efficiency:(i/h).toFixed(2)}},f5stego.prototype.analyze=function(){var a,b=this.j.i[0];if(1!=b.l)for(a=0;a<this.j.i.length;a++)if(1==this.j.i[a].l){b=this.j.i[a];break}return this.g(b.m)},f5stego.prototype.f5put=function(a,b){var c,d,e=this.j.i[0];if(a.length>8388607)throw"Data too big. Max 8388607 bytes allowed.";if(a.length<32768?(c=new Uint8Array(2+a.length),c[0]=255&a.length,c[1]=a.length>>>8,c.set(a,2)):(c=new Uint8Array(3+a.length),c[0]=255&a.length,c[1]=(a.length>>>8&127)+128,c[2]=a.length>>>15,c.set(a,3)),1!=e.l)for(d=0;d<this.j.i.length;d++)if(1==this.j.i[d].l){e=this.j.i[d];break}if(b)return this.h(e.m,c,b);var f,g=this.g(e.m);for(b=0,d=g.capacity.length-1;d>=0;d--)if(g.capacity[d]>=c.length){b=d;break}if(0===b)throw"capacity exceeded";try{f=this.h(e.m,c,b)}catch(a){if(b--,0===b)throw"capacity exceeded";f=this.h(e.m,c,b)}return f.stats=g,f},f5stego.prototype.f5get=function(){var a=this.j.i[0];if(1!=a.l)for(var b=0;b<this.j.i.length;b++)if(1==this.j.i[b].l){a=this.j.i[b];break}var c=new Int16Array(a.m.length);c.set(a.m);for(var d,e=-1,f=0,g=c.length-1,h=this.d(c),i=h.f,j=0,k=0,l=new Uint8Array(c.length/8|0),m=0,n=0,o=0,p=0,q=0;o<4;)e++,0!==c[e]&&(f=1&c[e],c[e]<0&&(f=1-f),k|=f<<o,o++);if(k=(k^15&i[j++])+1,d=(1<<k)-1,o=0,1==k)for(;e<g;)e++,0!==c[e]&&(f=1&c[e],c[e]<0&&(f=1-f),m|=f<<o,o++,8==o&&(l[n++]=m^i[j++],m=0,o=0));else for(;e<g;)if(e++,0!==c[e]&&(f=1&c[e],c[e]<0&&(f=1-f),q^=f*++p,p==d))for(m|=q<<o,o+=k,p=0,q=0;o>=8;)l[n++]=255&m^i[j++],o-=8,m>>=8;for(;o>0;)l[n++]=255&m^i[j++],o-=8,m>>=8;var r=2,s=l[0];return 128&l[1]?(r++,s+=((127&l[1])<<8)+(l[2]<<15)):s+=l[1]<<8,l.subarray(r,r+s)},f5stego.prototype.parse=function(a){function b(a,b){for(var c=0,d=0,e=new Uint16Array(65536),f=0;f<16;f++){for(var g=0;g<a[f];g++){for(var h=c<<15-f,i=c+1<<15-f;h<i;h++)e[h]=b[d]+(f+1<<8);d++,c++}c*=2}return e}function c(a,b,c,d,e,f,g,h,i){function j(c,d){for(;r<16;)q=(q<<8)+(0|a[b]),r+=8,255==a[b]&&b++,b++;var e=c.n[q>>>r-16&65535];if(!e)throw"invalid huffman sequence";r-=e>>>8,e&=255;var f=0;if(0!==e){for(;r<e;)q=(q<<8)+a[b++],255==(255&q)&&b++,r+=8;f=q>>>r-e&(1<<e)-1,r-=e,f<1<<e-1&&(f+=(-1<<e)+1)}c.o[d>>6]=c.p+=f;for(var g,h,i=1;i<64;){for(;r<16;)q=(q<<8)+(0|a[b]),r+=8,255==a[b]&&b++,b++;if(g=c.q[q>>>r-16&65535],!g)throw"invalid huffman sequence";if(r-=g>>>8,h=g>>4&15,g&=15,0!==g){for(i+=h;r<g;)q=(q<<8)+a[b++],255==(255&q)&&b++,r+=8;c.m[d+i]=q>>>r-g&(1<<g)-1,r-=g,c.m[d+i]<1<<g-1&&(c.m[d+i]+=(-1<<g)+1),i++}else{if(h<15)break;i+=16}}}function k(c,d){for(var e=0;r<16;)q=(q<<8)+(0|a[b]),r+=8,255==a[b]&&b++,b++;var f=c.n[q>>>r-16&65535];if(!f)throw"invalid huffman sequence";if(r-=f>>>8,f&=255,0!==f){for(;r<f;)q=(q<<8)+a[b++],255==(255&q)&&b++,r+=8;e=q>>>r-f&(1<<f)-1,r-=f,e<1<<f-1&&(e+=(-1<<f)+1)}c.o[d>>6]=c.p+=e<<i}function l(c,d){r||(q=a[b++],255==q&&b++,r=8),c.o[d>>6]|=(q>>>--r&1)<<i}function m(c,d){if(s>0)return void s--;for(var e,h,i=f;i<=g;){for(;r<16;)q=(q<<8)+(0|a[b]),r+=8,255==a[b]&&b++,b++;if(e=c.q[q>>>r-16&65535],!e)throw"invalid huffman sequence";if(r-=e>>>8,h=e>>4&15,e&=15,0!==e){for(i+=h;r<e;)q=(q<<8)+a[b++],255==(255&q)&&b++,r+=8;c.m[d+i]=q>>>r-e&(1<<e)-1,r-=e,c.m[d+i]<1<<e-1&&(c.m[d+i]+=(-1<<e)+1),c.m[d+i]*=t,i++}else{if(15!=h){if(s=(1<<h)-1,h){for(;r<h;)q=(q<<8)+a[b++],255==(255&q)&&b++,r+=8;s+=q>>>r-h&(1<<h)-1,r-=h}break}i+=16}}}function n(c,d){var e,h,i=f;if(!s)for(;i<=g;){for(;r<16;)q=(q<<8)+(0|a[b]),r+=8,255==a[b]&&b++,b++;if(h=c.q[q>>>r-16&65535],!h)throw"invalid huffman sequence";if(r-=h>>>8,e=h>>4&15,h&=15){if(1!=h)throw"bad jpeg";r||(q=a[b++],255==q&&b++,r=8),h=q>>>--r&1?t:u}else if(15!=e){if(s=1<<e,e){for(;r<e;)q=(q<<8)+a[b++],255==(255&q)&&b++,r+=8;s+=q>>>r-e&(1<<e)-1,r-=e}break}for(;i<=g;){if(c.m[d+i])r||(q=a[b++],255==q&&b++,r=8),c.m[d+i]+=(q>>>--r&1)*(c.m[d+i]>=0?t:u);else if(--e<0)break;i++}h&&(c.m[d+i]=h),i++}if(s){for(;i<=g;)c.m[d+i]&&(r||(q=a[b++],255==q&&b++,r=8),c.m[d+i]+=(q>>>--r&1)*(c.m[d+i]>=0?t:u)),i++;s--}}var o,p=b,q=0,r=0,s=0,t=1<<i,u=-1<<i;o=c.r?0===f?0===h?k:l:0===h?m:n:j;var v,w,x,y,z,A,B,C,D,E;if(1==d.length)for(B=d[0].s,C=d[0].t,w=C*B,e||(e=w),A=e,d[0].p=0,s=0,E=0;E<C;E++)for(D=0;D<B;D++){if(!A){if(A=e,d[0].p=0,s=0,b-=r/8|0,255==a[b-1]&&b--,r=0,v=a[b]<<8|a[b+1],!(v>=65488&&v<=65495)){if(v<=65280)throw"bad jpeg";break}b+=2}for(A--,x=0;x<d.length;x++)o(d[x],64*(E*d[x].u+D))}else{for(B=c.v,C=c.w,w=C*B,e||(e=w),A=e,x=0;x<d.length;x++)d[x].p=0;for(s=0,E=0;E<C;E++)for(D=0;D<B;D++){if(!A){for(A=e,x=0;x<d.length;x++)d[x].p=0;if(s=0,b-=r/8|0,255==a[b-1]&&b--,r=0,v=a[b]<<8|a[b+1],!(v>=65488&&v<=65495)){if(v<=65280)throw"bad jpeg";break}b+=2}for(A--,x=0;x<d.length;x++)for(y=0;y<d[x].x;y++)for(z=0;z<d[x].y;z++)o(d[x],64*((E*d[x].x+y)*d[x].u+D*d[x].y+z))}}return b-=r/8|0,255==a[b-1]&&b--,b-p}function d(){var b=a[f]<<8|a[f+1];return f+=2,b}function e(){var b=d(),c=a.subarray(f,f+b-2);return f+=c.length,c}var f=0;this.z=a,this.A=null,this.B=[],this.C=[],this.j=null,this.D=null;for(var g,h,i,j,k,l,m=[],n=[];;){if(f>=a.length)throw"unexpected EOF";if(g=a[f++],h=a[f++],255==g){if(224==h&&(this.A=e()),(h>224&&h<240||254==h)&&this.B.push({app:h,data:e()}),219==h&&this.C.push(e()),h>=192&&h<=194){if(this.j)throw"Only single frame JPEGs supported";if(d(),this.j={E:193===h,r:194===h,F:a[f++],G:d(),H:d(),i:[],I:{},J:1,K:1},this.j.G*this.j.H>this.a)throw"Image is too big.";var o,p=a[f++],q=0,r=0;for(i=0;i<p;i++){o=a[f];var s=a[f+1]>>4,t=15&a[f+1];q<s&&(q=s),r<t&&(r=t);var u=a[f+2],v=this.j.i.push({l:o,y:s,x:t,L:u});this.j.I[o]=v-1,f+=3}this.j.J=q,this.j.K=r;var w=Math.ceil(this.j.H/8/q),x=Math.ceil(this.j.G/8/r);for(i=0;i<this.j.i.length;i++){l=this.j.i[i];var y=Math.ceil(Math.ceil(this.j.H/8)*l.y/q),z=Math.ceil(Math.ceil(this.j.G/8)*l.x/r),A=w*l.y,B=x*l.x;l.m=new Int16Array(B*A*64),l.o=new Int16Array(B*A),l.s=y,l.t=z,l.u=A,l.M=B}this.j.v=w,this.j.w=x}if(196==h){var C=d();for(i=2;i<C;){var D=a[f++],E=new Uint8Array(16),F=0;for(j=0;j<16;j++,f++)F+=E[j]=a[f];var G=new Uint8Array(F);for(j=0;j<F;j++,f++)G[j]=a[f];i+=17+F,(D>>4===0?n:m)[15&D]=b(E,G)}}if(221==h&&(k=d()),218==h){d();var H=a[f++],I=[];for(i=0;i<H;i++){var J=this.j.I[a[f++]];l=this.j.i[J];var K=a[f++];l.n=n[K>>4],l.q=m[15&K],I.push(l)}var L=a[f++],M=a[f++],N=a[f++],O=c(a,f,this.j,I,k,L,M,N>>4,15&N);f+=O}if(217==h)break}else{for(255==a[f-3]&&a[f-2]>=192&&a[f-2]<=254&&(f-=3);255!=a[f]&&f<a.length;)f++;if(255!=a[f])throw"bad jpeg "}}if(!this.j)throw"bad jpeg";return f<a.length&&(this.D=a.subarray(f)),this};var c=new Array(65535),d=new Array(65535),e=[0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0],f=[0,1,2,3,4,5,6,7,8,9,10,11],g=[0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,125],h=[1,2,3,0,4,17,5,18,33,49,65,6,19,81,97,7,34,113,20,50,129,145,161,8,35,66,177,193,21,82,209,240,36,51,98,114,130,9,10,22,23,24,25,26,37,38,39,40,41,42,52,53,54,55,56,57,58,67,68,69,70,71,72,73,74,83,84,85,86,87,88,89,90,99,100,101,102,103,104,105,106,115,116,117,118,119,120,121,122,131,132,133,134,135,136,137,138,146,147,148,149,150,151,152,153,154,162,163,164,165,166,167,168,169,170,178,179,180,181,182,183,184,185,186,194,195,196,197,198,199,200,201,202,210,211,212,213,214,215,216,217,218,225,226,227,228,229,230,231,232,233,234,241,242,243,244,245,246,247,248,249,250],i=[0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0],j=[0,1,2,3,4,5,6,7,8,9,10,11],k=[0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,119],l=[0,1,2,3,17,4,5,33,49,6,18,65,81,7,97,113,19,34,50,129,8,20,66,145,161,177,193,9,35,51,82,240,21,98,114,209,10,22,36,52,225,37,241,23,24,25,26,38,39,40,41,42,53,54,55,56,57,58,67,68,69,70,71,72,73,74,83,84,85,86,87,88,89,90,99,100,101,102,103,104,105,106,115,116,117,118,119,120,121,122,130,131,132,133,134,135,136,137,138,146,147,148,149,150,151,152,153,154,162,163,164,165,166,167,168,169,170,178,179,180,181,182,183,184,185,186,194,195,196,197,198,199,200,201,202,210,211,212,213,214,215,216,217,218,226,227,228,229,230,231,232,233,234,242,243,244,245,246,247,248,249,250];a();var m=b(e,f),n=b(i,j),o=b(g,h),p=b(k,l);return f5stego.prototype.pack=function(){function a(a){var b;y[C++]=a,C>B&&(b=new Uint8Array(2*y.length),b.set(y),y=b,B=b.length-128)}function b(b){a(b>>8&255),a(255&b)}function q(a){var b;C+a.length>B&&(b=new Uint8Array(2*y.length+a.length),b.set(y),y=b,B=b.length-128),y.set(a,C),C+=a.length}function r(c){b(65504),c.A?(b(c.A.length+2),q(c.A)):(b(16),a(74),a(70),a(73),a(70),a(0),a(1),a(1),a(0),b(1),b(1),a(0),a(0))}function s(a){for(var c=0;c<a.C.length;c++)b(65499),b(a.C[c].length+2),q(a.C[c])}function t(a){for(var c=0;c<a.B.length;c++)b(65280|a.B[c].app),b(a.B[c].data.length+2),q(a.B[c].data)}function u(c){b(65472),b(8+3*c.j.i.length),a(c.j.F),b(c.j.G),b(c.j.H),a(c.j.i.length);for(var d=0;d<c.j.i.length;d++){var e=c.j.i[d];a(e.l),a(e.y<<4|e.x),a(e.L)}}function v(c){b(65476),b(31),a(0);for(var d=0;d<16;d++)a(e[d+1]);for(var m=0;m<=11;m++)a(f[m]);b(65476),b(181),a(16);for(var n=0;n<16;n++)a(g[n+1]);for(var o=0;o<=161;o++)a(h[o]);if(1!=c.j.i.length){b(65476),b(31),a(1);for(var p=0;p<16;p++)a(i[p+1]);for(var q=0;q<=11;q++)a(j[q]);b(65476),b(181),a(17);for(var r=0;r<16;r++)a(k[r+1]);for(var s=0;s<=161;s++)a(l[s])}}function w(c){b(65498),b(6+2*c.j.i.length),a(c.j.i.length);for(var d=0;d<c.j.i.length;d++){var e=c.j.i[d];a(e.l),a(0===d?0:17)}a(0),a(63),a(0)}function x(a,b,e,f,g){var h,i,j;0===A&&(z=0);var k=a.o[b>>6]-e;if(e=a.o[b>>6],0===k)for(i=f[0][1],z<<=i,z+=f[0][0],A+=i;A>7;)D=255&z>>>A-8,y[C++]=D,255==D&&C++,A-=8,z&=(1<<A)-1;else for(h=32767+k,i=f[d[h]][1],z<<=i,z+=f[d[h]][0],A+=i,i=c[h][1],z<<=i,z+=c[h][0],A+=i;A>7;)D=255&z>>>A-8,y[C++]=D,255==D&&C++,A-=8,z&=(1<<A)-1;for(var l=63;l>0&&0===a.m[b+l];l--);if(0===l){for(i=g[0][1],z<<=i,z+=g[0][0],A+=i;A>7;)D=255&z>>>A-8,y[C++]=D,255==D&&C++,A-=8,z&=(1<<A)-1;return e}for(var m,n=1;n<=l;){for(var o=n;0===a.m[b+n]&&n<=l;++n);var p=n-o;if(p>=16){m=p>>4;for(var q=1;q<=m;++q)for(i=g[240][1],z<<=i,z+=g[240][0],A+=i;A>7;)D=255&z>>>A-8,y[C++]=D,255==D&&C++,A-=8,z&=(1<<A)-1;p=15&p}for(h=32767+a.m[b+n],i=g[(p<<4)+d[h]][1],z<<=i,z+=g[(p<<4)+d[h]][0],A+=i;A>7;)D=255&z>>>A-8,y[C++]=D,255==D&&C++,A-=8,z&=(1<<A)-1;for(i=c[h][1],z<<=i,z+=c[h][0],A+=i;A>7;)D=255&z>>>A-8,y[C++]=D,255==D&&C++,A-=8,z&=(1<<A)-1;n++}if(63!=l)for(i=g[0][1],z<<=i,z+=g[0][0],A+=i;A>7;)D=255&z>>>A-8,y[C++]=D,255==D&&C++,A-=8,z&=(1<<A)-1;return C>B&&(j=new Uint8Array(2*y.length),j.set(y),y=j,B=j.length-128),e}var y,z,A,B,C,D;y=new Uint8Array(65536),B=65408,C=0,z=0,A=0,b(65496),r(this),t(this),s(this),u(this),v(this),w(this),z=0,A=0;var E,F,G,H,I,J,K,L,M,N=[];for(K=0;K<this.j.i.length;K++)N.push(0);for(J=0;J<this.j.v*this.j.w;J++)for(F=J/this.j.v|0,G=J%this.j.v,K=0;K<this.j.i.length;K++)for(E=this.j.i[K],L=0;L<E.x;L++)for(H=F*E.x+L,M=0;M<E.y;M++)I=G*E.y+M,0===K?N[K]=x(E,64*(H*this.j.v*E.y+I),N[K],m,o):N[K]=x(E,64*(H*this.j.v*E.y+I),N[K],n,p);for(;A>7;)D=255&z>>>A-8,y[C++]=D,255==D&&C++,A-=8;return A>0&&(z<<=8-A,z+=(1<<8-A)-1,y[C++]=255&z),b(65497),this.D&&q(this.D),y.slice(0,C)},f5stego.prototype.clearTail=function(){if(!this.D)return null;var a=this.D;return this.D=null,a},f5stego.prototype.N=function(a){this.D=a},f5stego.prototype.getTail=function(){return this.D},f5stego.prototype.clearAPPs=function(){var a=this.B;return this.B=[],a},f5stego.prototype.getAPPn=function(a,b){var c,d,e=new Uint8Array(0),f=[];if(a&=255,a<16&&(a+=224),224===a)return this.A;for(c=0;c<this.B.length;c++)this.B[c].app==a?(d=new Uint8Array(e.length+this.B[c].data.length),d.set(e),d.set(this.B[c].data,e.length),e=d):b&&f.push(this.B[c]);return b&&(this.B=f),0===e.length?null:e},f5stego.prototype.setAPPn=function(a,b){var c,d,e;if(a&=255,a<16&&(a+=224),224===a)return d=this.A,this.A=b,d;if(e=this.getAPPn(a,!0),b.length<65534)return this.B.push({app:a,data:b}),e;for(c=0;c<b.length;)this.B.push({app:a,data:b.subarray(c,c+65533)}),c+=65533;return e},f5stego.prototype.strip=function(){return this.clearTail(),this.clearAPPs(),!0},f5stego.prototype.embed=function(a,b){return this.parse(a).f5put(b),this.pack()},f5stego.prototype.extract=function(a){return this.parse(a).f5get()},f5stego});


--------------------------------------------------------------------------------
/extra/f5extract.js:
--------------------------------------------------------------------------------
  1 | /*	This software is licensed under the MIT License.
  2 | 
  3 | 	Copyright (c) 2016 desudesutalk
  4 | 
  5 | 	Permission is hereby granted, free of charge, to any person obtaining a copy of
  6 | 	this software and associated documentation files (the "Software"), to deal in
  7 | 	the Software without restriction, including without limitation the rights to
  8 | 	use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  9 | 	the Software, and to permit persons to whom the Software is furnished to do so,
 10 | 	subject to the following conditions:
 11 | 
 12 | 	The above copyright notice and this permission notice shall be included in all
 13 | 	copies or substantial portions of the Software.
 14 | 
 15 | 	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 | 	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 17 | 	FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 18 | 	COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 19 | 	IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 20 | 	CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 21 | 
 22 | 	https://github.com/desudesutalk/f5stegojs
 23 | 
 24 | 	This library is based on https://github.com/owencm/js-steg by Owen Campbell-
 25 | 	Moore. Decoder and encoder was optimized for speed, F5 algorithm and metadata
 26 | 	manipulation utils was added to library.
 27 | 
 28 | 	Original code was released under MIT and Apache licenses, so here follows
 29 | 	original licenses of Owen code:
 30 | 
 31 | 	jpeg decoder license:
 32 | 
 33 | 	Modified JPEG decoder for Steganography by Owen Campbell-Moore, based on one
 34 | 	released by Adobe.
 35 | 
 36 | 	Copyright 2011 notmasteryet
 37 | 
 38 | 	Licensed under the Apache License, Version 2.0 (the "License"); you may not use
 39 | 	this file except in compliance with the License. You may obtain a copy of the
 40 | 	License at
 41 | 
 42 | 	http://www.apache.org/licenses/LICENSE-2.0
 43 | 
 44 | 	Unless required by applicable law or agreed to in writing, software distributed
 45 | 	under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 46 | 	CONDITIONS OF ANY KIND, either express or implied. See the License for the
 47 | 	specific language governing permissions and limitations under the License.
 48 | 	*/
 49 | 
 50 | /* exported f5extract */
 51 | function f5extract(key, maxPixels) {
 52 | 	'use strict';
 53 | 
 54 | 	maxPixels = maxPixels || 4096 * 4096;
 55 | 
 56 | 	var randPool = new ArrayBuffer(maxPixels * 4.125),
 57 | 		rand32Array = new Uint32Array(randPool),
 58 | 		i, j, t;
 59 | 
 60 | 	var k = 0,
 61 | 		S = new Uint8Array(256),
 62 | 		rnd = new Uint8Array(randPool);
 63 | 	i = 0;
 64 | 	j = 0;
 65 | 	t = 0;
 66 | 	// init state from key
 67 | 	for (i = 0; i < 256; ++i) S[i] = i;
 68 | 
 69 | 	for (i = 0; i < 256; ++i) {
 70 | 		j = (j + S[i] + key[i % key.length]) & 255;
 71 | 		t = S[i];
 72 | 		S[i] = S[j];
 73 | 		S[j] = t;
 74 | 	}
 75 | 	i = 0;
 76 | 	j = 0;
 77 | 
 78 | 	// shuffle data
 79 | 	for (k = 0; k < maxPixels * 4.125; ++k) {
 80 | 		i = (i + 1) & 255;
 81 | 		j = (j + S[i]) & 255;
 82 | 		t = S[i];
 83 | 		S[i] = S[j];
 84 | 		S[j] = t;
 85 | 		rnd[k] = S[(t + S[i]) & 255];
 86 | 	}
 87 | 
 88 | 	function stegShuffle(pm) {
 89 | 		var k, random_index;
 90 | 
 91 | 		for (k = 1; k < pm.length; k++) {
 92 | 			random_index = rand32Array[k] % (k + 1);
 93 | 			if (random_index != k) {
 94 | 				t = pm[k];
 95 | 				pm[k] = pm[random_index];
 96 | 				pm[random_index] = t;
 97 | 			}
 98 | 		}
 99 | 
100 | 		return new Uint8Array(randPool, pm.length * 4);
101 | 	}
102 | 
103 | 	function _f5read(coeff) {
104 | 		var pos = -1,
105 | 			extrBit = 0,
106 | 			cCount = coeff.length - 1;
107 | 
108 | 		var gamma = stegShuffle(coeff),
109 | 			gammaI = 0;
110 | 
111 | 		var n, k = 0;
112 | 
113 | 		var out = new Uint8Array((coeff.length / 8) | 0),
114 | 			extrByte = 0,
115 | 			outPos = 0,
116 | 			bitsAvail = 0,
117 | 			code = 0,
118 | 			hash = 0;
119 | 
120 | 		while (bitsAvail < 4) {
121 | 			pos++;
122 | 
123 | 			if (coeff[pos] === 0) {
124 | 				continue;
125 | 			}
126 | 
127 | 			extrBit = coeff[pos] & 1;
128 | 
129 | 
130 | 			if (coeff[pos] < 0) {
131 | 				extrBit = 1 - extrBit;
132 | 			}
133 | 
134 | 			k |= extrBit << bitsAvail;
135 | 			bitsAvail++;
136 | 		}
137 | 
138 | 		k = (k ^ gamma[gammaI++] & 15) + 1;
139 | 		n = (1 << k) - 1;
140 | 
141 | 		bitsAvail = 0;
142 | 
143 | 		if (k == 1) {
144 | 			while (pos < cCount) {
145 | 				pos++;
146 | 
147 | 				if (coeff[pos] === 0) {
148 | 					continue;
149 | 				}
150 | 
151 | 				extrBit = coeff[pos] & 1;
152 | 
153 | 				if (coeff[pos] < 0) {
154 | 					extrBit = 1 - extrBit;
155 | 				}
156 | 
157 | 				extrByte |= extrBit << bitsAvail;
158 | 				bitsAvail++;
159 | 
160 | 				if (bitsAvail == 8) {
161 | 					out[outPos++] = extrByte ^ gamma[gammaI++];
162 | 					extrByte = 0;
163 | 					bitsAvail = 0;
164 | 				}
165 | 			}
166 | 		} else {
167 | 			while (pos < cCount) {
168 | 				pos++;
169 | 
170 | 				if (coeff[pos] === 0) {
171 | 					continue;
172 | 				}
173 | 
174 | 				extrBit = coeff[pos] & 1;
175 | 
176 | 				if (coeff[pos] < 0) {
177 | 					extrBit = 1 - extrBit;
178 | 				}
179 | 
180 | 				hash ^= extrBit * ++code;
181 | 
182 | 				if (code == n) {
183 | 					extrByte |= hash << bitsAvail;
184 | 					bitsAvail += k;
185 | 					code = 0;
186 | 					hash = 0;
187 | 
188 | 					while (bitsAvail >= 8) {
189 | 						out[outPos++] = (extrByte & 0xFF) ^ gamma[gammaI++];
190 | 						bitsAvail -= 8;
191 | 						extrByte = extrByte >> 8;
192 | 					}
193 | 				}
194 | 			}
195 | 		}
196 | 
197 | 		while (bitsAvail > 0) {
198 | 			out[outPos++] = (extrByte & 0xFF) ^ gamma[gammaI++];
199 | 			bitsAvail -= 8;
200 | 			extrByte = extrByte >> 8;
201 | 		}
202 | 		var s = 2,
203 | 			l = out[0];
204 | 
205 | 		if (out[1] & 128) {
206 | 			s++;
207 | 			l += ((out[1] & 127) << 8) + (out[2] << 15);
208 | 		} else {
209 | 			l += out[1] << 8;
210 | 		}
211 | 
212 | 		return out.subarray(s, s + l);
213 | 	}
214 | 
215 | 	function _buildHuffmanTable(nrcodes, values) {
216 | 		var codevalue = 0,
217 | 			pos_in_table = 0,
218 | 			HT = new Uint16Array(65536);
219 | 		for (var k = 0; k < 16; k++) {
220 | 			for (var j = 0; j < nrcodes[k]; j++) {
221 | 				for (var i = codevalue << (15 - k), cntTo = ((codevalue + 1) << (15 - k)); i < cntTo; i++) {
222 | 					HT[i] = values[pos_in_table] + ((k + 1) << 8);
223 | 				}
224 | 				pos_in_table++;
225 | 				codevalue++;
226 | 			}
227 | 			codevalue *= 2;
228 | 		}
229 | 		return HT;
230 | 	}
231 | 
232 | 	function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive) {
233 | 
234 | 		var startOffset = offset,
235 | 			bitsData = 0,
236 | 			bitsCount = 0,
237 | 			eobrun = 0,
238 | 			p1 = 1 << successive,  /*  1 in the bit position being coded */
239 | 			m1 = -1 << successive; /* -1 in the bit position being coded */
240 | 
241 | 		function decodeHuffman(t) {
242 | 			while (bitsCount < 16) {
243 | 				bitsData = (bitsData << 8) + (data[offset] | 0);
244 | 				bitsCount += 8;
245 | 				if (data[offset] == 0xFF) offset++;
246 | 				offset++;
247 | 			}
248 | 			t = t[(bitsData >>> (bitsCount - 16)) & 0xFFFF];
249 | 			if (!t) throw "invalid huffman sequence";
250 | 			bitsCount -= t >>> 8;
251 | 			return t & 255;
252 | 		}
253 | 
254 | 		function receiveAndExtend(r) {
255 | 			while (bitsCount < r) {
256 | 				bitsData = (bitsData << 8) + data[offset++];
257 | 				if ((bitsData & 0xff) == 0xFF) offset++;
258 | 				bitsCount += 8;
259 | 			}
260 | 			var n = (bitsData >> (bitsCount - r)) & ((1 << r) - 1);
261 | 			bitsCount -= r;
262 | 			if (n < 1 << (r - 1)) n += (-1 << r) + 1;
263 | 			return n;
264 | 		}
265 | 
266 | 		function receive(t) {
267 | 			while (bitsCount < t) {
268 | 				bitsData = (bitsData << 8) + data[offset++];
269 | 				if ((bitsData & 0xff) == 0xFF) offset++;
270 | 				bitsCount += 8;
271 | 			}
272 | 			var n = (bitsData >>> (bitsCount - t)) & ((1 << t) - 1);
273 | 			bitsCount -= t;
274 | 			return n;
275 | 		}
276 | 
277 | 		function getBit() {
278 | 			if (!bitsCount) {
279 | 				bitsData = data[offset++];
280 | 				if (bitsData == 0xFF) offset++;
281 | 				bitsCount = 8;
282 | 			}
283 | 			return (bitsData >>> --bitsCount) & 1;
284 | 		}
285 | 
286 | 		function decodeBaseline(component, pos) {
287 | 			var t = decodeHuffman(component.huffmanTableDC);
288 | 			var diff = 0;
289 | 			if (t !== 0) {
290 | 				diff = receiveAndExtend(t);
291 | 			}
292 | 			component.pred += diff;
293 | 
294 | 			var k = 1,
295 | 				s, r;
296 | 			while (k < 64) {
297 | 				s = decodeHuffman(component.huffmanTableAC);
298 | 
299 | 				r = s >> 4;
300 | 				s &= 15;
301 | 
302 | 				if (s === 0) {
303 | 					if (r < 15) {
304 | 						break;
305 | 					}
306 | 					k += 16;
307 | 					continue;
308 | 				}
309 | 				k += r;
310 | 				component.blocks[pos + k] = receiveAndExtend(s);
311 | 				k++;
312 | 			}
313 | 		}
314 | 
315 | 		function decodeDCFirst(component) {
316 | 			var diff = 0,
317 | 				t = decodeHuffman(component.huffmanTableDC);
318 | 			if (t !== 0) {
319 | 				diff = receiveAndExtend(t);
320 | 			}
321 | 			component.pred += diff << successive;
322 | 		}
323 | 
324 | 		function decodeACFirst(component, pos) {
325 | 			if (eobrun > 0) {
326 | 				eobrun--;
327 | 				return;
328 | 			}
329 | 
330 | 			var k = spectralStart,
331 | 				s, r;
332 | 
333 | 			while (k <= spectralEnd) {
334 | 				s = decodeHuffman(component.huffmanTableAC);
335 | 				r = s >> 4;
336 | 				s &= 15;
337 | 				if (s === 0) {
338 | 					if (r != 15) {
339 | 						eobrun = (1 << r) - 1;
340 | 						if (r) {
341 | 							eobrun += receive(r);
342 | 						}
343 | 						break;
344 | 					}
345 | 					k += 16;
346 | 					continue;
347 | 				}
348 | 
349 | 				k += r;
350 | 				component.blocks[pos + k] = receiveAndExtend(s) * p1;
351 | 				k++;
352 | 			}
353 | 		}
354 | 
355 | 		function decodeACSuccessive(component, pos) {
356 | 			var k = spectralStart,
357 | 				r, s;
358 | 
359 | 			if (!eobrun) {
360 | 				while (k <= spectralEnd) {
361 | 					s = decodeHuffman(component.huffmanTableAC);
362 | 					r = s >> 4;
363 | 					s &= 15;
364 | 
365 | 					if (s) {
366 | 						if (s != 1) throw "bad jpeg";
367 | 						if (getBit()) s = p1;
368 | 						else s = m1;
369 | 					} else {
370 | 						if (r != 15) {
371 | 							eobrun = (1 << r);
372 | 							if (r) {
373 | 								eobrun += receive(r);
374 | 							}
375 | 							break;
376 | 						}
377 | 					}
378 | 
379 | 					while (k <= spectralEnd) {
380 | 						if (component.blocks[pos + k]) {
381 | 							component.blocks[pos + k] += getBit() * (component.blocks[pos + k] >= 0 ? p1 : m1);
382 | 						} else {
383 | 							if (--r < 0) break;
384 | 						}
385 | 						k++;
386 | 					}
387 | 
388 | 					if (s) component.blocks[pos + k] = s;
389 | 					k++;
390 | 				}
391 | 			}
392 | 
393 | 			if (eobrun) {
394 | 				while (k <= spectralEnd) {
395 | 					if (component.blocks[pos + k]) {
396 | 						component.blocks[pos + k] += getBit() * (component.blocks[pos + k] >= 0 ? p1 : m1);
397 | 					}
398 | 					k++;
399 | 				}
400 | 				eobrun--;
401 | 			}
402 | 		}
403 | 
404 | 		var decodeFn;
405 | 
406 | 		if (frame.progressive) {
407 | 			if (spectralStart === 0)
408 | 				decodeFn = successivePrev === 0 ? decodeDCFirst : getBit;
409 | 			else
410 | 				decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
411 | 		} else {
412 | 			decodeFn = decodeBaseline;
413 | 		}
414 | 
415 | 		var marker, mcuExpected, i, j, k, n, mcusPerLine, mcusPerRow, x, y;
416 | 
417 | 		if (components.length == 1) {
418 | 			mcusPerLine = components[0].blocksPerLine;
419 | 			mcusPerRow = components[0].blocksPerColumn;
420 | 			mcuExpected = mcusPerRow * mcusPerLine;
421 | 
422 | 			if (!resetInterval) resetInterval = mcuExpected;
423 | 			n = resetInterval;
424 | 			components[0].pred = 0;
425 | 			eobrun = 0;
426 | 
427 | 			for (y = 0; y < mcusPerRow; y++) {
428 | 				for (x = 0; x < mcusPerLine; x++) {
429 | 					if (!n) {
430 | 						n = resetInterval;
431 | 						components[0].pred = 0;
432 | 						eobrun = 0;
433 | 
434 | 						// find marker
435 | 						offset -= (bitsCount / 8) | 0;
436 | 						if (data[offset - 1] == 0xFF) offset--;
437 | 						bitsCount = 0;
438 | 						marker = (data[offset] << 8) | data[offset + 1];
439 | 
440 | 						if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx
441 | 							offset += 2;
442 | 						} else {
443 | 							if (marker <= 0xFF00) {
444 | 								throw "bad jpeg";
445 | 							}
446 | 							break;
447 | 						}
448 | 					}
449 | 					n--;
450 | 					for (i = 0; i < components.length; i++) {
451 | 						decodeFn(components[i], (y * components[i].blocksPerLineForMcu + x) * 64);
452 | 					}
453 | 
454 | 				}
455 | 			}
456 | 		} else {
457 | 			mcusPerLine = frame.mcusPerLine;
458 | 			mcusPerRow = frame.mcusPerColumn;
459 | 			mcuExpected = mcusPerRow * mcusPerLine;
460 | 
461 | 			if (!resetInterval) resetInterval = mcuExpected;
462 | 			n = resetInterval;
463 | 			for (i = 0; i < components.length; i++) components[i].pred = 0;
464 | 			eobrun = 0;
465 | 
466 | 			for (y = 0; y < mcusPerRow; y++) {
467 | 				for (x = 0; x < mcusPerLine; x++) {
468 | 					if (!n) {
469 | 						n = resetInterval;
470 | 						for (i = 0; i < components.length; i++) components[i].pred = 0;
471 | 						eobrun = 0;
472 | 
473 | 						// find marker
474 | 						offset -= (bitsCount / 8) | 0;
475 | 						if (data[offset - 1] == 0xFF) offset--;
476 | 						bitsCount = 0;
477 | 						marker = (data[offset] << 8) | data[offset + 1];
478 | 
479 | 						if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx
480 | 							offset += 2;
481 | 						} else {
482 | 							if (marker <= 0xFF00) {
483 | 								throw "bad jpeg";
484 | 							}
485 | 							break;
486 | 						}
487 | 					}
488 | 					n--;
489 | 					for (i = 0; i < components.length; i++) {
490 | 						for (j = 0; j < components[i].v; j++) {
491 | 							for (k = 0; k < components[i].h; k++) {
492 | 								decodeFn(components[i], ((y * components[i].v + j) * components[i].blocksPerLineForMcu + x * components[i].h + k) * 64);
493 | 							}
494 | 						}
495 | 					}
496 | 				}
497 | 			}
498 | 		}
499 | 		offset -= (bitsCount / 8) | 0;
500 | 		if (data[offset - 1] == 0xFF) offset--;
501 | 		return offset - startOffset;
502 | 	}
503 | 
504 | 	function extract(data) {
505 | 
506 | 		function readUint16() {
507 | 			var value = (data[offset] << 8) | data[offset + 1];
508 | 			offset += 2;
509 | 			return value;
510 | 		}
511 | 
512 | 		var frame, offset = 0;
513 | 
514 | 		var markerHi, markerLo, resetInterval, component,
515 | 			huffmanTablesAC = [],
516 | 			huffmanTablesDC = [];
517 | 
518 | 		while (1) {
519 | 			if (offset >= data.length) throw "unexpected EOF";
520 | 
521 | 			markerHi = data[offset++];
522 | 			markerLo = data[offset++];
523 | 
524 | 			if (markerHi == 0xFF) {
525 | 				if ((markerLo >= 0xE0 && markerLo < 0xF0) || markerLo == 0xFE || markerLo == 0xDB) { //APPn + COM
526 | 					offset += readUint16();
527 | 				}
528 | 
529 | 				if (markerLo >= 0xC0 && markerLo <= 0xC2) {
530 | 					// SOF0 (Start of Frame, Baseline DCT)
531 | 					// SOF1 (Start of Frame, Extended DCT)
532 | 					// SOF2 (Start of Frame, Progressive DCT)
533 | 					if (frame) throw "Only single frame JPEGs supported";
534 | 					frame = {};
535 | 					readUint16(); // skip data length
536 | 					offset++;
537 | 					frame.progressive = markerLo === 0xC2;
538 | 					frame.scanLines = readUint16();
539 | 					frame.samplesPerLine = readUint16();
540 | 					frame.components = [];
541 | 					frame.componentIds = {};
542 | 
543 | 					if (frame.scanLines * frame.samplesPerLine > maxPixels) throw "Image is too big.";
544 | 
545 | 					var componentsCount = data[offset++],
546 | 						componentId;
547 | 					var maxH = 0,
548 | 						maxV = 0;
549 | 					for (i = 0; i < componentsCount; i++) {
550 | 						componentId = data[offset];
551 | 						var h = data[offset + 1] >> 4;
552 | 						var v = data[offset + 1] & 15;
553 | 						if (maxH < h) maxH = h;
554 | 						if (maxV < v) maxV = v;
555 | 						frame.componentIds[componentId] = frame.components.push({
556 | 							componentId: componentId,
557 | 							h: h,
558 | 							v: v
559 | 						}) - 1;
560 | 						offset += 3;
561 | 					}
562 | 					frame.maxH = maxH;
563 | 					frame.maxV = maxV;
564 | 
565 | 					var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH);
566 | 					var mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV);
567 | 					for (i = 0; i < frame.components.length; i++) {
568 | 						component = frame.components[i];
569 | 						var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH);
570 | 						var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV);
571 | 						var blocksPerLineForMcu = mcusPerLine * component.h;
572 | 						var blocksPerColumnForMcu = mcusPerColumn * component.v;
573 | 
574 | 						component.blocks = new Int16Array(64 * blocksPerColumnForMcu * blocksPerLineForMcu);
575 | 						component.blocksPerLine = blocksPerLine;
576 | 						component.blocksPerColumn = blocksPerColumn;
577 | 						component.blocksPerLineForMcu = blocksPerLineForMcu;
578 | 						component.blocksPerColumnForMcu = blocksPerColumnForMcu;
579 | 					}
580 | 					frame.mcusPerLine = mcusPerLine;
581 | 					frame.mcusPerColumn = mcusPerColumn;
582 | 				}
583 | 
584 | 				if (markerLo == 0xC4) { // DHT (Define Huffman Tables)
585 | 					var huffmanLength = readUint16();
586 | 					for (i = 2; i < huffmanLength;) {
587 | 						var huffmanTableSpec = data[offset++];
588 | 						var codeLengths = new Uint8Array(16);
589 | 						var codeLengthSum = 0;
590 | 						for (j = 0; j < 16; j++, offset++)
591 | 							codeLengthSum += (codeLengths[j] = data[offset]);
592 | 						var huffmanValues = new Uint8Array(codeLengthSum);
593 | 						for (j = 0; j < codeLengthSum; j++, offset++)
594 | 							huffmanValues[j] = data[offset];
595 | 						i += 17 + codeLengthSum;
596 | 						((huffmanTableSpec >> 4) === 0 ?
597 | 							huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = _buildHuffmanTable(codeLengths, huffmanValues);
598 | 					}
599 | 				}
600 | 
601 | 				if (markerLo == 0xDD) { // DRI (Define Restart Interval)
602 | 					resetInterval = readUint16();
603 | 				}
604 | 
605 | 				if (markerLo == 0xDA) { // SOS (Start of Scan)
606 | 					if (!frame) throw "bad jpeg";
607 | 					readUint16();
608 | 					var selectorsCount = data[offset++];
609 | 					var components = [];
610 | 
611 | 					for (i = 0; i < selectorsCount; i++) {
612 | 						var componentIndex = frame.componentIds[data[offset++]];
613 | 						component = frame.components[componentIndex];
614 | 						var tableSpec = data[offset++];
615 | 						component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
616 | 						component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
617 | 						components.push(component);
618 | 					}
619 | 
620 | 					var spectralStart = data[offset++];
621 | 					var spectralEnd = data[offset++];
622 | 					var successiveApproximation = data[offset++];
623 | 					offset += decodeScan(data, offset,
624 | 						frame, components, resetInterval,
625 | 						spectralStart, spectralEnd,
626 | 						successiveApproximation >> 4, successiveApproximation & 15);
627 | 				}
628 | 
629 | 				if (markerLo == 0xD9) { // EOI (End of image)
630 | 					break;
631 | 				}
632 | 			} else {
633 | 				if (data[offset - 3] == 0xFF &&
634 | 					data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) {
635 | 					// could be incorrect encoding -- last 0xFF byte of the previous
636 | 					// block was eaten by the encoder
637 | 					offset -= 3;
638 | 				}
639 | 				while (data[offset] != 0xFF && offset < data.length) {
640 | 					// file could be damaged and have some extra data between blocks
641 | 					offset++;
642 | 				}
643 | 
644 | 				if (data[offset] != 0xFF) {
645 | 					throw "bad jpeg ";
646 | 				}
647 | 			}
648 | 		}
649 | 
650 | 		if (!frame) throw 'bad jpeg';
651 | 
652 | 		component = frame.components[0];
653 | 
654 | 		if (component.componentId != 1) {
655 | 			for (i = 0; i < frame.components.length; i++) {
656 | 				if (frame.components[i].componentId == 1) {
657 | 					component = frame.components[i];
658 | 					break;
659 | 				}
660 | 			}
661 | 		}
662 | 
663 | 		return _f5read(component.blocks);
664 | 	}
665 | 
666 | 	return extract;
667 | }
668 | 


--------------------------------------------------------------------------------
/f5stego.js:
--------------------------------------------------------------------------------
   1 | /*	This software is licensed under the MIT License.
   2 | 
   3 | 	Copyright (c) 2016 desudesutalk
   4 | 
   5 | 	Permission is hereby granted, free of charge, to any person obtaining a copy of
   6 | 	this software and associated documentation files (the "Software"), to deal in
   7 | 	the Software without restriction, including without limitation the rights to
   8 | 	use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
   9 | 	the Software, and to permit persons to whom the Software is furnished to do so,
  10 | 	subject to the following conditions:
  11 | 
  12 | 	The above copyright notice and this permission notice shall be included in all
  13 | 	copies or substantial portions of the Software.
  14 | 
  15 | 	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 | 	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  17 | 	FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  18 | 	COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  19 | 	IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20 | 	CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21 | 
  22 | 	https://github.com/desudesutalk/f5stegojs
  23 | 
  24 | 	This library is based on https://github.com/owencm/js-steg by Owen Campbell-
  25 | 	Moore. Decoder and encoder was optimized for speed, F5 algorithm and metadata
  26 | 	manipulation utils was added to library.
  27 | 
  28 | 	Original code was released under MIT and Apache licenses, so here follows
  29 | 	original licenses of Owen code:
  30 | 
  31 | 	jpeg decoder license:
  32 | 
  33 | 	Modified JPEG decoder for Steganography by Owen Campbell-Moore, based on one
  34 | 	released by Adobe.
  35 | 
  36 | 	Copyright 2011 notmasteryet
  37 | 
  38 | 	Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  39 | 	this file except in compliance with the License. You may obtain a copy of the
  40 | 	License at
  41 | 
  42 | 	http://www.apache.org/licenses/LICENSE-2.0
  43 | 
  44 | 	Unless required by applicable law or agreed to in writing, software distributed
  45 | 	under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
  46 | 	CONDITIONS OF ANY KIND, either express or implied. See the License for the
  47 | 	specific language governing permissions and limitations under the License.
  48 | 
  49 | 
  50 | 	jpeg encoder license:
  51 | 
  52 | 	JPEG encoder ported to JavaScript, optimized by Andreas Ritter
  53 | 	(www.bytestrom.eu, 11/2009) and made suitable for steganography by Owen
  54 | 	Campbell-Moore (www.owencampbellmoore.com, 03/13)
  55 | 
  56 | 	Based on v 0.9a
  57 | 
  58 | 	Licensed under the MIT License
  59 | 
  60 | 	Copyright (c) 2009 Andreas Ritter
  61 | 
  62 | 	Permission is hereby granted, free of charge, to any person obtaining a copy of
  63 | 	this software and associated documentation files (the "Software"), to deal in
  64 | 	the Software without restriction, including without limitation the rights to
  65 | 	use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  66 | 	the Software, and to permit persons to whom the Software is furnished to do so,
  67 | 	subject to the following conditions:
  68 | 
  69 | 	The above copyright notice and this permission notice shall be included in all
  70 | 	copies or substantial portions of the Software.
  71 | 
  72 | 	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  73 | 	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  74 | 	FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  75 | 	COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  76 | 	IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  77 | 	CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  78 | 
  79 | 	Copyright (c) 2008, Adobe Systems Incorporated All rights reserved.
  80 | 
  81 | 	Redistribution and use in source and binary forms, with or without modification,
  82 | 	are permitted provided that the following conditions are met:
  83 | 
  84 | 	Redistributions of source code must retain the above copyright notice, this list
  85 | 	of conditions and the following disclaimer.
  86 | 
  87 | 	Redistributions in binary form must reproduce the above copyright notice, this
  88 | 	list of conditions and the following disclaimer in the documentation and/or
  89 | 	other materials provided with the distribution.
  90 | 
  91 | 	Neither the name of Adobe Systems Incorporated nor the names of its contributors
  92 | 	may be used to endorse or promote products derived from this software without
  93 | 	specific prior written permission.
  94 | 
  95 | 	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  96 | 	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  97 | 	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  98 | 	DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  99 | 	ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 100 | 	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 101 | 	LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 102 | 	ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 103 | 	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 104 | 	SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 105 | 	*/
 106 | 
 107 | /* global define, module, exports */
 108 | /* jshint sub:true */
 109 | ;(function(root, factory) {
 110 | 	'use strict';
 111 | 	if (typeof define === 'function' && define.amd) {
 112 | 		define([], factory);
 113 | 	} else if (typeof exports === 'object') {
 114 | 		module.exports = factory();
 115 | 	} else {
 116 | 		root.f5stego = factory();
 117 | 	}
 118 | }(this, function() {
 119 | 	'use strict';
 120 | 
 121 | 	var f5stego = function(key, maxPixels) {
 122 | 		this.maxPixels = maxPixels || 4096 * 4096;
 123 | 		this.shuffleInit(key);
 124 | 	};
 125 | 
 126 | 	// Shuffle used in f5 algo
 127 | 	// ===========================================================================================================
 128 | 		f5stego.prototype.shuffleInit = function(key) {
 129 | 			this.randPool = new ArrayBuffer(this.maxPixels * 4.125);
 130 | 
 131 | 			if (!key.length) throw 'key needed';
 132 | 
 133 | 			var i = 0,
 134 | 				j = 0,
 135 | 				t = 0,
 136 | 				k = 0,
 137 | 				S = new Uint8Array(256),
 138 | 				rnd = new Uint8Array(this.randPool);
 139 | 
 140 | 			// init state from key
 141 | 			for (i = 0; i < 256; ++i) S[i] = i;
 142 | 
 143 | 			for (i = 0; i < 256; ++i) {
 144 | 				j = (j + S[i] + key[i % key.length]) & 255;
 145 | 				t = S[i];
 146 | 				S[i] = S[j];
 147 | 				S[j] = t;
 148 | 			}
 149 | 			i = 0;
 150 | 			j = 0;
 151 | 
 152 | 			// shuffle data
 153 | 			for (k = 0; k < this.maxPixels * 4.125; ++k) {
 154 | 				i = (i + 1) & 255;
 155 | 				j = (j + S[i]) & 255;
 156 | 				t = S[i];
 157 | 				S[i] = S[j];
 158 | 				S[j] = t;
 159 | 				rnd[k] = S[(t + S[i]) & 255];
 160 | 			}
 161 | 		};
 162 | 
 163 | 		f5stego.prototype.stegShuffle = function(pm) {
 164 | 			var t, l, k, random_index,
 165 | 				rand32Array = new Uint32Array(this.randPool);
 166 | 
 167 | 			if (typeof pm == 'number') {
 168 | 				l = pm;
 169 | 				pm = new Uint32Array(l);
 170 | 				for (k = 1; k < l; k++) {
 171 | 					random_index = rand32Array[k] % (k + 1);
 172 | 					if (random_index != k) pm[k] = pm[random_index];
 173 | 					pm[random_index] = k;
 174 | 				}
 175 | 			} else {
 176 | 				l = pm.length;
 177 | 				for (k = 1; k < l; k++) {
 178 | 					random_index = rand32Array[k] % (k + 1);
 179 | 					// if (random_index != k) {
 180 | 						t = pm[k];
 181 | 						pm[k] = pm[random_index];
 182 | 						pm[random_index] = t;
 183 | 					// }
 184 | 				}
 185 | 			}
 186 | 			return { pm: pm, gamma: new Uint8Array(this.randPool, l * 4) };
 187 | 		};
 188 | 
 189 | 	// Internal f5 algo functions
 190 | 	// ===========================================================================================================
 191 | 		f5stego.prototype._analyze = function(coeff) {
 192 | 			var _one = 0,
 193 | 				_zero = 0,
 194 | 				_large, _ratio, usable, i, k, embedded, matched, changed;
 195 | 
 196 | 			for (i = 0; i < coeff.length; i++) {
 197 | 				if (i % 64 === 0) continue;
 198 | 				if (coeff[i] === 0) _zero++;
 199 | 				if (coeff[i] == 1 || coeff[i] == -1) _one++;
 200 | 			}
 201 | 
 202 | 			_large = coeff.length - _zero - _one - coeff.length / 64;
 203 | 			_ratio = _one / (_large + _one);
 204 | 
 205 | 			var res = {
 206 | 				'capacity': [0, ((_large + (0.49 * _one)) >> 3) - 1],
 207 | 				'coeff_total': coeff.length,
 208 | 				'coeff_large': _large,
 209 | 				'coeff_zero': _zero,
 210 | 				'coeff_one': _one,
 211 | 				'coeff_one_ratio': _one / (_large + _one)
 212 | 			};
 213 | 
 214 | 			for (i = 2; i < 17; i++) {
 215 | 				k = (1 << i) - 1;
 216 | 				usable = _large + _one;
 217 | 				embedded = 0;
 218 | 				while (usable > k) {
 219 | 					matched = (usable / k / (1 << i) / (1 << i)) | 0;
 220 | 					usable -= matched * k;
 221 | 
 222 | 					changed = (usable * (1 - _ratio) / k * 0.96) | 0;
 223 | 					usable -= changed * k;
 224 | 					embedded += changed + matched;
 225 | 
 226 | 					k++;
 227 | 				}
 228 | 				res.capacity[i] = ((i * embedded) >> 3) - 1;
 229 | 			}
 230 | 
 231 | 			return res;
 232 | 		};
 233 | 
 234 | 		f5stego.prototype._f5write = function(coeff, data, k) {
 235 | 			var coeff_count = coeff.length;
 236 | 
 237 | 			var _changed = 0,
 238 | 				_embedded = 0,
 239 | 				_examined = 0,
 240 | 				_thrown = 0,
 241 | 				shuffled_index = 0,
 242 | 				i, n, ii;
 243 | 
 244 | 			var pm = this.stegShuffle(coeff_count);
 245 | 			var gamma = pm.gamma,
 246 | 				gammaI = 0;
 247 | 			pm = pm.pm;
 248 | 
 249 | 			var next_bit_to_embed = 0,
 250 | 				byte_to_embed = data.length,
 251 | 				data_idx = 0,
 252 | 				available_bits_to_embed = 0;
 253 | 
 254 | 			n = (1 << k) - 1;
 255 | 
 256 | 			byte_to_embed = k - 1;
 257 | 			byte_to_embed ^= gamma[gammaI++];
 258 | 			next_bit_to_embed = byte_to_embed & 1;
 259 | 			byte_to_embed >>= 1;
 260 | 			available_bits_to_embed = 3;
 261 | 
 262 | 			for (ii = 0; ii < coeff_count; ii++) {
 263 | 				shuffled_index = pm[ii];
 264 | 
 265 | 				if (shuffled_index % 64 === 0 || coeff[shuffled_index] === 0) continue;
 266 | 
 267 | 				var cc = coeff[shuffled_index];
 268 | 				_examined++;
 269 | 
 270 | 				if (cc > 0 && (cc & 1) != next_bit_to_embed) {
 271 | 					coeff[shuffled_index]--;
 272 | 					_changed++;
 273 | 				} else if (cc < 0 && (cc & 1) == next_bit_to_embed) {
 274 | 					coeff[shuffled_index]++;
 275 | 					_changed++;
 276 | 				}
 277 | 
 278 | 				if (coeff[shuffled_index] !== 0) {
 279 | 					_embedded++;
 280 | 					if (available_bits_to_embed === 0) {
 281 | 						if (k != 1 || data_idx >= data.length) break;
 282 | 						byte_to_embed = data[data_idx++];
 283 | 						byte_to_embed ^= gamma[gammaI++];
 284 | 						available_bits_to_embed = 8;
 285 | 					}
 286 | 					next_bit_to_embed = byte_to_embed & 1;
 287 | 					byte_to_embed >>= 1;
 288 | 					available_bits_to_embed--;
 289 | 				} else {
 290 | 					_thrown++;
 291 | 				}
 292 | 			}
 293 | 
 294 | 			if (k == 1 && _embedded < data.length * 8) throw 'capacity exceeded ' + (_embedded / 8) + ' ' + data.length;
 295 | 
 296 | 			if (k != 1) {
 297 | 				//ii--;
 298 | 				var is_last_byte = false,
 299 | 					k_bits_to_embed = 0;
 300 | 
 301 | 				while (!is_last_byte || (available_bits_to_embed !== 0 && is_last_byte)) {
 302 | 					k_bits_to_embed = 0;
 303 | 
 304 | 					for (i = 0; i < k; i++) {
 305 | 						if (available_bits_to_embed === 0) {
 306 | 							if (data_idx >= data.length) {
 307 | 								is_last_byte = true;
 308 | 								break;
 309 | 							}
 310 | 							byte_to_embed = data[data_idx++];
 311 | 							byte_to_embed ^= gamma[gammaI++];
 312 | 							available_bits_to_embed = 8;
 313 | 						}
 314 | 						next_bit_to_embed = byte_to_embed & 1;
 315 | 						byte_to_embed >>= 1;
 316 | 						available_bits_to_embed--;
 317 | 						k_bits_to_embed |= next_bit_to_embed << i;
 318 | 
 319 | 					}
 320 | 
 321 | 					var code_word = [];
 322 | 					var ci = null;
 323 | 
 324 | 					for (i = 0; i < n; i++) {
 325 | 						while (true) {
 326 | 							if (++ii >= coeff_count) {
 327 | 								throw 'capacity exceeded ' + (_embedded / 8);
 328 | 							}
 329 | 							ci = pm[ii];
 330 | 
 331 | 							if (ci % 64 !== 0 && coeff[ci] !== 0) break;
 332 | 						}
 333 | 						code_word.push(ci);
 334 | 					}
 335 | 					_examined += n;
 336 | 
 337 | 					while (true) {
 338 | 						var vhash = 0,
 339 | 							extracted_bit;
 340 | 
 341 | 						for (i = 0; i < code_word.length; i++) {
 342 | 							if (coeff[code_word[i]] > 0) {
 343 | 								extracted_bit = coeff[code_word[i]] & 1;
 344 | 							} else {
 345 | 								extracted_bit = 1 - (coeff[code_word[i]] & 1);
 346 | 							}
 347 | 
 348 | 							if (extracted_bit == 1)
 349 | 								vhash ^= i + 1;
 350 | 						}
 351 | 
 352 | 						i = vhash ^ k_bits_to_embed;
 353 | 						if (!i) {
 354 | 							_embedded += k;
 355 | 							break;
 356 | 						}
 357 | 
 358 | 						i--;
 359 | 						coeff[code_word[i]] += coeff[code_word[i]] < 0 ? 1 : -1;
 360 | 						_changed++;
 361 | 
 362 | 						if (coeff[code_word[i]] === 0) {
 363 | 							_thrown++;
 364 | 							code_word.splice(i, 1);
 365 | 
 366 | 							while (true) {
 367 | 								if (++ii >= coeff_count) {
 368 | 									throw 'capacity exceeded ' + (_embedded / 8);
 369 | 								}
 370 | 								ci = pm[ii];
 371 | 								if (ci % 64 !== 0 && coeff[ci] !== 0) break;
 372 | 
 373 | 							}
 374 | 							_examined++;
 375 | 							code_word.push(ci);
 376 | 						} else {
 377 | 							_embedded += k;
 378 | 							break;
 379 | 						}
 380 | 					}
 381 | 				}
 382 | 			}
 383 | 
 384 | 			return {
 385 | 				'k': k,
 386 | 				'embedded': _embedded / 8,
 387 | 				'examined': _examined,
 388 | 				'changed': _changed,
 389 | 				'thrown': _thrown,
 390 | 				'efficiency': (_embedded / _changed).toFixed(2)
 391 | 			};
 392 | 		};
 393 | 
 394 | 	// Public f5 algo functions
 395 | 	// ===========================================================================================================
 396 | 		f5stego.prototype.analyze = function() {
 397 | 			var i, comp = this.frame.components[0];
 398 | 
 399 | 			if (comp.componentId != 1) {
 400 | 				for (i = 0; i < this.frame.components.length; i++) {
 401 | 					if (this.frame.components[i].componentId == 1) {
 402 | 						comp = this.frame.components[i];
 403 | 						break;
 404 | 					}
 405 | 				}
 406 | 			}
 407 | 
 408 | 			return this._analyze(comp.blocks);
 409 | 		};
 410 | 
 411 | 		f5stego.prototype.f5put = function(data, k) {
 412 | 			var t, i, comp = this.frame.components[0];
 413 | 
 414 | 			// Looks funny, but who knows?
 415 | 			// From the other hand you need ~80MB jpeg to hide 8MB of data and this will be bigger than 4096x4096 pixels
 416 | 			if (data.length > 8388607) throw 'Data too big. Max 8388607 bytes allowed.';
 417 | 
 418 | 			if (data.length < 32768) {
 419 | 				t = new Uint8Array(2 + data.length);
 420 | 				t[0] = data.length & 255;
 421 | 				t[1] = data.length >>> 8;
 422 | 				t.set(data, 2);
 423 | 			} else {
 424 | 				t = new Uint8Array(3 + data.length);
 425 | 				t[0] = data.length & 255;
 426 | 				t[1] = ((data.length >>> 8) & 127) + 128;
 427 | 				t[2] = data.length >>> 15;
 428 | 				t.set(data, 3);
 429 | 			}
 430 | 
 431 | 			if (comp.componentId != 1) {
 432 | 				for (i = 0; i < this.frame.components.length; i++) {
 433 | 					if (this.frame.components[i].componentId == 1) {
 434 | 						comp = this.frame.components[i];
 435 | 						break;
 436 | 					}
 437 | 				}
 438 | 			}
 439 | 
 440 | 			if (k) {
 441 | 				return this._f5write(comp.blocks, t, k);
 442 | 			}
 443 | 
 444 | 			var ret, prop = this._analyze(comp.blocks);
 445 | 
 446 | 			k = 0;
 447 | 
 448 | 			for (i = prop.capacity.length - 1; i >= 0; i--) {
 449 | 				if (prop.capacity[i] >= t.length) {
 450 | 					k = i;
 451 | 					break;
 452 | 				}
 453 | 			}
 454 | 
 455 | 			if (k === 0) throw 'capacity exceeded';
 456 | 
 457 | 			try {
 458 | 				ret = this._f5write(comp.blocks, t, k);
 459 | 			} catch (e) {
 460 | 				k--;
 461 | 				if (k === 0) throw 'capacity exceeded';
 462 | 				ret = this._f5write(comp.blocks, t, k);
 463 | 			}
 464 | 
 465 | 			ret['stats'] = prop;
 466 | 
 467 | 			return ret;
 468 | 		};
 469 | 
 470 | 		f5stego.prototype.f5get = function() {
 471 | 			var comp = this.frame.components[0];
 472 | 
 473 | 			if (comp.componentId != 1) {
 474 | 				for (var i = 0; i < this.frame.components.length; i++) {
 475 | 					if (this.frame.components[i].componentId == 1) {
 476 | 						comp = this.frame.components[i];
 477 | 						break;
 478 | 					}
 479 | 				}
 480 | 			}
 481 | 
 482 | 			var coeff = new Int16Array(comp.blocks.length);
 483 | 			coeff.set(comp.blocks);
 484 | 
 485 | 			var pos = -1,
 486 | 				extrBit = 0,
 487 | 				cCount = coeff.length - 1;
 488 | 
 489 | 			var pm = this.stegShuffle(coeff),
 490 | 				gamma = pm.gamma,
 491 | 				gammaI = 0;
 492 | 
 493 | 			var n, k = 0;
 494 | 
 495 | 			var out = new Uint8Array((coeff.length / 8) | 0),
 496 | 				extrByte = 0,
 497 | 				outPos = 0,
 498 | 				bitsAvail = 0,
 499 | 				code = 0,
 500 | 				hash = 0;
 501 | 
 502 | 			while (bitsAvail < 4) {
 503 | 				pos++;
 504 | 
 505 | 				if (coeff[pos] === 0) {
 506 | 					continue;
 507 | 				}
 508 | 
 509 | 				extrBit = coeff[pos] & 1;
 510 | 
 511 | 
 512 | 				if (coeff[pos] < 0) {
 513 | 					extrBit = 1 - extrBit;
 514 | 				}
 515 | 
 516 | 				k |= extrBit << bitsAvail;
 517 | 				bitsAvail++;
 518 | 			}
 519 | 
 520 | 			k = (k ^ gamma[gammaI++] & 15) + 1;
 521 | 			n = (1 << k) - 1;
 522 | 
 523 | 			bitsAvail = 0;
 524 | 
 525 | 			if (k == 1) {
 526 | 				while (pos < cCount) {
 527 | 					pos++;
 528 | 
 529 | 					if (coeff[pos] === 0) {
 530 | 						continue;
 531 | 					}
 532 | 
 533 | 					extrBit = coeff[pos] & 1;
 534 | 
 535 | 					if (coeff[pos] < 0) {
 536 | 						extrBit = 1 - extrBit;
 537 | 					}
 538 | 
 539 | 					extrByte |= extrBit << bitsAvail;
 540 | 					bitsAvail++;
 541 | 
 542 | 					if (bitsAvail == 8) {
 543 | 						out[outPos++] = extrByte ^ gamma[gammaI++];
 544 | 						extrByte = 0;
 545 | 						bitsAvail = 0;
 546 | 					}
 547 | 				}
 548 | 			} else {
 549 | 				while (pos < cCount) {
 550 | 					pos++;
 551 | 
 552 | 					if (coeff[pos] === 0) {
 553 | 						continue;
 554 | 					}
 555 | 
 556 | 					extrBit = coeff[pos] & 1;
 557 | 
 558 | 					if (coeff[pos] < 0) {
 559 | 						extrBit = 1 - extrBit;
 560 | 					}
 561 | 
 562 | 					hash ^= extrBit * ++code;
 563 | 
 564 | 					if (code == n) {
 565 | 						extrByte |= hash << bitsAvail;
 566 | 						bitsAvail += k;
 567 | 						code = 0;
 568 | 						hash = 0;
 569 | 
 570 | 						while (bitsAvail >= 8) {
 571 | 							out[outPos++] = (extrByte & 0xFF) ^ gamma[gammaI++];
 572 | 							bitsAvail -= 8;
 573 | 							extrByte = extrByte >> 8;
 574 | 						}
 575 | 					}
 576 | 				}
 577 | 			}
 578 | 
 579 | 			while (bitsAvail > 0) {
 580 | 				out[outPos++] = (extrByte & 0xFF) ^ gamma[gammaI++];
 581 | 				bitsAvail -= 8;
 582 | 				extrByte = extrByte >> 8;
 583 | 			}
 584 | 
 585 | 			var s = 2,
 586 | 				l = out[0];
 587 | 
 588 | 			if (out[1] & 128) {
 589 | 				s++;
 590 | 				l += ((out[1] & 127) << 8) + (out[2] << 15);
 591 | 			} else {
 592 | 				l += out[1] << 8;
 593 | 			}
 594 | 
 595 | 			return out.subarray(s, s + l);
 596 | 		};
 597 | 
 598 | 	// JPEG decoder
 599 | 	// ===========================================================================================================
 600 | 		f5stego.prototype.parse = function(data) {
 601 | 			var offset = 0;
 602 | 
 603 | 			function _buildHuffmanTable(nrcodes, values) {
 604 | 				var codevalue = 0,
 605 | 					pos_in_table = 0,
 606 | 					HT = new Uint16Array(65536);
 607 | 				for (var k = 0; k < 16; k++) {
 608 | 					for (var j = 0; j < nrcodes[k]; j++) {
 609 | 						for (var i = codevalue << (15 - k), cntTo = ((codevalue + 1) << (15 - k)); i < cntTo; i++) {
 610 | 							HT[i] = values[pos_in_table] + ((k + 1) << 8);
 611 | 						}
 612 | 						pos_in_table++;
 613 | 						codevalue++;
 614 | 					}
 615 | 					codevalue *= 2;
 616 | 				}
 617 | 				return HT;
 618 | 			}
 619 | 
 620 | 			function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive) {
 621 | 
 622 | 				var startOffset = offset,
 623 | 					bitsData = 0,
 624 | 					bitsCount = 0,
 625 | 					eobrun = 0,
 626 | 					p1 = 1 << successive,  /*  1 in the bit position being coded */
 627 | 					m1 = -1 << successive; /* -1 in the bit position being coded */
 628 | 
 629 | 				function decodeBaseline(component, pos) {
 630 | 					while (bitsCount < 16) {
 631 | 						bitsData = (bitsData << 8) + (data[offset] | 0);
 632 | 						bitsCount += 8;
 633 | 						if (data[offset] == 0xFF) offset++;
 634 | 						offset++;
 635 | 					}
 636 | 					var t = component.huffmanTableDC[(bitsData >>> (bitsCount - 16)) & 0xFFFF];
 637 | 					if (!t) throw "invalid huffman sequence";
 638 | 					bitsCount -= t >>> 8;
 639 | 					t &= 255;
 640 | 
 641 | 					var diff = 0;
 642 | 					if (t !== 0) {
 643 | 						while (bitsCount < t) {
 644 | 							bitsData = (bitsData << 8) + data[offset++];
 645 | 							if ((bitsData & 0xff) == 0xFF) offset++;
 646 | 							bitsCount += 8;
 647 | 						}
 648 | 						diff = (bitsData >>> (bitsCount - t)) & ((1 << t) - 1);
 649 | 						bitsCount -= t;
 650 | 						if (diff < 1 << (t - 1)) diff += (-1 << t) + 1;
 651 | 					}
 652 | 					component.blocksDC[pos >> 6] = (component.pred += diff);
 653 | 
 654 | 					var k = 1,
 655 | 						s, r;
 656 | 					while (k < 64) {
 657 | 
 658 | 						while (bitsCount < 16) {
 659 | 							bitsData = (bitsData << 8) + (data[offset] | 0);
 660 | 							bitsCount += 8;
 661 | 							if (data[offset] == 0xFF) offset++;
 662 | 							offset++;
 663 | 						}
 664 | 						s = component.huffmanTableAC[(bitsData >>> (bitsCount - 16)) & 0xFFFF];
 665 | 						if (!s) throw "invalid huffman sequence";
 666 | 						bitsCount -= s >>> 8;
 667 | 						r = (s >> 4) & 15;
 668 | 						s &= 15;
 669 | 
 670 | 						if (s === 0) {
 671 | 							if (r < 15) {
 672 | 								break;
 673 | 							}
 674 | 							k += 16;
 675 | 							continue;
 676 | 						}
 677 | 						k += r;
 678 | 						while (bitsCount < s) {
 679 | 							bitsData = (bitsData << 8) + data[offset++];
 680 | 							if ((bitsData & 0xff) == 0xFF) offset++;
 681 | 							bitsCount += 8;
 682 | 						}
 683 | 						component.blocks[pos + k] = (bitsData >>> (bitsCount - s)) & ((1 << s) - 1);
 684 | 						bitsCount -= s;
 685 | 						if (component.blocks[pos + k] < 1 << (s - 1)) component.blocks[pos + k] += (-1 << s) + 1;
 686 | 						k++;
 687 | 					}
 688 | 				}
 689 | 
 690 | 				function decodeDCFirst(component, pos) {
 691 | 					var diff = 0;
 692 | 					while (bitsCount < 16) {
 693 | 						bitsData = (bitsData << 8) + (data[offset] | 0);
 694 | 						bitsCount += 8;
 695 | 						if (data[offset] == 0xFF) offset++;
 696 | 						offset++;
 697 | 					}
 698 | 					var t = component.huffmanTableDC[(bitsData >>> (bitsCount - 16)) & 0xFFFF];
 699 | 					if (!t) throw "invalid huffman sequence";
 700 | 					bitsCount -= t >>> 8;
 701 | 					t &= 255;
 702 | 
 703 | 					if (t !== 0) {
 704 | 						while (bitsCount < t) {
 705 | 							bitsData = (bitsData << 8) + data[offset++];
 706 | 							if ((bitsData & 0xff) == 0xFF) offset++;
 707 | 							bitsCount += 8;
 708 | 						}
 709 | 						diff = (bitsData >>> (bitsCount - t)) & ((1 << t) - 1);
 710 | 						bitsCount -= t;
 711 | 						if (diff < 1 << (t - 1)) diff += (-1 << t) + 1;
 712 | 					}
 713 | 					component.blocksDC[pos >> 6] = (component.pred += diff << successive);
 714 | 				}
 715 | 
 716 | 				function decodeDCSuccessive(component, pos) {
 717 | 					if (!bitsCount) {
 718 | 						bitsData = data[offset++];
 719 | 						if (bitsData == 0xFF) offset++;
 720 | 						bitsCount = 8;
 721 | 					}
 722 | 					component.blocksDC[pos >> 6] |= ((bitsData >>> --bitsCount) & 1) << successive;
 723 | 				}
 724 | 
 725 | 				function decodeACFirst(component, pos) {
 726 | 					if (eobrun > 0) {
 727 | 						eobrun--;
 728 | 						return;
 729 | 					}
 730 | 
 731 | 					var k = spectralStart,
 732 | 						s, r;
 733 | 
 734 | 					while (k <= spectralEnd) {
 735 | 						while (bitsCount < 16) {
 736 | 							bitsData = (bitsData << 8) + (data[offset] | 0);
 737 | 							bitsCount += 8;
 738 | 							if (data[offset] == 0xFF) offset++;
 739 | 							offset++;
 740 | 						}
 741 | 						s = component.huffmanTableAC[(bitsData >>> (bitsCount - 16)) & 0xFFFF];
 742 | 						if (!s) throw "invalid huffman sequence";
 743 | 						bitsCount -= s >>> 8;
 744 | 						r = (s >> 4) & 15;
 745 | 						s &= 15;
 746 | 
 747 | 						if (s === 0) {
 748 | 							if (r != 15) {
 749 | 								eobrun = (1 << r) - 1;
 750 | 								if (r) {
 751 | 									while (bitsCount < r) {
 752 | 										bitsData = (bitsData << 8) + data[offset++];
 753 | 										if ((bitsData & 0xff) == 0xFF) offset++;
 754 | 										bitsCount += 8;
 755 | 									}
 756 | 									eobrun += (bitsData >>> (bitsCount - r)) & ((1 << r) - 1);
 757 | 									bitsCount -= r;
 758 | 								}
 759 | 								break;
 760 | 							}
 761 | 							k += 16;
 762 | 							continue;
 763 | 						}
 764 | 
 765 | 						k += r;
 766 | 						while (bitsCount < s) {
 767 | 							bitsData = (bitsData << 8) + data[offset++];
 768 | 							if ((bitsData & 0xff) == 0xFF) offset++;
 769 | 							bitsCount += 8;
 770 | 						}
 771 | 						component.blocks[pos + k] = (bitsData >>> (bitsCount - s)) & ((1 << s) - 1);
 772 | 						bitsCount -= s;
 773 | 						if (component.blocks[pos + k] < 1 << (s - 1)) component.blocks[pos + k] += (-1 << s) + 1;
 774 | 						component.blocks[pos + k] *= p1;
 775 | 						k++;
 776 | 					}
 777 | 				}
 778 | 
 779 | 				function decodeACSuccessive(component, pos) {
 780 | 					var k = spectralStart,
 781 | 						r, s;
 782 | 
 783 | 					if (!eobrun) {
 784 | 						while (k <= spectralEnd) {
 785 | 							while (bitsCount < 16) {
 786 | 								bitsData = (bitsData << 8) + (data[offset] | 0);
 787 | 								bitsCount += 8;
 788 | 								if (data[offset] == 0xFF) offset++;
 789 | 								offset++;
 790 | 							}
 791 | 							s = component.huffmanTableAC[(bitsData >>> (bitsCount - 16)) & 0xFFFF];
 792 | 							if (!s) throw "invalid huffman sequence";
 793 | 							bitsCount -= s >>> 8;
 794 | 							r = (s >> 4) & 15;
 795 | 							s &= 15;
 796 | 
 797 | 							if (s) {
 798 | 								if (s != 1) throw "bad jpeg";
 799 | 								if (!bitsCount) {
 800 | 									bitsData = data[offset++];
 801 | 									if (bitsData == 0xFF) offset++;
 802 | 									bitsCount = 8;
 803 | 								}
 804 | 								s = ((bitsData >>> --bitsCount) & 1) ? p1 : m1;
 805 | 							} else {
 806 | 								if (r != 15) {
 807 | 									eobrun = (1 << r);
 808 | 									if (r) {
 809 | 										while (bitsCount < r) {
 810 | 											bitsData = (bitsData << 8) + data[offset++];
 811 | 											if ((bitsData & 0xff) == 0xFF) offset++;
 812 | 											bitsCount += 8;
 813 | 										}
 814 | 										eobrun += (bitsData >>> (bitsCount - r)) & ((1 << r) - 1);
 815 | 										bitsCount -= r;
 816 | 									}
 817 | 									break;
 818 | 								}
 819 | 							}
 820 | 
 821 | 							while (k <= spectralEnd) {
 822 | 								if (component.blocks[pos + k]) {
 823 | 									if (!bitsCount) {
 824 | 										bitsData = data[offset++];
 825 | 										if (bitsData == 0xFF) offset++;
 826 | 										bitsCount = 8;
 827 | 									}
 828 | 									component.blocks[pos + k] += ((bitsData >>> --bitsCount) & 1) * (component.blocks[pos + k] >= 0 ? p1 : m1);
 829 | 								} else {
 830 | 									if (--r < 0) break;
 831 | 								}
 832 | 								k++;
 833 | 							}
 834 | 
 835 | 							if (s) component.blocks[pos + k] = s;
 836 | 							k++;
 837 | 						}
 838 | 					}
 839 | 
 840 | 					if (eobrun) {
 841 | 						while (k <= spectralEnd) {
 842 | 							if (component.blocks[pos + k]) {
 843 | 								if (!bitsCount) {
 844 | 									bitsData = data[offset++];
 845 | 									if (bitsData == 0xFF) offset++;
 846 | 									bitsCount = 8;
 847 | 								}
 848 | 								component.blocks[pos + k] += ((bitsData >>> --bitsCount) & 1) * (component.blocks[pos + k] >= 0 ? p1 : m1);
 849 | 							}
 850 | 							k++;
 851 | 						}
 852 | 						eobrun--;
 853 | 					}
 854 | 				}
 855 | 
 856 | 				var decodeFn;
 857 | 
 858 | 				if (frame.progressive) {
 859 | 					if (spectralStart === 0)
 860 | 						decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
 861 | 					else
 862 | 						decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
 863 | 				} else {
 864 | 					decodeFn = decodeBaseline;
 865 | 				}
 866 | 
 867 | 				var marker, mcuExpected, i, j, k, n, mcusPerLine, mcusPerRow, x, y;
 868 | 
 869 | 				if (components.length == 1) {
 870 | 					mcusPerLine = components[0].blocksPerLine;
 871 | 					mcusPerRow = components[0].blocksPerColumn;
 872 | 					mcuExpected = mcusPerRow * mcusPerLine;
 873 | 
 874 | 					if (!resetInterval) resetInterval = mcuExpected;
 875 | 					n = resetInterval;
 876 | 					components[0].pred = 0;
 877 | 					eobrun = 0;
 878 | 
 879 | 					for (y = 0; y < mcusPerRow; y++) {
 880 | 						for (x = 0; x < mcusPerLine; x++) {
 881 | 							if (!n) {
 882 | 								n = resetInterval;
 883 | 								components[0].pred = 0;
 884 | 								eobrun = 0;
 885 | 
 886 | 								// find marker
 887 | 								offset -= (bitsCount / 8) | 0;
 888 | 								if (data[offset - 1] == 0xFF) offset--;
 889 | 								bitsCount = 0;
 890 | 								marker = (data[offset] << 8) | data[offset + 1];
 891 | 
 892 | 								if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx
 893 | 									offset += 2;
 894 | 								} else {
 895 | 									if (marker <= 0xFF00) {
 896 | 										throw "bad jpeg";
 897 | 									}
 898 | 									break;
 899 | 								}
 900 | 							}
 901 | 							n--;
 902 | 							for (i = 0; i < components.length; i++) {
 903 | 								decodeFn(components[i], (y * components[i].blocksPerLineForMcu + x) * 64);
 904 | 							}
 905 | 
 906 | 						}
 907 | 					}
 908 | 				} else {
 909 | 					mcusPerLine = frame.mcusPerLine;
 910 | 					mcusPerRow = frame.mcusPerColumn;
 911 | 					mcuExpected = mcusPerRow * mcusPerLine;
 912 | 
 913 | 					if (!resetInterval) resetInterval = mcuExpected;
 914 | 					n = resetInterval;
 915 | 					for (i = 0; i < components.length; i++) components[i].pred = 0;
 916 | 					eobrun = 0;
 917 | 
 918 | 					for (y = 0; y < mcusPerRow; y++) {
 919 | 						for (x = 0; x < mcusPerLine; x++) {
 920 | 							if (!n) {
 921 | 								n = resetInterval;
 922 | 								for (i = 0; i < components.length; i++) components[i].pred = 0;
 923 | 								eobrun = 0;
 924 | 
 925 | 								// find marker
 926 | 								offset -= (bitsCount / 8) | 0;
 927 | 								if (data[offset - 1] == 0xFF) offset--;
 928 | 								bitsCount = 0;
 929 | 								marker = (data[offset] << 8) | data[offset + 1];
 930 | 
 931 | 								if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx
 932 | 									offset += 2;
 933 | 								} else {
 934 | 									if (marker <= 0xFF00) {
 935 | 										throw "bad jpeg";
 936 | 									}
 937 | 									break;
 938 | 								}
 939 | 							}
 940 | 							n--;
 941 | 							for (i = 0; i < components.length; i++) {
 942 | 								for (j = 0; j < components[i].v; j++) {
 943 | 									for (k = 0; k < components[i].h; k++) {
 944 | 										decodeFn(components[i], ((y * components[i].v + j) * components[i].blocksPerLineForMcu + x * components[i].h + k) * 64);
 945 | 									}
 946 | 								}
 947 | 							}
 948 | 						}
 949 | 					}
 950 | 				}
 951 | 				offset -= (bitsCount / 8) | 0;
 952 | 				if (data[offset - 1] == 0xFF) offset--;
 953 | 				return offset - startOffset;
 954 | 			}
 955 | 
 956 | 			function readUint16() {
 957 | 				var value = (data[offset] << 8) | data[offset + 1];
 958 | 				offset += 2;
 959 | 				return value;
 960 | 			}
 961 | 
 962 | 			function readDataBlock() {
 963 | 				var length = readUint16();
 964 | 				var array = data.subarray(offset, offset + length - 2);
 965 | 				offset += array.length;
 966 | 				return array;
 967 | 			}
 968 | 
 969 | 			this['_raw'] = data;
 970 | 			this['jfif'] = null;
 971 | 			this['APPn'] = [];
 972 | 			this['qts'] = [];
 973 | 			this['frame'] = null;
 974 | 			this['tail'] = null;
 975 | 
 976 | 			var markerHi, markerLo, i, j, resetInterval, component;
 977 | 			var huffmanTablesAC = [],
 978 | 				huffmanTablesDC = [];
 979 | 
 980 | 			while (1) {
 981 | 				if (offset >= data.length) throw "unexpected EOF";
 982 | 
 983 | 				markerHi = data[offset++];
 984 | 				markerLo = data[offset++];
 985 | 
 986 | 				if (markerHi == 0xFF) {
 987 | 					if (markerLo == 0xE0) { //APP0 - JFIF header
 988 | 						this.jfif = readDataBlock();
 989 | 					}
 990 | 
 991 | 					if ((markerLo > 0xE0 && markerLo < 0xF0) || markerLo == 0xFE) { //APPn + COM
 992 | 						this.APPn.push({
 993 | 							'app': markerLo,
 994 | 							'data': readDataBlock()
 995 | 						});
 996 | 					}
 997 | 
 998 | 					if (markerLo == 0xDB) { // DQT (Define Quantization Tables)
 999 | 						this.qts.push(readDataBlock());
1000 | 					}
1001 | 
1002 | 					if (markerLo >= 0xC0 && markerLo <= 0xC2) {
1003 | 						// SOF0 (Start of Frame, Baseline DCT)
1004 | 						// SOF1 (Start of Frame, Extended DCT)
1005 | 						// SOF2 (Start of Frame, Progressive DCT)
1006 | 						if (this.frame) throw "Only single frame JPEGs supported";
1007 | 						readUint16(); // skip data length
1008 | 
1009 | 						this.frame = {
1010 | 							'extended': (markerLo === 0xC1),
1011 | 							'progressive': (markerLo === 0xC2),
1012 | 							'precision': data[offset++],
1013 | 							'scanLines': readUint16(),
1014 | 							'samplesPerLine': readUint16(),
1015 | 							'components': [],
1016 | 							'componentIds': {},
1017 | 							'maxH': 1,
1018 | 							'maxV': 1
1019 | 						};
1020 | 
1021 | 						if (this.frame.scanLines * this.frame.samplesPerLine > this.maxPixels) throw "Image is too big.";
1022 | 
1023 | 						var componentsCount = data[offset++],
1024 | 							componentId;
1025 | 						var maxH = 0,
1026 | 							maxV = 0;
1027 | 						for (i = 0; i < componentsCount; i++) {
1028 | 							componentId = data[offset];
1029 | 							var h = data[offset + 1] >> 4;
1030 | 							var v = data[offset + 1] & 15;
1031 | 							if (maxH < h) maxH = h;
1032 | 							if (maxV < v) maxV = v;
1033 | 							var qId = data[offset + 2];
1034 | 							var l = this.frame.components.push({
1035 | 								'componentId': componentId,
1036 | 								'h': h,
1037 | 								'v': v,
1038 | 								'quantizationTable': qId
1039 | 							});
1040 | 							this.frame.componentIds[componentId] = l - 1;
1041 | 							offset += 3;
1042 | 						}
1043 | 						this.frame.maxH = maxH;
1044 | 						this.frame.maxV = maxV;
1045 | 
1046 | 						var mcusPerLine = Math.ceil(this.frame.samplesPerLine / 8 / maxH);
1047 | 						var mcusPerColumn = Math.ceil(this.frame.scanLines / 8 / maxV);
1048 | 						for (i = 0; i < this.frame.components.length; i++) {
1049 | 							component = this.frame.components[i];
1050 | 							var blocksPerLine = Math.ceil(Math.ceil(this.frame.samplesPerLine / 8) * component.h / maxH);
1051 | 							var blocksPerColumn = Math.ceil(Math.ceil(this.frame.scanLines / 8) * component.v / maxV);
1052 | 							var blocksPerLineForMcu = mcusPerLine * component.h;
1053 | 							var blocksPerColumnForMcu = mcusPerColumn * component.v;
1054 | 
1055 | 							component['blocks'] = new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu * 64);
1056 | 							component['blocksDC'] = new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu);
1057 | 							component['blocksPerLine'] = blocksPerLine;
1058 | 							component['blocksPerColumn'] = blocksPerColumn;
1059 | 							component['blocksPerLineForMcu'] = blocksPerLineForMcu;
1060 | 							component['blocksPerColumnForMcu'] = blocksPerColumnForMcu;
1061 | 						}
1062 | 						this.frame['mcusPerLine'] = mcusPerLine;
1063 | 						this.frame['mcusPerColumn'] = mcusPerColumn;
1064 | 					}
1065 | 
1066 | 					if (markerLo == 0xC4) { // DHT (Define Huffman Tables)
1067 | 						var huffmanLength = readUint16();
1068 | 						for (i = 2; i < huffmanLength;) {
1069 | 							var huffmanTableSpec = data[offset++];
1070 | 							var codeLengths = new Uint8Array(16);
1071 | 							var codeLengthSum = 0;
1072 | 							for (j = 0; j < 16; j++, offset++)
1073 | 								codeLengthSum += (codeLengths[j] = data[offset]);
1074 | 							var huffmanValues = new Uint8Array(codeLengthSum);
1075 | 							for (j = 0; j < codeLengthSum; j++, offset++)
1076 | 								huffmanValues[j] = data[offset];
1077 | 							i += 17 + codeLengthSum;
1078 | 							((huffmanTableSpec >> 4) === 0 ?
1079 | 								huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = _buildHuffmanTable(codeLengths, huffmanValues);
1080 | 						}
1081 | 					}
1082 | 
1083 | 					if (markerLo == 0xDD) { // DRI (Define Restart Interval)
1084 | 						resetInterval = readUint16();
1085 | 					}
1086 | 
1087 | 					if (markerLo == 0xDA) { // SOS (Start of Scan)
1088 | 						readUint16();
1089 | 						var selectorsCount = data[offset++];
1090 | 						var components = [];
1091 | 
1092 | 						for (i = 0; i < selectorsCount; i++) {
1093 | 							var componentIndex = this.frame.componentIds[data[offset++]];
1094 | 							component = this.frame.components[componentIndex];
1095 | 							var tableSpec = data[offset++];
1096 | 							component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
1097 | 							component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
1098 | 							components.push(component);
1099 | 						}
1100 | 
1101 | 						var spectralStart = data[offset++];
1102 | 						var spectralEnd = data[offset++];
1103 | 						var successiveApproximation = data[offset++];
1104 | 						var processed = decodeScan(data, offset,
1105 | 							this.frame, components, resetInterval,
1106 | 							spectralStart, spectralEnd,
1107 | 							successiveApproximation >> 4, successiveApproximation & 15);
1108 | 						offset += processed;
1109 | 					}
1110 | 
1111 | 					if (markerLo == 0xD9) { // EOI (End of image)
1112 | 						break;
1113 | 					}
1114 | 				} else {
1115 | 					if (data[offset - 3] == 0xFF &&
1116 | 						data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) {
1117 | 						// could be incorrect encoding -- last 0xFF byte of the previous
1118 | 						// block was eaten by the encoder
1119 | 						offset -= 3;
1120 | 					}
1121 | 					while (data[offset] != 0xFF && offset < data.length) {
1122 | 						// file could be damaged and have some extra data between blocks
1123 | 						offset++;
1124 | 					}
1125 | 
1126 | 					if (data[offset] != 0xFF) {
1127 | 						throw "bad jpeg ";
1128 | 					}
1129 | 				}
1130 | 			}
1131 | 
1132 | 			if (!this.frame) throw 'bad jpeg';
1133 | 
1134 | 			if (offset < data.length) this.tail = data.subarray(offset);
1135 | 
1136 | 			return this;
1137 | 		};
1138 | 
1139 | 	// Standard Huffman tables for coder initialization
1140 | 	// ===========================================================================================================
1141 | 		var bitcode = new Array(65535),
1142 | 			category = new Array(65535),
1143 | 			std_dc_luminance_nrcodes = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
1144 | 			std_dc_luminance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
1145 | 			std_ac_luminance_nrcodes = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d],
1146 | 			std_ac_luminance_values = [
1147 | 				0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
1148 | 				0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
1149 | 				0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
1150 | 				0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
1151 | 				0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
1152 | 				0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
1153 | 				0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
1154 | 				0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
1155 | 				0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
1156 | 				0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
1157 | 				0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
1158 | 				0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
1159 | 				0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
1160 | 				0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
1161 | 				0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
1162 | 				0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
1163 | 				0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
1164 | 				0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
1165 | 				0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
1166 | 				0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
1167 | 				0xf9, 0xfa
1168 | 			],
1169 | 			std_dc_chrominance_nrcodes = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
1170 | 			std_dc_chrominance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
1171 | 			std_ac_chrominance_nrcodes = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77],
1172 | 			std_ac_chrominance_values = [
1173 | 				0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
1174 | 				0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
1175 | 				0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
1176 | 				0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
1177 | 				0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
1178 | 				0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
1179 | 				0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
1180 | 				0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
1181 | 				0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
1182 | 				0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
1183 | 				0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
1184 | 				0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
1185 | 				0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
1186 | 				0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
1187 | 				0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
1188 | 				0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
1189 | 				0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
1190 | 				0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
1191 | 				0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
1192 | 				0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
1193 | 				0xf9, 0xfa
1194 | 			];
1195 | 
1196 | 		function _initCategoryNumber() {
1197 | 			var nrlower = 1;
1198 | 			var nrupper = 2;
1199 | 			for (var cat = 1; cat <= 15; cat++) {
1200 | 				//Positive numbers
1201 | 				for (var nr = nrlower; nr < nrupper; nr++) {
1202 | 					category[32767 + nr] = cat;
1203 | 					bitcode[32767 + nr] = [];
1204 | 					bitcode[32767 + nr][1] = cat;
1205 | 					bitcode[32767 + nr][0] = nr;
1206 | 				}
1207 | 				//Negative numbers
1208 | 				for (var nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) {
1209 | 					category[32767 + nrneg] = cat;
1210 | 					bitcode[32767 + nrneg] = [];
1211 | 					bitcode[32767 + nrneg][1] = cat;
1212 | 					bitcode[32767 + nrneg][0] = nrupper - 1 + nrneg;
1213 | 				}
1214 | 				nrlower <<= 1;
1215 | 				nrupper <<= 1;
1216 | 			}
1217 | 		}
1218 | 
1219 | 		_initCategoryNumber();
1220 | 
1221 | 		function _computeHuffmanTbl(nrcodes, std_table) {
1222 | 			var codevalue = 0;
1223 | 			var pos_in_table = 0;
1224 | 			var HT = [];
1225 | 			for (var k = 1; k <= 16; k++) {
1226 | 				for (var j = 1; j <= nrcodes[k]; j++) {
1227 | 					HT[std_table[pos_in_table]] = [];
1228 | 					HT[std_table[pos_in_table]][0] = codevalue;
1229 | 					HT[std_table[pos_in_table]][1] = k;
1230 | 					pos_in_table++;
1231 | 					codevalue++;
1232 | 				}
1233 | 				codevalue *= 2;
1234 | 			}
1235 | 			return HT;
1236 | 		}
1237 | 
1238 | 		var YDC_HT = _computeHuffmanTbl(std_dc_luminance_nrcodes, std_dc_luminance_values),
1239 | 			UVDC_HT = _computeHuffmanTbl(std_dc_chrominance_nrcodes, std_dc_chrominance_values),
1240 | 			YAC_HT = _computeHuffmanTbl(std_ac_luminance_nrcodes, std_ac_luminance_values),
1241 | 			UVAC_HT = _computeHuffmanTbl(std_ac_chrominance_nrcodes, std_ac_chrominance_values);
1242 | 
1243 | 	// JPEG encoder
1244 | 	// ===========================================================================================================
1245 | 		f5stego.prototype.pack = function() {
1246 | 			var byteout, bytenew, bytepos, poslast, outpos, byte;
1247 | 
1248 | 			// IO functions
1249 | 			function writeByte(value) {
1250 | 				var t;
1251 | 
1252 | 				byteout[outpos++] = value;
1253 | 				if (outpos > poslast) {
1254 | 					t = new Uint8Array(byteout.length * 2);
1255 | 					t.set(byteout);
1256 | 					byteout = t;
1257 | 					poslast = t.length - 128;
1258 | 				}
1259 | 			}
1260 | 
1261 | 			function writeWord(value) {
1262 | 				writeByte((value >> 8) & 0xFF);
1263 | 				writeByte((value) & 0xFF);
1264 | 			}
1265 | 
1266 | 			function writeBlock(block) {
1267 | 				var t;
1268 | 				if (outpos + block.length > poslast) {
1269 | 					t = new Uint8Array(byteout.length * 2 + block.length);
1270 | 					t.set(byteout);
1271 | 					byteout = t;
1272 | 					poslast = t.length - 128;
1273 | 				}
1274 | 
1275 | 				byteout.set(block, outpos);
1276 | 				outpos += block.length;
1277 | 			}
1278 | 
1279 | 			function writeAPP0(self) {
1280 | 				writeWord(0xFFE0); // marker
1281 | 				if (!self.jfif) {
1282 | 					writeWord(16); // length
1283 | 					writeByte(0x4A); // J
1284 | 					writeByte(0x46); // F
1285 | 					writeByte(0x49); // I
1286 | 					writeByte(0x46); // F
1287 | 					writeByte(0); // = "JFIF",'\0'
1288 | 					writeByte(1); // versionhi
1289 | 					writeByte(1); // versionlo
1290 | 					writeByte(0); // xyunits
1291 | 					writeWord(1); // xdensity
1292 | 					writeWord(1); // ydensity
1293 | 					writeByte(0); // thumbnwidth
1294 | 					writeByte(0); // thumbnheight
1295 | 				} else {
1296 | 					writeWord(self.jfif.length + 2); // length
1297 | 					writeBlock(self.jfif);
1298 | 				}
1299 | 			}
1300 | 
1301 | 			function writeDQT(self) {
1302 | 				for (var i = 0; i < self.qts.length; i++) {
1303 | 					writeWord(0xFFDB); // marker
1304 | 					writeWord(self.qts[i].length + 2); // length
1305 | 					writeBlock(self.qts[i]);
1306 | 				}
1307 | 			}
1308 | 
1309 | 			function writeAPPn(self) {
1310 | 				for (var i = 0; i < self.APPn.length; i++) {
1311 | 					writeWord(0xFF00 | self.APPn[i].app);
1312 | 					writeWord(self.APPn[i].data.length + 2);
1313 | 					writeBlock(self.APPn[i].data);
1314 | 				}
1315 | 			}
1316 | 
1317 | 			function writeSOF0(self) {
1318 | 				writeWord(0xFFC0); // marker
1319 | 				writeWord(8 + self.frame.components.length * 3); // length
1320 | 				writeByte(self.frame.precision); // precision
1321 | 				writeWord(self.frame.scanLines);
1322 | 				writeWord(self.frame.samplesPerLine);
1323 | 				writeByte(self.frame.components.length); // nrofcomponents
1324 | 
1325 | 				for (var i = 0; i < self.frame.components.length; i++) {
1326 | 					var c = self.frame.components[i];
1327 | 					writeByte(c.componentId);
1328 | 					writeByte(c.h << 4 | c.v);
1329 | 					writeByte(c.quantizationTable);
1330 | 				}
1331 | 			}
1332 | 
1333 | 			function writeDHT(self) {
1334 | 				writeWord(0xFFC4); // marker
1335 | 				writeWord(31); // length
1336 | 				writeByte(0); // HTYDCinfo
1337 | 				for (var i = 0; i < 16; i++) {
1338 | 					writeByte(std_dc_luminance_nrcodes[i + 1]);
1339 | 				}
1340 | 				for (var j = 0; j <= 11; j++) {
1341 | 					writeByte(std_dc_luminance_values[j]);
1342 | 				}
1343 | 
1344 | 				writeWord(0xFFC4); // marker
1345 | 				writeWord(181); // length
1346 | 				writeByte(0x10); // HTYACinfo
1347 | 				for (var k = 0; k < 16; k++) {
1348 | 					writeByte(std_ac_luminance_nrcodes[k + 1]);
1349 | 				}
1350 | 				for (var l = 0; l <= 161; l++) {
1351 | 					writeByte(std_ac_luminance_values[l]);
1352 | 				}
1353 | 
1354 | 				if (self.frame.components.length != 1) {
1355 | 					writeWord(0xFFC4); // marker
1356 | 					writeWord(31); // length
1357 | 					writeByte(1); // HTUDCinfo
1358 | 					for (var m = 0; m < 16; m++) {
1359 | 						writeByte(std_dc_chrominance_nrcodes[m + 1]);
1360 | 					}
1361 | 					for (var n = 0; n <= 11; n++) {
1362 | 						writeByte(std_dc_chrominance_values[n]);
1363 | 					}
1364 | 
1365 | 					writeWord(0xFFC4); // marker
1366 | 					writeWord(181); // length
1367 | 					writeByte(0x11); // HTUACinfo
1368 | 					for (var o = 0; o < 16; o++) {
1369 | 						writeByte(std_ac_chrominance_nrcodes[o + 1]);
1370 | 					}
1371 | 					for (var p = 0; p <= 161; p++) {
1372 | 						writeByte(std_ac_chrominance_values[p]);
1373 | 					}
1374 | 				}
1375 | 			}
1376 | 
1377 | 			function writeSOS(self) {
1378 | 				writeWord(0xFFDA); // marker
1379 | 				writeWord(6 + self.frame.components.length * 2); // length
1380 | 				writeByte(self.frame.components.length); // nrofcomponents
1381 | 
1382 | 				for (var i = 0; i < self.frame.components.length; i++) {
1383 | 					var c = self.frame.components[i];
1384 | 					writeByte(c.componentId);
1385 | 					if (i === 0) {
1386 | 						writeByte(0);
1387 | 					} else {
1388 | 						writeByte(0x11);
1389 | 					}
1390 | 				}
1391 | 
1392 | 				writeByte(0); // Ss
1393 | 				writeByte(0x3f); // Se
1394 | 				writeByte(0); // Bf
1395 | 			}
1396 | 
1397 | 			function processDU(comp, POS, DC, HTDC, HTAC) {
1398 | 				var pos, posval, t;
1399 | 
1400 | 				if (bytepos === 0) bytenew = 0;
1401 | 
1402 | 				var Diff = comp.blocksDC[POS >> 6] - DC;
1403 | 				DC = comp.blocksDC[POS >> 6];
1404 | 				//Encode DC
1405 | 				if (Diff === 0) {
1406 | 					posval = HTDC[0][1];
1407 | 
1408 | 					bytenew <<= posval;
1409 | 					bytenew += HTDC[0][0];
1410 | 					bytepos += posval;
1411 | 
1412 | 					while (bytepos > 7) {
1413 | 						byte = 0xFF & (bytenew >>> (bytepos - 8));
1414 | 						byteout[outpos++] = byte;
1415 | 						if (byte == 0xFF) {
1416 | 							outpos++;
1417 | 						}
1418 | 						bytepos -= 8;
1419 | 						bytenew &= (1 << bytepos) - 1;
1420 | 					}
1421 | 
1422 | 				} else {
1423 | 					pos = 32767 + Diff;
1424 | 
1425 | 					posval = HTDC[category[pos]][1];
1426 | 					bytenew <<= posval;
1427 | 					bytenew += HTDC[category[pos]][0];
1428 | 					bytepos += posval;
1429 | 
1430 | 					posval = bitcode[pos][1];
1431 | 					bytenew <<= posval;
1432 | 					bytenew += bitcode[pos][0];
1433 | 					bytepos += posval;
1434 | 
1435 | 					while (bytepos > 7) {
1436 | 						byte = 0xFF & (bytenew >>> (bytepos - 8));
1437 | 						byteout[outpos++] = byte;
1438 | 						if (byte == 0xFF) {
1439 | 							outpos++;
1440 | 						}
1441 | 						bytepos -= 8;
1442 | 						bytenew &= (1 << bytepos) - 1;
1443 | 					}
1444 | 				}
1445 | 				//Encode ACs
1446 | 				var end0pos = 63; // was const... which is crazy
1447 | 				for (;
1448 | 					(end0pos > 0) && (comp.blocks[POS + end0pos] === 0); end0pos--) {}
1449 | 				//end0pos = first element in reverse order !=0
1450 | 				if (end0pos === 0) {
1451 | 					posval = HTAC[0x00][1];
1452 | 					bytenew <<= posval;
1453 | 					bytenew += HTAC[0x00][0];
1454 | 					bytepos += posval;
1455 | 
1456 | 					while (bytepos > 7) {
1457 | 						byte = 0xFF & (bytenew >>> (bytepos - 8));
1458 | 						byteout[outpos++] = byte;
1459 | 						if (byte == 0xFF) {
1460 | 							outpos++;
1461 | 						}
1462 | 						bytepos -= 8;
1463 | 						bytenew &= (1 << bytepos) - 1;
1464 | 					}
1465 | 					return DC;
1466 | 				}
1467 | 				var i = 1;
1468 | 				var lng;
1469 | 				while (i <= end0pos) {
1470 | 					var startpos = i;
1471 | 					for (;
1472 | 						(comp.blocks[POS + i] === 0) && (i <= end0pos); ++i) {}
1473 | 					var nrzeroes = i - startpos;
1474 | 					if (nrzeroes >= 16) {
1475 | 						lng = nrzeroes >> 4;
1476 | 						for (var nrmarker = 1; nrmarker <= lng; ++nrmarker) {
1477 | 							posval = HTAC[0xF0][1];
1478 | 							bytenew <<= posval;
1479 | 							bytenew += HTAC[0xF0][0];
1480 | 							bytepos += posval;
1481 | 
1482 | 							while (bytepos > 7) {
1483 | 								byte = 0xFF & (bytenew >>> (bytepos - 8));
1484 | 								byteout[outpos++] = byte;
1485 | 								if (byte == 0xFF) {
1486 | 									outpos++;
1487 | 								}
1488 | 								bytepos -= 8;
1489 | 								bytenew &= (1 << bytepos) - 1;
1490 | 							}
1491 | 						}
1492 | 						nrzeroes = nrzeroes & 0xF;
1493 | 					}
1494 | 					pos = 32767 + comp.blocks[POS + i];
1495 | 
1496 | 					posval = HTAC[(nrzeroes << 4) + category[pos]][1];
1497 | 					bytenew <<= posval;
1498 | 					bytenew += HTAC[(nrzeroes << 4) + category[pos]][0];
1499 | 					bytepos += posval;
1500 | 
1501 | 					while (bytepos > 7) {
1502 | 						byte = 0xFF & (bytenew >>> (bytepos - 8));
1503 | 						byteout[outpos++] = byte;
1504 | 						if (byte == 0xFF) {
1505 | 							outpos++;
1506 | 						}
1507 | 						bytepos -= 8;
1508 | 						bytenew &= (1 << bytepos) - 1;
1509 | 					}
1510 | 
1511 | 					posval = bitcode[pos][1];
1512 | 					bytenew <<= posval;
1513 | 					bytenew += bitcode[pos][0];
1514 | 					bytepos += posval;
1515 | 
1516 | 					while (bytepos > 7) {
1517 | 						byte = 0xFF & (bytenew >>> (bytepos - 8));
1518 | 						byteout[outpos++] = byte;
1519 | 						if (byte == 0xFF) {
1520 | 							outpos++;
1521 | 						}
1522 | 						bytepos -= 8;
1523 | 						bytenew &= (1 << bytepos) - 1;
1524 | 					}
1525 | 					i++;
1526 | 				}
1527 | 				if (end0pos != 63) {
1528 | 					posval = HTAC[0x00][1];
1529 | 					bytenew <<= posval;
1530 | 					bytenew += HTAC[0x00][0];
1531 | 					bytepos += posval;
1532 | 
1533 | 					while (bytepos > 7) {
1534 | 						byte = 0xFF & (bytenew >>> (bytepos - 8));
1535 | 						byteout[outpos++] = byte;
1536 | 						if (byte == 0xFF) {
1537 | 							outpos++;
1538 | 						}
1539 | 						bytepos -= 8;
1540 | 						bytenew &= (1 << bytepos) - 1;
1541 | 					}
1542 | 				}
1543 | 
1544 | 				if (outpos > poslast) {
1545 | 					t = new Uint8Array(byteout.length * 2);
1546 | 					t.set(byteout);
1547 | 					byteout = t;
1548 | 					poslast = t.length - 128;
1549 | 				}
1550 | 
1551 | 				return DC;
1552 | 			}
1553 | 
1554 | 			// Initialize bit writer
1555 | 			byteout = new Uint8Array(65536);
1556 | 			poslast = 65536 - 128;
1557 | 			outpos = 0;
1558 | 			bytenew = 0;
1559 | 			bytepos = 0;
1560 | 
1561 | 			// Add JPEG headers
1562 | 			writeWord(0xFFD8); // SOI
1563 | 			writeAPP0(this);
1564 | 			writeAPPn(this);
1565 | 			writeDQT(this);
1566 | 			writeSOF0(this);
1567 | 			writeDHT(this);
1568 | 			writeSOS(this);
1569 | 
1570 | 			bytenew = 0;
1571 | 			bytepos = 0;
1572 | 
1573 | 			var c, mcuRow, mcuCol, blockRow, blockCol, mcu, i, v, h;
1574 | 
1575 | 			var DCdiff = [];
1576 | 			for (i = 0; i < this.frame.components.length; i++) {
1577 | 				DCdiff.push(0);
1578 | 			}
1579 | 
1580 | 			for (mcu = 0; mcu < this.frame.mcusPerLine * this.frame.mcusPerColumn; mcu++) {
1581 | 				mcuRow = (mcu / this.frame.mcusPerLine) | 0;
1582 | 				mcuCol = mcu % this.frame.mcusPerLine;
1583 | 				for (i = 0; i < this.frame.components.length; i++) {
1584 | 					c = this.frame.components[i];
1585 | 					for (v = 0; v < c.v; v++) {
1586 | 						blockRow = mcuRow * c.v + v;
1587 | 						for (h = 0; h < c.h; h++) {
1588 | 							blockCol = mcuCol * c.h + h;
1589 | 							if (i === 0) {
1590 | 								DCdiff[i] = processDU(c, (blockRow * this.frame.mcusPerLine * c.h + blockCol) * 64, DCdiff[i], YDC_HT, YAC_HT);
1591 | 							} else {
1592 | 								DCdiff[i] = processDU(c, (blockRow * this.frame.mcusPerLine * c.h + blockCol) * 64, DCdiff[i], UVDC_HT, UVAC_HT);
1593 | 							}
1594 | 						}
1595 | 					}
1596 | 				}
1597 | 			}
1598 | 
1599 | 			// Write last bytes from coder
1600 | 			while (bytepos > 7) {
1601 | 				byte = 0xFF & (bytenew >>> (bytepos - 8));
1602 | 				byteout[outpos++] = byte;
1603 | 				if (byte == 0xFF) {
1604 | 					outpos++;
1605 | 				}
1606 | 				bytepos -= 8;
1607 | 			}
1608 | 			// And do the bit alignment of the EOI marker
1609 | 			if (bytepos > 0) {
1610 | 				bytenew <<= 8 - bytepos;
1611 | 				bytenew += (1 << (8 - bytepos)) - 1;
1612 | 				byteout[outpos++] = 0xFF & bytenew;
1613 | 			}
1614 | 
1615 | 			writeWord(0xFFD9); //EOI
1616 | 			if (this.tail) writeBlock(this.tail);
1617 | 
1618 | 			return byteout.slice(0, outpos);
1619 | 		};
1620 | 
1621 | 	// Metadata manipulation
1622 | 	// ===========================================================================================================
1623 | 		f5stego.prototype.clearTail = function() {
1624 | 			if (!this.tail) return null;
1625 | 
1626 | 			var t = this.tail;
1627 | 			this.tail = null;
1628 | 
1629 | 			return t;
1630 | 		};
1631 | 
1632 | 		f5stego.prototype.setTail = function(data) {
1633 | 			this.tail = data;
1634 | 		};
1635 | 
1636 | 		f5stego.prototype.getTail = function() {
1637 | 			return this.tail;
1638 | 		};
1639 | 
1640 | 		f5stego.prototype.clearAPPs = function() {
1641 | 			var t = this.APPn;
1642 | 			this.APPn = [];
1643 | 			return t;
1644 | 		};
1645 | 
1646 | 		f5stego.prototype.getAPPn = function(id, remove) {
1647 | 			var i, t, ret = new Uint8Array(0),
1648 | 				n = [];
1649 | 
1650 | 			id &= 0xFF;
1651 | 			if (id < 16) id += 0xE0;
1652 | 			if (id === 0xE0) return this.jfif;
1653 | 
1654 | 			for (i = 0; i < this.APPn.length; i++) {
1655 | 				if (this.APPn[i].app == id) {
1656 | 					t = new Uint8Array(ret.length + this.APPn[i].data.length);
1657 | 					t.set(ret);
1658 | 					t.set(this.APPn[i].data, ret.length);
1659 | 					ret = t;
1660 | 				} else if (remove) n.push(this.APPn[i]);
1661 | 			}
1662 | 
1663 | 			if (remove) this.APPn = n;
1664 | 
1665 | 			if (ret.length === 0) return null;
1666 | 
1667 | 			return ret;
1668 | 		};
1669 | 
1670 | 		f5stego.prototype.setAPPn = function(id, data) {
1671 | 			var i, t, ret;
1672 | 
1673 | 			id &= 0xFF;
1674 | 			if (id < 16) id += 0xE0;
1675 | 
1676 | 			if (id === 0xE0) {
1677 | 				t = this.jfif;
1678 | 				this.jfif = data;
1679 | 				return t;
1680 | 			}
1681 | 
1682 | 			ret = this.getAPPn(id, true);
1683 | 
1684 | 			if (data.length < 65534) {
1685 | 				this.APPn.push({ 'app': id, 'data': data });
1686 | 				return ret;
1687 | 			}
1688 | 
1689 | 			i = 0;
1690 | 
1691 | 			while (i < data.length) {
1692 | 				this.APPn.push({ 'app': id, 'data': data.subarray(i, i + 65533) });
1693 | 				i += 65533;
1694 | 			}
1695 | 
1696 | 			return ret;
1697 | 		};
1698 | 
1699 | 		f5stego.prototype.strip = function() {
1700 | 			this.clearTail();
1701 | 			this.clearAPPs();
1702 | 			return true;
1703 | 		};
1704 | 
1705 | 	// Shorthand functions to embed/extract f5 data
1706 | 	// ===========================================================================================================
1707 | 		f5stego.prototype.embed = function(image, data) {
1708 | 			this.parse(image).f5put(data);
1709 | 			return this.pack();
1710 | 		};
1711 | 
1712 | 		f5stego.prototype.extract = function(image) {
1713 | 			return this.parse(image).f5get();
1714 | 		};
1715 | 
1716 | 	return f5stego;
1717 | }));
1718 | 


--------------------------------------------------------------------------------