5 # 2. IMPORT & INITIALIZATION
7 # 4. ARGUMENT PROCESSING
8 # 5. SIGNATURE CREATION AND CHECKING
10 #############################################################################
14 #############################################################################
17 [[[!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"]]][[[html]]][[[header]]][[[title]]]Signature-du-Terroir[[[/title]]][[[/header]]][[[body]]][[[h1]]]Signature-du-Terroir[[[/h1]]][[[p]]]
18 Construct a signature of the installed software state or check the integrity of the installation
19 using a previously made signature.
21 Usage: signduterre.py [options] FILE1 FILE2 ...
23 Options:[[[/p]]][[[pre]]]
24 -h, --help show this help message and exit
25 -s HEX, --salt=HEX Enter salt in cleartext. If not given, a hexadecimal
26 salt will be suggested. The SUGGESTED[=N] keyword will
27 cause the selection of the suggested string. N is the
28 number of salts generated (default N=1). If N>1, all
29 will be printed and a random one will be used to
30 generate the signature (selection printed to STDERR).
31 -a, --all-salts-pattern
32 Use all salts in sequence, randomly replace salts with
33 incorrect ones in the output to create a pattern of
34 failing hashes indicated by a corresponding integer
35 number. Depends on '--salt SUGGESTED=N'.
37 -p TEXT, --passphrase=TEXT
38 Enter passphrase in cleartext, the keyword
39 SUGGESTED[=N] will cause the suggested passphrase to
40 be used. If N>1, N passphrases will be printed to
41 STDERR and a random one will be used (selection
42 printed to STDERR). Entering the name of an existing
43 file (or '-' for STDIN) will cause it to be read and a
44 random passphrase found in the file will be used
45 (creating a signature), or they will all be used in
46 sequence (--check-file).
47 -c FILE, --check-file=FILE
48 Check contents with the output of a previous run from
49 file or STDIN ('-'). Except when the --quiet option is
50 given, the previous output will contain all
51 information needed for the program, but not the
52 passphrase and the --execute option.
53 -i FILE, --input-file=FILE
54 Use names from FILE or STDIN ('-'), use one
56 -o FILE, --output-file=FILE
57 Print to FILE instead of STDOUT
58 -P FILE, --Private-file=FILE
59 Print private information (passwords etc.) to FILE
61 -u USER, --user=USER Execute $(cmd) as USER, default 'nobody' (root/sudo
63 -S, --Status For each file, add a line with unvarying file status
64 information: st_mode, st_ino, st_dev, st_uid, st_gid,
65 and st_size (like the '?' prefix, default False)
66 --Status-values=MODE Status values to print for --Status, default MODE is
67 'fmidlugs' (file, mode, inode, device, uid, gid, size).
68 Also available (n)l(inks), a(time), (m)t(ime), and
70 -t, --total-only Only print the total hash, unsets --detailed-view
72 -d, --detailed-view Print hashes of individual files, is unset by --total-
74 -e, --execute Interpret $(cmd) (default False)
75 --execute-args=ARGS Arguments for the $(cmd) commands ($1 ....)
76 -n, --no-execute Explicitely do NOT Interpret $(cmd)
77 --print-execute Print the results of $() command execution to STDERR
78 for debugging purposes
79 -m, --manual Print the manual and exit
80 --manual-html Print the manual in HTML format and exit
81 --manual-make Print the examples in the manual as a makefile and
83 -r, --release-notes Print the release notes and exit
84 -l, --license Print license text and exit
85 -v, --verbose Print more information on output
86 -q, --quiet Print minimal information (hide filenames). If the
87 output is used with --check-file, the command line
88 options and arguments must be repeated.
91 Names and paths of one or more files to be checked. All file arguments in SdT accept '-' as the STDIN file
94 Any name starting with a '$', eg, $PATH, will be interpreted as an environmental variable or a command
95 according to the bash conventions: '$ENV' and '${ENV}' as variables, '$(cmd;cmd...)' as system commands
96 (bash --restricted -c 'cmd;cmd...' PID). Where PID the current Process ID is (available as positional
97 parameter $0). Other parameters can be entered with the --execute-args option ($1 etc). Do not forget to
98 enclose the arguments in single ''-quotes! The commands are scanned for unwanted characters and these
99 are removed (eg, ' and \\, however, escaping $ is allowed, eg, '\\$1'). The use of '$(cmd;cmd...)'
100 requires explicit use of the -e or --execute option.
102 If executed as root or sudo, $(cmd;cmd...) will be executed as 'sudo -H -u <user>' which defaults to
103 --user nobody ('--user root' is at your own risk). This will obviously not work when invoked as non-root/sudo.
104 --user root is necessary when you need to check privileged information, eg, you want to check the MBR with
105 '$(dd if=/dev/hda bs=512 count=1 status=noxfer | od -X)'
106 However, as you might use --check-file with files you did not create yourself, it is important to
107 be warned if commands are to be executed.
109 Interpretation of $() ONLY works if the -e or --execute options are entered. signduterre.py can easily
110 be adapted to automatically use the setting in the check-file. However, this is deemed insecure and
111 commented out in the distribution version.
113 The -n or --no-execute option explicitely supress the interpretation of $(cmd) arguments.
115 Meta information from stat() on files is signed when the filename is preceded by a '?'. '?./signduterre.py' will
116 extract (st_mode, st_ino, st_dev, st_nlinks, st_uid, st_gid, st_size) and hash a line of these data (visible
117 with --verbose). The --Status option will automatically add such a line in front of every file. Note that '?'
118 is implied for directories. Both '/' and '?/' produce a hash of, eg,:
120 stat(/) = [st_mode=041775, st_ino=2, st_dev=234881026, st_uid=0, st_gid=80, st_size=1360]
122 The --Status-values=<mode> option selects which status values will be used: f(ile), m(ode), i(node),
123 d(evice), u(id), g(id), s(ize), (n)l(inks), a(time), (m)t(ime), and c(time). Default is
124 --Status-values='fmidugs'. Note that nlinks of a directory include every file in the directory, so this
125 option can check whether files have been added to a directory.
127 Arguments enclosed in []-brackets will be hidden in the output. That is, '[/proc/self/exe]' will show up as
128 '[1]' in the output (or '[n]' with n the number of the hidden argument), equivalent to the use of the
129 --quiet option. This means the hidden arguments must be entered again when using the --check-file (-c)
134 A very simple tool to generate a signature that can be used to test the integrity of files and "states" in
135 a running installation. signduterre.py constructs a signature of the current system state and checks
136 installation state with a previously made signature. The files are hashed with a passphrase to allow detection
137 of compromised systems while running on the same system. The signature checking can be subverted, but the
138 flexibillity of signduterre.py and the fact that the output of any command can be tested should hamper
139 automated root-kit attacks.
141 signduterre.py writes a total SHA-256 hash to STDOUT of all the files and commands entered as arguments. It
142 can also write a hash for each individual file (insecure). The output of a signature can be send to a file and
143 later used to check with --check-file. Hashes are calculated with a hashed salt + passphrase sequence
144 pre-pended to create unpredictable hashes. This procedure ensures that an attacker does not know whether or
145 not the correct passphrase has been entered. An attacker can only know when to supply the requested hash
146 values if she knows the passphrase or has copies available of all the tested files and output of commands to
147 calculate the hashes on the fly.
151 How to test whether your system has been compromised when you can only use the potentially compromised system.
152 The solution is to store a password encrypted signature (or fingerprint) of your system when you are sure it
153 is in a good state. Then you check whether the system can still distinguish between correct and incorrect passwords
154 when it regenerates the signature. The trick is to use the right data (ie, questions) to generate the signature.
158 When run on a compromised system, signduterre.py can be subverted if the attacker keeps a copy of all the
159 files and command outputs, and reroutes the open() and stat() functions, or simply delegating signduterre.py
160 to a chroot jail with the original system. In principle, signduterre.py only checks whether the computer
161 responds identically to when the signature file was made. There is no theoretic barrier against a compromised
162 computer perfectly simulating the original system when tested, but behaving adversely at other times. Except
163 for running from clean boot media (USB?), I know of no theoretical sound solution to this problem.
165 However, this scenario assumes the use of unlimited resources and time. Inside a limited, real computer system,
166 the attacker must make compromises on what can and what cannot be simulated with the available time and
167 hardware. The idea behind signduterre.py is to "ask difficult questions" that increase the cost of simulating
168 the original system high enough to make detection of successful attacks likely.signduterre.py simply intends
169 to raise the bar high enoug. One point is to store the times needed to create the original hashes. This timing
170 can later be used to see whether the new timings are reasonable. If the same hardware takes considerably
171 longer to perform the same calculations, or needs a much longer delay before it starts, the tester might want
172 to see where this time is spent.
174 Signature-du-Terroir works on the assumption that any attacker in control of a compromised system cannot
175 predict whether the passphrase entered is correct or not. An attacker can always intercept the in- and output
176 of signduterre. When running with --check-file, this means the program can be made to print out OK
177 irrespective of the tests. A safe use of signduterre.py is to start with a random number of incorrect
178 passphrases and see whether they fail. Alternatively, and easier, is to add a number of unused salts
179 to the check-file and let the attacker guess which one is correct.
181 THE CORRECT USE OF signduterre.py IS TO ENTER A RANDOM NUMBER OF INCORRECT PASSPHRASES OR SALTS FOR EACH
182 TEST AND SEE WHETHER IT FAILS AT THE CORRECT INSTANCES!
184 On a compromised system, signduterre.py's detailed file testing (--detailed-view) is easily subverted. With a
185 matched file hash, the attacker will know that the correct passphrase has been entered and can print out the
186 stored hashes or 'ok's for the rest of the checks. So if the attacker keeps any entry in the signature file
187 uncompromised, she can intercept the output, test the password on the unchanged entry and substitute the
188 requested hashes for the output if the hash of that entry matches.
190 When checking for root-kits and other malware, it is safest to compare the signature files from a different,
191 clean, system. But then you would not need signduterre.py anyway. If you have to work on the system itself,
192 only use the -t or --total-only options to create signatures with a total hash and without individual file
193 hashes. Such a signature can be used to check whether the system is unchanged. Another signature file WITH A
194 DIFFERENT PASSPHRASE can then be used to identify the individual files that have changed. If a detailed
195 signature file has the same passphrase, an attacker could use that other file to read the individual file
196 hashes to check whether the correct passphrase was entered.
198 Using the --check-file option in itself is UNsafe. An attacker simply has to print out 'OK' to defeat the
199 check. This attack can be foiled by making it unpredictable when signduterre.py should return 'OK'. This can
200 be done by using a list of salts or passphrases where only one of them (or none!) is correct. Any attacker
201 will have to guess when to return 'OK'.
203 As generating and entering wrong passphrases and salts is tedious, users have to be supported in correct use
204 of SdT. To assist users, the '--salt SUGGESTED=<N>' option will generate a number N of salts. When
205 checking, each of these salts is tried in turn. An attacker that is unable to simulate the uncompromised
206 system will have to guess which one of the salts is the correct one, and whether or not the passphrase
207 is correct. This increases the chances of detecting compromised systems. If this is not enough guess
208 work, the '-a', '--all-salts-pattern' option will use all salts in sequence to generate total hashes,
209 but random salts will be changed in the output. This generates a pattern of failed salt tests. This pattern
210 is translated into a bit pattern and printed as an integer ([Fail, Fail, OK, Fail, OK, OK, Fail, OK]
211 = 00101101 (least significant first) = 10110100 (unsigned bin) = 180). On creation of a signature, this
212 number is printed to STDERR, on checking (--check-file) it is printed to STDOUT (note that the number
213 will never become 0 or all Fail). So for '--salt SUGGESTED=<N> --all-salts-pattern' the probability of
214 guessing the correct output goes from 1/N to 1/(2^N - 1). Note that '--all-salts-pattern' will work,
215 but is pointless, without '--salt SUGGESTED=<N>' with N>1.
217 The '--passphrase SUGGESTED=N' option will generate and print N passphrases. One of these is chosen at
218 random for the signature. The number of the chosen passphrase is printed on STDERR with the passwords.
219 When checking a file, the stored passphrases can be read in again, either by entering the passphrase
220 file after the --passphrase option ('--passphrase <passphrase file>'), or directly from the --check-file.
221 signduterre.py will print out the result for each of the passphrases.
223 Note, that storing passphrases in a file and feeding it to signduterre.py is MUCH less secure than just
224 typing them in. Moreover, it might completely defeat the purpose of signduterre.py. If future experiences
225 cast any more doubt on the security of this option, it will be removed.
227 For those who want to know more about what an "ideal attacker" can do, see:[[[br]]]
228 Ken Thompson "Reflections on Trusting Trust"[[[br]]]
229 [[[a href="http://cm.bell-labs.com/who/ken/trust.html"]]]http://cm.bell-labs.com/who/ken/trust.html[[[/a]]][[[br]]]
230 [[[a href="http://www.ece.cmu.edu/~ganger/712.fall02/papers/p761-thompson.pdf"]]]http://www.ece.cmu.edu/~ganger/712.fall02/papers/p761-thompson.pdf[[[/a]]]
232 David A Wheeler "Countering Trusting Trust through Diverse Double-Compiling"[[[br]]]
233 [[[a href="http://www.acsa-admin.org/2005/abstracts/47.html"]]]http://www.acsa-admin.org/2005/abstracts/47.html[[[/a]]]
235 and the discussion of these at Bruce Schneier's 'Countering "Trusting Trust"'[[[br]]]
236 [[[a href="http://www.schneier.com/blog/archives/2006/01/countering_trus.html"]]]http://www.schneier.com/blog/archives/2006/01/countering_trus.html[[[/a]]]
240 The intent of signduterre.py is to ensure that the signature cannot be subverted even if the system has been
241 compromised by an attacker that has obtained root control over the computer and any existing signature files.
243 signduterre.py asks for a passphrase which is PRE-pended to every file before the hash is constructed (unless
244 the passphrase is entered with an option). As long as the passphrase is not compromised, the hashes cannot
245 be reconstructed. A randomly generated, unpadded base-64 encoded 16 Byte password (ie, ~22 characters) is
246 suggested in interactive use. If '--passphrase SUGGESTED' is entered on the command line or no passphrase is
247 enetered when asked, the suggested value will be used. This value is printed to STDERR (the screen or 2) for
248 safe keeping. Please, make sure you store the printed passphrase. For instance:
249 [[[/p]]][[[pre make=example]]]
251 # Simple system sanity test using the 'which' command to establish the paths
252 $ python3.0 signduterre.py --passphrase SUGGESTED --salt SUGGESTED --detailed-view \\
253 `which python3.0 bash ps ls find stat` 2> test-20090630_11-14-03.pwd > test-20090630_11-14-03.sdt
254 $ python3.0 signduterre.py --passphrase test-20090630_11-14-03.pwd --check-file test-20090630_11-14-03.sdt
256 The first command will store the passphrase (and all error messages) in a file 'Signature_20090630_11-14-03.pwd'
257 and the check-file in 'Signature_20090630_11-14-03.sdt'. The second line will test the signature.
258 The signature will be made of the files used for the commands python3.0, bash, ps, ls, find, and stat.
259 These files are found using the 'which' command.
261 It is not secure to store files with the passphrase on the system you want to check. However, you could
262 pipe STDERR or --Private-file to some safe site.
264 Good passphrases are difficult to remember, so their plaintext form should be protected. To protect the
265 passphrase against rainbow and brute force attacks, the passphrase is concatenated to a salt phrase and
266 hashed before use (SHA-256).
268 The salt phrase is requested when constructing a signature. In interactive use, an 8 byte hexadecimal
269 (= 16 character) salt from /dev/urandom is suggested. If '--salt SUGGESTED' is entered on the command line
270 as the salt, the suggested value will be used. The salt is printed in plaintext to the output. The salt will
271 make it more difficult to determine whether the same passphrase has been used to create different signatures.
273 At the bottom, a 'TOTAL HASH' line will be printed that hashes all the lines printed for the files. This
274 includes the file names as printed on the hash lines. It is not inconceivable that existing signature files
275 could have been compromised in ways that might be missed when checking the signature. The total hash will
276 point out such changes.
278 Examples:[[[/p]]][[[pre make=example]]]
280 # Self test of root directory, python, and signduterre.py using the 'which' command to establish the paths
281 $ python3.0 signduterre.py --detailed-view --salt 436a73e3 --passphrase liauwefa3251EWC -o test-self.sdt \\
282 / `which python3.0 signduterre.py`
283 $ python3.0 signduterre.py --passphrase liauwefa3251EWC -c test-self.sdt
285 Write a signature to the file test-self.sdt and test it with the --check-file option. The signature contains
286 the SHA-256 hashes of the files, /usr/bin/python3.0, signduterre.py, and the status information on the root
287 directory. The salt '436a73e3' and passphrase 'liauwefa3251EWC' are used.
288 [[[/p]]][[[pre make=linux]]]
290 # Self test of root directory, python, and signduterre.py using the the /proc file system
291 $ python3.0 signduterre.py --detailed-view --salt SUGGESTED --passphrase liauwefa3251EWC -o test-self_proc.sdt \\
292 /proc/self/root /proc/self/exe `which signduterre.py`
293 $ python3.0 signduterre.py --passphrase liauwefa3251EWC --check-file test-self_proc.sdt
295 Write a signature to the file test-self_proc.sdt and test it with the --check-file option. The signature
296 contains the SHA-256 hashes of the same files as above, /usr/bin/python3.0, signduterre.py, and the status
297 information on the root directory. However, the python executable and the root directory are now accessed
298 through the /proc file system. The suggested salt is used (written to test-self_proc.sdt) and the passphrase
299 is (again) 'liauwefa3251EWC'.
300 [[[/p]]][[[pre make=example]]]
302 # Test of supporting commands for chkrootkit
303 $ python3.0 signduterre.py --execute --total-only --salt SUGGESTED=8 --passphrase SUGGESTED --Status \\
304 --output-file=test-chkrootkit.sdt --Private-file=test-chkrootkit.pwd \\
305 signduterre.py `which bash awk cut egrep find head id ls netstat ps strings sed uname`
306 $ python3.0 signduterre.py --execute --passphrase test-chkrootkit.pwd --check-file test-chkrootkit.sdt
308 Writes a signature of the requested files to test-chkrootkit.sdt (signature) and private information to
309 test-chkrootkit.pwd (password and selected salt) and checks it in the next line. The files are those of
310 commands required by the chkrootkit program (http://www.chkrootkit.org/), with bash added. The 'which'
311 command will give the paths for the commands. Eight salts are generated, of which only 1 is actually
312 used. When checking, the correct salt should match. This prevents a compromised program from simply
313 printing out OK tot he check. A more comprehensive evation of guessing the correct salt can be obtained
314 by using the '--all-salts-pattern' option.
315 [[[/p]]][[[pre make=linux]]]
317 # Simply lump all "system" files, the PATH environment variable and the first 2 columns of the output of lsmod
318 $ python3.0 signduterre.py --execute --detail --salt SUGGESTED --passphrase liauwefa3251EWC --Status --total-only \\
319 signduterre.py /sbin/* /bin/* /usr/bin/find /usr/bin/stat /usr/bin/python* '${PATH}' \\
320 '$(lsmod | awk "{print \$1, \$2}")' > test-20090625_14-31-54.sdt
322 # Failing check due to missing --execute option
323 $ python3.0 signduterre.py --passphrase liauwefa3251EWC -c test-20090625_14-31-54.sdt
324 $ python3.0 signduterre.py --passphrase liauwefa3251EWC -c test-20090625_14-31-54.sdt --no-execute
327 $ python3.0 signduterre.py --execute --passphrase liauwefa3251EWC --check-file test-20090625_14-31-54.sdt
329 Prints a signature to the system test-20090625_14-31-54.sdt and the automatically generated password to
330 test-20090625_14-31-54.pwd. The salt will be automatically determined. The signature contains the SHA-256
331 hashes of the file status and file contents of signduterre.py, /sbin/*, /bin/*, /usr/bin/find,
332 /usr/bin/file, /usr/bin/python* on separate lines, and a hash of the PATH environment variable. Do not
333 display the hash of every single file, which could be insecure, but only the total hash.
334 The first two checks will both fail if test-20090625_14-31-54.sdt contains a $(cmd) entry.
335 The --no-execute option is default and prevents the execute option (if reading the execute option from the
336 signature file has been activated). The last check will succeed (if the files have not been changed).
337 [[[/p]]][[[pre make=example]]]
339 # Use a list of generated passphrases
340 $ python3.0 signduterre.py --salt SUGGESTED --passphrase SUGGESTED=20 signduterre.py \\
341 2> test-20090630_16-44-34.pwd > test-20090630_16-44-34.sdt
342 $ python3.0 signduterre.py -p test-20090630_16-44-34.pwd -c test-20090630_16-44-34.sdt
344 Will generate and print 20 passphrases and print a signature using one randomly chosen passphrase from these
345 20. Everything is written to the files 'test-20090630_16-44-34.pwd' and 'test-20090630_16-44-34.sdt'.
346 Such file names can easily be generated with 'test-`date "+%Y%m%d_%H-%M-%S"`.sdt'.
347 The next command will check all 20 passphrases generated before from the Signature file and print the results.
348 [[[/p]]][[[pre make=example]]]
350 # Use a list of generated salts with a pattern of correct salts
351 $ python3.0 signduterre.py --salt SUGGESTED=16 --passphrase SUGGESTED --all-salts-pattern \\
352 -P test-salt-pattern.pwd -o test-salt-pattern.sdt `which bash stat find ls ps id uname awk gawk perl`
353 $ python3.0 signduterre.py -p test-salt-pattern.pwd -c test-salt-pattern.sdt
354 # Compare to salt pattern number to the one from the check-file
355 $ cat test-salt-pattern.pwd
357 [[[/p]]][[[pre make=sudo]]]
359 # Check MBR and current root directory (sudo and root user)
360 $ sudo python3.0 signduterre.py -u root -s SUGGESTED -p SUGGESTED --Status-values='i' -v -e -t \\
361 --output-file test-boot-sector.sdt --Private-file test-boot-sector.pwd --execute-args=sda \\
362 '?/proc/self/root' `which dd` '$(dd if=/dev/$1 bs=512 count=1 status=noxfer | od -X)'
363 $ sudo python3.0 signduterre.py -u root -e -p test-boot-sector.pwd -c test-boot-sector.sdt
365 Will hash the inode numbers of the effective root directory (eg, chroot) and the executable (python)
366 together with the contents of the MBR (Master Boot Record) on /dev/sda in Hex. It uses suggested salt and
367 passphrase. Accessing /dev/sda is only possible when root, so the command is entered with sudo and
368 --user root. Use the '--print-execute' option if you want to check the output of the dd command.
370 The examples can be run as a makefile using make. Use one of the following commands:
373 python3.0 signduterre.py --manual-make |make -f - example
374 # Linux specific examples
375 python3.0 signduterre.py --manual-make |make -f - linux
376 # Examples requiring sudo
377 python3.0 signduterre.py --manual-make | sudo make -f - sudo
378 [[[/pre]]][[[/body]]][[[/html]]]
383 Construct a signature of the installed software state or check a previously made signature.
385 copyright 2009, R.J.J.H. van Son
387 This program is free software: you can redistribute it and/or modify
388 it under the terms of the GNU General Public License as published by
389 the Free Software Foundation, either version 3 of the License, or
390 (at your option) any later version.
392 This program is distributed in the hope that it will be useful,
393 but WITHOUT ANY WARRANTY; without even the implied warranty of
394 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
395 GNU General Public License for more details.
397 You should have received a copy of the GNU General Public License
398 along with this program. If not, see <http://www.gnu.org/licenses/>.
401 # Note that only release notes are put here
402 # See git repository for detailed change comments:
403 # git clone git://repo.or.cz/signduterre.git
405 20090730 - Release candidate for v0.4
406 20090724 - Added '--all-salts-pattern' and HTML formatting in manual
407 20090723 - Added URL support for all files. Does not yet work due to bug in Python 3.0
408 20090723 - Added '-' for STDIN
409 20090717 - Added --execute-args
410 20090716 - Release v0.3
411 20090713 - Added --quiet option
412 20090712 - moved from /dev/random to /dev/urandom
413 20090702 - Replaced -g with -p SUGGESTED[=N]
414 20090702 - Generating and testing lists of random salts
415 20090701 - Release v0.2
416 20090630 - Generating and testing random passphrases
417 20090630 - --execute works on $(cmd) only, nlinks in ?path and ? implied for directories
418 20090630 - Ported to Python 3.0
420 20090628 - Release v0.1b
421 20090628 - Added release-notes
423 20090626 - Release v0.1a
424 20090626 - Initial commit to Git
427 #############################################################################
429 # IMPORT & INITIALIZATION #
431 #############################################################################
437 # if sys.stdout.isatty(): import readline;
442 from optparse
import OptionParser
;
446 import urllib
.request
;
449 # Limit the characters that can be used in $(cmd) commands
450 # Only allow the escape of '$'
451 not_allowed_chars
= re
.compile('([^\w\ \.\/\"\|\;\,\-\$\[\]\{\}\(\)\@\`\!\*\=\\\\]|([\\\\]+([^\$\\\\]|$)))');
453 programname
= "Signature-du-Terroir";
456 def open_infile(filename
, mode
):
459 elif filename
.find('://') > -1:
460 print("URL:", filename
, file=current_private
);
461 return urllib
.request
.urlopen(filename
);
463 if not os
.path
.isfile(filename
):
464 print(filename
, "does not exist", file=sys
.stderr
)
466 return open(filename
, mode
);
468 def open_outfile(filename
, mode
):
471 elif filename
.find('://') > -1:
472 print("URL:", filename
, file=current_private
);
473 return urllib
.request
.urlopen(filename
);
475 return open(filename
, mode
);
477 current_outfile
= sys
.stdout
;
478 current_private
= sys
.stderr
;
480 #############################################################################
484 #############################################################################
486 parser
= OptionParser()
487 parser
.add_option("-s", "--salt", metavar
="HEX",
488 dest
="salt", default
=False,
489 help="Enter salt in cleartext. If not given, a hexadecimal salt will be suggested. The SUGGESTED[=N] keyword will cause the selection of the suggested string. N is the number of salts generated (default N=1). If N>1, all will be printed and a random one will be used to generate the signature (selection printed to STDERR).")
490 parser
.add_option("-a", "--all-salts-pattern",
491 dest
="allsalts", default
=False, action
="store_true",
492 help="Use all salts in sequence, randomly replace salts with incorrect ones in the output to create a pattern of failing hashes indicated by a corresponding integer number. Depends on '--salt SUGGESTED=N'. Implies --total-only.")
493 parser
.add_option("-p", "--passphrase", metavar
="TEXT",
494 dest
="passphrase", default
=False,
495 help="Enter passphrase in cleartext, the keyword SUGGESTED[=N] will cause the suggested passphrase to be used. If N>1, N passphrases will be printed to STDERR and a random one will be used (selection printed to STDERR). Entering the name of an existing file (or '-' for STDIN) will cause it to be read and a random passphrase found in the file will be used (creating a signature), or they will all be used in sequence (--check-file).")
496 parser
.add_option("-c", "--check-file",
497 dest
="check", default
=False, metavar
="FILE",
498 help="Check contents with the output of a previous run from file or STDIN ('-'). Except when the --quiet option is given, the previous output will contain all information needed for the program, but not the passphrase and the --execute option.")
499 parser
.add_option("-i", "--input-file",
500 dest
="input", default
=False, metavar
="FILE",
501 help="Use names from FILE or STDIN ('-'), use one filename per line")
502 parser
.add_option("-o", "--output-file",
503 dest
="output", default
=False, metavar
="FILE",
504 help="Print to FILE instead of STDOUT")
505 parser
.add_option("-P", "--Private-file",
506 dest
="private", default
=False, metavar
="FILE",
507 help="Print private information (passwords etc.) to FILE instead of STDERR")
508 parser
.add_option("-u", "--user",
509 dest
="user", default
="nobody", metavar
="USER",
510 help="Execute $(cmd) as USER, default 'nobody' (root/sudo only)")
511 parser
.add_option("-S", "--Status",
512 dest
="status", default
=False, action
="store_true",
513 help="For each file, add a line with unvarying file status information: st_mode, st_ino, st_dev, st_uid, st_gid, and st_size (like the '?' prefix, default False)")
514 parser
.add_option("--Status-values",
515 dest
="statusvalues", default
="fmidugs", metavar
="MODE",
516 help="Status values to print for --Status, default MODE is 'fmidugs' (file, mode, inode, device, uid, gid, size). Also available (n)l(inks) a(time), (m)t(ime), and c(time).")
517 parser
.add_option("-t", "--total-only",
518 dest
="total", default
=False, action
="store_true",
519 help="Only print the total hash, unsets --detailed-view (default True)")
520 parser
.add_option("-d", "--detailed-view",
521 dest
="detail", default
=False, action
="store_true",
522 help="Print hashes of individual files, is unset by --total-only (default False)")
523 parser
.add_option("-e", "--execute",
524 dest
="execute", default
=False, action
="store_true",
525 help="Interpret $(cmd) (default False)")
526 parser
.add_option("--execute-args",
527 dest
="executeargs", default
='', metavar
="ARGS",
528 help="Arguments for the $(cmd) commands ($1 ....)")
529 parser
.add_option("-n", "--no-execute",
530 dest
="noexecute", default
=False, action
="store_true",
531 help="Explicitely do NOT Interpret $(cmd)")
532 parser
.add_option("--print-execute",
533 dest
="printexecute", default
=False, action
="store_true",
534 help="Print the results of $() command execution to STDERR for debugging purposes")
535 parser
.add_option("-m", "--manual",
536 dest
="manual", default
=False, action
="store_true",
537 help="Print the manual and exit")
538 parser
.add_option("--manual-html",
539 dest
="manualhtml", default
=False, action
="store_true",
540 help="Print the manual in HTML format and exit")
541 parser
.add_option("--manual-make",
542 dest
="manualmake", default
=False, action
="store_true",
543 help="Print the examples in the manual as a makefile and exit")
544 parser
.add_option("-r", "--release-notes",
545 dest
="releasenotes", default
=False, action
="store_true",
546 help="Print the release notes and exit")
547 parser
.add_option("-l", "--license",
548 dest
="license", default
=False, action
="store_true",
549 help="Print license text and exit")
550 parser
.add_option("-v", "--verbose",
551 dest
="verbose", default
=False, action
="store_true",
552 help="Print more information on output")
553 parser
.add_option("-q", "--quiet",
554 dest
="quiet", default
=False, action
="store_true",
555 help="Print minimal information (hide filenames). If the output is used with --check-file, the command line options and arguments must be repeated.")
557 (options
, check_filenames
) = parser
.parse_args();
560 # Start with opening any non-default output files
563 current_outfile
= open_outfile(options
.output
, 'w');
564 my_output
= options
.output
;
568 current_private
= open_outfile(options
.private
, 'w');
569 my_private
= options
.private
;
571 print("# Program: "+programname
+ " version " + version
, file=current_outfile
);
572 print("#", time
.strftime("%Y/%m/%d %H:%M:%S", time
.localtime()), "("+time
.tzname
[0]+")\n", file=current_outfile
);
576 print (license
, file=sys
.stderr
);
580 htmltags
= re
.compile('\[\[\[[^\]]*\]\]\]');
581 cleartext_manual
= htmltags
.sub('', manual
);
582 print (cleartext_manual
, file=sys
.stdout
);
585 if options
.manualhtml
:
586 protleftanglesbracks
= re
.compile('\<');
587 protrightanglesbracks
= re
.compile('\>');
588 leftanglesbracks
= re
.compile('\[\[\[');
589 rightanglesbracks
= re
.compile('\]\]\]');
590 html_manual
= protleftanglesbracks
.sub('<', manual
);
591 html_manual
= protrightanglesbracks
.sub('>', html_manual
);
592 html_manual
= leftanglesbracks
.sub('<', html_manual
);
593 html_manual
= rightanglesbracks
.sub('>', html_manual
);
594 print (html_manual
, file=sys
.stdout
);
596 # Print manual examples
597 if options
.manualmake
:
598 make_manual
= re
.sub("\$ ", "\t", manual
);
599 make_manual
= re
.sub("\#", "\t#", make_manual
);
600 make_manual
= re
.sub(r
"\\\s*\n", '', make_manual
);
601 make_manual
= re
.sub(r
"\$", r
'$$', make_manual
);
602 extrexamples
= re
.compile(r
"\[\[\[pre\s+make\=?(\w*)\s*\]\]\]\n([^\[]*)\n\[\[\[/pre\s*\]\]\]", re
.IGNORECASE|re
.MULTILINE|re
.DOTALL
);
603 exampleiter
= extrexamples
.finditer(make_manual
);
605 for match
in exampleiter
:
606 makefile_list
.append(match
.group(1)+":\n"+match
.group(2));
608 previous_cat
= 'NOT A VALUE';
610 for line
in makefile_list
:
611 (category
, commands
) = line
.split(':\n');
612 if category
!= previous_cat
:
613 previous_cat
= category
;
614 print("\n"+previous_cat
+":", file=sys
.stdout
);
615 print(commands
, file=sys
.stdout
);
617 print("\nclean:\n\trm test-*.sdt test-*.pwd", file=sys
.stdout
);
619 # Print release notes
620 if options
.releasenotes
:
621 print ("Version: "+version
, file=sys
.stderr
);
622 print (releasenotes
, file=sys
.stderr
);
625 my_salt
= options
.salt
;
626 my_allsalts
= options
.allsalts
;
627 my_passphrase
= options
.passphrase
;
628 my_check
= options
.check
;
629 my_status
= options
.status
;
630 my_statusvalues
= options
.statusvalues
;
631 my_verbose
= options
.verbose
and not options
.quiet
;
632 my_quiet
= options
.quiet
;
633 execute
= options
.execute
;
634 execute_args
= options
.executeargs
;
635 if options
.noexecute
: execute
= False;
636 input_file
= options
.input;
638 # Set total-only with the correct default
640 total_only
= not options
.detail
;
641 if options
.total
: total_only
= options
.total
;
642 if my_allsalts
: total_only
= my_allsalts
; # All alts pattern only sensible with total-only
643 if my_check
: total_only
= False;
645 my_user
= options
.user
;
646 # Things might be executed as another user
649 user_change
= 'sudo -H -u '+my_user
+' ';
650 if not my_quiet
: print("User: "+my_user
, file=current_outfile
);
654 text_execute
= "True";
656 text_execute
= "False";
658 if execute
and not my_quiet
:
659 print("Execute system commands: "+text_execute
+"\n", file=current_outfile
);
660 if execute_args
!= '': print("Execute arguments: '"+execute_args
+"'\n", file=current_outfile
);
663 if my_quiet
: print("Quiet: True\n", file=current_outfile
);
666 if my_statusvalues
!= 'fmidlugs': print("Status-values: '"+my_statusvalues
+"'\n", file=current_outfile
);
668 #############################################################################
670 # ARGUMENT PROCESSING #
672 #############################################################################
674 # Measure time intervals
675 start_time
= time
.time();
677 dev_random
= open("/dev/urandom", 'rb');
679 # Read the check file
680 passphrase_list
= [];
683 total_hash_list
= [];
685 highest_arg_used
= 0;
686 print("# Checking: "+my_check
+"\n", file=current_outfile
);
687 arg_list
= check_filenames
;
688 check_filenames
= [];
689 with
open_infile(my_check
, 'r') as c
:
691 match
= re
.search("Execute system commands:\s+(True|False)", line
);
693 # Uncomment the next line if you want automatic --execute from the check-file (DANGEROUS)
694 # execute = match.group(1).upper() == 'TRUE';
697 match
= re
.search("Execute arguments:\s+\'([\w\$\s\-\+\/]*)\'", line
);
699 execute_args
= match
.group(1);
702 match
= re
.search("Quiet:\s+(True|False)", line
);
704 my_quiet
= match
.group(1).upper() == 'TRUE';
705 if my_quiet
: my_verbose
= False;
708 match
= re
.search("Salt\s*\+\s*TOTAL HASH\s*\:\s+\'([\w]*)\'\s+\'([\w]*)\'", line
);
710 salt_list
.append(match
.group(1));
711 total_hash_list
.append(match
.group(2));
712 my_allsalts
= True; # Salt+TOTAL HASH imples all-salts-pattern
715 match
= re
.search("Salt\:\s+\'([\w]*)\'", line
);
717 salt_list
.append(match
.group(1));
720 match
= re
.search("Salt\s*\+\s*TOTAL HASH\s*\:\s+\'([\w]+)\'\s+\'([a-f0-9]+)\'", line
);
722 salt_list
.append(match
.group(1));
723 total_hash_list
.append(match
.group(2));
726 match
= re
.search("User\:\s+\'([\w]*)\'", line
);
728 # Uncomment the next line if you want automatic --user from the check-file (DANGEROUS)
729 # my_user = match.group(1);
732 match
= re
.search("Passphrase\:\s+\'([^\']*)\'", line
);
734 passphrase_list
.append(match
.group(1));
737 match
= re
.search("Status-values\:\s+\'([\w]*)\'", line
);
739 my_statusvalues
= match
.group(1);
742 match
= re
.search("^\s*([a-f0-9]+)\s+\*(TOTAL HASH)\s*$", line
)
744 total_hash_list
.append(match
.group(1));
747 match
= re
.search("^\s*([a-f0-9\-]+)\s+\*\[([0-9]+)\]\s*$", line
)
749 filenumber
= int(match
.group(2));
750 if filenumber
> highest_arg_used
: highest_arg_used
= filenumber
;
751 # Watch out, arguments count from 0
752 check_filenames
.append(arg_list
[filenumber
- 1]);
753 check_hashes
['['+match
.group(2)+']'] = match
.group(1);
756 match
= re
.search("^\s*([a-f0-9\-]+)\s+\*(.*)\s*$", line
)
758 check_filenames
.append(match
.group(2));
759 # Catch --execute error as early as possible
760 if match
.group(2).startswith('$(') and not execute
:
761 error_message
= "Executable argument \'"+match
.group(2)+"\' only allowed with the --execute flag";
762 print (error_message
, file=sys
.stderr
);
763 if not sys
.stdout
.isatty(): print(error_message
, file=current_outfile
);
765 check_hashes
[match
.group(2)] = match
.group(1);
767 for i
in range(highest_arg_used
, len(arg_list
)):
768 check_filenames
.append(arg_list
[i
]);
769 check_hashes
['['+str(i
+1)+']'] = (64*'-');
773 with
open_infile(input_file
, 'r') as i
:
776 current_filename
= re
.sub('[^\w\-\.\/\$\{\(\)\}\?\[\]]', '', line
);
777 check_filenames
.append(current_filename
);
778 if my_check
: check_hashes
['['+str(i
+1)+']'] = (64*'-');
781 for x
in check_filenames
:
784 if my_status
and not x
.startswith(('?', '$')):
785 stat_list
.append('?'+x
);
787 check_filenames
= stat_list
;
789 # Seed Pseudo Random Number Generator
790 seed
= dev_random
.read(16);
793 # Read suggested salts from /dev/(u)random if needed
795 if my_salt
.startswith('SUGGESTED'):
797 match
= re
.search("([0-9][0-9]*)$", my_salt
);
799 N
= int(match
.group(1));
801 salt
= dev_random
.read(8);
802 salt_list
.append(str(binascii
.hexlify(salt
), 'ascii'));
804 salt_list
.append(my_salt
);
805 elif len(salt_list
) == 0:
806 salt
= dev_random
.read(8);
807 sys
.stderr
.write("Enter salt (suggest \'"+str(binascii
.hexlify(salt
), 'ascii')+"\'): ");
809 if not new_salt
: new_salt
= str(binascii
.hexlify(salt
), 'ascii');
810 salt_list
.append(new_salt
);
812 # If not combining salts with TOTAL HASH, print salts now
814 for my_salt
in salt_list
:
815 print("Salt: \'"+my_salt
+"\'", file=current_outfile
);
818 if my_passphrase
and(my_passphrase
== '-' or os
.path
.isfile(my_passphrase
)):
819 with
open_infile(my_passphrase
, 'r') as file:
821 match
= re
.search("Passphrase\:\s+\'([^\']*)\'", line
);
823 passphrase_list
.append(match
.group(1));
824 elif not my_passphrase
and len(passphrase_list
) == 0:
825 suggest_passphrase
= dev_random
.read(16);
826 sys
.stderr
.write("Enter passphrase (suggest \'"+str(base64
.b64encode(suggest_passphrase
), 'ascii').rstrip('=')+"\'): ");
827 # How kan we make this unreadable on input?
828 current_passphrase
= input();
829 if not current_passphrase
:
830 current_passphrase
= str(base64
.b64encode(suggest_passphrase
), 'ascii').rstrip('=');
831 print("Passphrase: \'"+current_passphrase
+"\'", file=current_private
);
832 passphrase_list
.append(current_passphrase
);
833 elif my_passphrase
.startswith('SUGGESTED'):
835 match
= re
.search("([0-9][0-9]*)$", my_passphrase
);
837 N
= int(match
.group(1));
838 j
= int(random
.random()*N
);
839 for i
in range(0, N
):
840 suggest_passphrase
= dev_random
.read(16);
841 current_passphrase
= str(base64
.b64encode(suggest_passphrase
), 'ascii').rstrip('=');
842 print("Passphrase: \'"+current_passphrase
+"\'", file=current_private
);
843 passphrase_list
.append(current_passphrase
);
845 passphrase_list
.append(my_passphrase
);
850 if len(passphrase_list
) > 1:
851 j
= int(random
.random()*len(passphrase_list
));
852 passphrase_list
= [passphrase_list
[j
]];
853 print("# Selected passphrase:", j
+1, file=current_private
);
854 if len(salt_list
) > 1:
855 j
= int(random
.random()*len(salt_list
));
856 # Make sure at least 1 salt will match and print the selection if only one is used
859 salt_list
= [salt_list
[selected_salt
-1]];
860 print("# Selected salt:", selected_salt
, file=current_private
);
862 salt_N
= len(salt_list
);
863 fail_fraction
= (salt_N
/2.0)/(salt_N
- 1);
867 # Close /dev/(u)random
870 #############################################################################
872 # SIGNATURE CREATION AND CHECKING #
874 #############################################################################
876 end_time
= time
.time();
877 print("# Preparation time:", end_time
- start_time
, "seconds\n", file=current_outfile
);
883 matched_salt_pattern
= -1;
884 salt_pattern_number
= -1;
886 for my_passphrase
in passphrase_list
:
888 # Initialize salt pattern
890 salt_pattern_number
= 0;
891 current_salt_power
= 1;
893 for my_salt
in salt_list
:
894 print("# Start signature: ", end
='', file=current_outfile
);
895 if len(passphrase_list
) > 1: print("passphrase -", pnum
, end
='', file=current_outfile
);
896 if len(salt_list
) > 1: print(" salt -", snum
, end
='', file=current_outfile
);
897 print("", file=current_outfile
);
899 # Should everything be printed?
900 print_verbose
= my_verbose
and not (my_allsalts
and snum
> 1);
903 start_time
= time
.time();
904 # Construct the passphrase hash
905 passphrase
= hashlib
.sha256();
907 passphrase
.update(bytes(my_salt
, encoding
='ascii'));
908 passphrase
.update(bytes(my_passphrase
, encoding
='ascii'));
910 # Create prefix which is a hash of the salt+passphrase
911 prefix
= passphrase
.hexdigest();
913 # Create signature and write output
914 totalhash
= hashlib
.sha256();
915 totalhash
.update(bytes(prefix
, encoding
='ascii'));
916 for org_filename
in check_filenames
:
917 # Create file hash object
918 filehash
= hashlib
.sha256();
919 filehash
.update(bytes(prefix
, encoding
='ascii'));
921 filename
= org_filename
.strip('[').rstrip(']');
922 # Use system variables and commands
923 if filename
.startswith('$'):
924 # Commands $(command)
925 match
= re
.search('^\$[\(]([^\)]+)[\)]$', filename
);
928 error_message
= "Executable argument \'"+filename
+"\' only allowed with the --execute flag";
929 print (error_message
, file=sys
.stderr
);
930 if not sys
.stdout
.isatty(): print(error_message
, file=current_outfile
);
932 current_command
= not_allowed_chars
.sub(" ", match
.group(1));
933 current_command_line
= user_change
+"bash --restricted -c \'"+current_command
+"\' "+str(os
.getpid())+" "+execute_args
;
935 print("#", current_command_line
, file=current_outfile
);
936 (status
, b
) = subprocess
.getstatusoutput(current_command_line
);
938 print('$('+current_command
+')'+"\n"+b
, file=sys
.stderr
);
940 elif options
.printexecute
: # For debugging commands
941 print(b
, file=sys
.stderr
);
942 match
= re
.search('^\$[\{]?([^\}\(\)]+)[\}]?$', filename
);
944 current_var
= not_allowed_chars
.sub(" ", match
.group(1));
946 print("# echo $"+ current_var
, file=current_outfile
);
947 b
= os
.environ
[current_var
];
948 filehash
.update(bytes(bytes(b
, encoding
='utf8')));
949 # lstat() meta information
950 elif filename
.startswith('?'):
951 if not os
.path
.exists(filename
.lstrip('?')):
952 print(filename
, "does not exist", file=sys
.stderr
)
954 filestat
= os
.stat(filename
.lstrip('?'));
955 if my_statusvalues
== "": my_statusvalues
= 'fmidlugs'
957 if 'f' in my_statusvalues
:
958 b
+= 'stat('+filename
.lstrip('?')+') = '
960 if 'm' in my_statusvalues
:
961 b
+= 'st_mode='+str(oct(filestat
.st_mode
))+', ';
962 if 'i' in my_statusvalues
:
963 b
+= 'st_ino='+str(filestat
.st_ino
)+', ';
964 if 'd' in my_statusvalues
:
965 b
+= 'st_dev='+str(filestat
.st_dev
)+', '
966 if 'l' in my_statusvalues
:
967 b
+= 'st_nlink='+str(filestat
.st_nlink
)+', '
968 if 'u' in my_statusvalues
:
969 b
+= 'st_uid='+str(filestat
.st_uid
)+', '
970 if 'g' in my_statusvalues
:
971 b
+= 'st_gid='+str(filestat
.st_gid
)+', '
972 if 's' in my_statusvalues
:
973 b
+= 'st_size='+str(filestat
.st_size
)+', '
974 if 'a' in my_statusvalues
:
975 b
+= 'st_atime='+str(filestat
.st_atime
)+', '
976 if 't' in my_statusvalues
:
977 b
+= 'st_mtime='+str(filestat
.st_mtime
)+', '
978 if 'c' in my_statusvalues
:
979 b
+= 'st_ctime='+str(filestat
.st_ctime
);
981 b
= b
.rstrip(', ') + ']';
982 filehash
.update(bytes(b
, encoding
='utf8'));
984 print ("# "+ b
, file=current_outfile
);
987 # open and read the file
988 if filename
!= '-' and filename
.find('://') == -1 and not os
.path
.exists(filename
):
989 print(filename
, "does not exist", file=sys
.stderr
)
991 with
open_infile(filename
, 'rb') as file:
993 if type(b
).__name
__ == 'str': b
= str.encode(b
);
996 current_digest
= filehash
.hexdigest();
997 print_name
= filename
;
998 if my_quiet
or org_filename
.startswith('['):
1000 print_name
= '['+str(file_argnum
)+']';
1001 current_hash_line
= current_digest
+" *"+print_name
1002 totalhash
.update(bytes(current_hash_line
, encoding
='ascii'));
1004 # Be careful to use this ONLY after totalhash has been updated!
1006 current_hash_line
= (len(current_digest
)*'-')+" *"+print_name
;
1010 if not (my_quiet
and total_only
) and not (my_allsalts
and snum
> 1):
1011 print(current_hash_line
, file=current_outfile
);
1012 elif not (my_quiet
or my_allsalts
):
1013 if check_hashes
[print_name
] == (len(current_digest
)*'-'):
1014 # Suppress redundant output of empty, ----, lines
1015 if snum
<= 1 and pnum
<= 1:
1016 print(check_hashes
[print_name
]+" *"+print_name
, file=current_outfile
);
1017 elif current_digest
!= check_hashes
[print_name
]:
1018 print("DIFFERENT: "+current_hash_line
, file=current_outfile
);
1020 print("ok"+" *"+print_name
, file=current_outfile
);
1023 current_total_digest
= totalhash
.hexdigest();
1024 # Write (in)correct salts with the TOTAL HASH
1026 output_salt
= my_salt
;
1027 j
= random
.random();
1028 # Randomly create an incorrect salt for failed output
1030 if j
< fail_fraction
and snum
!= selected_salt
:
1031 salt
= dev_random
.read(8);
1032 output_salt
= str(binascii
.hexlify(salt
), 'ascii');
1034 salt_pattern_number
+= current_salt_power
;
1035 current_total_digest_line
= "Salt+TOTAL HASH: '"+output_salt
+"' '"+current_total_digest
+"'";
1036 else: # Standard TOTAL HASH line
1037 current_total_digest_line
= current_total_digest
+" *"+"TOTAL HASH";
1038 end_time
= time
.time();
1039 print("# \n# Total hash - Time to completion:", end_time
- start_time
, "seconds", file=current_outfile
);
1041 if my_allsalts
: total_hash_num
= snum
-1; # Current TOTAL HASH number of more are used
1043 print(current_total_digest_line
+"\n", file=current_outfile
);
1044 elif current_total_digest
!= total_hash_list
[total_hash_num
]:
1045 if not my_allsalts
: print("DIFFERENT: "+current_total_digest_line
+"\n", file=current_outfile
);
1047 if my_allsalts
: salt_pattern_number
+= current_salt_power
; # Update salt bit pattern
1049 if len(passphrase_list
) > 1 or len(salt_list
): match_number
= " #"
1050 if len(passphrase_list
) > 1: match_number
+= " passphrase no: "+str(pnum
);
1051 if len(salt_list
) > 1: match_number
+= " salt no: "+str(snum
);
1052 if not my_allsalts
: print("OK"+" *"+"TOTAL HASH"+match_number
+"\n", file=current_outfile
);
1056 if my_allsalts
: current_salt_power
*= 2; # Update current bit position in salt pattern
1057 if my_check
and corrpnum
== pnum
: matched_salt_pattern
= salt_pattern_number
;
1060 if my_check
and len(passphrase_list
) > 1:
1062 print("Passphrase entry:",corrpnum
,"matched", file=current_outfile
);
1064 print("No passphrase entry matched!", file=current_outfile
);
1065 if my_check
and (not my_allsalts
) and len(salt_list
) > 1:
1068 print("Salt entry:",corrsnum
,"matched", file=current_outfile
);
1070 print("No salt entry matched!", file=current_outfile
);
1072 print("No entry matched", file=current_outfile
);
1073 # Print salt bit patterns
1074 elif my_check
and my_allsalts
:
1075 print("Salt pattern number:", matched_salt_pattern
, file=current_outfile
);
1076 elif not my_check
and my_allsalts
:
1077 print("# Salt pattern number:", salt_pattern_number
, file=current_private
);
1079 # Close output files if necessary
1080 if my_output
and my_output
!= '-':
1081 current_outfile
.close();
1082 if my_private
and my_private
!= '-':
1083 current_private
.close();