Truecrypt benchmark for Raspberry Pi

This benchmark was run on raspbian/wheezy. So it's used the armhf architecture. The buffer size was was 5MB. Checkout the truecrypt benchmark with the new turbo overclock setting.

Algorithm	Encrypt	Decrypt	Mean
Twofish	8.9	7.7	8.3
Serpent	6.8	6.9	6.9
AES	4.4	3.7	4.1
Twofish-Serpent	3.9	3.7	3.8
Serpant-AES	2.7	2.4	2.5
AES-Twofish	1.9	2.4	2.1
Serpant-Twofish-AES	2.1	1.8	2.0
AES-Twofish-Serpent	2.0	1.8	1.9

Truecrypt armhf executable for Raspberry Pi (raspbian/wheezy)

Because Truecrypt it's a bit of a work and takes so long to compile I uploaded the compiled binary file

Compile Truecrypt on Raspberry Pi

I wanted to run Truecrypt on my Raspberry Pi. But there is no precompiled package which you could simply install with apt-get. So you have to compile it yourself - which take a few hours. If you just want the truecrypt binary for Raspbian/Wheezy then you can download them here.
The first thing you need to do is to get all needed dependencies. Thereby you have to compile one dependency yourself. We start with this dependency.


How to compile wxWidgets
First download the source code: http://www.wxwidgets.org/downloads/#latest_stable I used wxAll 2.8.11. Unpack it, go into the directory and execute these commands.

sudo apt-get install libgtk2.0-dev
./configure
make

How to setup PKCS11
Truecrypt needs three header files (pkcs11.h, pkcs11f.h, pkcs11t.h) which you can download from this location: ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-11/v211/
Put them into a directory and then set the PKCS11_INC variable.

export PKCS11_INC=/home/pi/pkcs11

How to compile Truecrypt
First download the source code: http://www.truecrypt.org/downloads2 I used 7.1a. Unpack it, go into the unpacked directory and execute these commands.

sudo apt-get install libfuse-dev nasm libwxgtk2.8-dev
make WX_ROOT=/home/pi/wxWidgets/ wxbuild
make WXSTATIC=1

 There will be this warning

configure: WARNING: libSM not found; disabling session management detection

sadly I couldn't figure out how to fix it. But Truecrypt will work anyway.


If you get this error message

In file included from Keyfile.cpp:10:0:
.../SecurityToken.h:43:21: fatal error: pkcs11.h: No such file or directory

then the  PKCS11_INC variable isn't set correctly or you forgot to put the header files in the directory.


Now you can use Truecrypt. The executable file will be created in Main/truecrypt. To mount a truecrypt volume just use

./truecrypt /path/to/truecrypt-volume /path/to/mount-point

or you can just execute ./truecrypt and use the graphical surface.

Grails with ATS Transformation tutorial with a demo example

I wanted to play with  Groovy's AST Transformation in Grails. I thought naively that it would be enough to put the AST Transformation code into the source folder, like in a pure groovy project. I run the grails-app and it didn't worked. So I searched for help in the world-wide-web. Some guys said that the AST code need to be precompiled and there is no way to do it with one compile run. Sadly I couldn't find an example or a tutorial how to do the precompiling. After some frustrating hours of searching and trying I got a working solution. Now I am going to share my knowledge and hope that I can help you with this post.

At first I give you an explanation what an AST Transformation is.

When the Groovy compiler compiles Groovy scripts and classes, at some point in the process, the source code will end up being represented in memory in the form of a Concrete Syntax Tree, then transformed into an Abstract Syntax Tree. The purpose of AST Transformations is to let developers hook into the compilation process to be able to modify the AST before it is turned into bytecode that will be run by the JVM.

In simple words it means that you can modify programmable your code at compile time.Groovy's documentation provides a simple example what you can do with AST. In this example a new Annotation @WithLogging is created. If you add this Annotation to a method then the AST Transformation adds at the beginning and at the end of the method a print line statement with "Starting" and "Ending" and the method name. Now I will show you how to get this example running in grails.

The first thing i had done was creating a new source-folder (src/ast) and put all files in it which needs to be precompiled => all AST related files. In this case WithLogging.groovy and WithLoggingASTTransformation.groovy

WithLogging.groovy

1:  @Retention(RetentionPolicy.SOURCE)  
2:  @Target([ElementType.METHOD])  
3:  @GroovyASTTransformationClass("astexample.WithLoggingASTTransformation")  
4:  public @interface WithLogging {  
5:  }

Here we define the Annotation and bind it to the WithLoggingASTTransformation class. It's important to use the full path to the class.

WithLoggingASTTransformation.groovy

1:  @GroovyASTTransformation(phase = CompilePhase.CANONICALIZATION)  
2:  class WithLoggingASTTransformation implements ASTTransformation {  
3:    private static HashSet<MethodNode> set = new HashSet<MethodNode>()  
4:    public void visit(ASTNode[] nodes, SourceUnit sourceUnit) {  
5:      sourceUnit.getAST()?.getClasses().each { ClassNode classNode ->  
6:        classNode.getAllDeclaredMethods().findAll { MethodNode method ->  
7:          method.getAnnotations(new ClassNode(WithLogging))  
8:        }.each { MethodNode method ->  
9:          if(!set.contains(method)) {  
10:            Statement startMessage = createPrintlnAst("Starting $method.name")  
11:            Statement endMessage = createPrintlnAst("Ending $method.name")  
12:            List existingStatements = method.getCode().getStatements()  
13:            existingStatements.add(0, startMessage)  
14:            existingStatements.add(endMessage)  
15:            set.add(method)  
16:          }  
17:        }  
18:      }  
19:    }  
20:    private Statement createPrintlnAst(String message) {  
21:      return new ExpressionStatement(  
22:      new MethodCallExpression(  
23:      new VariableExpression("this"),  
24:      new ConstantExpression("println"),  
25:      new ArgumentListExpression(  
26:      new ConstantExpression(message)  
27:      )  
28:      )  
29:      )  
30:    }  
31:  }  

This class preforms the AST Transformation. The compiler automatically calls the visit-method.  This method iterates over all methods of all classes and check if the method has the @WithLogging Annotation. If the method has this Annotation then it adds the println-statements to the method.

The next step is to tell the grails app that it needs to precompile those files. To do that you have to create a new file in /scripts called "_Events.groovy". This file is a grant script and with it you can hook into the grails events. We need now a hook into the compiling of the app and it's done like this.

1:  eventCompileStart = {target ->  
2:    compileAST(basedir, classesDirPath)  
3:  }  
4:  def compileAST(def srcBaseDir, def destDir) {  
5:    ant.sequential {  
6:      echo "Precompiling AST Transformations ..."  
7:      echo "src ${srcBaseDir} ${destDir}"  
8:      path id: "grails.compile.classpath", compileClasspath  
9:      def classpathId = "grails.compile.classpath"  
10:      mkdir dir: destDir  
11:      groovyc(destdir: destDir,  
12:          srcDir: "$srcBaseDir/src/ast",  
13:          classpathref: classpathId,  
14:          verbose: grailsSettings.verboseCompile,  
15:          stacktrace: "yes",  
16:          encoding: "UTF-8")  
17:      echo "done precompiling AST Transformations"  
18:    }  
19:  }  

At last we create a simple grails-controller to test the AST Transformation.

1:  class AstController {  
2:    def index = {   
3:      loggedMethod()  
4:      render 'i am just a dummy method to call the method..'  
5:    }  
6:    @WithLogging  
7:    def loggedMethod() {  
8:      println "i am doing some important stuff!"  
9:    }  
10:  }  

When you run the app and call the index-handler than you will get this output:

1:  Starting loggedMethod  
2:  i am doing some important stuff!  
3:  Ending loggedMethod  

That's it. The most important thing for the AST transformation in Grails is the /scripts/_Events.groovy file. The rest is just normal AST transformation code or Grail's code.

You can download the whole tutorial code as a STS project with includes a running AST Grails app here.

I hope you enjoyed the tutorial and you are welcome to leave some feedback.