1 from __future__ import unicode_literals
14 def _extract_tags(file_contents):
15 if file_contents[1:3] != b'WS':
17 'Not an SWF file; header is %r' % file_contents[:3])
18 if file_contents[:1] == b'C':
19 content = zlib.decompress(file_contents[8:])
21 raise NotImplementedError(
22 'Unsupported compression format %r' %
25 # Determine number of bits in framesize rectangle
26 framesize_nbits = struct_unpack('!B', content[:1])[0] >> 3
27 framesize_len = (5 + 4 * framesize_nbits + 7) // 8
29 pos = framesize_len + 2 + 2
30 while pos < len(content):
31 header16 = struct_unpack('<H', content[pos:pos + 2])[0]
33 tag_code = header16 >> 6
34 tag_len = header16 & 0x3f
36 tag_len = struct_unpack('<I', content[pos:pos + 4])[0]
38 assert pos + tag_len <= len(content), \
39 ('Tag %d ends at %d+%d - that\'s longer than the file (%d)'
40 % (tag_code, pos, tag_len, len(content)))
41 yield (tag_code, content[pos:pos + tag_len])
45 class _AVMClass_Object(object):
46 def __init__(self, avm_class):
47 self.avm_class = avm_class
50 return '%s#%x' % (self.avm_class.name, id(self))
53 class _ScopeDict(dict):
54 def __init__(self, avm_class):
55 super(_ScopeDict, self).__init__()
56 self.avm_class = avm_class
59 return '%s__Scope(%s)' % (
61 super(_ScopeDict, self).__repr__())
64 class _AVMClass(object):
65 def __init__(self, name_idx, name, static_properties=None):
66 self.name_idx = name_idx
68 self.method_names = {}
71 self.method_pyfunctions = {}
72 self.static_properties = static_properties if static_properties else {}
74 self.variables = _ScopeDict(self)
77 def make_object(self):
78 return _AVMClass_Object(self)
81 return '_AVMClass(%s)' % (self.name)
83 def register_methods(self, methods):
84 self.method_names.update(methods.items())
85 self.method_idxs.update(dict(
87 for name, idx in methods.items()))
90 class _Multiname(object):
91 def __init__(self, kind):
95 return '[MULTINAME kind: 0x%x]' % self.kind
98 def _read_int(reader):
104 b = struct_unpack('<B', buf)[0]
105 res = res | ((b & 0x7f) << shift)
113 res = _read_int(reader)
114 assert res & 0xf0000000 == 0
120 v = _read_int(reader)
121 if v & 0x80000000 != 0:
122 v = - ((v ^ 0xffffffff) + 1)
129 last_byte = b'\xff' if (ord(bs[2:3]) >= 0x80) else b'\x00'
130 return struct_unpack('<i', bs + last_byte)[0]
133 def _read_string(reader):
135 resb = reader.read(slen)
136 assert len(resb) == slen
137 return resb.decode('utf-8')
140 def _read_bytes(count, reader):
142 resb = reader.read(count)
143 assert len(resb) == count
147 def _read_byte(reader):
148 resb = _read_bytes(1, reader=reader)
149 res = struct_unpack('<B', resb)[0]
153 StringClass = _AVMClass('(no name idx)', 'String')
154 ByteArrayClass = _AVMClass('(no name idx)', 'ByteArray')
155 TimerClass = _AVMClass('(no name idx)', 'Timer')
156 TimerEventClass = _AVMClass('(no name idx)', 'TimerEvent', {'TIMER': 'timer'})
158 StringClass.name: StringClass,
159 ByteArrayClass.name: ByteArrayClass,
160 TimerClass.name: TimerClass,
161 TimerEventClass.name: TimerEventClass,
165 class _Undefined(object):
168 __nonzero__ = __bool__
173 undefined = _Undefined()
176 class SWFInterpreter(object):
177 def __init__(self, file_contents):
178 self._patched_functions = {
179 (TimerClass, 'addEventListener'): lambda params: undefined,
182 for tag_code, tag in _extract_tags(file_contents)
184 p = code_tag.index(b'\0', 4) + 1
185 code_reader = io.BytesIO(code_tag[p:])
187 # Parse ABC (AVM2 ByteCode)
189 # Define a couple convenience methods
190 u30 = lambda *args: _u30(*args, reader=code_reader)
191 s32 = lambda *args: _s32(*args, reader=code_reader)
192 u32 = lambda *args: _u32(*args, reader=code_reader)
193 read_bytes = lambda *args: _read_bytes(*args, reader=code_reader)
194 read_byte = lambda *args: _read_byte(*args, reader=code_reader)
196 # minor_version + major_version
201 self.constant_ints = [0]
202 for _c in range(1, int_count):
203 self.constant_ints.append(s32())
204 self.constant_uints = [0]
206 for _c in range(1, uint_count):
207 self.constant_uints.append(u32())
209 read_bytes(max(0, (double_count - 1)) * 8)
211 self.constant_strings = ['']
212 for _c in range(1, string_count):
213 s = _read_string(code_reader)
214 self.constant_strings.append(s)
215 namespace_count = u30()
216 for _c in range(1, namespace_count):
220 for _c in range(1, ns_set_count):
222 for _c2 in range(count):
224 multiname_count = u30()
233 0x0e: 2, # MultinameA
234 0x1b: 1, # MultinameL
235 0x1c: 1, # MultinameLA
237 self.multinames = ['']
238 for _c in range(1, multiname_count):
240 assert kind in MULTINAME_SIZES, 'Invalid multiname kind %r' % kind
242 u30() # namespace_idx
244 self.multinames.append(self.constant_strings[name_idx])
248 self.multinames.append(self.constant_strings[name_idx])
250 self.multinames.append(_Multiname(kind))
251 for _c2 in range(MULTINAME_SIZES[kind]):
256 MethodInfo = collections.namedtuple(
258 ['NEED_ARGUMENTS', 'NEED_REST'])
260 for method_id in range(method_count):
263 for _ in range(param_count):
265 u30() # name index (always 0 for youtube)
267 if flags & 0x08 != 0:
270 for c in range(option_count):
273 if flags & 0x80 != 0:
274 # Param names present
275 for _ in range(param_count):
277 mi = MethodInfo(flags & 0x01 != 0, flags & 0x04 != 0)
278 method_infos.append(mi)
281 metadata_count = u30()
282 for _c in range(metadata_count):
285 for _c2 in range(item_count):
289 def parse_traits_info():
290 trait_name_idx = u30()
291 kind_full = read_byte()
292 kind = kind_full & 0x0f
293 attrs = kind_full >> 4
296 if kind == 0x00: # Slot
298 u30() # type_name_idx
302 elif kind == 0x06: # Const
304 u30() # type_name_idx
309 if vkind == 0x03: # Constant_Int
310 value = self.constant_ints[vindex]
311 elif vkind == 0x04: # Constant_UInt
312 value = self.constant_uints[vindex]
314 return {}, None # Ignore silently for now
315 constants = {self.multinames[trait_name_idx]: value}
316 elif kind in (0x01, 0x02, 0x03): # Method / Getter / Setter
319 methods[self.multinames[trait_name_idx]] = method_idx
320 elif kind == 0x04: # Class
323 elif kind == 0x05: # Function
326 methods[function_idx] = self.multinames[trait_name_idx]
328 raise ExtractorError('Unsupported trait kind %d' % kind)
330 if attrs & 0x4 != 0: # Metadata present
331 metadata_count = u30()
332 for _c3 in range(metadata_count):
333 u30() # metadata index
335 return methods, constants
340 for class_id in range(class_count):
343 cname = self.multinames[name_idx]
344 avm_class = _AVMClass(name_idx, cname)
345 classes.append(avm_class)
347 u30() # super_name idx
349 if flags & 0x08 != 0: # Protected namespace is present
350 u30() # protected_ns_idx
352 for _c2 in range(intrf_count):
356 for _c2 in range(trait_count):
357 trait_methods, trait_constants = parse_traits_info()
358 avm_class.register_methods(trait_methods)
360 avm_class.constants.update(trait_constants)
362 assert len(classes) == class_count
363 self._classes_by_name = dict((c.name, c) for c in classes)
365 for avm_class in classes:
366 avm_class.cinit_idx = u30()
368 for _c2 in range(trait_count):
369 trait_methods, trait_constants = parse_traits_info()
370 avm_class.register_methods(trait_methods)
372 avm_class.constants.update(trait_constants)
376 for _c in range(script_count):
379 for _c2 in range(trait_count):
383 method_body_count = u30()
384 Method = collections.namedtuple('Method', ['code', 'local_count'])
385 self._all_methods = []
386 for _c in range(method_body_count):
390 u30() # init_scope_depth
391 u30() # max_scope_depth
393 code = read_bytes(code_length)
394 m = Method(code, local_count)
395 self._all_methods.append(m)
396 for avm_class in classes:
397 if method_idx in avm_class.method_idxs:
398 avm_class.methods[avm_class.method_idxs[method_idx]] = m
399 exception_count = u30()
400 for _c2 in range(exception_count):
407 for _c2 in range(trait_count):
410 assert p + code_reader.tell() == len(code_tag)
412 def patch_function(self, avm_class, func_name, f):
413 self._patched_functions[(avm_class, func_name)] = f
415 def extract_class(self, class_name, call_cinit=True):
417 res = self._classes_by_name[class_name]
419 raise ExtractorError('Class %r not found' % class_name)
421 if call_cinit and hasattr(res, 'cinit_idx'):
422 res.register_methods({'$cinit': res.cinit_idx})
423 res.methods['$cinit'] = self._all_methods[res.cinit_idx]
424 cinit = self.extract_function(res, '$cinit')
429 def extract_function(self, avm_class, func_name):
430 p = self._patched_functions.get((avm_class, func_name))
433 if func_name in avm_class.method_pyfunctions:
434 return avm_class.method_pyfunctions[func_name]
435 if func_name in self._classes_by_name:
436 return self._classes_by_name[func_name].make_object()
437 if func_name not in avm_class.methods:
438 raise ExtractorError('Cannot find function %s.%s' % (
439 avm_class.name, func_name))
440 m = avm_class.methods[func_name]
444 coder = io.BytesIO(m.code)
445 s24 = lambda: _s24(coder)
446 u30 = lambda: _u30(coder)
448 registers = [avm_class.variables] + list(args) + [None] * m.local_count
450 scopes = collections.deque([
451 self._classes_by_name, avm_class.constants, avm_class.variables])
453 opcode = _read_byte(coder)
454 if opcode == 9: # label
455 pass # Spec says: "Do nothing."
456 elif opcode == 16: # jump
458 coder.seek(coder.tell() + offset)
459 elif opcode == 17: # iftrue
463 coder.seek(coder.tell() + offset)
464 elif opcode == 18: # iffalse
468 coder.seek(coder.tell() + offset)
469 elif opcode == 19: # ifeq
474 coder.seek(coder.tell() + offset)
475 elif opcode == 20: # ifne
480 coder.seek(coder.tell() + offset)
481 elif opcode == 21: # iflt
486 coder.seek(coder.tell() + offset)
487 elif opcode == 32: # pushnull
489 elif opcode == 33: # pushundefined
490 stack.append(undefined)
491 elif opcode == 36: # pushbyte
492 v = _read_byte(coder)
494 elif opcode == 37: # pushshort
497 elif opcode == 38: # pushtrue
499 elif opcode == 39: # pushfalse
501 elif opcode == 40: # pushnan
502 stack.append(float('NaN'))
503 elif opcode == 42: # dup
506 elif opcode == 44: # pushstring
508 stack.append(self.constant_strings[idx])
509 elif opcode == 48: # pushscope
510 new_scope = stack.pop()
511 scopes.append(new_scope)
512 elif opcode == 66: # construct
514 args = list(reversed(
515 [stack.pop() for _ in range(arg_count)]))
517 res = obj.avm_class.make_object()
519 elif opcode == 70: # callproperty
521 mname = self.multinames[index]
523 args = list(reversed(
524 [stack.pop() for _ in range(arg_count)]))
527 if obj == StringClass:
528 if mname == 'String':
529 assert len(args) == 1
530 assert isinstance(args[0], (
531 int, compat_str, _Undefined))
532 if args[0] == undefined:
535 res = compat_str(args[0])
539 raise NotImplementedError(
540 'Function String.%s is not yet implemented'
542 elif isinstance(obj, _AVMClass_Object):
543 func = self.extract_function(obj.avm_class, mname)
547 elif isinstance(obj, _AVMClass):
548 func = self.extract_function(obj, mname)
552 elif isinstance(obj, _ScopeDict):
553 if mname in obj.avm_class.method_names:
554 func = self.extract_function(obj.avm_class, mname)
560 elif isinstance(obj, compat_str):
562 assert len(args) == 1
563 assert isinstance(args[0], compat_str)
567 res = obj.split(args[0])
570 elif mname == 'charCodeAt':
571 assert len(args) <= 1
572 idx = 0 if len(args) == 0 else args[0]
573 assert isinstance(idx, int)
577 elif isinstance(obj, list):
579 assert len(args) == 1
580 assert isinstance(args[0], int)
584 elif mname == 'join':
585 assert len(args) == 1
586 assert isinstance(args[0], compat_str)
587 res = args[0].join(obj)
590 raise NotImplementedError(
591 'Unsupported property %r on %r'
593 elif opcode == 71: # returnvoid
596 elif opcode == 72: # returnvalue
599 elif opcode == 73: # constructsuper
600 # Not yet implemented, just hope it works without it
602 args = list(reversed(
603 [stack.pop() for _ in range(arg_count)]))
605 elif opcode == 74: # constructproperty
608 args = list(reversed(
609 [stack.pop() for _ in range(arg_count)]))
612 mname = self.multinames[index]
613 assert isinstance(obj, _AVMClass)
615 # We do not actually call the constructor for now;
616 # we just pretend it does nothing
617 stack.append(obj.make_object())
618 elif opcode == 79: # callpropvoid
620 mname = self.multinames[index]
622 args = list(reversed(
623 [stack.pop() for _ in range(arg_count)]))
625 if isinstance(obj, _AVMClass_Object):
626 func = self.extract_function(obj.avm_class, mname)
628 assert res is undefined
630 if isinstance(obj, _ScopeDict):
631 assert mname in obj.avm_class.method_names
632 func = self.extract_function(obj.avm_class, mname)
634 assert res is undefined
636 if mname == 'reverse':
637 assert isinstance(obj, list)
640 raise NotImplementedError(
641 'Unsupported (void) property %r on %r'
643 elif opcode == 86: # newarray
646 for i in range(arg_count):
647 arr.append(stack.pop())
650 elif opcode == 93: # findpropstrict
652 mname = self.multinames[index]
653 for s in reversed(scopes):
659 if mname not in res and mname in _builtin_classes:
660 stack.append(_builtin_classes[mname])
662 stack.append(res[mname])
663 elif opcode == 94: # findproperty
665 mname = self.multinames[index]
666 for s in reversed(scopes):
671 res = avm_class.variables
673 elif opcode == 96: # getlex
675 mname = self.multinames[index]
676 for s in reversed(scopes):
681 scope = avm_class.variables
685 elif mname in _builtin_classes:
686 res = _builtin_classes[mname]
691 elif opcode == 97: # setproperty
694 idx = self.multinames[index]
695 if isinstance(idx, _Multiname):
699 elif opcode == 98: # getlocal
701 stack.append(registers[index])
702 elif opcode == 99: # setlocal
705 registers[index] = value
706 elif opcode == 102: # getproperty
708 pname = self.multinames[index]
709 if pname == 'length':
711 assert isinstance(obj, (compat_str, list))
712 stack.append(len(obj))
713 elif isinstance(pname, compat_str): # Member access
715 if isinstance(obj, _AVMClass):
716 res = obj.static_properties[pname]
720 assert isinstance(obj, (dict, _ScopeDict)),\
721 'Accessing member %r on %r' % (pname, obj)
722 res = obj.get(pname, undefined)
724 else: # Assume attribute access
726 assert isinstance(idx, int)
728 assert isinstance(obj, list)
729 stack.append(obj[idx])
730 elif opcode == 104: # initproperty
733 idx = self.multinames[index]
734 if isinstance(idx, _Multiname):
738 elif opcode == 115: # convert_
740 intvalue = int(value)
741 stack.append(intvalue)
742 elif opcode == 128: # coerce
744 elif opcode == 130: # coerce_a
746 # um, yes, it's any value
748 elif opcode == 133: # coerce_s
749 assert isinstance(stack[-1], (type(None), compat_str))
750 elif opcode == 147: # decrement
752 assert isinstance(value, int)
753 stack.append(value - 1)
754 elif opcode == 149: # typeof
757 _Undefined: 'undefined',
758 compat_str: 'String',
762 elif opcode == 160: # add
765 res = value1 + value2
767 elif opcode == 161: # subtract
770 res = value1 - value2
772 elif opcode == 162: # multiply
775 res = value1 * value2
777 elif opcode == 164: # modulo
780 res = value1 % value2
782 elif opcode == 168: # bitand
785 assert isinstance(value1, int)
786 assert isinstance(value2, int)
787 res = value1 & value2
789 elif opcode == 171: # equals
792 result = value1 == value2
794 elif opcode == 175: # greaterequals
797 result = value1 >= value2
799 elif opcode == 192: # increment_i
801 assert isinstance(value, int)
802 stack.append(value + 1)
803 elif opcode == 208: # getlocal_0
804 stack.append(registers[0])
805 elif opcode == 209: # getlocal_1
806 stack.append(registers[1])
807 elif opcode == 210: # getlocal_2
808 stack.append(registers[2])
809 elif opcode == 211: # getlocal_3
810 stack.append(registers[3])
811 elif opcode == 212: # setlocal_0
812 registers[0] = stack.pop()
813 elif opcode == 213: # setlocal_1
814 registers[1] = stack.pop()
815 elif opcode == 214: # setlocal_2
816 registers[2] = stack.pop()
817 elif opcode == 215: # setlocal_3
818 registers[3] = stack.pop()
820 raise NotImplementedError(
821 'Unsupported opcode %d' % opcode)
823 avm_class.method_pyfunctions[func_name] = resfunc