Python obfuscator online
(as a web form)

This web form obfuscates your one-file Python program or module within seconds.

It achieves NON-1:1 mapping of identifiers within your program to obfuscated identifiers. For example, not only is 'self' no longer 'self', but 'self' is generally replaced by a variety of different gibberish identifiers, without impairing program functionality.

Docstrings and comments are also removed.

As a limited demo, this webpage only supports:

Python 2.3 (Realistically, almost all Python 2.4 and Python 2.5 features are supported by a Python 2.3 compliant obfuscator.)
Most standard library modules, specifically, about all that are:
- sufficiently cross-platform to be present in both Unix and Windows versions of typical builds of Python
Obfuscates single module/file of limited size.

In general there is the additional limitation:

Limits on handling of keyword arguments

Please paste your source code into the box below.

12345678901234567890123456789012345678901234567890123456789012345678901234567890
         1         2         3         4         5         6         7         8

"""Demo code.
   Note that class animal is labeled EXPORT within the code, 
   so it isn't renamed.
   Ditto for animal's shout method.
"""
import string
import sys    # for stderr

from sys import stdout, stdin

lista = ['a', (0, 'second/oneth'), 3, [[0x10, 'word'], [sys.stdout.write]] ]
for x in lista:
  print x, ' is in lista.'
  'This string is wholly gratuitous.'

if 1:
  print "\nAnalyzing lista's contents a little:"
  for x in lista:
    print x, ' is in lista.'
    if isinstance(x, list):
      print '   x is a list.'
      if 0:
        pass
      else:
        pass
    else:
      print '   x is not a list.'
    'This string is wholly gratuitous.'
    print 'Next item!'
  print ""
else:
  print 'constant was false.'

dicta = {'William': 7, 7: 'seven', 'sys.stdout.write': sys.stdout.write,
         (52.24, .01): 'London', 'example-list':  ['I', ['deeper', 2], 'or']}

print "This doesn't end with a newline>",
stdout.write('Hello stdout.')

print "\n\n= = = = = = = = = = = = == = = = = =\n\n"

#import string

def weigh(a):
  """I am the docstring for global function weigh."""
  print a.weigh()

class animal:
  """EXPORT
     I am the docstr for class animal."""

def __init__(self, massGrams):
    self.massGrams = massGrams
  
  def sound(self, a):
    """I am the docstr for animal.sound(self, what2say),
       which attempts to make the animal 'speak' the string argument what2say."""
    print 'Animal says:', a

def shout(self, a):
    """EXPORT
       Like sound, but CAPITALIZES GRATUITOUSLY. """
    self.sound(string.upper(a))

def poop(self, massGrams):
    """This docstr is basically crap and we will throw it away."""
    self.massGrams -= massGrams
    print 'Animal poops', massGrams, 'grams.'

def weigh(self):
    print 'Animal now weighs', self.massGrams, 'grams.'

class dirt:
  def __init__(self, massGrams):
    self.massGrams = massGrams
  def get_weight(self):
    return self.massGrams

class vegetable:
  """Don't eat your vegetables!"""

def __init__(self, massGrams):
    self.massGrams = massGrams
  
  def weigh(self):
    print 'Vegetable now weighs', self.massGrams, 'grams.'

def loseWater(self, massGrams):
    self.massGrams -= massGrams
    print 'Vegetable loses water,', massGrams, 'grams.'

def len(self):
    """ I assume vegetables are immeasurable,
        maybe they change shape and size as they retain and lose water,
        and also most have no skeletons. """
    return None

class tuber(vegetable):

def __init__(self, massGrams, dirt=None):
    vegetable.__init__(self, massGrams)
    self.dirt = dirt

def weigh(self):
    if self.dirt == None:
      print 'Dirt on scale adds estimated 5 grams, for a total of', self.massGrams
    else:
      print 'tuber weighs:', self.massGrams + self.dirt.massGrams

def plant_them(vegetables):
  pass;
  for v1 in vegetables:
    print 'I plant something with weight...'
    v1.weigh()

class rutabaga(tuber):
  pass

class slimemold(animal, vegetable):

def sound(self, a):
    print 'Slime molds are very quiet and cannot talk.'

def marksection(a):
  print
  print '---', a, 'SECTION --------------------------------'

marksection('ANIMAL')
a1 = animal(500)
a1.sound('squeak')
a1.weigh()
a1.poop(5)
a1.weigh()
a1.shout('squeak')

marksection('VEGETABLE')
v1 = vegetable(200)
v1.weigh()
v1.loseWater(2)
v1.weigh()
print "the vegetable's length is", v1.len()

marksection('TUBER')
t1 = tuber(100, dirt(3))
t1.weigh()
t1.loseWater(2)
t1.weigh()
print "the tuber's length is", t1.len()

marksection('ANIMAL (2)')
print "I try to weigh an animal: "
a1.weigh()

marksection('SLIMEMOLD')
s1 = slimemold(20)
s1.weigh()
s1.sound('Hello, you might think I am disgusting creature, but actually I am all-natural.')

marksection('PLANTING')
plant_them([a1, v1, t1])

Names to specially spare from obfuscation (obfuscator should not need help for most names):

I would appreciate your feedback about this online obfuscator. Perhaps you would even like to license a more complete version of my obfuscator toolkit?

Click here for contact information.

Please report any bugs!

Technical Commentary

Limits on handling of keyword arguments

If you make a function call with keyword arguments, the keyword argument names in the function call are presently left unobfuscated. Why did I do this? Suppose the keyword arguments are going into a dictionary, as in this example code from Guido van Rossum's Python Tutorial (Release 2.4.2) wherein the dictionary is named "keywords" ...

  def cheeseshop(kind, *arguments, **keywords):
    print "-- Do you have any", kind, '?'
    print "-- I'm sorry, we're all out of", kind
    for arg in arguments: print arg
    print '-'*40
    keys = keywords.keys()
    keys.sort()
    for kw in keys: print kw, ':', keywords[kw]
  cheeseshop('Limburger', "It's very runny, sir.",
             "It's really very, VERY runny, sir.",
             client='John Cleese',
             shopkeeper='Michael Palin',
             sketch='Cheese Shop Sketch')

which is intended to print:

  -- Do you have any Limburger ?
  -- I'm sorry, we're all out of Limburger
  It's very runny, sir.
  It's really very, VERY runny, sir.
  ----------------------------------------
  client : John Cleese
  shopkeeper : Michael Palin
  sketch : Cheese Shop Sketch

The latter part of the output would be totally ruined if we obfuscate the keyword argument names, which would change the words 'client', 'shopkeeper' and 'sketch'. I didn't want to try to automatically distinguish every case where the keyword arguments' names should be obfuscated from every case where they should not be.

This shortcoming can become a nuisance, because if you're calling a function with many declared arguments, you might want your call to mention some declared arguments by name to improve your code's readability, and/or to help you select which of the function's default arguments you want used.

Please contact me if you find this issue important and want me to address it.

Python obfuscator online (as a web form)

Technical Commentary

Limits on handling of keyword arguments

Python obfuscator online
(as a web form)