This is a pretty cool task where we need to break the secret sharing system to get the flag. We are given the source code and the server address. Let’s look inside the source.

We are looking for the flag and see that it is used only once in the code and it’s printed out in `main`

function on certain conditions. Let’s consider these conditions.

First of all, the flag is printed, when `real_coords`

variable, which is our input, equals to some `REAL_COORDS`

, which we don’t know. (See the green arrow and third bubble.) So first let’s note that we have to find `REAL_COORDS`

value.

But, before this check we have to pass three more `if`

constructions. First condition (bubble 1) is that value `secret_coords`

returned from function `run_combiner()`

is not coords (the call to `is_coords(secret_coords)`

must return `false`

). We will look at `run_combiner()`

later to see what we can do about it.

Second condition once again checks if `secret_coords`

returned from another call to `run_combiner()`

is coords (this time `is_coords(secret_coords)`

must return `true`

).

And the third condition, is the `secret_coords`

value equals to `FAKE_COORDS`

.

Note also, that function `run_combiner()`

requires value `shares`

that is returned from `create_shares(REAL_COORDS)`

call in the start of `main`

.

All right, now that we’ve considered conditions to get the flag, let’s think about how we can fulfill them. We need to find out what `create_shares()`

and `run_combiner()`

functions do. Code for `create_shares()`

is fairly simple:

It gets two random numbers `r1, r2`

and calculates three values using these numbers and secret passed to the function. Remember, that this function is called only once with value `REAL_COORDS`

. Let’s rewrite the calculation in a fancy mathematical notation to get the better view:

And values `s1`

, `s2`

and `s3`

are returned from the function as the array. `main()`

function later prints out `s1`

for us as our share, but values `s2`

and `s3`

are kept secret. To make things clear I point out that now we know `s1`

, but values `r1`

, `r2`

, `secret`

, `s2`

and `s3`

are unknown.

Okay, now let’s look at the `run_combiner()`

It just asks us to input our share and then calls to `reveal_secret()`

. `reveal_secret()`

performs some calculation with passed shares and returns the calculates `secret`

value. Let’s write that calculation down, I will rename `secret`

to `reveal`

here, you will see why.

Now, let’s say we input the share (`s1`

) we actually got from server, and values `s2`

and `s3`

are the same as were calculated in `create_shares()`

’cause we can’t control them. In this case the equation may be presented as follows

Gather similar values together

Open parentheses

Now terms r1 and r2 may be removed because

And we are left with

**Note: instead of writing negative powers I will just use fractions. That will make more compact and readable formulas, but I do not mean the actual division, remember that we cannot divide in modular arithmetic.**

In conclusion, if we input the valid share, function `run_combiner()`

will return the actual secret value, which is `REAL_COORDS`

. And after first call to `run_combiner()`

function `main()`

will print that value out. That’s great, because we want to know `REAL_COORDS`

value to pass one of the checks. Unfortunately, if we enter the valid share, function `is_coords()`

will return `true`

and we will fail the first check.

## Passing check 1

So we have to modify our share value before entering it. How exactly we will modify it? Well, when we enter it first time, we need it to be some value so that passing it with other shares to `run_combiner()`

will eventually return us the value with which we could calculate the secret. Why is that? Just because we will need `REAL_COORDS`

value and the only time we can get some information from server is after we enter our share the first time. When we enter our share the second time we need `run_combiner()`

to return `FAKE_COORDS`

and after that we will have to input `REAL_COORDS`

.

Let’s see now what value we want `run_combiner()`

to return for us so we can calculate `REAL_COORDS`

from it. Consider how our share is calculated:

To get the secret from it we would want to know value

so that we could do the following

and get the value of `secret`

, which is `REAL_COORDS`

. All right, now let’s think how ca we modify our share so that `run_combier()`

will return

Let’s look at how shares are combined

Note that, if instead of power 3 we had power 2, we would receive what we want.

So what we want, is to create `fakeShare1`

value such that

To do that, we can just raise our real share `s1`

to some power `x`

such that

And that yields us the equation

If you wounder why we changed the modulus, that’s because when we have modulo `n`

calculations with powers, powers are considered modulo `Phi(n)`

. Remember RSA scheme:

And that works because

Fortunately for us, we have `p`

that is a prime number, and Euler’s function for prime `p`

is just `p — 1`

. That’s why we do calculations modulo `p — 1`

.

Okay, now with value `x`

we can modify our share to make it `fakeShare1`

And when we are asked to enter our share the first time, we will put that value. `run_combiner()`

will perform some calculations and return us

`is_coords()`

will return `false`

for this value and we will pass first check.

## Passing check 2 and check 3

Cool, now we can calculate the secret value. But we also have to enter our share the second time. This time we need to modify this value so that `run_combiner()`

returns `FAKE_COORDS`

. This will get us through checks 2 and 3 ( `is_coords()`

will return `true`

and `secret_coords`

will be equal to `FAKE_COORDS`

).

Let’s consider `reveal`

calculation once again

What should we do to make `reveal = FAKE_COORDS`

?

One step at a time. First of all, let’s add `FAKE_COORDS`

to the equation (call it `fake`

). We will multiply our original share with `fake`

to make

We can remove terms `r1`

and `r2`

Second step would be to remove `secret`

term. For that, we need to have `secret`

to the power of 2, not 3. For that, we need to find the value `y`

such that

And this yields us the equation

Now we can multiply our share with `secret`

to the power of `y`

and get

And now we are left with

So let’s instead of multiplying our share with `fake`

in the first place we multiply it with `fake`

to the power of multiple inverse of `3`

modulo `p — 1`

, i.e.

Let’s call this power `z`

.

Finally, we can write the equation for `fakeShare2`

Putting it into `reveal`

calculation gives us the following

And that’s what we want.

## Getting it all together

Now that we are done with the math, we can write the auxiliary script to solve the challenge. We could fully automate it, but there is no need. So, what our script will do:

- Receive our original share, given by the server (we input that)
- Calculate and print
`fakeShare1`

(we take that share and give it to server as first input) - Take reveal value given by the server
- Calculate and print secret (this we will use in the end when server asks for real coordinates)
- Calculate and print
`fakeShare2`

(this we will give to server when it asks for second input).

And here is the script itself

And the solution process is presented on the screenshot below.