]>
jfr.im git - yt-dlp.git/blob - youtube_dl/swfinterp.py
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
):
66 self
.name_idx
= name_idx
68 self
.method_names
= {}
71 self
.method_pyfunctions
= {}
73 self
.variables
= _ScopeDict(self
)
75 def make_object(self
):
76 return _AVMClass_Object(self
)
79 return '_AVMClass(%s)' % (self
.name
)
81 def register_methods(self
, methods
):
82 self
.method_names
.update(methods
.items())
83 self
.method_idxs
.update(dict(
85 for name
, idx
in methods
.items()))
88 class _Multiname(object):
89 def __init__(self
, kind
):
93 return '[MULTINAME kind: 0x%x]' % self
.kind
96 def _read_int(reader
):
102 b
= struct_unpack('<B', buf
)[0]
103 res
= res |
((b
& 0x7f) << shift
)
111 res
= _read_int(reader
)
112 assert res
& 0xf0000000 == 0
118 v
= _read_int(reader
)
119 if v
& 0x80000000 != 0:
120 v
= - ((v ^
0xffffffff) + 1)
127 last_byte
= b
'\xff' if (ord(bs
[2:3]) >= 0x80) else b
'\x00'
128 return struct_unpack('<i', bs
+ last_byte
)[0]
131 def _read_string(reader
):
133 resb
= reader
.read(slen
)
134 assert len(resb
) == slen
135 return resb
.decode('utf-8')
138 def _read_bytes(count
, reader
):
140 resb
= reader
.read(count
)
141 assert len(resb
) == count
145 def _read_byte(reader
):
146 resb
= _read_bytes(1, reader
=reader
)
147 res
= struct_unpack('<B', resb
)[0]
151 StringClass
= _AVMClass('(no name idx)', 'String')
154 class SWFInterpreter(object):
155 def __init__(self
, file_contents
):
156 self
._patched
_functions
= {}
158 for tag_code
, tag
in _extract_tags(file_contents
)
160 p
= code_tag
.index(b
'\0', 4) + 1
161 code_reader
= io
.BytesIO(code_tag
[p
:])
163 # Parse ABC (AVM2 ByteCode)
165 # Define a couple convenience methods
166 u30
= lambda *args
: _u30(*args
, reader
=code_reader
)
167 s32
= lambda *args
: _s32(*args
, reader
=code_reader
)
168 u32
= lambda *args
: _u32(*args
, reader
=code_reader
)
169 read_bytes
= lambda *args
: _read_bytes(*args
, reader
=code_reader
)
170 read_byte
= lambda *args
: _read_byte(*args
, reader
=code_reader
)
172 # minor_version + major_version
177 for _c
in range(1, int_count
):
180 for _c
in range(1, uint_count
):
183 read_bytes(max(0, (double_count
- 1)) * 8)
185 self
.constant_strings
= ['']
186 for _c
in range(1, string_count
):
187 s
= _read_string(code_reader
)
188 self
.constant_strings
.append(s
)
189 namespace_count
= u30()
190 for _c
in range(1, namespace_count
):
194 for _c
in range(1, ns_set_count
):
196 for _c2
in range(count
):
198 multiname_count
= u30()
207 0x0e: 2, # MultinameA
208 0x1b: 1, # MultinameL
209 0x1c: 1, # MultinameLA
211 self
.multinames
= ['']
212 for _c
in range(1, multiname_count
):
214 assert kind
in MULTINAME_SIZES
, 'Invalid multiname kind %r' % kind
216 u30() # namespace_idx
218 self
.multinames
.append(self
.constant_strings
[name_idx
])
222 self
.multinames
.append(self
.constant_strings
[name_idx
])
224 self
.multinames
.append(_Multiname(kind
))
225 for _c2
in range(MULTINAME_SIZES
[kind
]):
230 MethodInfo
= collections
.namedtuple(
232 ['NEED_ARGUMENTS', 'NEED_REST'])
234 for method_id
in range(method_count
):
237 for _
in range(param_count
):
239 u30() # name index (always 0 for youtube)
241 if flags
& 0x08 != 0:
244 for c
in range(option_count
):
247 if flags
& 0x80 != 0:
248 # Param names present
249 for _
in range(param_count
):
251 mi
= MethodInfo(flags
& 0x01 != 0, flags
& 0x04 != 0)
252 method_infos
.append(mi
)
255 metadata_count
= u30()
256 for _c
in range(metadata_count
):
259 for _c2
in range(item_count
):
263 def parse_traits_info():
264 trait_name_idx
= u30()
265 kind_full
= read_byte()
266 kind
= kind_full
& 0x0f
267 attrs
= kind_full
>> 4
269 if kind
in [0x00, 0x06]: # Slot or Const
271 u30() # type_name_idx
275 elif kind
in [0x01, 0x02, 0x03]: # Method / Getter / Setter
278 methods
[self
.multinames
[trait_name_idx
]] = method_idx
279 elif kind
== 0x04: # Class
282 elif kind
== 0x05: # Function
285 methods
[function_idx
] = self
.multinames
[trait_name_idx
]
287 raise ExtractorError('Unsupported trait kind %d' % kind
)
289 if attrs
& 0x4 != 0: # Metadata present
290 metadata_count
= u30()
291 for _c3
in range(metadata_count
):
292 u30() # metadata index
299 for class_id
in range(class_count
):
302 cname
= self
.multinames
[name_idx
]
303 avm_class
= _AVMClass(name_idx
, cname
)
304 classes
.append(avm_class
)
306 u30() # super_name idx
308 if flags
& 0x08 != 0: # Protected namespace is present
309 u30() # protected_ns_idx
311 for _c2
in range(intrf_count
):
315 for _c2
in range(trait_count
):
316 trait_methods
= parse_traits_info()
317 avm_class
.register_methods(trait_methods
)
319 assert len(classes
) == class_count
320 self
._classes
_by
_name
= dict((c
.name
, c
) for c
in classes
)
322 for avm_class
in classes
:
325 for _c2
in range(trait_count
):
326 trait_methods
= parse_traits_info()
327 avm_class
.register_methods(trait_methods
)
331 for _c
in range(script_count
):
334 for _c2
in range(trait_count
):
338 method_body_count
= u30()
339 Method
= collections
.namedtuple('Method', ['code', 'local_count'])
340 for _c
in range(method_body_count
):
344 u30() # init_scope_depth
345 u30() # max_scope_depth
347 code
= read_bytes(code_length
)
348 for avm_class
in classes
:
349 if method_idx
in avm_class
.method_idxs
:
350 m
= Method(code
, local_count
)
351 avm_class
.methods
[avm_class
.method_idxs
[method_idx
]] = m
352 exception_count
= u30()
353 for _c2
in range(exception_count
):
360 for _c2
in range(trait_count
):
363 assert p
+ code_reader
.tell() == len(code_tag
)
365 def patch_function(self
, avm_class
, func_name
, f
):
366 self
._patched
_functions
[(avm_class
, func_name
)] = f
368 def extract_class(self
, class_name
):
370 return self
._classes
_by
_name
[class_name
]
372 raise ExtractorError('Class %r not found' % class_name
)
374 def extract_function(self
, avm_class
, func_name
):
375 p
= self
._patched
_functions
.get((avm_class
, func_name
))
378 if func_name
in avm_class
.method_pyfunctions
:
379 return avm_class
.method_pyfunctions
[func_name
]
380 if func_name
in self
._classes
_by
_name
:
381 return self
._classes
_by
_name
[func_name
].make_object()
382 if func_name
not in avm_class
.methods
:
383 raise ExtractorError('Cannot find function %s.%s' % (
384 avm_class
.name
, func_name
))
385 m
= avm_class
.methods
[func_name
]
389 coder
= io
.BytesIO(m
.code
)
390 s24
= lambda: _s24(coder
)
391 u30
= lambda: _u30(coder
)
393 registers
= [avm_class
.variables
] + list(args
) + [None] * m
.local_count
395 scopes
= collections
.deque([
396 self
._classes
_by
_name
, avm_class
.variables
])
398 opcode
= _read_byte(coder
)
399 if opcode
== 16: # jump
401 coder
.seek(coder
.tell() + offset
)
402 elif opcode
== 17: # iftrue
406 coder
.seek(coder
.tell() + offset
)
407 elif opcode
== 18: # iffalse
411 coder
.seek(coder
.tell() + offset
)
412 elif opcode
== 19: # ifeq
417 coder
.seek(coder
.tell() + offset
)
418 elif opcode
== 20: # ifne
423 coder
.seek(coder
.tell() + offset
)
424 elif opcode
== 32: # pushnull
426 elif opcode
== 36: # pushbyte
427 v
= _read_byte(coder
)
429 elif opcode
== 38: # pushtrue
431 elif opcode
== 39: # pushfalse
433 elif opcode
== 42: # dup
436 elif opcode
== 44: # pushstring
438 stack
.append(self
.constant_strings
[idx
])
439 elif opcode
== 48: # pushscope
440 new_scope
= stack
.pop()
441 scopes
.append(new_scope
)
442 elif opcode
== 66: # construct
444 args
= list(reversed(
445 [stack
.pop() for _
in range(arg_count
)]))
447 res
= obj
.avm_class
.make_object()
449 elif opcode
== 70: # callproperty
451 mname
= self
.multinames
[index
]
453 args
= list(reversed(
454 [stack
.pop() for _
in range(arg_count
)]))
457 if isinstance(obj
, _AVMClass_Object
):
458 func
= self
.extract_function(obj
.avm_class
, mname
)
462 elif isinstance(obj
, _ScopeDict
):
463 if mname
in obj
.avm_class
.method_names
:
464 func
= self
.extract_function(obj
.avm_class
, mname
)
470 elif isinstance(obj
, compat_str
):
472 assert len(args
) == 1
473 assert isinstance(args
[0], compat_str
)
477 res
= obj
.split(args
[0])
480 elif isinstance(obj
, list):
482 assert len(args
) == 1
483 assert isinstance(args
[0], int)
487 elif mname
== 'join':
488 assert len(args
) == 1
489 assert isinstance(args
[0], compat_str
)
490 res
= args
[0].join(obj
)
493 elif obj
== StringClass
:
494 if mname
== 'String':
495 assert len(args
) == 1
496 assert isinstance(args
[0], (int, compat_str
))
497 res
= compat_str(args
[0])
501 raise NotImplementedError(
502 'Function String.%s is not yet implemented'
504 raise NotImplementedError(
505 'Unsupported property %r on %r'
507 elif opcode
== 72: # returnvalue
510 elif opcode
== 74: # constructproperty
513 args
= list(reversed(
514 [stack
.pop() for _
in range(arg_count
)]))
517 mname
= self
.multinames
[index
]
518 assert isinstance(obj
, _AVMClass
)
520 # We do not actually call the constructor for now;
521 # we just pretend it does nothing
522 stack
.append(obj
.make_object())
523 elif opcode
== 79: # callpropvoid
525 mname
= self
.multinames
[index
]
527 args
= list(reversed(
528 [stack
.pop() for _
in range(arg_count
)]))
530 if mname
== 'reverse':
531 assert isinstance(obj
, list)
534 raise NotImplementedError(
535 'Unsupported (void) property %r on %r'
537 elif opcode
== 86: # newarray
540 for i
in range(arg_count
):
541 arr
.append(stack
.pop())
544 elif opcode
== 93: # findpropstrict
546 mname
= self
.multinames
[index
]
547 for s
in reversed(scopes
):
553 if mname
not in res
and mname
== 'String':
554 stack
.append(StringClass
)
556 stack
.append(res
[mname
])
557 elif opcode
== 94: # findproperty
559 mname
= self
.multinames
[index
]
560 for s
in reversed(scopes
):
565 res
= avm_class
.variables
567 elif opcode
== 96: # getlex
569 mname
= self
.multinames
[index
]
570 for s
in reversed(scopes
):
575 scope
= avm_class
.variables
576 # I cannot find where static variables are initialized
577 # so let's just return None
578 res
= scope
.get(mname
)
580 elif opcode
== 97: # setproperty
583 idx
= self
.multinames
[index
]
584 if isinstance(idx
, _Multiname
):
588 elif opcode
== 98: # getlocal
590 stack
.append(registers
[index
])
591 elif opcode
== 99: # setlocal
594 registers
[index
] = value
595 elif opcode
== 102: # getproperty
597 pname
= self
.multinames
[index
]
598 if pname
== 'length':
600 assert isinstance(obj
, (compat_str
, list))
601 stack
.append(len(obj
))
602 elif isinstance(pname
, compat_str
): # Member access
604 assert isinstance(obj
, (dict, _ScopeDict
)), \
605 'Accessing member %r on %r' % (pname
, obj
)
606 stack
.append(obj
[pname
])
607 else: # Assume attribute access
609 assert isinstance(idx
, int)
611 assert isinstance(obj
, list)
612 stack
.append(obj
[idx
])
613 elif opcode
== 115: # convert_
615 intvalue
= int(value
)
616 stack
.append(intvalue
)
617 elif opcode
== 128: # coerce
619 elif opcode
== 133: # coerce_s
620 assert isinstance(stack
[-1], (type(None), compat_str
))
621 elif opcode
== 160: # add
624 res
= value1
+ value2
626 elif opcode
== 161: # subtract
629 res
= value1
- value2
631 elif opcode
== 164: # modulo
634 res
= value1
% value2
636 elif opcode
== 171: # equals
639 result
= value1
== value2
641 elif opcode
== 175: # greaterequals
644 result
= value1
>= value2
646 elif opcode
== 208: # getlocal_0
647 stack
.append(registers
[0])
648 elif opcode
== 209: # getlocal_1
649 stack
.append(registers
[1])
650 elif opcode
== 210: # getlocal_2
651 stack
.append(registers
[2])
652 elif opcode
== 211: # getlocal_3
653 stack
.append(registers
[3])
654 elif opcode
== 212: # setlocal_0
655 registers
[0] = stack
.pop()
656 elif opcode
== 213: # setlocal_1
657 registers
[1] = stack
.pop()
658 elif opcode
== 214: # setlocal_2
659 registers
[2] = stack
.pop()
660 elif opcode
== 215: # setlocal_3
661 registers
[3] = stack
.pop()
663 raise NotImplementedError(
664 'Unsupported opcode %d' % opcode
)
666 avm_class
.method_pyfunctions
[func_name
] = resfunc