PythonChallenge第8题

点击题目链接
技巧：
1.看页面提示
2.点击图片
3.看网站源码
误点图片，发现让我输入账号和密码，真是狗屎运，看网页好像有个加密的用户名和密码。
下面就是解密的问题。
如何解密？
看的博客告诉我是用bzip2解压，对应Python的bz2模块用于解密，现在好像明白打开这一题链接上面一个很像苍蝇顶在油菜花上，那是蜜蜂，bee，bee和bz2声音有点像。
查看bz2的帮助文档：

>>> import bz2
>>> help(bz2)
Help on module bz2:

NAME
    bz2

FILE
    c:\python27\dlls\bz2.pyd

DESCRIPTION
    The python bz2 module provides a comprehensive interface for
    the bz2 compression library. It implements a complete file
    interface, one shot (de)compression functions, and types for
    sequential (de)compression.

CLASSES
    __builtin__.object
        BZ2Compressor
        BZ2Decompressor
        BZ2File

    class BZ2Compressor(__builtin__.object)
     |  BZ2Compressor([compresslevel=9]) -> compressor object
     |  
     |  Create a new compressor object. This object may be used to compress
     |  data sequentially. If you want to compress data in one shot, use the
     |  compress() function instead. The compresslevel parameter, if given,
     |  must be a number between 1 and 9.
     |  
     |  Methods defined here:
     |  
     |  __delattr__(...)
     |      x.__delattr__('name') <==> del x.name
     |  
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |  
     |  __init__(...)
     |      x.__init__(...) initializes x; see help(type(x)) for signature
     |  
     |  __setattr__(...)
     |      x.__setattr__('name', value) <==> x.name = value
     |  
     |  compress(...)
     |      compress(data) -> string
     |      
     |      Provide more data to the compressor object. It will return chunks of
     |      compressed data whenever possible. When you've finished providing data
     |      to compress, call the flush() method to finish the compression process,
     |      and return what is left in the internal buffers.
     |  
     |  flush(...)
     |      flush() -> string
     |      
     |      Finish the compression process and return what is left in internal buffers.
     |      You must not use the compressor object after calling this method.
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  __new__ = <built-in method __new__ of type object>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T

    class BZ2Decompressor(__builtin__.object)
     |  BZ2Decompressor() -> decompressor object
     |  
     |  Create a new decompressor object. This object may be used to decompress
     |  data sequentially. If you want to decompress data in one shot, use the
     |  decompress() function instead.
     |  
     |  Methods defined here:
     |  
     |  __delattr__(...)
     |      x.__delattr__('name') <==> del x.name
     |  
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |  
     |  __init__(...)
     |      x.__init__(...) initializes x; see help(type(x)) for signature
     |  
     |  __setattr__(...)
     |      x.__setattr__('name', value) <==> x.name = value
     |  
     |  decompress(...)
     |      decompress(data) -> string
     |      
     |      Provide more data to the decompressor object. It will return chunks
     |      of decompressed data whenever possible. If you try to decompress data
     |      after the end of stream is found, EOFError will be raised. If any data
     |      was found after the end of stream, it'll be ignored and saved in
     |      unused_data attribute.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  unused_data
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  __new__ = <built-in method __new__ of type object>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T

    class BZ2File(__builtin__.object)
     |  BZ2File(name [, mode='r', buffering=0, compresslevel=9]) -> file object
     |  
     |  Open a bz2 file. The mode can be 'r' or 'w', for reading (default) or
     |  writing. When opened for writing, the file will be created if it doesn't
     |  exist, and truncated otherwise. If the buffering argument is given, 0 means
     |  unbuffered, and larger numbers specify the buffer size. If compresslevel
     |  is given, must be a number between 1 and 9.
     |  
     |  Add a 'U' to mode to open the file for input with universal newline
     |  support. Any line ending in the input file will be seen as a '\n' in
     |  Python. Also, a file so opened gains the attribute 'newlines'; the value
     |  for this attribute is one of None (no newline read yet), '\r', '\n',
     |  '\r\n' or a tuple containing all the newline types seen. Universal
     |  newlines are available only when reading.
     |  
     |  Methods defined here:
     |  
     |  __delattr__(...)
     |      x.__delattr__('name') <==> del x.name
     |  
     |  __enter__(...)
     |      __enter__() -> self.
     |  
     |  __exit__(...)
     |      __exit__(*excinfo) -> None.  Closes the file.
     |  
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |  
     |  __init__(...)
     |      x.__init__(...) initializes x; see help(type(x)) for signature
     |  
     |  __iter__(...)
     |      x.__iter__() <==> iter(x)
     |  
     |  __setattr__(...)
     |      x.__setattr__('name', value) <==> x.name = value
     |  
     |  close(...)
     |      close() -> None or (perhaps) an integer
     |      
     |      Close the file. Sets data attribute .closed to true. A closed file
     |      cannot be used for further I/O operations. close() may be called more
     |      than once without error.
     |  
     |  next(...)
     |      x.next() -> the next value, or raise StopIteration
     |  
     |  read(...)
     |      read([size]) -> string
     |      
     |      Read at most size uncompressed bytes, returned as a string. If the size
     |      argument is negative or omitted, read until EOF is reached.
     |  
     |  readline(...)
     |      readline([size]) -> string
     |      
     |      Return the next line from the file, as a string, retaining newline.
     |      A non-negative size argument will limit the maximum number of bytes to
     |      return (an incomplete line may be returned then). Return an empty
     |      string at EOF.
     |  
     |  readlines(...)
     |      readlines([size]) -> list
     |      
     |      Call readline() repeatedly and return a list of lines read.
     |      The optional size argument, if given, is an approximate bound on the
     |      total number of bytes in the lines returned.
     |  
     |  seek(...)
     |      seek(offset [, whence]) -> None
     |      
     |      Move to new file position. Argument offset is a byte count. Optional
     |      argument whence defaults to 0 (offset from start of file, offset
     |      should be >= 0); other values are 1 (move relative to current position,
     |      positive or negative), and 2 (move relative to end of file, usually
     |      negative, although many platforms allow seeking beyond the end of a file).
     |      
     |      Note that seeking of bz2 files is emulated, and depending on the parameters
     |      the operation may be extremely slow.
     |  
     |  tell(...)
     |      tell() -> int
     |      
     |      Return the current file position, an integer (may be a long integer).
     |  
     |  write(...)
     |      write(data) -> None
     |      
     |      Write the 'data' string to file. Note that due to buffering, close() may
     |      be needed before the file on disk reflects the data written.
     |  
     |  writelines(...)
     |      writelines(sequence_of_strings) -> None
     |      
     |      Write the sequence of strings to the file. Note that newlines are not
     |      added. The sequence can be any iterable object producing strings. This is
     |      equivalent to calling write() for each string.
     |  
     |  xreadlines(...)
     |      xreadlines() -> self
     |      
     |      For backward compatibility. BZ2File objects now include the performance
     |      optimizations previously implemented in the xreadlines module.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  closed
     |      True if the file is closed
     |  
     |  mode
     |      file mode ('r', 'w', or 'U')
     |  
     |  name
     |      file name
     |  
     |  newlines
     |      end-of-line convention used in this file
     |  
     |  softspace
     |      flag indicating that a space needs to be printed; used by print
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  __new__ = <built-in method __new__ of type object>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T

FUNCTIONS
    compress(...)
        compress(data [, compresslevel=9]) -> string

        Compress data in one shot. If you want to compress data sequentially,
        use an instance of BZ2Compressor instead. The compresslevel parameter, if
        given, must be a number between 1 and 9.

    decompress(...)
        decompress(data) -> decompressed data

        Decompress data in one shot. If you want to decompress data sequentially,
        use an instance of BZ2Decompressor instead.

DATA
    __author__ = 'The bz2 python module was written by:\n\n    Gustavo Nie...

AUTHOR
    The bz2 python module was written by:

        Gustavo Niemeyer <[email protected]>

三个类：BZ2Compressor，BZ2Decompressor，BZ2File
两个函数：compress，decompress

两个函数翻译下，压缩和解压缩。

import bz2
un='BZh91AY&SYA\xaf\x82\r\x00\x00\x01\x01\x80\x02\xc0\x02\x00 \x00!\x9ah3M\x07<]\xc9\x14\xe1BA\x06\xbe\x084'
pw= 'BZh91AY&SY\x94$|\x0e\x00\x00\x00\x81\x00\x03$ \x00!\x9ah3M\x13<]\xc9\x14\xe1BBP\x91\xf08'
print bz2.decompress(un)
print bz2.decompress(pw)

输出的结果：

>>> print bz2.decompress(un)
huge
>>> print bz2.decompress(pw)
file

用户名：huge
密码：file
点击蜜蜂位置输入用户名密码进入下一题