Polynomial multiplication using Karatsuba method
Algorithmic complexity is not a good indicator of real-world performance
When you have to choose between an \$\mathcal{O}(N^2)\$ or \$\mathcal{O}(N^{1.58})\$ algorithm, you would think that the latter is faster, however that is only true for sufficiently large values of \$N\$. In practice, unless you have more than a thousand digits to multiply, the simple \$\mathcal{O}(N^2)\$ algorithm is faster.
Don't make the inputs of equal length
If you want to multiply a polynomial of degree 100 with a polynomial of degree 1, then your program will expand the latter polynomial to degree 100, and then do the multiplication. But most of the work is now wasted on multiplying things by 0. Try to make your algorithm work for vectors of different lengths.
Avoid creating unnecessary intermediate results
If the goal is purely to get the XOR of the coefficients of the product, then you don't actually need to store the product before calculating the final result of the XORs. Instead, with a trivial algorithm, you can just simply do:
int result{};
for (auto i: a)
    for (auto j: b)
         result ^= i * j;

This avoids creating a temporary vector, which requires heap memory allocation, and avoids an additional pass over the temporary result to get the final answer. Again, this doesn't reduce algorithmic complexity, but it does reduce how many cycles you have to spend for each iteration of the \$\mathcal{O}(N^2)\$ algorithm even further.
Use a hybrid approach
In your implementation of Karatsuba's algorithm, you have this line:
if (deg == 1) return {a[0] * b[0]};

Knowing that for smaller vectors, a naive algorithm is actually faster, you can replace this line with:
if (deg &lt; CUTOFF)
    return naive_product(a, b);

Where you set the constant CUTOFF to some value that you have to determine experimentally. This approach is similar to those taken by state-of-the-art sorting algorithms, which typically also use a divide-and-conquer approach and when the problem gets small enough, they will use insertion sort.
Pass vectors by const reference
Most of your functions like prod(), sum(), and so on, take parameters by value. This is very inefficient, since it means a copy of the  vectors used as input arguments will be made. Pass them by const reference instead, it's as simple as:
vector&lt;int&gt; sum(const vector&lt;int&gt; &amp;a, const vector&lt;int&gt; &amp;b) {
    ...
}