Dec 072017
ShroudIt! source code shrouder v1.0, works for any programming language.

Full Description of File

ShroudIt! source code shrouder v1.0, works
for any programming language. MUST HAVE tool
for any serious professional programmer.
Allows you to protect your source code,
provide protected toolkits and libraries,
port source across platform on customers
site, and so on. Patent pending templating
works for 'C', Pascal, dBase, BASIC, COBOL,
SQL, Prolog, PERL and more. Tutorial and
manual provided on disk.

File SHRDIT01.ZIP from The Programmer’s Corner in
Category Miscellaneous Language Source Code
ShroudIt! source code shrouder v1.0, works for any programming language.
File Name File Size Zip Size Zip Type
!README 65 62 deflated
BASIC.ZIP 766 668 deflated
COBOL.ZIP 1443 1158 deflated
DBASE.ZIP 871 782 deflated
DESC.SDI 37 36 deflated
EXAMPLES.ZIP 1797 1678 deflated
FILE_ID.DIZ 424 270 deflated
HINTS 2049 1021 deflated
INTRO 1029 527 deflated
INTRO.EXE 146000 65755 deflated
INTRO.POP 1530 664 deflated
LICENSE 2521 1285 deflated
LOAD.C 1160 550 deflated
LOGO 497 193 deflated
ORDER 2086 701 deflated
OVERVIEW 1342 389 deflated
PACKING.LST 1843 429 deflated
PASCAL.ZIP 1368 1210 deflated
PERL.ZIP 1088 940 deflated
PROLOG.ZIP 2749 2487 deflated
SH-C.CPY 487 79 deflated
SH-C.CTL 1020 580 deflated
SH-C.GLB 34 34 stored
SH-C.INC 20 19 deflated
SH-C.KEY 907 450 deflated
SH-C.OBS 117 87 deflated
SH-LOW.CTL 709 436 deflated
SH-LOW.KEY 907 450 deflated
SH-SQL.KEY 386 234 deflated
SHROUDIT.DOC 37817 12979 deflated
SHROUDIT.EXE 181520 79651 deflated
SHROUDIT.PRO 55835 15136 deflated
SHROUDIT.SHR 17513 4699 deflated
VENDINFO.DIZ 22153 8947 deflated

Download File SHRDIT01.ZIP Here

Contents of the SHROUDIT.DOC file

S h r o u d I t ! U S E R S G U I D E

Table of Contents

1 Introduction

2 ShroudIt! Features

3 Technical Overview

4 Setting up

5 Control parameters

6 Command line

7 Cross-reference Map

8 Technical Support

9 Appendix

Error codes
License & Warranty


ShroudIt! is designed to be used whenever you are concerned that the
security of your original work could be compromised or you want to
protect your intellectual property. ShroudIt! uses a patent pending
rule based system implemented in Prolog that allows you to obfuscate
practically any part of your original work. The obfuscation changes
your original so that a human reader is unable to discern the sense or
meaning, but the computer interprets it EXACTLY equivalent to the

All the features and techniques are controlled by externally definable
rules, so the entire process can be tailored to a specific target
source language of your choice. Of course we cannot guarantee that
ShroudIt! will work with absolutely any source, but with careful tuning
it should cover most of the major language systems in use today.

The degree of obfuscation consists of three distinct levels. At the
base level the core scrambling is achieved by replacing all variables by
meaningless random strings instead. Additionally any text inside
comments is discarded. This level of obfuscation will work with almost
any language.

The next level allows you to expand any copy book or included source code
in-line into the main source body. In addition you can replace any
numeric or string constants with tokens instead. This is done by
declaring the tokens to be equivalent to the number or text, and the
text can be optionally written as raw ASCII codes if the target language
supports this.

The final level both compresses the source and replaces keywords with
random tokens. Again this is only possible where the target language
syntax is not dependent on line numbers and white space (or end of line)
significance, and has some kind of macro or pre-processor facility.

You can use the INTRO program provided to review an example of each
level when used against a small sample 'C' language source program.

The key to successfully using ShroudIt! is to customize the rule set
to match your requirements. Several examples are provided for you to
work from. The strength in this method is that you can set ShroudIt! to
skip over any special language extensions such as embedded SQL, or key
external routines with specific syntax. Of course you may conclude that
this would limit the level of obscuring in the process, but there is
nothing to stop you not only obscuring your source code, but also your
database tables as well!

Once you deploy your secured system, ShroudIt! provides you with MAP
files which cross reference between the original source and the
obfucated text. These facilitate providing debugging and support for
the deployed system.

As with any process you need to determine a balance between your
business goals and technical needs. ShroudIt! provides a tool which
gives you more options in achieving that balance.

Some extra business support functions that ShroudIt! includes are
automatic prefixing of copyright notices to source, along with copy
branding. The branding works by automatically generating a serial
number using a hash scheme. You provide the name of the end user and
this is hashed to produce a serial number. This serial number is then
used to seed the random number generator. Doing this means each
resultant source output is uniquely identifiable, even if your original
files are tampered with or incorporated into other source.

The following section summarizes the feature set that ShroudIt! provides.

ShroudIt! Features:

ShroudIt! features can be divided into three distinct levels. Each
level is shown, first with the key functions performed, then followed by
the main components that allow this, and after that special control
parameters that specify the exact details.

Level One - (base level)

- Variable name substitution and comment stripping

- Components
Language key words dynamically definable
External and global function key words dynamically definable
Comment syntax dynamically definable

- Parameters
Regular line, complex nested, or simple block comments
Compiler directives handling
Minimum length for random names
Join character for name tokens
Repeated use of name across code blocks obfuscation
Code block delimiter tokens
Registration and serial number branding
Random number seeding control
Duplicate token name checking
String text delimiters
Continuation line syntax

Level Two - (extended level)

- Include file expansion, number and string constant replacement. (Supports
use of includes within includes to any depth).

- Components
Include or copy book language syntax definition
Language syntax for replacing numbers and strings

- Parameters
Supports compiler environment variables for include file paths
Optionally exclude certain system includes or copy books
Language syntax for ASCII code substitution

Level Three - (maximum level)

- Source compression and language keyword substitution

- Components
Language key words dynamically definable
External function key words dynamically definable
Include or copy book language syntax definition

- Parameters
Compression line length
Compression exclusions
Continuation line syntax
Randomly generated replacement names
Occasional special token replacement

Finally as needed you can use the in-line &&ShroudIt! parameter to pass
on the fly instructions to the shrouder at critical points within a
particular source file. These override the default values specified by
the parameter rules.


As a company we develop custom AI and Image Processing solutions and
integrate them into traditional application systems.

ShroudIt! was developed to protect our own source code library on a Sun
UNIX system for a CNAPS massively parallel processor. The CNAPS has its
own unique dialect of C and as yet no object linking capability. Our
patent pending LNK_ImageLib graphical image processing product used in
combination with the CNAPS processor gives a stunning improvement to
automated satellite imagery processing. What used to take 8 hours to do
on a high end RISC workstation, can now be done in real time in under 3
minutes. We would be happy to discuss any image processing needs you
have too.

As an example of our confidence in ShroudIt!, you can find the
obfuscated Prolog source code included along with the other system

Just a reminder that our licensing terms allow you to work with
ShroudIt! free of charge for up to 60 days. However, at the moment that
you distribute product created using ShroudIt! you must have purchased
an applicable license from LNK Corporation, Inc. See ordering details
in the ORDER file accompanying this document, and in the Appendix also.

Technical Overview:

ShroudIt! allows you to distribute program source code so that it can
be compiled, but not re-engineered. The code itself is masked to
obscure the content from the human reader, while allowing a compiler to
re-produce the exact equivalent executable to the original source.

This product is designed to work with various 3GL block structured
languages. It has been tried with C, Pascal, Basic, dBase, Prolog, Perl
and COBOL. In addition it should work for C++, Ada, PL/1, and others

Note: You must ensure all code clean compiles with the native compiler
BEFORE attempting to use ShroudIt! on that source.

The design allows you to specify the language key words and global
functions, and also to set various control parameters specific to
the program you wish to obfuscate.

Sets of key words are provided as examples. (You must produce your own
specific to the particular source code and compiler you are using).

A shrouded word map cross-reference is produced, along with line numbers.
This allows you to support your code when users report bugs. You should
NEVER provide your end-users with this map!

Always check the MAP to make sure no language key words have been overlooked
from the .KEY parameter file. (If your compile fails on an undefined word
this is the first thing you should check).

You can optionally provide a copyright notice to be prefixed to your code.

Also, the shrouder can use a hash count from a company name string to seed the
random number generator. This means each copy can be custom produced with
a serial number, and will be unique to each customer.

Setting up:

Shrouder will run in two modes, interactive, or batch. The -b command
line parameter forces batch mode processing.

Shrouder expects its control files to be called "sh-xxxxx.ttt", where xxxxx
is the name of the language you are using. 'ttt' is an extension depending
on the type of information in the control file. I.e.

ctl - control parameters that control execution.
key - language key word list

glb - optional, global names that should not be obfuscated, or exact
obfuscated name for global names.

inc - optional, include files to be EXCLUDED from in-line expansion into
obs - optional, obscure list, useful for generic variables like i,j,k, etc.
cpy - optional, copyright notice, will prefix all output files.
dir - optional, compiler directives to be scanned as is.

You can therefore create different sets of files in different directories
to tailor the shrouding required for each set of code files. (You can also
embed inline control parameters in the code. To do this place an &&ShroudIt!
token immediately before the actual parameter, and make the line a comment).

ShroudIt! searches for control files in the following places, the location
of the input source code; the current directory; the executable location.
This allows you to place control files to override the default set as
you need.

You will notice that the supplied key word and global lists contain only
single columns. If you add a second column, separated by a comma,
shrouding will use the word in the second column as the replacement
token. This is useful for global functions that you wish to obscure,
but must be consistently named. (When loading keywords or globals
ShroudIt! ignores subsequent duplicate entries in your list).

Optionally you can set the DEFINE GLOBLS switch in the control file,
then the program will automatically assign DEFINE statements for these
globals along with a randomly generated name. The same can be done for
language keywords if the language supports such substitutions. (See
notes below for further ideas). Note that the program scans for
duplicate entries while loading these parameters and ignores subsequent
entries for the same key word or global. Key words are loaded first.

These substitutions will be written to an include file. The include
file is given the file extension .SHR, and the name from the output file
specified. You can also direct that numeric or string constants be
defined into the include file, and replaced in the original code by a
random token instead.

Control parameters:

Each line in the control file sets a particular parameter.
The basic format is: CODE WORD: Value1,Value2

Value2 is optional.

Those familiar with C and Pascal will recognise various language
characteristics. A "%" in the first column indicates a text comment.

Below is a sample of control parameters for C language shrouding.

% These parameters control string processing
CHAR: ','

% These parameters control name substitutions

% Comment delimiters
COMMENT: /*,*/

% Include file handling
INCLUDING: #include,<>
INCLUDING: #include,""
REPLACE NUMBS: #define ,

% Random name generation and miscellaneous
REGISTRATION: R&D,, LNK Corporation, Inc, Riverdale, MD.

The random seed should be set off if you want SHROUDER to generate exactly
the same names each time. This is useful when you are de-bugging code
changes, and you need to compare the output from two different runs.

Obscuring names:

This feature is designed to mask your use of common variable names such
as i,j,k, etc, across all of your code. Use "OBSCURE NAMES: No" if you
want to disable this feature. Otherwise, provide the block START and
END delimiters. (For Prolog these would be : and ., for Pascal they
would be BEGIN and END) You then also need to list variables in the .OBS
control file. Processing will then replace these variables uniquely
within each new block of code. So if you habitually use i, j, and k for
integer loop counters, you can obscure this by making them different
within each new code block. Of course, you should also use the "KEEP
LENGTH" option to ensure unique names.

Keep Length:

If this parameter is set on, then you must supply a length. This is a
minimum length. Any variable names less than this length will be expanded
to be this number of characters long. Any longer names will be unchanged.

Command line:

The format is:

SHROUDER Infile Outfile Language [-b]


SHROUDER Infile OutMask Language [-b]

Provide the mask in the format *.ttt, where ttt is the extension you
want. The * will be replaced with the name of the input file. This makes
batch file runs for SHROUDER easier to write.

The optional -b parameter suppresses the interactive display so only the
batch messages are produced.

Include file processing supports use of environment variables to
specify search paths. The default is the INCLUDE environment variable.
You may also use SHROUD environment to point to another variable, which
itself contains a valid path. I.e set TEMP=c:\dos;c:\temp;c:\include and
set SHROUD=TEMP which will allow ShroudIt to find includes pointed to by
the TEMP path.


- Program does not handle "/* */", i.e. comments within a string.
This is a design decision, since such a combination is rare.
If you must have these, manually change the /* */ to something else
before shrouding, and switch them back after. If shrouding fails with
only part of the original source written, you should check for this
problem. Also line comments contained in text string delimiters without
a matching terminator can also cause problems. I.e. " //
or // ' on a line without the second delimiter.

- Comment checking assumes a space after the comment symbol, so if comments
are retained in the obfuscated code, adjust the comment in the original
by adding a space accordingly. I.e. //This comment, becomes // This comment.

- String delimiters within comments, such as ' or " can sometimes cause
miss matching in string handling. You will notice that parts of the
code are not obscured, and string text is. Correct your source code
by removing ' or " from within your comment.

- Duplicate word check is done for names less than the default length.
This means that there is a finite chance that some words
could collide with language keywords or other variables. If you
suspect this, just re-run the shrouding again, after altering the
duplicate check parameter in the CTL file.

- Case sensitivity - sometimes the Shrouding can be more rigorous on this
than the compiler - foreinstance some Prologs will accept KeyWord and
Keyword as the same token, since the case sensitivity is triggered off
only the first letter (constants start with lowercase). This is easily
corrected by setting the CASE SENSITIVE: No, which will treat all tokens
as upper case. Alternatively, you can also just spell tokens exactly
the same where necessary. I.e. change Keyword to KeyWord, and so on.
In function declarations it gets crazier as string and STRING are
treated the same. To get around this manually specify a shrouded name
in the KEY word file. i.e.
Turbo Pascal and BASIC also play this same game! (Setting CASE SENSITIVE
to No for BASIC makes sense, since most people usually code key words
as caps).

- Dbase and xBase programs - calls to external programs use the OS code
file name as a cue. Therefore you need to put the list of such globals
in the global control file. An easy way to do this is to use the DOS
command ==> dir *.prg > mylist Then cut and paste the list using an
editor. To add further confusion you may want to create random names
for these files, and then create a batch file to rename the program
files themselves. (This is best done in a separate directory which is
used for shrouding only!)

- For C code that uses #ifdef #endif blocks which select different #includes,
you can simulate that this by putting the names of includes NOT to use
in the exclude include list. You can then have different sets of these
control files to match your ifdef settings. I.e SH-DOS.INC and SH-UNIX.INC,
and so on.

- C style <> include files will be automatically excluded, i.e. ,
and so on. This reduces the control file setup needed to handle C include
files. This behavior is controlled by the SKIP INCLUDE setting.

- dBase style includes which are actually called programs - there are
no name delimiters such as " or < >, so you need only specify a default
extension (such as .PRG) to cause the called program to be included.

- Compression - when using compression you can control when compression
starts i.e. don't compress until "void main" is reached, or optionally
skip compressing for every line with a particular keyword on it, such
as #define, or #undef. However you can only use compression for
languages that ignore white space such as C, and not with COBOL, etc.
Use the LINE CONTINUE parameter to suppress compression for lines with
continuation characters on them.

- PERL - there are three parameters specific to this language. PERL
allows use of strings and function parameters very differently to
other languages. ShroudIt! reverts to only obfuscating words proceeded
by the specified NAME TOKENs. It also looks inside strings for variable
names (normally the reverse is true). LABELS for the NEXT statement
should be obscured using the .GLB file, and specifying your own replacement
name. Care should be taken to choose labels that DO NOT conflict with
system variables such as FILE, DIR; i.e. Use FILEL: as label in your code.

Parameter Format:

TOKEN: [Parm],[Parm]

Where token is the keyword for the parameter, followed by a :, and Parm is
either Yes/No, or two values associated with the parameter.

Parameter Descriptions:

STRING: "," --- Start and end delimiters for string substitutions.
CHAR: ',' --- Start and end delimiters for single char substitutions.
SPECIAL CHAR: \ --- Escape character used for special char in string.

NAME JOINS: _ --- Char used for joining variables names.
KEEP LENGTH: No,6 --- Variables with names less than 6 bytes, expanded to 6.
Yes --- Length of names of variables is not changed.
CASE SENSITIVE: No --- When set to No, program treats all tokens as uppercase
when doing key word and global comparisons.
Tokens are written to .MAP cross ref' as uppercase.
Yes --- Default setting - program is case sensitive.
KEEP SEPARATORS: Yes --- Not implemented, intended to allow shuffling of names.
KEEP CASE: Yes --- Not implemented, program follows case as written.
MAX LENGTH: 31 --- Not implemented, program follows max length as written.
DUP CHECK: 5 --- Controls length at which duplicate name checking done.

LINE COMMENT: // --- Characters that signal rest of line is a comment.
LINE COMMENT: *,6 --- As above, except that second parm is number, look
only at this column within the line. This then
means COBOL style line comments will work.
COMMENT: /*,*/ --- Characters that signal start of comment block.
NESTED: No --- Switch that indicates if language uses nested comments.
OUT COMMENT: /*,*/ --- Comment delimiter to be used outputting from ShroudIt!
If second parameter is a number (i.e. *,6) then
assume COBOL style comments are required.
KEEP COMMENT: $ --- Use this if you have compiler directives inside
comments, and you therefore need to keep the comments.
Specify the token within the comment that indicates
a compiler directive. You can have more than one.

INCLUDING: #include,<> --- Special characters that denote including of code.
INCLUDING: #include,"" --- More than one type syntax is supported.
SKIP INCLUDE: <> --- Do not expand this type of include file. Use this
for C code to ignore library includes.

REPLACE NUMBS: #define &&name [&&numb|&&text] [&&len]
--- replace numeric constants with a define instead.
Special tokens hold the place of the variable,
its number or text value, and optionally its
length. (Languages like Cobol require you to
know the length of strings).
REPLACE STRGS: No, --- Replace string constants with a define instead.
STRING TO HEX: No --- If set to Yes, then string constants are output
as their decimal equivalents.

SEED RANDOM: Yes --- If set to No, then random seed not set, so each
run of shrouder will produce exactly the same
COMPRESS LINE: Yes,70 --- If Yes, compacts lines together, upto maximum
width specified, and strips off leading
whitespace. This may not work for all languages.
COMPRESS OFF: predicates --- Optional keyword, until this line found, do not
compress lines. (This is need for Prolog source).
COMPRESS OFF: another You can have more than one keyword to look for.
COMPRESS SKIP: #define --- Skips compression on line containing this word.
COMPRESS SKIP: #undef You can have more than one keyword to look for.
LINE CONTINUE: \ --- If last char on line, then don't compress as this
is a continuation.
LINE CONTINUE: \,End --- As above, but don't start compressing again till
one line after end of continuation!

REGISTRATION: Company Name --- Causes comments to be generated with this
detail in them. Also used to create serial
number (using a string hashing algorithm).
SERIAL NUMBER: L01-,IL-1 --- Text to prefix and suffix the hash number above.
OBSCURE NAMES: Yes --- Determines if global used names are obscured.
BLOCK TOKENS: {,} --- When obsuring names that are globally used, you
must specify the logical block start and end chars.
Also used by the procedure matching logic for the
cross-reference map.
FUNCTIONS OFF: main(void) - Optional keyword, until this line found, do not
start function mapping. You may have more than 1.
DEFINE CODE: #define &&name &&text [&&len]
--- source code syntax for the following defines.
DEFINE GLOBLS: Yes --- Global names are shrouded with random replacements.
DEFINE KEYWRD: Yes --- Language key words are shrouded with randoms.
DEFINE REPLACE: }, $_ --- Random (20% chance) replacement of char symbol to
confuse beautifier programs when code is compressed.
DEFINE REPLACE: ), x_Rqz You can have more than one replacement.

NAME TOKEN: $ --- PERL style variable naming, provide as many as
NAME TOKEN: & --- you need, more than one type syntax is supported.
ShroudIt! will ONLY obfuscate names prefixed with
the token specified. Also names inside strings
will be substituted. (See Notes above for more).

SKIP CODE: EOF,EOF --- Allows skipping of chunk of source code, based
on tokens provided, From token, To token.
Designed for PERL die< ....text...EOF syntax. Will also work for BASIC
style DATA statements.
COMMENT DIRC: #! --- PERL style compiler directives, will also work
for other languages that put directives inside
comments at the top of the program.

Cross-reference Map:

A obfuscated word map cross-reference is produced, along with line numbers.
This allows you to support your code when users report bugs. You should
NEVER provide your end-users with this map!

Always check the MAP to make sure no language key words have been overlooked
from the .KEY parameter file. (If your compile fails on an undefined word
this is the first thing you should check).

The map is organized into three sections:

Program Variables

The External/Global names are determined from your entries in the .GLB
file. All other tokens are stored with their line number occurances.

Line numbers are listed as is, without any attempt to line wrap them, so
in an editor you will have to scroll right to see the complete list.

The line number for source tokens within an include or copybook file are
listed as the line number of the include file within the main source code.

If you provide block tokens using the BLOCK TOKENS: parameter, ShroudIt!
will uses these to determine Procedure/Function/Sub-routine boundaries.

This capability can be helpful in clarifying the map listing. However,
because of the inherent differences between languages and coding styles,
leakage can occur, and entries can be transposed between the Program Variable
section. This is not a symptom of a 'bug', but merely the behaviour of the
method as currently implemented.

Future versions will look to improve in this area. Currently the results
will varying depending on the language and syntax you are using.

Generally when debugging using the MAP after shipping your product, you
merely want to search for a token to discover the real source code name.
The value of the separate sections comes mainly when you are doing the
original shrouding, and are cross-checking the results to obtain further
insights into the process.

Hint - output in the External/Global variables section can be cut and paste
back into the .GLB file to force substitution of the same obfuscated names
across the complete system. This saves you having to come up with random
names manually yourself.

Technical Support:

ShroudIt! has been designed to encourage you to experiment to find the
best mix of components to match your own source code. On the other hand
this process should also provide for a minimal number of physical changes
to the source itself. Obviously in a ten program system, this is not too
contentious, but in a 500 program system it is critical. This also
applies to pre- or post-processing by say editor macros to facilitate
ShroudIt! translation. You want to minimize that stuff.

Therefore you should carefully work through the user manual, the notes,
and your own inventiveness, but when all else fails you can reach us
through the following:


InterNet - [email protected]
Compuserve - 72030,1547





Be aware that all telephone calls are screened to ensure that you have
either tried E-Mail or FAX first, and that licensed customers have
priority on voice contact.

You should use E-Mail as your preferred contact, since the turn around
will be MUCH faster.

============== S h r o u d I t ! U S E R S G U I D E ====================

A P P E N D I X:

Exit Codes and Prolog Errors:

If ShroudIt! detects a processing error it will return the following
error levels to the operating system:

10 - Processing failed, invalid input parameters.
15 - Expected file was missing, none fatal error.
16 - Expected input file was missing, none fatal error.
21 - Processing failed, translation aborted for some reason.
17 - Expected include file was missing, none fatal error.
99 - Invalid integer value in compression length.

You may also experience Prolog errors, 7000 level errors are system
level errors, usually due to missing files, or invalid file i/o.
Here is a sampling of the more common system related errors. The
first thing to try is to increase the amount of available free memory
available by unloading any unnecessary utility programs.

Below is a sampling of common error messages due to system problems.

1001 Gstack overflow. Not enough memory or an endless loop.
1002 Heap overflow. Not enough memory or an endless loop.
1008 Memory initialization failure.
This indicates severe shortage of memory. The program is unable
to start execution.
1010 Stack overflow. Not enough memory or an endless loop.
1020 Trail overflow. Not enough memory or an endless loop.

1101 Attempt to open an already open file.
1103 Attempt to assign output device to a file that is not in writemode.
7003 Path not found
7005 Access denied
7008 Insufficient memory
7019 Disk write-protected
7021 Drive not ready
7029 Write fault
7030 Read fault
7032 Sharing violation
7112 Disk is full

Legal Terms and Conditions of use:

ShroudIt! and its related programs are NOT public domain or freeware!
The Shroudit! package is a copyrighted software product developed and
owned by LNK Corporation, Inc, with patent application pending.
This software and accompanying documentation are protected by United
States copyright law and also by international treaty provisions.

The ShroudIt! product is provided on a 60 day evaluation. However to
distribute the obfuscated source code that ShroudIt! produces you MUST
obtain a license agreement from LNK Corporation Inc.

Refer to the ORDER form enclosed in the ShroudIt! documentation for
details of the different licenses available. All payments must be in
U.S. dollars.

Upon receipt of your license fee, a signed license agreement for
distribution of products created with ShroudIt! will be sent to you. In
addition, you will be entitled to technical support and future releases
at a reduced price.

You may not use, copy, rent, lease, sell, modify, decompile,
disassemble, otherwise reverse engineer, or transfer the licensed
program except as provided in this agreement. Any such unauthorized
use shall result in immediate and automatic termination of this license.
All rights not expressly granted here are reserved to LNK Corporation,

Shareware disk distributors, computer user groups and computer bulletin boards
may distribute the unlicensed version of ShroudIt! without a distribution
license provided the ShroudIt! package is not modified, and a fee not to exceed
$15 is charged for such distribution.


The following may distribute ShroudIt!, completely unaltered, without
further permission...; for other cases or to distribute in modified
form, you must consult the attached data record, which is hereby
incorporated by reference. Any distribution satisfying all the
distribution requirements expressed in that data record is hereby

Permission to distribute the ShroudIt! package is not transferable,
assignable, saleable, or franchisable. Each vendor wishing to
distribute the package must independently satisfy the terms of this
limited distribution license.

U.S. Government Information: Use, duplication, or disclosure by the
U.S. Government of the computer software and documentation in this
package shall be subject to the restricted rights applicable to
commercial computer software as set forth in subdivision (b)(3)(ii) of
the Rights in Technical Data and Computer Software clause at
252.227-7013 (DFARS 52.227-7013). The Contractor/manufacturer is
LNK Corporation, Inc, Riverdale, Maryland 20737.

LNK Corporation, Inc may revoke any permissions granted here, by
notifying you in writing. All rights not expressly granted here are
reserved to LNK Corporation, Inc.



This agreement shall be governed by the laws of the State of Maryland
and shall inure to the benefit of LNK Corporation, Inc. and any
successors, administrators, heirs and assigns. Any action or proceeding
brought by either party against the other arising out of or related to
this agreement shall be brought only in a STATE or FEDERAL COURT of
competent jurisdiction located in Prince George's County, Maryland. The
parties hereby consent to in personam jurisdiction of said courts.

Ordering Form:

============ License Agreement for ShroudIt! Software use =================

This product is provided on a 60 day evaluation. However to distribute the
obfuscated source code that ShroudIt! produces you MUST obtain a license
agreement from LNK Corporation Inc.

Two categories are used for license pricing which are determined on
the following basis:

Category A - one time usage for personal or small business use, or any
use for product distribution as shareware or freeware.

Category B - all other commercial uses.

Once you are ready to distribute the obfuscated source code, complete
and sign two copies of this form and return it to LNK Corporation, along
with your payment. Your original will then be signed and returned to
you and LNK will retain the second copy.
--------------------------------- ### -------------------------------------

License agreement between _________________________________________ and
LNK Corporation, Inc, of Riverdale, Maryland is for distribution of
Category ___ product(s) as determined above.

The license is valid until terminated by either party, and subject to
the laws of the state of Maryland.

A license fee of $ _________ is payable in advance.

Category A - $90.00, Category B - $190.00

Signed by and date _____________________________________________

Name and Title _____________________________________________

for and on behalf of ___________________________________________



Signed by and date _____________________________________________

Name and Title _____________________________________________

for and on behalf of LNK Corporation, Inc,
6811 Kenilworth Avenue,
Suite #306,
Riverdale, Maryland, 20737.

--------------------------------- ### -------------------------------------

 December 7, 2017  Add comments

Leave a Reply