A large number of vulnerabilities occur because protocol implementations failed to anticipate illegal packets. RFCs typically define what constitute "right" packets relevant to the protocol and they specify what the response should be for such packets. They are often ambiguous and remain silent on what the protocol implementation should do for packets which deviate from the specification. Implementers must and, by and large, do faithfully implement an RFC. However, implementers usually take any silence in a specification as "design freedom". Even though the protocol implementers are network specialists, they often are not knowledgeable in network security and cryptography issues, past exploits and common attack techniques that can impact the security of a protocol module, and consequently, the whole system. This paper systematically discusses vulnerabilities that can be attributed to protocol designs, inadequacies of RFCs, and omissions of the protocol implementers. Using specific examples, we point out how ambiguities in protocol RFCs have lead to security vulnerabilities. We correlate various types of security vulnerabilities with the way the RFCs are written. We make a case for such exploit-robust and attack-aware RFCs, and recommend the features for a better RFC, called eRFC (enhanced RFC). We offer advice to RFC writers, implementers and RFC approval bodies. The most effective solution to reducing network security incidents is to fix the RFCs in such a way that the implementers are forced to write an exploit-robust implementation, irrespective of their security knowledge and expertise.

We developed a laboratory-based course on Internet Security. The course is aimed at the senior undergraduate. This paper discusses the course and explains how others can set up their own labs to teach this course. All the laboratory work is conducted in a laboratory of PCs running Linux. We developed lecture notes for the course, and a web site to widely disseminate these materials.

Automatic drawing of aesthetically pleasing data structure diagrams is a challenging problem which has attracted much research attention. In building such a system, we are confronted with four basic problems: (1) proper user involvement, (2) good user customization facilities, (3) aesthetics, and (4) efficiency. Each of the above problems has been attacked separately in the past. In this paper, we describe a prototype which brings the above four issues together and builds a powerful, usable, and natural automatic diagram drawing system.

Data structure diagrams are two-dimensional figures made up of lines that aim to pictorially indicate the interrelationships of the elements of a data structure. The various rules and factors of aesthetics that go into the way data structure diagrams are drawn are collected together. The various subjective factors are formulated into computable objectives and numeric parameters. These are distilled from a large number of data structure drawings found in various textbooks. The rules used have not reached a level of acceptance comparable to that of the relevant rules in engineering graphics. The internal architecture of a (sub)system that helps draw data structure diagrams is outlined.>

Abstract A two level specification of the functional behaviour of a class of indenting programs for Pascal is presented. The transformation that these programs perform on the input text is a composition of splitting input lines, altering the blank space between lexical tokens and computing the margin required in front of each of the split lines. The high level specification is given as a stylized Pascal grammar in Extended BNF. In contrast, the low level specifications, which are operationally closer to a program, and which define how syntactically invalid text is dealt with, require several mathematical functions that capture the essence of these basic transformations. The specifications of an indenting program for Pascal are then obtained as a further elaboration of these functions. Most indentation styles appearing in the literature can be specified with precision using methods developed in this paper. Our experience in this case study indicates that although specifications for real‐life programs can be given using simple mathematics, the effort required is still considerable.

Abstract The correctness of an indenting program for Pascal is proved at an intermediate level of rigour. The specifications of the program are given in the companion paper.1 The program is approximately 330 lines long and consists of four modules: io, lex, stack and indent. We prove first that the individual procedures contained in these modules meet their specifications as given by the entry and exit assertions. A global proof of the main routine then establishes that the interaction between modules is such that the main routine meets the specification of the entire program. We argue that correctness proofs at the level of rigour used here serve very well to transfer one's understanding of a program to others. We believe proofs at this level should become commonplace before more formal proofs can take over to reduce traditional testing to an inconsequential place.

Verification of certain properties of a class of programs is considered.The programs are written In a miniprogrammmg language that has variables of only two data types, a linear array of elements, and pomters to these elements.The array elements can only be exchanged; pointers can only be incremented or decremented by one Program properties to be venfied are expressed in a severely restricted assertion language which contains essentially Boolean expressions of comparisons among pointers and among array elements Several in-place sorting algorithms can be readily written and asserted m these languages A decision procedure for the truthhood of the verification conditions generated for the above class of asserted programs is presented An algorithm for generating counterexamples for false verification conditions is also given The theorem prover can be readily implemented using simple graph algorithms The objective of this exercise is to use problem knowledge to design simple and efficient verifiers.The techmques developed seem applicable to wider classes of programs mampulatmg data structures.

A brief description and comparison of all known algorithms for enumerating all circuits of a graph is provided, and upper bounds on computation time of many algorithms are derived. The vector space method of circuit enumeration is discussed. It is proved that $K_3 ,K_4 ,K_4 - x$ and $K_{3,3} $ are the only undirected and reduced graphs which do not have any edge-disjoint unions of circuits.