Start menu




Open...

Opens an Excel file.

Any existing auto–procedures are NOT performed.

The most recent Excel file is preset and can be opened immediately.

Files with password protected VBA projects (source–code)
or those which do not contain a VBA project cannot be processed.

CrunchCode supports the following file types:

xlsm Excel workbooks with macros
xls Excel–97–2003 workbooks
xlsb Excel binary workbooks
xltm Excel templates with macros
xlt Excel–97–2003 templates
xlw Excel–4.0 macro workbooks

Add–ins (*.xla*) cannot be processed directly.

CrunchCode saves all options, values and states for each project.
In the case of a new project selection, they will be restored individually.
Except for the CrunchCode options (see below) all settings are only for the current project.

   Important note!

   CrunchCode saves these options and values in a data file of type  *.cci

Excel file: nnnn.xlsm
Data file: nnnn_xlsm.cci

   The stored data includes the folder and name of the Excel file; these are of crucial importance.
   If the Excel file is renamed or relocated, this association is lost
   and thus all previous settings and options are lost!

   If you want to rename the Excel file or change its location,
   then please you do the same with the data file!

   In this way, the settings from previous sessions are maintained.


   Tip!

   If you want to use the entire settings of a project for another project,
   then copy the data file of the previous project and rename it.

old_xlsm.cci ––> new_xlsm.cci


In addition, in the folder of the Excel file a sub folder will be generated
named "_CrunchCode\<Excel–file–name>."

Example:
Project: D:\VBA\myproject.xlsm
CrunchCode folder: D:\VBA\_CrunchCode\myproject.xlsm\Debug\...

There are:

– the backup(s) of the Excel file (for possible restoring)
– text files with the original contents of all VBA modules of the project
– text files with the processed VBA modules of the project
– all from CrunchCode during the program execution created lists

DO NOT DELETE THE DATA IN THIS FOLDER MANUALLY!
Otherwise your project cannot be reset.
(use for this "Project... –> Settings –> Delete")

ALWAYS BACKUP YOUR PROJECT!
CrunchCode has numerous safeguards to prevent data loss.
However, absolute security cannot be guaranteed.


Project...

Allows the following operations for the currently selected VBA project:

– Reset to its original state
– Displaying reports from the previous processing
– Viewing the working directory
– Export and import of VBA modules
– Retranslation of camouflaged identifier
– E–Mail support
– Deletion of temporary project data

If this button text is red, the project has already been processed
and must be reset to a previous state before the next treatment.
Possibly also required a repair.

TIP: With CrunchCode you can also edit VBA modules
that are exported from other programs:

– create a new blank Excel file
– load the required modules into this file using the import function
– save the Excel file
– process the VBA project with CrunchCode
– save the processed VBA modules using the export function

For more details refer to the help for "Project".


Close

Closes the selected Excel file.

Any auto–procedures are NOT performed.

You can also trigger this action with the DEL key.


Processing level

Desired processing level for the VBA project of the selected Excel file.
The processing steps build upon each other and cannot be selected independently.
Each level increases the degree of camouflage.


Analysis

If you select this level, the code is only analyzed.
You will get project statistics, a detailed list of all identifiers,
strings, and constants and a list of problems found
(this requires the syntax of the project be correct, see below "Changing code structure"!).

It is recommended that this option be run first, to ensure the code
is correct before continuing to the next steps.

In addition all strings are listed.
So you have a specified basis for the options and their camouflage.

This analysis is the lowest level. It cannot be deactivated,
because it is a necessary part of subsequent levels.

Deleting comments

Elimination of all comments.
Resulting empty lines are maintained.

Deleting blank lines/spaces

Elimination of all blank lines and consecutive spaces in VBA code
(spaces within strings are not changed).

Deleting block structure

Elimination of the typical indentations (block structures).
This step alligns all the text lines to the left which reduces the readability of the code.
It makes it harder to identify code blocks (If...End If, etc.)

Changing code structure

It reduces the readability of the code and recognition of structures by:

– insertion of meaningless line breaks ("xxx _")
– arbitrary combination of several statements in a row ("xxx: yyy: zzz")

-------------------------------------------------------------------------------------------------------------------------
Warning!

From this level on, the SYNTAX of the project must be absolutely correct!

CrunchCode does not check the syntax.
Use the VBA editor menu "Debugging –> Compiling VBA project"
to check the syntax before processing.

From this level on, the changes to the source text are
so extensive that it is not possible to process code to a higher level
that has already been partially processed. Instead it is necessary to
reset the project ("Project –> Recover").
-------------------------------------------------------------------------------------------------------------------------

For more details refer to help for "Changing code structure".

Camouflaging names/project

Replacement of all identifiers for variables, procedures, modules, etc. with random names.
This means that the source–code can no longer be followed by sight.
The code can only be understood with very meticulous effort, line–by–line.
Meaning and content of variables, procedures, etc. is extremely difficult to detect.

This intervention does not affect the speed of the program.

In addition, you can protect the VBA project against manipulation.

Notes:

– CrunchCode also camouflages the names of modules!
  The camouflage is limited to the VBA part of the Excel file.
  Named ranges, worksheet registers, formulas etc. will NOT be camouflaged!

– In UserForm modules the names of the controls are camouflaged,
  but NOT the captions within them. This is because their function can usually
  be worked out from the arrangement of elements within the UserForm.
  If such elements need to be camouflaged, this must be implemented using special
  programming techniques (e.g. by generating them at run time).
  Alternatively CrunchCode offers the option to hide the content of UserForms
  in the VBA editor (see "Camouflaging names/project" –> "Masking of UserForms in VBA editor").

– VBA keywords CANNOT be camouflaged.
  (e.g. "Application", "If...Then...Else" etc.)

For more details refer to the help for "Camouflaging names/project".

Encrypting strings

Cryptographically coding of all strings.
This obscures particularly sensitive code areas (such as a password prompt),
so that it cannot be located by "Find".

All coded strings are stored within constants then decoded
into plain text during runtime.

------------------------------------------------------------------------------
Note: The additional work required by the decoding can
in some cases slow program execution!
------------------------------------------------------------------------------

Captions of UserForm elements are NOT camouflaged
(see above "Camouflaging names/project").

For more details refer to the help for "Encrypting strings".

Additional procedures

Relocation of suitable source–code lines into new procedures or functions.

This step makes it difficult to follow the VBA code. Each new branch into a procedure
interferes with the identification of the context.
The procedures also contain pseudo–parameters in order to further disguise the meaning.

The calls to the new procedures during runtime
have little affect on the speed of the program.

NOT be relocated are lines that

– refer to local variables
– relate to the surrounding procedure (handover of function values??)
– are  basic parts of a statement block (e.g. If...End If  oder  With...End With)
– are within conditionally compiled blocks (#If...#End If)

Note: For complex projects, this feature takes a long time to process.

With very large projects, this processing step can be omitted
because such code is typically complex anyway.

For more details refer to the help for "Additional procedures".


CrunchCode options

Settings that influence process and use of the program.
These are global, thus independent of the active VBA project.


Start

Starts the processing of the selected project with the specified settings.

Was the project already processed, or occurred errors during a previous processing,
then the project is previously reset to its initial status.


Debug mode

Prevents certain processing steps to enable the analysis of specific problems.

The settings selected may result
in syntax or runtime errors.

Example: In the source–code the command

Application.OnKey  "{F1}",  "Hilfe"

assigns procedure 'Help' to the F1 key.

The settings for camouflaging identifiers has specified
that the names of procedures are to be camouflaged.

However, it was forgotten to indicate that such names
also appear in character strings.

This would result in a runtime error because the procedure name 'Help' is camouflaged,
but the word "Help" still occurs within the character string.

In a fully camouflaged source–code, however, the effect of these settings
cannot be recognized. To enable this, the text must must remain readable as far as possible.

For this mode, the following processing–steps are modified:

– Deleting blank lines/spaces: is skipped

– Deleting block structure: is skipped

– Changing code structure: is skipped

– Camouflaging names/project: * code names are not generated randomly,
but derived from the original name
by adding of a unique identification number:
"OriginalNameO00001"

(by CrunchCode poss. additionally generated identifiers
 get names of the form "O00001")

– Additional procedures: Source–code lines, they have been relocated into additional
procedures, will be preserved as comment and get the marker
'>

Before the processed VBA modules are copied back into the project,
CrunchCode saves each module as a text file in the folder
"_CrunchCode\<Excel–file–name>\Debug",
which is located in the Excel file folder.

Example:
Project: D:\VBA\myproject.xlsm
CrunchCode folder: D:\VBA\_CrunchCode\myproject.xlsm\Debug\...

Should errors occur when the modules are copied back,
these text files can indicate possible causes.

The Debug mode is effective only from the processing level "Camouflaging names/project".

--------------------------------------------------------------------------------------------------------------------------------------------

* Note: The effective length of camouflaged names is limited to 31 characters.
Longer names will be truncated to this length.

Example: before: ThisIsAVeryLongIdentifierName
after: ThisIsAVeryLongIdentifierO00001