fix: 修复部分已知问题

hyb

2026-01-30 44480e71b27aa9d4cb8441f50c873f1b110e9691

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
Ë  
ž¬`iQ!ãód—dZd
g
Z
ddlmZmZmZmZmZmZm    Z    m
Z

edd«ZGd„d
e«Z d„Zy)    z"
Electronic Code Book (ECB) mode.
ÚEcbModeé)Úload_pycryptodome_raw_libÚVoidPointerÚcreate_string_bufferÚget_raw_bufferÚSmartPointerÚc_size_tÚc_uint8_ptrÚis_writeable_bufferzCrypto.Cipher._raw_ecbak
                    int ECB_start_operation(void *cipher,
                                            void **pResult);
                    int ECB_encrypt(void *ecbState,
                                    const uint8_t *in,
                                    uint8_t *out,
                                    size_t data_len);
                    int ECB_decrypt(void *ecbState,
                                    const uint8_t *in,
                                    uint8_t *out,
                                    size_t data_len);
                    int ECB_stop_operation(void *state);
                    có&—eZ
dZd
Zd„Zdd„
Zdd„
Zy)raó
*Electronic Code Book (ECB)*.
 
    This is the simplest encryption mode. Each of the plaintext blocks
    is directly encrypted into a ciphertext block, independently of
    any other block.
 
    This mode is dangerous because it exposes frequency of symbols
    in your plaintext. Other modes (e.g. *CBC*) should be used instead.
 
    See `NIST SP800-38A`_ , Section 6.1.
 
    .. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
 
    :undocumented: __init__
    cój
—|
j|_t«|_tj    |
j«|jj ««}|rtd
|z«
‚
t|jj«tj«|_|
j«
y)z¸Create a new block cipher, configured in ECB mode.
 
        :Parameters:
          block_cipher : C pointer
            A smart pointer to the low-level block cipher instance.
        z)Error %d while instantiating the ECB modeN)Ú
block_sizerÚ_stateÚraw_ecb_libÚECB_start_operationÚgetÚ
address_ofÚ
ValueErrorrÚECB_stop_operationÚrelease)ÚselfÚblock_cipherÚresults   õjH:\项目\archive\测试组\脚本\Change_password\venv_build\Lib\site-packages\Crypto/Cipher/_mode_ecb.pyÚ__init__zEcbMode.__init__Ds”€ð'×1Ñ1ˆŒä!“mˆŒÜ×0Ñ0°×1AÑ1AÓ1CØ15·±×1GÑ1GÓ1Ió
K
ˆáÜÐHØ%ñ
&ó
'ð
 'ô# 4§;¡;§?¡?Ó#4Ü#.×#AÑ#Aó
C
ˆŒð
    ×ÑÕóNc
óÀ
—|€t
t|
«
«
}nF|}t|«
std«
‚
t|
«
t|«
k7rt    dt|
«
z«
‚
t
j |jj«t|
«
t|«
tt|
«
«
«}|r|dk(rt    d«
‚
t    d|z«
‚
|€t|«
Sy
)abEncrypt data with the key set at initialization.
 
        The data to encrypt can be broken up in two or
        more pieces and `encrypt` can be called multiple times.
 
        That is, the statement:
 
            >>> c.encrypt(a) + c.encrypt(b)
 
        is equivalent to:
 
             >>> c.encrypt(a+b)
 
        This function does not add any padding to the plaintext.
 
        :Parameters:
          plaintext : bytes/bytearray/memoryview
            The piece of data to encrypt.
            The length must be multiple of the cipher block length.
        :Keywords:
          output : bytearray/memoryview
            The location where the ciphertext must be written to.
            If ``None``, the ciphertext is returned.
        :Return:
          If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
          Otherwise, ``None``.
        Nú4output must be a bytearray or a writeable memoryviewú9output must have the same length as the input  (%d bytes)éú2Data must be aligned to block boundary in ECB modez%Error %d while encrypting in ECB mode)rÚlenrÚ    TypeErrorrrÚECB_encryptrrr
r    r)rÚ    plaintextÚoutputÚ
ciphertextrs     rÚencryptzEcbMode.encrypt^sـð:ˆ>Ü-¬c°)«nÓ=‰JàˆJä& vÔ.ÜРVÓWÐWä9‹~¤ V£Ò,Ü ð
"0Ü25°i³.ñ
"A
ó
B
ð
B
ô×(Ñ(¨¯©¯©Ó):Ü)4°YÓ)?Ü)4°ZÓ)@Ü)1´#°i³.Ó)AóC
ˆñؘŠ{Ü Ð!UÓVÐVÜÐDÀvÑMÓNÐNàˆ>Ü! *Ó-Ð-àrc
óÀ
—|€t
t|
«
«
}nF|}t|«
std«
‚
t|
«
t|«
k7rt    dt|«
z«
‚
t
j |jj«t|
«
t|«
tt|
«
«
«}|r|dk(rt    d«
‚
t    d|z«
‚
|€t|«
Sy
)aeDecrypt data with the key set at initialization.
 
        The data to decrypt can be broken up in two or
        more pieces and `decrypt` can be called multiple times.
 
        That is, the statement:
 
            >>> c.decrypt(a) + c.decrypt(b)
 
        is equivalent to:
 
             >>> c.decrypt(a+b)
 
        This function does not remove any padding from the plaintext.
 
        :Parameters:
          ciphertext : bytes/bytearray/memoryview
            The piece of data to decrypt.
            The length must be multiple of the cipher block length.
        :Keywords:
          output : bytearray/memoryview
            The location where the plaintext must be written to.
            If ``None``, the plaintext is returned.
        :Return:
          If ``output`` is ``None``, the plaintext is returned as ``bytes``.
          Otherwise, ``None``.
        Nrrr r!z%Error %d while decrypting in ECB mode)rr"rr#rrÚECB_decryptrrr
r    r)rr'r&r%rs     rÚdecryptzEcbMode.decrypt•sـð:ˆ>Ü,¬S°«_Ó=‰IàˆIä& vÔ.ÜРVÓWÐWä:‹¤# f£+Ò-Ü ð
"0Ü25°i³.ñ
"A
ó
B
ð
B
ô×(Ñ(¨¯©¯©Ó):Ü)4°ZÓ)@Ü)4°YÓ)?Ü)1´#°j³/Ó)BóD
ˆñؘŠ{Ü Ð!UÓVÐVÜÐDÀvÑMÓNÐNàˆ>Ü! )Ó,Ð,àr)
N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rr(r+©rrrr3s„ñò ó45ôn
5rc
óŽ—|j
|
«
}|j|_
|
rtd
t|
«
z«
‚
t    |«
S)aM
Instantiate a cipher object that performs ECB encryption/decryption.
 
    :Parameters:
      factory : module
        The underlying block cipher, a module from ``Crypto.Cipher``.
 
    All keywords are passed to the underlying block cipher.
    See the relevant documentation for details (at least ``key`` will need
    to be presentzUnknown parameters for ECB: %s)Ú_create_base_cipherrr#Ústrr)ÚfactoryÚkwargsÚcipher_states   rÚ_create_ecb_cipherr7ÍsE€ð×.Ñ.¨vÓ6€LØ%×0Ñ0€LÔÙ ÜÐ8¼3¸v»;ÑFÓGÐGܐ<ӠРrN)r/Ú__all__ÚCrypto.Util._raw_apirrrrrr    r
rrÚobjectrr7r0rrú<module>r;
sKð


ñ.
ð ˆ-€÷
7÷
7ó
7ñ(Ð(@ðC
ó *€ô W
ˆfôW
ót
!r