Since @Mouin has described the steps for you and you are using HAL already, here is how to execute those steps, so the way to configure it by using STM32CubeMX software provided by ST Microelectronics. (Note: Browsing that link is recommended as there are many-many examples for the STM32 family, STM32CubeF3 package for example.)

So in brief download it, create a new project for an STM32F3 Discovery board.

1. On the Pinout tab, the MCU will be shown with all its pins. Just click on a pin and select a functionality you want. In your case GPIO_EXTI2 on PA2 pin:

   

2. Now switch to do Configuration tab, and in the last column called System, click on the GPIO button. Available options can be seen on the image below:

   

3. Next step is to enable the corresponding interrupt. To do so close the Pin Configuration window and from the System column, click on the NVIC button. If you remember, the EXTI2 has been chosen on PA2 so tick the Enable checkbox for EXTI line2. You can set the priorities here as well.

   

Everything is ready, click on the Generate source code based on user settigns button → . Following source files will be genereted:

GPIO configuration in gpio.c:

  GPIO_InitTypeDef GPIO_InitStruct;

  /* GPIO Ports Clock Enable */
  __GPIOA_CLK_ENABLE();

  GPIO_InitStruct.Speed = GPIO_SPEED_LOW;

  /*Configure GPIO pin : PA2 */
  GPIO_InitStruct.Pin = GPIO_PIN_2;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI2_TSC_IRQn, 0, 0); // <--- This and
  HAL_NVIC_EnableIRQ(EXTI2_TSC_IRQn); // <--- this are what were missing for you.

Interrupt service rutine in the stm32f3xx_it.c:

/**
* @brief This function handles EXTI line2 and Touch Sense controller.
*/
void EXTI2_TSC_IRQHandler(void)
{
  /* USER CODE BEGIN EXTI2_TSC_IRQn 0 */

  /* USER CODE END EXTI2_TSC_IRQn 0 */
  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_2);
  /* USER CODE BEGIN EXTI2_TSC_IRQn 1 */

  /* USER CODE END EXTI2_TSC_IRQn 1 */
}

This is what will be called when an interrupt is triggered, it will call an IRQ handler for the GPIO2 and if everything is fine, the following callback will be called. You have to write your handler code here.

/**
* @brief Interrupt callback for GPIOs
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    if ( GPIO_Pin == GPIO_PIN_2)
    {
        // Write your code here
    }
}

You have to add the previous part manually (the callback), it has a weak declaration only but won't be generated. You can place it in the stm32f3xx_it.c .

If you want to learn more about the MCU, open up the reference manual and read the GPIO and NVIC section to know how it is done on register level.

There are several things you need to do to make GPIO interrupt happen. The peripherals of interest include:

1. GPIOx - Obviously
2. EXTI - Handles GPIO interrupts, sets edges, masks pins ("Set rising edge interrupt to EXTI5" - note we set the pin number, but not the port here)
3. SYSCFG - Assigns GPIO port to pin interrupt (make EXTI5 a GPIOA5 interrupt and not GPIOB5 interrupt)
4. NVIC - Enable interrupts

GPIO and SYSCFG require clock provided to them from RCC, EXTI doesn't have any clock enable bits in RCC as per reference manual, must be always operational then.

So the sequence of actions seems to be roughly the following:

1. Enable GPIO port clock, configure the pin (input, pull-up?)
2. In EXTI, configure edge and pin number (EXTI1 for GPIOx1, EXTI5 for GPIOx5 etc.), unmask the desired pin.
3. Enable SYSCFG clock, assign GPIO port to the desired EXTIx (note this rules out having interrupts on PA5 and PB5 at the same time)
4. Configure EXTI interrupt in NVIC.

The logic of GPIO interrupts looks more or less like this:
When the desired edge happens on a GPIO pin, EXTI gets a signal from pin 5 (EXTI5 from GPIOA5 and not from GPIOB5 as per SYSCFG), and if that signal is unmasked, it is sent further into NVIC, which in turn triggers an interrupt.

Note that some EXTIx can share a single NVIC interrupt, so you will have to check within interrupt handler which EXTIx actually triggered it (in the EXTI registers). In case of your MCU, EXTI0 and EXTI1 share one NVIC interrupt, as do EXTI2 and EXTI3, and there is one NVIC interrupt for EXTI4...EXTI15. It's slightly different for every MCU.

P.S. I chose to give a detailed explanation rather than just write the code, because 1) "please bro write me code" is a meh teaching material and because 2) you probably wanted to see the code to understand how it works, so I skipped an extra step. Most things you need to do here are only 2-5 lines each, so I think you should be able to handle it now.

Click on the pin you want to configure, then select GPIO_EXT# in the dropdown menu, that should enable the EXTI line in the NVIC menu.

On the other Hand, CubeMX isnt perfect and it might not have the interrupt on the pins you want well implemented

If you look into the STM32F103 Reference Manual p. 209, you will see that there is actually a multiplexer that decides if PA0, PB0, ... or PG0 is connected to the EXTI0 signal:

STM32F103 ExtI0 schematic

That means that you cannot connect both PA0 and PB0 to EXTI0. In fact, there are four specific bits in the alternate function input/output register (AFIO) which let you choose which pin is connected to the EXTI0 signal. Here, these bits are located in the control register AFIO_EXTICR1. See the AFIO register map in the same document for further information.

Now I don't know which setup you are using, but as I recall, I had separate functions for different interrupt request routines (for EXTI0, EXTI1 and so on).