I’m sorry for making such long posts, but need to convey the ideas somehow heh
I’m not intending on stealing the thread either, it just looks like it

, as these are mainly ideas for Agito to put into simply uplink, I am just going into detail in how I think it should work - i can't help it i over think things
Take a look at this picture.
http://members.lycos.co.uk/pid4x/Files/gui1.JPG
It shows possible ways the compiler could work for building these programs, anyone else have any other thoughts at all?, even if you hate the idea all together?
The high level way would resemble how it’s done in the movie sword fish, as well as described in the dev bibles, don’t know if its even legal to copy the ideas from sword fish, like the blocks breaking apart and flying, I am guessing it probably isn’t
It would also require a fair amount of programming opengl / graphical stuff, so I think the ‘realistic’ approach is better.
The 'realistic' approach would work like this:
"code work space" looks like this when we first open the compiler:
void main()
{
}
Then when we add components it changes.
Lets say we add spreader version 2 and proxy bypass v5, it would show something like
void main()
{
Spreader = new SpreaderVx();
proxBypass = new ProxybypassVx();
%display pesudoC here%
}
and so on for each component added - it shows component type & version for each component
While we are adding components we will display pseudo code that resembles c, we can guess what type of pseudo code to show depending on the components added:
if it has rootkit module, then we can guess its going to be a root kit
if it has a spreader, then chances are where making a worm....etc
so the 'code workspace' will display a string like this
codeWorkspaceString = header + pesudoC;
Where pesudoC is just a string of mock c code to resemble the type of program we are building... and header is the "void main()" and a list of variables for the components we added....
When we compile it asks for any arguments to give to the compiler, and then starts, if we are successful a new program is added to the memory bank.
Say the standard arguments are this "compiler -o *filename*" - where *filename* is the name to save to. (gcc anyone?

)
The 'debug output' shows any errors in error lines like:
"%component& is depended on: &component%,..."
"%component% can not be used with %component%"
"%component% is already included, %component% is not needed"
etc...
e.g.
"Bouncer is depended on: LogModifierV4, ProxyDisabler, FirewallDisabler"
"SpreaderV2 can not be used with RootKit"
"ProxyBypassV5 is already included, ProxyDisableV4 is not needed, to include it anyway pass '/incDepComp yes' to the compiler"
(including 'depreciated' components could be another trick used to make the same worm again, but with a diffrent signature, but now that secret is out

)
When it is saved, should each component reguardless of versions etc, take 1 block of memory?
also the use of a 'packer' to 'pack and compress' our compiled program to reduce it to a few blocks
e.g.
if(numBlocksUsed > 4)
{
numBlocksUsed = (numBlocksUsed % 4); //mod 4
}
The effect could be faster transfer (obvously), also decrease the chances of it being found, and give it a diffrent signature. Maybe having 4 or 5 'packing/compression routens' that you can choose with arguments that you can output the same compressed program, with upto 4 or 5 diffrent signatures.
Edit: Or if you pack the program it has a higher chance of being found with as a 'default virus' so users would need to either use one of the 4 or 5 default packing strings, or get there own to make it totaly undetectable untill the standard 'new virus found in the wild' events happen.
This could work on a simple serial generator / check bit concept like a valid 'packing algorithm' could be testing using a forumla similar to this (VB code).
packString = "1234-5678-1234-8146"
subSA = Mid(packString, 1, 4)
subSB = Mid(packString, 6, 4)
subSC = Mid(packString, 11, 4)
subSD = Mid(packString, 16, 4)
' Whatever u mod it by determins the amount of valid packing strings,
' and there for, the amount of signatures each worm could possibly have.
checkbit = ((subSA + subSB + subSC) Mod 9999)
If subSD = checkbit Then
'valid packing string
MsgBox "valid"
Unload Me
Else
'invalid packing string
Unload Me
End If
so now a compiled virus/worm's signature would be made up of
signature = "names of compiled components and versions" & other & packingString
("other" = all the other things that make up the signature that i mentioned in previouse post)
A possible way to keep track of it all would be to save the actual programs to a file either by sterilizing the object to a file, or plain text config file (an ini?), this would also allow people to make apps in external programs (like notepad) and share programs with other people they have made.
All that would be needed then is some checking to see if the player has all the needed components and fail if they don’t, when they load someone else’s 'source code'.