EmbLogic's Blog

Why Linux Is More Secure Than Windows
Article posted by——Rana Brijendra singh

“Security through obscurity” may be a catchy phrase, but it’s not the only thing that’s catching among Windows users.
The expression is intended to suggest that proprietary software is more secure by virtue of its closed nature. If hackers can’t see the code, then it’s harder for them to create exploits for it–or so the thinking goes.
Unfortunately for Windows users, that’s just not true–as evidenced by the never-ending parade of patches coming out of Redmond. In fact, one of Linux’s many advantages over Windows is that it is more secure–much more. For small businesses and other organizations without a dedicated staff of security experts, that benefit can be particularly critical.
Five key factors underlie Linux’s superior security:
1. Privileges
Linux systems are by no means infallible, but one of their key advantages lies in the way account privileges are assigned. In Windows, users are generally given administrator access by default, which means they pretty much have access to everything on the system, even its most crucial parts. So, then, do viruses. It’s like giving terrorists high-level government positions.
With Linux, on the other hand, users do not usually have such “root” privileges; rather, they’re typically given lower-level accounts. What that means is that even if a Linux system is compromised, the virus won’t have the root access it would need to do damage systemwide; more likely, just the user’s local files and programs would be affected. That can make the difference between a minor annoyance and a major catastrophe in any business setting.
Social Engineering
Viruses and worms often spread by convincing computer users to do something they shouldn’t, like open attachments that carry viruses and worms. This is called social engineering, and it’s all too easy on Windows systems. Just send out an e-mail with a malicious attachment and a subject line like, “Check out these adorable puppies!”–or the porn equivalent–and some proportion of users is bound to click without thinking. The result? An open door for the attached malware, with potentially disastrous consequences organizationwide.
Thanks to the fact that most Linux users don’t have root access, however, it’s much harder to accomplish any real damage on a Linux system by getting them to do something foolish. Before any real damage could occur, a Linux user would have to read the e-mail, save the attachment, give it executable permissions and then run the executable. Not very likely, in other words.
3. The Monoculture Effect
However you want to argue the exact numbers, there’s no doubt that Microsoft Windows still dominates most of the computing world. In the realm of e-mail, so too do Outlook and Outlook Express. And therein lies a problem: It’s essentially a monoculture, which is no better in technology than it is in the natural world. Just as genetic diversity is a good thing in the natural world because it minimizes the deleterious effects of a deadly virus, so a diversity of computing environments helps protect users.
Fortunately, a diversity of environments is yet another benefit that Linux offers. There’sUbuntu, there’s Debian, there’s fedora and there are many other distributions. There are also many shells, many packaging systems, and many mail clients; Linux even runs on many architectures beyond just Intel. So, whereas a virus can be targeted squarely at Windows users, since they all use pretty much the same technology, reaching more than a small faction of Linux users is much more difficult. Who wouldn’t want to give their company that extra layer of assurance?
4-Audience Size
Hand-in-hand with this monoculture effect comes the not particularly surprising fact that the majority of viruses target Windows, and the desktops in your organization are no exception. Millions of people all using the same software make an attractive target formalicious attacks.
5. How Many Eyeballs
“Linus’ Law”–named for Linus Torvalds, the creator of Linux–holds that, “given enough eyeballs, all bugs are shallow.” What that means is that the larger the group of developers and testers working on a set of code, the more likely any flaws will be caught and fixed quickly. This, in other words, is essentially the polar opposite of the “security through obscurity” argument.
With Windows, it’s a limited set of paid developers who are trying to find problems in the code. They adhere to their own set timetables, and they don’t generally tell anyone about the problems until they’ve already created a solution, leaving the door open to exploits until that happens. Not a very comforting thought for the businesses that depend on that technology.
In the Linux world, on the other hand, countless users can see the code at any time, making it more likely that someone will find a flaw sooner rather than later. Not only that, but users can even fix problems themselves. Microsoft may tout its large team of paid developers, but it’s unlikely that team can compare with a global base of Linux user-developers around the globe. Security can only benefit through all those extra “eyeballs.”
Once again, none of this is to say that Linux is impervious; no operating system is. And there are definitely steps Linux users should take to make their systems as secure as possible, such as enabling a firewall, minimizing the use of root privileges, and keeping the system up to date. For extra peace of mind there are also virus scanners available for Linux, including ClamAV. These are particularly good measures for small businesses, which likely have more at stake than individual users do.
It’s also worth noting that security firm Secunia recently declared that Apple products have more security vulnerabilities than any others–including Microsoft’s.
Either way, however, when it comes to security, there’s no doubt that Linux users have a lot less to worry about.

ENCRYPT a file:

>>gpg -c filename

then enter password  & it will be saved as filename.gpg

DECRYPT a file:

>>gpg filename.gpg

enter password and file is decrypted as filename

PROJECT TITLE:
Multiple Data Compression and Encryption using Iterative Technique.

Abstract:

In digital forms of data storage, data can be represented by patterns of 0s and 1s.
The more the patterns the more data can be compressed. Text may be compressed upto 40% of its original size. The percent of compression that can be done on a piece of text or a file depends on the type of file and the format of the text used.
Compression of a file may not be useful un till it can be decompressed back to its original form for further usage.

The requirement of compressing a file arises form various reasons, some of which may be
:
1. Security purpose.
2. Transmission purpose.(better bit rates, small latencies, etc)
3. Secrecy of the data or file being transferred.(Only some people may access, understand and manipulate data that is visible to all)
4. Storage purpose.(Efficient use of storage space)
etc,

When a file is compressed using any algorithm, it may be decompressed using more or less of that same algorithm in reverse order. An efficient compression may only be tested upon successful decompression of the compressed file if it generates the original file as it was before compression.
General Idea.
Any text file that has some text in it must be compressed depending on the size of the file and distinct characters it have. The same file may be decompressed using suitable algorithm and it must generate a file having same information of the source file used for compression. The program must be able to find number of distinct characters in the text file and store them in am array. In computer architecture (x86 machines) the data encoding scheme used to store, manipulate and transmit data is ASCII(American Standard Code for Information Interchange). It defines that maximum number of distinct characters available are 256 (i.e., 2^8). I used this very property of ASCII codes in my algorithm for compressing and decompressing files of any length but must have 256 distinct characters.

A simple algorithm used in compressing a text file may be :

1) Open a source file that comtains some text.(this file will be subjected to compression and decompression).
2) Read first character from source file.
3) Store first character in an array.
3) Read a character from this source file.
4) Compare the character with already existing character(s) in the array.
if the character matches with any character present in array goto step 4.
otherwise, modify the size of array by appending this character into it.
NOTE : this array now will have all the distinct characters in the file. This is the “key” used to compress and decompress the source file.
5) Now calculate the code length according to the number of elements in the master array. This is the actual size that my character must use in memory.
6) Seek the file position of the opened file to its begining.
7) Read a character from this file.
8. Compare this character with the one’s in array.
if it is present in array then assign its array index into a variable with appropriate shifting and goto step 7.
otherwise goto step 7.
NOTE: step 8 may differently handle the characters depending the code length and algorithm but the working principle is same.
9) Save the newely available coded word(after shifting) in to a new file. This is the compressed file.
10) Close all opened files.
11) Exit.

A simple algorithm used in decompressing a text file may be :

NOTE : I must have the “key” used in compression.(i.e., array holding distinct characters that were present in the source file)
1) Open the compressed file.
2) Read a character from this file.
3) save the bits of this character in different variables with appropriate shifting.
NOTE: step 3 may differently handle the character depending the code length and algorithm but the working principle is same.
4) Save the new bytes(new variables) in a new file.
5) goto step 2.
6) close all the opened files.
7) Exit.

Now to test the compression algorithm, compare the final newely created file’s information with that of original source file’s.

Conclusion:
I used the above algorithm to successfully compress and decompress many source files having variable text lengths.

Thank You.
HARPREET SINGH
ece.harpreetsingh@gmail.com

Multiple Data compresion is technique to compress more than 50 percent of the data,by using iteration methods in C language.

before compession and decompession there are certain function we have to perform;-

MASTER ARRAY

Array is the collection of elements of same data type in continous memory location.here,we create the array of all the characters including space and put them in array which is called as master array.from where we call all the repeated character of main string from there index.

CODELENGTH

Codelength is the no.of bits in which we have to keep the data i.e. a character takes 1 byte and integer take 4 byte for its storage but an integer can represent in 4 bits or 3 bits in how many bits we have to represent data  it is decided by code length .

COMPRESSION

logically in compression ,we compress the data i.e. firstly we put all the data in array as described earlier simultaneously we create index and after making index we call the characters through their index .By using bitwise shift operator we shift the index value  and put it into a character (type casting) using bitwise OR (|) the 2 byte data stored in 1 byte.here 50% compression is done.

ch=ch<<4;
ch2=ch|ch1;

DECOMPRESSION

In decompression ,logically we repeat the reverse process of compression

STEPS TO COMPRESS AND DECOMPRESS.

COMPRESSION
1.) Open the file to be compressed.
2.) Find the distinct characters in the file and store it in an array(master array).
3.) From the master array find the maximum number of bits required to represent each distinct character in compressed file.
4.) Read the file character by character.
5.) Replace each character with the index of the corresponding character in master array.
6.) Manipulate the indexes in the form of 1 byte using shift operations.
7.) Write the manipulated indexes to the compressed file.
8.) Store the master array in other file so that it could be used at the time of decompression.

DECOMPRESSION
1.) Open the compressed file.
2.) Open the file containing master array and store it in array.
3.) Form the master array find out the number of bits used to represent each character.
4.) Read the compressed file character by character.
5.) From this read characters filter out the actual ASCII characters using shift operations and indexes.
6.) Save the filtered out ASCII characters to new file.

POINTERS IN C LANGUAGE

C is the most powerful programming language in the software development world. You can do whatever you want to do regarding development then go through the C language. You can’t even imagine the depth of C language. And the most powerful tool of the C is Pointer. If you are master in the Pointer you can be the master of C language.

So, now your curiosity is some questions arising in your mind, like:

1. Why Pointer are that much powerful tool?, When we can use the Pointers in our program?

2. How Pointer works?

3. How Pointers can increase the efficiency and decrease the length of our program?

 Here are the answers of these question.

Definition of Pointers-: The simple definition of Pointer is the variable which holds the address in memory of some other variable. You can understand this like a arrow pointing towards your home and on the arrow your address is print means the arrow holding the address of your home, and your home is the variable. This Lehman definition will help you to understand what is pointer.

 The declaration of Pointer is as follows:

                   int *pointer;

Here’s the pointer is a variable which is integer type, and * sign is actually an operator to DE-reference a pointer. The only time it means “hey I’m a pointer” is during variable declaration.

And how it holds the address:

                int *pointer;

                int a;

             pointer = &a;

Here, & ampersand sign specify the address of the variable.

In the above expression, variable a is the integer type and pointer is holding the address of a with the help of & sign. The data type int shows, 4 bytes of data the variable stored in.

Pointers in Array-:

Arrays are continuous block of memory holds multiple objects and the type of objects are specified. An array variable is constant. You can’t assign a pointer to an array variable, even if the pointer variable actually points to the same or a different array. You also cannot assign one array variable to another. You can assign an array variable to a pointer though and that is where things get confusing. When assigning the array to the pointer we are actually assigning the address of the first element in the array to the pointer.

 int a[4] = {1,2,3};

int *pointer = a;

printf(“*pointer=%d\n”, *pointer);

 Firstly we initialize the array of integer type. After this we initialize the integer pointer and assign the array variable to it. Since the array variable actually is the memory address of the first element in the array, we have assigned the memory address of the first element in the array to the pointer. This is the same as doing int *pointer = &a[0], explicitly stating the address-of the first element in the array.

 Notice the pointer has to be the same type as the elements of the array, unless the pointer is a void pointer.

Pointers to structure-:

A pointer to a structure holds the memory address of the first memory of structures. And the pointers to structure must be declared to point to the structure type or be void type.

struct person {

int age;

   char *name;

};

struct person first;

struct person *ptr;

 first.age = 21;

char *fullname = “full name”;

first.name = fullname;

ptr = &first;

 printf(“age=%d, name=%s\n”, first.age, ptr->name);

 On the first 6 lines we declare the struct person, a variable to hold a person struct, and a pointer to a person struct. Line 8 we assign a literal int to the age member. Line 9-10 we declare a char pointer to a literal char array and then assign that to the struct name member. Line 11 we assign a reference to the first person struct to our struct pointer variable.

Line 13 we print out the age and name of our struct instance. Notice the two different notations, the . and the ->. With the age field we are accessing the struct instance directly and so we use the . notation. With the name field we are using our pointer to the struct instance and so we use the -> notation. This would be the same as doing (*ptr).name where we first derefence the pointer and then access the name field.

Block driver

we take a look at the
important data structures and driver methods that you are likely to encounter while implementing a block
driver.They are as follows:

register_blkdev – register a new block device

@major: the requested major device number [1..255]. If @major=0, try to
allocate any unused major number.
@name: the name of the new block device as a zero terminated string
The @name must be unique within the system.
The return value depends on the @major input parameter.
– if a major device number was requested in range [1..255] then the
function returns zero on success, or a negative error code
– if any unused major number was requested with @major=0 parameter
then the return value is the allocated major number in range
[1..255] or a negative error code otherwise // /block/genhd.c

—————————————–blk_init_queue————————————————————

blk_init_queue – prepare a request queue for use with a block device
@rfn: The function to be called to process requests that have been
placed on the queue.
@lock: Request queue spin lock
Description:
If a block device wishes to use the standard request handling procedures,
which sorts requests and coalesces adjacent requests, then it must
call blk_init_queue(). The function @rfn will be called when there
are requests on the queue that need to be processed. If the device
supports plugging, then @rfn may not be called immediately when requests
are available on the queue, but may be called at some time later instead.
Plugged queues are generally unplugged when a buffer belonging to one
of the requests on the queue is needed, or due to memory pressure.
@rfn is not required, or even expected, to remove all requests off the
queue, but only as many as it can handle at a time. If it does leave
requests on the queue, it is responsible for arranging that the requests
get dealt with eventually.

The queue spin lock must be held while manipulating the requests on the
request queue; this lock will be taken also from interrupt context, so irq
disabling is needed for it.

Function returns a pointer to the initialized request queue, or %NULL if
it didn’t succeed.

—————————————blk_queue_logical_block_size——————————————–
blk_queue_logical_block_size – set logical block size for the queue
@q: the request queue for the device
@size: the logical block size, in bytes
Description:
This should be set to the lowest possible block size that the
storage device can address. The default of 512 covers most
hardware.

————————————–blk_queue_physical_block_size————————————————
64 * blk_queue_physical_block_size – set physical block size for the queue
@q: the request queue for the device
@size: the physical block size, in byte
Description:
This should be set to the lowest possible sector size that the
hardware can operate on without reverting to read-modify-write
operations.

————————————-blk_fetch_request——————————————————-

blk_fetch_request – fetch a request from a request queue
@q: request queue to fetch a request from

Description:
Return the request at the top of @q. The request is started on
return and LLD can start processing it immediately.
Return:
Pointer to the request at the top of @q if available. Null
otherwise.

* Context:
queue_lock must be held.
It calls blk_peek_request further and the blk_start_request as described below:

————————————blk_peek_request——————————————————–

blk_peek_request – peek at the top of a request queue
@q: request queue to peek at

Description:
Return the request at the top of @q. The returned request
should be started using blk_start_request() before LLD starts
processing it.

Return:
Pointer to the request at the top of @q if available. Null
otherwise.

Context:
queue_lock must be held.

—————————————————blk_start_request————————————————————-

blk_start_request – start request processing on the driver
* @req: request to dequeue
*
Description:
Dequeue @req and start timeout timer on it. This hands off the
request to the driver.

Block internal functions which don’t want to start timer should
call blk_dequeue_request().

Context:
queue_lock must be held.

———————————————————blk_end_request_all——————————————————-

blk_end_request_all – Helper function for drives to finish the request.
@rq: the request to finish
@error: %0 for success, < %0 for error

Description:
Completely finish @rq.

——————————————————–blk_end_request_cur——————————————————-

blk_end_request_cur – Helper function to finish the current request chunk.
@rq: the request to finish the current chunk for
@error: %0 for success, < %0 for error

Description:
* Complete the current consecutively mapped chunk from @rq.
*
Return:
* %false – we are done with this request
%true – still buffers pending for this request