Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-06-25 08:26
📄 __init__.py # Copyright 2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Package marker file."""	623 B	2025-02-24 20:22
📄 apdu_test.py # Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for pyu2f.apdu.""" import range import unittest from pyu2f import apdu from pyu2f import errors class ApduTest(unittest.TestCase): def testSerializeCommandApdu(self): cmd = apdu.CommandApdu(0, 0x01, 0x03, 0x04, bytearray([0x10, 0x20, 0x30])) self.assertEqual( cmd.ToByteArray(), bytearray([0x00, 0x01, 0x03, 0x04, 0x00, 0x00, 0x03, 0x10, 0x20, 0x30, 0x00, 0x00])) self.assertEqual( cmd.ToLegacyU2FByteArray(), bytearray([0x00, 0x01, 0x03, 0x04, 0x00, 0x00, 0x03, 0x10, 0x20, 0x30, 0x00, 0x00])) def testSerializeCommandApduNoData(self): cmd = apdu.CommandApdu(0, 0x01, 0x03, 0x04) self.assertEqual(cmd.ToByteArray(), bytearray([0x00, 0x01, 0x03, 0x04, 0x00, 0x00, 0x00])) self.assertEqual(cmd.ToLegacyU2FByteArray(), bytearray([0x00, 0x01, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00])) def testSerializeCommandApduTooLong(self): self.assertRaises(errors.InvalidCommandError, apdu.CommandApdu, 0, 0x01, 0x03, 0x04, bytearray(0 for x in range(0, 65536))) def testResponseApduParse(self): resp = apdu.ResponseApdu(bytearray([0x05, 0x04, 0x90, 0x00])) self.assertEqual(resp.body, bytearray([0x05, 0x04])) self.assertEqual(resp.sw1, 0x90) self.assertEqual(resp.sw2, 0x00) self.assertTrue(resp.IsSuccess()) def testResponseApduParseNoBody(self): resp = apdu.ResponseApdu(bytearray([0x69, 0x85])) self.assertEqual(resp.sw1, 0x69) self.assertEqual(resp.sw2, 0x85) self.assertFalse(resp.IsSuccess()) def testResponseApduParseInvalid(self): self.assertRaises(errors.InvalidResponseError, apdu.ResponseApdu, bytearray([0x05])) def testResponseApduCheckSuccessTUPRequired(self): resp = apdu.ResponseApdu(bytearray([0x69, 0x85])) self.assertRaises(errors.TUPRequiredError, resp.CheckSuccessOrRaise) def testResponseApduCheckSuccessInvalidKeyHandle(self): resp = apdu.ResponseApdu(bytearray([0x6a, 0x80])) self.assertRaises(errors.InvalidKeyHandleError, resp.CheckSuccessOrRaise) def testResponseApduCheckSuccessOtherError(self): resp = apdu.ResponseApdu(bytearray([0xfa, 0x05])) self.assertRaises(errors.ApduError, resp.CheckSuccessOrRaise) if __name__ == '__main__': unittest.main()	2.92 KB	2025-02-24 20:22
📄 customauthenticator_test.py # Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for pyu2f.convenience.customauthenticator.""" import base64 import json import struct import sys import mock from pyu2f import errors from pyu2f import model from pyu2f.convenience import customauthenticator if sys.version_info[:2] < (2, 7): import unittest2 as unittest # pylint: disable=g-import-not-at-top else: import unittest # pylint: disable=g-import-not-at-top # Input/ouput values recorded from a successful signing flow SIGN_SUCCESS = { 'app_id': 'test_app_id', 'app_id_hash_encoded': 'TnMguTdPn7OcIO9f-0CgfQdY254bvc6WR-DTPZnJ49w', 'challenge': b'asdfasdf', 'challenge_hash_encoded': 'qhJtbTQvsU0BmLLpDWes-3zFGbegR2wp1mv5BJ2BwC0', 'key_handle_encoded': ('iBbl9-VYt-XSdWeHVNX-gfQcXGzlrAQ7BcngVNUxWijIQQlnZEI' '4Vb0Bp2ydBCbIQu_5rNlKqPH6NK1TtnM7fA'), 'origin': 'test_origin', 'signature_data_encoded': ('AQAAAI8wRQIhALlIPo6Hg8HwzELdYRIXnAnpsiHYCSXHex' 'CS34eiS2ixAiBt3TRmKE1A9WyMjc3JGrGI7gSPg-QzDSNL' 'aIj7JwcCTA'), 'client_data_encoded': ('eyJjaGFsbGVuZ2UiOiAiWVhOa1ptRnpaR1kiLCAib3JpZ2luI' 'jogInRlc3Rfb3JpZ2luIiwgInR5cCI6ICJuYXZpZ2F0b3IuaW' 'QuZ2V0QXNzZXJ0aW9uIn0'), 'u2f_version': 'U2F_V2', 'registered_key': model.RegisteredKey(base64.urlsafe_b64decode( 'iBbl9-VYt-XSdWeHVNX-gfQcXGzlrAQ7BcngVNUxWijIQQlnZEI4Vb0Bp2ydBCbIQu' '_5rNlKqPH6NK1TtnM7fA==' )) } @mock.patch.object(sys, 'stderr', new=mock.MagicMock()) class CustomAuthenticatorTest(unittest.TestCase): @mock.patch.object(customauthenticator.os.environ, 'get', return_value=None) def testEnvVarNotSet(self, os_get_method): authenticator = customauthenticator.CustomAuthenticator('testorigin') self.assertFalse(authenticator.IsAvailable(), 'Should return false when no env var is present') # Assert exception if Authenticate is called when no env var is set with self.assertRaises(errors.PluginError): authenticator.Authenticate('appid', {}) @mock.patch.object(customauthenticator.subprocess, 'Popen') @mock.patch.object(customauthenticator.os.environ, 'get', return_value='gnubbyagent') def testSuccessAuthenticate(self, os_get_method, popen_method): """Test plugin Authenticate success.""" valid_plugin_response = { 'type': 'sign_helper_reply', 'code': 0, 'errorDetail': '', 'responseData': { 'appIdHash': SIGN_SUCCESS['app_id_hash_encoded'], 'challengeHash': SIGN_SUCCESS['challenge_hash_encoded'], 'keyHandle': SIGN_SUCCESS['key_handle_encoded'], 'version': SIGN_SUCCESS['u2f_version'], 'signatureData': SIGN_SUCCESS['signature_data_encoded']}, 'data': None } valid_plugin_response_json = json.dumps(valid_plugin_response).encode() valid_plugin_response_len = struct.pack('<I', len(valid_plugin_response_json)) # process returns sign response in json mock_communicate_method = mock.MagicMock() mock_communicate_method.return_value = [valid_plugin_response_len + valid_plugin_response_json] # process returns with return code of 0 mock_wait_method = mock.MagicMock() mock_wait_method.return_value = 0 process_mock = mock.MagicMock() process_mock.communicate = mock_communicate_method process_mock.wait = mock_wait_method popen_method.return_value = process_mock # Call IsAvailable() authenticator = customauthenticator.CustomAuthenticator( SIGN_SUCCESS['origin']) self.assertTrue(authenticator.IsAvailable(), 'Should return true if env var is present') self.assertTrue(os_get_method.called) # Call Authenticate() challenge_data = [{'key': SIGN_SUCCESS['registered_key'], 'challenge': SIGN_SUCCESS['challenge']}] result = authenticator.Authenticate(SIGN_SUCCESS['app_id'], challenge_data) # Validate expected plugin request self.assertTrue(popen_method.called) self.assertTrue(mock_communicate_method.called) communicate_args = mock_communicate_method.call_args[0] self.assertEqual(len(communicate_args), 1, 'communicate() should have been called with two args') communicate_stdin = communicate_args[0] communicate_json_len_le = communicate_stdin[:4] communicate_json_len = struct.unpack('<I', communicate_json_len_le)[0] communicate_json = communicate_stdin[4:] self.assertEqual(len(communicate_json), communicate_json_len, 'communicate() should have been called with correct' 'length field') communicate_dict = json.loads(communicate_json.decode("utf8")) self.assertEqual(communicate_dict.get('type'), 'sign_helper_request') self.assertEqual(communicate_dict.get('timeoutSeconds'), 5) self.assertEqual(communicate_dict.get('localAlways'), True) challenges = communicate_dict.get('signData') # Validate Challenge portion of plugin request self.assertIsNotNone(challenges) self.assertEqual(len(challenges), 1) challenge = challenges[0] self.assertEqual(challenge.get('appIdHash'), SIGN_SUCCESS['app_id_hash_encoded']) self.assertEqual(challenge.get('challengeHash'), SIGN_SUCCESS['challenge_hash_encoded']) self.assertEqual(challenge.get('keyHandle'), SIGN_SUCCESS['key_handle_encoded']) self.assertEqual(challenge.get('version'), SIGN_SUCCESS['u2f_version']) mock_wait_method.assert_called_with() # Validate Authenticate() response self.assertEqual(result['applicationId'], SIGN_SUCCESS['app_id']) self.assertEqual(result['clientData'], SIGN_SUCCESS['client_data_encoded']) self.assertEqual(result['keyHandle'], SIGN_SUCCESS['key_handle_encoded']) self.assertEqual(result['signatureData'], SIGN_SUCCESS['signature_data_encoded']) @mock.patch.object(customauthenticator.subprocess, 'Popen') @mock.patch.object(customauthenticator.os.environ, 'get', return_value='gnubbyagent') def testPluginReturnsMalformedJson(self, os_get_method, popen_method): """Test when plugin returns non-json response.""" plugin_response = b'abc' plugin_response_len = struct.pack('<I', len(plugin_response)) # process returns sign response in json mock_communicate_method = mock.MagicMock() mock_communicate_method.return_value = [plugin_response_len + plugin_response] # process returns with return code of 0 mock_wait_method = mock.MagicMock() mock_wait_method.return_value = 0 process_mock = mock.MagicMock() process_mock.communicate = mock_communicate_method process_mock.wait = mock_wait_method popen_method.return_value = process_mock # Call Authenticate() challenge_data = [{'key': SIGN_SUCCESS['registered_key'], 'challenge': SIGN_SUCCESS['challenge']}] authenticator = customauthenticator.CustomAuthenticator( SIGN_SUCCESS['origin']) with self.assertRaises(errors.PluginError): authenticator.Authenticate(SIGN_SUCCESS['app_id'], challenge_data) @mock.patch.object(customauthenticator.subprocess, 'Popen') @mock.patch.object(customauthenticator.os.environ, 'get', return_value='gnubbyagent') def testPluginResponseMissingType(self, os_get_method, popen_method): """Test when plugin response is missing sign_helper_reply type.""" valid_plugin_response = { 'errorDetail': '', 'code': 0, 'responseData': { 'appIdHash': SIGN_SUCCESS['app_id_hash_encoded'], 'challengeHash': SIGN_SUCCESS['challenge_hash_encoded'], 'keyHandle': SIGN_SUCCESS['key_handle_encoded'], 'version': SIGN_SUCCESS['u2f_version'], 'signatureData': SIGN_SUCCESS['signature_data_encoded']}, 'data': None } plugin_response_json = json.dumps(valid_plugin_response).encode() plugin_response_len = struct.pack('<I', len(plugin_response_json)) # process returns sign response in json mock_communicate_method = mock.MagicMock() mock_communicate_method.return_value = [plugin_response_len + plugin_response_json] # process returns with return code of 0 mock_wait_method = mock.MagicMock() mock_wait_method.return_value = 0 process_mock = mock.MagicMock() process_mock.communicate = mock_communicate_method process_mock.wait = mock_wait_method popen_method.return_value = process_mock # Call Authenticate() challenge_data = [{'key': SIGN_SUCCESS['registered_key'], 'challenge': SIGN_SUCCESS['challenge']}] authenticator = customauthenticator.CustomAuthenticator( SIGN_SUCCESS['origin']) with self.assertRaises(errors.PluginError): authenticator.Authenticate(SIGN_SUCCESS['app_id'], challenge_data) @mock.patch.object(customauthenticator.subprocess, 'Popen') @mock.patch.object(customauthenticator.os.environ, 'get', return_value='gnubbyagent') def testPluginReturnsIncompleteResponse(self, os_get_method, popen_method): """Test when plugin response has missing fields.""" valid_plugin_response = { 'type': 'sign_helper_reply', 'errorDetail': '', 'responseData': { 'appIdHash': SIGN_SUCCESS['app_id_hash_encoded'], 'challengeHash': SIGN_SUCCESS['challenge_hash_encoded'], 'keyHandle': SIGN_SUCCESS['key_handle_encoded'], 'version': SIGN_SUCCESS['u2f_version'], 'signatureData': SIGN_SUCCESS['signature_data_encoded']}, 'data': None } plugin_response_json = json.dumps(valid_plugin_response).encode() plugin_response_len = struct.pack('<I', len(plugin_response_json)) # process returns sign response in json mock_communicate_method = mock.MagicMock() mock_communicate_method.return_value = [plugin_response_len + plugin_response_json] # process returns with return code of 0 mock_wait_method = mock.MagicMock() mock_wait_method.return_value = 0 process_mock = mock.MagicMock() process_mock.communicate = mock_communicate_method process_mock.wait = mock_wait_method popen_method.return_value = process_mock # Call Authenticate() challenge_data = [{'key': SIGN_SUCCESS['registered_key'], 'challenge': SIGN_SUCCESS['challenge']}] authenticator = customauthenticator.CustomAuthenticator( SIGN_SUCCESS['origin']) with self.assertRaises(errors.PluginError): authenticator.Authenticate(SIGN_SUCCESS['app_id'], challenge_data) @mock.patch.object(customauthenticator.subprocess, 'Popen') @mock.patch.object(customauthenticator.os.environ, 'get', return_value='gnubbyagent') def testPluginReturnsTouchRequired(self, os_get_method, popen_method): """Test when plugin with error 'touch required'.""" valid_plugin_response = { 'type': 'sign_helper_reply', 'errorDetail': '', 'code': customauthenticator.SK_SIGNING_PLUGIN_TOUCH_REQUIRED, 'responseData': { 'appIdHash': SIGN_SUCCESS['app_id_hash_encoded'], 'challengeHash': SIGN_SUCCESS['challenge_hash_encoded'], 'keyHandle': SIGN_SUCCESS['key_handle_encoded'], 'version': SIGN_SUCCESS['u2f_version'], 'signatureData': SIGN_SUCCESS['signature_data_encoded']}, 'data': None } plugin_response_json = json.dumps(valid_plugin_response).encode() plugin_response_len = struct.pack('<I', len(plugin_response_json)) # process returns sign response in json mock_communicate_method = mock.MagicMock() mock_communicate_method.return_value = [plugin_response_len + plugin_response_json] # process returns with return code of 0 mock_wait_method = mock.MagicMock() mock_wait_method.return_value = 0 process_mock = mock.MagicMock() process_mock.communicate = mock_communicate_method process_mock.wait = mock_wait_method popen_method.return_value = process_mock # Call Authenticate() challenge_data = [{'key': SIGN_SUCCESS['registered_key'], 'challenge': SIGN_SUCCESS['challenge']}] authenticator = customauthenticator.CustomAuthenticator( SIGN_SUCCESS['origin']) with self.assertRaises(errors.U2FError) as cm: authenticator.Authenticate(SIGN_SUCCESS['app_id'], challenge_data) self.assertEqual(cm.exception.code, errors.U2FError.TIMEOUT) @mock.patch.object(customauthenticator.subprocess, 'Popen') @mock.patch.object(customauthenticator.os.environ, 'get', return_value='gnubbyagent') def testPluginReturnsWrongData(self, os_get_method, popen_method): """Test when plugin with error 'wrong data'.""" valid_plugin_response = { 'type': 'sign_helper_reply', 'errorDetail': '', 'code': customauthenticator.SK_SIGNING_PLUGIN_WRONG_DATA, 'responseData': { 'appIdHash': SIGN_SUCCESS['app_id_hash_encoded'], 'challengeHash': SIGN_SUCCESS['challenge_hash_encoded'], 'keyHandle': SIGN_SUCCESS['key_handle_encoded'], 'version': SIGN_SUCCESS['u2f_version'], 'signatureData': SIGN_SUCCESS['signature_data_encoded']}, 'data': None } plugin_response_json = json.dumps(valid_plugin_response).encode() plugin_response_len = struct.pack('<I', len(plugin_response_json)) # process returns sign response in json mock_communicate_method = mock.MagicMock() mock_communicate_method.return_value = [plugin_response_len + plugin_response_json] # process returns with return code of 0 mock_wait_method = mock.MagicMock() mock_wait_method.return_value = 0 process_mock = mock.MagicMock() process_mock.communicate = mock_communicate_method process_mock.wait = mock_wait_method popen_method.return_value = process_mock # Call Authenticate() challenge_data = [{'key': SIGN_SUCCESS['registered_key'], 'challenge': SIGN_SUCCESS['challenge']}] authenticator = customauthenticator.CustomAuthenticator( SIGN_SUCCESS['origin']) with self.assertRaises(errors.U2FError) as cm: authenticator.Authenticate(SIGN_SUCCESS['app_id'], challenge_data) self.assertEqual(cm.exception.code, errors.U2FError.DEVICE_INELIGIBLE) if __name__ == '__main__': unittest.main()	15.16 KB	2025-02-24 20:22
📄 hardware_test.py # Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for pyu2f.hardware.""" import sys import mock from pyu2f import errors from pyu2f import hardware if sys.version_info[:2] < (2, 7): import unittest2 as unittest # pylint: disable=g-import-not-at-top else: import unittest # pylint: disable=g-import-not-at-top class HardwareTest(unittest.TestCase): def testSimpleCommands(self): mock_transport = mock.MagicMock() sk = hardware.SecurityKey(mock_transport) sk.CmdBlink(5) mock_transport.SendBlink.assert_called_once_with(5) sk.CmdWink() mock_transport.SendWink.assert_called_once_with() sk.CmdPing(bytearray(b'foo')) mock_transport.SendPing.assert_called_once_with(bytearray(b'foo')) def testRegisterInvalidParams(self): mock_transport = mock.MagicMock() sk = hardware.SecurityKey(mock_transport) self.assertRaises(errors.InvalidRequestError, sk.CmdRegister, '1234', '1234') def testRegisterSuccess(self): mock_transport = mock.MagicMock() sk = hardware.SecurityKey(mock_transport) challenge_param = b'01234567890123456789012345678901' app_param = b'01234567890123456789012345678901' mock_transport.SendMsgBytes.return_value = bytearray( [0x01, 0x02, 0x90, 0x00]) reply = sk.CmdRegister(challenge_param, app_param) self.assertEqual(reply, bytearray([0x01, 0x02])) self.assertEqual(mock_transport.SendMsgBytes.call_count, 1) (sent_msg,), _ = mock_transport.SendMsgBytes.call_args self.assertEqual(sent_msg[0:4], bytearray([0x00, 0x01, 0x03, 0x00])) self.assertEqual(sent_msg[7:-2], bytearray(challenge_param + app_param)) def testRegisterTUPRequired(self): mock_transport = mock.MagicMock() sk = hardware.SecurityKey(mock_transport) challenge_param = b'01234567890123456789012345678901' app_param = b'01234567890123456789012345678901' mock_transport.SendMsgBytes.return_value = bytearray([0x69, 0x85]) self.assertRaises(errors.TUPRequiredError, sk.CmdRegister, challenge_param, app_param) self.assertEqual(mock_transport.SendMsgBytes.call_count, 1) def testVersion(self): mock_transport = mock.MagicMock() sk = hardware.SecurityKey(mock_transport) mock_transport.SendMsgBytes.return_value = bytearray(b'U2F_V2\x90\x00') reply = sk.CmdVersion() self.assertEqual(reply, bytearray(b'U2F_V2')) self.assertEqual(mock_transport.SendMsgBytes.call_count, 1) (sent_msg,), _ = mock_transport.SendMsgBytes.call_args self.assertEqual(sent_msg, bytearray( [0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00])) def testVersionFallback(self): mock_transport = mock.MagicMock() sk = hardware.SecurityKey(mock_transport) mock_transport.SendMsgBytes.side_effect = [ bytearray([0x67, 0x00]), bytearray(b'U2F_V2\x90\x00')] reply = sk.CmdVersion() self.assertEqual(reply, bytearray(b'U2F_V2')) self.assertEqual(mock_transport.SendMsgBytes.call_count, 2) (sent_msg,), _ = mock_transport.SendMsgBytes.call_args_list[0] self.assertEqual(len(sent_msg), 7) self.assertEqual(sent_msg[0:4], bytearray([0x00, 0x03, 0x00, 0x00])) self.assertEqual(sent_msg[4:7], bytearray([0x00, 0x00, 0x00])) # Le (sent_msg,), _ = mock_transport.SendMsgBytes.call_args_list[1] self.assertEqual(len(sent_msg), 9) self.assertEqual(sent_msg[0:4], bytearray([0x00, 0x03, 0x00, 0x00])) self.assertEqual(sent_msg[4:7], bytearray([0x00, 0x00, 0x00])) # Lc self.assertEqual(sent_msg[7:9], bytearray([0x00, 0x00])) # Le def testVersionErrors(self): mock_transport = mock.MagicMock() sk = hardware.SecurityKey(mock_transport) mock_transport.SendMsgBytes.return_value = bytearray([0xfa, 0x05]) self.assertRaises(errors.ApduError, sk.CmdVersion) self.assertEqual(mock_transport.SendMsgBytes.call_count, 1) def testAuthenticateSuccess(self): mock_transport = mock.MagicMock() sk = hardware.SecurityKey(mock_transport) challenge_param = b'01234567890123456789012345678901' app_param = b'01234567890123456789012345678901' key_handle = b'\x01\x02\x03\x04' mock_transport.SendMsgBytes.return_value = bytearray( [0x01, 0x02, 0x90, 0x00]) reply = sk.CmdAuthenticate(challenge_param, app_param, key_handle) self.assertEqual(reply, bytearray([0x01, 0x02])) self.assertEqual(mock_transport.SendMsgBytes.call_count, 1) (sent_msg,), _ = mock_transport.SendMsgBytes.call_args self.assertEqual(sent_msg[0:4], bytearray([0x00, 0x02, 0x03, 0x00])) self.assertEqual( sent_msg[7:-2], bytearray(challenge_param + app_param + bytearray([4, 1, 2, 3, 4]))) def testAuthenticateCheckOnly(self): mock_transport = mock.MagicMock() sk = hardware.SecurityKey(mock_transport) challenge_param = b'01234567890123456789012345678901' app_param = b'01234567890123456789012345678901' key_handle = b'\x01\x02\x03\x04' mock_transport.SendMsgBytes.return_value = bytearray( [0x01, 0x02, 0x90, 0x00]) reply = sk.CmdAuthenticate(challenge_param, app_param, key_handle, check_only=True) self.assertEqual(reply, bytearray([0x01, 0x02])) self.assertEqual(mock_transport.SendMsgBytes.call_count, 1) (sent_msg,), _ = mock_transport.SendMsgBytes.call_args self.assertEqual(sent_msg[0:4], bytearray([0x00, 0x02, 0x07, 0x00])) self.assertEqual( sent_msg[7:-2], bytearray(challenge_param + app_param + bytearray([4, 1, 2, 3, 4]))) def testAuthenticateTUPRequired(self): mock_transport = mock.MagicMock() sk = hardware.SecurityKey(mock_transport) challenge_param = b'01234567890123456789012345678901' app_param = b'01234567890123456789012345678901' key_handle = b'\x01\x02\x03\x04' mock_transport.SendMsgBytes.return_value = bytearray([0x69, 0x85]) self.assertRaises(errors.TUPRequiredError, sk.CmdAuthenticate, challenge_param, app_param, key_handle) self.assertEqual(mock_transport.SendMsgBytes.call_count, 1) def testAuthenticateInvalidKeyHandle(self): mock_transport = mock.MagicMock() sk = hardware.SecurityKey(mock_transport) challenge_param = b'01234567890123456789012345678901' app_param = b'01234567890123456789012345678901' key_handle = b'\x01\x02\x03\x04' mock_transport.SendMsgBytes.return_value = bytearray([0x6a, 0x80]) self.assertRaises(errors.InvalidKeyHandleError, sk.CmdAuthenticate, challenge_param, app_param, key_handle) self.assertEqual(mock_transport.SendMsgBytes.call_count, 1) if __name__ == '__main__': unittest.main()	7.14 KB	2025-02-24 20:22
📁 hid	-	2025-02-24 20:22
📄 hidtransport_test.py # Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for pyu2f.hidtransport.""" import range import unittest from unittest import mock from pyu2f import errors from pyu2f import hidtransport from pyu2f.tests.lib import util def MakeKeyboard(path, usage): d = {} d['vendor_id'] = 1133 # Logitech d['product_id'] = 49948 d['path'] = path d['usage'] = usage d['usage_page'] = 1 return d def MakeU2F(path): d = {} d['vendor_id'] = 4176 d['product_id'] = 1031 d['path'] = path d['usage'] = 1 d['usage_page'] = 0xf1d0 return d def RPad(collection, to_size): while len(collection) < to_size: collection.append(0) return collection class DiscoveryTest(unittest.TestCase): def testHidUsageSelector(self): u2f_device = {'usage_page': 0xf1d0, 'usage': 0x01} other_device = {'usage_page': 0x06, 'usage': 0x01} self.assertTrue(hidtransport.HidUsageSelector(u2f_device)) self.assertFalse(hidtransport.HidUsageSelector(other_device)) def testDiscoverLocalDevices(self): def FakeHidDevice(path): mock_hid_dev = mock.MagicMock() mock_hid_dev.GetInReportDataLength.return_value = 64 mock_hid_dev.GetOutReportDataLength.return_value = 64 mock_hid_dev.path = path return mock_hid_dev with mock.patch.object(hidtransport, 'hid') as hid_mock: # We mock out init so that it doesn't try to do the whole init # handshake with the device, which isn't what we're trying to test # here. with mock.patch.object(hidtransport.UsbHidTransport, 'InternalInit') as _: hid_mock.Enumerate.return_value = [ MakeKeyboard('path1', 6), MakeKeyboard('path2', 2), MakeU2F('path3'), MakeU2F('path4') ] mock_hid_dev = mock.MagicMock() mock_hid_dev.GetInReportDataLength.return_value = 64 mock_hid_dev.GetOutReportDataLength.return_value = 64 hid_mock.Open.side_effect = FakeHidDevice # Force the iterator into a list devs = list(hidtransport.DiscoverLocalHIDU2FDevices()) self.assertEqual(hid_mock.Enumerate.call_count, 1) self.assertEqual(hid_mock.Open.call_count, 2) self.assertEqual(len(devs), 2) self.assertEqual(devs[0].hid_device.path, 'path3') self.assertEqual(devs[1].hid_device.path, 'path4') class TransportTest(unittest.TestCase): def testInit(self): fake_hid_dev = util.FakeHidDevice(bytearray([0x00, 0x00, 0x00, 0x01])) t = hidtransport.UsbHidTransport(fake_hid_dev) self.assertEqual(t.cid, bytearray([0x00, 0x00, 0x00, 0x01])) self.assertEqual(t.u2fhid_version, 0x01) def testPing(self): fake_hid_dev = util.FakeHidDevice(bytearray([0x00, 0x00, 0x00, 0x01])) t = hidtransport.UsbHidTransport(fake_hid_dev) reply = t.SendPing(b'1234') self.assertEqual(reply, b'1234') def testMsg(self): fake_hid_dev = util.FakeHidDevice( bytearray([0x00, 0x00, 0x00, 0x01]), bytearray([0x01, 0x90, 0x00])) t = hidtransport.UsbHidTransport(fake_hid_dev) reply = t.SendMsgBytes([0x00, 0x01, 0x00, 0x00]) self.assertEqual(reply, bytearray([0x01, 0x90, 0x00])) def testMsgBusy(self): fake_hid_dev = util.FakeHidDevice( bytearray([0x00, 0x00, 0x00, 0x01]), bytearray([0x01, 0x90, 0x00])) t = hidtransport.UsbHidTransport(fake_hid_dev) # Each call will retry twice: the first attempt will fail after 2 retreis, # the second will succeed on the second retry. fake_hid_dev.SetChannelBusyCount(3) with mock.patch.object(hidtransport, 'time') as _: self.assertRaisesRegex(errors.HidError, '^Device Busy', t.SendMsgBytes, [0x00, 0x01, 0x00, 0x00]) reply = t.SendMsgBytes([0x00, 0x01, 0x00, 0x00]) self.assertEqual(reply, bytearray([0x01, 0x90, 0x00])) def testFragmentedResponseMsg(self): body = bytearray([x % 256 for x in range(0, 1000)]) fake_hid_dev = util.FakeHidDevice(bytearray([0x00, 0x00, 0x00, 0x01]), body) t = hidtransport.UsbHidTransport(fake_hid_dev) reply = t.SendMsgBytes([0x00, 0x01, 0x00, 0x00]) # Confirm we properly reassemble the message self.assertEqual(reply, bytearray(x % 256 for x in range(0, 1000))) def testFragmentedSendApdu(self): body = bytearray(x % 256 for x in range(0, 1000)) fake_hid_dev = util.FakeHidDevice( bytearray([0x00, 0x00, 0x00, 0x01]), [0x90, 0x00]) t = hidtransport.UsbHidTransport(fake_hid_dev) reply = t.SendMsgBytes(body) self.assertEqual(reply, bytearray([0x90, 0x00])) # 1 init packet from creating transport, 18 packets to send # the fragmented message self.assertEqual(len(fake_hid_dev.received_packets), 18) def testInitPacketShape(self): packet = hidtransport.UsbHidTransport.InitPacket( 64, bytearray(b'\x00\x00\x00\x01'), 0x83, 2, bytearray(b'\x01\x02')) self.assertEqual(packet.ToWireFormat(), RPad( [0, 0, 0, 1, 0x83, 0, 2, 1, 2], 64)) copy = hidtransport.UsbHidTransport.InitPacket.FromWireFormat( 64, packet.ToWireFormat()) self.assertEqual(copy.cid, bytearray(b'\x00\x00\x00\x01')) self.assertEqual(copy.cmd, 0x83) self.assertEqual(copy.size, 2) self.assertEqual(copy.payload, bytearray(b'\x01\x02')) def testContPacketShape(self): packet = hidtransport.UsbHidTransport.ContPacket( 64, bytearray(b'\x00\x00\x00\x01'), 5, bytearray(b'\x01\x02')) self.assertEqual(packet.ToWireFormat(), RPad([0, 0, 0, 1, 5, 1, 2], 64)) copy = hidtransport.UsbHidTransport.ContPacket.FromWireFormat( 64, packet.ToWireFormat()) self.assertEqual(copy.cid, bytearray(b'\x00\x00\x00\x01')) self.assertEqual(copy.seq, 5) self.assertEqual(copy.payload, RPad(bytearray(b'\x01\x02'), 59)) if __name__ == '__main__': unittest.main()	6.21 KB	2025-02-24 20:22
📁 lib	-	2025-02-24 20:22
📄 localauthenticator_test.py # Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for pyu2f.convenience.localauthenticator.""" import base64 import sys import mock from pyu2f import errors from pyu2f import model from pyu2f.convenience import localauthenticator if sys.version_info[:2] < (2, 7): import unittest2 as unittest # pylint: disable=g-import-not-at-top else: import unittest # pylint: disable=g-import-not-at-top # Input/ouput values recorded from a successful signing flow SIGN_SUCCESS = { 'app_id': 'test_app_id', 'app_id_hash_encoded': 'TnMguTdPn7OcIO9f-0CgfQdY254bvc6WR-DTPZnJ49w=', 'challenge': b'asdfasdf', 'challenge_hash_encoded': 'qhJtbTQvsU0BmLLpDWes-3zFGbegR2wp1mv5BJ2BwC0=', 'key_handle_encoded': ('iBbl9-VYt-XSdWeHVNX-gfQcXGzlrAQ7BcngVNUxWijIQQlnZEI' '4Vb0Bp2ydBCbIQu_5rNlKqPH6NK1TtnM7fA=='), 'origin': 'test_origin', 'signature_data_encoded': ('AQAAAI8wRQIhALlIPo6Hg8HwzELdYRIXnAnpsiHYCSXHex' 'CS34eiS2ixAiBt3TRmKE1A9WyMjc3JGrGI7gSPg-QzDSNL' 'aIj7JwcCTA=='), 'client_data_encoded': ('eyJjaGFsbGVuZ2UiOiAiWVhOa1ptRnpaR1kiLCAib3JpZ2luI' 'jogInRlc3Rfb3JpZ2luIiwgInR5cCI6ICJuYXZpZ2F0b3IuaW' 'QuZ2V0QXNzZXJ0aW9uIn0='), 'u2f_version': 'U2F_V2' } SIGN_SUCCESS['registered_key'] = model.RegisteredKey( base64.urlsafe_b64decode(SIGN_SUCCESS['key_handle_encoded'])) SIGN_SUCCESS['client_data'] = model.ClientData( model.ClientData.TYP_AUTHENTICATION, SIGN_SUCCESS['challenge'], SIGN_SUCCESS['origin']) @mock.patch.object(sys, 'stderr', new=mock.MagicMock()) class LocalAuthenticatorTest(unittest.TestCase): @mock.patch.object(localauthenticator.u2f, 'GetLocalU2FInterface') def testSignSuccess(self, mock_get_u2f_method): """Test successful signing with a valid key.""" # Prepare u2f mocks mock_u2f = mock.MagicMock() mock_get_u2f_method.return_value = mock_u2f mock_authenticate = mock.MagicMock() mock_u2f.Authenticate = mock_authenticate mock_authenticate.return_value = model.SignResponse( base64.urlsafe_b64decode(SIGN_SUCCESS['key_handle_encoded']), base64.urlsafe_b64decode(SIGN_SUCCESS['signature_data_encoded']), SIGN_SUCCESS['client_data'] ) # Call LocalAuthenticator challenge_data = [{'key': SIGN_SUCCESS['registered_key'], 'challenge': SIGN_SUCCESS['challenge']}] authenticator = localauthenticator.LocalAuthenticator('testorigin') self.assertTrue(authenticator.IsAvailable()) response = authenticator.Authenticate(SIGN_SUCCESS['app_id'], challenge_data) # Validate that u2f authenticate was called with the correct values self.assertTrue(mock_authenticate.called) authenticate_args = mock_authenticate.call_args[0] self.assertEqual(len(authenticate_args), 3) self.assertEqual(authenticate_args[0], SIGN_SUCCESS['app_id']) self.assertEqual(authenticate_args[1], SIGN_SUCCESS['challenge']) registered_keys = authenticate_args[2] self.assertEqual(len(registered_keys), 1) self.assertEqual(registered_keys[0], SIGN_SUCCESS['registered_key']) # Validate authenticator response self.assertEqual(response.get('clientData'), SIGN_SUCCESS['client_data_encoded']) self.assertEqual(response.get('signatureData'), SIGN_SUCCESS['signature_data_encoded']) self.assertEqual(response.get('applicationId'), SIGN_SUCCESS['app_id']) self.assertEqual(response.get('keyHandle'), SIGN_SUCCESS['key_handle_encoded']) @mock.patch.object(localauthenticator.u2f, 'GetLocalU2FInterface') def testSignMultipleIneligible(self, mock_get_u2f_method): """Test signing with multiple keys registered, but none eligible.""" # Prepare u2f mocks mock_u2f = mock.MagicMock() mock_get_u2f_method.return_value = mock_u2f mock_authenticate = mock.MagicMock() mock_u2f.Authenticate = mock_authenticate mock_authenticate.side_effect = errors.U2FError( errors.U2FError.DEVICE_INELIGIBLE) # Call LocalAuthenticator challenge_item = {'key': SIGN_SUCCESS['registered_key'], 'challenge': SIGN_SUCCESS['challenge']} challenge_data = [challenge_item, challenge_item] authenticator = localauthenticator.LocalAuthenticator('testorigin') with self.assertRaises(errors.U2FError) as cm: authenticator.Authenticate(SIGN_SUCCESS['app_id'], challenge_data) self.assertEqual(cm.exception.code, errors.U2FError.DEVICE_INELIGIBLE) @mock.patch.object(localauthenticator.u2f, 'GetLocalU2FInterface') def testSignMultipleSuccess(self, mock_get_u2f_method): """Test signing with multiple keys registered and one is eligible.""" # Prepare u2f mocks mock_u2f = mock.MagicMock() mock_get_u2f_method.return_value = mock_u2f mock_authenticate = mock.MagicMock() mock_u2f.Authenticate = mock_authenticate return_value = model.SignResponse( base64.urlsafe_b64decode(SIGN_SUCCESS['key_handle_encoded']), base64.urlsafe_b64decode(SIGN_SUCCESS['signature_data_encoded']), SIGN_SUCCESS['client_data'] ) mock_authenticate.side_effect = [ errors.U2FError(errors.U2FError.DEVICE_INELIGIBLE), return_value ] # Call LocalAuthenticator challenge_item = {'key': SIGN_SUCCESS['registered_key'], 'challenge': SIGN_SUCCESS['challenge']} challenge_data = [challenge_item, challenge_item] authenticator = localauthenticator.LocalAuthenticator('testorigin') response = authenticator.Authenticate(SIGN_SUCCESS['app_id'], challenge_data) # Validate that u2f authenticate was called with the correct values self.assertTrue(mock_authenticate.called) authenticate_args = mock_authenticate.call_args[0] self.assertEqual(len(authenticate_args), 3) self.assertEqual(authenticate_args[0], SIGN_SUCCESS['app_id']) self.assertEqual(authenticate_args[1], SIGN_SUCCESS['challenge']) registered_keys = authenticate_args[2] self.assertEqual(len(registered_keys), 1) self.assertEqual(registered_keys[0], SIGN_SUCCESS['registered_key']) # Validate authenticator response self.assertEqual(response.get('clientData'), SIGN_SUCCESS['client_data_encoded']) self.assertEqual(response.get('signatureData'), SIGN_SUCCESS['signature_data_encoded']) self.assertEqual(response.get('applicationId'), SIGN_SUCCESS['app_id']) self.assertEqual(response.get('keyHandle'), SIGN_SUCCESS['key_handle_encoded']) if __name__ == '__main__': unittest.main()	7.26 KB	2025-02-24 20:22
📄 model_test.py # Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for pyu2f.model.""" import json import sys from pyu2f import errors from pyu2f import model if sys.version_info[:2] < (2, 7): import unittest2 as unittest # pylint: disable=g-import-not-at-top else: import unittest # pylint: disable=g-import-not-at-top class ModelTest(unittest.TestCase): def testClientDataRegistration(self): cd = model.ClientData(model.ClientData.TYP_REGISTRATION, b'ABCD', 'somemachine') obj = json.loads(cd.GetJson()) self.assertEqual(len(list(obj.keys())), 3) self.assertEqual(obj['typ'], model.ClientData.TYP_REGISTRATION) self.assertEqual(obj['challenge'], 'QUJDRA') self.assertEqual(obj['origin'], 'somemachine') def testClientDataAuth(self): cd = model.ClientData(model.ClientData.TYP_AUTHENTICATION, b'ABCD', 'somemachine') obj = json.loads(cd.GetJson()) self.assertEqual(len(list(obj.keys())), 3) self.assertEqual(obj['typ'], model.ClientData.TYP_AUTHENTICATION) self.assertEqual(obj['challenge'], 'QUJDRA') self.assertEqual(obj['origin'], 'somemachine') def testClientDataInvalid(self): self.assertRaises(errors.InvalidModelError, model.ClientData, 'foobar', b'ABCD', 'somemachine') if __name__ == '__main__': unittest.main()	1.87 KB	2025-02-24 20:22
📄 u2f_test.py # Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for pyu2f.u2f.""" import sys import mock from pyu2f import errors from pyu2f import model from pyu2f import u2f if sys.version_info[:2] < (2, 7): import unittest2 as unittest # pylint: disable=g-import-not-at-top else: import unittest # pylint: disable=g-import-not-at-top class U2fTest(unittest.TestCase): def testRegisterSuccessWithTUP(self): mock_sk = mock.MagicMock() mock_sk.CmdRegister.side_effect = [errors.TUPRequiredError, 'regdata'] mock_sk.CmdVersion.return_value = b'U2F_V2' u2f_api = u2f.U2FInterface(mock_sk) resp = u2f_api.Register('testapp', b'ABCD', []) self.assertEqual(mock_sk.CmdRegister.call_count, 2) self.assertEqual(mock_sk.CmdWink.call_count, 1) self.assertEqual(resp.client_data.raw_server_challenge, b'ABCD') self.assertEqual(resp.client_data.typ, 'navigator.id.finishEnrollment') self.assertEqual(resp.registration_data, 'regdata') def testRegisterSuccessWithPreviousKeys(self): mock_sk = mock.MagicMock() mock_sk.CmdAuthenticate.side_effect = errors.InvalidKeyHandleError mock_sk.CmdRegister.side_effect = [errors.TUPRequiredError, 'regdata'] mock_sk.CmdVersion.return_value = b'U2F_V2' u2f_api = u2f.U2FInterface(mock_sk) resp = u2f_api.Register('testapp', b'ABCD', [model.RegisteredKey('khA')]) self.assertEqual(mock_sk.CmdAuthenticate.call_count, 1) # Should be "Check only" self.assertTrue(mock_sk.CmdAuthenticate.call_args[0][3]) self.assertEqual(mock_sk.CmdRegister.call_count, 2) self.assertEqual(mock_sk.CmdWink.call_count, 1) self.assertEqual(resp.client_data.raw_server_challenge, b'ABCD') self.assertEqual(resp.client_data.typ, 'navigator.id.finishEnrollment') self.assertEqual(resp.registration_data, 'regdata') def testRegisterFailAlreadyRegistered(self): mock_sk = mock.MagicMock() mock_sk.CmdAuthenticate.side_effect = errors.TUPRequiredError mock_sk.CmdVersion.return_value = b'U2F_V2' u2f_api = u2f.U2FInterface(mock_sk) with self.assertRaises(errors.U2FError) as cm: u2f_api.Register('testapp', b'ABCD', [model.RegisteredKey('khA')]) self.assertEqual(cm.exception.code, errors.U2FError.DEVICE_INELIGIBLE) self.assertEqual(mock_sk.CmdAuthenticate.call_count, 1) # Should be "Check only" self.assertTrue(mock_sk.CmdAuthenticate.call_args[0][3]) self.assertEqual(mock_sk.CmdRegister.call_count, 0) self.assertEqual(mock_sk.CmdWink.call_count, 0) def testRegisterTimeout(self): mock_sk = mock.MagicMock() mock_sk.CmdRegister.side_effect = errors.TUPRequiredError mock_sk.CmdVersion.return_value = b'U2F_V2' u2f_api = u2f.U2FInterface(mock_sk) # Speed up the test by mocking out sleep to do nothing with mock.patch.object(u2f, 'time') as _: with self.assertRaises(errors.U2FError) as cm: u2f_api.Register('testapp', b'ABCD', []) self.assertEqual(cm.exception.code, errors.U2FError.TIMEOUT) self.assertEqual(mock_sk.CmdRegister.call_count, 30) self.assertEqual(mock_sk.CmdWink.call_count, 30) def testRegisterError(self): mock_sk = mock.MagicMock() mock_sk.CmdRegister.side_effect = errors.ApduError(0xff, 0xff) mock_sk.CmdVersion.return_value = b'U2F_V2' u2f_api = u2f.U2FInterface(mock_sk) with self.assertRaises(errors.U2FError) as cm: u2f_api.Register('testapp', b'ABCD', []) self.assertEqual(cm.exception.code, errors.U2FError.BAD_REQUEST) self.assertEqual(cm.exception.cause.sw1, 0xff) self.assertEqual(cm.exception.cause.sw2, 0xff) self.assertEqual(mock_sk.CmdRegister.call_count, 1) self.assertEqual(mock_sk.CmdWink.call_count, 0) def testAuthenticateSuccessWithTUP(self): mock_sk = mock.MagicMock() mock_sk.CmdAuthenticate.side_effect = [errors.TUPRequiredError, 'signature'] mock_sk.CmdVersion.return_value = b'U2F_V2' u2f_api = u2f.U2FInterface(mock_sk) resp = u2f_api.Authenticate('testapp', b'ABCD', [model.RegisteredKey('khA')]) self.assertEqual(mock_sk.CmdAuthenticate.call_count, 2) self.assertEqual(mock_sk.CmdWink.call_count, 1) self.assertEqual(resp.key_handle, 'khA') self.assertEqual(resp.client_data.raw_server_challenge, b'ABCD') self.assertEqual(resp.client_data.typ, 'navigator.id.getAssertion') self.assertEqual(resp.signature_data, 'signature') def testAuthenticateSuccessSkipInvalidKey(self): mock_sk = mock.MagicMock() mock_sk.CmdAuthenticate.side_effect = [errors.InvalidKeyHandleError, 'signature'] mock_sk.CmdVersion.return_value = b'U2F_V2' u2f_api = u2f.U2FInterface(mock_sk) resp = u2f_api.Authenticate( 'testapp', b'ABCD', [model.RegisteredKey('khA'), model.RegisteredKey('khB')]) self.assertEqual(mock_sk.CmdAuthenticate.call_count, 2) self.assertEqual(mock_sk.CmdWink.call_count, 0) self.assertEqual(resp.key_handle, 'khB') self.assertEqual(resp.client_data.raw_server_challenge, b'ABCD') self.assertEqual(resp.client_data.typ, 'navigator.id.getAssertion') self.assertEqual(resp.signature_data, 'signature') def testAuthenticateSuccessSkipInvalidVersion(self): mock_sk = mock.MagicMock() mock_sk.CmdAuthenticate.return_value = 'signature' mock_sk.CmdVersion.return_value = b'U2F_V2' u2f_api = u2f.U2FInterface(mock_sk) resp = u2f_api.Authenticate('testapp', b'ABCD', [model.RegisteredKey('khA', version='U2F_V3'), model.RegisteredKey('khB')]) self.assertEqual(mock_sk.CmdAuthenticate.call_count, 1) self.assertEqual(mock_sk.CmdWink.call_count, 0) self.assertEqual(resp.key_handle, 'khB') self.assertEqual(resp.client_data.raw_server_challenge, b'ABCD') self.assertEqual(resp.client_data.typ, 'navigator.id.getAssertion') self.assertEqual(resp.signature_data, 'signature') def testAuthenticateTimeout(self): mock_sk = mock.MagicMock() mock_sk.CmdAuthenticate.side_effect = errors.TUPRequiredError mock_sk.CmdVersion.return_value = b'U2F_V2' u2f_api = u2f.U2FInterface(mock_sk) # Speed up the test by mocking out sleep to do nothing with mock.patch.object(u2f, 'time') as _: with self.assertRaises(errors.U2FError) as cm: u2f_api.Authenticate('testapp', b'ABCD', [model.RegisteredKey('khA')]) self.assertEqual(cm.exception.code, errors.U2FError.TIMEOUT) self.assertEqual(mock_sk.CmdAuthenticate.call_count, 30) self.assertEqual(mock_sk.CmdWink.call_count, 30) def testAuthenticateAllKeysInvalid(self): mock_sk = mock.MagicMock() mock_sk.CmdAuthenticate.side_effect = errors.InvalidKeyHandleError mock_sk.CmdVersion.return_value = b'U2F_V2' u2f_api = u2f.U2FInterface(mock_sk) with self.assertRaises(errors.U2FError) as cm: u2f_api.Authenticate('testapp', b'ABCD', [model.RegisteredKey('khA'), model.RegisteredKey('khB')]) self.assertEqual(cm.exception.code, errors.U2FError.DEVICE_INELIGIBLE) u2f_api = u2f.U2FInterface(mock_sk) def testAuthenticateError(self): mock_sk = mock.MagicMock() mock_sk.CmdAuthenticate.side_effect = errors.ApduError(0xff, 0xff) mock_sk.CmdVersion.return_value = b'U2F_V2' u2f_api = u2f.U2FInterface(mock_sk) with self.assertRaises(errors.U2FError) as cm: u2f_api.Authenticate('testapp', b'ABCD', [model.RegisteredKey('khA')]) self.assertEqual(cm.exception.code, errors.U2FError.BAD_REQUEST) self.assertEqual(cm.exception.cause.sw1, 0xff) self.assertEqual(cm.exception.cause.sw2, 0xff) self.assertEqual(mock_sk.CmdAuthenticate.call_count, 1) self.assertEqual(mock_sk.CmdWink.call_count, 0) if __name__ == '__main__': unittest.main()	8.31 KB	2025-02-24 20:22
📄 util_test.py # Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for pyu2f.tests.lib.util.""" import range import unittest from pyu2f.tests.lib import util class UtilTest(unittest.TestCase): def testSimplePing(self): dev = util.FakeHidDevice(cid_to_allocate=None) dev.Write([0, 0, 0, 1, 0x81, 0, 3, 1, 2, 3]) self.assertEqual( dev.Read(), [0, 0, 0, 1, 0x81, 0, 3, 1, 2, 3] + [0 for _ in range(54)]) def testErrorBusy(self): dev = util.FakeHidDevice(cid_to_allocate=None) dev.SetChannelBusyCount(2) dev.Write([0, 0, 0, 1, 0x81, 0, 3, 1, 2, 3]) self.assertEqual( dev.Read(), [0, 0, 0, 1, 0xbf, 0, 1, 6] + [0 for _ in range(56)]) dev.Write([0, 0, 0, 1, 0x81, 0, 3, 1, 2, 3]) self.assertEqual( dev.Read(), [0, 0, 0, 1, 0xbf, 0, 1, 6] + [0 for _ in range(56)]) dev.Write([0, 0, 0, 1, 0x81, 0, 3, 1, 2, 3]) self.assertEqual( dev.Read(), [0, 0, 0, 1, 0x81, 0, 3, 1, 2, 3] + [0 for _ in range(54)]) def testFragmentedApdu(self): dev = util.FakeHidDevice(cid_to_allocate=None, msg_reply=list(range(85, 0, -1))) dev.Write([0, 0, 0, 1, 0x83, 0, 100] + [x for x in range(57)]) dev.Write([0, 0, 0, 1, 0] + [x for x in range(57, 100)]) self.assertEqual( dev.Read(), [0, 0, 0, 1, 0x83, 0, 85] + [x for x in range(85, 28, -1)]) self.assertEqual( dev.Read(), [0, 0, 0, 1, 0] + [x for x in range(28, 0, -1)] + [0 for _ in range(31)]) if __name__ == '__main__': unittest.main()	2.19 KB	2025-02-24 20:22

Terminal