Background on Clock Glitching

Digital hardware devices almost always expect some form of reliable clock. We can manipulate the clock being presented to the device to cause unintended behaviour. We'll be concentrating on microcontrollers here, however other digital devices (e.g. hardware encryption accelerators) can also have faults injected using this technique.

Consider a microcontroller first. The following figure is an excerpt the Atmel AVR ATMega328P datasheet:

Rather than loading each instruction from FLASH and performing the entire execution, the system has a pipeline to speed up the execution process. This means that an instruction is being decoded while the next one is being retrieved, as the following diagram shows:

But if we modify the clock, we could have a situation where the system doesn't have enough time to actually perform an instruction. Consider the following, where Execute #1 is effectively skipped. Before the system has time to actually execute it another clock edge comes, causing the microcontroller to start execution of the next instruction:

This causes the microcontroller to skip an instruction. Such attacks can be immensely powerful in practice. Consider for example the following code from `linux-util-2.24`:

/*
 *   auth.c -- PAM authorization code, common between chsh and chfn
 *   (c) 2012 by Cody Maloney <cmaloney@theoreticalchaos.com>
 *
 *   this program is free software.  you can redistribute it and
 *   modify it under the terms of the gnu general public license.
 *   there is no warranty.
 *
 */

#include "auth.h"
#include "pamfail.h"

int auth_pam(const char *service_name, uid_t uid, const char *username)
{
    if (uid != 0) {
        pam_handle_t *pamh = NULL;
        struct pam_conv conv = { misc_conv, NULL };
        int retcode;

        retcode = pam_start(service_name, username, &conv, &pamh);
        if (pam_fail_check(pamh, retcode))
            return FALSE;

        retcode = pam_authenticate(pamh, 0);
        if (pam_fail_check(pamh, retcode))
            return FALSE;

        retcode = pam_acct_mgmt(pamh, 0);
        if (retcode == PAM_NEW_AUTHTOK_REQD)
            retcode =
                pam_chauthtok(pamh, PAM_CHANGE_EXPIRED_AUTHTOK);
        if (pam_fail_check(pamh, retcode))
            return FALSE;

        retcode = pam_setcred(pamh, 0);
        if (pam_fail_check(pamh, retcode))
            return FALSE;

        pam_end(pamh, 0);
        /* no need to establish a session; this isn't a
         * session-oriented activity...  */
    }
    return TRUE;
}

This is the login code for the Linux OS. Note that if we could skip the check of if (uid != 0) and simply branch to the end, we could avoid having to enter a password. This is the power of glitch attacks - not that we are breaking encryption, but simply bypassing the entire authentication module!

Glitch Hardware

The ChipWhisperer Glitch system uses the same synchronous methodology as it's Side Channel Analysis (SCA) capture. A system clock (which can come from either the ChipWhisperer or the Device Under Test (DUT)) is used to generate the glitches. These glitches are then inserted back into the clock, although it's possible to use the glitches alone for other purposes (i.e. for voltage glitching, EM glitching).

The generation of glitches is done with two variable phase shift modules, configured as follows:

The enable line is used to determine when glitches are inserted. Glitches can be inserted continuously (useful for development) or triggered by some event. The following figure shows how the glitch can be muxd to output to the Device Under Test (DUT).

Python GUI Interface

The portion of the GUI of interest to us is primarily located in this section:

If the Partial Reconfiguration system has been disabled (due to missing PR files or files differing from the FPGA bitstream) the two fields marked that say (as % of period) will be disabled. Only the fields labeled (fine adjust) will be available.

Setting up Glitch Example

#Multi-Target Board, AVR Device (ATMega328P)
#PLATFORM = CW301_AVR

#CW-Lite XMEGA Target Device (XMEGA128D4)
PLATFORM = CW303

make

void glitch_infinite(void)
{
    char str[64];
    //Declared volatile to avoid optimizing away loop.
    //This also adds lots of SRAM access
    volatile uint16_t i, j;
    volatile uint32_t cnt;
    while(1){
        cnt = 0;
        for(i=0; i<500; i++){
            for(j=0; j<500; j++){
                cnt++;
            }
        }
        sprintf(str, "%lu %d %d\n", cnt, i, j);
        uart_puts(str);
    }
}

int main(void){

    platform_init();
    init_uart();    
    trigger_setup();

    /* Uncomment this to get a HELLO message for debug */
    putch('h');
    putch('e');
    putch('l');
    putch('l');
    putch('o');
    putch('\n');
    _delay_ms(20);


    while(1){
        glitch_infinite();
    }

    return 1;
}

void glitch_infinite(void)
{
    char str[64];
    //Declared volatile to avoid optimizing away loop.
    //This also adds lots of SRAM access
    volatile uint16_t i, j;
    volatile uint32_t cnt;
    while(1){
        cnt = 0;
        for(i=0; i<500; i++){
            for(j=0; j<500; j++){
                cnt++;
            }
        }
        sprintf(str, "%lu %d %d\n", cnt, i, j);
        uart_puts(str);
    }
}

Manual Glitch Trigger

To begin with, you'll simply use the manual glitch triggering. This works well in the examples where we have a simple loop we are breaking out of. Doing so requires modifying the glitch width and glitch offset experimentally. The exact values will vary for every device and setup.

It is recommended to only use the glitch width (as % of period) option, as the fine adjust is too small of a change for this lower-speed example. Other hardware may need the precision added by the fine adjust however!

The following figure shows several different settings for a 7.37 MHz clock. The width is set to 10%, which for the 136nS clock period of the 7.37 MHz clock means the glitch width is about 13.6 nS. When the offset is negative, the glitch is placed in-front of the clock. The glitch is XORd with the clock, meaning this becomes a small positive-going glitch in-front of the regular clock pulse.

If the offset is positive, the glitch occurs after the rising edge of the clock pulse. Because this glitch pulse is XORd with the clock, it becomes a negative-going glitch inserted in the 'middle' of the regular clock pulse.

With some background, let's now check some glitches. Assuming you've setup the example as before, do the following:

1. Adjust the settings for Glitch Width (as % of period) , Glitch Offset (as % of period), and Repeat based on your target and the following table for different targets:

   Parameter	AVR on Multi-Target (CW301)	CW-Lite XMEGA Board
   Glitch Width (as % of period)	7.5	10
   Glitch Offset (as % of period)	-10	26.6
   Repeat	5	105

2. Ensure Glitch Trigger is Manual
3. Hit the Manual Trigger button
4. See if you end up with either the target resetting (reprints hello\n), or if the loop count becomes wrong. You may need to press the Manual Trigger button several times quickly. The objective is to have an incorrect loop count, meaning you caused a glitch!
5. To force a reset of the target, use the Signature Read option on the programmer.
6. Adjust the glith width & offset as needed.
7. You may also adjust the Repeat option, or cause it to glitch several instructions.

Be aware that you may crash the target! In the previous examples the target could have reset after each glitch. It may simply go into another infinite loop however, or even enter invalid states. Again force a hardware reset of the target in these cases. It may appear like the target was never glitched, whereas in reality it was glitched into some invalid state.

Automatically Resetting Target

If we are going to start with the target at a pre-determined state, we need to reset the target. There are two ways of automatically performing this. The method used here will use the existing programmer interface to reset the device by performing that "read signature" operation we have already been using. The other method is to toggle a GPIO pin, which is more generic for future use.

To setup the automatic reset, perform the following:

1. Switch to the General Settings tab, and select the appropriate "Auxiliary Module":

   1. For ChipWhisperer-Lite (CW1173/CW1180), select "Reset AVR/XMEGA via CW-Lite"
   2. For ChipWhisperer-Capture Rev 2, select "Reset AVR via ISP-MKII"

   

2. Switch to the Aux Settings tab. Depending on your module you will see different settings here, for example the ChipWhisperer-Lite lets you select between AVR and XMEGA targets. The defaults should be ok:

   

3. Press the "Test Reset" button. This should reset the AVR target. Confirm this by monitoring the terminal emulator window, and check the startup message (of "hello") is printed again.

We can now confirm the reset works with the "Capture 1" button. This requires us to disable the normal routing of the output data to a file for analysis, as we want to just dump data to the terminal emulator. To do this:

1. Switch to the Target Settings tab.

2. Remove all of the Load Key Command, Go Command, and Output Format options:

   

3. Press the "Capture 1" button a few times, which should confirm on each "capture" the target device is resetting.

4. Finally, we will switch the glitch target to give us a more realistic target to glitch. To do this open the file chipwhisperer\hardware\victims\firmware\glitch-simple\glitchsimple.c and modify the call in main(), such that we now call the glitch1() function. This means the following:

   while(1){
       glitch_infinite();
   }

   can be changed to:

   while(1){
       glitch1();
   }

   After which recompile (with make), and reprogram the target device. Note the new function being glitched looks like this:

   void glitch1(void)
   {
       led_ok(1);
       led_error(0);
   
       //Some fake variable
       volatile uint8_t a = 0;
   
       putch('A');
   
       //External trigger logic
       trigger_high();
       trigger_low();
   
       //Should be an infinite loop
       while(a != 2){
       ;
       }    
   
       led_error(1);
       led_error(1);
       led_error(1);
       led_error(1);
       led_error(1);
       led_error(1);
       led_error(1);
       led_error(1);
       led_error(1);
   
       uart_puts("1234");
   
       led_error(1);
       led_error(1);
       led_error(1);
       led_error(1);
       led_error(1);
       led_error(1);
       led_error(1);
       led_error(1);
   
       //Several loops in order to try and prevent restarting
       while(1){
       ;
       }
       while(1){
       ;
       }
       while(1){
       ;
       }
       while(1){
       ;
       }
       while(1){
       ;
       }    
   }

5. When you perform a Capture 1, the terminal should print hello\nA, based on the above source code. Note the objective will be to glitch past the infinite loop, such that 1234 is printed. If using the XMEGA target board this will also turn on the RED led.

   hint

   If the startup message isn't visible, it may be related to issues with the Capture software not being fast enough after reset to display the serial port contents on the terminal emulator. This happens often on the virtual machine environment, as can be seen in the demo video. You can ignore this error for now.

Automatically Triggering Glitch

The manual trigger used previously is suitable when the embedded system is waiting for further input. For example if the embedded system is waiting for a password, you could insert glitches without requiring accurate timing. We'll explore the use of the capture trigger for glitching here, which also improves the repeatability of your glitch attempts.

To use this system, you must first understand the routing of the trigger to the glitch module. The following figure shows the trigger routing, which is more basic than the power capture trigger:

Note in particular that if using an external IO pin, you only have a rising edge trigger. The example glitch program includes a line which is set 'High' at critical moments, allowing you to experiment with this basic IO trigger.

Based on the source code loaded, we currently have a trigger to time the glitch. This is very useful during the characterization phase, where we wish to determine what sort of glitch affects this specific hardware. Once we know that, we can move onto glitching a more "realistic" routine.

Before doing that, we will actually enable the power analysis capture. To do this:

1. Switch to the Scope Settings tab.
2. Switch the ADC Clock Source as being CLKGEN x4.
3. Press Reset ADC DCM, confirm the frequency is 29.5 MHz as expected.
4. Switch the Trigger Setup --> Mode to be Rising Edge
5. Switch the Trigger Setup --> Total Samples to be 1000
6. Switch the Gain Setting --> Setting to be 40. You might need to adjust this for different hardware.

7. Press Capture 1, confirm some waveform is displayed. For example with the XMEGA Target on the ChipWhisperer-Lite, the waveform looks like this:

   

8. If this does't work: check the trigger in use is the Target IO4 pin.

Finally, we can enable the trigger of the glitch to occur based on this external trigger pin. This can be accomplished by:

1. Switch the Glitch Trigger mode to Ext Trigger:Single-Shot:

   

2. Performing a Capture 1, you'll notice that the waveform is now perturbed. This is due to the clock glitches causing odd power consumption behavior:

   

3. Play around a bit with the glitch width, offset, and repeat. You should see different effects in the power consumption traces.

Using the Glitch Explorer

Now that we can automatically perform the glitching, we can use the glitch explorer to automatically vary glitch parameters while recording what the target device is doing. Before continuing with the tutorial, we'll go through an overview of the the glitch explorer.

param_value_0 = starting_value_0
param_value_1 = starting_value_1

while capture_in_progress:
    while param_value_1 < param_value_1_max:

      while param_value_0 < param_value_0_max:
          param_value_0 += param_value_0_incr
          run_glitch_here()

      param_value_0 = param_value_0_min        
      param_value_1 += param_value_1_incr

    param_value_1 = param_value_1_min

Glitching a Password Check

This assumes you now have a set of parameters which caused a reliable glitch. We'll now glitch past a password check, initially using our trigger as a crutch. The function of interest compares a received password to some known password. The glitch3() function looks as follows:

void glitch3(void)
{
    char inp[16];
    char c = 'A';
    unsigned char cnt = 0;
    uart_puts("Password:");

    while((c != '\n') & (cnt < 16)){
        c = getch();
        inp[cnt] = c;
        cnt++;
    }

    char passwd[] = "touch";
    char passok = 1;

    trigger_high();
    trigger_low();

    //Simple test - doesn't check for too-long password!
    for(cnt = 0; cnt < 5; cnt++){
        if (inp[cnt] != passwd[cnt]){
            passok = 0;
        }
    }

    if (!passok){
        uart_puts("Denied\n");
    } else {
        uart_puts("Welcome\n");
    }
}

The following assumes you have already completed the previous steps:

1. Close the glitch explorer.
2. Modify the file glitchexample.c to call glitch3() instead of glitch1(), which is to say simply change the main function called from main() to glitch3().
3. Run make in the folder chipwhisperer\hardware\victims\firmware\glitch-simple.
4. Program the target device with your .hex file.
5. On the Target Settings tab, clear the Output Format field. That is remove the $GLITCH$ text, as we are no longer using the glitch explorer. If you don't do this, you will not see any output of the device on the terminal emulator.
6. Open the terminal emulator, and connect to it again (if you closed it).

7. Reset the device, it should prompt you for a password. The correct password is touch, try both correct and incorrect passwords. The program as designed loops after a password try to prompt you again. You should see both correct and incorrect responses:

   

8. On the Scope Settings tab, adjust the Timeout(s) to a larger value such as 20. We need a longer timeout to work with the serial terminal.

9. Let's try a glitch insertion! Perform the following:

   1. Press the Capture 1 button. This will reset the target and arm the glitch.
   2. Before the timeout, enter a wrong password such as test in the terminal and hit enter.
   3. See if you can get the wrong password accepted. If not, let's use the Glitch Explorer to automate the parameter adjustments.

10. Switching to the Auxiliary Settings tab, adjust the delay on the reset such that you have a 150 mS delay. This will mean once the device resets there is a delay while it prints the startup message.

    

11. Switch to the Target Settings tab:

    1. In the Go Command field, put the bad password such as test\n.
    2. In the Output Format field, put $GLITCH$ to route the output to the glitch explorer.

12. Open the Glitch Explorer, and press Capture 1. You should see the Denied message come across.

13. In the Glitch Explorer, adjust the following settings:

    1. Set Tuning Parameters to 1

    2. Set Parameter 0 options to:

       Option	Value
       Name	Trigger Offset
       Parameter Path	['Glitch Module', 'Ext Trigger Offset']
       Data Format	Int
       Range	0 : 200
       Value	0
       Step	1
       Repeat	1

14. Set the number of traces on the General Settings tab to 200.
15. On the main GUI, in the Scope Settings tab, ensure that you have the number of repeats on the Glitch Module set to 1. We will start with a single clock cycle glitched.

16. Press Capture Multi. Monitor the glitch outputs, you may see some errors or a successful glitch. Note that sometimes the errors are useful - here is an example where the glitched code actually dumped the password:

    

    More likely you might see a "Welcome" message indicating the password check was glitched:

    

17. If the previous step isn't successful, increase the "repeat" count on the Glitch Module section of the Scope Settings tab, and try again. In this example I actually needed a repeat count of "3" to get the successful "Welcome" message printed above.

    You can also increase the repeat count in the glitch explorer, which simply tries the same settings multiple times. You will likely find that the successful glitch does not have 100% success rate, so using a repeat count of 2 or 3 is helpful to increase your chances of success.

Glitching Onward

This basic tutorial has introduced you to glitch attacks. They are a powerful tool for bypassing authentication in embedded hardware devices. There are many ways to expand your knowledge with additional practice, such as:

• Use manual glitches to try simply glitching past the prompt in glitch3().
• Download some example source code (bootloaders, login prompts, etc) and port them to the AVR. See how you can glitch past security checks.
• Use one of the IO triggers discussed in Tutorial_A1_Synchronization_to_Communication_Lines.