I pronounce it as \"Open Wart\" but I digress and the notes haven't even begun. It is a Linux(-based), open source operating system for embedded devices but it's most use if found in your routers. If you want your router to have an open source and free operating system, this is a decent bet.<\/p>\n
To download firmware for your device\/architecture go to OpenWrt Firmware download page and try to find your device<\/a>.<\/p>\n OpenWrt is open to adding new devices. Check how to add new device page<\/a> for details. If you want to go that route, maybe check if your device is already supported by going to \"Table of Hardware\" support page<\/a>. This is also available as an archive to download and grep locally.<\/p>\n OpenWrt also has a package ecosystem<\/a>. So, you can package your own application for the OS. In fact, the UI (Web based) called Luci is a package itself that you can install once you have the OS up and running. The packages are divided into many categories<\/a> and creating a new package means you should choose one of those categories and likely sub-categories.<\/p>\n You can install packages using the This is new! Starting OpenWrt version 23.05 you have native Rust package support<\/a>. This can make life easier if you want to create a simple Rust package for OpenWrt.<\/p>\n For me, my application was far more complex than what the OpenWrt Rust support toolchain can handle right now because we bundle some web artifacts etc. So, in my case it was easier to find the architecture and compile my binary for that using Nix<\/a>.<\/p>\n You can find a few things by running these commands for your router -<\/p>\n Shows you system information in brief. For example,<\/p>\n This will show you architecture in detail. For example,<\/p>\n The important part is that you can also get the Model name (Cortex-A9) which maybe needed to choose the right architecture.<\/p>\n This will tell you which base library your system is using. For example, the following uses I should begin by saying that in this exercise, you need a lot of GNU Make knowledge. The hell of Make will be enough for you to say no to creating OpenWrt package. However, let's look at a few things I learned during this \"simple\" exercise.<\/p>\n If you know the architectures you want to support and can publish the package yourself, you can avoid the entire drama and just host things yourself. Honestly, it was far easier to do that especially if you have a complex build process. Which brings the next point.<\/p>\n Quick before the next point, the You can try and follow their tutorial for packaging on their Wiki<\/a>.<\/p>\n If you want to package it using their Make stuff, you will end up having more architectural support but it is a nightmare and not even like the Halloween kind where you get the candy.<\/p>\n No really, look at this makefile -<\/p>\n This reminds me of the CMake hell of NCBI C++ Toolkit<\/a>. You can see there is a configuration file to configure CMake first.<\/p>\n"},{"title":"(In)secure C++ Training with Patricia Aas","published":"2023-11-23T00:00:00+00:00","updated":"2023-11-23T00:00:00+00:00","author":{"name":"\n \n Unknown\n \n "},"link":{"@attributes":{"rel":"alternate","type":"text\/html","href":"https:\/\/amanjeev.com\/blog\/insecure-cpp-training-with-patricia\/"}},"id":"https:\/\/amanjeev.com\/blog\/insecure-cpp-training-with-patricia\/","content":" A few weeks ago I had the privilege of attending the security training (using C++) by Patricia Aas<\/a>. This was also the only training she ever did in the North American timezone and that was such a fortunate thing for me. This was such a fun experience and I want to give you a bit of detail on what you can expect from this training.<\/p>\n This is an intense course, but it is also a lot of fun. As a trainer myself, I am just in sheer awe of Patricia. This was 4 (four) days of 8 (eight) hours each day. You do get an hour of break in the middle but I can tell you this is still a lot of work for the trainer. Apart from that, there is a healthy variety of theory (including history) with practical exercises.<\/p>\n I have always wanted to get hands-on security courses from the vantage of reverse-engineering, fuzzing, shellcode, and learn about the tooling around it. All of that was covered.<\/p>\n I give extra mention for slides because Patricia\u2019s slide-deck is so beautiful. You can get some idea of what to expect by visiting her website<\/a>.<\/p>\n There are a plenty of exercises and hands-on work. You even get to do your own fuzzing, you learn about In my group, there were seasoned security and reverse-engineering folks. There were also total beginners like me. Seldom is a course where people from both ends of the spectrum of knowledge can get so much out of. I can assure you that no matter where you are, this course will be fun and educational for you.<\/p>\n"},{"title":"Publications","published":"2023-09-13T00:00:00+00:00","updated":"2023-09-13T00:00:00+00:00","author":{"name":"\n \n Unknown\n \n "},"link":{"@attributes":{"rel":"alternate","type":"text\/html","href":"https:\/\/amanjeev.com\/publications\/"}},"id":"https:\/\/amanjeev.com\/publications\/","content":" These are some of my writings published elsewhere. They are posted here in reverse-chronological order.<\/p>\n This blog post is about failures that ate two days of my time with STM32L433RC board with Rust. I gave up many times and still not entirely back from the land of given ups<\/em>.<\/p>\n The story starts when I got this beautiful board<\/a> to try out some Rust. I am still learning embedded systems so even though I know some Rust, I struggle with the hardware part. Datasheets for the hardware I use are really cool to read but they are hard for me to translate to Rust many times.<\/p>\n Before we go further -<\/p>\n This is a classic! That is, when I am excited about tinkering with hardware and no clue where to begin. There are a ton of frameworks! Friends' and experts' suggestion point to the latest Rust frameworks and libraries and sometimes it gets daunting. I was pointed to Embassy<\/a>. The cool part about this framework is that it is ground up support for Rust's Anyway, Embassy docs explain about what is I made this another classic mistake. I went down rabbit holes and lost track of how many projects<\/em> I had created.<\/p>\n Yes, I am told the best of the best also first head to the example directory to see how things are. The only downside is that as a beginner, I do not have any prior knowledge to build upon. Most embedded programmers can look at a new framework but they have a reference from prior experience with other frameworks etc. I did not even remember to look at examples in at first.<\/p>\n Anyway, Embassy has some nice example programs for my board here<\/a>.<\/p>\n I have no idea what I want to with the hardware but I like blinking lights. That's where I start and perhaps most others too. I am told that blinking lights are the Anyway, I have now started to see that some of these boards have some sensors on them. For example, I see that there is a temperature sensor on this board I am working with.<\/p>\n Ok, I may have used the incorrect word here but by algorithms I mean correct steps to do a certain task. For example, my task of reading the temperature sensor value continuously and print on the console. Some of the examples of the things I had no clue about are -<\/p>\n This is called Flashing<\/em>. The amazing thing with Rust embedded work is that you do not have to worry too much about it because Here the This is trickier because for STM32 boards at least you need a special file called Architectures and devices<\/h3>\n
Packages<\/h3>\n
opkg<\/code> installation tool from the commandline. You will need to SSH into the router\/device after installing the OS.<\/p>\nRust and OpenWrt<\/h2>\n
uname -a<\/code><\/h3>\nroot@OpenWrt:~# uname -a\n<\/span>Linux OpenWrt 5.14.171 # 21:05:12 2023 armv7l GNU\/Linux\n<\/span><\/code><\/pre>\nlscpu<\/code><\/h3>\nroot@OpenWrt:~# lscpu\n<\/span>Architecture: armv7l\n<\/span> Byte Order: Little Endian\n<\/span>CPU(s): 2\n<\/span> On-line CPU(s) list: 0,1\n<\/span>Vendor ID: ARM\n<\/span> Model name: Cortex-A9\n<\/span> Model: 1\n<\/span> Thread(s) per core: 1\n<\/span> Core(s) per socket: 2\n<\/span> Socket(s): 1\n<\/span><\/code><\/pre>\nldd --version<\/code><\/h3>\nmusl<\/code>,<\/p>\nroot@OpenWrt:~# ldd --version\n<\/span>musl libc (armhf)\n<\/span>Version 1.2.3\n<\/span>Dynamic Program Loader\n<\/span>Usage: ldd [options] [--] pathname\n<\/span><\/code><\/pre>\nCreate a package for OpenWrt<\/h2>\n
Easy way out is to build binary yourself<\/h3>\n
.ipk<\/code> file is just a tar.gz<\/code>. So, you can unpack some existing package and see what kind of files are inside. It kinda feels like debian based structure but I could be wrong.<\/p>\nThe packaging process is a nightmare<\/h3>\n
include $(<\/span>TOPDIR<\/span>)<\/span>\/rules.mk\n<\/span> \n<\/span>PKG_NAME<\/span>:=<\/span>bridge\n<\/span>PKG_VERSION<\/span>:=<\/span>1.0.6\n<\/span>PKG_RELEASE<\/span>:=<\/span>1\n<\/span> \n<\/span>PKG_BUILD_DIR<\/span>:=<\/span>$(<\/span>BUILD_DIR<\/span>)<\/span>\/bridge-utils-<\/span>$(<\/span>PKG_VERSION<\/span>)\n<\/span>PKG_SOURCE<\/span>:=<\/span>bridge-utils-<\/span>$(<\/span>PKG_VERSION<\/span>)<\/span>.tar.gz\n<\/span>PKG_SOURCE_URL<\/span>:=<\/span>@SF\/bridge\n<\/span>PKG_HASH<\/span>:=<\/span>9b7dc52656f5cbec846a7ba3299f73bd\n<\/span> \n<\/span>include $(<\/span>INCLUDE_DIR<\/span>)<\/span>\/package.mk\n<\/span> \n<\/span>define<\/span> Package\/bridge\n<\/span> SECTION:=base\n<\/span> CATEGORY:=Network\n<\/span> TITLE:=Ethernet bridging configuration utility\n<\/span> #DESCRIPTION:=This variable is obsolete. use the Package\/name\/description define instead!\n<\/span> URL:=http:\/\/bridge.sourceforge.net\/\n<\/span>endef\n<\/span> \n<\/span>define<\/span> Package\/bridge\/description\n<\/span> Ethernet bridging configuration utility\n<\/span> Manage ethernet bridging; a way to connect networks together to\n<\/span> form a larger network.\n<\/span>endef\n<\/span> \n<\/span>define<\/span> Build\/Configure\n<\/span> $(call Build\/Configure\/Default,--with-linux-headers=$(LINUX_DIR))\n<\/span>endef\n<\/span> \n<\/span>define<\/span> Package\/bridge\/install\n<\/span> $(INSTALL_DIR) $(1)\/usr\/sbin\n<\/span> $(INSTALL_BIN) $(PKG_BUILD_DIR)\/brctl\/brctl $(1)\/usr\/sbin\/\n<\/span>endef\n<\/span> \n<\/span>$(<\/span>eval <\/span>$(<\/span>call <\/span>BuildPackage<\/span>,bridge<\/span>))\n<\/span><\/code><\/pre>\nBasic structure<\/h2>\n
Highlights (for me)<\/h2>\n
Material<\/h3>\n
Slides<\/h3>\n
Exercises<\/h3>\n
heartbless<\/del> heartbleed as an exercises! I am going to setup my own fuzzing lab at home.<\/p>\nIs it for you?<\/h2>\n
Articles<\/h2>\n
\n
bindgen<\/code> project update<\/a> - March 06, 2023<\/li>\nResearch papers<\/h2>\n
\n
![\"STM32L433RC](\"https:\/\/amanjeev.com\/blog\/stm32-embassy-rust-love\/.\/STM32L433RC.jpeg\")
<\/p>\n\n
List of my failure modes<\/h1>\n
Not knowing where to begin with Rust embedded<\/h2>\n
async\/await<\/code> in embedded world. This async\/await<\/code> style of programming allows for better resource allocation when there are IO blocking and wait times.<\/p>\nasync\/await<\/code><\/a> here.<\/p>\nDropping the framework midway and jumping to another<\/h2>\n
Not looking at the examples in the framework<\/h2>\n
Not knowing what to do with the board<\/h2>\n
println!(\"Hello, world!\")<\/code> of the embedded world. So, I did that.<\/p>\nUnable to figure out the \"algorithms\"<\/h2>\n
How does \"pushing\" a program I am writing on my PC, to the board work?<\/h3>\n
cargo<\/code> takes care of most of it. Often you just need a file .cargo\/config.toml<\/code> in your project root<\/a> with some content like this -<\/p>\n[target.'<\/span>cfg(all(target_arch = "arm", target_os = "none"))<\/span>']\n<\/span># replace the chip below with your chip \n<\/span># as listed in `probe-run --list-chips`\n<\/span>runner <\/span>= "<\/span>probe-run --chip STM32L433RCTxP<\/span>"\n<\/span>\n<\/span>[build]\n<\/span>target <\/span>= "<\/span>thumbv7em-none-eabi<\/span>"\n<\/span>\n<\/span>[env]\n<\/span>DEFMT_LOG <\/span>= "<\/span>trace<\/span>"\n<\/span><\/code><\/pre>\ntarget<\/code> is the architecture. Using rustup<\/code> works like rustup target add thumbv7em-none-eabi<\/code> to add this target on your PC.<\/p>\nHow to make sure we tell Rust the right environment?<\/h3>\n
memory.x<\/code> and you may have to do some magic<\/a> to put it in the right place during the build phase of your project. I failed at this miserably but datasheet of your board can tell you the values you need to specify.<\/p>\nMEMORY\n<\/span>{\n<\/span> \/* NOTE 1 K = 1 KiBi = 1024 bytes *\/\n<\/span> \/* These values correspond to the STM32L433 *\/\n<\/span> FLASH : ORIGIN = 0x08000000, LENGTH = 256K\n<\/span> RAM : ORIGIN = 0x20000000, LENGTH = 64K\n<\/span>}\n<\/span><\/code><\/pre>\n