Multilevel security (MLS) presents a set of users and a set of objects to be accessed. Both the users and objects are classified hierarchically with a security level as well as need-to-know categories. For example, you may have an “Unclassified” user trying to read a “Classified” object or a “Classified Crypto” user trying to write a “Classified Nuclear” object.

The Bell-La Padula model defines a way for deciding whether to grant access in each of these cases. This model uses a formula to define whether a certain level combined with a category dominatessome other level combined with a category. We’ll define “Classified” as a higher level than “Unclassified”, so in the first example “Classified” (with no category) dominates “Unclassified” (with no category). I’ll ignore categories here for simplification, but in reality for one classification to dominate another, both its level and category set must dominate the other.

Having this domination function defined, we can describe the two main properties in the Bell-La Padula model:

• The Simple Security Property – A user can only read an object if the classification of the user dominates that of the object. (Also known as “read down” or “no read up”.)
• The *-Property – A user can only write to an object if the classification of the object dominates that of the user. (Also known as “write up” or “no write down”.)

The reasoning behind the Simple Security Property is pretty straight-forward. If you’re concerned about confidentiality, you definitely don’t want people to read anything that they don’t have to. It’s the second property that raises some eyebrows. Why should a user be able to overwrite something that they can’t even read? Doesn’t this create huge issues with integrity?

The answer is simply that BLP doesn’t concern itself with integrity. But when you look at the property solely from the concept of confidentiality, the idea becomes a bit more clear. A user at a certain level knows information that users at lower levels don’t, so he shouldn’t be able to write anything to those other levels. However, users at a higher level already know that information so in that sense it’s okay to write to a higher level. You don’t have to worry that someone will see something they shouldn’t know about.

Another question in this model is how can someone give an order to their subordinate at a lower level? Here BLP adds the concept of trusted users. These are a special type of users who are proven trustworthy and who have the ability to write to lower levels. To me this seems like a cheap way of adding in functionality that should be provided by the basic system. “How do you make sure someone is trustworthy?” seems like as much of a complex question as “how do you make sure information isn’t written where it shouldn’t be?” Perhaps the reason for considering the first is that it’s easier to just have a person decide the second.

Overall, it’s interesting to find that the Bell-La Padula model has retained such influence despite its inherent shortcomings. As we continue in my Computer Security course, I look forward to seeing how more modern models compare and how they’ve solved the integrity problem.

Compared to my former 71 wpm in QWERTY, my peak in DVORAK is only around 55 wpm. Of course, this is partly because whenever I use any computer other than my own, it’s in QWERTY. If there’s someone who can maintain finger fluency in two keyboard languages, they have all my respect. I’m not like that. And I’m not quite sure what my typing speed on QWERTY has dwindled down to. If there’s a potential to type faster, that’s just in ideal situations. As for any possible ergonomic benefits, that simply doesn’t matter. Switching back and forth between two keyboard layouts does not work.

Goodbye, DVORAK. I’ll miss your home-row words like “the” and “sound”. I’ll miss the lack of single-handed words. But none of my friends like you so it just won’t work out.

CS 336: Analysis of Algorithms (Myers)

This class focuses on formal proofs of algorithm correctness, including topics such as weakest preconditions, developing invariants, induction, and probability. Even for a computer science course, it’s very math-intensive. One of my favorite things about this class, though, was having a support group available. There are some classes where you’re supposed to figure out everything on your own and not discuss the homeworks at all, while here we were encouraged to attend ACM’s weekly theory reviews or our own groups to meet up and work on the homeworks. For a class where the students have such varying backgrounds (everyone teaches 313k differently), it’s really necessary. I may not have been able to get a firm grip on recurrence relations without it.

CS 352: Computer Systems Architectures (McKinley)

This was McKinley’s first time teaching CS 352, and unfortunately it was at times very obvious. Reading the textbook was helpful, but the exercises often used terminology not in the rest of the book and were very confusing. The midterms were also insanely difficult. I’d go in thinking I had a good understanding of the material but then leave completely stunned. (Being able to keep the graded midterms would have been nice.) But for the final at least, I had almost a whole week to study. I read the book, worked out extra exercises, summarized the class notes, checked Wikipedia for clarifications, and everything came together. Sure, there were a couple of small things that I couldn’t remember ever going over, but in an hour and a half I was done and ended up with a 90.5–the highest grade on the final for any student. If you want to do well in this class, you need to have a lot of time to devote to it.

CS 378: Software Design (Batory)

This has been probably my favorite computer science course. We learned how to reason about programs using UML and studied refactorings, design patterns, and architectural patterns. For even common design patterns like hooks, I had never understood before exactly what they were. My favorite part, though, was learning about parallel architectures and having the opportunity to simulate everything from a basic join up to the parallelized Gamma join architecture. It’s a difficult class, but Batory’s generally an entertaining lecturer and I would recommend it to any computer science student.

I considered it at first to be something like the fictional writer Joseph Grand in Camus’s The Plague. Grand had started a novel some time back but hadn’t gotten past the first sentence because he wanted to find the perfect words and was never satisfied. And it somewhat reminds me of myself trying to get back in the habit of writing these blog entries. Knowing when not to refactor really is the hardest part. Sometimes you have to just complete something even knowing that you could write it so much better.

Looking for examples of refactoring in prose writing rather than code, I stumbled across the history of Wikipedia’s article on code refactoring which includes such gems as the Adding Quotation (to Make the Topic Less Dry) refactoring or the Change Word (“Metric” to “Measurement”) refactoring.

Keep in mind, though, that not everything counts as a refactoring. There are some transformations such as Remove Excess Comma which are still just good ole’ bug squashing.

In our Software Design course, our first assignment of the semester is to use reflection to create Java programs called adaptors. I’ve just started with the assignment by playing around with the Java reflection library and figuring out how to use these tools, but I thought I’d share a simple example which may be much quicker to understand than the article linked to above.

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Main {
    public static void main(String[] args) { 

        // select the class to look into
        Class myclass = String.class;

        // check how many methods the class declares
        Method[] methods = myclass.getDeclaredMethods();
        System.out.println( "Number of methods in "
                + myclass.getName() + " class: " + methods.length + "\n" );

        // select a method from the class
        int methodNum = 52;
        Method mymethod = methods[methodNum];
        System.out.println( "Checking method #" + methodNum + ":" );

        // name of method
        System.out.println( "Name: " + mymethod.getName() );

        // modifiers such as protected or static
        // note: getModifiers() returns an int that you need the Modifier
        //       class to makes sense of
        System.out.println( "Modifiers: "
                + Modifier.toString(mymethod.getModifiers()) );

        // return type of method
        System.out.println( "Return Type: " + mymethod.getReturnType().getName() );

        // list of method's parameters
        Class[] mytypes = mymethod.getParameterTypes();
        for (Class c: mytypes)
            System.out.println( "Parameter: " + c.getName() );
    }
}

The output for this program is:

Number of methods in java.lang.String class: 68

Checking method #52:
Name: substring
Modifiers: public
Return Type: java.lang.String
Parameter: int
Parameter: int

A few years ago, I had fun using Gimp for one of the first times in creating the favicon for Chavez360. It was just a smiley face with a red headband. The favicon was very simple, but it symbolized something easily recognizable to any Chavez fan.

This blog is a whole different story, though. Even after almost a year of occasional posts, I don’t have a main focus so a true symbol is out of the question. However, after putting it off for so long, I had to come up with something. Fortunately, I have a short word in the title and used a online favicon generator to come up with something reasonable. Then not knowing what else to put in all the blank space left over, I added in some symmetrical symbols. Adding it to WordPress was simple.

No, it’s not the best favicon in the world, but it sure beats the default icon that Firefox provides so now when I visit, it feels just a little more like home.

When I went to my site to post a few article updates, it was gone. Just a generic landing page with annoying ads instead of the fansite that I had toiled over for so long.

I immediately went to the GoDaddy site to renew my domain as well as my webhosting, which I discovered had also expired. As I was scrambling to type in various numbers, I was thinking to myself: When was the last time I backed up the database? Are all the files on my local machine the same as those that were online when my site was last up? So this is what all those best practices are really about.

Fortunately, shortly after my payment went through, everything was back to normal. All the files, the databases–it was all saved even though GoDaddy could’ve gotten rid of it all if they wanted to. I just have to thank them for making it so easy to get it all back.

Then I went straight to the forum to post an apology to any visitors who had seen that awful page. By evening, there was a response from someone who was afraid I had just given up on the site and was thankful it was back up.

Yep, that’s what makes it all worthwhile.

Anyhow, some closing thoughts on the classes that have encompassed me for the past few months:

CS 315: Algorithms and Data Structures (Novak)

Novak’s CS 315 site is one of the best in the department–if for nothing else than having an excellent vocabulary list and so many ways to browse the class notes. Novak wasn’t the most exciting lecturer, but he always made sure we understood what was going on. If I could change one thing about this class, though, I’d like to look at implementations a bit more. He’d tell us that the code already existed, and his focus was on making programming faster and easier for others, but for now I still want to see things very in depth.

CS 310: Computer Organization and Programming (Boral)

In this course, we got to learn the fundamentals. We implemented our own stack and heap using LC-3 and learned how to write machine code. There’s much to be learned from this, but I think the main thing is to cherish the high-level languages we get to use (I still think it’s funny to call C “high-level” though) and to optimize how we use them without having to constantly focus on the small details. Boral was usually an entertaining lecturer, and if it wasn’t for the unpredictability of his tests I’d love to take another course with him.

CS 313K: Logic, Sets, and Functions (Lifschitz)

I took this class ten years ago as Philosophy 313K, so I expected this to be mostly a refresher course, and as such much of it was quite boring. However, I couldn’t miss any lectures because the exams would have questions about topics that weren’t in any of our notes or assignments. The course was mainly focused on mathematical functions and sequences, and I was a bit disappointed that logical quantifiers and connectives weren’t really covered. At least it was a (mostly) easy A for me.

EE 316: Digital Logic Design (Touba)

Between readings, homeworks, and labs, EE 316 is probably the most time-intensive course I’ve taken so far. (The required lab section doesn’t count for any credit hours.) Much of the material looks easy in retrospect, but the pace is so quick that you’re sure to get behind at some point along the way and have a lot of trouble catching up. The verbosity of VHDL is quite irritating, but learning all the tricks with Karnaugh maps was fun and state diagrams seem almost natural now.

M 328K: Introduction to Number Theory (Caputo)

Ah, my last ever pure math course. For being a rather easy course, though, it really made me miss Differential Equations. I mentioned this earlier, and now I’m sure that Moore method isn’t my strong point. I love to research things just to get new ideas even and felt pretty stifled in this class. It looks like what I did learn won’t go to waste, though. I’ve been looking over the supplementary textbook for CS 336 (next semester), and many of the theorems and algorithms I’ve learned are in there.

(Note: I’m still waiting for my official grades to come out, but as I’ve calculated it: for the semester I have A’s in CS 310, CS 313k, and M 328k, and B’s in CS 315 and EE 316.
Update: I got an A in CS 315 and an A- in EE 316. Whoo!)

This is a way of teaching known as the Moore method. Instead of the standard lectures, this method allows students to experiment in a way by doing proofs and seeing how what we already know applies to new situations. We all progress at the same rate by presenting what we’ve learned in class and discussing what we did differently or anything that still doesn’t make sense.

Though this method is also used in our logic course, most computer science classes follow the standard lecture and lab format. Professor Gordon Novak told us, “CS is an experimental science,” but by this he didn’t mean that we discover new data structures just by trying to solve a problem and seeing that that would be the best possible solution. Instead with some exceptions, we learn most of the time we don’t need to reinvent the wheel. The focus is on learning about many different data structures, gaining experience using them, and figuring out how to decide which is the best solution to any particular problem.

Of course, the concept of number theory is completely different than most of what we encounter in computer science. The method of proving the theorem (which may be as close to programming as math gets) isn’t so important as the fact that you can prove it and really understand why something’s true. It’s still kind of a shock being in a Moore method class, but it’s only been two weeks, so I still have most of a semester left to see if this works for me.

After two whole weeks, I’ve earned a whopping $2.13! At this rate, I’ll hit my first $100 payout in just a short couple of years. Now I really wish I had applied again last year instead of putting it off; then I’d already be halfway there. Oh, well. In the end when it’s all averaged out, I’ll have made just enough to cover my hosting costs which makes this a no-cost hobby. There’s nothing better.