The Official Radare2 Book

Python

$ pip install r2pipe

import r2pipe

r2 = r2pipe.open("/bin/ls")

r2.cmd('aa')

print(r2.cmd("afl"))

print(r2.cmdj("aflj"))

# evaluates JSONs and returns an object

NodeJS

Use this command to install the r2pipe bindings

$ npm install r2pipe

Here's a sample hello world

const r2pipe = require('r2pipe');

r2pipe.open('/bin/ls', (err, res) => {

if (err) {

throw err;

}

r2.cmd ('af @ entry0', function (o) {

r2.cmd ("pdf @ entry0", function (o) {

console.log (o);

r.quit ()

});

});

});

Checkout the GIT repository for more examples and details.

https://github.com/radareorg/radare2-r2pipe/blob/master/nodejs/r2pipe/README.md

Go

$ r2pm -i r2pipe-go

https://github.com/radare/r2pipe-go

package main

import (

"fmt"

"github.com/radare/r2pipe-go"

)

func main() {

r2p, err := r2pipe.NewPipe("/bin/ls")

if err != nil {

panic(err)

}

defer r2p.Close()

buf1, err := r2p.Cmd("?E Hello World")

if err != nil {

panic(err)

}

fmt.Println(buf1)

}

Rust

$ cat Cargo.toml

...

[dependencies]

r2pipe = "*"

#[macro_use]

extern crate r2pipe;

use r2pipe::R2Pipe;

fn main() {

let mut r2p = open_pipe!(Some("/bin/ls")).unwrap();

println!("{:?}", r2p.cmd("?e Hello World"));

let json = r2p.cmdj("ij").unwrap();

println!("{}", serde_json::to_string_pretty(&json).unwrap());

println!("ARCH {}", json["bin"]["arch"]);

r2p.close();

}

Ruby

$ gem install r2pipe

require 'r2pipe'

puts 'r2pipe ruby api demo'

puts '===================='

r2p = R2Pipe.new '/bin/ls'

puts r2p.cmd 'pi 5'

puts r2p.cmd 'pij 1'

puts r2p.json(r2p.cmd 'pij 1')

puts r2p.cmd 'px 64'

r2p.quit

Perl

#!/usr/bin/perl

use R2::Pipe;

use strict;

my $r = R2::Pipe->new ("/bin/ls");

print $r->cmd ("pd 5")."\n";

print $r->cmd ("px 64")."\n";

$r->quit ();

Erlang

#!/usr/bin/env escript

%% -*- erlang -*-

%%! -smp enable

%% -sname hr

-mode(compile).

-export([main/1]).

main(_Args) ->

%% adding r2pipe to modulepath, set it to your r2pipe_erl location

R2pipePATH = filename:dirname(escript:script_name()) ++ "/ebin",

true = code:add_pathz(R2pipePATH),

%% initializing the link with r2

H = r2pipe:init(lpipe),

%% all work goes here

io:format("~s", [r2pipe:cmd(H, "i")]).

Haskell

import R2pipe

import qualified Data.ByteString.Lazy as L

showMainFunction ctx = do

cmd ctx "s main"

L.putStr =<< cmd ctx "pD `fl $$`"

main = do

-- Run r2 locally

open "/bin/ls" >>= showMainFunction

-- Connect to r2 via HTTP (e.g. if "r2 -qc=h /bin/ls" is running)

open "http://127.0.0.1:9090" >>= showMainFunction

Dotnet

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using r2pipe;

namespace LocalExample {

class Program {

static void Main(string[] args) {

#if __MonoCS__

using(IR2Pipe pipe = new R2Pipe("/bin/ls")) {

#else

using (IR2Pipe pipe = new R2Pipe(@"C:\Windows\notepad.exe",

@"C:\radare2\radare2.exe")) {

#endif

Console.WriteLine("Hello r2! " + pipe.RunCommand("?V"));

Task async = pipe.RunCommandAsync("?V");

Console.WriteLine("Hello async r2!" + async.Result);

QueuedR2Pipe qr2 = new QueuedR2Pipe(pipe);

qr2.Enqueue(new R2Command("x", (string result) => {

Console.WriteLine("Result of x:\n {0}", result); }));

qr2.Enqueue(new R2Command("pi 10", (string result) => {

Console.WriteLine("Result of pi 10:\n {0}", result); }));

qr2.ExecuteCommands();

}

}

}

}

Java

import org.radare.r2pipe.R2Pipe;

public class Test {

public static void main (String[] args) {

try {

R2Pipe r2p = new R2Pipe ("/bin/ls");

// new R2Pipe ("http://cloud.rada.re/cmd/", true);

System.out.println (r2p.cmd ("pd 10"));

System.out.println (r2p.cmd ("px 32"));

r2p.quit();

} catch (Exception e) {

System.err.println (e);

}

}

}

Swift

if let r2p = R2Pipe(url:nil) {

r2p.cmd ("?V", closure:{

(str:String?) in

if let s = str {

print ("Version: \(s)");

exit (0);

} else {

debugPrint ("R2PIPE. Error");

exit (1);

}

});

NSRunLoop.currentRunLoop().run();

} else {

print ("Needs to run from r2")

}

Vala

public static int main (string[] args) {

MainLoop loop = new MainLoop ();

var r2p = new R2Pipe ("/bin/ls");

r2p.cmd ("pi 4", (x) => {

stdout.printf ("Disassembly:\n%s\n", x);

r2p.cmd ("ie", (x) => {

stdout.printf ("Entrypoint:\n%s\n", x);

r2p.cmd ("q");

});

});

ChildWatch.add (r2p.child_pid, (pid, status) => {

Process.close_pid (pid);

loop.quit ();

});

loop.run ();

return 0;

}

NewLisp

(load "r2pipe.lsp")

(println "pd 3:\n" (r2pipe:cmd "pd 3"))

(exit)

Dlang

import std.stdio;

import r2pipe;

void main() {

auto r2 = r2pipe.open ();

writeln ("Hello "~ r2.cmd("?e World"));

writeln ("Hello "~ r2.cmd("?e Works"));

string uri = r2.cmdj("ij")["core"]["uri"].str;

writeln ("Uri: ",uri);

}