hook up obfuscator

Author: David Sheldrick

package.json

@@ -7,10 +7,13 @@
   "author": "David Sheldrick",
   "license": "MIT",
   "dependencies": {
+    "@types/app-root-path": "^1.2.4",
     "@types/babel-core": "^6.25.3",
+    "@types/babel-generator": "^6.25.1",
     "@types/node": "^9.3.0",
     "@types/semver": "^5.4.0",
     "app-root-path": "^2.0.1",
+    "babel-generator": "^6.26.0",
     "javascript-obfuscator": "^0.13.0",
     "jju": "^1.3.0",
     "semver": "^5.4.1",
@@ -25,7 +28,9 @@
   },
   "typings": "dist/index.d.ts",
   "lint-staged": {
-    "*.ts": ["prettier --no-semi --single-quote --trailing-comma es5"]
+    "*.ts": [
+      "prettier --no-semi --single-quote --trailing-comma es5"
+    ]
   },
   "devDependencies": {
     "@types/jest": "^22.0.1",
@@ -39,13 +44,25 @@
     "prettier": "^1.10.2",
     "react-native": "^0.45.1",
     "ts-jest": "^22.0.1",
+    "ts-node": "^4.1.0",
     "typescript": "^2.6.2"
   },
   "jest": {
     "transform": {
       ".(ts|tsx)": "<rootDir>/node_modules/ts-jest/preprocessor.js"
     },
+    "transformIgnorePatterns": [
+      "node_modules/(?!(javascript-obfuscator)/)"
+    ],
+    "moduleNameMapper": {
+      "javascript-obfuscator": "<rootDir>/node_modules/javascript-obfuscator/index.ts"
+    },
     "testRegex": "src/.*(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
-    "moduleFileExtensions": ["ts", "tsx", "js", "json"]
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "json"
+    ]
   }
 }

src/__tests__/files/es5.js

@@ -0,0 +1,4 @@
+var y = "yes"
+module.exports = function banana() {
+  return y
+}

src/__tests__/obfuscateCode.test.ts

@@ -0,0 +1,24 @@
+import * as fs from "fs"
+
+jest.mock("javascript-obfuscator", () => ({
+  obfuscate() {
+    return {
+      getObfuscatedCode() {
+        return "this code is obfuscated"
+      },
+      getSourceMap() {
+        return ""
+      },
+    }
+  },
+}))
+
+import { obfuscateCode } from "../obfuscateCode"
+
+describe("obfuscateCode", () => {
+  it("obfuscates code", () => {
+    const filename = require.resolve("./files/es5.js")
+    const es5code = fs.readFileSync(filename).toString()
+    expect(obfuscateCode(es5code, {})).toBe("this code is obfuscated")
+  })
+})

src/getMetroTransformer.ts

@@ -1,7 +1,9 @@
 import { Node } from "babel-core"
-import { RawSourceMap } from "source-map"
+import { RawSourceMap, SourceMapConsumer } from "source-map"
 import * as semver from "semver"
 import { MetroRawSourceMap } from "./composeSourceMaps"
+import * as babylon from "babylon"
+import traverse from "babel-traverse"
 
 export interface MetroTransformerResult {
   ast?: Node
@@ -47,3 +49,40 @@ export function getMetroTransformer(
     )
   }
 }
+
+export interface ReactNativeObfuscatingTransformerDefaultResult {
+  code: string
+  map: string
+}
+
+export function maybeTransformMetroResult(
+  { code, map }: ReactNativeObfuscatingTransformerDefaultResult,
+  reactNativeMinorVersion: number = getReactNativeMinorVersion(),
+): ReactNativeObfuscatingTransformerDefaultResult | { ast: Node } {
+  if (reactNativeMinorVersion >= 52) {
+    // convert code and map to ast
+    const ast = babylon.parse(code, {
+      sourceType: "module",
+    })
+
+    const mapConsumer = new SourceMapConsumer(map as any) // upstream types are wrong
+    ;(traverse as any).cheap(ast, (node: Node) => {
+      if (node.loc) {
+        const originalStart = mapConsumer.originalPositionFor(node.loc.start)
+        if (originalStart.line) {
+          node.loc.start.line = originalStart.line
+          node.loc.start.column = originalStart.column
+        }
+        const originalEnd = mapConsumer.originalPositionFor(node.loc.end)
+        if (originalEnd.line) {
+          node.loc.start.line = originalEnd.line
+          node.loc.start.column = originalEnd.column
+        }
+      }
+    })
+
+    return { ast }
+  } else {
+    return { code, map }
+  }
+}

src/obfuscateCode.ts

@@ -0,0 +1,50 @@
+import * as Obfuscator from "javascript-obfuscator"
+import {
+  convertMetroRawSourceMapToStandardSourceMap,
+  composeSourceMaps,
+  MetroRawSourceMap,
+} from "./composeSourceMaps"
+import { RawSourceMap } from "source-map/source-map"
+
+export function obfuscateCode(
+  code: string,
+  options: Obfuscator.Options,
+): string {
+  return Obfuscator.obfuscate(code, options).getObfuscatedCode()
+}
+
+export function obfuscateCodePreservingSourceMap(
+  code: string,
+  map: string | RawSourceMap | MetroRawSourceMap,
+  originlFilename: string,
+  originalSource: string,
+  options: Obfuscator.Options,
+): { code: string; map: string } {
+  const obfuscationResult = Obfuscator.obfuscate(code, options)
+  const obfuscationResultMap = obfuscationResult.getSourceMap()
+
+  if (!obfuscationResultMap) {
+    throw new Error(
+      "javascript-obfuscator did not return a source map for file " +
+        originlFilename,
+    )
+  }
+
+  if (Array.isArray(map)) {
+    map = convertMetroRawSourceMapToStandardSourceMap(
+      map,
+      originlFilename,
+      originalSource,
+    )
+  }
+
+  return {
+    code: obfuscationResult.getObfuscatedCode(),
+    map: composeSourceMaps(
+      map,
+      obfuscationResultMap,
+      originlFilename,
+      originalSource,
+    ),
+  }
+}

src/obfuscatingTransformer.ts

@@ -1,39 +1,98 @@
 import * as crypto from "crypto"
 import * as fs from "fs"
+import * as path from "path"
 import * as JavaScriptObfuscator from "javascript-obfuscator"
+import { path as appRootPath } from "app-root-path"
+
+import generate from "babel-generator"
 
 import { getCallerFile } from "./getCallerFile"
-import { MetroTransformer, getMetroTransformer } from "./getMetroTransformer"
+import {
+  MetroTransformer,
+  getMetroTransformer,
+  MetroTransformerResult,
+  maybeTransformMetroResult,
+} from "./getMetroTransformer"
+import {
+  obfuscateCode,
+  obfuscateCodePreservingSourceMap,
+} from "./obfuscateCode"
 
-function getOwnCacheKey(upstreamCacheKey: string, callerFilename: string) {
+function getOwnCacheKey(upstreamCacheKey: string, configFilename: string) {
   var key = crypto.createHash("md5")
   key.update(upstreamCacheKey)
   key.update(fs.readFileSync(__filename))
-  key.update(fs.readFileSync(callerFilename))
+  key.update(fs.readFileSync(configFilename))
   return key.digest("hex")
 }
 
 export interface ObfuscatingTransformerOptions {
-  match?: RegExp
+  filter?(filename: string, source: string): boolean
   upstreamTransformer?: MetroTransformer
   obfuscatorOptions?: JavaScriptObfuscator.Options
+  trace?: boolean
 }
 
+const sourceDir = path.join(appRootPath, "src")
+
 export function obfuscatingTransformer({
-  match = /.*.js/,
+  filter = filename => filename.startsWith(sourceDir),
   upstreamTransformer = getMetroTransformer(),
-  ..._options
+  obfuscatorOptions: _obfuscatorOptions,
+  ...otherOptions
 }: ObfuscatingTransformerOptions): MetroTransformer {
   const callerFilename = getCallerFile()
 
+  const obfuscatorOptions: JavaScriptObfuscator.Options = {
+    ..._obfuscatorOptions,
+    sourceMap: true,
+    sourceMapMode: "separate",
+    stringArray: false,
+  }
+
   return {
     transform(props) {
       const result = upstreamTransformer.transform(props)
-      if (props.filename.match(match)) {
-        console.log("obfuscating", props.filename)
+      const resultCanBeObfuscated = result.code || result.ast
+
+      if (resultCanBeObfuscated && filter(props.filename, props.src)) {
+        if (otherOptions.trace) {
+          console.log("Obfuscating", props.filename)
+        }
+
+        const { code, map }: MetroTransformerResult = result.code
+          ? result
+          : result.ast
+            ? (generate(result.ast, {
+                filename: props.filename,
+                retainLines: true,
+                sourceMaps: true,
+                sourceFileName: props.filename,
+              }) as MetroTransformerResult)
+            : { code: "", map: "" }
+
+        if (!code) {
+          return result
+        } else if (!map) {
+          return {
+            code: obfuscateCode(code, obfuscatorOptions),
+          }
+        }
+
+        return maybeTransformMetroResult(
+          obfuscateCodePreservingSourceMap(
+            code,
+            map,
+            props.filename,
+            props.src,
+            obfuscatorOptions,
+          ),
+        )
       }
+
       return result
     },
+
     getCacheKey() {
       return getOwnCacheKey(
         upstreamTransformer.getCacheKey

tsconfig.json

@@ -10,7 +10,6 @@
     "moduleResolution": "node",
     "noUnusedLocals": true,
     "noUnusedParameters": true,
-    "inlineSourceMap": true,
     "declaration": true,
     "baseUrl": ".",
     "paths": {
@@ -19,7 +18,6 @@
       ]
     },
     "experimentalDecorators": true,
-    "inlineSources": true
   },
   "include": [
     "typings",