├── .gitignore
├── .travis.yml
├── AUTHORS
├── CHANGES
├── README.md
├── crxmake
    ├── __init__.py
    └── crxmake.py
├── examples
    └── app
    │   ├── _locales
    │       └── en
    │       │   └── messages.json
    │   ├── manifest.json
    │   └── scripts
    │       └── background.js
├── legacy
    └── m2crypto-0.20.2-enable-rsa-pubout.patch
├── scripts
    └── crxmake
├── setup.py
└── test
    ├── __init__.py
    └── test_crxmake.py


/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | *~


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: python
2 | python:
3 |   - "2.7"
4 | # command to install dependencies, e.g. pip install -r requirements.txt --use-mirrors
5 | install: "pip install . --use-mirrors"
6 | # command to run tests, e.g. python setup.py test
7 | script: nosetests
8 | 


--------------------------------------------------------------------------------
/AUTHORS:
--------------------------------------------------------------------------------
1 | @bellbind - maintainer
2 | @mekarpeles


--------------------------------------------------------------------------------
/CHANGES:
--------------------------------------------------------------------------------
 1 | v0.0.2, Tue 04, March 2014 -- Refactor
 2 | - renamed zip var to zf to avoid clobering zip builtin
 3 | - created functions for public key, private key creation and signing
 4 | - added .travis.yml and test case placeholder
 5 | - setup.py for easy installation
 6 | - added swig as os level dependency within README
 7 | - added file injection (inject files from memory into zip dynamically)
 8 | 
 9 | v0.0.1, Fri 02, Jul 2010  -- Initial Release. (bellbind)
10 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # crxmake-python
 2 | 
 3 | Python script for building google chrome extension crx package.
 4 | It is inspired by rubygems' crxmake.
 5 | 
 6 | ## Ubuntu Installation
 7 | 
 8 |     sudo apt-get install swig
 9 |     sudo pip install crxmake
10 | 
11 | ## Usage:
12 | 
13 |     crxmake.py PACKAGE_BASE_DIR
14 | 
15 | ## Example
16 | 
17 | An example extension named 'app' is provided in the examples/
18 | directory for testing purposes:
19 | 
20 |     $ crxmake.py examples/app
21 |     $ ls examples/app
22 |     $ app app.crx app.pem
23 | 
24 | ## Requires:
25 | 
26 | - python 2
27 | - swig
28 | - M2Crypto (available via pip, requires swig)
29 | - "openssl" command: because current M2Crypto lacks func for rsa pubout DER
30 | 
31 | ## Legacy Dependencies
32 | 
33 | ### Appendix: m2crypto-0.20.2-enable-rsa-pubout.patch
34 | 
35 | "svn diff" output for appending the feature for rsa pubout DER.
36 | 
37 | Howto build m2crypto with it:
38 | 
39 |     svn co http://svn.osafoundation.org/m2crypto/tags/0.20.2 m2crypto-0.20.2
40 |     cd m2crypto-0.20.2
41 |     patch -p0 < ../legacy/m2crypto-0.20.2-enable-rsa-pubout.patch
42 |     python setup.py build
43 | 
44 | (I hope someone send it to M2Crypto maintainer ^^)
45 | 
46 | ## Resources:
47 | 
48 | - "M2Crypto":http://chandlerproject.org/bin/view/Projects/MeTooCrypto
49 | - "crxmake":http://github.com/Constellation/crxmake
50 | - "Packing Chrome extensions in Python":http://grack.com/blog/2009/11/09/packing-chrome-extensions-in-python/
51 | 


--------------------------------------------------------------------------------
/crxmake/__init__.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | # -*- mode: python coding: utf-8 -*-
 3 | 
 4 | """crxmake packages chrome extensions as .crx from python"""
 5 | 
 6 | __version__ = "0.0.2"
 7 | __author__ = [
 8 |     "bellbind <bellbind@gmail.com>"
 9 | ]
10 | __license__ = "see LICENSE"
11 | __contributors__ = "see AUTHORS"
12 | 
13 | from crxmake import package, cli
14 | 


--------------------------------------------------------------------------------
/crxmake/crxmake.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | # -*- mode: python coding: utf-8 -*-
  3 | 
  4 | """
  5 |     crxmake
  6 |     ~~~~~~~
  7 | 
  8 |     building google chrome extension crx with commandline
  9 |     it is inspired by rubygem's crxmake
 10 |     requires: M2Crypto module (and "openssl" commandline)
 11 | 
 12 |     :copyright: (c) 2010 bellbind
 13 |     :license: pending, see LICENSE for more details.
 14 | """
 15 | 
 16 | import os
 17 | import sys
 18 | import io
 19 | import argparse
 20 | import tempfile
 21 | import dircache
 22 | import hashlib
 23 | import struct
 24 | import subprocess
 25 | import zipfile
 26 | import M2Crypto.EVP
 27 | import M2Crypto.RSA
 28 | import M2Crypto.BIO
 29 | 
 30 | MAGIC = "Cr24"
 31 | VERSION = struct.pack("<I", 2)
 32 | 
 33 | def rm_trailing_slash(d):
 34 |     """Removing trailing slash from directory name
 35 | 
 36 |     usage:
 37 |         >>> rm_trailing_slash('foo/bar/')
 38 |         'foo/bar'
 39 |     """
 40 |     return d[:-1] if d.endswith(os.path.sep) else d
 41 | 
 42 | def package(basedir, files=None, magic=MAGIC, version=VERSION):
 43 |     """Create a chrome extension .crx package of a base directory
 44 | 
 45 |     params:
 46 |         basedir - the base directory where the application is located
 47 |         files - a dict of {filepath: filecontents} to inject before
 48 |                 packing.  Useful for dynamically injecting configs or
 49 |                 keys within projects. Filenames are relative to basedir.
 50 |                 i.e. 'scripts/config.js'
 51 |     """
 52 |     if not os.path.isdir(basedir):
 53 |         raise IOError("Non-existant directory <%s>" % basedir)
 54 |     crxd = rm_trailing_slash(basedir)
 55 | 
 56 |     try:
 57 |         zipdata = zipdir(crxd, inject=files)
 58 |     except IOError as e:
 59 |         raise e
 60 |     pem, key = create_privatekey(crxd)
 61 |     sig = sign(zipdata, pem)
 62 |     der = create_publickey(crxd, key)
 63 | 
 64 |     der_len = struct.pack("<I", len(der))
 65 |     sig_len = struct.pack("<I", len(sig))
 66 | 
 67 |     with open("%s.crx" % crxd, 'w') as crx:
 68 |         data = [magic, version, der_len, sig_len, der, sig, zipdata]
 69 |         for d in data:
 70 |             crx.write(d)
 71 | 
 72 | def zipdir(directory, inject=None):
 73 |     """Create a .zip of the directory in memory and return its data
 74 | 
 75 |     params:
 76 |         inject - dict allows you to inject content into an app
 77 |                  (such as config files, keys, or secrets). The
 78 |                  format is {'filepath': 'file contents ...'}.
 79 |     """
 80 |     zip_memory = io.BytesIO()
 81 |     with zipfile.ZipFile(zip_memory, "w", zipfile.ZIP_DEFLATED) as zf:
 82 |         def _rec_zip(path, parent="", inject=None):
 83 |             """utility method for recursively zipping"""
 84 |             if inject:
 85 |                 for fname, fdata in inject.items():
 86 |                     fpath = '%s/%s' % (directory, fname)
 87 |                     zf.writestr(fname, fdata) 
 88 | 
 89 |             for d in dircache.listdir(path):
 90 |                 child = os.path.join(path, d)
 91 |                 name = "%s/%s" % (parent, d)
 92 |                 if os.path.isfile(child):
 93 |                     zf.write(child, name)
 94 |                 if os.path.isdir(child):
 95 |                     _rec_zip(child, name)
 96 | 
 97 |         _rec_zip(directory, "", inject=inject)
 98 |         zf.close()
 99 |         zipdata = zip_memory.getvalue()
100 |         return zipdata
101 |     raise IOError("Failed to create zip")
102 | 
103 | def create_publickey(crxd, key):
104 |     """generate public key DER"""
105 |     if hasattr(key, "save_pub_key_der_bio"):
106 |         mem_bio = M2Crypto.BIO.MemoryBuffer()
107 |         key.save_pub_key_der_bio(mem_bio) # missing API on M2Crypto <= 0.20.2
108 |         return mem_bio.getvalue()
109 |     else:
110 |         return subprocess.Popen(
111 |             ["openssl", "rsa", "-pubout", "-outform", "DER",
112 |              "-inform", "PEM", "-in", "%s.pem" % crxd],
113 |             stdout=subprocess.PIPE).stdout.read()
114 | 
115 | def create_privatekey(path):
116 |     """Create a private key PEM file"""
117 |     pemfile = "%s.pem" % path
118 |     if os.path.exists(pemfile):
119 |         with open(pemfile, "r") as pf:
120 |             key = M2Crypto.RSA.load_key(pemfile)
121 |             pem = pf.read()
122 |             return pem, key
123 |     with open(pemfile, "w") as pf:
124 |         key = M2Crypto.RSA.gen_key(1024, 65537, lambda: None)
125 |         pem = key.as_pem(cipher=None)
126 |         pf.write(pem)
127 |         return pem, key
128 | 
129 | def sign(data, pem):
130 |     """Sign a data with a key using M2Crypto wrapper for OpenSSL EVP
131 |     API
132 |     """
133 |     pkey = M2Crypto.EVP.load_key_string(pem)
134 |     pkey.sign_init()
135 |     pkey.sign_update(data)
136 |     signature = pkey.sign_final()
137 |     return signature
138 | 
139 | def argparser():
140 |     parser = argparse.ArgumentParser(description="crxmake ")
141 |     parser.add_argument("src", type=str, default='',
142 |                         help="Source directory containing unpacked chrome ext")
143 |     parser.add_argument("-o", "--output", type=str, default='',
144 |                         help="Output directory for packed .crx")
145 |     return parser
146 | 
147 | def cli():
148 |     parser = argparser()
149 |     args = parser.parse_args()
150 |     if not args.src:
151 |         raise ValueError("src of app is required argument")
152 |     package(args.src)
153 | 
154 | if __name__ == "__main__":
155 |     cli()
156 | 


--------------------------------------------------------------------------------
/examples/app/_locales/en/messages.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "appName": {
 3 |     "message": "CrxmakeTestApp",
 4 |     "description": "Test chrome extension"
 5 |   },
 6 |   "appDescription": {
 7 |     "message": "Test chrome extension",
 8 |     "description": "Tests python crxmake chrome extension packager"
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/examples/app/manifest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "__MSG_appName__",
 3 |   "version": "0.0.1",
 4 |   "manifest_version": 2,
 5 |   "description": "__MSG_appDescription__",
 6 |   "default_locale": "en",
 7 |   "browser_action": {
 8 |     "default_title": "__MSG_appName__",
 9 |   },
10 |   "background": {
11 |     "scripts": ["scripts/background.js"]
12 |   },
13 |   "permissions": [
14 |     "http://*/*",
15 |   ]
16 | }
17 | 


--------------------------------------------------------------------------------
/examples/app/scripts/background.js:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bellbind/crxmake-python/a40000f7186531ef1526b002b07b674a3c218f74/examples/app/scripts/background.js


--------------------------------------------------------------------------------
/legacy/m2crypto-0.20.2-enable-rsa-pubout.patch:
--------------------------------------------------------------------------------
 1 | Index: M2Crypto/RSA.py
 2 | ===================================================================
 3 | --- M2Crypto/RSA.py	(revision 724)
 4 | +++ M2Crypto/RSA.py	(working copy)
 5 | @@ -138,6 +138,25 @@
 6 |          bio = BIO.openfile(file, 'wb')
 7 |          return self.save_key_der_bio(bio)
 8 |  
 9 | +    def save_pub_key_der_bio(self, bio):
10 | +        """
11 | +        Save the public key to an M2Crypto.BIO.BIO object in DER format.
12 | +
13 | +        @type bio: M2Crypto.BIO.BIO
14 | +        @param bio: M2Crypto.BIO.BIO object to save key to.
15 | +        """
16 | +        return m2.rsa_write_pub_key_der(self.rsa, bio._ptr())
17 | +    
18 | +    def save_pub_key_der(self, file):
19 | +        """
20 | +        Save the public key to a file in DER format.
21 | +
22 | +        @type file: str
23 | +        @param file: Filename to save key to
24 | +        """
25 | +        bio = BIO.openfile(file, 'wb')
26 | +        return self.save_pub_key_der_bio(bio)
27 | +
28 |      def save_pub_key_bio(self, bio):
29 |          """
30 |          Save the public key to an M2Crypto.BIO.BIO object in PEM format.
31 | Index: SWIG/_rsa.i
32 | ===================================================================
33 | --- SWIG/_rsa.i	(revision 724)
34 | +++ SWIG/_rsa.i	(working copy)
35 | @@ -440,6 +440,17 @@
36 |  }
37 |  %}
38 |  
39 | +%threadallow rsa_write_pub_key_der;
40 | +%inline %{
41 | +int rsa_write_pub_key_der(RSA *rsa, BIO *bio) {
42 | +  /*
43 | +    it writes same format of  "openssl rsa -pubout -outform DER".
44 | +    i2d_RSAPublicKey_bio(bio, rsa) writes no header struct data.
45 | +  */
46 | +  return i2d_RSA_PUBKEY_bio(bio, rsa); 
47 | +}
48 | +%}
49 | +
50 |  %threadallow rsa_write_key_der;
51 |  %inline %{
52 |  int rsa_write_key_der(RSA *rsa, BIO *bio) {
53 | 


--------------------------------------------------------------------------------
/scripts/crxmake:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | # -*- mode: python coding: utf-8 -*-
 3 | 
 4 | """
 5 |     crxmake
 6 |     ~~~~~~~
 7 | 
 8 |     building google chrome extension crx with commandline
 9 |     it is inspired by rubygem's crxmake
10 |     requires: M2Crypto module (and "openssl" commandline)
11 | 
12 |     :copyright: (c) 2010 bellbind
13 |     :license: pending, see LICENSE for more details.
14 | """
15 | 
16 | import crxmake
17 | 
18 | if __name__ == "__main__":
19 |     crxmake.cli()
20 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | #-*- coding: utf-8 -*-
 2 | 
 3 | """
 4 |     crxmake
 5 |     ~~~~~~~
 6 | 
 7 |     Setup
 8 |     `````
 9 |     $ sudo apt-get install swig # dep for m2crypto
10 |     $ sudo pip install .
11 | """
12 | 
13 | from distutils.core import setup
14 | import os
15 | 
16 | setup(
17 |     name='crxmake',
18 |     version='0.0.2',
19 |     url='http://github.com/bellbind/crxmake',
20 |     author='bellbind',
21 |     author_email='bellbind@gmail.com',
22 |     packages=[
23 |         'crxmake',
24 |         ],
25 |     platforms='any',
26 |     license='LICENSE',
27 |     install_requires=[
28 |         'm2crypto'
29 |     ],
30 |     scripts=[
31 |         "scripts/crxmake"
32 |         ],
33 |     description="crxmake packages chrome extensions as .crx from python",
34 |     long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
35 | )
36 | 


--------------------------------------------------------------------------------
/test/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bellbind/crxmake-python/a40000f7186531ef1526b002b07b674a3c218f74/test/__init__.py


--------------------------------------------------------------------------------
/test/test_crxmake.py:
--------------------------------------------------------------------------------
 1 | #-*- coding: utf-8 -*-
 2 | 
 3 | """
 4 |     crxmake.test
 5 |     ~~~~~~~~~~~~
 6 | 
 7 |     Test cases for the makecrx module
 8 | 
 9 |     :copyright: (c) 2010 bellbind
10 |     :license: pending, see LICENSE for more details.
11 | """
12 | 
13 | import unittest
14 | import os
15 | 
16 | class TestWaltz(unittest.TestCase):
17 | 
18 |     pass
19 | 


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