Skip to content

Commit 61befa4

Browse files
KroisseKroisse
committed
Add optional data parameter for each hashlib ctors
1 parent e671528 commit 61befa4

File tree

1 file changed

+109
-45
lines changed

1 file changed

+109
-45
lines changed

‎vm/src/stdlib/hashlib.rs‎

Lines changed: 109 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -86,23 +86,27 @@ fn hashlib_new(
8686
data: OptionalArg<PyBytesRef>,
8787
vm: &VirtualMachine,
8888
) -> PyResult<PyHasher> {
89-
let hasher = match name.as_str() {
90-
"md5" => Ok(PyHasher::new("md5", HashWrapper::md5())),
91-
"sha1" => Ok(PyHasher::new("sha1", HashWrapper::sha1())),
92-
"sha224" => Ok(PyHasher::new("sha224", HashWrapper::sha224())),
93-
"sha256" => Ok(PyHasher::new("sha256", HashWrapper::sha256())),
94-
"sha384" => Ok(PyHasher::new("sha384", HashWrapper::sha384())),
95-
"sha512" => Ok(PyHasher::new("sha512", HashWrapper::sha512())),
96-
"sha3_224" => Ok(PyHasher::new("sha3_224", HashWrapper::sha3_224())),
97-
"sha3_256" => Ok(PyHasher::new("sha3_256", HashWrapper::sha3_256())),
98-
"sha3_384" => Ok(PyHasher::new("sha3_384", HashWrapper::sha3_384())),
99-
"sha3_512" => Ok(PyHasher::new("sha3_512", HashWrapper::sha3_512())),
100-
// TODO: "shake128" => Ok(PyHasher::new("shake128", HashWrapper::shake128())),
101-
// TODO: "shake256" => Ok(PyHasher::new("shake256", HashWrapper::shake256())),
102-
"blake2b" => Ok(PyHasher::new("blake2b", HashWrapper::blake2b())),
103-
"blake2s" => Ok(PyHasher::new("blake2s", HashWrapper::blake2s())),
89+
match name.as_str() {
90+
"md5" => md5(data, vm),
91+
"sha1" => sha1(data, vm),
92+
"sha224" => sha224(data, vm),
93+
"sha256" => sha256(data, vm),
94+
"sha384" => sha384(data, vm),
95+
"sha512" => sha512(data, vm),
96+
"sha3_224" => sha3_224(data, vm),
97+
"sha3_256" => sha3_256(data, vm),
98+
"sha3_384" => sha3_384(data, vm),
99+
"sha3_512" => sha3_512(data, vm),
100+
// TODO: "shake128" => shake128(data, vm),
101+
// TODO: "shake256" => shake256(data, vm),
102+
"blake2b" => blake2b(data, vm),
103+
"blake2s" => blake2s(data, vm),
104104
other => Err(vm.new_value_error(format!("Unknown hashing algorithm: {}", other))),
105-
}?;
105+
}
106+
}
107+
108+
fn md5(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
109+
let hasher = PyHasher::new("md5", HashWrapper::md5());
106110

107111
if let OptionalArg::Present(data) = data {
108112
hasher.update(data, vm)?;
@@ -111,64 +115,124 @@ fn hashlib_new(
111115
Ok(hasher)
112116
}
113117

114-
fn md5(_vm: &VirtualMachine) -> PyResult<PyHasher> {
115-
Ok(PyHasher::new("md5", HashWrapper::md5()))
116-
}
118+
fn sha1(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
119+
let hasher = PyHasher::new("sha1", HashWrapper::sha1());
117120

118-
fn sha1(_vm: &VirtualMachine) -> PyResult<PyHasher> {
119-
Ok(PyHasher::new("sha1", HashWrapper::sha1()))
121+
if let OptionalArg::Present(data) = data {
122+
hasher.update(data, vm)?;
123+
}
124+
125+
Ok(hasher)
120126
}
121127

122-
fn sha224(_vm: &VirtualMachine) -> PyResult<PyHasher> {
123-
Ok(PyHasher::new("sha224", HashWrapper::sha224()))
128+
fn sha224(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
129+
let hasher = PyHasher::new("sha224", HashWrapper::sha224());
130+
131+
if let OptionalArg::Present(data) = data {
132+
hasher.update(data, vm)?;
133+
}
134+
135+
Ok(hasher)
124136
}
125137

126-
fn sha256(_vm: &VirtualMachine) -> PyResult<PyHasher> {
127-
Ok(PyHasher::new("sha256", HashWrapper::sha256()))
138+
fn sha256(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
139+
let hasher = PyHasher::new("sha256", HashWrapper::sha256());
140+
141+
if let OptionalArg::Present(data) = data {
142+
hasher.update(data, vm)?;
143+
}
144+
145+
Ok(hasher)
128146
}
129147

130-
fn sha384(_vm: &VirtualMachine) -> PyResult<PyHasher> {
131-
Ok(PyHasher::new("sha384", HashWrapper::sha384()))
148+
fn sha384(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
149+
let hasher = PyHasher::new("sha384", HashWrapper::sha384());
150+
151+
if let OptionalArg::Present(data) = data {
152+
hasher.update(data, vm)?;
153+
}
154+
155+
Ok(hasher)
132156
}
133157

134-
fn sha512(_vm: &VirtualMachine) -> PyResult<PyHasher> {
135-
Ok(PyHasher::new("sha512", HashWrapper::sha512()))
158+
fn sha512(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
159+
let hasher = PyHasher::new("sha512", HashWrapper::sha512());
160+
161+
if let OptionalArg::Present(data) = data {
162+
hasher.update(data, vm)?;
163+
}
164+
165+
Ok(hasher)
136166
}
137167

138-
fn sha3_224(_vm: &VirtualMachine) -> PyResult<PyHasher> {
139-
Ok(PyHasher::new("sha3_224", HashWrapper::sha3_224()))
168+
fn sha3_224(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
169+
let hasher = PyHasher::new("sha3_224", HashWrapper::sha3_224());
170+
171+
if let OptionalArg::Present(data) = data {
172+
hasher.update(data, vm)?;
173+
}
174+
175+
Ok(hasher)
140176
}
141177

142-
fn sha3_256(_vm: &VirtualMachine) -> PyResult<PyHasher> {
143-
Ok(PyHasher::new("sha3_256", HashWrapper::sha3_256()))
178+
fn sha3_256(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
179+
let hasher = PyHasher::new("sha3_256", HashWrapper::sha3_256());
180+
181+
if let OptionalArg::Present(data) = data {
182+
hasher.update(data, vm)?;
183+
}
184+
185+
Ok(hasher)
144186
}
145187

146-
fn sha3_384(_vm: &VirtualMachine) -> PyResult<PyHasher> {
147-
Ok(PyHasher::new("sha3_384", HashWrapper::sha3_384()))
188+
fn sha3_384(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
189+
let hasher = PyHasher::new("sha3_384", HashWrapper::sha3_384());
190+
191+
if let OptionalArg::Present(data) = data {
192+
hasher.update(data, vm)?;
193+
}
194+
195+
Ok(hasher)
148196
}
149197

150-
fn sha3_512(_vm: &VirtualMachine) -> PyResult<PyHasher> {
151-
Ok(PyHasher::new("sha3_512", HashWrapper::sha3_512()))
198+
fn sha3_512(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
199+
let hasher = PyHasher::new("sha3_512", HashWrapper::sha3_512());
200+
201+
if let OptionalArg::Present(data) = data {
202+
hasher.update(data, vm)?;
203+
}
204+
205+
Ok(hasher)
152206
}
153207

154-
fn shake128(vm: &VirtualMachine) -> PyResult<PyHasher> {
208+
fn shake128(_data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
155209
Err(vm.new_not_implemented_error("shake256".to_string()))
156-
// Ok(PyHasher::new("shake128", HashWrapper::shake128()))
157210
}
158211

159-
fn shake256(vm: &VirtualMachine) -> PyResult<PyHasher> {
212+
fn shake256(_data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
160213
Err(vm.new_not_implemented_error("shake256".to_string()))
161-
// TODO: Ok(PyHasher::new("shake256", HashWrapper::shake256()))
162214
}
163215

164-
fn blake2b(_vm: &VirtualMachine) -> PyResult<PyHasher> {
216+
fn blake2b(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
165217
// TODO: handle parameters
166-
Ok(PyHasher::new("blake2b", HashWrapper::blake2b()))
218+
let hasher = PyHasher::new("blake2b", HashWrapper::blake2b());
219+
220+
if let OptionalArg::Present(data) = data {
221+
hasher.update(data, vm)?;
222+
}
223+
224+
Ok(hasher)
167225
}
168226

169-
fn blake2s(_vm: &VirtualMachine) -> PyResult<PyHasher> {
227+
fn blake2s(data: OptionalArg<PyBytesRef>, vm: &VirtualMachine) -> PyResult<PyHasher> {
170228
// TODO: handle parameters
171-
Ok(PyHasher::new("blake2s", HashWrapper::blake2s()))
229+
let hasher = PyHasher::new("blake2s", HashWrapper::blake2s());
230+
231+
if let OptionalArg::Present(data) = data {
232+
hasher.update(data, vm)?;
233+
}
234+
235+
Ok(hasher)
172236
}
173237

174238
pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {

0 commit comments

Comments
 (0)