Recent changes to Rules Processing

Rules Processing modified by chalo

chalo — Wed, 30 Oct 2013 15:34:39 -0000

--- v9
+++ v10
@@ -59,13 +59,13 @@
 **Capitalize the word**
 -: c

-**Capitalize the word and insert at the end the 'r' character if it length is grater than 5**
+**Capitalize the word and append at the end the 'r' character if it length is grater than 5**
 \>5 c $r

 **Append all digits to the end of the word**
-$\[0-1]
+$\[0-9]

-**Append some birthdays to the end of the word**
+**Append some birthdays years to the end of the word**
 $1 $9 $\[789] $\[0-9]

 **Convert the word to uppercase if it length is grater than 5**

Rules Processing modified by chalo

chalo — Wed, 30 Oct 2013 15:31:52 -0000

--- v8
+++ v9
@@ -7,7 +7,7 @@

 In JBrute, you have 2 main components: the rule preprocessor and the processor. The preprocessor does several things related to validation of rules, and it generates multiple rules from one rule if it uses masks. The processor checks the rule conditions and applies commands to the processing word.
 First of all, JBrute read all wordlist from file to memory. Then, for each rule, it process each word. There is no action related to save processed words, so, when it finish whit a rule, just starts again with the next rule and the original wordlist.
-In the parsing of a rule the processor checks all conditions and actions from left to right, so, the condition/command´s order matters.
+In the parsing of a rule the processor checks all conditions and actions from left to right, so, the condition/command´s order matters. Also, each condition/action in a rule must be separed from the next one by a space character. So, JTR rules with conditions/actions not separed will not work on JBrute.

 As I said, rules syntax are very similar to the "John The Ripper" rules syntax, but with some limitations:

Rules Processing modified by chalo

chalo — Tue, 29 Oct 2013 20:08:00 -0000

--- v7
+++ v8
@@ -3,7 +3,7 @@
 Introduction
 ------------

-Rules are very similar to the "John The Ripper" rules. In fact, I really want to implement the whole JTR rules conditions and rules, but it isn´t an easy work...
+Rules are very similar to the "John The Ripper" rules. In fact, I really want to implement the whole JTR rules conditions and commands, but it isn´t an easy work...

 In JBrute, you have 2 main components: the rule preprocessor and the processor. The preprocessor does several things related to validation of rules, and it generates multiple rules from one rule if it uses masks. The processor checks the rule conditions and applies commands to the processing word.
 First of all, JBrute read all wordlist from file to memory. Then, for each rule, it process each word. There is no action related to save processed words, so, when it finish whit a rule, just starts again with the next rule and the original wordlist.

Rules Processing modified by chalo

chalo — Tue, 29 Oct 2013 20:07:17 -0000

--- v6
+++ v7
@@ -7,7 +7,7 @@

 In JBrute, you have 2 main components: the rule preprocessor and the processor. The preprocessor does several things related to validation of rules, and it generates multiple rules from one rule if it uses masks. The processor checks the rule conditions and applies commands to the processing word.
 First of all, JBrute read all wordlist from file to memory. Then, for each rule, it process each word. There is no action related to save processed words, so, when it finish whit a rule, just starts again with the next rule and the original wordlist.
-At the beginning of the parsing of a rule, the preprocessor separates the conditions and the actions. The processor check all conditions from left to right, and then applies commands to the word from left to right too. So, it doesn´t matter the condition/command´s order.
+In the parsing of a rule the processor checks all conditions and actions from left to right, so, the condition/command´s order matters.

 As I said, rules syntax are very similar to the "John The Ripper" rules syntax, but with some limitations:

@@ -44,11 +44,7 @@
 -\[:c]

 4) The next actions (memory access commands) are not working (JBrute just ignore it for compatibility reasons):
-    M  memorize the word (for use with "Q", "X", or to update "m")
-    Q  query the memory and reject the word unless it has changed
     XNMI   extract substring NM from memory and insert into current word at I
-
-I want to implement memory access commands, but actually I have not enough information about how it works exactly, so, I´m still working on it... 

 5) The next Insert/delete commands are not working (JBrute will tell you that it is an invalid action)
     xNM    extract substring from position N for up to M characters

Rules Processing modified by chalo

chalo — Fri, 27 Sep 2013 03:39:06 -0000

--- v5
+++ v6
@@ -1,37 +1,56 @@
-Rules Examples
-==============
-Intoduction
+Rules Processing
+================
+Introduction
 ------------

-Rules are similar to "John The Ripper" rules, with some limitations:
-1) There is no support for masking
-    So, if you want to use the next JTR rule:
-    =^\[A-Z]
-    You must use instead one rule for each member of the mask:
-    =^A
-    =^B
-    =^C
-    ...
-    =^Z
+Rules are very similar to the "John The Ripper" rules. In fact, I really want to implement the whole JTR rules conditions and rules, but it isn´t an easy work...

-2) The next conditions are not working (JBrute just ignore it for compatibiliry reasons):
+In JBrute, you have 2 main components: the rule preprocessor and the processor. The preprocessor does several things related to validation of rules, and it generates multiple rules from one rule if it uses masks. The processor checks the rule conditions and applies commands to the processing word.
+First of all, JBrute read all wordlist from file to memory. Then, for each rule, it process each word. There is no action related to save processed words, so, when it finish whit a rule, just starts again with the next rule and the original wordlist.
+At the beginning of the parsing of a rule, the preprocessor separates the conditions and the actions. The processor check all conditions from left to right, and then applies commands to the word from left to right too. So, it doesn´t matter the condition/command´s order.
+
+As I said, rules syntax are very similar to the "John The Ripper" rules syntax, but with some limitations:
+
+1) There are partial support for masking
+    Actually masks are only supported for the "^" and "$" actions. Only the next mask are supported: a-z, A-Z, 0-9, a-z0-9, a-zA-z, A-Z0-9, a-zA-Z0-9
+    So:
+    ^\[0-9]
+    will be:
+    ^0
+    ^1
+    ^2
+    ^3    
+    ^4
+    ^5
+    ^6
+    ^7
+    ^8
+    ^9
+    You could use your own custom charsets in that way:
+    ^\[6789]
+    should be:
+    ^6
+    ^7
+    ^8
+    ^9
+
+2) The next conditions are not working (JBrute just ignore it for compatibility reasons):
     -c reject this rule unless current hash type is case-sensitive
     -8 reject this rule unless current hash type uses 8-bit characters
     -s reject this rule unless some password hashes were split at loading
     -p reject this rule unless word pair commands are currently allowed

-3) Because 1) and 2), this beggining condition are not supported:
+3) Because 1) and 2), this beginning condition are not supported:
 -\[:c]

-4) The next actions (memory access commands) are not working (JBrute just ignore it for compatibiliry reasons):
+4) The next actions (memory access commands) are not working (JBrute just ignore it for compatibility reasons):
     M  memorize the word (for use with "Q", "X", or to update "m")
     Q  query the memory and reject the word unless it has changed
     XNMI   extract substring NM from memory and insert into current word at I

+I want to implement memory access commands, but actually I have not enough information about how it works exactly, so, I´m still working on it... 
+
 5) The next Insert/delete commands are not working (JBrute will tell you that it is an invalid action)
-    \[ delete the first character
-    ]  delete the last character
-    DN delete the character in position N
     xNM    extract substring from position N for up to M characters
     iNX    insert character X in position N and shift the rest right
     oNX    overstrike character in position N with character X
@@ -47,19 +66,25 @@
 **Capitalize the word and insert at the end the 'r' character if it length is grater than 5**
 \>5 c $r

-**Uppercase the word if it length is grater than 5**
-\>5 S
+**Append all digits to the end of the word**
+$\[0-1]

-**Capitalize the word and insert at the beggining the '9' character if it length is grater than 3 and it starts with 'c' character**
+**Append some birthdays to the end of the word**
+$1 $9 $\[789] $\[0-9]
+
+**Convert the word to uppercase if it length is grater than 5**
+\>5 u
+
+**Convert the word to uppercase and insert the '9' character at the beginning if it length is grater than 3 and it starts with 'c' character**
 \>3 =0c c ^9

 **For the complete list of options, please refer to the "John The Ripper" rules syntax:**
 http://www.openwall.com/john/doc/RULES.shtml

-**You can always check your rule conditions/aplications with the next command:**
+**You can always check your rule conditions/commands with the next command:**
 $ ./jbrute.sh --decrypt --method=dictionary --dict_file=words.txt --rule_file=rules.txt --stdout

-Note: JBrute will not try to decrypt, it will just read the dictionary file "words.txt" and process it with the specifies rules on file "rules.txt".
+Note: JBrute will not try to decrypt, it will just read the dictionary file "words.txt" and process it with the specifies rules on "rules.txt" file.

-**If you found a functionality that is not implemented (except the mentioned limitations), or it is not working as expected, please tell me and I will be happy to correct it.**
+**If you found a functionality that is not implemented (except the mentioned limitations), or it is not working as expected, please tell me and I will be happy to fix it.**

Rules Examples modified by chalo

chalo — Thu, 19 Sep 2013 00:03:17 -0000

--- v4
+++ v5
@@ -20,12 +20,15 @@
     -s reject this rule unless some password hashes were split at loading
     -p reject this rule unless word pair commands are currently allowed

-3) The next actions (memory access commands) are not working (JBrute just ignore it for compatibiliry reasons):
+3) Because 1) and 2), this beggining condition are not supported:
+-\[:c]
+
+4) The next actions (memory access commands) are not working (JBrute just ignore it for compatibiliry reasons):
     M  memorize the word (for use with "Q", "X", or to update "m")
     Q  query the memory and reject the word unless it has changed
     XNMI   extract substring NM from memory and insert into current word at I

-4) The next Insert/delete commands are not working (JBrute will tell you that it is an invalid action)
+5) The next Insert/delete commands are not working (JBrute will tell you that it is an invalid action)
     \[ delete the first character
     ]  delete the last character
     DN delete the character in position N

Rules Examples modified by chalo

chalo — Wed, 18 Sep 2013 23:46:50 -0000

--- v3
+++ v4
@@ -6,12 +6,13 @@
 Rules are similar to "John The Ripper" rules, with some limitations:
 1) There is no support for masking
     So, if you want to use the next JTR rule:
-    =0\[a-z] c
+    =^\[A-Z]
     You must use instead one rule for each member of the mask:
-    =0a c
-    =0b c
+    =^A
+    =^B
+    =^C
     ...
-    =0z c
+    =^Z

 2) The next conditions are not working (JBrute just ignore it for compatibiliry reasons):
     -c reject this rule unless current hash type is case-sensitive
@@ -23,6 +24,14 @@
     M  memorize the word (for use with "Q", "X", or to update "m")
     Q  query the memory and reject the word unless it has changed
     XNMI   extract substring NM from memory and insert into current word at I
+
+4) The next Insert/delete commands are not working (JBrute will tell you that it is an invalid action)
+    \[ delete the first character
+    ]  delete the last character
+    DN delete the character in position N
+    xNM    extract substring from position N for up to M characters
+    iNX    insert character X in position N and shift the rest right
+    oNX    overstrike character in position N with character X

 Some examples:
 --------------
@@ -45,4 +54,9 @@
 **For the complete list of options, please refer to the "John The Ripper" rules syntax:**
 http://www.openwall.com/john/doc/RULES.shtml

+**You can always check your rule conditions/aplications with the next command:**
+$ ./jbrute.sh --decrypt --method=dictionary --dict_file=words.txt --rule_file=rules.txt --stdout
+
+Note: JBrute will not try to decrypt, it will just read the dictionary file "words.txt" and process it with the specifies rules on file "rules.txt".
+
 **If you found a functionality that is not implemented (except the mentioned limitations), or it is not working as expected, please tell me and I will be happy to correct it.**

Rules Examples modified by chalo

chalo — Thu, 05 Sep 2013 20:33:57 -0000

--- v2
+++ v3
@@ -19,6 +19,10 @@
     -s reject this rule unless some password hashes were split at loading
     -p reject this rule unless word pair commands are currently allowed

+3) The next actions (memory access commands) are not working (JBrute just ignore it for compatibiliry reasons):
+    M  memorize the word (for use with "Q", "X", or to update "m")
+    Q  query the memory and reject the word unless it has changed
+    XNMI   extract substring NM from memory and insert into current word at I

 Some examples:
 --------------

Rules Examples modified by chalo

chalo — Thu, 05 Sep 2013 20:08:48 -0000

--- v1
+++ v2
@@ -1,6 +1,27 @@
 Rules Examples
 ==============
+Intoduction
+------------

+Rules are similar to "John The Ripper" rules, with some limitations:
+1) There is no support for masking
+    So, if you want to use the next JTR rule:
+    =0\[a-z] c
+    You must use instead one rule for each member of the mask:
+    =0a c
+    =0b c
+    ...
+    =0z c
+
+2) The next conditions are not working (JBrute just ignore it for compatibiliry reasons):
+    -c reject this rule unless current hash type is case-sensitive
+    -8 reject this rule unless current hash type uses 8-bit characters
+    -s reject this rule unless some password hashes were split at loading
+    -p reject this rule unless word pair commands are currently allowed
+
+
+Some examples:
+--------------
 **Use a word as is**
 -:

@@ -15,3 +36,9 @@

 **Capitalize the word and insert at the beggining the '9' character if it length is grater than 3 and it starts with 'c' character**
 \>3 =0c c ^9
+
+
+**For the complete list of options, please refer to the "John The Ripper" rules syntax:**
+http://www.openwall.com/john/doc/RULES.shtml
+
+**If you found a functionality that is not implemented (except the mentioned limitations), or it is not working as expected, please tell me and I will be happy to correct it.**

Rules Examples modified by chalo

chalo — Thu, 05 Sep 2013 19:38:21 -0000

Rules Examples

Use a word as is
-:

Capitalize the word
-: c

Capitalize the word and insert at the end the 'r' character if it length is grater than 5
>5 c $r

Uppercase the word if it length is grater than 5
>5 S

Capitalize the word and insert at the beggining the '9' character if it length is grater than 3 and it starts with 'c' character
>3 =0c c ^9