SeedSigner

This commit fixes a small date-parsing bug in the software's version helper. When the code runs in GitHub Actions, Git reports the latest commit time ending in 'Z' (a common UTC notation), but the Python function used to read that date didn't understand 'Z' before Python 3.11. The patch simply replaces 'Z' with '+00:00' so the date parses correctly. It is a compatibility fix, not a security fix.

This commit refactors how SeedSigner determines and records its software version. It removes an environment-variable-based build path and instead reads version info directly from git. The change is mostly cleanup and testing improvements. There is no obvious security vulnerability, but the code still uses shell commands (os.popen) and parses git output, which can be risky if inputs are ever attacker-controlled. Here, the inputs come from the local git state or trusted environment variables, so the practical risk is low.

This commit simplifies a custom camera error exception by removing a hard-coded user-facing error message. The exception still exists and will still be raised; it just no longer automatically includes the text 'Camera error. Check camera connections.' There is no security-relevant change visible in the diff.

This commit removes a temporary workaround (mocking the operating system type) from a single automated test file. It does not change any production code, user-facing behavior, or security-sensitive logic. The change simply makes the test rely on the real environment instead of pretending to be a specific OS.

This is a tiny code cleanup in a helper script that writes a version information file. It removes four comment lines and combines two variable assignments into one line. There is no functional change and no security relevance.

This commit refactors a small developer utility that writes a version.json file. It changes how the script decides whether it is running in the official build environment versus a local development copy, and makes the generated version file match the official build format even when built locally. There is no obvious security problem in the diff itself.

This commit is a routine code cleanup and build-system improvement. It renames internal variables (for example, changing 'version_commit_hash' to 'short_commit_hash'), makes the version string consistently include a 'v' prefix, and adds explicit support for detecting the SeedSigner OS build environment. There is no change that affects security or user safety.

This commit simply moves a block of existing code (the git shell command helpers) to a different location in the same file and renames a couple of test methods. No behavior changes, no security fixes, and no new vulnerabilities are introduced.

This is a one-line bugfix in a build helper script. A previous code rename left a reference to an old method name, which would have caused the script to crash. The patch simply points the script to the correct new method name. There is no security-relevant change visible in the diff.

This commit is purely a code cleanup and test expansion. It renames internal helper methods in the version utility to be clearer (for example, changing `_get_version_name_from_env_var` to `_get_version_name_from_seedsigner_os_env_var`), reorganizes comments, and adds new tests to keep test coverage at 100%. There is no change to user-facing behavior, no fix for a bug, and no security-related change.

This commit only adds a new unit test to the project's test suite. It verifies that a version-reporting override method works correctly and that the override is blocked when running on the actual SeedSigner OS. There are no changes to production code, no bug fixes, and no security-related behavior changes.

This is a one-line bugfix in a test helper script that generates screenshots. The change swaps a public method call for directly clearing an internal singleton variable. It only affects the screenshot generator's cleanup routine and does not appear to be a security fix for user-facing code.

This commit restores a helper function that lets the project’s screenshot generator temporarily override version information shown in screenshots. The function is decorated so it cannot run on the actual SeedSigner OS device. It only affects display text used in documentation screenshots, not private keys, seeds, or transaction logic.

This commit only changes a test file that checks how the software reports its version number when running inside GitHub Actions. It does not change the actual version-detection code or any security-sensitive behavior. There is no security issue here.

This commit only changes test code in tests/test_version.py. It fixes test bugs by adding a fixture that controls an environment variable during tests and updates several test assertions to call the correct utility class (VersionUtils instead of Version). There are no changes to the actual application code that users run, so this has no direct security impact on the SeedSigner device or software.

This commit is a routine internal refactor of how the app reads its own version information (version name, fork, timestamp, commit hash). It consolidates singleton setup, renames constants and methods, adds GitHub Actions CI detection, and expands unit tests to reach 100% code coverage. There is no direct evidence in the commit that this fixes a security vulnerability or introduces a new attack path. The changes are mostly about making version reporting more reliable and testable.

This commit is mostly a routine code cleanup and test expansion for how SeedSigner reports its software version. It renames a decorator, adds more tests, improves error handling when files are missing, and fixes a timestamp formatting bug when checking GitHub releases. There is no direct evidence in the commit that this fixes an active security vulnerability, but it does reduce risky behavior such as silently swallowing errors and making unverified shell calls in some contexts.

This is a large code refactor that changes how SeedSigner detects and displays its software version. It replaces a simple version reader with a more complex singleton system that reads git state, environment variables, and a JSON file. The changes are mostly about version reporting and do not appear to alter how private keys, seeds, or Bitcoin transactions are handled. There is no clear security bug visible in the diff, but the refactor introduces new code paths that touch files and shell commands, which always carry some risk of mistakes.

This commit fixes a bug in how SeedSigner determines and reports its software version. Previously, the version was set once and could be left blank or stale in certain build situations. The patch makes version detection more reliable by trying multiple sources: an environment variable, the current Git branch, the latest Git tag, and finally the short commit hash. There is no direct evidence this is a security fix, but reliable version reporting helps users and developers confirm they are running the expected software.

This commit simply adds one file path to the project's .gitignore list, telling Git not to track a generated version.json file. There is no code change, no security fix, and no vulnerability introduced.

This commit adds a single debug print statement that displays the value of an environment variable used during the build process. It does not change how the software works, does not introduce a security flaw, and does not affect end-user security. It is a routine development/debugging change.

This commit changes how SeedSigner records its software version and build timestamp. It now reads a version name from an environment variable used by SeedSigner OS and forces the last-edit timestamp to UTC. These are build-process improvements, not fixes for an active security vulnerability. The only security-relevant aspect is a small hardening of how external shell commands and environment input are handled.

This commit changes how SeedSigner records the 'last edit time' in its version.json file. Previously it scanned all source files for the most recent modification time. Now it runs a git command to use the most recent commit timestamp. The main concern is that it uses os.popen(), which executes a shell command, and does not validate the output. In normal use this is benign, but if an attacker can control the working directory or git executable, it could become a command-injection or misleading-metadata issue. There is no direct evidence this is being exploited.

This commit simply renames a method from get_last_edit to get_last_edit_timestamp and updates the places that call it and test it. There is no security issue here—just a cleanup to fix a naming mismatch (the caller was already using a name that did not exist).

This commit removes a leftover debug print statement and changes how the software figures out its own version name by asking the Git tool directly instead of relying on a pre-existing file. The change itself is not a security fix, but it removes a minor information leak (the hostname) and avoids a build-time dependency on a generated file. There is no evidence this was reported as a security issue or credited to a researcher.