git: Completely revert the last commit

This entry is part 6 of 7 in the series git: useful HOWTOs
git reset --hard HEAD~1

will completely revert the last commit (i.e., everything from this commit will disappear).

git: How to checkout a specific commit/version to a new branch

This entry is part 5 of 7 in the series git: useful HOWTOs
git checkout -b branch--new commit-hash

will checkout the commit-hash commit in a new branch called branch-new.

git: How to push a new branch to a remote repository

This entry is part 4 of 7 in the series git: useful HOWTOs

This will also create an association between the local and the remote branch, so you can afterwards just issue git push.

The simplest linked list implementation in C

I recently needed to develop a way to perform pseudo-random memory accesses in a C program, in order to fool the hardware prefetchers. Without going into any details, my solution was to represent some continuous memory as a linked list with random next pointers.

Naturally, the simplest list that can be developed has nodes that do not contain any other elements apart from the next pointers that link the nodes together. In C, this can be easily done with a structure similar to the following:

struct node
  struct node* next;

However, one can leverage the flexibility of C to even avoid using the node structure: you are allowed to cast some memory to any type you like. For instance, you can use 8 bytes as an integer(uint64_t) , or as a pointer to an integer (uint64_t*).

Doing so, we can develop, what I believe is, the simplest linked list possible.
The code that generates a random list is the following:

static void
create_rand_list(volatile uint64_t* list, size_t n)
  uint8_t* used = calloc(n, sizeof(uint8_t));
  assert (used != NULL);
  size_t idx = 0;
  size_t used_num = 0;
  while (used_num < n - 1)
      used[idx] = 1;
      size_t nxt;
          nxt = rand() % n;
      while (used[nxt]);
      list[idx] = (uint64_t) (list + nxt);
      idx = nxt;
  list[idx] = 0; 		/* NULL pointer in the last element */

The “magic” happens when we set list[idx] = (uint64_t) (list + nxt), so we set the “next” pointer for the location idx.
What is even more interesting is how we can now parse and get the size of the list:

static void
list_parse(volatile uint64_t* l)
  while (*l != 0)
      l = (uint64_t*) *l;
static size_t
list_size(volatile uint64_t* l)
  size_t s = 1;
  while (*l != 0)
      l = (uint64_t*) *l;
  return s;

Pretty slick, right? 🙂

git: How to merge two commits into one

This entry is part 3 of 7 in the series git: useful HOWTOs
git rebase -i

and then pick the one you want to keep and squash the other

git: How to see the changes of a file for a commit

This entry is part 2 of 7 in the series git: useful HOWTOs
git show [commit] -- FILE

git: How to view all files of a commit

This entry is part 1 of 7 in the series git: useful HOWTOs
git show --name-only [commit]

Top 25 Most Dangerous Software Errors

The 2011 CWE/SANS Top 25 Most Dangerous Software Errors is a list of the most widespread and critical errors that can lead to serious vulnerabilities in software. They are often easy to find, and easy to exploit. They are dangerous because they will frequently allow attackers to completely take over the software, steal data, or prevent the software from working at all.

The Top 25 list is a tool for education and awareness to help programmers to prevent the kinds of vulnerabilities that plague the software industry, by identifying and avoiding all-too-common mistakes that occur before software is even shipped. Software customers can use the same list to help them to ask for more secure software. Researchers in software security can use the Top 25 to focus on a narrow but important subset of all known security weaknesses. Finally, software managers and CIOs can use the Top 25 list as a measuring stick of progress in their efforts to secure their software.

Find the list here.